@leapfrogtechnology/db-model/dist/db.d.ts

Low-footprint database abstraction layer and model built on top of Knex.

import * as Knex from 'knex';
import RawBindingParams, { ValueMap } from './domain/RawBindingParams';
interface BatchUpdateOptions {
    dataSize: number;
    batchSize: number;
    log?: (msg: any) => any;
}
/**
 * Check if the provided object is a knex connection instance.
 *
 * @param {any} obj
 * @returns {boolean}
 */
export declare function isKnexInstance(obj: any): obj is Knex;
/**
 * Creates a knex database connection instance from
 * the provided database configuration.
 *
 * @param {Knex.Config} dbConfig
 * @returns {Knex}
 */
export declare function createInstance(dbConfig: Knex.Config): Knex;
/**
 * Check database connection from provided knex params.
 *
 * @param {Knex.Config | Knex | Knex.Transaction} connection
 * @returns {Promise<boolean>}
 */
export declare function isValidConnection(connection: Knex.Config | Knex | Knex.Transaction): Promise<boolean>;
/**
 * Returns a query builder instance depending on the provided transaction.
 *
 * @param {Knex} connection
 * @param {Knex.Transaction} [trx]
 * @returns {(Knex.Transaction | Knex)}
 */
export declare function queryBuilder(connection: Knex, trx?: Knex.Transaction): Knex.Transaction | Knex;
/**
 * Finds a record based on the params.
 *
 * @param {Knex} connection
 * @param {string} table
 * @param {object} [params={}]
 * @param {Function} callback
 * @param {Knex.Transaction} [trx]
 * @returns {Knex.QueryBuilder}
 */
export declare function find<T>(connection: Knex, table: string, params?: object, callback?: any, trx?: Knex.Transaction): Knex.QueryBuilder;
/**
 * Finds a single record based on the params.
 *
 * @param {Knex} connection
 * @param {string} table
 * @param {object} [params={}]
 * @param {Function} callback
 * @param {Knex.Transaction} [trx]
 * @returns {(Promise<T | null>)}
 */
export declare function findFirst<T>(connection: Knex, table: string, params?: object, callback?: any, trx?: Knex.Transaction): Promise<T | null>;
/**
 * Insert all records sent in data object.
 *
 * @param {Knex} connection
 * @param {string} table
 * @param {(object | object[])} data
 * @param {Knex.Transaction} [trx]
 * @returns {Knex.QueryBuilder}
 */
export declare function insert<T>(connection: Knex, table: string, data: object | object[], trx?: Knex.Transaction): Knex.QueryBuilder;
/**
 * Update records by where condition.
 *
 * @param {object} where
 * @param {object} params
 * @param {Transaction} transaction
 * @returns {Promise<T[]>}
 */
export declare function update<T>(connection: Knex, table: string, where: object, params: object, trx?: Knex.Transaction): Promise<T[]>;
/**
 * Delete row in table.
 *
 * @param {Knex} connection
 * @param {string} table
 * @param {object} params
 * @param {Transaction} trx
 * @returns {Promise<T[]>}
 */
export declare function remove<T>(connection: Knex, table: string, params: object, trx?: Knex.Transaction): Promise<T[]>;
/**
 * Execute SQL raw query and return results.
 *
 * @param {Knex} connection
 * @param {string} sql
 * @param {RawBindingParams | ValueMap} [params]
 * @param {Knex.Transaction} [trx]
 * @returns {Promise<T[]>}
 */
export declare function query<T>(connection: Knex, sql: string, params?: RawBindingParams | ValueMap, trx?: Knex.Transaction): Promise<T[]>;
/**
 * Batch inserts the given data.
 *
 * @param {Knex} connection
 * @param {string} table
 * @param {object[]} data
 * @param {number} chunkSize
 * @param {Knex.Transaction} [trx]
 * @returns {Promise<T[]>}
 */
export declare function batchInsert<T>(connection: Knex, table: string, data: object[], chunkSize: number, trx?: Knex.Transaction): Promise<T[]>;
/**
 * Execute SQL raw query returning a scalar value.
 *
 * Example:
 *  const count:number = await db.getValue<number>(
 *    connection,
 *    'SELECT count(id) FROM jobs WHERE is_active = 1'
 *  );
 *
 * @param {Knex} connection
 * @param {string} sql
 * @param {any} params
 * @param {Knex.Transaction} trx
 * @returns {Promise<T | null>}
 */
export declare function getValue<T>(connection: Knex, sql: string, params?: any, trx?: Knex.Transaction): Promise<T | null>;
/**
 * Execute SQL raw query returning a boolean result.
 *
 * Example:
 *  const result:boolean = await db.check(
 *    connection,
 *    'SELECT is_active FROM jobs WHERE id = :jobId'
 *  );
 *
 * @param {Knex} connection
 * @param {string} sql
 * @param {any} params
 * @param {Knex.Transaction} trx
 * @returns {Promise<boolean>}
 */
export declare function check(connection: Knex, sql: string, params?: any, trx?: Knex.Transaction): Promise<boolean>;
/**
 * Execute SQL raw query returning a JSON encoded result
 * and produce the parsed object.
 *
 * Example:
 *
 *  const result:JobDetail = await db.getJson<JobDetail>(
 *    connection,
 *    'SELECT * FROM jobs WHERE id = :jobId FOR JSON AUTO'
 *  );
 *
 * @param {Knex} connection
 * @param {string} sql
 * @param {any} params
 * @param {Knex.Transaction} trx
 * @returns {Promise<T | null>}
 */
export declare function getJson<T>(connection: Knex, sql: string, params?: any, trx?: Knex.Transaction): Promise<T | null>;
/**
 * Invoke a scalar-valued function and return results.
 *
 * Example usage:
 *
 *  const username = await db.invoke<string>(con, 'dbo.can_user_access_object', { userId: 10, objectId: 15 });
 *
 *  // => Runs SQL: SELECT dbo.can_user_access_object(:userId, :objectId)
 *  // => Binds params: { userId: 10, objectId: 15 }
 *
 * @param {(Knex | Knex.Transaction)} connection
 * @param {string} objectName
 * @param {(RawBindingParams | ValueMap)} [params]
 * @returns {(Promise<T | null>)}
 */
export declare function invoke<T>(connection: Knex | Knex.Transaction, objectName: string, params?: RawBindingParams | ValueMap): Promise<T | null>;
/**
 * Execute a procedure and return the results returned (if any).
 *
 * Example usage:
 *
 *  await db.exec<string>(trx, 'dbo.update_top_recommendations', { userId: 10, type });
 *
 *  // => Runs SQL: EXEC dbo.update_top_recommendations :userId, :type
 *  // => Binds params: { userId: 10, type }
 *
 * @param {(Knex | Knex.Transaction)} connection
 * @param {string} objectName
 * @param {(RawBindingParams | ValueMap)} [params]
 * @returns {Promise<T[]>}
 */
export declare function exec<T>(connection: Knex | Knex.Transaction, objectName: string, params?: RawBindingParams | ValueMap): Promise<T[]>;
/**
 * Extract parameter binding expression for procedure or a function.
 *
 * @param {string} objectName
 * @param {(RawBindingParams | ValueMap)} [params]
 * @returns {{ procName: string, expr: string }}
 */
export declare function getProcParamsExpr(objectName: string, params?: RawBindingParams | ValueMap): {
    procName: string;
    expr: string;
};
/**
 * Run updates in batch via given query. The query supplied should have an UPDATE TOP
 * statement, as it is the preferred method of updating given N rows.
 *
 * Example usage:
 *
 *  await db.batchUpdateViaQuery(trx, UPDATE_QUERY, { dataSize: 1000, batchSize: 100 });
 *
 *  // => Runs the query and binds params: { batchSize: 100 }
 *
 * @param {Knex.Transaction} trx
 * @param {string} updateQuery
 * @param {BatchUpdateOptions} options
 */
export declare function batchUpdateViaQuery(trx: Knex.Transaction, updateQuery: string, options: BatchUpdateOptions): Promise<void>;
export {};