uql-orm 0.54.0 → 0.55.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

@@ -170,4 +170,4 @@ 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;

package/dist/util/dialect.util.js

@@ -418,7 +418,7 @@ 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);
         }

package/dist/util/logger.d.ts

@@ -54,12 +54,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) {
@@ -133,17 +137,20 @@ export class LoggerWrapper {
     }
 }
 /**
- * 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 function attachPoolErrorHandler(pool, message) {
-    const logger = new LoggerWrapper(true);
+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/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/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.55.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);
-    }
-}

package/dist/postgres/pgDialect.d.ts

@@ -1,10 +0,0 @@
-import { PostgresDialect } from './postgresDialect.js';
-/**
- * Postgres dialect for the Node.js `pg` driver.
- *
- * @remarks Uses base {@link PostgresDialect} capabilities: native JS arrays for `ANY` / `ALL`
- * (`nativeArrays: true`) and `$n::jsonb` without a text re-cast. Bun SQL Postgres needs
- * `BunSqlQuerierPool` from `uql-orm/bunSql` instead (wire array literals + text json cast).
- */
-export declare class PgDialect extends PostgresDialect {
-}

package/dist/postgres/pgDialect.js

@@ -1,10 +0,0 @@
-import { PostgresDialect } from './postgresDialect.js';
-/**
- * Postgres dialect for the Node.js `pg` driver.
- *
- * @remarks Uses base {@link PostgresDialect} capabilities: native JS arrays for `ANY` / `ALL`
- * (`nativeArrays: true`) and `$n::jsonb` without a text re-cast. Bun SQL Postgres needs
- * `BunSqlQuerierPool` from `uql-orm/bunSql` instead (wire array literals + text json cast).
- */
-export class PgDialect extends PostgresDialect {
-}

package/dist/turso/tursoQuerier.d.ts

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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 {
-}