@danceroutine/tango-orm 0.1.0

package/dist/connection/adapters/Adapter.d.ts

@@ -0,0 +1,20 @@
+import type { DBClient } from '../clients/DBClient';
+export interface AdapterConfig {
+    url?: string;
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    filename?: string;
+    maxConnections?: number;
+}
+export interface Adapter {
+    name: string;
+    connect(config: AdapterConfig): Promise<DBClient>;
+    features: {
+        transactionalDDL: boolean;
+        concurrentIndex: boolean;
+        validateForeignKeys: boolean;
+    };
+}

package/dist/connection/adapters/AdapterRegistry.d.ts

@@ -0,0 +1,17 @@
+import type { Adapter, AdapterConfig } from './Adapter';
+import type { DBClient } from '../clients/DBClient';
+export declare class AdapterRegistry {
+    static readonly BRAND: "tango.orm.adapter_registry";
+    readonly __tangoBrand: typeof AdapterRegistry.BRAND;
+    private static defaultRegistryInstance;
+    private adapters;
+    static isAdapterRegistry(value: unknown): value is AdapterRegistry;
+    static getDefaultRegistry(): Promise<AdapterRegistry>;
+    register(adapter: Adapter): this;
+    get(name: string): Adapter;
+    has(name: string): boolean;
+}
+export declare function connectDB(config: AdapterConfig & {
+    adapter: string;
+}, registry?: AdapterRegistry): Promise<DBClient>;
+export declare function getDefaultAdapterRegistry(): Promise<AdapterRegistry>;

package/dist/connection/adapters/dialects/PostgresAdapter.d.ts

@@ -0,0 +1,22 @@
+import type { Adapter, AdapterConfig } from '../Adapter';
+import type { DBClient } from '../../clients/DBClient';
+export declare class PostgresAdapter implements Adapter {
+    static readonly BRAND: "tango.orm.postgres_adapter";
+    readonly __tangoBrand: typeof PostgresAdapter.BRAND;
+    readonly name = "postgres";
+    static isPostgresAdapter(value: unknown): value is PostgresAdapter;
+    /**
+     * Declares capabilities of this database adapter.
+     * Used by the migration runner and query compiler to determine which
+     * SQL features can be safely used:
+     * - transactionalDDL: Postgres supports DDL inside transactions (safe rollback of schema changes)
+     * - concurrentIndex: Supports CREATE INDEX CONCURRENTLY (non-blocking index builds)
+     * - validateForeignKeys: Supports deferred FK validation via NOT VALID + VALIDATE CONSTRAINT
+     */
+    readonly features: {
+        transactionalDDL: boolean;
+        concurrentIndex: boolean;
+        validateForeignKeys: boolean;
+    };
+    connect(config: AdapterConfig): Promise<DBClient>;
+}

package/dist/connection/adapters/dialects/SqliteAdapter.d.ts

@@ -0,0 +1,14 @@
+import type { Adapter, AdapterConfig } from '../Adapter';
+import type { DBClient } from '../../clients/DBClient';
+export declare class SqliteAdapter implements Adapter {
+    static readonly BRAND: "tango.orm.sqlite_adapter";
+    readonly __tangoBrand: typeof SqliteAdapter.BRAND;
+    readonly name = "sqlite";
+    readonly features: {
+        transactionalDDL: boolean;
+        concurrentIndex: boolean;
+        validateForeignKeys: boolean;
+    };
+    static isSqliteAdapter(value: unknown): value is SqliteAdapter;
+    connect(config: AdapterConfig): Promise<DBClient>;
+}

package/dist/connection/adapters/dialects/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Domain boundary barrel: centralizes this subdomain's public contract.
+ */
+export { PostgresAdapter } from './PostgresAdapter';
+export { SqliteAdapter } from './SqliteAdapter';

package/dist/connection/adapters/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Domain boundary barrel: exposes namespaced exports for Django-style drill-down
+ * imports and curated flat exports for TS-native ergonomics.
+ */
+export * as dialects from './dialects/index';
+export { AdapterRegistry, connectDB, getDefaultAdapterRegistry } from './AdapterRegistry';
+export type { Adapter, AdapterConfig } from './Adapter';
+export { PostgresAdapter, SqliteAdapter } from './dialects/index';

package/dist/connection/clients/DBClient.d.ts

@@ -0,0 +1,9 @@
+export interface DBClient {
+    query<T = unknown>(sql: string, params?: readonly unknown[]): Promise<{
+        rows: T[];
+    }>;
+    begin(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/connection/clients/DBClient.js

@@ -0,0 +1 @@
+export {};

package/dist/connection/clients/dialects/PostgresClient.d.ts

@@ -0,0 +1,17 @@
+import type pg from 'pg';
+import type { DBClient } from '../DBClient';
+export declare class PostgresClient implements DBClient {
+    private pool;
+    private client;
+    static readonly BRAND: "tango.orm.postgres_client";
+    readonly __tangoBrand: typeof PostgresClient.BRAND;
+    static isPostgresClient(value: unknown): value is PostgresClient;
+    constructor(pool: pg.Pool, client: pg.PoolClient);
+    query<T = unknown>(sql: string, params?: readonly unknown[]): Promise<{
+        rows: T[];
+    }>;
+    begin(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/connection/clients/dialects/PostgresClient.js

@@ -0,0 +1,32 @@
+export class PostgresClient {
+    pool;
+    client;
+    static BRAND = 'tango.orm.postgres_client';
+    __tangoBrand = PostgresClient.BRAND;
+    static isPostgresClient(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            value.__tangoBrand === PostgresClient.BRAND);
+    }
+    constructor(pool, client) {
+        this.pool = pool;
+        this.client = client;
+    }
+    async query(sql, params) {
+        const result = await this.client.query(sql, params);
+        return { rows: result.rows };
+    }
+    async begin() {
+        await this.client.query('BEGIN');
+    }
+    async commit() {
+        await this.client.query('COMMIT');
+    }
+    async rollback() {
+        await this.client.query('ROLLBACK');
+    }
+    async close() {
+        this.client.release();
+        await this.pool.end();
+    }
+}

package/dist/connection/clients/dialects/SqliteClient.d.ts

@@ -0,0 +1,17 @@
+import type Database from 'better-sqlite3';
+import type { DBClient } from '../DBClient';
+export declare class SqliteClient implements DBClient {
+    private db;
+    static readonly BRAND: "tango.orm.sqlite_client";
+    readonly __tangoBrand: typeof SqliteClient.BRAND;
+    private inTransaction;
+    static isSqliteClient(value: unknown): value is SqliteClient;
+    constructor(db: Database.Database);
+    query<T = unknown>(sql: string, params?: readonly unknown[]): Promise<{
+        rows: T[];
+    }>;
+    begin(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/connection/clients/dialects/SqliteClient.js

@@ -0,0 +1,44 @@
+export class SqliteClient {
+    db;
+    static BRAND = 'tango.orm.sqlite_client';
+    __tangoBrand = SqliteClient.BRAND;
+    inTransaction = false;
+    static isSqliteClient(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            value.__tangoBrand === SqliteClient.BRAND);
+    }
+    constructor(db) {
+        this.db = db;
+    }
+    async query(sql, params) {
+        const stmt = this.db.prepare(sql);
+        if (/^\s*(SELECT|PRAGMA)/i.test(sql)) {
+            const rows = params ? stmt.all(...params) : stmt.all();
+            return { rows: rows };
+        }
+        params ? stmt.run(...params) : stmt.run();
+        return { rows: [] };
+    }
+    async begin() {
+        if (!this.inTransaction) {
+            this.db.prepare('BEGIN').run();
+            this.inTransaction = true;
+        }
+    }
+    async commit() {
+        if (this.inTransaction) {
+            this.db.prepare('COMMIT').run();
+            this.inTransaction = false;
+        }
+    }
+    async rollback() {
+        if (this.inTransaction) {
+            this.db.prepare('ROLLBACK').run();
+            this.inTransaction = false;
+        }
+    }
+    async close() {
+        this.db.close();
+    }
+}

package/dist/connection/clients/dialects/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Domain boundary barrel: centralizes this subdomain's public contract.
+ */
+export { PostgresClient } from './PostgresClient';
+export { SqliteClient } from './SqliteClient';

package/dist/connection/clients/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Domain boundary barrel: exposes namespaced exports for Django-style drill-down
+ * imports and curated flat exports for TS-native ergonomics.
+ */
+export * as dialects from './dialects/index';
+export type { DBClient } from './DBClient';
+export { PostgresClient, SqliteClient } from './dialects/index';

package/dist/connection/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Domain boundary barrel: exposes namespaced exports for Django-style drill-down
+ * imports and curated flat exports for TS-native ergonomics.
+ */
+export * as adapters from './adapters/index';
+export * as clients from './clients/index';
+export { AdapterRegistry, connectDB, getDefaultAdapterRegistry } from './adapters/index';
+export type { Adapter, AdapterConfig } from './adapters/index';
+export type { DBClient } from './clients/DBClient';
+export { PostgresAdapter, SqliteAdapter } from './adapters/index';
+export { PostgresClient, SqliteClient } from './clients/index';

package/dist/connection/index.js

@@ -0,0 +1,5 @@
+import { PostgresAdapter, PostgresClient } from "../PostgresAdapter-_X36-mLL.js";
+import { SqliteAdapter, SqliteClient } from "../SqliteAdapter-J03fEjmr.js";
+import { AdapterRegistry, adapters_exports, clients_exports, connectDB, getDefaultAdapterRegistry } from "../connection-DytAsjC9.js";
+
+export { AdapterRegistry, PostgresAdapter, PostgresClient, SqliteAdapter, SqliteClient, adapters_exports as adapters, clients_exports as clients, connectDB, getDefaultAdapterRegistry };

package/dist/connection-DytAsjC9.js

@@ -0,0 +1,102 @@
+import { __export } from "./chunk-DLY2FNSh.js";
+import { PostgresAdapter, PostgresClient } from "./PostgresAdapter-_X36-mLL.js";
+import { SqliteAdapter, SqliteClient } from "./SqliteAdapter-J03fEjmr.js";
+
+//#region src/connection/adapters/dialects/index.ts
+var dialects_exports$1 = {};
+__export(dialects_exports$1, {
+	PostgresAdapter: () => PostgresAdapter,
+	SqliteAdapter: () => SqliteAdapter
+});
+
+//#endregion
+//#region src/connection/adapters/AdapterRegistry.ts
+var AdapterRegistry = class AdapterRegistry {
+	static BRAND = "tango.orm.adapter_registry";
+	__tangoBrand = AdapterRegistry.BRAND;
+	static defaultRegistryInstance;
+	adapters = new Map();
+	static isAdapterRegistry(value) {
+		return typeof value === "object" && value !== null && value.__tangoBrand === AdapterRegistry.BRAND;
+	}
+	static async getDefaultRegistry() {
+		if (AdapterRegistry.defaultRegistryInstance) return AdapterRegistry.defaultRegistryInstance;
+		AdapterRegistry.defaultRegistryInstance = new AdapterRegistry();
+		const { PostgresAdapter: PostgresAdapter$1 } = await import("./PostgresAdapter-DCF8T4vh.js");
+		const { SqliteAdapter: SqliteAdapter$1 } = await import("./SqliteAdapter-CBnxCznk.js");
+		AdapterRegistry.defaultRegistryInstance.register(new PostgresAdapter$1());
+		AdapterRegistry.defaultRegistryInstance.register(new SqliteAdapter$1());
+		return AdapterRegistry.defaultRegistryInstance;
+	}
+	register(adapter) {
+		this.adapters.set(adapter.name, adapter);
+		return this;
+	}
+	get(name) {
+		const adapter = this.adapters.get(name);
+		if (!adapter) {
+			const available = [...this.adapters.keys()].join(", ");
+			throw new Error(`Unknown adapter: ${name}. Available adapters: ${available || "none"}`);
+		}
+		return adapter;
+	}
+	has(name) {
+		return this.adapters.has(name);
+	}
+};
+async function connectDB(config, registry) {
+	const effectiveRegistry = registry ?? await AdapterRegistry.getDefaultRegistry();
+	const adapter = effectiveRegistry.get(config.adapter);
+	return adapter.connect(config);
+}
+async function getDefaultAdapterRegistry() {
+	return AdapterRegistry.getDefaultRegistry();
+}
+
+//#endregion
+//#region src/connection/adapters/index.ts
+var adapters_exports = {};
+__export(adapters_exports, {
+	AdapterRegistry: () => AdapterRegistry,
+	PostgresAdapter: () => PostgresAdapter,
+	SqliteAdapter: () => SqliteAdapter,
+	connectDB: () => connectDB,
+	dialects: () => dialects_exports$1,
+	getDefaultAdapterRegistry: () => getDefaultAdapterRegistry
+});
+
+//#endregion
+//#region src/connection/clients/dialects/index.ts
+var dialects_exports = {};
+__export(dialects_exports, {
+	PostgresClient: () => PostgresClient,
+	SqliteClient: () => SqliteClient
+});
+
+//#endregion
+//#region src/connection/clients/index.ts
+var clients_exports = {};
+__export(clients_exports, {
+	PostgresClient: () => PostgresClient,
+	SqliteClient: () => SqliteClient,
+	dialects: () => dialects_exports
+});
+
+//#endregion
+//#region src/connection/index.ts
+var connection_exports = {};
+__export(connection_exports, {
+	AdapterRegistry: () => AdapterRegistry,
+	PostgresAdapter: () => PostgresAdapter,
+	PostgresClient: () => PostgresClient,
+	SqliteAdapter: () => SqliteAdapter,
+	SqliteClient: () => SqliteClient,
+	adapters: () => adapters_exports,
+	clients: () => clients_exports,
+	connectDB: () => connectDB,
+	getDefaultAdapterRegistry: () => getDefaultAdapterRegistry
+});
+
+//#endregion
+export { AdapterRegistry, adapters_exports, clients_exports, connectDB, connection_exports, getDefaultAdapterRegistry };
+//# sourceMappingURL=connection-DytAsjC9.js.map

package/dist/connection-DytAsjC9.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-DytAsjC9.js","names":["value: unknown","adapter: Adapter","name: string","config: AdapterConfig & { adapter: string }","registry?: AdapterRegistry"],"sources":["../src/connection/adapters/dialects/index.ts","../src/connection/adapters/AdapterRegistry.ts","../src/connection/adapters/index.ts","../src/connection/clients/dialects/index.ts","../src/connection/clients/index.ts","../src/connection/index.ts"],"sourcesContent":["/**\n * Domain boundary barrel: centralizes this subdomain's public contract.\n */\n\nexport { PostgresAdapter } from './PostgresAdapter';\nexport { SqliteAdapter } from './SqliteAdapter';\n","import type { Adapter, AdapterConfig } from './Adapter';\nimport type { DBClient } from '../clients/DBClient';\nexport class AdapterRegistry {\n    static readonly BRAND = 'tango.orm.adapter_registry' as const;\n    readonly __tangoBrand: typeof AdapterRegistry.BRAND = AdapterRegistry.BRAND;\n    private static defaultRegistryInstance: AdapterRegistry | undefined;\n\n    private adapters = new Map<string, Adapter>();\n\n    static isAdapterRegistry(value: unknown): value is AdapterRegistry {\n        return (\n            typeof value === 'object' &&\n            value !== null &&\n            (value as { __tangoBrand?: unknown }).__tangoBrand === AdapterRegistry.BRAND\n        );\n    }\n\n    static async getDefaultRegistry(): Promise<AdapterRegistry> {\n        if (AdapterRegistry.defaultRegistryInstance) {\n            return AdapterRegistry.defaultRegistryInstance;\n        }\n\n        AdapterRegistry.defaultRegistryInstance = new AdapterRegistry();\n\n        const { PostgresAdapter } = await import('./dialects/PostgresAdapter');\n        const { SqliteAdapter } = await import('./dialects/SqliteAdapter');\n\n        AdapterRegistry.defaultRegistryInstance.register(new PostgresAdapter());\n        AdapterRegistry.defaultRegistryInstance.register(new SqliteAdapter());\n\n        return AdapterRegistry.defaultRegistryInstance;\n    }\n\n    register(adapter: Adapter): this {\n        this.adapters.set(adapter.name, adapter);\n        return this;\n    }\n\n    get(name: string): Adapter {\n        const adapter = this.adapters.get(name);\n        if (!adapter) {\n            const available = [...this.adapters.keys()].join(', ');\n            throw new Error(`Unknown adapter: ${name}. Available adapters: ${available || 'none'}`);\n        }\n        return adapter;\n    }\n\n    has(name: string): boolean {\n        return this.adapters.has(name);\n    }\n}\n\nexport async function connectDB(\n    config: AdapterConfig & { adapter: string },\n    registry?: AdapterRegistry\n): Promise<DBClient> {\n    const effectiveRegistry = registry ?? (await AdapterRegistry.getDefaultRegistry());\n    const adapter = effectiveRegistry.get(config.adapter);\n    return adapter.connect(config);\n}\n\nexport async function getDefaultAdapterRegistry(): Promise<AdapterRegistry> {\n    return AdapterRegistry.getDefaultRegistry();\n}\n","/**\n * Domain boundary barrel: exposes namespaced exports for Django-style drill-down\n * imports and curated flat exports for TS-native ergonomics.\n */\n\nexport * as dialects from './dialects/index';\n\nexport { AdapterRegistry, connectDB, getDefaultAdapterRegistry } from './AdapterRegistry';\nexport type { Adapter, AdapterConfig } from './Adapter';\nexport { PostgresAdapter, SqliteAdapter } from './dialects/index';\n","/**\n * Domain boundary barrel: centralizes this subdomain's public contract.\n */\n\nexport { PostgresClient } from './PostgresClient';\nexport { SqliteClient } from './SqliteClient';\n","/**\n * Domain boundary barrel: exposes namespaced exports for Django-style drill-down\n * imports and curated flat exports for TS-native ergonomics.\n */\n\nexport * as dialects from './dialects/index';\n\nexport type { DBClient } from './DBClient';\nexport { PostgresClient, SqliteClient } from './dialects/index';\n","/**\n * Domain boundary barrel: exposes namespaced exports for Django-style drill-down\n * imports and curated flat exports for TS-native ergonomics.\n */\n\nexport * as adapters from './adapters/index';\nexport * as clients from './clients/index';\n\nexport { AdapterRegistry, connectDB, getDefaultAdapterRegistry } from './adapters/index';\nexport type { Adapter, AdapterConfig } from './adapters/index';\nexport type { DBClient } from './clients/DBClient';\nexport { PostgresAdapter, SqliteAdapter } from './adapters/index';\nexport { PostgresClient, SqliteClient } from './clients/index';\n"],"mappings":";;;;;;;;;;;;;ICEa,kBAAN,MAAM,gBAAgB;CACzB,OAAgB,QAAQ;CACxB,eAAsD,gBAAgB;CACtE,OAAe;CAEf,WAAmB,IAAI;CAEvB,OAAO,kBAAkBA,OAA0C;AAC/D,gBACW,UAAU,YACjB,UAAU,QACT,MAAqC,iBAAiB,gBAAgB;CAE9E;CAED,aAAa,qBAA+C;AACxD,MAAI,gBAAgB,wBAChB,QAAO,gBAAgB;AAG3B,kBAAgB,0BAA0B,IAAI;EAE9C,MAAM,EAAE,oCAAiB,GAAG,MAAM,OAAO;EACzC,MAAM,EAAE,gCAAe,GAAG,MAAM,OAAO;AAEvC,kBAAgB,wBAAwB,SAAS,IAAI,oBAAkB;AACvE,kBAAgB,wBAAwB,SAAS,IAAI,kBAAgB;AAErE,SAAO,gBAAgB;CAC1B;CAED,SAASC,SAAwB;AAC7B,OAAK,SAAS,IAAI,QAAQ,MAAM,QAAQ;AACxC,SAAO;CACV;CAED,IAAIC,MAAuB;EACvB,MAAM,UAAU,KAAK,SAAS,IAAI,KAAK;AACvC,OAAK,SAAS;GACV,MAAM,YAAY,CAAC,GAAG,KAAK,SAAS,MAAM,AAAC,EAAC,KAAK,KAAK;AACtD,SAAM,IAAI,OAAO,mBAAmB,KAAK,wBAAwB,aAAa,OAAO;EACxF;AACD,SAAO;CACV;CAED,IAAIA,MAAuB;AACvB,SAAO,KAAK,SAAS,IAAI,KAAK;CACjC;AACJ;AAEM,eAAe,UAClBC,QACAC,UACiB;CACjB,MAAM,oBAAoB,YAAa,MAAM,gBAAgB,oBAAoB;CACjF,MAAM,UAAU,kBAAkB,IAAI,OAAO,QAAQ;AACrD,QAAO,QAAQ,QAAQ,OAAO;AACjC;AAEM,eAAe,4BAAsD;AACxE,QAAO,gBAAgB,oBAAoB;AAC9C"}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Bundled exports for Django users who are used to Django domain-drill-down imports
+ */
+export * as connection from './connection/index';
+export * as query from './query/index';
+export * as repository from './repository/index';
+export * as transaction from './transaction/index';
+/**
+ * Unbundled exports for more TS native developers
+ */
+export { AdapterRegistry, connectDB, getDefaultAdapterRegistry } from './connection/index';
+export type { Adapter, AdapterConfig, DBClient } from './connection/index';
+export { PostgresAdapter, SqliteAdapter } from './connection/index';
+export { Q, QBuilder, QueryCompiler, QuerySet } from './query/index';
+export type { RepositoryLike } from './query/index';
+export type { CompiledQuery, Dialect, Direction, FilterInput, FilterKey, FilterValue, LookupType, OrderSpec, OrderToken, QNode, QueryResult, QuerySetState, RelationMeta, RepoMeta, WhereClause, } from './query/domain/index';
+export { Repository } from './repository/index';
+export { UnitOfWork } from './transaction/index';

package/dist/index.js

@@ -0,0 +1,9 @@
+import { PostgresAdapter } from "./PostgresAdapter-_X36-mLL.js";
+import { SqliteAdapter } from "./SqliteAdapter-J03fEjmr.js";
+import { AdapterRegistry, connectDB, connection_exports, getDefaultAdapterRegistry } from "./connection-DytAsjC9.js";
+import { QBuilder, QueryCompiler, QuerySet } from "./QuerySet-BzR5QzGi.js";
+import { query_exports } from "./query-CQbvLeuh.js";
+import { Repository, repository_exports } from "./repository-DaRvsfjs.js";
+import { UnitOfWork, transaction_exports } from "./transaction-DIGJnp19.js";
+
+export { AdapterRegistry, PostgresAdapter, QBuilder as Q, QBuilder, QueryCompiler, QuerySet, Repository, SqliteAdapter, UnitOfWork, connectDB, connection_exports as connection, getDefaultAdapterRegistry, query_exports as query, repository_exports as repository, transaction_exports as transaction };

package/dist/query/QBuilder.d.ts

@@ -0,0 +1,11 @@
+import type { QNode } from './domain/QNode';
+import type { FilterInput } from './domain/FilterInput';
+export declare class QBuilder {
+    static readonly BRAND: "tango.orm.q_builder";
+    readonly __tangoBrand: typeof QBuilder.BRAND;
+    static isQBuilder(value: unknown): value is QBuilder;
+    static and<T>(...nodes: Array<FilterInput<T> | QNode<T>>): QNode<T>;
+    static or<T>(...nodes: Array<FilterInput<T> | QNode<T>>): QNode<T>;
+    static not<T>(node: FilterInput<T> | QNode<T>): QNode<T>;
+    private static wrapNode;
+}

package/dist/query/QuerySet.d.ts

@@ -0,0 +1,64 @@
+import type { DBClient } from '../connection/clients/DBClient';
+import type { Dialect } from './domain/Dialect';
+import type { QuerySetState } from './domain/QuerySetState';
+import type { RepositoryMeta } from './domain/RepositoryMeta';
+import type { QNode } from './domain/QNode';
+import type { QueryResult } from './domain/QueryResult';
+import type { OrderToken } from './domain/OrderToken';
+import type { FilterInput } from './domain/FilterInput';
+/**
+ * Interface for repository-like objects that can execute queries.
+ * Used internally by QuerySet to remain decoupled from specific repository implementations.
+ *
+ * @template T - The model type
+ */
+export interface RepositoryLike<T> {
+    meta: RepositoryMeta;
+    client: DBClient;
+    dialect: Dialect;
+    run(compiled: {
+        sql: string;
+        params: readonly unknown[];
+    }): Promise<T[]>;
+}
+/**
+ * Django-inspired query builder for constructing and executing database queries.
+ * Provides a fluent API for filtering, ordering, pagination, and eager loading.
+ *
+ * @template T - The model type being queried
+ *
+ * @example
+ * ```typescript
+ * const users = await repository
+ *   .query()
+ *   .filter({ active: true })
+ *   .filter(Q.or({ role: 'admin' }, { role: 'moderator' }))
+ *   .orderBy('-createdAt')
+ *   .limit(10)
+ *   .fetchAll();
+ * ```
+ */
+export declare class QuerySet<T extends Record<string, unknown>> {
+    private repo;
+    private state;
+    static readonly BRAND: "tango.orm.query_set";
+    readonly __tangoBrand: typeof QuerySet.BRAND;
+    static isQuerySet<T extends Record<string, unknown>>(value: unknown): value is QuerySet<T>;
+    constructor(repo: RepositoryLike<T>, state?: QuerySetState<T>);
+    filter(q: FilterInput<T> | QNode<T>): QuerySet<T>;
+    exclude(q: FilterInput<T> | QNode<T>): QuerySet<T>;
+    orderBy(...tokens: OrderToken<T>[]): QuerySet<T>;
+    limit(n: number): QuerySet<T>;
+    offset(n: number): QuerySet<T>;
+    select(cols: (keyof T)[]): QuerySet<T>;
+    selectRelated(...rels: string[]): QuerySet<T>;
+    prefetchRelated(...rels: string[]): QuerySet<T>;
+    fetch<Out = T>(shape?: ((r: T) => Out) | {
+        parse: (r: T) => Out;
+    }): Promise<QueryResult<Out>>;
+    fetchOne<Out = T>(shape?: ((r: T) => Out) | {
+        parse: (r: T) => Out;
+    }): Promise<Out | null>;
+    count(): Promise<number>;
+    exists(): Promise<boolean>;
+}

package/dist/query/QuerySet.js

@@ -0,0 +1,108 @@
+import { InternalQNodeType } from './domain/internal/InternalQNodeType';
+import { InternalDirection } from './domain/internal/InternalDirection';
+import { QBuilder as Q } from './QBuilder';
+import { QueryCompiler } from './compiler';
+/**
+ * Django-inspired query builder for constructing and executing database queries.
+ * Provides a fluent API for filtering, ordering, pagination, and eager loading.
+ *
+ * @template T - The model type being queried
+ *
+ * @example
+ * ```typescript
+ * const users = await repository
+ *   .query()
+ *   .filter({ active: true })
+ *   .filter(Q.or({ role: 'admin' }, { role: 'moderator' }))
+ *   .orderBy('-createdAt')
+ *   .limit(10)
+ *   .fetchAll();
+ * ```
+ */
+export class QuerySet {
+    repo;
+    state;
+    static BRAND = 'tango.orm.query_set';
+    __tangoBrand = QuerySet.BRAND;
+    static isQuerySet(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            value.__tangoBrand === QuerySet.BRAND);
+    }
+    constructor(repo, state = {}) {
+        this.repo = repo;
+        this.state = state;
+    }
+    filter(q) {
+        const wrapped = q.kind
+            ? q
+            : { kind: InternalQNodeType.ATOM, where: q };
+        const merged = this.state.q ? Q.and(this.state.q, wrapped) : wrapped;
+        return new QuerySet(this.repo, { ...this.state, q: merged });
+    }
+    exclude(q) {
+        const wrapped = q.kind
+            ? q
+            : { kind: InternalQNodeType.ATOM, where: q };
+        const excludes = [...(this.state.excludes ?? []), wrapped];
+        return new QuerySet(this.repo, { ...this.state, excludes });
+    }
+    orderBy(...tokens) {
+        const order = tokens.map((t) => {
+            const str = String(t);
+            if (str.startsWith('-')) {
+                return { by: str.slice(1), dir: InternalDirection.DESC };
+            }
+            return { by: t, dir: InternalDirection.ASC };
+        });
+        return new QuerySet(this.repo, { ...this.state, order });
+    }
+    limit(n) {
+        return new QuerySet(this.repo, { ...this.state, limit: n });
+    }
+    offset(n) {
+        return new QuerySet(this.repo, { ...this.state, offset: n });
+    }
+    select(cols) {
+        return new QuerySet(this.repo, { ...this.state, select: cols });
+    }
+    selectRelated(...rels) {
+        return new QuerySet(this.repo, { ...this.state, selectRelated: rels });
+    }
+    prefetchRelated(...rels) {
+        return new QuerySet(this.repo, { ...this.state, prefetchRelated: rels });
+    }
+    async fetch(shape) {
+        const compiler = new QueryCompiler(this.repo.meta, this.repo.dialect);
+        const compiled = compiler.compile(this.state);
+        const rows = await this.repo.run(compiled);
+        const results = !shape
+            ? rows
+            : typeof shape === 'function'
+                ? rows.map(shape)
+                : rows.map((r) => shape.parse(r));
+        return {
+            results,
+            nextCursor: null,
+        };
+    }
+    async fetchOne(shape) {
+        const limited = this.limit(1);
+        const result = await limited.fetch(shape);
+        return result.results[0] ?? null;
+    }
+    async count() {
+        const compiler = new QueryCompiler(this.repo.meta, this.repo.dialect);
+        const compiled = compiler.compile({
+            ...this.state,
+            select: ['COUNT(*) as count'],
+        });
+        const countQuery = compiled.sql.replace(/SELECT .+ FROM/, 'SELECT COUNT(*) as count FROM');
+        const rows = await this.repo.client.query(countQuery, compiled.params);
+        return Number(rows.rows[0]?.count ?? 0);
+    }
+    async exists() {
+        const count = await this.count();
+        return count > 0;
+    }
+}

package/dist/query/compiler/QueryCompiler.d.ts

@@ -0,0 +1,20 @@
+import type { QuerySetState } from '../domain/QuerySetState';
+import type { RepositoryMeta } from '../domain/RepositoryMeta';
+import type { CompiledQuery } from '../domain/CompiledQuery';
+import type { Dialect } from '../domain/Dialect';
+export declare class QueryCompiler {
+    private meta;
+    private dialect;
+    static readonly BRAND: "tango.orm.query_compiler";
+    readonly __tangoBrand: typeof QueryCompiler.BRAND;
+    static isQueryCompiler(value: unknown): value is QueryCompiler;
+    constructor(meta: RepositoryMeta, dialect?: Dialect);
+    compile<T>(state: QuerySetState<T>): CompiledQuery;
+    private compileQNode;
+    private compileAtom;
+    private compileAnd;
+    private compileOr;
+    private compileNot;
+    private lookupToSQL;
+    private normalizeParam;
+}