@danceroutine/tango-orm 0.1.0 → 1.0.0

package/dist/connection-CVvycXus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-CVvycXus.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';\n\n/**\n * Runtime registry for database adapters.\n *\n * Use a custom instance when tests or applications need explicit control\n * over supported adapters; use `getDefaultRegistry()` for the built-in set.\n */\nexport class AdapterRegistry {\n    static readonly BRAND = 'tango.orm.adapter_registry' as const;\n    private static defaultRegistryInstance: AdapterRegistry | undefined;\n    readonly __tangoBrand: typeof AdapterRegistry.BRAND = AdapterRegistry.BRAND;\n    private adapters = new Map<string, Adapter>();\n\n    /**\n     * Narrow an unknown value to `AdapterRegistry`.\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    /**\n     * Return a lazily-initialized registry preloaded with built-in adapters.\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    /**\n     * Register an adapter under its declared `name`.\n     */\n    register(adapter: Adapter): this {\n        this.adapters.set(adapter.name, adapter);\n        return this;\n    }\n\n    /**\n     * Resolve an adapter by name, or throw a descriptive error.\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    /**\n     * Check whether an adapter has been registered.\n     */\n    has(name: string): boolean {\n        return this.adapters.has(name);\n    }\n}\n\n/**\n * Connect to a database by adapter name using the provided (or default) registry.\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\n/**\n * Convenience helper that exposes the singleton default adapter registry.\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":";;;;;;;;;;;;;ICSa,kBAAN,MAAM,gBAAgB;CACzB,OAAgB,QAAQ;CACxB,OAAe;CACf,eAAsD,gBAAgB;CACtE,WAAmB,IAAI;;;;CAKvB,OAAO,kBAAkBA,OAA0C;AAC/D,gBACW,UAAU,YACjB,UAAU,QACT,MAAqC,iBAAiB,gBAAgB;CAE9E;;;;CAKD,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;;;;CAKD,SAASC,SAAwB;AAC7B,OAAK,SAAS,IAAI,QAAQ,MAAM,QAAQ;AACxC,SAAO;CACV;;;;CAKD,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;;;;CAKD,IAAIA,MAAuB;AACvB,SAAO,KAAK,SAAS,IAAI,KAAK;CACjC;AACJ;AAKM,eAAe,UAClBC,QACAC,UACiB;CACjB,MAAM,oBAAoB,YAAa,MAAM,gBAAgB,oBAAoB;CACjF,MAAM,UAAU,kBAAkB,IAAI,OAAO,QAAQ;AACrD,QAAO,QAAQ,QAAQ,OAAO;AACjC;AAKM,eAAe,4BAAsD;AACxE,QAAO,gBAAgB,oBAAoB;AAC9C"}

package/dist/index.d.ts

@@ -2,8 +2,9 @@
  * Bundled exports for Django users who are used to Django domain-drill-down imports
  */
 export * as connection from './connection/index';
+export * as manager from './manager/index';
 export * as query from './query/index';
-export * as repository from './repository/index';
+export * as runtime from './runtime/index';
 export * as transaction from './transaction/index';
 /**
  * Unbundled exports for more TS native developers
@@ -11,8 +12,10 @@ export * as transaction from './transaction/index';
 export { AdapterRegistry, connectDB, getDefaultAdapterRegistry } from './connection/index';
 export type { Adapter, AdapterConfig, DBClient } from './connection/index';
 export { PostgresAdapter, SqliteAdapter } from './connection/index';
+export { ModelManager } from './manager/index';
+export type { ManagerLike } from './manager/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 type { QueryExecutor } from './query/index';
+export type { CompiledQuery, Dialect, Direction, FilterInput, FilterKey, FilterValue, LookupType, OrderSpec, OrderToken, QNode, QueryResult, QuerySetState, RelationMeta, TableMeta, WhereClause, } from './query/domain/index';
+export { getTangoRuntime, initializeTangoRuntime, resetTangoRuntime, TangoRuntime } from './runtime/index';
 export { UnitOfWork } from './transaction/index';

package/dist/index.js

@@ -1,9 +1,10 @@
-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";
+import { PostgresAdapter } from "./PostgresAdapter-C9a1XJRx.js";
+import { SqliteAdapter } from "./SqliteAdapter-Dp6VRXmz.js";
+import { AdapterRegistry, connectDB, connection_exports, getDefaultAdapterRegistry } from "./connection-CVvycXus.js";
+import { QBuilder, QueryCompiler, QuerySet, query_exports } from "./query-wnl4h2o7.js";
+import { ModelManager, TangoRuntime, getTangoRuntime, initializeTangoRuntime, resetTangoRuntime } from "./registerModelObjects-emX7Hja9.js";
+import { manager_exports } from "./manager-D6tU8xTO.js";
+import { runtime_exports } from "./runtime-7U5_XDad.js";
+import { UnitOfWork, transaction_exports } from "./transaction-DooTMuAl.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 };
+export { AdapterRegistry, ModelManager, PostgresAdapter, QBuilder as Q, QBuilder, QueryCompiler, QuerySet, SqliteAdapter, TangoRuntime, UnitOfWork, connectDB, connection_exports as connection, getDefaultAdapterRegistry, getTangoRuntime, initializeTangoRuntime, manager_exports as manager, query_exports as query, resetTangoRuntime, runtime_exports as runtime, transaction_exports as transaction };

package/dist/manager/ManagerLike.d.ts

@@ -0,0 +1,15 @@
+import type { QuerySet } from '../query/index';
+import type { TableMeta } from '../query/domain/index';
+/**
+ * Public manager contract consumed by Tango resources and applications.
+ */
+export interface ManagerLike<T extends Record<string, unknown>> {
+    readonly meta: TableMeta;
+    query(): QuerySet<T>;
+    findById(id: T[keyof T]): Promise<T | null>;
+    getOrThrow(id: T[keyof T]): Promise<T>;
+    create(input: Partial<T>): Promise<T>;
+    update(id: T[keyof T], patch: Partial<T>): Promise<T>;
+    delete(id: T[keyof T]): Promise<void>;
+    bulkCreate(inputs: Partial<T>[]): Promise<T[]>;
+}

package/dist/manager/ModelManager.d.ts

@@ -0,0 +1,48 @@
+import type { ModelWriteHooks } from '@danceroutine/tango-schema';
+import type { TableMeta } from '../query/domain/index';
+import type { QuerySet } from '../query/index';
+import type { TangoRuntime } from '../runtime/TangoRuntime';
+import type { ManagerLike } from './ManagerLike';
+type FieldLike = {
+    name: string;
+    type: string;
+    primaryKey?: boolean;
+};
+type ModelLike<T extends Record<string, unknown>> = {
+    metadata: {
+        name: string;
+        table: string;
+        fields: FieldLike[];
+    };
+    schema: {
+        parse(input: unknown): T;
+    };
+    hooks?: ModelWriteHooks<T>;
+};
+/**
+ * Model-backed data access API exposed as `Model.objects`.
+ */
+export declare class ModelManager<T extends Record<string, unknown>> implements ManagerLike<T> {
+    static readonly BRAND: "tango.orm.model_manager";
+    readonly __tangoBrand: typeof ModelManager.BRAND;
+    readonly meta: TableMeta;
+    private readonly queryExecutor;
+    private readonly mutationCompiler;
+    private readonly model;
+    constructor(model: ModelLike<T>, runtime: TangoRuntime);
+    /**
+     * Narrow an unknown value to `ModelManager`.
+     */
+    static isModelManager<T extends Record<string, unknown>>(value: unknown): value is ModelManager<T>;
+    private static createTableMeta;
+    query(): QuerySet<T>;
+    findById(id: T[keyof T]): Promise<T | null>;
+    getOrThrow(id: T[keyof T]): Promise<T>;
+    create(input: Partial<T>): Promise<T>;
+    update(id: T[keyof T], patch: Partial<T>): Promise<T>;
+    delete(id: T[keyof T]): Promise<void>;
+    bulkCreate(inputs: Partial<T>[]): Promise<T[]>;
+    private runBeforeCreate;
+    private runBeforeUpdate;
+}
+export {};

package/dist/manager/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Domain boundary barrel: centralizes manager-first ORM APIs.
+ */
+export type { ManagerLike } from './ManagerLike';
+export { ModelManager } from './ModelManager';
+export { registerModelObjects } from './registerModelObjects';

package/dist/manager/index.js

@@ -0,0 +1,8 @@
+import "../PostgresAdapter-C9a1XJRx.js";
+import "../SqliteAdapter-Dp6VRXmz.js";
+import "../connection-CVvycXus.js";
+import "../query-wnl4h2o7.js";
+import { ModelManager, registerModelObjects } from "../registerModelObjects-emX7Hja9.js";
+import "../manager-D6tU8xTO.js";
+
+export { ModelManager, registerModelObjects };

package/dist/manager/internal/MutationCompiler.d.ts

@@ -0,0 +1,15 @@
+import type { CompiledQuery, Dialect } from '../../query/domain/index';
+import type { ValidatedDeleteSqlPlan, ValidatedInsertSqlPlan, ValidatedUpdateSqlPlan } from '../../validation/SQLValidationEngine';
+/**
+ * Internal compiler for manager-owned INSERT/UPDATE/DELETE statements.
+ */
+export declare class MutationCompiler {
+    private readonly dialect;
+    constructor(dialect: Dialect);
+    compileInsert(plan: ValidatedInsertSqlPlan, values: readonly unknown[]): CompiledQuery;
+    compileUpdate(plan: ValidatedUpdateSqlPlan, values: readonly unknown[], id: unknown): CompiledQuery;
+    compileDelete(plan: ValidatedDeleteSqlPlan, id: unknown): CompiledQuery;
+    compileBulkInsert(plan: ValidatedInsertSqlPlan, valueRows: ReadonlyArray<ReadonlyArray<unknown>>): CompiledQuery;
+    private buildValuePlaceholders;
+    private placeholder;
+}

package/dist/manager/internal/RuntimeBoundClient.d.ts

@@ -0,0 +1,16 @@
+import type { DBClient } from '../../connection/index';
+import type { TangoRuntime } from '../../runtime/index';
+/**
+ * DB client proxy that resolves the real Tango runtime client lazily.
+ */
+export declare class RuntimeBoundClient implements DBClient {
+    private readonly runtime;
+    constructor(runtime: TangoRuntime);
+    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/manager/registerModelObjects.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Install the schema model augmentor that exposes `Model.objects`.
+ * This registration is idempotent so multiple Tango entrypoints can safely call it.
+ */
+export declare function registerModelObjects(): void;

package/dist/manager-D6tU8xTO.js

@@ -0,0 +1,13 @@
+import { __export } from "./chunk-DLY2FNSh.js";
+import { ModelManager, registerModelObjects } from "./registerModelObjects-emX7Hja9.js";
+
+//#region src/manager/index.ts
+var manager_exports = {};
+__export(manager_exports, {
+	ModelManager: () => ModelManager,
+	registerModelObjects: () => registerModelObjects
+});
+
+//#endregion
+export { manager_exports };
+//# sourceMappingURL=manager-D6tU8xTO.js.map

package/dist/manager-D6tU8xTO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager-D6tU8xTO.js","names":[],"sources":["../src/manager/index.ts"],"sourcesContent":["/**\n * Domain boundary barrel: centralizes manager-first ORM APIs.\n */\nexport type { ManagerLike } from './ManagerLike';\nexport { ModelManager } from './ModelManager';\nexport { registerModelObjects } from './registerModelObjects';\n"],"mappings":""}

package/dist/query/QBuilder.d.ts

@@ -1,11 +1,29 @@
 import type { QNode } from './domain/QNode';
 import type { FilterInput } from './domain/FilterInput';
+/**
+ * Static builder for composing boolean query expressions.
+ *
+ * This mirrors Django's `Q(...)` composition patterns and is intended
+ * for ergonomic construction of nested `AND`/`OR`/`NOT` trees.
+ */
 export declare class QBuilder {
     static readonly BRAND: "tango.orm.q_builder";
     readonly __tangoBrand: typeof QBuilder.BRAND;
+    /**
+     * Narrow an unknown value to `QBuilder`.
+     */
     static isQBuilder(value: unknown): value is QBuilder;
+    /**
+     * Combine multiple filter fragments using logical `AND`.
+     */
     static and<T>(...nodes: Array<FilterInput<T> | QNode<T>>): QNode<T>;
+    /**
+     * Combine multiple filter fragments using logical `OR`.
+     */
     static or<T>(...nodes: Array<FilterInput<T> | QNode<T>>): QNode<T>;
+    /**
+     * Negate a filter fragment using logical `NOT`.
+     */
     static not<T>(node: FilterInput<T> | QNode<T>): QNode<T>;
     private static wrapNode;
 }

package/dist/query/QuerySet.d.ts

@@ -1,19 +1,21 @@
 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 { TableMeta } from './domain/TableMeta';
 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.
+ * Query execution seam consumed by `QuerySet`.
+ *
+ * Application code usually reaches this through `Model.objects` or testing
+ * fixtures rather than implementing it directly.
  *
  * @template T - The model type
  */
-export interface RepositoryLike<T> {
-    meta: RepositoryMeta;
+export interface QueryExecutor<T> {
+    meta: TableMeta;
     client: DBClient;
     dialect: Dialect;
     run(compiled: {
@@ -29,36 +31,85 @@ export interface RepositoryLike<T> {
  *
  * @example
  * ```typescript
- * const users = await repository
+ * const users = await TodoModel.objects
  *   .query()
  *   .filter({ active: true })
  *   .filter(Q.or({ role: 'admin' }, { role: 'moderator' }))
  *   .orderBy('-createdAt')
  *   .limit(10)
- *   .fetchAll();
+ *   .fetch();
  * ```
  */
 export declare class QuerySet<T extends Record<string, unknown>> {
-    private repo;
+    private executor;
     private state;
     static readonly BRAND: "tango.orm.query_set";
     readonly __tangoBrand: typeof QuerySet.BRAND;
+    constructor(executor: QueryExecutor<T>, state?: QuerySetState<T>);
+    /**
+     * Narrow an unknown value to `QuerySet`.
+     */
     static isQuerySet<T extends Record<string, unknown>>(value: unknown): value is QuerySet<T>;
-    constructor(repo: RepositoryLike<T>, state?: QuerySetState<T>);
+    /**
+     * Add a filter expression to the query.
+     *
+     * Multiple `filter()` calls are composed with `AND`.
+     */
     filter(q: FilterInput<T> | QNode<T>): QuerySet<T>;
+    /**
+     * Add an exclusion expression to the query.
+     *
+     * Exclusions are translated to `NOT (...)` predicates.
+     */
     exclude(q: FilterInput<T> | QNode<T>): QuerySet<T>;
+    /**
+     * Apply ordering tokens such as `'name'` or `'-createdAt'`.
+     */
     orderBy(...tokens: OrderToken<T>[]): QuerySet<T>;
+    /**
+     * Limit the maximum number of rows returned.
+     */
     limit(n: number): QuerySet<T>;
+    /**
+     * Skip the first `n` rows.
+     */
     offset(n: number): QuerySet<T>;
+    /**
+     * Restrict selected columns.
+     */
     select(cols: (keyof T)[]): QuerySet<T>;
+    /**
+     * Request SQL joins for related data when supported by relation metadata.
+     */
     selectRelated(...rels: string[]): QuerySet<T>;
+    /**
+     * Register relation names for prefetch behavior.
+     *
+     * Prefetch orchestration is adapter-specific.
+     */
     prefetchRelated(...rels: string[]): QuerySet<T>;
+    /**
+     * Execute the query and optionally shape each row.
+     */
     fetch<Out = T>(shape?: ((r: T) => Out) | {
         parse: (r: T) => Out;
     }): Promise<QueryResult<Out>>;
+    /**
+     * Execute the query and return the first row, or `null`.
+     */
     fetchOne<Out = T>(shape?: ((r: T) => Out) | {
         parse: (r: T) => Out;
     }): Promise<Out | null>;
+    /**
+     * Execute a `COUNT(*)` query for the current filtered state.
+     */
     count(): Promise<number>;
+    /**
+     * Return whether at least one row matches the current query state.
+     */
     exists(): Promise<boolean>;
+    private normalizeRowsForSchemaParsing;
+    private isBooleanColumnType;
+    private normalizeSqliteBoolean;
+    private normalizeBooleanColumns;
 }

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

@@ -1,14 +1,29 @@
 import type { QuerySetState } from '../domain/QuerySetState';
-import type { RepositoryMeta } from '../domain/RepositoryMeta';
+import type { TableMeta } from '../domain/TableMeta';
 import type { CompiledQuery } from '../domain/CompiledQuery';
 import type { Dialect } from '../domain/Dialect';
+/**
+ * Compiles immutable `QuerySet` state into parameterized SQL.
+ *
+ * The compiler is intentionally stateless with respect to execution and only
+ * produces SQL + params artifacts that can be executed by a `DBClient`.
+ */
 export declare class QueryCompiler {
     private meta;
     private dialect;
     static readonly BRAND: "tango.orm.query_compiler";
     readonly __tangoBrand: typeof QueryCompiler.BRAND;
+    /**
+     * Build a compiler for the given repository metadata and SQL dialect.
+     */
+    constructor(meta: TableMeta, dialect?: Dialect);
+    /**
+     * Narrow an unknown value to `QueryCompiler`.
+     */
     static isQueryCompiler(value: unknown): value is QueryCompiler;
-    constructor(meta: RepositoryMeta, dialect?: Dialect);
+    /**
+     * Compile a query state tree into a SQL statement and bound parameters.
+     */
     compile<T>(state: QuerySetState<T>): CompiledQuery;
     private compileQNode;
     private compileAtom;
@@ -17,4 +32,6 @@ export declare class QueryCompiler {
     private compileNot;
     private lookupToSQL;
     private normalizeParam;
+    private collectStateFilterKeys;
+    private collectNodeFilterKeys;
 }

package/dist/query/domain/{RepositoryMeta.d.ts → TableMeta.d.ts}

@@ -1,5 +1,5 @@
 import type { RelationMeta } from './RelationMeta';
-export interface RepositoryMeta {
+export interface TableMeta {
     table: string;
     pk: string;
     columns: Record<string, string>;

package/dist/query/domain/index.d.ts

@@ -14,5 +14,5 @@ export type { QNode } from './QNode';
 export type { QueryResult } from './QueryResult';
 export type { QuerySetState } from './QuerySetState';
 export type { RelationMeta } from './RelationMeta';
-export type { RepositoryMeta as RepoMeta } from './RepositoryMeta';
+export type { TableMeta } from './TableMeta';
 export type { WhereClause } from './WhereClause';

package/dist/query/index.d.ts

@@ -5,8 +5,8 @@
 export * as compiler from './compiler/index';
 export * as domain from './domain/index';
 export type * from './domain/index';
-export type { RepoMeta } from './domain/index';
+export type { TableMeta } from './domain/index';
 export { QuerySet } from './QuerySet';
-export type { RepositoryLike } from './QuerySet';
+export type { QueryExecutor } from './QuerySet';
 export { QBuilder, QBuilder as Q } from './QBuilder';
 export { QueryCompiler } from './compiler/index';

package/dist/query/index.js

@@ -1,4 +1,3 @@
-import { QBuilder, QueryCompiler, QuerySet, compiler_exports } from "../QuerySet-BzR5QzGi.js";
-import { domain_exports } from "../query-CQbvLeuh.js";
+import { QBuilder, QueryCompiler, QuerySet, compiler_exports, domain_exports } from "../query-wnl4h2o7.js";
 
 export { QBuilder as Q, QBuilder, QueryCompiler, QuerySet, compiler_exports as compiler, domain_exports as domain };