uql-orm 0.54.0 → 0.56.0

package/dist/turso/tursoLocalQuerierPool.js

@@ -1,5 +1,6 @@
 import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractSharedHandleQuerierPool } from '../querier/abstractSharedHandleQuerierPool.js';
+import { applySqlitePragmas } from '../sqlite/sqlitePragmas.js';
 import { TursoDialect } from './tursoDialect.js';
 import { TursoLocalQuerier } from './tursoLocalQuerier.js';
 /**
@@ -21,8 +22,7 @@ export class TursoLocalQuerierPool extends AbstractSharedHandleQuerierPool {
         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');
-        await db.pragma('foreign_keys = ON');
+        await applySqlitePragmas(db);
         return db;
     }
     buildQuerier(db) {

package/dist/turso/tursoQuerierPool.d.ts

@@ -2,7 +2,6 @@ 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`.
  *
@@ -26,7 +25,7 @@ export type TursoConfig = {
  * 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> {
+export declare class TursoQuerierPool extends AbstractHranaQuerierPool<TursoDialect> {
     protected readonly ownsClient: boolean;
     private readonly conf;
     /**
@@ -35,5 +34,4 @@ export declare class TursoQuerierPool extends AbstractHranaQuerierPool<TursoQuer
      */
     constructor(conf: TursoConfig | HranaClient, extra?: ExtraOptions);
     protected openClient(): Promise<HranaClient>;
-    protected buildQuerier(client: HranaClient): TursoQuerier;
 }

package/dist/turso/tursoQuerierPool.js

@@ -1,7 +1,6 @@
 import { dialectOptionsFrom } from '../dialect/abstractDialect.js';
 import { AbstractHranaQuerierPool } from '../sqlite/hranaQuerierPool.js';
 import { TursoDialect } from './tursoDialect.js';
-import { TursoQuerier } from './tursoQuerier.js';
 function isClient(conf) {
     return typeof conf.execute === 'function';
 }
@@ -33,7 +32,4 @@ export class TursoQuerierPool extends AbstractHranaQuerierPool {
         const { createClient } = await import('@tursodatabase/serverless/compat');
         return createClient(this.conf);
     }
-    buildQuerier(client) {
-        return new TursoQuerier(client, this.dialect, this.extra);
-    }
 }

package/dist/type/dialect.d.ts

@@ -59,7 +59,7 @@ export interface DriverCapabilities {
     readonly explicitJsonCast: boolean;
     /**
      * Whether the driver natively supports JS arrays for the underlying database type.
-     * `PgDialect` keeps this `true` for node-postgres; Bun SQL PostgreSQL uses `false` and
+     * `PgQuerierPool` keeps this `true` for node-postgres; `BunSqlQuerierPool` sets `false` and binds
      * `toPgArray` string literals instead.
      */
     readonly nativeArrays: boolean;

package/dist/util/dialect.util.d.ts

@@ -1,4 +1,4 @@
-import { type CascadeType, type EntityData, type EntityId, type EntityIndexMeta, type EntityMeta, type FieldKey, type FieldOptions, type JsonUpdateOp, type OnFieldCallback, type Query, type QueryAggMap, type QueryAggregateOp, type QueryExclude, type QueryGroupMap, type QueryOptions, QueryRaw, type QuerySearch, type QuerySelect, type QuerySelectValue, type QuerySizeComparisonOps, type QuerySortMap, type QueryVectorSearch, type QueryWhere, type RelationKey, type UpdatePayload } from '../type/index.js';
+import { type CascadeType, type EntityData, type EntityId, type EntityIndexMeta, type EntityMeta, type FieldKey, type FieldOptions, type JsonUpdateOp, type OnFieldCallback, type Query, type QueryAggMap, type QueryAggregateOp, type QueryExclude, type QueryGroupMap, type QueryOptions, QueryRaw, type QuerySearch, type QuerySelect, type QuerySelectValue, type QuerySizeComparisonOps, type QuerySortMap, type QueryTextSearchOptions, type QueryVectorSearch, type QueryWhere, type RelationKey, type UpdatePayload } from '../type/index.js';
 export type CallbackKey = keyof Pick<FieldOptions, 'onInsert' | 'onUpdate'>;
 export declare function filterFieldKeys<E>(meta: EntityMeta<E>, payload: EntityData<E>, callbackKey: CallbackKey): FieldKey<E>[];
 /** Appends `record`'s not-yet-`seen` insertable keys (real, caller-written, defined value) to `keys`. */
@@ -170,4 +170,10 @@ export declare function assertNonNegativeInteger(value: number, clause: string):
  */
 export declare function throwUnknownAggregateColumn(key: string, clause: string): never;
 /** {@link throwUnknownAggregateColumn} over every key of a clause, for backends that check up front. */
-export declare function assertAggregateColumns(clauseMap: object | undefined, emitted: ReadonlySet<string>, clause: string): void;
+export declare function assertAggregateColumns(clauseMap: object, emitted: ReadonlySet<string>, clause: string): void;
+/**
+ * The fields a `$text` searches: those it names, or else the columns of the entity's fulltext index,
+ * the declaration MySQL's `MATCH` has to name exactly and a MongoDB text index already is. Refused
+ * where neither says, rather than guessed: every engine answers a guess with an error of its own.
+ */
+export declare function textSearchFields<E>(meta: EntityMeta<E>, search: QueryTextSearchOptions<E>): readonly string[];

package/dist/util/dialect.util.js

@@ -418,9 +418,28 @@ export function throwUnknownAggregateColumn(key, clause) {
 }
 /** {@link throwUnknownAggregateColumn} over every key of a clause, for backends that check up front. */
 export function assertAggregateColumns(clauseMap, emitted, clause) {
-    for (const key of getKeys(clauseMap ?? {})) {
+    for (const key of getKeys(clauseMap)) {
         if (!emitted.has(key)) {
             throwUnknownAggregateColumn(key, clause);
         }
     }
 }
+/**
+ * The fields a `$text` searches: those it names, or else the columns of the entity's fulltext index,
+ * the declaration MySQL's `MATCH` has to name exactly and a MongoDB text index already is. Refused
+ * where neither says, rather than guessed: every engine answers a guess with an error of its own.
+ */
+export function textSearchFields(meta, search) {
+    if (search.$fields?.length) {
+        return search.$fields;
+    }
+    const fulltext = (meta.indexes ?? []).filter((index) => index.type === 'fulltext');
+    if (fulltext.length === 1) {
+        return fulltext[0].columns.map((entry) => entry.column);
+    }
+    const name = entityName(meta);
+    const declared = fulltext.length
+        ? `${fulltext.length} fulltext indexes to choose from`
+        : 'no fulltext index to search';
+    throw new TypeError(`$text on '${name}' names no $fields, and '${name}' declares ${declared}. Name them with $fields.`);
+}

package/dist/util/logger.d.ts

@@ -34,7 +34,7 @@ export declare class LoggerWrapper implements Logger {
     private readonly loggerFunction?;
     private readonly logValues;
     private readonly slowQuery?;
-    constructor(options: LoggingOptions, config?: LoggerWrapperConfig);
+    constructor(options?: LoggingOptions, config?: LoggerWrapperConfig);
     /** Whether `logQuery` would ever actually surface bound values, given the configured levels/slowQuery/logValues. */
     willLogValues(): boolean;
     logQuery(query: string, values?: unknown[], duration?: number): void;
@@ -46,6 +46,15 @@ export declare class LoggerWrapper implements Logger {
     logSkippedMigration(message: string): void;
     private log;
 }
+/**
+ * The wrapper a querier logs through, one per options object and read once: a pool builds a querier
+ * for every statement, and all of them log by the same options.
+ */
+export declare function queryLoggerFor(extra?: {
+    readonly logger?: LoggingOptions;
+    readonly logValues?: boolean;
+    readonly slowQuery?: number;
+}): LoggerWrapper;
 /**
  * Structural type for any EventEmitter-like connection pool that emits an
  * `'error'` event on a dropped connection (node-postgres, `mariadb`, etc.).
@@ -54,12 +63,11 @@ export interface ErrorEmittingPool {
     on(event: 'error', listener: (err: Error) => void): unknown;
 }
 /**
- * Attaches an error listener to a connection pool so a dropped connection is
- * logged instead of left unhandled - which crashes the process for drivers
- * that don't guard against it themselves (node-postgres), or silently
- * swallowed with zero visibility for drivers that already install their own
- * no-op safety net (`mariadb`'s `createPool`). Always logs via a dedicated
- * logger (ignoring the consumer's configured log level) since a silently
- * swallowed pool error is exactly the failure mode this guards against.
+ * Attaches an error listener to a connection pool so a dropped connection is logged instead of left
+ * unhandled - which crashes the process for drivers that don't guard against it themselves
+ * (node-postgres, `mssql`), or is silently swallowed by those that install a no-op of their own
+ * (`mariadb`). Reported through the pool's own logger when it has one, and through the default one
+ * otherwise: never dropped, whatever levels were configured, since a swallowed pool error is exactly
+ * the failure this guards against.
  */
-export declare function attachPoolErrorHandler(pool: ErrorEmittingPool, message: string): void;
+export declare function attachPoolErrorHandler(pool: ErrorEmittingPool, message: string, logging?: LoggingOptions): void;

package/dist/util/logger.js

@@ -7,18 +7,22 @@ const DEFAULT_LOG_LEVELS = [
     'migration',
     'skippedMigration',
 ];
+/** Bound values as JSON, a `bigint` by its digits: `JSON.stringify` refuses one outright. */
+function renderValues(values) {
+    return JSON.stringify(values, (_key, value) => (typeof value === 'bigint' ? value.toString() : value));
+}
 /**
  * Default implementation of the Logger interface using console methods.
  */
 export class DefaultLogger {
     logQuery(query, values, duration) {
         const time = duration !== undefined ? ` [${duration}ms]` : '';
-        const params = values?.length ? ` -- ${JSON.stringify(values)}` : '';
+        const params = values?.length ? ` -- ${renderValues(values)}` : '';
         console.log(`\x1b[36mquery:\x1b[0m ${query}${params}\x1b[32m${time}\x1b[0m`);
     }
     logSlowQuery(query, values, duration) {
         const time = duration !== undefined ? ` [${duration}ms]` : '';
-        const params = values?.length ? ` -- ${JSON.stringify(values)}` : '';
+        const params = values?.length ? ` -- ${renderValues(values)}` : '';
         console.warn(`\x1b[33mslow query:\x1b[0m ${query}${params}\x1b[31m${time}\x1b[0m`);
     }
     logWarn(message) {
@@ -132,18 +136,39 @@ export class LoggerWrapper {
         }
     }
 }
+const wrappersByOptions = new WeakMap();
+let unconfigured;
 /**
- * Attaches an error listener to a connection pool so a dropped connection is
- * logged instead of left unhandled - which crashes the process for drivers
- * that don't guard against it themselves (node-postgres), or silently
- * swallowed with zero visibility for drivers that already install their own
- * no-op safety net (`mariadb`'s `createPool`). Always logs via a dedicated
- * logger (ignoring the consumer's configured log level) since a silently
- * swallowed pool error is exactly the failure mode this guards against.
+ * The wrapper a querier logs through, one per options object and read once: a pool builds a querier
+ * for every statement, and all of them log by the same options.
  */
-export function attachPoolErrorHandler(pool, message) {
-    const logger = new LoggerWrapper(true);
+export function queryLoggerFor(extra) {
+    if (!extra) {
+        unconfigured ??= new LoggerWrapper();
+        return unconfigured;
+    }
+    let wrapper = wrappersByOptions.get(extra);
+    if (!wrapper) {
+        wrapper = new LoggerWrapper(extra.logger, { logValues: extra.logValues, slowQuery: extra.slowQuery });
+        wrappersByOptions.set(extra, wrapper);
+    }
+    return wrapper;
+}
+/**
+ * Attaches an error listener to a connection pool so a dropped connection is logged instead of left
+ * unhandled - which crashes the process for drivers that don't guard against it themselves
+ * (node-postgres, `mssql`), or is silently swallowed by those that install a no-op of their own
+ * (`mariadb`). Reported through the pool's own logger when it has one, and through the default one
+ * otherwise: never dropped, whatever levels were configured, since a swallowed pool error is exactly
+ * the failure this guards against.
+ */
+export function attachPoolErrorHandler(pool, message, logging) {
+    const logger = new LoggerWrapper(isOwnLogger(logging) ? logging : true);
     pool.on('error', (err) => {
         logger.logError(message, err);
     });
 }
+/** A logger the consumer wrote, as opposed to a switch or a level list for the default one. */
+function isOwnLogger(logging) {
+    return typeof logging === 'function' || (typeof logging === 'object' && !Array.isArray(logging));
+}

package/dist/util/object.util.d.ts

@@ -20,6 +20,8 @@ export declare function isOperatorObject(value: unknown): value is Record<string
 /** Whether every key of the non-empty object `value` is an operator (no plain field names mixed in). */
 export declare function isOperatorOnlyObject(value: unknown): value is Record<string, unknown>;
 export declare function getKeys<T extends object>(obj: T): (keyof T & string)[];
+/** The entries of `record` holding a value: a key declared but left `undefined` is no entry at all. */
+export declare function definedEntries<K extends string, V>(record: Partial<Record<K, V>>): [K, V][];
 /**
  * The entity's own name, declared or its class's. `meta.name` holds only what the author wrote, so
  * the fallback is what an entity that named no table is called - which is why the sites spelling this

package/dist/util/object.util.js

@@ -52,6 +52,10 @@ export function isOperatorOnlyObject(value) {
 export function getKeys(obj) {
     return obj ? Object.keys(obj) : [];
 }
+/** The entries of `record` holding a value: a key declared but left `undefined` is no entry at all. */
+export function definedEntries(record) {
+    return Object.entries(record).filter((entry) => entry[1] !== undefined);
+}
 /**
  * The entity's own name, declared or its class's. `meta.name` holds only what the author wrote, so
  * the fallback is what an entity that named no table is called - which is why the sites spelling this

package/dist/util/raw.js

@@ -7,11 +7,11 @@ export function raw(value, ...rest) {
     if (!rest.length) {
         // Nothing to bind, so this is the string form: keep it one, for the DDL paths that need to read
         // the expression back as text (an index expression cannot carry a parameter).
-        return new QueryRaw(value[0] ?? '');
+        return new QueryRaw(value[0]);
     }
     return new QueryRaw((opts) => {
         const { ctx } = opts;
-        ctx.append(value[0] ?? '');
+        ctx.append(value[0]);
         rest.forEach((interpolated, i) => {
             if (interpolated instanceof QueryRaw) {
                 interpolated.render(opts);
@@ -19,7 +19,7 @@ export function raw(value, ...rest) {
             else {
                 ctx.addValue(interpolated);
             }
-            ctx.append(value[i + 1] ?? '');
+            ctx.append(value[i + 1]);
         });
     });
 }

package/dist/util/relationQuery.util.d.ts

@@ -1,8 +1,8 @@
 import type { EntityMeta, FieldMeta, Except, Query, QueryPopulate, RelationKey, RelationMeta } from '../type/index.js';
 export type RelationRequestSummary<E> = {
-    readonly requestedKeys: RelationKey<E>[];
-    readonly joinableKeys: RelationKey<E>[];
-    readonly toManyKeys: RelationKey<E>[];
+    readonly requestedKeys: readonly RelationKey<E>[];
+    readonly joinableKeys: readonly RelationKey<E>[];
+    readonly toManyKeys: readonly RelationKey<E>[];
 };
 /**
  * Whether a relation holds many rows per parent, so it cannot be joined into the parent's row. Takes

package/dist/util/relationQuery.util.js

@@ -1,5 +1,11 @@
 import { QUERY_BOOLEAN_CLAUSES, QUERY_NUMBER_CLAUSES, QUERY_OBJECT_CLAUSES, QUERY_ROOT_NUMBER_CLAUSES, } from '../type/query.js';
 import { getKeys, someKey } from './object.util.js';
+/** What a query populating nothing requests, shared: most reads populate nothing, and ask on every one. */
+const NOTHING_REQUESTED = Object.freeze({
+    requestedKeys: Object.freeze([]),
+    joinableKeys: Object.freeze([]),
+    toManyKeys: Object.freeze([]),
+});
 /**
  * Whether a relation holds many rows per parent, so it cannot be joined into the parent's row. Takes
  * the one field it reads, so it answers for a relation being declared as well as for a resolved one.
@@ -142,11 +148,11 @@ function assertJoinableRelationQuery(relKey, value) {
     }
 }
 export function getRelationRequestSummary(meta, populate) {
+    if (!populate)
+        return NOTHING_REQUESTED;
     const requestedKeys = [];
     const joinableKeys = [];
     const toManyKeys = [];
-    if (!populate)
-        return { requestedKeys, joinableKeys, toManyKeys };
     for (const key of getKeys(populate)) {
         if (!populate[key])
             continue;

package/dist/util/sqlLiteral.js

@@ -33,9 +33,6 @@ const MYSQL_ESCAPES = {
 };
 const mysqlStringLiteral = (val) => `'${val.replace(MYSQL_SPECIALS, (char) => MYSQL_ESCAPES[char])}'`;
 const pad = (value, len) => String(value).padStart(len, '0');
-function isByteSource(val) {
-    return (typeof Buffer !== 'undefined' && Buffer.isBuffer(val)) || val instanceof Uint8Array;
-}
 const HEX_BYTES = Array.from({ length: 256 }, (_, byte) => byte.toString(16).padStart(2, '0'));
 /** Native hex encoder where available (~130x faster on 4 KB); lookup table for browsers. */
 function bytesToHexLiteral(bytes) {
@@ -72,7 +69,8 @@ function createEscaper(escapeString) {
         if (Array.isArray(value)) {
             return sqlList(value);
         }
-        if (isByteSource(value)) {
+        // A Node `Buffer` is a `Uint8Array` too.
+        if (value instanceof Uint8Array) {
             return bytesToHexLiteral(value);
         }
         if ('toSqlString' in value && typeof value.toSqlString === 'function') {
@@ -95,11 +93,8 @@ function createEscaper(escapeString) {
                 return escapeString(value);
             case 'object':
                 return escapeObject(value);
-            case 'symbol':
-            case 'function':
-                throw new TypeError('escapeSqlLiteral: symbol and function values are not supported; use bound parameters.');
             default:
-                // Unreachable today; throwing keeps a future JS type from silently becoming SQL.
+                // A symbol or a function, or a future JS type: none of them may silently become SQL.
                 throw new TypeError(`escapeSqlLiteral: unsupported value type '${typeof value}'; use bound parameters.`);
         }
     };

package/dist/util/string.util.js

@@ -6,14 +6,10 @@ export function kebabCase(val) {
     return resp;
 }
 export function upperFirst(text) {
-    if (!text)
-        return text;
-    return text[0].toUpperCase() + text.slice(1);
+    return text.charAt(0).toUpperCase() + text.slice(1);
 }
 export function lowerFirst(text) {
-    if (!text)
-        return text;
-    return text[0].toLowerCase() + text.slice(1);
+    return text.charAt(0).toLowerCase() + text.slice(1);
 }
 export function snakeCase(val) {
     if (val === null || val === undefined)

package/dist/util/wideNumber.d.ts

@@ -0,0 +1,14 @@
+import type { RawRow } from '../type/index.js';
+/**
+ * A wide number as a JS number where that number is exact, and as its exact decimal text where it is
+ * not - past 2^53, where a number silently rounds. The one rule every driver decodes a BIGINT by, and
+ * hydration a numeric column a driver handed back as text: never a wrong number. `type: BigInt` is the
+ * declared way to a typed exact integer.
+ */
+export declare function decodeWideNumber(value: string | bigint): number | string;
+/**
+ * {@link decodeWideNumber} over every `bigint` cell of a row, for the drivers that hand a BIGINT back
+ * as one (`bun:sql` with `bigint: true`, `mariadb`). In place: the row is the driver's fresh object, and
+ * a copy per row cost more than the decode it carried.
+ */
+export declare function decodeBigInts(row: RawRow): RawRow;

package/dist/util/wideNumber.js

@@ -0,0 +1,24 @@
+/**
+ * A wide number as a JS number where that number is exact, and as its exact decimal text where it is
+ * not - past 2^53, where a number silently rounds. The one rule every driver decodes a BIGINT by, and
+ * hydration a numeric column a driver handed back as text: never a wrong number. `type: BigInt` is the
+ * declared way to a typed exact integer.
+ */
+export function decodeWideNumber(value) {
+    const decoded = Number(value);
+    return Math.abs(decoded) <= Number.MAX_SAFE_INTEGER ? decoded : String(value);
+}
+/**
+ * {@link decodeWideNumber} over every `bigint` cell of a row, for the drivers that hand a BIGINT back
+ * as one (`bun:sql` with `bigint: true`, `mariadb`). In place: the row is the driver's fresh object, and
+ * a copy per row cost more than the decode it carried.
+ */
+export function decodeBigInts(row) {
+    for (const key in row) {
+        const value = row[key];
+        if (typeof value === 'bigint') {
+            row[key] = decodeWideNumber(value);
+        }
+    }
+    return row;
+}

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "The JSON-native TypeScript ORM for Bun, Browsers, Edge, Deno, Node, Workers. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, SQL Server, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.54.0",
+  "version": "0.56.0",
   "type": "module",
   "engines": {
     "node": ">=24"

package/dist/cockroachdb/crdbQuerier.d.ts

@@ -1,8 +0,0 @@
-import type { PoolClient } from 'pg';
-import { AbstractPgQuerier } from '../postgres/abstractPgQuerier.js';
-import type { CockroachDialect } from './cockroachDialect.js';
-/**
- * Querier for CockroachDB utilizing the standard `pg` PoolClient.
- */
-export declare class CrdbQuerier extends AbstractPgQuerier<PoolClient, CockroachDialect> {
-}

package/dist/cockroachdb/crdbQuerier.js

@@ -1,6 +0,0 @@
-import { AbstractPgQuerier } from '../postgres/abstractPgQuerier.js';
-/**
- * Querier for CockroachDB utilizing the standard `pg` PoolClient.
- */
-export class CrdbQuerier extends AbstractPgQuerier {
-}

package/dist/libsql/libsqlQuerier.d.ts

@@ -1,10 +0,0 @@
-import { HranaQuerier } from '../sqlite/hranaQuerier.js';
-/**
- * Querier for the `@libsql/client` driver.
- *
- * @remarks Empty subclass by design: that client speaks the Hrana protocol, so the whole
- * implementation is inherited. Kept as a distinct type for `LibsqlQuerierPool` and as a hook for
- * future libsql-specific behavior.
- */
-export declare class LibsqlQuerier extends HranaQuerier {
-}

package/dist/libsql/libsqlQuerier.js

@@ -1,10 +0,0 @@
-import { HranaQuerier } from '../sqlite/hranaQuerier.js';
-/**
- * Querier for the `@libsql/client` driver.
- *
- * @remarks Empty subclass by design: that client speaks the Hrana protocol, so the whole
- * implementation is inherited. Kept as a distinct type for `LibsqlQuerierPool` and as a hook for
- * future libsql-specific behavior.
- */
-export class LibsqlQuerier extends HranaQuerier {
-}

package/dist/mongo/mongodbNativeDialect.d.ts

@@ -1,9 +0,0 @@
-import { MongoDialect } from './mongoDialect.js';
-/**
- * MongoDB Dialect specialization for the official `mongodb` driver.
- *
- * @remarks Empty subclass by design: distinct type for `MongodbQuerierPool` and a hook
- * for future driver-specific behavior.
- */
-export declare class MongodbNativeDialect extends MongoDialect {
-}

package/dist/mongo/mongodbNativeDialect.js

@@ -1,9 +0,0 @@
-import { MongoDialect } from './mongoDialect.js';
-/**
- * MongoDB Dialect specialization for the official `mongodb` driver.
- *
- * @remarks Empty subclass by design: distinct type for `MongodbQuerierPool` and a hook
- * for future driver-specific behavior.
- */
-export class MongodbNativeDialect extends MongoDialect {
-}

package/dist/mysql/mysql2Dialect.d.ts

@@ -1,9 +0,0 @@
-import { MySqlDialect } from './mysqlDialect.js';
-/**
- * MySQL Dialect specialization for the `mysql2` driver.
- *
- * @remarks Empty subclass by design: distinct type for `Mysql2QuerierPool` and a place
- * for future mysql2-specific query or capability overrides.
- */
-export declare class MySql2Dialect extends MySqlDialect {
-}

package/dist/mysql/mysql2Dialect.js

@@ -1,9 +0,0 @@
-import { MySqlDialect } from './mysqlDialect.js';
-/**
- * MySQL Dialect specialization for the `mysql2` driver.
- *
- * @remarks Empty subclass by design: distinct type for `Mysql2QuerierPool` and a place
- * for future mysql2-specific query or capability overrides.
- */
-export class MySql2Dialect extends MySqlDialect {
-}

package/dist/neon/neonDialect.d.ts

@@ -1,10 +0,0 @@
-import { PostgresDialect } from '../postgres/postgresDialect.js';
-/**
- * Postgres dialect marker for the `@neondatabase/serverless` driver.
- *
- * @remarks Extends {@link PostgresDialect} with identical defaults (`explicitJsonCast: false`,
- * `nativeArrays: true`, etc.). Kept as a distinct class for `NeonQuerierPool` typing and for
- * Neon-only capability tweaks later without affecting `pg` or Bun pools.
- */
-export declare class NeonDialect extends PostgresDialect {
-}

package/dist/neon/neonDialect.js

@@ -1,10 +0,0 @@
-import { PostgresDialect } from '../postgres/postgresDialect.js';
-/**
- * Postgres dialect marker for the `@neondatabase/serverless` driver.
- *
- * @remarks Extends {@link PostgresDialect} with identical defaults (`explicitJsonCast: false`,
- * `nativeArrays: true`, etc.). Kept as a distinct class for `NeonQuerierPool` typing and for
- * Neon-only capability tweaks later without affecting `pg` or Bun pools.
- */
-export class NeonDialect extends PostgresDialect {
-}

package/dist/neon/neonQuerier.d.ts

@@ -1,5 +0,0 @@
-import type { PoolClient } from '@neondatabase/serverless';
-import { AbstractPgQuerier } from '../postgres/abstractPgQuerier.js';
-import type { PostgresDialect } from '../postgres/postgresDialect.js';
-export declare class NeonQuerier extends AbstractPgQuerier<PoolClient, PostgresDialect> {
-}

package/dist/neon/neonQuerier.js

@@ -1,3 +0,0 @@
-import { AbstractPgQuerier } from '../postgres/abstractPgQuerier.js';
-export class NeonQuerier extends AbstractPgQuerier {
-}

package/dist/pglite/pgliteDialect.d.ts

@@ -1,14 +0,0 @@
-import { PostgresDialect } from '../postgres/postgresDialect.js';
-/**
- * Postgres dialect for PGlite, the WASM Postgres build.
- *
- * @remarks Keeps every {@link PostgresDialect} default, `dialectName` included: PGlite *is* Postgres,
- * so the introspector, schema generator and CLI must all resolve to the Postgres ones. Both driver
- * capabilities are inherited deliberately rather than by omission. `nativeArrays: true` holds because
- * PGlite registers an array serializer for every built-in array type at boot and resolves each
- * parameter's type from a server-side `Describe` before binding; `explicitJsonCast: false` holds
- * because `PgLikeSqlDialect` already emits `$n::jsonb`, which is what makes that `Describe` report
- * JSONB and select PGlite's `JSON.stringify` serializer. A bare `$n` would bind `[object Object]`.
- */
-export declare class PgliteDialect extends PostgresDialect {
-}

package/dist/pglite/pgliteDialect.js

@@ -1,14 +0,0 @@
-import { PostgresDialect } from '../postgres/postgresDialect.js';
-/**
- * Postgres dialect for PGlite, the WASM Postgres build.
- *
- * @remarks Keeps every {@link PostgresDialect} default, `dialectName` included: PGlite *is* Postgres,
- * so the introspector, schema generator and CLI must all resolve to the Postgres ones. Both driver
- * capabilities are inherited deliberately rather than by omission. `nativeArrays: true` holds because
- * PGlite registers an array serializer for every built-in array type at boot and resolves each
- * parameter's type from a server-side `Describe` before binding; `explicitJsonCast: false` holds
- * because `PgLikeSqlDialect` already emits `$n::jsonb`, which is what makes that `Describe` report
- * JSONB and select PGlite's `JSON.stringify` serializer. A bare `$n` would bind `[object Object]`.
- */
-export class PgliteDialect extends PostgresDialect {
-}

package/dist/postgres/abstractPgQuerier.d.ts

@@ -1,24 +0,0 @@
-import type { AbstractSqlDialect } from '../dialect/index.js';
-import { AbstractPoolQuerier } from '../querier/abstractPoolQuerier.js';
-import type { ExtraOptions, RawRow } from '../type/index.js';
-export interface PgAnyClient {
-    query(text: string, values?: unknown[]): Promise<{
-        rows: RawRow[];
-        rowCount: number | null;
-    }>;
-    query(stream: object): AsyncIterable<RawRow> & {
-        destroy(): void;
-    };
-    /** Any truthy argument makes `pg-pool` evict the client instead of returning it to the idle list. */
-    release(discard?: boolean): void | Promise<void>;
-}
-/**
- * Shared base class for Postgres-compatible queriers (standard pg, CockroachDB, Neon).
- */
-export declare abstract class AbstractPgQuerier<C extends PgAnyClient, D extends AbstractSqlDialect> extends AbstractPoolQuerier<C> {
-    constructor(connect: () => Promise<C>, dialect: D, extra?: ExtraOptions);
-    internalAll<T>(query: string, values?: unknown[]): Promise<T[]>;
-    internalRun(query: string, values?: unknown[]): Promise<import("../type/query.js").QueryUpdateResult>;
-    internalStream<T>(query: string, values?: unknown[]): AsyncGenerator<Awaited<T>, void, unknown>;
-    protected releaseConn(conn: C, discard: boolean): Promise<void>;
-}

package/dist/postgres/abstractPgQuerier.js

@@ -1,32 +0,0 @@
-import { AbstractPoolQuerier } from '../querier/abstractPoolQuerier.js';
-/**
- * Shared base class for Postgres-compatible queriers (standard pg, CockroachDB, Neon).
- */
-export class AbstractPgQuerier extends AbstractPoolQuerier {
-    constructor(connect, dialect, extra) {
-        super(dialect, connect, extra);
-    }
-    async internalAll(query, values) {
-        const res = await this.getConn().query(query, values);
-        return res.rows;
-    }
-    async internalRun(query, values) {
-        const res = await this.getConn().query(query, values);
-        return this.buildUpdateResult({ rows: res.rows, changes: res.rowCount ?? 0 });
-    }
-    async *internalStream(query, values) {
-        const { default: QueryStream } = await import('pg-query-stream');
-        const stream = this.getConn().query(new QueryStream(query, values));
-        try {
-            for await (const row of stream) {
-                yield row;
-            }
-        }
-        finally {
-            stream.destroy();
-        }
-    }
-    async releaseConn(conn, discard) {
-        await conn.release(discard);
-    }
-}