@sqb/connect 4.0.9 → 4.0.13

package/dist/client/SqbClient.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqbClient = void 0;
+const tslib_1 = require("tslib");
+const lightning_pool_1 = require("lightning-pool");
+const putil_varhelpers_1 = require("putil-varhelpers");
+const strict_typed_events_1 = require("strict-typed-events");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const SqbConnection_1 = require("./SqbConnection");
+const extensions_1 = require("./extensions");
+const repository_class_1 = require("../orm/repository.class");
+const entity_model_1 = require("../orm/model/entity-model");
+const debug = (0, debug_1.default)('sqb:client');
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+class SqbClient extends (0, strict_typed_events_1.TypedEventEmitterClass)(strict_typed_events_1.AsyncEventEmitter) {
+    constructor(config) {
+        super();
+        this._entities = {};
+        if (!(config && typeof config === 'object'))
+            throw new TypeError('Configuration object required');
+        let adapter;
+        if (config.driver) {
+            adapter = extensions_1.adapters.find(x => x.driver === config.driver);
+            if (!adapter)
+                throw new Error(`No database adapter registered for "${config.driver}" driver`);
+        }
+        else if (config.dialect) {
+            adapter = extensions_1.adapters.find(x => x.dialect === config.dialect);
+            if (!adapter)
+                throw new Error(`No database adapter registered for "${config.dialect}" dialect`);
+        }
+        if (!adapter)
+            throw new Error(`You must provide one of "driver" or "dialect" properties`);
+        this._adapter = adapter;
+        this._defaults = config.defaults || {};
+        const poolOptions = {};
+        const popts = config.pool || {};
+        poolOptions.acquireMaxRetries = (0, putil_varhelpers_1.coerceToInt)(popts.acquireMaxRetries, 0);
+        poolOptions.acquireRetryWait = (0, putil_varhelpers_1.coerceToInt)(popts.acquireRetryWait, 2000);
+        poolOptions.acquireTimeoutMillis = (0, putil_varhelpers_1.coerceToInt)(popts.acquireTimeoutMillis, 0);
+        poolOptions.idleTimeoutMillis = (0, putil_varhelpers_1.coerceToInt)(popts.idleTimeoutMillis, 30000);
+        poolOptions.max = (0, putil_varhelpers_1.coerceToInt)(popts.max, 10);
+        poolOptions.maxQueue = (0, putil_varhelpers_1.coerceToInt)(popts.maxQueue, 1000);
+        poolOptions.max = (0, putil_varhelpers_1.coerceToInt)(popts.max, 10);
+        poolOptions.min = (0, putil_varhelpers_1.coerceToInt)(popts.min, 0);
+        poolOptions.minIdle = (0, putil_varhelpers_1.coerceToInt)(popts.minIdle, 0);
+        poolOptions.validation = (0, putil_varhelpers_1.coerceToBoolean)(popts.validation, false);
+        const cfg = { ...config };
+        const poolFactory = {
+            create: () => adapter.connect(cfg),
+            destroy: instance => instance.close(),
+            reset: instance => instance.reset(),
+            validate: instance => instance.test()
+        };
+        this._pool = (0, lightning_pool_1.createPool)(poolFactory, poolOptions);
+        this._pool.on('closing', () => this.emit('closing'));
+        this._pool.on('close', () => this.emit('close'));
+        this._pool.on('terminate', () => this.emit('terminate'));
+        // @ts-ignore
+        this._pool.on('error', (...args) => this.emit('error', ...args));
+    }
+    get defaults() {
+        return this._defaults;
+    }
+    /**
+     * Returns dialect
+     */
+    get dialect() {
+        return this._adapter.dialect;
+    }
+    /**
+     * Returns database driver name
+     */
+    get driver() {
+        return this._adapter.driver;
+    }
+    /**
+     * Returns true if pool is closed
+     */
+    get isClosed() {
+        return this._pool.state === lightning_pool_1.PoolState.CLOSED;
+    }
+    get pool() {
+        return this._pool;
+    }
+    async acquire(arg0, arg1) {
+        debug('acquire');
+        if (typeof arg0 === 'function') {
+            const connection = await this.acquire(arg1);
+            try {
+                return await arg0(connection);
+            }
+            finally {
+                connection.release();
+            }
+        }
+        const options = arg1;
+        const adapterConnection = await this._pool.acquire();
+        const opts = { autoCommit: this.defaults.autoCommit, ...options };
+        const connection = new SqbConnection_1.SqbConnection(this, adapterConnection, opts);
+        await this.emitAsyncSerial('acquire', connection);
+        connection.on('execute', (request) => this.emit('execute', request));
+        connection.on('error', (error) => this.emit('error', error));
+        return connection;
+    }
+    /**
+     * Shuts down the pool and destroys all resources.
+     */
+    async close(terminateWait) {
+        const ms = terminateWait == null ? Infinity : 0;
+        return this._pool.close(ms);
+    }
+    async execute(query, options) {
+        debug('execute');
+        const connection = await this.acquire();
+        try {
+            const qr = await connection.execute(query, options);
+            if (qr && qr.cursor) {
+                connection.retain();
+                qr.cursor.once('close', () => connection.release());
+            }
+            return qr;
+        }
+        finally {
+            connection.release();
+        }
+    }
+    /**
+     * Tests the pool
+     */
+    async test() {
+        const connection = await this.acquire();
+        try {
+            await connection.test();
+        }
+        finally {
+            connection.release();
+        }
+    }
+    getRepository(entity, opts) {
+        let ctor;
+        if (typeof entity === 'string') {
+            ctor = this.getEntity(entity);
+            if (!ctor)
+                throw new Error(`Repository "${entity}" is not registered`);
+        }
+        else
+            ctor = entity;
+        const entityDef = entity_model_1.EntityModel.get(ctor);
+        if (!entityDef)
+            throw new Error(`You must provide an @Entity annotated constructor`);
+        return new repository_class_1.Repository(entityDef, this, opts?.schema);
+    }
+    getEntity(name) {
+        return this._entities[name];
+    }
+    toString() {
+        return '[object ' + Object.getPrototypeOf(this).constructor.name + '(' +
+            this.dialect + ')]';
+    }
+    [inspect]() {
+        return this.toString();
+    }
+}
+exports.SqbClient = SqbClient;

package/dist/client/SqbConnection.d.ts

@@ -0,0 +1,74 @@
+import { classes } from '@sqb/builder';
+import { Type } from 'ts-gems';
+import { SqbClient } from './SqbClient';
+import { ConnectionOptions, QueryExecuteOptions, QueryRequest } from './types';
+import { Adapter } from './Adapter';
+import { Repository } from '../orm/repository.class';
+interface SqbConnectionEvents {
+    close: () => void;
+    execute: (request: QueryRequest) => void;
+    error: (error: Error) => void;
+    retain: (refCount: number) => void;
+    release: (refCount: number) => void;
+    'start-transaction': () => void;
+    'set-savepoint': () => void;
+    'release-savepoint': () => void;
+    'rollback-savepoint': () => void;
+    commit: () => void;
+    rollback: () => void;
+}
+declare const SqbConnection_base: Type<import("strict-typed-events").TypedEventEmitter<any, SqbConnectionEvents, SqbConnectionEvents>>;
+export declare class SqbConnection extends SqbConnection_base {
+    readonly client: SqbClient;
+    private _intlcon?;
+    private readonly _tasks;
+    private readonly _options?;
+    private _inTransaction;
+    private _refCount;
+    constructor(client: SqbClient, adapterConnection: Adapter.Connection, options?: ConnectionOptions);
+    /**
+     * Returns session id
+     */
+    get sessionId(): string;
+    /**
+     * Returns reference counter value
+     */
+    get refCount(): number;
+    /**
+     * Returns true if transaction started
+     */
+    get inTransaction(): boolean;
+    /**
+     * Increases internal reference counter to keep session alive
+     */
+    retain(): void;
+    /**
+     * Decreases the internal reference counter.
+     * When reference count is 0, connection returns to the pool.
+     * Returns true if connection released.
+     */
+    release(): boolean;
+    /**
+     * Immediately releases the connection.
+     */
+    close(): Promise<void>;
+    execute(query: string | classes.Query, options?: QueryExecuteOptions): Promise<any>;
+    getRepository<T>(entity: Type<T> | string, opts?: {
+        schema?: string;
+    }): Repository<T>;
+    getSchema(): Promise<string>;
+    setSchema(schema: string): Promise<void>;
+    /**
+     * Executes a query
+     */
+    protected _execute(query: string | classes.Query, options?: QueryExecuteOptions): Promise<any>;
+    startTransaction(): Promise<void>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    setSavepoint(savepoint: string): Promise<void>;
+    releaseSavepoint(savepoint: string): Promise<void>;
+    rollbackSavepoint(savepoint: string): Promise<void>;
+    test(): Promise<void>;
+    private _prepareQueryRequest;
+}
+export {};

package/dist/client/SqbConnection.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqbConnection = void 0;
+const tslib_1 = require("tslib");
+const builder_1 = require("@sqb/builder");
+const strict_typed_events_1 = require("strict-typed-events");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const putil_varhelpers_1 = require("putil-varhelpers");
+const putil_taskqueue_1 = tslib_1.__importDefault(require("putil-taskqueue"));
+const helpers_1 = require("./helpers");
+const Cursor_1 = require("./Cursor");
+const repository_class_1 = require("../orm/repository.class");
+const entity_model_1 = require("../orm/model/entity-model");
+const debug = (0, debug_1.default)('sqb:connection');
+class SqbConnection extends (0, strict_typed_events_1.TypedEventEmitterClass)(strict_typed_events_1.AsyncEventEmitter) {
+    constructor(client, adapterConnection, options) {
+        super();
+        this.client = client;
+        this._tasks = new putil_taskqueue_1.default();
+        this._inTransaction = false;
+        this._refCount = 1;
+        this._intlcon = adapterConnection;
+        this._options = options || {};
+    }
+    /**
+     * Returns session id
+     */
+    get sessionId() {
+        return this._intlcon && this._intlcon.sessionId;
+    }
+    /**
+     * Returns reference counter value
+     */
+    get refCount() {
+        return this._refCount;
+    }
+    /**
+     * Returns true if transaction started
+     */
+    get inTransaction() {
+        if (this._intlcon && typeof this._intlcon.getInTransaction === 'function') {
+            this._inTransaction = this._intlcon.getInTransaction();
+        }
+        return this._inTransaction;
+    }
+    /**
+     * Increases internal reference counter to keep session alive
+     */
+    retain() {
+        this._refCount++;
+        debug('[%s] retain | refCount: %s', this.sessionId, this._refCount);
+        this.emit('retain', this._refCount);
+    }
+    /**
+     * Decreases the internal reference counter.
+     * When reference count is 0, connection returns to the pool.
+     * Returns true if connection released.
+     */
+    release() {
+        if (!this._intlcon)
+            return true;
+        const ref = --this._refCount;
+        this.emit('release', this._refCount);
+        debug('[%s] release | refCount: %s', this.sessionId, ref);
+        if (!ref) {
+            this.close().catch(() => 0);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Immediately releases the connection.
+     */
+    async close() {
+        if (!this._intlcon)
+            return;
+        await this.emitAsyncSerial('close');
+        const intlcon = this._intlcon;
+        this._intlcon = undefined;
+        this.client.pool.release(intlcon)
+            .catch(e => this.client.emit('error', e));
+        debug('[%s] closed', intlcon.sessionId);
+    }
+    async execute(query, options) {
+        if (!this._intlcon)
+            throw new Error(`Can't execute query, because connection is released`);
+        return this._tasks.enqueue(() => this._execute(query, options));
+    }
+    getRepository(entity, opts) {
+        let ctor;
+        if (typeof entity === 'string') {
+            ctor = this.client.getEntity(entity);
+            if (!ctor)
+                throw new Error(`Repository "${entity}" is not registered`);
+        }
+        else
+            ctor = entity;
+        const entityDef = entity_model_1.EntityModel.get(ctor);
+        if (!entityDef)
+            throw new Error(`You must provide an @Entity annotated constructor`);
+        return new repository_class_1.Repository(entityDef, this, opts?.schema);
+    }
+    async getSchema() {
+        assert_1.default.ok(this._intlcon, `Can't set schema, because connection is released`);
+        assert_1.default.ok(this._intlcon.getSchema, `${this.client.dialect} adapter does have Schema support`);
+        return await this._intlcon.getSchema();
+    }
+    async setSchema(schema) {
+        assert_1.default.ok(this._intlcon, `Can't set schema, because connection is released`);
+        assert_1.default.ok(this._intlcon.setSchema, `${this.client.dialect} adapter does have Schema support`);
+        await this._intlcon.setSchema(schema);
+    }
+    /**
+     * Executes a query
+     */
+    async _execute(query, options) {
+        assert_1.default.ok(this._intlcon, `Can't execute query, because connection is released`);
+        const intlcon = this._intlcon;
+        this.retain();
+        try {
+            const startTime = Date.now();
+            const request = this._prepareQueryRequest(query, options);
+            debug('[%s] execute | %o', this.sessionId, request);
+            this.emit('execute', request);
+            // Call execute hooks
+            if (request.executeHooks) {
+                for (const fn of request.executeHooks) {
+                    await fn(this, request);
+                }
+            }
+            const response = await intlcon.execute(request);
+            if (!response)
+                throw new Error('Database adapter returned an empty response');
+            const result = {
+                executeTime: Date.now() - startTime
+            };
+            if (request.showSql)
+                result.query = request;
+            if (response.rows || response.cursor) {
+                if (!response.fields)
+                    throw new Error('Adapter did not returned fields info');
+                if (!response.rowType)
+                    throw new Error('Adapter did not returned rowType');
+                result.fields = (0, helpers_1.wrapAdapterFields)(response.fields, request.fieldNaming);
+                result.rowType = response.rowType;
+                if (response.rows) {
+                    result.rows = request.objectRows ?
+                        (0, helpers_1.normalizeRowsToObjectRows)(result.fields, response.rowType, response.rows, request) :
+                        (0, helpers_1.normalizeRowsToArrayRows)(result.fields, response.rowType, response.rows, request);
+                    (0, helpers_1.callFetchHooks)(result.rows, request);
+                }
+                else if (response.cursor) {
+                    const cursor = result.cursor = new Cursor_1.Cursor(this, result.fields, response.cursor, request);
+                    const hook = () => cursor.close();
+                    cursor.once('close', () => this.off('close', hook));
+                    this.on('close', hook);
+                }
+            }
+            if (response.rowsAffected)
+                result.rowsAffected = response.rowsAffected;
+            return result;
+        }
+        finally {
+            this.release();
+        }
+    }
+    async startTransaction() {
+        if (!this._intlcon)
+            throw new Error('Can not call startTransaction() on a released connection');
+        await this._intlcon.startTransaction();
+        this._inTransaction = true;
+        this.emit('start-transaction');
+    }
+    async commit() {
+        if (!this._intlcon)
+            throw new Error('Can not call commit() on a released connection');
+        await this._intlcon.commit();
+        this._inTransaction = false;
+        this.emit('commit');
+    }
+    async rollback() {
+        if (!this._intlcon)
+            throw new Error('Can not call rollback() on a released connection');
+        await this._intlcon.rollback();
+        this._inTransaction = false;
+        this.emit('rollback');
+    }
+    async setSavepoint(savepoint) {
+        if (!this._intlcon)
+            throw new Error('Can not call setSavepoint() on a released connection');
+        if (typeof this._intlcon.setSavepoint !== 'function')
+            throw new Error(this.client.driver + ' does not support setSavepoint method');
+        if (!this.inTransaction)
+            await this.startTransaction();
+        await this._intlcon.setSavepoint(savepoint);
+        this.emit('set-savepoint');
+    }
+    async releaseSavepoint(savepoint) {
+        if (!this._intlcon)
+            throw new Error('Can not call releaseSavepoint() on a released connection');
+        if (typeof this._intlcon.releaseSavepoint !== 'function')
+            throw new Error(this.client.driver + ' does not support releaseSavepoint method');
+        await this._intlcon.releaseSavepoint(savepoint);
+        this.emit('release-savepoint');
+    }
+    async rollbackSavepoint(savepoint) {
+        if (!this._intlcon)
+            throw new Error('Can not call rollbackSavepoint() on a released connection');
+        if (typeof this._intlcon.rollbackSavepoint !== 'function')
+            throw new Error(this.client.driver + ' does not support rollbackSavepoint method');
+        await this._intlcon.rollbackSavepoint(savepoint);
+        this.emit('rollback-savepoint');
+    }
+    async test() {
+        if (!this._intlcon)
+            throw new Error('Can not call test() on a released connection');
+        await this._intlcon.test();
+    }
+    _prepareQueryRequest(query, options = {}) {
+        if (!this._intlcon)
+            throw new Error('Session released');
+        const defaults = this.client.defaults;
+        const request = {
+            dialect: this.client.dialect,
+            sql: '',
+            autoCommit: this.inTransaction ? false :
+                (0, putil_varhelpers_1.coerceToBoolean)((0, putil_varhelpers_1.coalesce)(options.autoCommit, this._options?.autoCommit, defaults.autoCommit), true),
+            cursor: (0, putil_varhelpers_1.coerceToBoolean)((0, putil_varhelpers_1.coalesce)(options.cursor, defaults.cursor), false),
+            objectRows: (0, putil_varhelpers_1.coerceToBoolean)((0, putil_varhelpers_1.coalesce)(options.objectRows, defaults.objectRows), true),
+            ignoreNulls: (0, putil_varhelpers_1.coerceToBoolean)((0, putil_varhelpers_1.coalesce)(options.ignoreNulls, defaults.ignoreNulls), false),
+            fetchRows: (0, putil_varhelpers_1.coerceToInt)((0, putil_varhelpers_1.coalesce)(options.fetchRows, defaults.fetchRows), 100),
+            fieldNaming: (0, putil_varhelpers_1.coalesce)(options.namingStrategy, defaults.fieldNaming),
+            transform: (0, putil_varhelpers_1.coalesce)(options.transform, defaults.transform),
+            showSql: (0, putil_varhelpers_1.coerceToBoolean)((0, putil_varhelpers_1.coalesce)(options.showSql, defaults.showSql), false),
+            prettyPrint: (0, putil_varhelpers_1.coerceToBoolean)((0, putil_varhelpers_1.coalesce)(options.prettyPrint, defaults.prettyPrint), false),
+            action: (0, putil_varhelpers_1.coerceToString)(options.action),
+            fetchAsString: options.fetchAsString
+        };
+        request.ignoreNulls = request.ignoreNulls && request.objectRows;
+        if (query instanceof builder_1.classes.Query) {
+            if (this._intlcon.onGenerateQuery)
+                this._intlcon.onGenerateQuery(request, query);
+            const q = query
+                .generate({
+                dialect: request.dialect,
+                dialectVersion: request.dialectVersion,
+                params: options.params,
+                strictParams: true,
+                prettyPrint: request.prettyPrint
+            });
+            request.sql = q.sql;
+            request.params = q.params;
+            request.paramOptions = q.paramOptions;
+            if (q.returningFields)
+                request.returningFields = q.returningFields;
+            if (query.listenerCount('execute'))
+                request.executeHooks = query.listeners('execute');
+            if (query.listenerCount('fetch'))
+                request.fetchHooks = query.listeners('fetch');
+        }
+        else if (typeof query === 'string') {
+            request.sql = query;
+            request.params = options.params;
+        }
+        // @ts-ignore
+        if (!request.sql)
+            throw new Error('No sql given');
+        return request;
+    }
+}
+exports.SqbConnection = SqbConnection;

package/dist/client/extensions.d.ts

@@ -0,0 +1,4 @@
+import { Adapter } from './Adapter';
+export declare let adapters: Adapter[];
+export declare function registerAdapter(adapter: Adapter): void;
+export declare function unRegisterAdapter(...adapter: Adapter[]): void;

package/dist/client/extensions.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unRegisterAdapter = exports.registerAdapter = exports.adapters = void 0;
+exports.adapters = [];
+function registerAdapter(adapter) {
+    if (!adapter.driver)
+        throw new TypeError('A DatabaseAdapter must contain "driver" property');
+    exports.adapters.push(adapter);
+}
+exports.registerAdapter = registerAdapter;
+function unRegisterAdapter(...adapter) {
+    exports.adapters = exports.adapters.filter(x => !adapter.includes(x));
+}
+exports.unRegisterAdapter = unRegisterAdapter;

package/dist/client/helpers.d.ts

@@ -0,0 +1,9 @@
+import { Maybe } from 'ts-gems';
+import { ArrayRowset, FieldNaming, ObjectRowset, QueryRequest } from './types';
+import { FieldInfoMap } from './FieldInfoMap';
+import { Adapter } from './Adapter';
+export declare function applyNamingStrategy(value: string, namingStrategy?: FieldNaming): Maybe<string>;
+export declare function wrapAdapterFields(oldFields: Adapter.Field[], fieldNaming?: FieldNaming): FieldInfoMap;
+export declare function normalizeRowsToObjectRows(fields: FieldInfoMap, rowType: 'array' | 'object', oldRows: ObjectRowset | ArrayRowset, options?: Pick<QueryRequest, 'ignoreNulls' | 'transform'>): Record<string, any>[];
+export declare function normalizeRowsToArrayRows(fields: FieldInfoMap, rowType: 'array' | 'object', oldRows: ObjectRowset | ArrayRowset, options?: Pick<QueryRequest, 'ignoreNulls' | 'transform'>): any[][];
+export declare function callFetchHooks(rows: ObjectRowset | ArrayRowset, request: QueryRequest): void;

package/dist/client/helpers.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callFetchHooks = exports.normalizeRowsToArrayRows = exports.normalizeRowsToObjectRows = exports.wrapAdapterFields = exports.applyNamingStrategy = void 0;
+const putil_varhelpers_1 = require("putil-varhelpers");
+const FieldInfoMap_1 = require("./FieldInfoMap");
+function applyNamingStrategy(value, namingStrategy) {
+    if (typeof namingStrategy === 'string' && namingStrategy !== 'original') {
+        switch (namingStrategy.toLowerCase()) {
+            case 'lowercase':
+                return value.toLowerCase();
+            case 'uppercase':
+                return value.toUpperCase();
+            case 'camelcase':
+                if (!value.match(/[a-z]/))
+                    return (0, putil_varhelpers_1.camelCase)(value.toLowerCase());
+                value = (0, putil_varhelpers_1.camelCase)(value);
+                return value[0].toLowerCase() + value.substring(1);
+            case 'pascalcase':
+                if (!value.match(/[a-z]/))
+                    return (0, putil_varhelpers_1.pascalCase)(value.toLowerCase());
+                return (0, putil_varhelpers_1.pascalCase)(value);
+        }
+    }
+    else if (typeof namingStrategy === 'function')
+        return namingStrategy(value);
+    return value;
+}
+exports.applyNamingStrategy = applyNamingStrategy;
+function wrapAdapterFields(oldFields, fieldNaming) {
+    const mapFieldInfo = (f, index) => {
+        const name = applyNamingStrategy(f.fieldName, fieldNaming);
+        if (name)
+            return { ...f, name, index };
+    };
+    const result = new FieldInfoMap_1.FieldInfoMap();
+    let i = 0;
+    oldFields.forEach(f => {
+        const x = mapFieldInfo(f, i);
+        if (x) {
+            i++;
+            result.add(x);
+        }
+    });
+    return result;
+}
+exports.wrapAdapterFields = wrapAdapterFields;
+function normalizeRowsToObjectRows(fields, rowType, oldRows, options) {
+    return normalizeRows(fields, rowType, oldRows, { ...options, objectRows: true });
+}
+exports.normalizeRowsToObjectRows = normalizeRowsToObjectRows;
+function normalizeRowsToArrayRows(fields, rowType, oldRows, options) {
+    return normalizeRows(fields, rowType, oldRows, { ...options, objectRows: false });
+}
+exports.normalizeRowsToArrayRows = normalizeRowsToArrayRows;
+function normalizeRows(fields, rowType, oldRows, options) {
+    const ignoreNulls = options.ignoreNulls && options.objectRows;
+    const transform = options.transform;
+    const coerceValue = (v, f) => {
+        if (v === undefined)
+            return;
+        if (transform)
+            v = transform(v, f);
+        if (v === null && ignoreNulls)
+            return;
+        return v;
+    };
+    if (options.objectRows) {
+        if (rowType === 'array') {
+            return oldRows.map((row) => {
+                const r = {};
+                for (const f of fields.values()) {
+                    const v = coerceValue(row[f.index], f);
+                    if (v !== undefined)
+                        r[f.name] = v;
+                }
+                return r;
+            });
+        }
+        let hasFieldNaming = false;
+        for (const f of fields.values()) {
+            if (f.name !== f.fieldName) {
+                hasFieldNaming = true;
+                break;
+            }
+        }
+        if (hasFieldNaming || transform) {
+            return oldRows.map((row) => {
+                const r = {};
+                for (const f of fields.values()) {
+                    const v = coerceValue(row[f.fieldName], f);
+                    if (v !== undefined)
+                        r[f.name] = v;
+                }
+                return r;
+            });
+        }
+        if (ignoreNulls) {
+            oldRows.forEach(row => {
+                for (const [k, v] of Object.entries(row)) {
+                    if (v === null)
+                        delete row[k];
+                }
+            });
+        }
+        return oldRows;
+    }
+    if (rowType === 'array') {
+        oldRows.forEach((row) => {
+            for (const [i, v] of row.entries()) {
+                row[i] = coerceValue(v, fields.get(i));
+            }
+        });
+        return oldRows;
+    }
+    return oldRows.map((row) => {
+        const r = [];
+        for (const f of fields.values()) {
+            r[f.index] = coerceValue(row[f.fieldName], f);
+        }
+        return r;
+    });
+}
+function callFetchHooks(rows, request) {
+    const fetchHooks = request.fetchHooks;
+    if (!fetchHooks)
+        return;
+    for (const row of rows) {
+        for (const fn of fetchHooks) {
+            fn(row, request);
+        }
+    }
+}
+exports.callFetchHooks = callFetchHooks;