uql-orm 0.20.2 → 0.22.0

package/dist/turso/tursoLocalQuerier.js

@@ -0,0 +1,20 @@
+import { PreparedSqliteQuerier } from '../sqlite/abstractSqliteQuerier.js';
+/**
+ * Querier for the embedded Turso engine.
+ *
+ * @remarks The engine exposes better-sqlite3 semantics (`reader`, `{changes, lastInsertRowid}`,
+ * array-bound values) over an async API, so all it supplies is the awaited `prepare`.
+ * `BEGIN`/`COMMIT` work as plain statements, leaving transactions to the base class.
+ */
+export class TursoLocalQuerier extends PreparedSqliteQuerier {
+    db;
+    extra;
+    constructor(db, dialect, extra) {
+        super(dialect, extra);
+        this.db = db;
+        this.extra = extra;
+    }
+    prepare(query) {
+        return this.db.prepare(query);
+    }
+}

package/dist/turso/tursoLocalQuerierPool.d.ts

@@ -0,0 +1,32 @@
+import { AbstractSqlQuerierPool } from '../querier/index.js';
+import type { ExtraOptions } from '../type/index.js';
+import { TursoDialect } from './tursoDialect.js';
+import { TursoLocalQuerier } from './tursoLocalQuerier.js';
+/** Subset of `DatabaseOpts` from `@tursodatabase/database`, declared locally to avoid the coupling. */
+export type TursoLocalOptions = {
+    readonly?: boolean;
+    fileMustExist?: boolean;
+    timeout?: number;
+    defaultQueryTimeout?: number;
+    tracing?: 'info' | 'debug' | 'trace';
+};
+/**
+ * Pool for the embedded Turso engine (`@tursodatabase/database`), the Rust rewrite of SQLite.
+ *
+ * @remarks Kept on the `uql-orm/turso/local` entry point rather than `uql-orm/turso`, because this
+ * package ships native binaries that do not resolve on edge runtimes. Separating them guarantees a
+ * bundle targeting Workers never reaches the native import.
+ */
+export declare class TursoLocalQuerierPool extends AbstractSqlQuerierPool<TursoLocalQuerier, TursoDialect> {
+    readonly filename: string;
+    readonly opts?: TursoLocalOptions | undefined;
+    private db?;
+    constructor(filename?: string, opts?: TursoLocalOptions | undefined, extra?: ExtraOptions);
+    /**
+     * The database handle is shared (single connection), but each acquisition gets its own querier
+     * so transaction state stays per unit of work.
+     */
+    getQuerier(): Promise<TursoLocalQuerier>;
+    private openDb;
+    end(): Promise<void>;
+}

package/dist/turso/tursoLocalQuerierPool.js

@@ -0,0 +1,39 @@
+import { AbstractSqlQuerierPool } from '../querier/index.js';
+import { TursoDialect } from './tursoDialect.js';
+import { TursoLocalQuerier } from './tursoLocalQuerier.js';
+/**
+ * Pool for the embedded Turso engine (`@tursodatabase/database`), the Rust rewrite of SQLite.
+ *
+ * @remarks Kept on the `uql-orm/turso/local` entry point rather than `uql-orm/turso`, because this
+ * package ships native binaries that do not resolve on edge runtimes. Separating them guarantees a
+ * bundle targeting Workers never reaches the native import.
+ */
+export class TursoLocalQuerierPool extends AbstractSqlQuerierPool {
+    filename;
+    opts;
+    db;
+    constructor(filename = ':memory:', opts, extra) {
+        super(new TursoDialect({ namingStrategy: extra?.namingStrategy }), extra);
+        this.filename = filename;
+        this.opts = opts;
+    }
+    /**
+     * The database handle is shared (single connection), but each acquisition gets its own querier
+     * so transaction state stays per unit of work.
+     */
+    async getQuerier() {
+        this.db ??= await this.openDb();
+        return new TursoLocalQuerier(this.db, this.dialect, this.extra);
+    }
+    async openDb() {
+        const { connect } = await import('@tursodatabase/database');
+        // Annotated rather than cast, so the structural contract is checked against the real driver.
+        const db = await connect(this.filename, this.opts);
+        await db.pragma('journal_mode = WAL');
+        return db;
+    }
+    async end() {
+        await this.db?.close();
+        this.db = undefined;
+    }
+}

package/dist/turso/tursoQuerier.d.ts

@@ -0,0 +1,10 @@
+import { HranaQuerier } from '../sqlite/hranaQuerier.js';
+/**
+ * Querier for remote Turso Cloud databases over `@tursodatabase/serverless/compat`.
+ *
+ * @remarks Empty subclass by design: that compat client speaks the Hrana protocol, so the whole
+ * implementation is inherited. Kept as a distinct type so `TursoQuerierPool` does not expose a
+ * libsql-named class.
+ */
+export declare class TursoQuerier extends HranaQuerier {
+}

package/dist/turso/tursoQuerier.js

@@ -0,0 +1,10 @@
+import { HranaQuerier } from '../sqlite/hranaQuerier.js';
+/**
+ * Querier for remote Turso Cloud databases over `@tursodatabase/serverless/compat`.
+ *
+ * @remarks Empty subclass by design: that compat client speaks the Hrana protocol, so the whole
+ * implementation is inherited. Kept as a distinct type so `TursoQuerierPool` does not expose a
+ * libsql-named class.
+ */
+export class TursoQuerier extends HranaQuerier {
+}

package/dist/turso/tursoQuerierPool.d.ts

@@ -0,0 +1,39 @@
+import type { HranaClient } from '../sqlite/hranaQuerier.js';
+import { AbstractHranaQuerierPool } from '../sqlite/hranaQuerierPool.js';
+import type { ExtraOptions } from '../type/index.js';
+import { TursoDialect } from './tursoDialect.js';
+import { TursoQuerier } from './tursoQuerier.js';
+/**
+ * Connection settings for Turso Cloud, mirroring `@tursodatabase/serverless`.
+ *
+ * @remarks Declared here rather than imported so this package does not couple its published types
+ * to a pre-1.0 dependency.
+ */
+export type TursoConfig = {
+    /** `libsql://<db>.turso.io` or `https://<db>.turso.io`. */
+    url: string;
+    authToken?: string;
+    remoteEncryptionKey?: string;
+    /** Extra HTTP headers attached to every request, e.g. for routing through a gateway. */
+    requestHeaders?: Record<string, string>;
+};
+/**
+ * Pool for remote Turso Cloud databases, driven by `@tursodatabase/serverless/compat`.
+ *
+ * @remarks The compat entry point is required rather than the native one: the native
+ * `conn.transaction()` takes a callback, which cannot satisfy the explicit
+ * `beginTransaction`/`commitTransaction` contract, and issuing a bare `BEGIN` is not an option
+ * because over plain HTTP consecutive requests need not share a connection. Compat's session-backed
+ * transaction handle is the piece that makes it work.
+ */
+export declare class TursoQuerierPool extends AbstractHranaQuerierPool<TursoQuerier, TursoDialect> {
+    protected readonly ownsClient: boolean;
+    private readonly conf;
+    /**
+     * Accepts either connection settings or an already-built client. The latter covers any driver
+     * with the same shape: `@libsql/client/web`, `@libsql/client-wasm`, or a test double.
+     */
+    constructor(conf: TursoConfig | HranaClient, extra?: ExtraOptions);
+    protected openClient(): Promise<HranaClient>;
+    protected buildQuerier(client: HranaClient): TursoQuerier;
+}

package/dist/turso/tursoQuerierPool.js

@@ -0,0 +1,38 @@
+import { AbstractHranaQuerierPool } from '../sqlite/hranaQuerierPool.js';
+import { TursoDialect } from './tursoDialect.js';
+import { TursoQuerier } from './tursoQuerier.js';
+function isClient(conf) {
+    return typeof conf.execute === 'function';
+}
+/**
+ * Pool for remote Turso Cloud databases, driven by `@tursodatabase/serverless/compat`.
+ *
+ * @remarks The compat entry point is required rather than the native one: the native
+ * `conn.transaction()` takes a callback, which cannot satisfy the explicit
+ * `beginTransaction`/`commitTransaction` contract, and issuing a bare `BEGIN` is not an option
+ * because over plain HTTP consecutive requests need not share a connection. Compat's session-backed
+ * transaction handle is the piece that makes it work.
+ */
+export class TursoQuerierPool extends AbstractHranaQuerierPool {
+    ownsClient;
+    conf;
+    /**
+     * Accepts either connection settings or an already-built client. The latter covers any driver
+     * with the same shape: `@libsql/client/web`, `@libsql/client-wasm`, or a test double.
+     */
+    constructor(conf, extra) {
+        super(new TursoDialect({ namingStrategy: extra?.namingStrategy }), extra);
+        this.conf = conf;
+        this.ownsClient = !isClient(conf);
+    }
+    async openClient() {
+        if (isClient(this.conf)) {
+            return this.conf;
+        }
+        const { createClient } = await import('@tursodatabase/serverless/compat');
+        return createClient(this.conf);
+    }
+    buildQuerier(client) {
+        return new TursoQuerier(client, this.dialect, this.extra);
+    }
+}

package/dist/type/config.d.ts

@@ -1,6 +1,5 @@
 import type { AbstractDialect } from '../dialect/abstractDialect.js';
 import type { ForeignKeyAction } from '../schema/types.js';
-import type { NamingStrategy } from './namingStrategy.js';
 import type { Querier } from './querier.js';
 import type { QuerierPool } from './querierPool.js';
 import type { Type } from './utility.js';
@@ -29,15 +28,9 @@ export interface Config {
      * @default 'uql_migrations'
      */
     tableName?: string;
-    /**
-     * The naming strategy for mapping class/property names to database table/column names.
-     * @default DefaultNamingStrategy (camelCase -> camelCase)
-     */
-    namingStrategy?: NamingStrategy;
     /**
      * Default action for foreign key ON DELETE and ON UPDATE clauses.
      * @default 'NO ACTION'
      */
     defaultForeignKeyAction?: ForeignKeyAction;
 }
-//# sourceMappingURL=config.d.ts.map

package/dist/type/config.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=config.js.map

package/dist/type/dialect.d.ts

@@ -74,11 +74,11 @@ export interface EngineFeatures {
     /** Whether the dialect supports inline COMMENT on columns (MySQL/MariaDB). */
     readonly columnComment: boolean;
     /**
-     * How vector indexes are emitted: inline in CREATE TABLE (MySQL/MariaDB), a standalone
-     * `CREATE INDEX ... USING <type> (col opclass)` (Postgres/SQLite), or a standalone
-     * `CREATE VECTOR INDEX (col opclass)` with no access-method keyword (CockroachDB's native type).
+     * Whether a vector index is declared inline in `CREATE TABLE` (MySQL/MariaDB) rather than as its own
+     * `CREATE INDEX` statement. The statement's shape itself is the dialect's business, see
+     * `AbstractSqlDialect.getCreateIndexStatement`.
      */
-    readonly vectorIndexStyle: 'inline' | 'create' | 'native';
+    readonly inlineVectorIndex: boolean;
     /** Whether the dialect requires/allows (n) length constraints on vector types. */
     readonly vectorSupportsLength: boolean;
     /** Whether the dialect natively supports the TIMESTAMPTZ alias/type. */
@@ -196,4 +196,11 @@ export interface SqlQueryDialect extends QueryDialect {
      */
     placeholder(index: number): string;
 }
-//# sourceMappingURL=dialect.d.ts.map
+/**
+ * An index capability that some engines have and others reject outright. Verified live: expression
+ * indexes exist everywhere but MariaDB 12.3 (which needs a generated column); prefix lengths are
+ * MySQL-family only and *required* there to index `TEXT`; `NULLS FIRST/LAST` and operator classes are
+ * Postgres-only (CockroachDB 26.2 answers "unimplemented"); `INCLUDE` is Postgres-wire only.
+ */
+export type IndexFeature = 'expression' | 'prefixLength' | 'nullsOrder' | 'opsClass' | 'include';
+export declare const INDEX_FEATURE_LABELS: Record<IndexFeature, string>;

package/dist/type/dialect.js

@@ -1,2 +1,7 @@
-export {};
-//# sourceMappingURL=dialect.js.map
+export const INDEX_FEATURE_LABELS = {
+    expression: 'expression indexes',
+    prefixLength: 'index prefix lengths',
+    nullsOrder: 'NULLS FIRST/LAST in an index',
+    opsClass: 'index operator classes',
+    include: 'covering indexes (INCLUDE)',
+};

package/dist/type/entity.d.ts

@@ -1,7 +1,7 @@
 import type { IndexType } from '../schema/types.js';
 import type { FilterOptions } from './query.js';
 import type { QueryRaw } from './queryRaw.js';
-import type { Json, Scalar, Type, Unpacked } from './utility.js';
+import type { DistributiveOmit, Json, Scalar, Type, Unpacked } from './utility.js';
 import type { VectorDistance, VectorIndexOptions, VectorIndexType } from './vector.js';
 /**
  * Allow to customize the name of the property that identifies an entity
@@ -344,17 +344,66 @@ export type IndexTypeOptions = {
     distance?: never;
 };
 /**
- * Index metadata from @Index decorator.
+ * One entry of an index: a column name by default, `raw(...)` to index an expression, or an object
+ * when the entry needs more than a name.
+ *
+ * @example
+ * ```ts
+ * @Index(['tenantId', { column: 'createdAt', order: 'desc' }])   // keyset pagination
+ * @Index([raw('lower("email")')], { unique: true })              // case-insensitive uniqueness
+ * @Index([{ column: 'body', length: 64 }])                       // MySQL needs a prefix on TEXT
+ * @Index(['data'], { type: 'gin' })                              // JSONB containment
+ * ```
+ */
+export type IndexColumnInput = string | QueryRaw | IndexColumnOptions;
+/**
+ * What an index entry can carry besides the thing being indexed. Shared with the normalized
+ * `IndexColumnSchema`, so the authored and internal shapes cannot drift apart.
+ */
+export type IndexColumnModifiers = {
+    /**
+     * Index only the first `n` characters. MySQL and MariaDB *require* this to index a `TEXT`/`BLOB`
+     * column at all ("used in key specification without a key length"); no other engine accepts it.
+     */
+    readonly length?: number;
+    /** Stored sort order, which lets `ORDER BY ... DESC` pagination use the index. */
+    readonly order?: 'asc' | 'desc';
+    /** Where NULLs sort. Postgres only. */
+    readonly nulls?: 'first' | 'last';
+    /** Operator class, e.g. `jsonb_path_ops` for a smaller GIN index. Postgres only. */
+    readonly opsClass?: string;
+};
+export type IndexColumnOptions = IndexColumnModifiers & {
+    /** The column to index, or `raw(...)` for an expression. */
+    readonly column: string | QueryRaw;
+};
+/**
+ * One index entry, normalized: {@link IndexColumnInput}'s three authored shapes all reduce to this
+ * before any dialect or generator sees them, so rendering never re-parses the sugar.
+ */
+export type IndexColumnSchema = IndexColumnModifiers & {
+    /** A column name, or raw SQL when {@link expression} is set. */
+    readonly column: string;
+    /** Whether {@link column} is an expression to emit as-is rather than an identifier to quote. */
+    readonly expression?: boolean;
+};
+/**
+ * An index as stored in entity metadata: authored options with the columns normalized.
  */
 export type EntityIndexMeta = {
-    /** Column names in the index */
-    columns: string[];
+    /** The indexed columns, in order. */
+    columns: readonly IndexColumnSchema[];
     /** Custom index name */
     name?: string;
     /** Whether index is unique; omit or `false` for a non-unique index (default). */
     unique?: boolean;
     /** Partial index condition (WHERE clause) */
     where?: string;
+    /**
+     * Extra columns stored in the index but not part of its key, so a query reading only these is
+     * answered from the index alone. Postgres-wire only (`INCLUDE`).
+     */
+    include?: readonly string[];
 } & VectorIndexOptions & IndexTypeOptions;
 export type EntityMeta<E> = {
     readonly entity: Type<E>;
@@ -392,9 +441,20 @@ export type EntityOptions<E = unknown> = {
     /** Scalar fields; use `isId: true` on exactly one field for the primary key. */
     readonly fields?: Record<string, FieldOptions>;
     readonly relations?: Record<string, RelationOptions>;
-    readonly indexes?: readonly EntityIndexMeta[];
+    readonly indexes?: readonly EntityIndexInput[];
     /** Map hook events to method names on the entity class. */
     readonly hooks?: Partial<Record<HookEvent, readonly string[]>>;
 };
+/**
+ * Everything an index carries beyond its columns, shared by `@Index`, `defineEntity` and the
+ * migration builder's `table.index(...)`. `DistributiveOmit` (not plain `Omit`) keeps `type`/
+ * `distance` a discriminated pair: omitting `distance` on a vector index type is a compile error.
+ */
+export type IndexOptions = DistributiveOmit<EntityIndexMeta, 'columns'>;
+/**
+ * An index as authored, before {@link appendEntityIndex} normalizes its columns.
+ */
+export type EntityIndexInput = IndexOptions & {
+    readonly columns: readonly IndexColumnInput[];
+};
 export {};
-//# sourceMappingURL=entity.d.ts.map

package/dist/type/entity.js

@@ -2,4 +2,3 @@
  * Allow to customize the name of the property that identifies an entity
  */
 export const idKey = Symbol('idKey');
-//# sourceMappingURL=entity.js.map

package/dist/type/index.d.ts

@@ -14,4 +14,3 @@ export * from './queryWhere.js';
 export * from './universalQuerier.js';
 export * from './utility.js';
 export * from './vector.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/type/index.js

@@ -14,4 +14,3 @@ export * from './queryWhere.js';
 export * from './universalQuerier.js';
 export * from './utility.js';
 export * from './vector.js';
-//# sourceMappingURL=index.js.map

package/dist/type/logger.d.ts

@@ -58,4 +58,3 @@ export type LoggerFunction = (message: unknown, ...args: unknown[]) => void;
  * - LoggerFunction: use a custom function (backward compatibility).
  */
 export type LoggingOptions = boolean | LogLevel[] | Logger | LoggerFunction;
-//# sourceMappingURL=logger.d.ts.map

package/dist/type/logger.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=logger.js.map

package/dist/type/migration.d.ts

@@ -1,7 +1,8 @@
+import type { VectorCast } from '../dialect/vectorCast.js';
 import type { FullColumnDefinition, TableDefinition, TableForeignKeyDefinition } from '../migrate/builder/types.js';
 import type { SchemaAST } from '../schema/schemaAST.js';
 import type { ForeignKeyAction, IndexNode, IndexType, TableNode } from '../schema/types.js';
-import type { EntityMeta, FieldOptions, LoggingOptions, NamingStrategy, SqlQuerier, Type, VectorIndexOptions } from './index.js';
+import type { EntityMeta, FieldOptions, IndexColumnSchema, LoggingOptions, SqlQuerier, Type, VectorIndexOptions } from './index.js';
 /**
  * Defines a migration using a simple object literal
  */
@@ -72,10 +73,6 @@ export interface MigratorOptions {
      * Entities to use for schema generation
      */
     readonly entities?: Type<unknown>[];
-    /**
-     * Naming strategy for database tables and columns
-     */
-    readonly namingStrategy?: NamingStrategy;
     /**
      * Default action for foreign key ON DELETE and ON UPDATE clauses.
      */
@@ -101,6 +98,13 @@ export interface MigrationResult {
  */
 export interface ColumnSchema {
     readonly name: string;
+    /**
+     * The engine's own type spelling, as introspection read it (`tinyint(1)`, `DATETIME`, `VARCHAR`).
+     * Deliberately not a {@link CanonicalType}: the diff has to compare what the engine would *store*,
+     * and several canonical types share one storage type per engine - an entity `boolean` is `TINYINT(1)`
+     * on MySQL and `INTEGER` on SQLite. Comparing canonical categories instead reports an alteration on
+     * every sync for those columns. Use `sqlToCanonical` to interpret it.
+     */
     readonly type: string;
     readonly nullable: boolean;
     readonly defaultValue?: unknown;
@@ -127,10 +131,20 @@ export interface TableSchema {
  */
 export interface IndexSchema extends VectorIndexOptions {
     readonly name: string;
-    readonly columns: string[];
+    readonly columns: readonly IndexColumnSchema[];
     readonly unique: boolean;
     /** Index type (btree, hnsw, ivfflat, etc.) */
     readonly type?: IndexType;
+    /** Partial index condition (WHERE clause) */
+    readonly where?: string;
+    /** Non-key columns stored in the index (Postgres-wire `INCLUDE`). */
+    readonly include?: readonly string[];
+    /**
+     * The indexed column's vector type, which pgvector's operator-class names are built from
+     * (`halfvec_cosine_ops`). Absent for a non-vector index, and for an index whose column types are
+     * unknown, where `vector` is assumed.
+     */
+    readonly vectorType?: VectorCast;
 }
 /**
  * Represents a foreign key constraint
@@ -171,10 +185,11 @@ export interface SchemaGenerator {
     generateCreateTable<E>(entity: Type<E>, options?: {
         ifNotExists?: boolean;
     }): string[];
-    /**
-     * Generate DROP TABLE statement for an entity
-     */
-    generateDropTable<E>(entity: Type<E>): string;
+    /** Generate DROP TABLE statement. */
+    generateDropTable(tableName: string, options?: {
+        ifExists?: boolean;
+        cascade?: boolean;
+    }): string;
     /**
      * Generate ALTER TABLE statements based on schema diff
      */
@@ -215,21 +230,19 @@ export interface SchemaGenerator {
     generateCreateIndexFromNode(index: IndexNode, options?: {
         ifNotExists?: boolean;
     }): string;
-    /** Generate DROP TABLE statement from a TableNode */
-    generateDropTableFromNode(table: TableNode, options?: {
-        ifExists?: boolean;
-    }): string;
     /** DDL from a `TableDefinition`, one string per `querier.run`. */
     generateCreateTableFromDefinition(table: TableDefinition, options?: {
         ifNotExists?: boolean;
     }): string[];
-    /** Generate DROP TABLE statement */
-    generateDropTableSql(tableName: string, options?: {
-        ifExists?: boolean;
-        cascade?: boolean;
-    }): string;
     /** Generate RENAME TABLE statement */
     generateRenameTableSql(oldName: string, newName: string): string;
+}
+/**
+ * The column and constraint DDL a migration builder emits, which only a SQL engine has. Split from
+ * {@link SchemaGenerator} because MongoDB used to satisfy these six by returning `''`: a document store
+ * has no `ADD COLUMN`, and an empty statement silently did nothing rather than saying so.
+ */
+export interface SqlDdlGenerator extends SchemaGenerator {
     /** Generate ADD COLUMN statement */
     generateAddColumnSql(tableName: string, column: FullColumnDefinition): string;
     /** Generate ALTER COLUMN statement */
@@ -238,10 +251,6 @@ export interface SchemaGenerator {
     generateDropColumnSql(tableName: string, columnName: string): string;
     /** Generate RENAME COLUMN statement */
     generateRenameColumnSql(tableName: string, oldName: string, newName: string): string;
-    /** Generate CREATE INDEX statement from IndexSchema */
-    generateCreateIndexSql(tableName: string, index: IndexSchema): string;
-    /** Generate DROP INDEX statement */
-    generateDropIndexSql(tableName: string, indexName: string): string;
     /** Generate ADD FOREIGN KEY statement */
     generateAddForeignKeySql(tableName: string, foreignKey: TableForeignKeyDefinition): string;
     /** Generate DROP FOREIGN KEY statement */
@@ -268,4 +277,3 @@ export interface SchemaIntrospector {
      */
     tableExists(tableName: string): Promise<boolean>;
 }
-//# sourceMappingURL=migration.d.ts.map

package/dist/type/migration.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=migration.js.map

package/dist/type/migratorDialect.d.ts

@@ -7,4 +7,3 @@ export type KnownMigratorDialect = (typeof KNOWN_MIGRATOR_DIALECTS)[number];
  */
 export declare function isKnownMigratorDialect(d: DialectName): d is KnownMigratorDialect;
 export {};
-//# sourceMappingURL=migratorDialect.d.ts.map

package/dist/type/migratorDialect.js

@@ -13,4 +13,3 @@ const KNOWN_MIGRATOR_DIALECTS = [
 export function isKnownMigratorDialect(d) {
     return KNOWN_MIGRATOR_DIALECTS.includes(d);
 }
-//# sourceMappingURL=migratorDialect.js.map

package/dist/type/namingStrategy.d.ts

@@ -15,4 +15,3 @@ export interface NamingStrategy {
      */
     joinTableName(sourceEntityName: string, targetEntityName: string, propertyName?: string): string;
 }
-//# sourceMappingURL=namingStrategy.d.ts.map

package/dist/type/namingStrategy.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=namingStrategy.js.map

package/dist/type/querier.d.ts

@@ -177,4 +177,3 @@ export type ExtraOptions = {
     readonly namingStrategy?: NamingStrategy;
     readonly listeners?: readonly QuerierListener[];
 };
-//# sourceMappingURL=querier.d.ts.map

package/dist/type/querier.js

@@ -8,4 +8,3 @@ export function isSqlQuerier(querier) {
         q.dialect !== undefined &&
         typeof q.dialect.escapeIdChar === 'string');
 }
-//# sourceMappingURL=querier.js.map

package/dist/type/querierPool.d.ts

@@ -94,4 +94,3 @@ export interface SqlPoolCompat {
      */
     on?: (event: string, listener: (...args: unknown[]) => void) => void;
 }
-//# sourceMappingURL=querierPool.d.ts.map

package/dist/type/querierPool.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=querierPool.js.map

package/dist/type/query.d.ts

@@ -217,4 +217,3 @@ export type QueryUpdateResult = {
      */
     created?: boolean;
 };
-//# sourceMappingURL=query.d.ts.map

package/dist/type/query.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=query.js.map

package/dist/type/queryAggregate.d.ts

@@ -188,4 +188,3 @@ export type QueryAggregate<E, G extends QueryGroupMap<E> = QueryGroupMap<E>, A e
     };
 } & QueryPager;
 export {};
-//# sourceMappingURL=queryAggregate.d.ts.map

package/dist/type/queryAggregate.js

@@ -36,4 +36,3 @@ export function resolveAggregateOp(key) {
     }
     throw new TypeError(`unsupported aggregate operator: ${key}`);
 }
-//# sourceMappingURL=queryAggregate.js.map

package/dist/type/queryRaw.d.ts

@@ -32,4 +32,3 @@ export declare class QueryRaw {
     readonly [RAW_ALIAS]?: string;
     constructor(value: Scalar | QueryRawFn, alias?: string);
 }
-//# sourceMappingURL=queryRaw.d.ts.map

package/dist/type/queryRaw.js

@@ -8,4 +8,3 @@ export class QueryRaw {
         this[RAW_ALIAS] = alias;
     }
 }
-//# sourceMappingURL=queryRaw.js.map

package/dist/type/queryWhere.d.ts

@@ -268,4 +268,3 @@ export type QueryWhereArray<E> = (QueryWhereMap<E> | QueryRaw)[];
  */
 export type QueryWhere<E> = IdValue<E> | IdValue<E>[] | QueryWhereMap<E> | QueryWhereArray<E> | QueryRaw;
 export {};
-//# sourceMappingURL=queryWhere.d.ts.map

package/dist/type/queryWhere.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=queryWhere.js.map

package/dist/type/universalQuerier.d.ts

@@ -134,4 +134,3 @@ export interface UniversalQuerier {
      */
     aggregate<E extends object, const G extends QueryGroupMap<E>, const A extends QueryAggMap<E>>(entity: Type<E>, q: QueryAggregate<E, G, A>, opts?: QueryOptions): Promise<QueryAggregateResult<E, G, A>[]>;
 }
-//# sourceMappingURL=universalQuerier.d.ts.map

package/dist/type/universalQuerier.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=universalQuerier.js.map

package/dist/type/utility.d.ts

@@ -48,4 +48,3 @@ export type Writable<T> = {
  */
 export type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
 export type Unpacked<T> = T extends readonly (infer U)[] ? U : T extends (...args: unknown[]) => infer U ? U : T extends Promise<infer U> ? U : T;
-//# sourceMappingURL=utility.d.ts.map

package/dist/type/utility.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=utility.js.map