postgrejs 2.23.1 → 3.0.2

package/util/parse-row.d.ts

@@ -1,3 +1,5 @@
 import type { DataMappingOptions } from '../interfaces/data-mapping-options.js';
+import type { FieldInfo } from '../interfaces/field-info.js';
 import type { AnyParseFunction } from '../types.js';
-export declare function parseRow(parsers: AnyParseFunction[], row: any[], options: DataMappingOptions): void;
+export declare function parseRow(parsers: AnyParseFunction[], data: Buffer, columnCount: number, options: DataMappingOptions): any[];
+export declare function parseObjectRow(parsers: AnyParseFunction[], data: Buffer, columnCount: number, options: DataMappingOptions, fields: FieldInfo[]): object;

package/util/parse-row.js

@@ -1,8 +1,63 @@
-export function parseRow(parsers, row, options) {
-    const l = row.length;
+export function parseRow(parsers, data, columnCount, options) {
+    const row = new Array(columnCount);
+    let offset = 0;
+    let len;
     let i;
-    for (i = 0; i < l; i++) {
-        row[i] =
-            row[i] == null ? null : parsers[i].call(undefined, row[i], options);
+    for (i = 0; i < columnCount; i++) {
+        // The length of the column value, in bytes (this count does not
+        // include itself). Can be zero. As a special case, -1 indicates a
+        // NULL column value - no value bytes follow in that case.
+        len = data.readInt32BE(offset);
+        offset += 4;
+        if (len < 0) {
+            row[i] = null;
+        }
+        else {
+            // None of the parsers use `this`, so a direct call avoids .call()'s
+            // extra indirection (measured ~5.7x slower than invoking directly).
+            row[i] = parsers[i](data, offset, len, options);
+            offset += len;
+        }
     }
+    return row;
+}
+export function parseObjectRow(parsers, data, columnCount, options, fields) {
+    const row = {};
+    let offset = 0;
+    let len;
+    let i;
+    let value;
+    for (i = 0; i < columnCount; i++) {
+        // The length of the column value, in bytes (this count does not
+        // include itself). Can be zero. As a special case, -1 indicates a
+        // NULL column value - no value bytes follow in that case.
+        len = data.readInt32BE(offset);
+        offset += 4;
+        if (len < 0) {
+            value = null;
+        }
+        else {
+            // None of the parsers use `this`, so a direct call avoids .call()'s
+            // extra indirection (measured ~5.7x slower than invoking directly).
+            value = parsers[i](data, offset, len, options);
+            offset += len;
+        }
+        const name = fields[i].fieldName;
+        if (name === '__proto__') {
+            // `value`, not row[i] - nothing is ever assigned by numeric index
+            // here (row is a plain object keyed by field name), so reading row[i]
+            // handed defineProperty an undefined and silently dropped the
+            // column's actual value.
+            Object.defineProperty(row, name, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+        }
+        else {
+            row[name] = value;
+        }
+    }
+    return row;
 }

package/util/parse-time.js

@@ -14,8 +14,15 @@ export function parseTime(str, parseTimeZone, utc) {
         const s = m[i];
         args[i + 2] = fastParseInt(s) || 0;
     }
+    // Fractional seconds (m[4]) were never read here at all - pad/truncate to
+    // exactly 3 digits, same reasoning as parse-datetime.ts's equivalent fix.
+    if (m[4])
+        args[6] = fastParseInt((m[4] + '000').slice(0, 3));
     if (parseTimeZone && m[6]) {
-        const r = m[9] === '-' ? -1 : 1;
+        // m[6] is the sign group itself ('+'/'-') - there is no m[9] in this
+        // pattern (only 8 capture groups), so the old `m[9] === '-'` check was
+        // always false, silently treating every offset as positive.
+        const r = m[6] === '-' ? -1 : 1;
         args[3] -= (fastParseInt(m[7]) || 0) * r;
         args[4] -= (fastParseInt(m[8]) || 0) * r;
         return new Date(Date.UTC(...args));

package/util/sql-tag.d.ts

@@ -0,0 +1,60 @@
+import { DataTypeMap } from '../data-type-map.js';
+import type { DataMappingOptions } from '../interfaces/data-mapping-options.js';
+/**
+ * A statement built by the `sql` tag: its text with the values pulled out.
+ *
+ * The same object serves both protocols, which is the point of building it
+ * rather than a string. query() takes `sql` and `params` and lets the server
+ * receive the values out of band, where they can never be read as SQL.
+ * execute() has no such option - the Simple Query protocol carries no
+ * parameters at all - so it takes stringify(), which writes the values into
+ * the statement as properly encoded literals.
+ *
+ * Those two are not equally strong. Parameters are safe by construction;
+ * literals are only as safe as the encoder, which is why stringify() refuses
+ * to guess (see below) instead of producing something that looks plausible.
+ */
+export declare class QueryRequest {
+    readonly sql: string;
+    readonly params: any[];
+    constructor(text: string, params: any[]);
+    /**
+     * The statement with its values written in as literals, for the Simple
+     * Query protocol.
+     *
+     * Every value is encoded by its own data type and given an explicit cast:
+     * a parameter carries its OID in the Bind message, but a literal carries
+     * nothing, so without the cast the server would infer a type from context
+     * and the same statement could mean different things through query() and
+     * execute(). A value whose type has no text encoding throws rather than
+     * falling back to a generic conversion.
+     */
+    stringify(options?: DataMappingOptions & {
+        typeMap?: DataTypeMap;
+    }): string;
+}
+/**
+ * Builds a QueryRequest from a template literal, turning every interpolated
+ * value into a bind parameter.
+ *
+ * ```ts
+ * await connection.query(sql`select * from t where id = any(${[1, 3]})`);
+ * ```
+ *
+ * A nested QueryRequest is spliced in as a fragment with its parameters
+ * renumbered, so a statement can be assembled from pieces:
+ *
+ * ```ts
+ * const filter = city ? sql`where city = ${city}` : sql``;
+ * await connection.query(sql`select * from t ${filter} order by id`);
+ * ```
+ *
+ * Interpolated values are never written into the text, so this is not string
+ * building with extra steps - there is no way for a value to be read as SQL.
+ */
+export declare function sql(strings: TemplateStringsArray, ...values: any[]): QueryRequest;
+export declare namespace sql {
+    var ident: (name: string) => QueryRequest;
+    var values: (data: Record<string, any> | Record<string, any>[], columns?: string[]) => QueryRequest;
+    var set: (data: Record<string, any>, columns?: string[]) => QueryRequest;
+}

package/util/sql-tag.js

@@ -0,0 +1,202 @@
+import { BindParam } from '../connection/bind-param.js';
+import { DataTypeMap, GlobalTypeMap } from '../data-type-map.js';
+import { escapeIdentifier } from './escape-identifier.js';
+import { escapeLiteral } from './escape-literal.js';
+/**
+ * A statement built by the `sql` tag: its text with the values pulled out.
+ *
+ * The same object serves both protocols, which is the point of building it
+ * rather than a string. query() takes `sql` and `params` and lets the server
+ * receive the values out of band, where they can never be read as SQL.
+ * execute() has no such option - the Simple Query protocol carries no
+ * parameters at all - so it takes stringify(), which writes the values into
+ * the statement as properly encoded literals.
+ *
+ * Those two are not equally strong. Parameters are safe by construction;
+ * literals are only as safe as the encoder, which is why stringify() refuses
+ * to guess (see below) instead of producing something that looks plausible.
+ */
+export class QueryRequest {
+    sql;
+    params;
+    constructor(text, params) {
+        this.sql = text;
+        this.params = params;
+    }
+    /**
+     * The statement with its values written in as literals, for the Simple
+     * Query protocol.
+     *
+     * Every value is encoded by its own data type and given an explicit cast:
+     * a parameter carries its OID in the Bind message, but a literal carries
+     * nothing, so without the cast the server would infer a type from context
+     * and the same statement could mean different things through query() and
+     * execute(). A value whose type has no text encoding throws rather than
+     * falling back to a generic conversion.
+     */
+    stringify(options) {
+        const typeMap = options?.typeMap || GlobalTypeMap;
+        const params = this.params;
+        if (!params.length)
+            return this.sql;
+        // $1..$n, longest first so $10 is not matched as $1 followed by "0".
+        return this.sql.replace(/\$(\d+)/g, (match, n) => {
+            const i = +n - 1;
+            if (i < 0 || i >= params.length)
+                return match;
+            return encodeLiteral(params[i], typeMap, options);
+        });
+    }
+}
+/**
+ * Builds a QueryRequest from a template literal, turning every interpolated
+ * value into a bind parameter.
+ *
+ * ```ts
+ * await connection.query(sql`select * from t where id = any(${[1, 3]})`);
+ * ```
+ *
+ * A nested QueryRequest is spliced in as a fragment with its parameters
+ * renumbered, so a statement can be assembled from pieces:
+ *
+ * ```ts
+ * const filter = city ? sql`where city = ${city}` : sql``;
+ * await connection.query(sql`select * from t ${filter} order by id`);
+ * ```
+ *
+ * Interpolated values are never written into the text, so this is not string
+ * building with extra steps - there is no way for a value to be read as SQL.
+ */
+export function sql(strings, ...values) {
+    const params = [];
+    let text = '';
+    const l = strings.length;
+    let i;
+    for (i = 0; i < l; i++) {
+        text += strings[i];
+        if (i >= values.length)
+            continue;
+        const v = values[i];
+        if (v instanceof QueryRequest) {
+            // Renumber the fragment's placeholders onto this statement's params.
+            const offset = params.length;
+            text += v.sql.replace(/\$(\d+)/g, (_m, n) => '$' + (+n + offset));
+            params.push(...v.params);
+            continue;
+        }
+        params.push(v);
+        text += '$' + params.length;
+    }
+    return new QueryRequest(text, params);
+}
+/**
+ * Quotes a table, column or schema name for use inside a `sql` template.
+ *
+ * Values become parameters, but names cannot: `$1` is always a value, so
+ * `sql`select ${col} from t`` selects the string, not the column. This
+ * writes the name into the statement instead, quoted the way PostgreSQL's
+ * own `quote_ident()` does.
+ *
+ * ```ts
+ * await connection.query(sql`select ${sql.ident(col)} from ${sql.ident(table)}`);
+ * ```
+ */
+sql.ident = function ident(name) {
+    return new QueryRequest(escapeIdentifier(name), []);
+};
+/**
+ * Builds the column list and VALUES clause of an INSERT from an object, or
+ * from an array of objects for a multi-row insert.
+ *
+ * ```ts
+ * await connection.query(sql`insert into users ${sql.values(user)}`);
+ * // insert into users ("id","name") values ($1,$2)
+ * ```
+ *
+ * `columns` restricts and orders what is written. Pass it whenever the
+ * object comes from outside - a request body, say. Without it the columns
+ * are whatever keys the object happens to carry, so a caller could add one
+ * you did not intend to accept. The values are always parameters, so this
+ * is not an SQL injection either way; it is the column list that needs
+ * deciding by you rather than by the input.
+ */
+sql.values = function values(data, columns) {
+    const rows = Array.isArray(data) ? data : [data];
+    if (!rows.length)
+        throw new TypeError('sql.values() needs at least one row');
+    const cols = columns ?? Object.keys(rows[0]);
+    if (!cols.length)
+        throw new TypeError('sql.values() needs at least one column');
+    const params = [];
+    const tuples = rows.map(row => {
+        const placeholders = cols.map(c => {
+            params.push(row[c]);
+            return '$' + params.length;
+        });
+        return `(${placeholders.join(',')})`;
+    });
+    const names = cols.map(escapeIdentifier).join(',');
+    return new QueryRequest(`(${names}) values ${tuples.join(',')}`, params);
+};
+/**
+ * Builds the assignment list of an UPDATE from an object.
+ *
+ * ```ts
+ * await connection.query(
+ *   sql`update users set ${sql.set({ city })} where id = ${id}`,
+ * );
+ * // update users set "city" = $1 where id = $2
+ * ```
+ *
+ * `columns` restricts what is written, for the same reason as in
+ * sql.values().
+ */
+sql.set = function set(data, columns) {
+    const cols = columns ?? Object.keys(data);
+    if (!cols.length)
+        throw new TypeError('sql.set() needs at least one column');
+    const params = [];
+    const assignments = cols.map(c => {
+        params.push(data[c]);
+        return `${escapeIdentifier(c)} = $${params.length}`;
+    });
+    return new QueryRequest(assignments.join(', '), params);
+};
+function encodeLiteral(value, typeMap, options) {
+    let v = value;
+    let oid;
+    if (v instanceof BindParam) {
+        oid = v.oid;
+        v = v.value;
+    }
+    if (v == null)
+        return 'null';
+    oid = oid ?? typeMap.determine(v);
+    /* c8 ignore start - typeMap.determine() always falls back to the
+       "unknown" oid rather than returning null/undefined, so this can't
+       currently be reached through any public call path. */
+    if (oid == null)
+        throw new TypeError(`Cannot write ${describe(v)} into a statement as a literal: no data type matches it. ` +
+            `Use query() instead, which sends it as a parameter.`);
+    /* c8 ignore stop */
+    const dataType = typeMap.get(oid);
+    if (!dataType?.encodeText)
+        throw new TypeError(`Cannot write ${describe(v)} into a statement as a literal: ` +
+            `data type "${dataType?.name ?? oid}" has no text encoding. ` +
+            `Use query() instead, which sends it as a parameter.`);
+    const cast = dataType.name;
+    if (dataType.elementsOID) {
+        const elementType = typeMap.get(dataType.elementsOID);
+        const arr = (Array.isArray(v) ? v : [v]).map(x => x == null
+            ? 'null'
+            : escapeLiteral(elementType.encodeText(x, options || {})));
+        return `ARRAY[${arr.join(',')}]::${cast}`;
+    }
+    return `${escapeLiteral(dataType.encodeText(v, options || {}))}::${cast}`;
+}
+function describe(v) {
+    const t = typeof v;
+    if (t === 'object')
+        return v.constructor?.name || 'object';
+    return t;
+}

package/util/starts-transaction.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Does this SQL open a transaction?
+ *
+ * Pool.query()/Pool.execute() may share one connection between several
+ * in-flight queries, which is only safe while none of them opens a
+ * transaction: the others are already dispatched on that connection by the
+ * time a BEGIN takes effect, so they would silently join it. Knowing
+ * BEFORE dispatch is what makes the difference between routing the
+ * statement to a connection of its own - where it simply works - and
+ * finding out afterwards, when the damage is done and all that is left is
+ * to report it.
+ *
+ * Two passes: a cheap regex rejects the overwhelming majority, and only a
+ * hit pays for the accurate scan below, which skips comments and quoted
+ * text so `select 'begin'`, `-- begin`, and a `DO $$ BEGIN ... END $$`
+ * block (PL/pgSQL, not a transaction) are not mistaken for one. It looks
+ * ANYWHERE rather than only at the start, since execute() runs
+ * multi-statement scripts where the BEGIN can be the second statement.
+ *
+ * What it cannot see is a transaction opened inside a called procedure -
+ * no reading of the SQL can reveal that. Pool keeps a second, authoritative
+ * check on the server's own transaction status for exactly that case.
+ */
+export declare function startsTransaction(sql: string): boolean;
+/**
+ * Reports whether `sql` contains a COPY statement.
+ *
+ * Pooled pipelining has to refuse these outright: a COPY puts the server
+ * into copy-in/copy-out mode, where the only messages it will accept are
+ * CopyData/CopyDone/CopyFail - the next pipelined query's Query message
+ * arriving mid-copy is a protocol error that takes the whole shared
+ * connection down with it, not just that one caller.
+ *
+ * Deliberately blunt: it matches the word anywhere outside comments and
+ * quoted text, so a column actually named "copy" costs its query a
+ * dedicated connection. That is the harmless direction to be wrong in.
+ */
+export declare function startsCopy(sql: string): boolean;

package/util/starts-transaction.js

@@ -0,0 +1,148 @@
+// Cheap first pass. Almost no statement contains either word, so almost
+// every pooled query is decided by this one scan and never reaches the
+// accurate (and more expensive) pass below. It over-matches on purpose -
+// comments, string literals and PL/pgSQL blocks all get through here.
+const MAYBE_TRANSACTION = /\b(?:begin|start)\b/i;
+const MAYBE_COPY = /\bcopy\b/i;
+function isWordChar(code) {
+    return ((code >= 48 && code <= 57) || // 0-9
+        (code >= 65 && code <= 90) || // A-Z
+        (code >= 97 && code <= 122) || // a-z
+        code === 95 || // _
+        code === 36 // $
+    );
+}
+/** Case-insensitive whole-word match of `word` at `at`. */
+function matchesWord(sql, at, word) {
+    if (at + word.length > sql.length)
+        return false;
+    for (let i = 0; i < word.length; i++) {
+        if ((sql.charCodeAt(at + i) | 32) !== word.charCodeAt(i))
+            return false;
+    }
+    if (at > 0 && isWordChar(sql.charCodeAt(at - 1)))
+        return false;
+    const after = at + word.length;
+    return after >= sql.length || !isWordChar(sql.charCodeAt(after));
+}
+/** Skips whitespace, then reports whether `word` follows. */
+function nextWordIs(sql, from, word) {
+    let i = from;
+    while (i < sql.length && /\s/.test(sql[i]))
+        i++;
+    return matchesWord(sql, i, word);
+}
+/**
+ * Walks `sql` calling `at(i)` at every position that is real code, skipping
+ * line and (nestable) block comments, single- and double-quoted text and
+ * dollar-quoted bodies. Reports whether `at` ever returned true, stopping
+ * at the first one that does.
+ */
+function scanCode(sql, at) {
+    const n = sql.length;
+    let i = 0;
+    while (i < n) {
+        const c = sql[i];
+        if (c === '-' && sql[i + 1] === '-') {
+            const nl = sql.indexOf('\n', i + 2);
+            i = nl === -1 ? n : nl + 1;
+            continue;
+        }
+        if (c === '/' && sql[i + 1] === '*') {
+            // Block comments nest in PostgreSQL, unlike in most SQL dialects.
+            let depth = 1;
+            i += 2;
+            while (i < n && depth > 0) {
+                if (sql[i] === '/' && sql[i + 1] === '*') {
+                    depth++;
+                    i += 2;
+                }
+                else if (sql[i] === '*' && sql[i + 1] === '/') {
+                    depth--;
+                    i += 2;
+                }
+                else
+                    i++;
+            }
+            continue;
+        }
+        // '...' literal or "..." identifier; a doubled quote escapes itself.
+        if (c === "'" || c === '"') {
+            i++;
+            while (i < n) {
+                if (sql[i] === c) {
+                    if (sql[i + 1] === c)
+                        i += 2;
+                    else {
+                        i++;
+                        break;
+                    }
+                }
+                else
+                    i++;
+            }
+            continue;
+        }
+        // $tag$ ... $tag$ - function bodies live in these, and the BEGIN of a
+        // PL/pgSQL block is not a transaction.
+        if (c === '$') {
+            const tag = /^\$(?:[A-Za-z_][A-Za-z0-9_]*)?\$/.exec(sql.slice(i))?.[0];
+            if (tag) {
+                const end = sql.indexOf(tag, i + tag.length);
+                i = end === -1 ? n : end + tag.length;
+                continue;
+            }
+        }
+        if (at(i))
+            return true;
+        i++;
+    }
+    return false;
+}
+/**
+ * Does this SQL open a transaction?
+ *
+ * Pool.query()/Pool.execute() may share one connection between several
+ * in-flight queries, which is only safe while none of them opens a
+ * transaction: the others are already dispatched on that connection by the
+ * time a BEGIN takes effect, so they would silently join it. Knowing
+ * BEFORE dispatch is what makes the difference between routing the
+ * statement to a connection of its own - where it simply works - and
+ * finding out afterwards, when the damage is done and all that is left is
+ * to report it.
+ *
+ * Two passes: a cheap regex rejects the overwhelming majority, and only a
+ * hit pays for the accurate scan below, which skips comments and quoted
+ * text so `select 'begin'`, `-- begin`, and a `DO $$ BEGIN ... END $$`
+ * block (PL/pgSQL, not a transaction) are not mistaken for one. It looks
+ * ANYWHERE rather than only at the start, since execute() runs
+ * multi-statement scripts where the BEGIN can be the second statement.
+ *
+ * What it cannot see is a transaction opened inside a called procedure -
+ * no reading of the SQL can reveal that. Pool keeps a second, authoritative
+ * check on the server's own transaction status for exactly that case.
+ */
+export function startsTransaction(sql) {
+    if (!MAYBE_TRANSACTION.test(sql))
+        return false;
+    return scanCode(sql, i => matchesWord(sql, i, 'begin') ||
+        (matchesWord(sql, i, 'start') && nextWordIs(sql, i + 5, 'transaction')));
+}
+/**
+ * Reports whether `sql` contains a COPY statement.
+ *
+ * Pooled pipelining has to refuse these outright: a COPY puts the server
+ * into copy-in/copy-out mode, where the only messages it will accept are
+ * CopyData/CopyDone/CopyFail - the next pipelined query's Query message
+ * arriving mid-copy is a protocol error that takes the whole shared
+ * connection down with it, not just that one caller.
+ *
+ * Deliberately blunt: it matches the word anywhere outside comments and
+ * quoted text, so a column actually named "copy" costs its query a
+ * dedicated connection. That is the harmless direction to be wrong in.
+ */
+export function startsCopy(sql) {
+    if (!MAYBE_COPY.test(sql))
+        return false;
+    return scanCode(sql, i => matchesWord(sql, i, 'copy'));
+}

package/util/stringify-arrayliteral.js

@@ -1,12 +1,19 @@
 import { arrayCalculateDim } from './array-calculatedim.js';
 export function stringifyArrayLiteral(value, options, encode) {
     const dim = arrayCalculateDim(value);
+    // `dim` is built once above and never mutated, so its last index is
+    // invariant across the whole recursion - not just this loop. Reading
+    // dim.length (a property load) and subtracting on every element of every
+    // level was the only per-element work here that didn't depend on the
+    // element.
+    const lastLevel = dim.length - 1;
     const writeDim = (arr, level) => {
         const elemCount = dim[level];
         const out = [];
+        const isLeafLevel = level >= lastLevel;
         for (let i = 0; i < elemCount; i++) {
             let x = arr && arr[i];
-            if (level < dim.length - 1) {
+            if (!isLeafLevel) {
                 if (x != null && !Array.isArray(x))
                     x = [x];
                 out.push(writeDim(x, level + 1));
@@ -17,10 +24,15 @@ export function stringifyArrayLiteral(value, options, encode) {
                 out.push('NULL');
                 continue;
             }
+            /* c8 ignore start - dim is (re)computed above from a DFS that visits
+               every array node in `value` and deepens dim to match, so a value
+               can never actually be an array once `level` reaches the leaf -
+               if it were, dim would already have gone one level deeper there. */
             if (Array.isArray(x)) {
                 out.push(stringifyArrayLiteral(x, options, encode));
                 continue;
             }
+            /* c8 ignore stop */
             if (encode)
                 x = encode(x, options || {});
             out.push(escapeArrayItem('' + x));

package/util/wrap-row-description.js

@@ -1,4 +1,14 @@
 import { DataFormat, DataTypeNames } from '../constants.js';
+// DataTypeNames (oid -> name) is a static, never-mutated map, so its
+// reverse (name -> oid) can be precomputed once here instead of rebuilding
+// Object.keys(DataTypeNames) and linearly rescanning it (with no early
+// exit) for every array-typed column in every query. Duplicate names would
+// resolve to the same "last one wins" oid either way, matching the old
+// loop's behavior exactly.
+const DataTypeOIDByName = {};
+for (const oid of Object.keys(DataTypeNames)) {
+    DataTypeOIDByName[DataTypeNames[oid]] = Number(oid);
+}
 export function wrapRowDescription(typeMap, fields, columnFormat) {
     return fields.map((f, idx) => {
         const cf = Array.isArray(columnFormat) ? columnFormat[idx] : columnFormat;
@@ -13,10 +23,9 @@ export function wrapRowDescription(typeMap, fields, columnFormat) {
         x.isArray = x.dataTypeName.startsWith('_');
         if (x.isArray) {
             x.elementDataTypeName = x.dataTypeName.substring(1);
-            for (const oid of Object.keys(DataTypeNames)) {
-                if (DataTypeNames[oid] === x.elementDataTypeName)
-                    x.elementDataTypeId = parseInt(oid, 10);
-            }
+            const elementOid = DataTypeOIDByName[x.elementDataTypeName];
+            if (elementOid !== undefined)
+                x.elementDataTypeId = elementOid;
         }
         if (f.fixedSize && f.fixedSize > 0)
             x.fixedSize = f.fixedSize;

package/util/convert-row-to-object.d.ts

@@ -1,2 +0,0 @@
-import type { FieldInfo } from '../interfaces/field-info.js';
-export declare function convertRowToObject(fields: FieldInfo[], row: any[]): any;

package/util/convert-row-to-object.js

@@ -1,9 +0,0 @@
-export function convertRowToObject(fields, row) {
-    const out = {};
-    const l = row.length;
-    let i;
-    for (i = 0; i < l; i++) {
-        out[fields[i].fieldName] = row[i];
-    }
-    return out;
-}