firebird-wasm 0.9.0 → 0.10.1

package/dist/drizzle/index.js

@@ -0,0 +1,627 @@
+"use strict";
+/**
+ * firebird-wasm/drizzle – a Drizzle ORM driver & dialect for `FirebirdBrowser`
+ * and `FirebirdLite`.
+ *
+ * ```ts
+ * import {
+ *   drizzle,
+ *   firebirdTable,
+ *   integer,
+ *   varchar,
+ *   boolean,
+ *   eq,
+ * } from 'firebird-wasm/drizzle';
+ *
+ * const items = firebirdTable('items', {
+ *   id: integer('id').primaryKey(),
+ *   title: varchar('title', { length: 80 }).notNull(),
+ *   done: boolean('done').default(false),
+ * });
+ *
+ * const db = drizzle(fb, { schema: { items } });
+ *
+ * await db.insert(items).values({ id: 1, title: 'Ship Drizzle driver', done: false });
+ * const open = await db.select().from(items).where(eq(items.done, false)).limit(10).offset(0);
+ * ```
+ *
+ * Translates Drizzle's SQL AST to Firebird 3+ SQL:
+ * - `?` positional parameter placeholders;
+ * - `OFFSET ? ROWS FETCH NEXT ? ROWS ONLY` pagination;
+ * - `INSERT / UPDATE / DELETE … RETURNING` (decoded positionally via `rowMode: 'array'`);
+ * - multi-row `INSERT INTO … SELECT … FROM RDB$DATABASE UNION ALL …`;
+ * - `UPDATE OR INSERT INTO … MATCHING (…)` on `.onConflictDoUpdate({ target })`;
+ * - `db.$count(table, where)` with quoted `"COUNT"` alias;
+ * - `db.transaction()` mapped onto Firebird isolation levels, plus nested savepoints;
+ * - bijective identifier folding (`items` ↔ `"ITEMS"`, while `"camelCase"` stays `"camelCase"`).
+ */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _a, _FirebirdDrizzlePreparedQuery_client, _FirebirdDrizzlePreparedQuery_queryString, _FirebirdDrizzlePreparedQuery_params, _FirebirdDrizzlePreparedQuery_logger, _FirebirdDrizzlePreparedQuery_fields, _FirebirdDrizzlePreparedQuery_isResponseInArrayMode, _FirebirdDrizzlePreparedQuery_customResultMapper, _FirebirdDrizzlePreparedQuery_queryMetadata, _FirebirdDrizzlePreparedQuery_identifierCase, _b, _FirebirdDrizzleSession_client, _FirebirdDrizzleSession_dialect, _FirebirdDrizzleSession_schema, _FirebirdDrizzleSession_options, _FirebirdDrizzleSession_logger, _FirebirdDrizzleSession_identifierCase, _c, _FirebirdDrizzleTransaction_txDialect, _FirebirdDrizzleTransaction_txSession, _d, _e;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirebirdDrizzleTransaction = exports.FirebirdDrizzleSession = exports.FirebirdDrizzlePreparedQuery = exports.FirebirdDrizzleDialect = exports.relations = exports.max = exports.min = exports.avg = exports.sum = exports.count = exports.desc = exports.asc = exports.between = exports.ilike = exports.like = exports.isNotNull = exports.isNull = exports.notInArray = exports.inArray = exports.not = exports.or = exports.and = exports.lte = exports.lt = exports.gte = exports.gt = exports.ne = exports.eq = exports.sql = exports.customType = exports.uuid = exports.jsonb = exports.json = exports.timestamp = exports.time = exports.date = exports.numeric = exports.doublePrecision = exports.real = exports.boolean = exports.char = exports.varchar = exports.text = exports.bigserial = exports.serial = exports.bigint = exports.smallint = exports.integer = exports.firebirdTable = exports.pgTable = void 0;
+exports.FirebirdDrizzleDatabase = void 0;
+exports.drizzle = drizzle;
+const drizzle_orm_1 = require("drizzle-orm");
+const pg_core_1 = require("drizzle-orm/pg-core");
+Object.defineProperty(exports, "bigint", { enumerable: true, get: function () { return pg_core_1.bigint; } });
+Object.defineProperty(exports, "bigserial", { enumerable: true, get: function () { return pg_core_1.bigserial; } });
+Object.defineProperty(exports, "boolean", { enumerable: true, get: function () { return pg_core_1.boolean; } });
+Object.defineProperty(exports, "char", { enumerable: true, get: function () { return pg_core_1.char; } });
+Object.defineProperty(exports, "customType", { enumerable: true, get: function () { return pg_core_1.customType; } });
+Object.defineProperty(exports, "date", { enumerable: true, get: function () { return pg_core_1.date; } });
+Object.defineProperty(exports, "doublePrecision", { enumerable: true, get: function () { return pg_core_1.doublePrecision; } });
+Object.defineProperty(exports, "integer", { enumerable: true, get: function () { return pg_core_1.integer; } });
+Object.defineProperty(exports, "json", { enumerable: true, get: function () { return pg_core_1.json; } });
+Object.defineProperty(exports, "jsonb", { enumerable: true, get: function () { return pg_core_1.jsonb; } });
+Object.defineProperty(exports, "numeric", { enumerable: true, get: function () { return pg_core_1.numeric; } });
+Object.defineProperty(exports, "pgTable", { enumerable: true, get: function () { return pg_core_1.pgTable; } });
+Object.defineProperty(exports, "firebirdTable", { enumerable: true, get: function () { return pg_core_1.pgTable; } });
+Object.defineProperty(exports, "real", { enumerable: true, get: function () { return pg_core_1.real; } });
+Object.defineProperty(exports, "serial", { enumerable: true, get: function () { return pg_core_1.serial; } });
+Object.defineProperty(exports, "smallint", { enumerable: true, get: function () { return pg_core_1.smallint; } });
+Object.defineProperty(exports, "text", { enumerable: true, get: function () { return pg_core_1.text; } });
+Object.defineProperty(exports, "time", { enumerable: true, get: function () { return pg_core_1.time; } });
+Object.defineProperty(exports, "timestamp", { enumerable: true, get: function () { return pg_core_1.timestamp; } });
+Object.defineProperty(exports, "uuid", { enumerable: true, get: function () { return pg_core_1.uuid; } });
+Object.defineProperty(exports, "varchar", { enumerable: true, get: function () { return pg_core_1.varchar; } });
+const kysely_1 = require("../kysely");
+var drizzle_orm_2 = require("drizzle-orm");
+Object.defineProperty(exports, "sql", { enumerable: true, get: function () { return drizzle_orm_2.sql; } });
+Object.defineProperty(exports, "eq", { enumerable: true, get: function () { return drizzle_orm_2.eq; } });
+Object.defineProperty(exports, "ne", { enumerable: true, get: function () { return drizzle_orm_2.ne; } });
+Object.defineProperty(exports, "gt", { enumerable: true, get: function () { return drizzle_orm_2.gt; } });
+Object.defineProperty(exports, "gte", { enumerable: true, get: function () { return drizzle_orm_2.gte; } });
+Object.defineProperty(exports, "lt", { enumerable: true, get: function () { return drizzle_orm_2.lt; } });
+Object.defineProperty(exports, "lte", { enumerable: true, get: function () { return drizzle_orm_2.lte; } });
+Object.defineProperty(exports, "and", { enumerable: true, get: function () { return drizzle_orm_2.and; } });
+Object.defineProperty(exports, "or", { enumerable: true, get: function () { return drizzle_orm_2.or; } });
+Object.defineProperty(exports, "not", { enumerable: true, get: function () { return drizzle_orm_2.not; } });
+Object.defineProperty(exports, "inArray", { enumerable: true, get: function () { return drizzle_orm_2.inArray; } });
+Object.defineProperty(exports, "notInArray", { enumerable: true, get: function () { return drizzle_orm_2.notInArray; } });
+Object.defineProperty(exports, "isNull", { enumerable: true, get: function () { return drizzle_orm_2.isNull; } });
+Object.defineProperty(exports, "isNotNull", { enumerable: true, get: function () { return drizzle_orm_2.isNotNull; } });
+Object.defineProperty(exports, "like", { enumerable: true, get: function () { return drizzle_orm_2.like; } });
+Object.defineProperty(exports, "ilike", { enumerable: true, get: function () { return drizzle_orm_2.ilike; } });
+Object.defineProperty(exports, "between", { enumerable: true, get: function () { return drizzle_orm_2.between; } });
+Object.defineProperty(exports, "asc", { enumerable: true, get: function () { return drizzle_orm_2.asc; } });
+Object.defineProperty(exports, "desc", { enumerable: true, get: function () { return drizzle_orm_2.desc; } });
+Object.defineProperty(exports, "count", { enumerable: true, get: function () { return drizzle_orm_2.count; } });
+Object.defineProperty(exports, "sum", { enumerable: true, get: function () { return drizzle_orm_2.sum; } });
+Object.defineProperty(exports, "avg", { enumerable: true, get: function () { return drizzle_orm_2.avg; } });
+Object.defineProperty(exports, "min", { enumerable: true, get: function () { return drizzle_orm_2.min; } });
+Object.defineProperty(exports, "max", { enumerable: true, get: function () { return drizzle_orm_2.max; } });
+Object.defineProperty(exports, "relations", { enumerable: true, get: function () { return drizzle_orm_2.relations; } });
+/**
+ * Drizzle SQL dialect for Firebird 3+.
+ *
+ * Extends `PgDialect` (since both dialects share standard SQL quoting, `RETURNING`,
+ * CTEs, window functions, and positional `rowMode: 'array'` result mapping) while
+ * emitting `?` parameter placeholders, `OFFSET ? ROWS FETCH NEXT ? ROWS ONLY`,
+ * multi-row `INSERT INTO … SELECT … FROM RDB$DATABASE UNION ALL …`, and
+ * `UPDATE OR INSERT INTO … MATCHING (…)`.
+ */
+class FirebirdDrizzleDialect extends pg_core_1.PgDialect {
+    constructor(config) {
+        super(config);
+        this.identifierCase = config?.identifierCase ?? 'lower';
+        this.escapeName = this.escapeName.bind(this);
+        this.escapeParam = this.escapeParam.bind(this);
+    }
+    escapeName(name) {
+        const mapped = this.identifierCase === 'lower' && /^[a-z_][a-z0-9_$]*$/.test(name)
+            ? name.toUpperCase()
+            : name;
+        return `"${mapped.replace(/"/g, '""')}"`;
+    }
+    escapeParam(_num) {
+        return '?';
+    }
+    buildSelectQuery(config) {
+        const { limit, offset, lockingClause, setOperators } = config;
+        const hasLimit = typeof limit === 'object' || (typeof limit === 'number' && limit >= 0);
+        const hasOffset = offset !== undefined;
+        if (!hasLimit && !hasOffset) {
+            return super.buildSelectQuery(config);
+        }
+        const base = super.buildSelectQuery({
+            ...config,
+            limit: undefined,
+            offset: undefined,
+            lockingClause: undefined,
+            setOperators: [],
+        });
+        // Firebird SQL:2008 order: OFFSET <n> ROWS FETCH NEXT <m> ROWS ONLY
+        if (hasOffset) {
+            base.append((0, drizzle_orm_1.sql) ` offset ${offset} rows`);
+        }
+        if (hasLimit) {
+            base.append((0, drizzle_orm_1.sql) ` fetch next ${limit} rows only`);
+        }
+        if (lockingClause) {
+            base.append((0, drizzle_orm_1.sql) ` for ${drizzle_orm_1.sql.raw(lockingClause.strength)}`);
+            if (lockingClause.config.noWait) {
+                base.append((0, drizzle_orm_1.sql) ` with lock`);
+            }
+        }
+        if (setOperators.length > 0) {
+            return this.buildSetOperations(base, setOperators);
+        }
+        return base;
+    }
+    buildSetOperationQuery({ leftSelect, setOperator, }) {
+        const { limit, offset } = setOperator;
+        const hasLimit = typeof limit === 'object' || (typeof limit === 'number' && limit >= 0);
+        const hasOffset = offset !== undefined;
+        if (!hasLimit && !hasOffset) {
+            return super.buildSetOperationQuery({ leftSelect, setOperator });
+        }
+        const base = super.buildSetOperationQuery({
+            leftSelect,
+            setOperator: { ...setOperator, limit: undefined, offset: undefined },
+        });
+        if (hasOffset) {
+            base.append((0, drizzle_orm_1.sql) ` offset ${offset} rows`);
+        }
+        if (hasLimit) {
+            base.append((0, drizzle_orm_1.sql) ` fetch next ${limit} rows only`);
+        }
+        return base;
+    }
+    buildInsertQuery({ table, values: valuesOrSelect, onConflict, returning, withList, select, overridingSystemValue_, }) {
+        if (select) {
+            return super.buildInsertQuery({
+                table,
+                values: valuesOrSelect,
+                onConflict,
+                returning,
+                withList,
+                select,
+                overridingSystemValue_,
+            });
+        }
+        const columns = (0, drizzle_orm_1.getTableColumns)(table);
+        const allEntries = Object.entries(columns).filter(([, col]) => !col
+            .shouldDisableInsert?.());
+        const values = valuesOrSelect;
+        // Keep only columns that are explicitly supplied in `values` or have a runtime
+        // `defaultFn` / `onUpdateFn`. This lets omitted identity / default columns use
+        // Firebird's column defaults cleanly in both single-row and multi-row inserts.
+        const activeEntries = allEntries.filter(([fieldName, col]) => {
+            if (col.defaultFn !== undefined)
+                return true;
+            if (!col.default && col.onUpdateFn !== undefined)
+                return true;
+            return values.some((row) => {
+                const v = row[fieldName];
+                return v !== undefined && !((0, drizzle_orm_1.is)(v, drizzle_orm_1.Param) && v.value === undefined);
+            });
+        });
+        const internal = this;
+        const withSql = internal.buildWithCTE(withList);
+        const returningSql = returning
+            ? (0, drizzle_orm_1.sql) ` returning ${internal.buildSelection(returning, { isSingleTable: true })}`
+            : undefined;
+        if (activeEntries.length === 0) {
+            return (0, drizzle_orm_1.sql) `${withSql}insert into ${table} default values${returningSql}`;
+        }
+        const insertOrder = activeEntries.map(([, column]) => drizzle_orm_1.sql.identifier(internal.casing.getColumnCasing(column)));
+        const resolveCell = (row, fieldName, col) => {
+            const colValue = row[fieldName];
+            if (colValue === undefined ||
+                ((0, drizzle_orm_1.is)(colValue, drizzle_orm_1.Param) && colValue.value === undefined)) {
+                if (col.defaultFn !== undefined) {
+                    const fnRes = col.defaultFn();
+                    return (0, drizzle_orm_1.is)(fnRes, drizzle_orm_1.SQL) ? fnRes : drizzle_orm_1.sql.param(fnRes, col);
+                }
+                if (!col.default && col.onUpdateFn !== undefined) {
+                    const fnRes = col.onUpdateFn();
+                    return (0, drizzle_orm_1.is)(fnRes, drizzle_orm_1.SQL) ? fnRes : drizzle_orm_1.sql.param(fnRes, col);
+                }
+                return drizzle_orm_1.sql.param(null, col);
+            }
+            return colValue;
+        };
+        // Check if onConflict is an upsert (`(<cols>) ... do update set ...`)
+        if (onConflict) {
+            const conflictQuery = this.sqlToQuery(onConflict);
+            const match = /^\(([^)]+)\)\s+do\s+update\s+set\b/i.exec(conflictQuery.sql.trim());
+            if (match && values.length === 1) {
+                const targetCols = match[1];
+                const rowCells = activeEntries.map(([fieldName, col]) => resolveCell(values[0], fieldName, col));
+                return (0, drizzle_orm_1.sql) `${withSql}update or insert into ${table} ${insertOrder} values (${drizzle_orm_1.sql.join(rowCells, (0, drizzle_orm_1.sql) `, `)}) matching (${drizzle_orm_1.sql.raw(targetCols)})${returningSql}`;
+            }
+        }
+        const overridingSql = overridingSystemValue_ === true ? (0, drizzle_orm_1.sql) `overriding system value ` : undefined;
+        if (values.length === 1) {
+            const rowCells = activeEntries.map(([fieldName, col]) => resolveCell(values[0], fieldName, col));
+            const onConflictSql = onConflict ? (0, drizzle_orm_1.sql) ` on conflict ${onConflict}` : undefined;
+            return (0, drizzle_orm_1.sql) `${withSql}insert into ${table} ${insertOrder} ${overridingSql}values (${drizzle_orm_1.sql.join(rowCells, (0, drizzle_orm_1.sql) `, `)})${onConflictSql}${returningSql}`;
+        }
+        // Multi-row insert via SELECT ... FROM RDB$DATABASE UNION ALL ...
+        const selects = values.map((row) => {
+            const rowCells = activeEntries.map(([fieldName, col]) => resolveCell(row, fieldName, col));
+            return (0, drizzle_orm_1.sql) `select ${drizzle_orm_1.sql.join(rowCells, (0, drizzle_orm_1.sql) `, `)} from rdb$database`;
+        });
+        return (0, drizzle_orm_1.sql) `${withSql}insert into ${table} ${insertOrder} ${overridingSql}${drizzle_orm_1.sql.join(selects, (0, drizzle_orm_1.sql) ` union all `)}${returningSql}`;
+    }
+    sqlToQuery(sqlNode, invokeSource) {
+        const query = super.sqlToQuery(sqlNode, invokeSource);
+        // PgCountBuilder generates `select count(*) as count from ...;`.
+        // In Firebird, COUNT is a reserved word and must be quoted as an alias.
+        if (/^select count\(\*\) as count from /i.test(query.sql)) {
+            query.sql = query.sql
+                .replace(/^select count\(\*\) as count from /i, 'select count(*) as "COUNT" from ')
+                .replace(/;\s*$/, '');
+        }
+        return query;
+    }
+}
+exports.FirebirdDrizzleDialect = FirebirdDrizzleDialect;
+_a = drizzle_orm_1.entityKind;
+FirebirdDrizzleDialect[_a] = 'FirebirdDrizzleDialect';
+/**
+ * Prepared query execution against `FirebirdBrowser` or `FirebirdLite`.
+ */
+class FirebirdDrizzlePreparedQuery extends pg_core_1.PgPreparedQuery {
+    constructor(client, queryString, params, logger, fields, isResponseInArrayMode, customResultMapper, queryMetadata, identifierCase) {
+        super({ sql: queryString, params }, undefined, queryMetadata, undefined);
+        _FirebirdDrizzlePreparedQuery_client.set(this, void 0);
+        _FirebirdDrizzlePreparedQuery_queryString.set(this, void 0);
+        _FirebirdDrizzlePreparedQuery_params.set(this, void 0);
+        _FirebirdDrizzlePreparedQuery_logger.set(this, void 0);
+        _FirebirdDrizzlePreparedQuery_fields.set(this, void 0);
+        _FirebirdDrizzlePreparedQuery_isResponseInArrayMode.set(this, void 0);
+        _FirebirdDrizzlePreparedQuery_customResultMapper.set(this, void 0);
+        _FirebirdDrizzlePreparedQuery_queryMetadata.set(this, void 0);
+        _FirebirdDrizzlePreparedQuery_identifierCase.set(this, void 0);
+        __classPrivateFieldSet(this, _FirebirdDrizzlePreparedQuery_client, client, "f");
+        __classPrivateFieldSet(this, _FirebirdDrizzlePreparedQuery_queryString, queryString, "f");
+        __classPrivateFieldSet(this, _FirebirdDrizzlePreparedQuery_params, params, "f");
+        __classPrivateFieldSet(this, _FirebirdDrizzlePreparedQuery_logger, logger, "f");
+        __classPrivateFieldSet(this, _FirebirdDrizzlePreparedQuery_fields, fields, "f");
+        __classPrivateFieldSet(this, _FirebirdDrizzlePreparedQuery_isResponseInArrayMode, isResponseInArrayMode, "f");
+        __classPrivateFieldSet(this, _FirebirdDrizzlePreparedQuery_customResultMapper, customResultMapper, "f");
+        __classPrivateFieldSet(this, _FirebirdDrizzlePreparedQuery_queryMetadata, queryMetadata, "f");
+        __classPrivateFieldSet(this, _FirebirdDrizzlePreparedQuery_identifierCase, identifierCase, "f");
+    }
+    async execute(placeholderValues = {}) {
+        const params = normalizeParams((0, drizzle_orm_1.fillPlaceholders)(__classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_params, "f"), placeholderValues));
+        __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_logger, "f").logQuery(__classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_queryString, "f"), params);
+        const multiInsert = (0, kysely_1.parseMultiRowInsert)(__classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_queryString, "f"), params);
+        const fields = __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_fields, "f");
+        const customResultMapper = __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_customResultMapper, "f");
+        const joinsNotNullableMap = this.joinsNotNullableMap;
+        if (!fields && !customResultMapper) {
+            const isDmlWithoutReturning = __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_queryMetadata, "f")?.type === 'insert' ||
+                __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_queryMetadata, "f")?.type === 'update' ||
+                __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_queryMetadata, "f")?.type === 'delete' ||
+                (/^\s*(insert|update|delete|create|alter|drop|recreate)\b/i.test(__classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_queryString, "f")) &&
+                    !/\breturning\b/i.test(__classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_queryString, "f")));
+            if (isDmlWithoutReturning) {
+                if (multiInsert && typeof __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_client, "f").execBatch === 'function') {
+                    if (multiInsert.uniformSql) {
+                        const res = await __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_client, "f").execBatch(multiInsert.uniformSql, multiInsert.rows.map((r) => r.params));
+                        return {
+                            rows: [],
+                            fields: [],
+                            affectedRows: extractAffectedRows(res) ?? multiInsert.rows.length,
+                        };
+                    }
+                    for (const row of multiInsert.rows) {
+                        await __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_client, "f").exec(row.sql, row.params);
+                    }
+                    return {
+                        rows: [],
+                        fields: [],
+                        affectedRows: multiInsert.rows.length,
+                    };
+                }
+                const res = await __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_client, "f").exec(__classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_queryString, "f"), params);
+                return {
+                    rows: [],
+                    fields: [],
+                    affectedRows: extractAffectedRows(res),
+                };
+            }
+            const raw = await __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_client, "f").query(__classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_queryString, "f"), params, { rowMode: 'object' });
+            return {
+                rows: mapObjectRows(raw.rows, __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_identifierCase, "f")),
+                fields: raw.fields,
+            };
+        }
+        let resultRows;
+        if (multiInsert && multiInsert.hasReturning && typeof __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_client, "f").execBatch === 'function') {
+            resultRows = [];
+            for (const row of multiInsert.rows) {
+                const res = await __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_client, "f").query(row.sql, row.params, {
+                    rowMode: 'array',
+                });
+                resultRows.push(...res.rows);
+            }
+        }
+        else {
+            const result = await __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_client, "f").query(__classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_queryString, "f"), params, {
+                rowMode: 'array',
+            });
+            resultRows = result.rows;
+        }
+        if (customResultMapper) {
+            return customResultMapper(resultRows);
+        }
+        return resultRows.map((row) => mapDrizzleResultRow(fields, row, joinsNotNullableMap));
+    }
+    async all(placeholderValues = {}) {
+        const params = normalizeParams((0, drizzle_orm_1.fillPlaceholders)(__classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_params, "f"), placeholderValues));
+        __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_logger, "f").logQuery(__classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_queryString, "f"), params);
+        const result = await __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_client, "f").query(__classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_queryString, "f"), params, { rowMode: 'object' });
+        return mapObjectRows(result.rows, __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_identifierCase, "f"));
+    }
+    /** @internal */
+    isResponseInArrayMode() {
+        return __classPrivateFieldGet(this, _FirebirdDrizzlePreparedQuery_isResponseInArrayMode, "f");
+    }
+}
+exports.FirebirdDrizzlePreparedQuery = FirebirdDrizzlePreparedQuery;
+_FirebirdDrizzlePreparedQuery_client = new WeakMap(), _FirebirdDrizzlePreparedQuery_queryString = new WeakMap(), _FirebirdDrizzlePreparedQuery_params = new WeakMap(), _FirebirdDrizzlePreparedQuery_logger = new WeakMap(), _FirebirdDrizzlePreparedQuery_fields = new WeakMap(), _FirebirdDrizzlePreparedQuery_isResponseInArrayMode = new WeakMap(), _FirebirdDrizzlePreparedQuery_customResultMapper = new WeakMap(), _FirebirdDrizzlePreparedQuery_queryMetadata = new WeakMap(), _FirebirdDrizzlePreparedQuery_identifierCase = new WeakMap(), _b = drizzle_orm_1.entityKind;
+FirebirdDrizzlePreparedQuery[_b] = 'FirebirdDrizzlePreparedQuery';
+/**
+ * Drizzle session wrapping a `FirebirdBrowser`, `FirebirdLite`, or active transaction.
+ */
+class FirebirdDrizzleSession extends pg_core_1.PgSession {
+    constructor(client, dialect, schema, options = {}) {
+        super(dialect);
+        _FirebirdDrizzleSession_client.set(this, void 0);
+        _FirebirdDrizzleSession_dialect.set(this, void 0);
+        _FirebirdDrizzleSession_schema.set(this, void 0);
+        _FirebirdDrizzleSession_options.set(this, void 0);
+        _FirebirdDrizzleSession_logger.set(this, void 0);
+        _FirebirdDrizzleSession_identifierCase.set(this, void 0);
+        __classPrivateFieldSet(this, _FirebirdDrizzleSession_client, client, "f");
+        __classPrivateFieldSet(this, _FirebirdDrizzleSession_dialect, dialect, "f");
+        __classPrivateFieldSet(this, _FirebirdDrizzleSession_schema, schema, "f");
+        __classPrivateFieldSet(this, _FirebirdDrizzleSession_options, options, "f");
+        __classPrivateFieldSet(this, _FirebirdDrizzleSession_logger, options.logger ?? new drizzle_orm_1.NoopLogger(), "f");
+        __classPrivateFieldSet(this, _FirebirdDrizzleSession_identifierCase, options.identifierCase ?? 'lower', "f");
+    }
+    prepareQuery(query, fields, _name, isResponseInArrayMode, customResultMapper, queryMetadata) {
+        return new FirebirdDrizzlePreparedQuery(__classPrivateFieldGet(this, _FirebirdDrizzleSession_client, "f"), query.sql, query.params, __classPrivateFieldGet(this, _FirebirdDrizzleSession_logger, "f"), fields, isResponseInArrayMode, customResultMapper, queryMetadata, __classPrivateFieldGet(this, _FirebirdDrizzleSession_identifierCase, "f"));
+    }
+    async transaction(transaction, config) {
+        if (!('transaction' in __classPrivateFieldGet(this, _FirebirdDrizzleSession_client, "f"))) {
+            throw new Error('Cannot start a root transaction on a transaction client');
+        }
+        return __classPrivateFieldGet(this, _FirebirdDrizzleSession_client, "f").transaction(async (txClient) => {
+            const session = new FirebirdDrizzleSession(txClient, __classPrivateFieldGet(this, _FirebirdDrizzleSession_dialect, "f"), __classPrivateFieldGet(this, _FirebirdDrizzleSession_schema, "f"), __classPrivateFieldGet(this, _FirebirdDrizzleSession_options, "f"));
+            const tx = new FirebirdDrizzleTransaction(__classPrivateFieldGet(this, _FirebirdDrizzleSession_dialect, "f"), session, __classPrivateFieldGet(this, _FirebirdDrizzleSession_schema, "f"));
+            return transaction(tx);
+        }, mapDrizzleTransactionConfig(config));
+    }
+    async count(countSql) {
+        const res = await this.execute(countSql);
+        const first = res.rows[0] ?? {};
+        const val = first['count'] ?? first['COUNT'] ?? Object.values(first)[0] ?? 0;
+        return Number(val);
+    }
+}
+exports.FirebirdDrizzleSession = FirebirdDrizzleSession;
+_FirebirdDrizzleSession_client = new WeakMap(), _FirebirdDrizzleSession_dialect = new WeakMap(), _FirebirdDrizzleSession_schema = new WeakMap(), _FirebirdDrizzleSession_options = new WeakMap(), _FirebirdDrizzleSession_logger = new WeakMap(), _FirebirdDrizzleSession_identifierCase = new WeakMap(), _c = drizzle_orm_1.entityKind;
+FirebirdDrizzleSession[_c] = 'FirebirdDrizzleSession';
+/**
+ * Drizzle transaction over a Firebird transaction, with nested savepoints.
+ */
+class FirebirdDrizzleTransaction extends pg_core_1.PgTransaction {
+    constructor(dialect, session, schema, nestedIndex = 0) {
+        super(dialect, session, schema, nestedIndex);
+        _FirebirdDrizzleTransaction_txDialect.set(this, void 0);
+        _FirebirdDrizzleTransaction_txSession.set(this, void 0);
+        __classPrivateFieldSet(this, _FirebirdDrizzleTransaction_txDialect, dialect, "f");
+        __classPrivateFieldSet(this, _FirebirdDrizzleTransaction_txSession, session, "f");
+    }
+    async transaction(transaction) {
+        const savepointName = `sp${this.nestedIndex + 1}`;
+        const tx = new FirebirdDrizzleTransaction(__classPrivateFieldGet(this, _FirebirdDrizzleTransaction_txDialect, "f"), __classPrivateFieldGet(this, _FirebirdDrizzleTransaction_txSession, "f"), this.schema, this.nestedIndex + 1);
+        await tx.execute(drizzle_orm_1.sql.raw(`savepoint ${savepointName}`));
+        try {
+            const result = await transaction(tx);
+            await tx.execute(drizzle_orm_1.sql.raw(`release savepoint ${savepointName}`));
+            return result;
+        }
+        catch (err) {
+            await tx.execute(drizzle_orm_1.sql.raw(`rollback to savepoint ${savepointName}`));
+            throw err;
+        }
+    }
+}
+exports.FirebirdDrizzleTransaction = FirebirdDrizzleTransaction;
+_FirebirdDrizzleTransaction_txDialect = new WeakMap(), _FirebirdDrizzleTransaction_txSession = new WeakMap(), _d = drizzle_orm_1.entityKind;
+FirebirdDrizzleTransaction[_d] = 'FirebirdDrizzleTransaction';
+/**
+ * Drizzle database instance backed by `FirebirdBrowser` or `FirebirdLite`.
+ */
+class FirebirdDrizzleDatabase extends pg_core_1.PgDatabase {
+}
+exports.FirebirdDrizzleDatabase = FirebirdDrizzleDatabase;
+_e = drizzle_orm_1.entityKind;
+FirebirdDrizzleDatabase[_e] = 'FirebirdDrizzleDatabase';
+/**
+ * Create a Drizzle ORM database instance over a `FirebirdBrowser` or `FirebirdLite` client.
+ */
+function drizzle(clientOrConfig, config) {
+    let client;
+    let resolvedConfig;
+    if (typeof clientOrConfig === 'object' &&
+        clientOrConfig !== null &&
+        'client' in clientOrConfig &&
+        typeof clientOrConfig.query !== 'function') {
+        const { client: c, ...rest } = clientOrConfig;
+        client = c;
+        resolvedConfig = rest;
+    }
+    else {
+        client = clientOrConfig;
+        resolvedConfig = config ?? {};
+    }
+    const identifierCase = resolvedConfig.identifierCase ?? 'lower';
+    const dialect = new FirebirdDrizzleDialect({
+        casing: resolvedConfig.casing,
+        identifierCase,
+    });
+    let logger;
+    if (resolvedConfig.logger === true) {
+        logger = new drizzle_orm_1.DefaultLogger();
+    }
+    else if (resolvedConfig.logger !== false) {
+        logger = resolvedConfig.logger;
+    }
+    let schema;
+    if (resolvedConfig.schema) {
+        const tablesConfig = (0, drizzle_orm_1.extractTablesRelationalConfig)(resolvedConfig.schema, drizzle_orm_1.createTableRelationsHelpers);
+        schema = {
+            fullSchema: resolvedConfig.schema,
+            schema: tablesConfig.tables,
+            tableNamesMap: tablesConfig.tableNamesMap,
+        };
+    }
+    const session = new FirebirdDrizzleSession(client, dialect, schema, { logger, identifierCase });
+    const db = new FirebirdDrizzleDatabase(dialect, session, schema);
+    db.$client = client;
+    return db;
+}
+/**
+ * Map a positional row (`rowMode: 'array'`) into Drizzle's nested object shape
+ * using each selected column/expression's `mapFromDriverValue` decoder.
+ */
+function mapDrizzleResultRow(columns, row, joinsNotNullableMap) {
+    const nullifyMap = {};
+    const result = columns.reduce((acc, { path, field }, columnIndex) => {
+        let decoder;
+        if ((0, drizzle_orm_1.is)(field, drizzle_orm_1.Column)) {
+            decoder = field;
+        }
+        else if ((0, drizzle_orm_1.is)(field, drizzle_orm_1.SQL)) {
+            decoder = field.decoder;
+        }
+        else if ((0, drizzle_orm_1.is)(field, drizzle_orm_1.Subquery)) {
+            decoder = field._.sql.decoder;
+        }
+        else {
+            decoder = field.sql
+                .decoder;
+        }
+        let node = acc;
+        for (const [pathChunkIndex, pathChunk] of path.entries()) {
+            if (pathChunkIndex < path.length - 1) {
+                if (!(pathChunk in node)) {
+                    node[pathChunk] = {};
+                }
+                node = node[pathChunk];
+            }
+            else {
+                const rawValue = row[columnIndex];
+                const value = (node[pathChunk] =
+                    rawValue === null || rawValue === undefined
+                        ? null
+                        : decoder.mapFromDriverValue(rawValue));
+                if (joinsNotNullableMap && (0, drizzle_orm_1.is)(field, drizzle_orm_1.Column) && path.length === 2) {
+                    const objectName = path[0];
+                    if (!(objectName in nullifyMap)) {
+                        nullifyMap[objectName] =
+                            value === null ? (0, drizzle_orm_1.getTableName)(field.table) : false;
+                    }
+                    else if (typeof nullifyMap[objectName] === 'string' &&
+                        nullifyMap[objectName] !== (0, drizzle_orm_1.getTableName)(field.table)) {
+                        nullifyMap[objectName] = false;
+                    }
+                }
+            }
+        }
+        return acc;
+    }, {});
+    if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
+        for (const [objectName, tableName] of Object.entries(nullifyMap)) {
+            if (typeof tableName === 'string' && !joinsNotNullableMap[tableName]) {
+                result[objectName] = null;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Convert Drizzle's `Date.toISOString()` (`YYYY-MM-DDTHH:mm:ss.sssZ`) parameter
+ * strings to Firebird's `YYYY-MM-DD HH:mm:ss.sss` timestamp literal format.
+ */
+function normalizeParams(params) {
+    return params.map((p) => {
+        if (typeof p === 'string' &&
+            /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/.test(p)) {
+            return p.replace('T', ' ').replace(/Z$/, '');
+        }
+        return p;
+    });
+}
+function mapObjectRows(rows, mode) {
+    if (mode === 'preserve' || rows.length === 0) {
+        return rows;
+    }
+    const first = rows[0];
+    const keys = Object.keys(first);
+    const mappedKeys = keys.map((k) => /^[A-Z_][A-Z0-9_$]*$/.test(k) ? k.toLowerCase() : k);
+    if (keys.every((k, i) => k === mappedKeys[i])) {
+        return rows;
+    }
+    return rows.map((row) => {
+        const out = {};
+        for (let i = 0; i < keys.length; i++) {
+            out[mappedKeys[i]] = row[keys[i]];
+        }
+        return out;
+    });
+}
+function mapDrizzleTransactionConfig(config) {
+    if (!config)
+        return undefined;
+    const options = {};
+    if (config.accessMode === 'read only') {
+        options.readOnly = true;
+    }
+    switch (config.isolationLevel) {
+        case 'read uncommitted':
+        case 'read committed':
+            options.isolationLevel = 'READ_COMMITTED';
+            break;
+        case 'repeatable read':
+            options.isolationLevel = 'SNAPSHOT';
+            break;
+        case 'serializable':
+            options.isolationLevel = 'SNAPSHOT_TABLE_STABILITY';
+            break;
+    }
+    return options;
+}
+function extractAffectedRows(res) {
+    if (typeof res === 'object' && res !== null && 'affectedRows' in res) {
+        const n = res.affectedRows;
+        return typeof n === 'number' ? n : undefined;
+    }
+    if (Array.isArray(res)) {
+        let total = 0;
+        for (const item of res) {
+            if (typeof item === 'object' && item !== null && 'affectedRows' in item) {
+                total += Number(item.affectedRows ?? 0);
+            }
+        }
+        return total;
+    }
+    return undefined;
+}
+//# sourceMappingURL=index.js.map