firebird-wasm 0.2.0 → 0.3.0

package/dist/sql-tag.d.ts

@@ -0,0 +1,184 @@
+/**
+ * sql-tag.ts – the `` sql`…` `` template tag.
+ *
+ * Interpolation in a SQL string is the classic injection bug, and the usual
+ * advice — "use parameters" — is awkward enough that people don't:
+ *
+ * ```ts
+ * await db.query('SELECT * FROM items WHERE id = ? AND name = ?', [id, name]);
+ * ```
+ *
+ * The values sit far from the holes they fill, and adding a condition means
+ * editing two places and keeping them in the same order. The tag closes that
+ * distance without giving up parameter binding:
+ *
+ * ```ts
+ * await db.query(sql`SELECT * FROM items WHERE id = ${id} AND name = ${name}`);
+ * ```
+ *
+ * Every `${…}` becomes a `?` and its value is bound, so a value can never be
+ * read as SQL. That is the whole safety property, and it holds no matter what
+ * the value contains — `"'; DROP TABLE items --"` is a five-word string, not a
+ * statement.
+ *
+ * What a tagged template cannot do is parameterise the parts of a statement
+ * that are not values: table and column names, `ORDER BY` direction, whole
+ * conditions. Those need text, and text is where injection lives again, so the
+ * three ways to produce it are named and separate — {@link SqlTag.identifier},
+ * {@link SqlTag.join}, and {@link SqlTag.unsafe}. Only the last is a loaded
+ * gun, and it says so at the call site.
+ *
+ * Fragments nest, which is what makes conditional SQL bearable:
+ *
+ * ```ts
+ * const active = onlyActive ? sql`AND active = ${true}` : sql``;
+ * await db.query(sql`SELECT * FROM items WHERE owner = ${user} ${active}`);
+ * ```
+ *
+ * Placeholders renumber themselves because Firebird's are positional `?`
+ * rather than `$1` — splicing a fragment is concatenation on both the text and
+ * the parameter list, with no renumbering to get wrong.
+ */
+import type { QueryParams, TransactionOptions } from './types';
+/**
+ * A piece of SQL and the values bound to its placeholders.
+ *
+ * Produced by {@link sql}, accepted anywhere `(sql, params)` is. Both fields
+ * are readable, which is what makes a query loggable before it runs.
+ */
+export declare class SqlFragment {
+    /** Statement text, with a `?` for every bound value. */
+    readonly sql: string;
+    /** Values for the placeholders, in order. */
+    readonly params: QueryParams;
+    constructor(
+    /** Statement text, with a `?` for every bound value. */
+    sql: string, 
+    /** Values for the placeholders, in order. */
+    params: QueryParams);
+}
+/**
+ * SQL text that is spliced in literally, with nothing bound.
+ *
+ * There is no way to make this safe in general — that is the point of keeping
+ * it a distinct type rather than letting any string through. It exists because
+ * identifiers and syntax cannot be parameters.
+ */
+export declare class RawSql {
+    readonly sql: string;
+    constructor(sql: string);
+}
+/** True if `value` came from {@link sql}. */
+export declare function isSqlFragment(value: unknown): value is SqlFragment;
+/** The shape of {@link sql}: callable as a tag, with helpers hanging off it. */
+export interface SqlTag {
+    (strings: TemplateStringsArray, ...values: unknown[]): SqlFragment;
+    /**
+     * Quote a table or column name so it can be interpolated as text.
+     *
+     * ```ts
+     * await db.query(sql`SELECT * FROM ${sql.identifier(table)} WHERE id = ${id}`);
+     * ```
+     *
+     * The name is quoted verbatim, with any `"` doubled, so it cannot end the
+     * quoting and start a statement.
+     *
+     * **Firebird folds unquoted names to upper case, and quoting turns that
+     * off.** A table created as `CREATE TABLE items` is stored as `ITEMS`, and
+     * `sql.identifier('items')` produces `"items"`, which will not find it. Pass
+     * the name in its stored case — usually upper. This helper deliberately does
+     * not upper-case for you: names created *with* quotes keep whatever case
+     * they were given, and mangling those would be the worse failure of the two,
+     * because it would corrupt a name that was previously correct.
+     */
+    identifier(name: string): RawSql;
+    /**
+     * Join values or fragments with a separator, as one fragment.
+     *
+     * The `IN` list problem: `WHERE id IN ${ids}` cannot work, because one
+     * placeholder binds one value.
+     *
+     * ```ts
+     * await db.query(sql`SELECT * FROM items WHERE id IN (${sql.join(ids)})`);
+     * // SELECT * FROM items WHERE id IN (?, ?, ?)
+     * ```
+     *
+     * Elements may be fragments, which is how a list of conditions is built:
+     *
+     * ```ts
+     * sql`WHERE ${sql.join(conditions, ' AND ')}`
+     * ```
+     *
+     * Note the parentheses above are written by the caller, not added here —
+     * `join` has no way to know whether it is filling an `IN` list or an
+     * `AND` chain.
+     *
+     * @throws if `values` is empty. `IN ()` is a syntax error in Firebird and an
+     *   empty `AND` chain is an empty `WHERE`, so there is no text this could
+     *   return that is not a bug somewhere later. An empty list usually means
+     *   the caller wants "match nothing" (`1 = 0`) or "no filter" (`1 = 1`), and
+     *   only the caller knows which.
+     */
+    join(values: readonly unknown[], separator?: string): SqlFragment;
+    /**
+     * Splice text in literally, escaping nothing.
+     *
+     * For syntax that cannot be a parameter and is not an identifier — a sort
+     * direction, a `FIRST`/`SKIP` clause built by hand.
+     *
+     * ```ts
+     * const dir = ascending ? sql.unsafe('ASC') : sql.unsafe('DESC');
+     * await db.query(sql`SELECT * FROM items ORDER BY name ${dir}`);
+     * ```
+     *
+     * Named `unsafe` because it is: anything reaching it from outside the
+     * program is an injection. The name is the warning, and it shows up at the
+     * call site during review rather than in this file.
+     */
+    unsafe(text: string): RawSql;
+}
+/**
+ * Build a {@link SqlFragment} from a template literal.
+ *
+ * See the module comment for what this is for and what it cannot do.
+ */
+export declare const sql: SqlTag;
+/** A statement in the form the backends bind: text plus positional values. */
+export interface Statement {
+    sql: string;
+    params: QueryParams;
+}
+/**
+ * Normalise the two calling conventions into one.
+ *
+ * `query()` and `exec()` take either a string with its parameters or a
+ * fragment carrying its own, and every backend needs the same reduction.
+ *
+ * @throws if a fragment is given alongside parameters. It reads as though the
+ *   two combine, and they cannot: the fragment's placeholders are already
+ *   filled, so the extra values would bind to nothing. Silently ignoring them
+ *   would run a query the caller did not write.
+ */
+export declare function toStatement(sql: string | SqlFragment, params?: QueryParams): Statement;
+/**
+ * Resolve `query()`'s two shapes: `(sql, params, options)` and
+ * `(fragment, options)`.
+ *
+ * A fragment carries its own parameters, so the slot that would have held them
+ * is free — and making the caller write `query(fragment, undefined, options)`
+ * to reach the third argument would be a poor trade for the tag's ergonomics.
+ * The two are told apart by whether the argument is an array, which is
+ * unambiguous: parameters are always one, options never are.
+ *
+ * @throws if a string statement is given a second argument that is not an
+ *   array. `query('… WHERE id = ?', 5)` reads as though it binds 5, and taking
+ *   it for transaction options instead would run the statement with no
+ *   parameters at all — the engine then complains about a placeholder count,
+ *   naming nothing the caller wrote. TypeScript rules this out; untyped
+ *   JavaScript, which the browser build is used from, does not.
+ */
+export declare function resolveQueryCall(sql: string | SqlFragment, paramsOrOptions?: QueryParams | TransactionOptions, maybeOptions?: TransactionOptions): {
+    statement: Statement;
+    options: TransactionOptions;
+};
+//# sourceMappingURL=sql-tag.d.ts.map

package/dist/sql-tag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-tag.d.ts","sourceRoot":"","sources":["../src/sql-tag.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAkB/D;;;;;GAKG;AACH,qBAAa,WAAW;IAEpB,wDAAwD;IACxD,QAAQ,CAAC,GAAG,EAAE,MAAM;IACpB,6CAA6C;IAC7C,QAAQ,CAAC,MAAM,EAAE,WAAW;;IAH5B,wDAAwD;IAC/C,GAAG,EAAE,MAAM;IACpB,6CAA6C;IACpC,MAAM,EAAE,WAAW;CAM/B;AAED;;;;;;GAMG;AACH,qBAAa,MAAM;IACL,QAAQ,CAAC,GAAG,EAAE,MAAM;gBAAX,GAAG,EAAE,MAAM;CAGjC;AAED,6CAA6C;AAC7C,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAMlE;AAcD,gFAAgF;AAChF,MAAM,WAAW,MAAM;IACrB,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,WAAW,CAAC;IAEnE;;;;;;;;;;;;;;;;;OAiBG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,IAAI,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;IAElE;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;CAC9B;AAkHD;;;;GAIG;AACH,eAAO,MAAM,GAAG,EAAE,MAAyD,CAAC;AAM5E,8EAA8E;AAC9E,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,WAAW,CAAC;CACrB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,MAAM,GAAG,WAAW,EACzB,MAAM,GAAE,WAAgB,GACvB,SAAS,CAgCX;AAgBD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,MAAM,GAAG,WAAW,EACzB,eAAe,GAAE,WAAW,GAAG,kBAAuB,EACtD,YAAY,GAAE,kBAAuB,GACpC;IAAE,SAAS,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,kBAAkB,CAAA;CAAE,CAoBvD"}

package/dist/sql-tag.js

@@ -0,0 +1,287 @@
+"use strict";
+/**
+ * sql-tag.ts – the `` sql`…` `` template tag.
+ *
+ * Interpolation in a SQL string is the classic injection bug, and the usual
+ * advice — "use parameters" — is awkward enough that people don't:
+ *
+ * ```ts
+ * await db.query('SELECT * FROM items WHERE id = ? AND name = ?', [id, name]);
+ * ```
+ *
+ * The values sit far from the holes they fill, and adding a condition means
+ * editing two places and keeping them in the same order. The tag closes that
+ * distance without giving up parameter binding:
+ *
+ * ```ts
+ * await db.query(sql`SELECT * FROM items WHERE id = ${id} AND name = ${name}`);
+ * ```
+ *
+ * Every `${…}` becomes a `?` and its value is bound, so a value can never be
+ * read as SQL. That is the whole safety property, and it holds no matter what
+ * the value contains — `"'; DROP TABLE items --"` is a five-word string, not a
+ * statement.
+ *
+ * What a tagged template cannot do is parameterise the parts of a statement
+ * that are not values: table and column names, `ORDER BY` direction, whole
+ * conditions. Those need text, and text is where injection lives again, so the
+ * three ways to produce it are named and separate — {@link SqlTag.identifier},
+ * {@link SqlTag.join}, and {@link SqlTag.unsafe}. Only the last is a loaded
+ * gun, and it says so at the call site.
+ *
+ * Fragments nest, which is what makes conditional SQL bearable:
+ *
+ * ```ts
+ * const active = onlyActive ? sql`AND active = ${true}` : sql``;
+ * await db.query(sql`SELECT * FROM items WHERE owner = ${user} ${active}`);
+ * ```
+ *
+ * Placeholders renumber themselves because Firebird's are positional `?`
+ * rather than `$1` — splicing a fragment is concatenation on both the text and
+ * the parameter list, with no renumbering to get wrong.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sql = exports.RawSql = exports.SqlFragment = void 0;
+exports.isSqlFragment = isSqlFragment;
+exports.toStatement = toStatement;
+exports.resolveQueryCall = resolveQueryCall;
+// ---------------------------------------------------------------------------
+// Fragments
+// ---------------------------------------------------------------------------
+/**
+ * Brands, registered globally rather than per module instance.
+ *
+ * `instanceof` would be the obvious check and is wrong here: this package has
+ * two entry points, and an application that reaches both — or that ends up
+ * with two installed copies — gets two `SqlFragment` classes whose instances
+ * fail each other's `instanceof`. A `Symbol.for` key is the same symbol in
+ * every copy, so the check survives that.
+ */
+const FRAGMENT = Symbol.for('firebird-wasm.SqlFragment');
+const RAW = Symbol.for('firebird-wasm.RawSql');
+/**
+ * A piece of SQL and the values bound to its placeholders.
+ *
+ * Produced by {@link sql}, accepted anywhere `(sql, params)` is. Both fields
+ * are readable, which is what makes a query loggable before it runs.
+ */
+class SqlFragment {
+    constructor(
+    /** Statement text, with a `?` for every bound value. */
+    sql, 
+    /** Values for the placeholders, in order. */
+    params) {
+        this.sql = sql;
+        this.params = params;
+        // Non-enumerable so the brand stays out of spreads, `JSON.stringify` and
+        // anything else that walks own keys.
+        Object.defineProperty(this, FRAGMENT, { value: true });
+    }
+}
+exports.SqlFragment = SqlFragment;
+/**
+ * SQL text that is spliced in literally, with nothing bound.
+ *
+ * There is no way to make this safe in general — that is the point of keeping
+ * it a distinct type rather than letting any string through. It exists because
+ * identifiers and syntax cannot be parameters.
+ */
+class RawSql {
+    constructor(sql) {
+        this.sql = sql;
+        Object.defineProperty(this, RAW, { value: true });
+    }
+}
+exports.RawSql = RawSql;
+/** True if `value` came from {@link sql}. */
+function isSqlFragment(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value[FRAGMENT] === true);
+}
+function isRawSql(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value[RAW] === true);
+}
+function tag(strings, ...values) {
+    let text = '';
+    const params = [];
+    for (let i = 0; i < strings.length; i++) {
+        const chunk = strings[i];
+        // Cooked strings are `undefined` for an invalid escape sequence — legal in
+        // a tagged template since ES2018, where it hands the tag a hole rather
+        // than a syntax error. Concatenating it would put the text "undefined"
+        // into the statement, which fails later and somewhere else.
+        if (chunk === undefined) {
+            throw new SyntaxError(`sql\`…\` contains an invalid escape sequence in segment ${i}; ` +
+                'use sql.unsafe() if the text is meant to be literal');
+        }
+        text += chunk;
+        if (i < values.length) {
+            text += interpolate(values[i], params, i, 'template');
+        }
+    }
+    return new SqlFragment(text, params);
+}
+/**
+ * Render one `${…}`, appending to `params` when it binds.
+ *
+ * `where` names the caller, because the two callers fail differently and a
+ * message that describes the wrong one sends the reader to the wrong line —
+ * see {@link join}.
+ *
+ * @returns the text this value contributes.
+ */
+function interpolate(value, params, index, where) {
+    if (isSqlFragment(value)) {
+        // A loop rather than push(...spread): every parameter would otherwise
+        // become a separate argument, and a large enough list overflows the call
+        // stack with a RangeError that names neither the list nor the limit.
+        for (const param of value.params)
+            params.push(param);
+        return value.sql;
+    }
+    if (isRawSql(value)) {
+        return value.sql;
+    }
+    if (Array.isArray(value)) {
+        // One placeholder binds one value, so an array here is always a mistake —
+        // and always the same mistake, which is worth naming precisely. Left to
+        // the parameter encoder it surfaces as "unsupported type object" at bind
+        // time, which does not suggest the fix.
+        throw new TypeError(where === 'join'
+            ? `Element ${index} passed to sql.join() is an array. sql.join() does ` +
+                'not flatten, because a nested list has no unambiguous SQL form — ' +
+                'flatten it first, or join the inner lists yourself'
+            : `Value ${index} in sql\`…\` is an array, which cannot bind to a ` +
+                'single placeholder; use sql.join(values) to expand it into a list');
+    }
+    params.push(value);
+    return '?';
+}
+function identifier(name) {
+    if (typeof name !== 'string' || name.length === 0) {
+        throw new TypeError('sql.identifier() needs a non-empty name');
+    }
+    if (name.includes('\0')) {
+        // Firebird would reject it, but not before the NUL had truncated the
+        // statement in whatever handled it first.
+        throw new TypeError('sql.identifier() cannot contain a NUL character');
+    }
+    return new RawSql(`"${name.replace(/"/g, '""')}"`);
+}
+function join(values, separator = ', ') {
+    if (values.length === 0) {
+        throw new RangeError('sql.join() needs at least one value: an empty list has no valid SQL ' +
+            'form (IN () is a syntax error). Guard the empty case with the ' +
+            'condition you actually mean — 1 = 0 to match nothing, 1 = 1 to ' +
+            'match everything');
+    }
+    let text = '';
+    const params = [];
+    values.forEach((value, index) => {
+        if (index > 0)
+            text += separator;
+        text += interpolate(value, params, index, 'join');
+    });
+    return new SqlFragment(text, params);
+}
+function unsafe(text) {
+    if (typeof text !== 'string') {
+        throw new TypeError('sql.unsafe() needs a string');
+    }
+    return new RawSql(text);
+}
+/**
+ * Build a {@link SqlFragment} from a template literal.
+ *
+ * See the module comment for what this is for and what it cannot do.
+ */
+exports.sql = Object.assign(tag, { identifier, join, unsafe });
+/**
+ * Normalise the two calling conventions into one.
+ *
+ * `query()` and `exec()` take either a string with its parameters or a
+ * fragment carrying its own, and every backend needs the same reduction.
+ *
+ * @throws if a fragment is given alongside parameters. It reads as though the
+ *   two combine, and they cannot: the fragment's placeholders are already
+ *   filled, so the extra values would bind to nothing. Silently ignoring them
+ *   would run a query the caller did not write.
+ */
+function toStatement(sql, params = []) {
+    if (typeof sql === 'string') {
+        return { sql, params };
+    }
+    if (isSqlFragment(sql)) {
+        if (params.length > 0) {
+            throw new TypeError('A sql`…` fragment already carries its parameters; passing more would ' +
+                'bind them to nothing. Interpolate the values into the template ' +
+                'instead');
+        }
+        return { sql: sql.sql, params: sql.params };
+    }
+    // Anything else would have been passed through as the statement text, and
+    // an object reaches the engine as "[object Object]" — a syntax error that
+    // names a token rather than the argument, with the fragment's values
+    // silently dropped.
+    //
+    // The look-alike this catches is not hypothetical. `SqlFragment` is
+    // structurally `{ sql, params }`, so a plain object of that shape type-checks
+    // against the fragment overload, and the brand is a symbol, which neither
+    // `structuredClone` nor `JSON` carries: a fragment built in a Worker and
+    // posted to the main thread arrives as exactly such a look-alike.
+    throw new TypeError(`Expected a SQL string or a sql\`…\` fragment, got ${describe(sql)}. ` +
+        'A fragment does not survive structuredClone or JSON — it carries a ' +
+        'symbol brand — so rebuild it on the receiving side rather than sending it');
+}
+/** Name a value for an error message, without dumping its contents. */
+function describe(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'an array';
+    if (typeof value !== 'object')
+        return `a ${typeof value}`;
+    const name = value.constructor?.name;
+    const looksLikeFragment = 'sql' in value && 'params' in value;
+    return looksLikeFragment
+        ? `a { sql, params } object that is not a fragment (${name ?? 'object'})`
+        : `a ${name ?? 'object'}`;
+}
+/**
+ * Resolve `query()`'s two shapes: `(sql, params, options)` and
+ * `(fragment, options)`.
+ *
+ * A fragment carries its own parameters, so the slot that would have held them
+ * is free — and making the caller write `query(fragment, undefined, options)`
+ * to reach the third argument would be a poor trade for the tag's ergonomics.
+ * The two are told apart by whether the argument is an array, which is
+ * unambiguous: parameters are always one, options never are.
+ *
+ * @throws if a string statement is given a second argument that is not an
+ *   array. `query('… WHERE id = ?', 5)` reads as though it binds 5, and taking
+ *   it for transaction options instead would run the statement with no
+ *   parameters at all — the engine then complains about a placeholder count,
+ *   naming nothing the caller wrote. TypeScript rules this out; untyped
+ *   JavaScript, which the browser build is used from, does not.
+ */
+function resolveQueryCall(sql, paramsOrOptions = [], maybeOptions = {}) {
+    if (Array.isArray(paramsOrOptions)) {
+        return {
+            statement: toStatement(sql, paramsOrOptions),
+            options: maybeOptions,
+        };
+    }
+    if (typeof sql === 'string') {
+        throw new TypeError(`Expected an array of parameters, got ${describe(paramsOrOptions)}. ` +
+            'Transaction options go in the second argument only for a sql`…` ' +
+            'fragment, which carries its own parameters');
+    }
+    return {
+        statement: toStatement(sql, []),
+        options: paramsOrOptions,
+    };
+}
+//# sourceMappingURL=sql-tag.js.map

package/dist/sql-tag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-tag.js","sourceRoot":"","sources":["../src/sql-tag.ts"],"names":[],"mappings":"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"}

package/dist/statement-types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * statement-types.ts – names for Firebird's statement-type codes.
+ *
+ * The engine reports what a statement *is* as one of the `isc_info_sql_stmt_*`
+ * constants. A caller asking `describeQuery()` what they have wants the name,
+ * not the number — the number is only meaningful next to a copy of
+ * `iberror.h`.
+ *
+ * Shared by both backends rather than per-backend: `node-firebird-driver`'s
+ * `StatementType` enum is these same codes, so one table describes what either
+ * one reports and the two cannot drift into naming the same statement
+ * differently.
+ */
+import type { StatementKind } from './types';
+/**
+ * Name a statement-type code.
+ *
+ * An unrecognised code is `'UNKNOWN'` rather than an error: a Firebird release
+ * may add one, and a name this library has not learned yet is no reason to
+ * fail a description that is otherwise complete.
+ */
+export declare function statementKind(code: number): StatementKind;
+//# sourceMappingURL=statement-types.d.ts.map

package/dist/statement-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statement-types.d.ts","sourceRoot":"","sources":["../src/statement-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAoB7C;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAEzD"}

package/dist/statement-types.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * statement-types.ts – names for Firebird's statement-type codes.
+ *
+ * The engine reports what a statement *is* as one of the `isc_info_sql_stmt_*`
+ * constants. A caller asking `describeQuery()` what they have wants the name,
+ * not the number — the number is only meaningful next to a copy of
+ * `iberror.h`.
+ *
+ * Shared by both backends rather than per-backend: `node-firebird-driver`'s
+ * `StatementType` enum is these same codes, so one table describes what either
+ * one reports and the two cannot drift into naming the same statement
+ * differently.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statementKind = statementKind;
+// From firebird/impl/consts_pub.h (isc_info_sql_stmt_*).
+const NAMES = {
+    1: 'SELECT',
+    2: 'INSERT',
+    3: 'UPDATE',
+    4: 'DELETE',
+    5: 'DDL',
+    6: 'GET_SEGMENT',
+    7: 'PUT_SEGMENT',
+    8: 'EXEC_PROCEDURE',
+    9: 'START_TRANS',
+    10: 'COMMIT',
+    11: 'ROLLBACK',
+    12: 'SELECT_FOR_UPD',
+    13: 'SET_GENERATOR',
+    14: 'SAVEPOINT',
+};
+/**
+ * Name a statement-type code.
+ *
+ * An unrecognised code is `'UNKNOWN'` rather than an error: a Firebird release
+ * may add one, and a name this library has not learned yet is no reason to
+ * fail a description that is otherwise complete.
+ */
+function statementKind(code) {
+    return NAMES[code] ?? 'UNKNOWN';
+}
+//# sourceMappingURL=statement-types.js.map

package/dist/statement-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statement-types.js","sourceRoot":"","sources":["../src/statement-types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;AA6BH,sCAEC;AA3BD,yDAAyD;AACzD,MAAM,KAAK,GAAkC;IAC3C,CAAC,EAAE,QAAQ;IACX,CAAC,EAAE,QAAQ;IACX,CAAC,EAAE,QAAQ;IACX,CAAC,EAAE,QAAQ;IACX,CAAC,EAAE,KAAK;IACR,CAAC,EAAE,aAAa;IAChB,CAAC,EAAE,aAAa;IAChB,CAAC,EAAE,gBAAgB;IACnB,CAAC,EAAE,aAAa;IAChB,EAAE,EAAE,QAAQ;IACZ,EAAE,EAAE,UAAU;IACd,EAAE,EAAE,gBAAgB;IACpB,EAAE,EAAE,eAAe;IACnB,EAAE,EAAE,WAAW;CAChB,CAAC;AAEF;;;;;;GAMG;AACH,SAAgB,aAAa,CAAC,IAAY;IACxC,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,SAAS,CAAC;AAClC,CAAC"}

package/dist/types.d.ts

@@ -85,4 +85,66 @@ export interface TransactionOptions {
     isolationLevel?: IsolationLevel;
     readOnly?: boolean;
 }
+/**
+ * What each row is.
+ *
+ * - `'object'` (default) keys every value by its upper-cased column name.
+ * - `'array'` gives the values in column order, positionally.
+ *
+ * Names live in `fields` either way, so `'array'` loses nothing — it trades
+ * the convenience of `row.NAME` for `row[1]`, and for that it skips building
+ * one object per row.
+ */
+export type RowMode = 'object' | 'array';
+/**
+ * Options accepted by `query()`.
+ *
+ * A superset of {@link TransactionOptions}: a query may start a transaction of
+ * its own, and it decides the shape of what comes back.
+ */
+export interface QueryOptions extends TransactionOptions {
+    /**
+     * How to shape each row.
+     *
+     * `'array'` is worth reaching for on large result sets and on columns whose
+     * names collide: `SELECT a.ID, b.ID` has two columns and, in object mode,
+     * one `ID` key — the second value wins and the first is unreachable.
+     * Positional rows keep both.
+     *
+     * @default 'object'
+     */
+    rowMode?: RowMode;
+}
+/** A row in `rowMode: 'array'` — values in column order. */
+export type ArrayRow = unknown[];
+/**
+ * What a statement is, from Firebird's `isc_info_sql_stmt_*` codes.
+ *
+ * `'UNKNOWN'` covers a code this library does not name rather than a failure
+ * to describe the statement.
+ */
+export type StatementKind = 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE' | 'DDL' | 'GET_SEGMENT' | 'PUT_SEGMENT' | 'EXEC_PROCEDURE' | 'START_TRANS' | 'COMMIT' | 'ROLLBACK' | 'SELECT_FOR_UPD' | 'SET_GENERATOR' | 'SAVEPOINT' | 'UNKNOWN';
+/**
+ * The shape of a statement, without running it.
+ *
+ * Returned by `describeQuery()`. Parameters are positional `?` in Firebird and
+ * carry no names, so a `ParamInfo` has everything a {@link FieldInfo} has
+ * except a meaningful one.
+ */
+export interface QueryDescription {
+    /**
+     * One entry per `?`, in order.
+     *
+     * `undefined` where the backend cannot report them — the Node driver
+     * exposes no input metadata, and an empty array there would claim the
+     * statement takes no parameters.
+     */
+    params?: FieldInfo[];
+    /** One entry per result column, in order.  Empty for a statement returning none. */
+    fields: FieldInfo[];
+    /** What kind of statement it is. */
+    statementType: StatementKind;
+    /** Whether executing it yields rows. */
+    hasResultSet: boolean;
+}
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,2EAA2E;IAC3E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8BAA8B;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,GAAG;IAClC,4BAA4B;IAC5B,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,iDAAiD;IACjD,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,0DAA0D;IAC1D,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iFAAiF;IACjF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gCAAgC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,2EAA2E;AAC3E,MAAM,MAAM,gBAAgB,GACxB,MAAM,GACN,SAAS,GACT,UAAU,GACV,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,YAAY,GACZ,YAAY,GACZ,SAAS,GACT,MAAM,GACN,MAAM,GACN,WAAW,GACX,SAAS,GACT,cAAc,GACd,SAAS,GACT,MAAM,GACN,OAAO,GACP,MAAM,GACN,SAAS,CAAC;AAEd;;GAEG;AACH,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE1C;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,EAAE,CAAC;AAEpC;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GACtB,gBAAgB,GAChB,UAAU,GACV,0BAA0B,CAAC;AAE/B;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,2EAA2E;IAC3E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gDAAgD;IAChD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8BAA8B;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,GAAG;IAClC,4BAA4B;IAC5B,IAAI,EAAE,CAAC,EAAE,CAAC;IACV,iDAAiD;IACjD,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,0DAA0D;IAC1D,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,mEAAmE;IACnE,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iFAAiF;IACjF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gCAAgC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,2EAA2E;AAC3E,MAAM,MAAM,gBAAgB,GACxB,MAAM,GACN,SAAS,GACT,UAAU,GACV,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,YAAY,GACZ,YAAY,GACZ,SAAS,GACT,MAAM,GACN,MAAM,GACN,WAAW,GACX,SAAS,GACT,cAAc,GACd,SAAS,GACT,MAAM,GACN,OAAO,GACP,MAAM,GACN,SAAS,CAAC;AAEd;;GAEG;AACH,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE1C;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,EAAE,CAAC;AAEpC;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GACtB,gBAAgB,GAChB,UAAU,GACV,0BAA0B,CAAC;AAE/B;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEzC;;;;;GAKG;AACH,MAAM,WAAW,YAAa,SAAQ,kBAAkB;IACtD;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,4DAA4D;AAC5D,MAAM,MAAM,QAAQ,GAAG,OAAO,EAAE,CAAC;AAEjC;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GACrB,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,QAAQ,GACR,KAAK,GACL,aAAa,GACb,aAAa,GACb,gBAAgB,GAChB,aAAa,GACb,QAAQ,GACR,UAAU,GACV,gBAAgB,GAChB,eAAe,GACf,WAAW,GACX,SAAS,CAAC;AAEd;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,SAAS,EAAE,CAAC;IACrB,oFAAoF;IACpF,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,oCAAoC;IACpC,aAAa,EAAE,aAAa,CAAC;IAC7B,wCAAwC;IACxC,YAAY,EAAE,OAAO,CAAC;CACvB"}