sql-love 0.9.3 → 0.9.5

package/dist/src/extractIndexed/extractIndexed.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Index each database row by a column value
+ * @param field  The database column to index by
+ * @param records  Records from the database
+ * @example
+ * extractIndexed('id', users); // result:
+ * {
+ *   "1": { id: 1, name: "John" },
+ *   "2": { id: 2, name: "Jane" },
+ * }
+ */
+export default function extractIndexed<DbRecord extends Record<string, any>>(field: keyof DbRecord, records: DbRecord[]): Record<string, DbRecord>;

package/dist/src/extractIndexed/extractIndexed.js

@@ -0,0 +1,23 @@
+/**
+ * Index each database row by a column value
+ * @param field  The database column to index by
+ * @param records  Records from the database
+ * @example
+ * extractIndexed('id', users); // result:
+ * {
+ *   "1": { id: 1, name: "John" },
+ *   "2": { id: 2, name: "Jane" },
+ * }
+ */
+export default function extractIndexed(field, records) {
+    let idx = 0;
+    const indexed = {};
+    for (const record of records) {
+        if (!(field in record)) {
+            throw new Error(`Column "${String(field)}" is not present in record ${idx}`);
+        }
+        indexed[record[field]] = record;
+        idx++;
+    }
+    return indexed;
+}

package/dist/src/getPagination/getPagination.d.ts

@@ -0,0 +1,16 @@
+import type SelectBuilder from '../SelectBuilder/SelectBuilder';
+/**
+ * Given a foundRows number of records and a limit, return the foundRows number of pages
+ * @param query  The query that was just run
+ * @param total  The number of records if there were no limit
+ */
+export default function getPagination(query: SelectBuilder, total: BigInt | number): {
+    page: number;
+    prevPage: number;
+    nextPage: number;
+    perPage: number;
+    numPages: number;
+    total: number;
+    isFirst: boolean;
+    isLast: boolean;
+};

package/dist/src/getPagination/getPagination.js

@@ -0,0 +1,25 @@
+/**
+ * Given a foundRows number of records and a limit, return the foundRows number of pages
+ * @param query  The query that was just run
+ * @param total  The number of records if there were no limit
+ */
+export default function getPagination(query, total) {
+    total = Number(total) || 0;
+    const page = Number(query._page) || 1;
+    const perPage = Number(query._limit);
+    const numPages = Math.ceil(total / perPage) || 0;
+    const isFirst = page === 1;
+    const isLast = page === numPages;
+    const prevPage = page - 1 || null;
+    const nextPage = page + 1 <= numPages ? page + 1 : null;
+    return {
+        page,
+        prevPage,
+        nextPage,
+        perPage,
+        numPages,
+        total,
+        isFirst,
+        isLast,
+    };
+}

package/dist/src/runMysql/runMysql.d.ts

@@ -0,0 +1,46 @@
+import type SelectBuilder from '../SelectBuilder/SelectBuilder';
+import type { EngineStyle } from '../SelectBuilder/SelectBuilder';
+interface MysqlClient {
+    query: (sql: string, bindings: any[], callback: (err: Error | null, results: Array<Record<string, any>>, fields: any[]) => void) => void;
+}
+interface MysqlAsyncClient {
+    query: (sql: string, bindings: any[]) => Promise<[Array<Record<string, any>>, any[]]>;
+}
+export declare function runMysql(mysqlClient: MysqlClient, query: SelectBuilder): Promise<[Array<Record<string, any>>, any[]]>;
+export declare function runMysqlWithCount(mysqlClient: MysqlClient, query: SelectBuilder, { countExpr }?: {
+    countExpr?: string;
+}): Promise<{
+    records: Record<string, any>[];
+    total: any;
+    pagination: {
+        page: number;
+        prevPage: number;
+        nextPage: number;
+        perPage: number;
+        numPages: number;
+        total: number;
+        isFirst: boolean;
+        isLast: boolean;
+    };
+    fields: any[];
+}>;
+export declare function runMysqlAsync(mysqlClient: MysqlAsyncClient, query: SelectBuilder): Promise<[Array<Record<string, any>>, any[]]>;
+export declare function runMysqlAsyncWithCount(mysqlClient: MysqlAsyncClient, query: SelectBuilder, { engine, countExpr, }?: {
+    engine?: EngineStyle;
+    countExpr?: string;
+}): Promise<{
+    records: Record<string, any>[];
+    total: any;
+    pagination: {
+        page: number;
+        prevPage: number;
+        nextPage: number;
+        perPage: number;
+        numPages: number;
+        total: number;
+        isFirst: boolean;
+        isLast: boolean;
+    };
+    fields: any[];
+}>;
+export {};

package/dist/src/runMysql/runMysql.js

@@ -0,0 +1,49 @@
+import getPagination from '../getPagination/getPagination';
+function _queryToPromise(mysqlClient, sql, bindings) {
+    return new Promise((resolve, reject) => {
+        mysqlClient.query(sql, bindings, (err, rows, fields) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve([rows, fields]);
+        });
+    });
+}
+export async function runMysql(mysqlClient, query) {
+    const { sql, bindings } = query.compile({ engine: 'mysql' });
+    return _queryToPromise(mysqlClient, sql, bindings);
+}
+export async function runMysqlWithCount(mysqlClient, query, { countExpr = '*' } = {}) {
+    const { sql, bindings } = query.compile({ engine: 'mysql' });
+    const [records, fields] = await _queryToPromise(mysqlClient, sql, bindings);
+    if (records.length > 0) {
+        const { sql, bindings } = query.compileCount({
+            engine: 'mysql',
+            countExpr,
+        });
+        const [rows] = await _queryToPromise(mysqlClient, sql, bindings);
+        const total = rows[0].found_rows;
+        return { records, total, pagination: getPagination(query, total), fields };
+    }
+    else {
+        return { records, total: 0, pagination: getPagination(query, 0), fields };
+    }
+}
+export async function runMysqlAsync(mysqlClient, query) {
+    const { sql, bindings } = query.compile({ engine: 'mysql' });
+    return mysqlClient.query(sql, bindings);
+}
+export async function runMysqlAsyncWithCount(mysqlClient, query, { engine = 'mysql', countExpr = '*', } = {}) {
+    const { sql, bindings } = query.compile({ engine });
+    const [records, fields] = await mysqlClient.query(sql, bindings);
+    if (records.length > 0) {
+        const { sql, bindings } = query.compileCount({ engine, countExpr });
+        const [rows] = await mysqlClient.query(sql, bindings);
+        const total = rows[0].found_rows;
+        return { records, total, pagination: getPagination(query, total), fields };
+    }
+    else {
+        return { records, total: 0, pagination: getPagination(query, 0), fields };
+    }
+}

package/dist/src/runPrisma/runPrisma.d.ts

@@ -0,0 +1,26 @@
+import type SelectBuilder from '../SelectBuilder/SelectBuilder';
+import type { EngineStyle } from '../SelectBuilder/SelectBuilder';
+interface PrismaClient {
+    $queryRawUnsafe: (sql: string, ...bindings: any[]) => Promise<Array<Record<string, any>>>;
+}
+export declare function runPrisma(prisma: PrismaClient, query: SelectBuilder, { engine }?: {
+    engine?: EngineStyle;
+}): Promise<Array<Record<string, any>>>;
+export declare function runPrismaWithCount(prisma: PrismaClient, query: SelectBuilder, { engine, countExpr, }?: {
+    engine?: EngineStyle;
+    countExpr?: string;
+}): Promise<{
+    records: Record<string, any>[];
+    total: any;
+    pagination: {
+        page: number;
+        prevPage: number;
+        nextPage: number;
+        perPage: number;
+        numPages: number;
+        total: number;
+        isFirst: boolean;
+        isLast: boolean;
+    };
+}>;
+export {};

package/dist/src/runPrisma/runPrisma.js

@@ -0,0 +1,18 @@
+import getPagination from '../getPagination/getPagination';
+export async function runPrisma(prisma, query, { engine = undefined } = {}) {
+    const { sql, bindings } = query.compile({ engine });
+    return prisma.$queryRawUnsafe(sql, ...bindings);
+}
+export async function runPrismaWithCount(prisma, query, { engine = undefined, countExpr = '*', } = {}) {
+    const { sql, bindings } = query.compile({ engine });
+    const records = await prisma.$queryRawUnsafe(sql, ...bindings);
+    if (records.length > 0) {
+        const { sql, bindings } = query.compileCount({ engine, countExpr });
+        const result = await prisma.$queryRawUnsafe(sql, ...bindings);
+        const total = result[0].found_rows;
+        return { records, total, pagination: getPagination(query, total) };
+    }
+    else {
+        return { records, total: 0, pagination: getPagination(query, 0) };
+    }
+}

package/index.ts

@@ -1,2 +1,6 @@
 export { default as Parser } from './src/Parser/Parser';
 export { default as SelectBuilder } from './src/SelectBuilder/SelectBuilder';
+export { default as extractGrouped } from './src/extractGrouped/extractGrouped';
+export { default as extractIndexed } from './src/extractIndexed/extractIndexed';
+export { default as getPagination } from './src/getPagination/getPagination';
+export { runPrisma, runPrismaWithCount } from './src/runPrisma/runPrisma';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sql-love",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "description": "Build SQL queries with JavaScript",
   "main": "dist/index.js",
   "type": "module",

package/src/SelectBuilder/SelectBuilder.spec.ts

@@ -31,7 +31,7 @@ describe('where() with arguments', () => {
         id: 123,
       }
     );
-    const { sql, bindings } = query.compile('pg');
+    const { sql, bindings } = query.compile({ engine: 'pg' });
     expect(trim(sql)).toBe('SELECT * FROM users WHERE id = $1 AND age >= $2');
     expect(bindings).toEqual([123, 18]);
   });
@@ -267,6 +267,14 @@ describe('orWhere()', () => {
     expect(trim(sql)).toBe('SELECT * FROM users WHERE (a > ? OR b = ?)');
     expect(bindings).toEqual([1, 2]);
   });
+  it('should handle an object', () => {
+    const query = new SelectBuilder();
+    query.table('users');
+    query.orWhere({ 'a >': 1, b: 2 });
+    const { sql, bindings } = query.compile();
+    expect(trim(sql)).toBe('SELECT * FROM users WHERE (a > ? OR b = ?)');
+    expect(bindings).toEqual([1, 2]);
+  });
 });
 describe('having()', () => {
   it('should handle expression', () => {
@@ -520,7 +528,7 @@ describe('LIMIT and OFFSET', () => {
     const query = new SelectBuilder('SELECT * FROM posts');
     query.limit(2);
     query.offset(4);
-    const { sql, bindings } = query.compile('mssql');
+    const { sql, bindings } = query.compile({ engine: 'mssql' });
     expect(trim(sql)).toBe(
       'SELECT * FROM posts OFFSET 4 ROWS FETCH NEXT 2 ROWS ONLY'
     );
@@ -600,7 +608,10 @@ describe('compileCount()', () => {
   });
   it('should handle a distinct', () => {
     const query = new SelectBuilder('SELECT * FROM posts');
-    const { sql, bindings } = query.compileCount('DISTINCT group_id');
+    const { sql, bindings } = query.compileCount({
+      countExpr: 'DISTINCT group_id',
+      engine: 'mysql',
+    });
     expect(trim(sql)).toBe(
       'SELECT COUNT(DISTINCT group_id) AS found_rows FROM posts'
     );
@@ -627,6 +638,23 @@ describe('compileCount()', () => {
   });
 });
 
+describe('compileUnion()', () => {
+  it('should error on non-number', () => {
+    const query1 = new SelectBuilder(
+      'SELECT first, last, email FROM users WHERE org = :org AND group = :group',
+      { org: 'ACME', group: 2 }
+    );
+    const query2 = new SelectBuilder(
+      'SELECT first, last, email FROM contacts WHERE org = :org AND group = :group',
+      { org: 'ACME', group: 2 }
+    );
+    const { sql, bindings } = query1.compileUnion(query2, { engine: 'pg' });
+    expect(trim(sql)).toBe(
+      `(SELECT first, last, email FROM users WHERE org = $1 AND group = $2) UNION (SELECT first, last, email FROM contacts WHERE org = $3 AND group = $4)`
+    );
+    expect(bindings).toEqual(['ACME', 2, 'ACME', 2]);
+  });
+});
 describe('reset()', () => {
   it('should reset all', () => {
     const query = new SelectBuilder('SELECT id FROM a');
@@ -739,3 +767,19 @@ describe('tables()', () => {
     expect(bindings).toEqual([]);
   });
 });
+describe('setDefaultEngine()', () => {
+  it('should set ok', () => {
+    SelectBuilder.setDefaultEngine('pg');
+    const query = new SelectBuilder('SELECT * FROM users');
+    query.where('id', 123);
+    const { sql, bindings } = query.compile();
+    expect(trim(sql)).toBe('SELECT * FROM users WHERE id = $1');
+    expect(bindings).toEqual([123]);
+
+    // and set engine to something else then compile again
+    SelectBuilder.setDefaultEngine('oracle');
+    const compiled = query.compile();
+    expect(trim(compiled.sql)).toBe('SELECT * FROM users WHERE id = ?');
+    expect(compiled.bindings).toEqual([123]);
+  });
+});

package/src/SelectBuilder/SelectBuilder.ts

@@ -33,6 +33,8 @@ export type WhereCriteria =
 
 const isNullish = v => v === undefined || v === null || v === false || isNaN(v);
 
+let defaultEngine: EngineStyle = 'mysql';
+
 /**
  * Build a select query
  * Class Select
@@ -119,12 +121,27 @@ export default class SelectBuilder {
     }
   }
 
+  /**
+   * Set the default database engine style (mssql, mysql, oracle, pg)
+   * @param engine
+   */
+  static setDefaultEngine(engine: EngineStyle) {
+    defaultEngine = engine;
+    return SelectBuilder;
+  }
+
   /**
    * Get the SQL as a pretty-printed string alongside an array of bindings
-   * @param engineStyle  The database engine style (mssql, mysql, oracle, pg)
+   * @param engine  The database engine style (mssql, mysql, oracle, pg)
    * @return The SQL query as a string
    */
-  compile(engineStyle: EngineStyle = 'mysql') {
+  compile({
+    engine = defaultEngine,
+    bindingIndex = 1,
+  }: {
+    engine?: EngineStyle;
+    bindingIndex?: number;
+  } = {}) {
     // build all the lines
     const lines = [
       'SELECT',
@@ -139,28 +156,28 @@ export default class SelectBuilder {
     ];
     if (this._page > 0) {
       const offset = (this._page - 1) * this._limit;
-      lines.push(this._compileOFFSET(engineStyle, offset));
-      lines.push(this._compileLIMIT(engineStyle, this._limit));
+      lines.push(this._compileOFFSET(engine, offset));
+      lines.push(this._compileLIMIT(engine, this._limit));
     } else {
       if (this._offset) {
-        lines.push(this._compileOFFSET(engineStyle, this._offset));
+        lines.push(this._compileOFFSET(engine, this._offset));
       }
       if (this._limit) {
-        lines.push(this._compileLIMIT(engineStyle, this._limit));
+        lines.push(this._compileLIMIT(engine, this._limit));
       }
     }
 
     const pretty = lines.filter(Boolean).join('\n').trim();
     let replacer: (match0: string, match1: string) => string;
     const bindings: any = [];
-    if (engineStyle === 'pg') {
-      let idx = 1;
-      replacer = ($0, $1) => {
+    if (engine === 'pg') {
+      let idx = bindingIndex;
+      replacer = (_, $1) => {
         bindings.push(this._bindings[$1]);
         return '$' + idx++;
       };
     } else {
-      replacer = ($0, $1) => {
+      replacer = (_, $1) => {
         bindings.push(this._bindings[$1]);
         return '?';
       };
@@ -190,9 +207,17 @@ export default class SelectBuilder {
    * @param engineStyle  The database engine style (mssql, mysql, oracle, pg)
    * @param countExpr  The expression to use inside the COUNT()
    */
-  compileCount(engineStyle: EngineStyle = 'mysql', countExpr: string = '*') {
+  compileCount({
+    countExpr = '*',
+    engine = defaultEngine,
+    bindingIndex = 1,
+  }: {
+    countExpr?: string;
+    engine?: EngineStyle;
+    bindingIndex?: number;
+  } = {}) {
     const query = this.getFoundRowsQuery(countExpr);
-    const { sql, bindings } = query.compile(engineStyle);
+    const { sql, bindings } = query.compile({ engine, bindingIndex });
     if (this._havings.length === 0) {
       return { sql, bindings };
     } else {
@@ -204,6 +229,32 @@ export default class SelectBuilder {
     }
   }
 
+  /**
+   * Get SQL needed to union this query with another
+   * @param query  The query to union
+   * @param engine  The database engine style (mssql, mysql, oracle, pg)
+   */
+  compileUnion(
+    query: SelectBuilder,
+    {
+      engine = defaultEngine,
+      bindingIndex = 1,
+    }: {
+      engine?: EngineStyle;
+      bindingIndex?: number;
+    } = {}
+  ) {
+    const first = this.compile({ engine, bindingIndex });
+    const second = query.compile({
+      engine,
+      bindingIndex: first.bindings.length + bindingIndex,
+    });
+    return {
+      sql: `(${first.sql})\nUNION\n(${second.sql})`,
+      bindings: [...first.bindings, ...second.bindings],
+    };
+  }
+
   /**
    * @param  [fieldOrFields]  If given, reset the given component(s), otherwise reset all query components
    *   Valid components: option, column, table, where, orWhere, having, groupBy, orderBy, limit, offset, page
@@ -676,13 +727,23 @@ export default class SelectBuilder {
    * Add a series of WHERE clauses joined by OR (See _conditions for usage)
    * @param conditions
    */
-  _orConditions(conditions: WhereCriteria[] | Record<string, any>[]) {
+  _orConditions(
+    conditions: WhereCriteria[] | Record<string, any>[] | Record<string, any>
+  ) {
     const items = [];
-    for (const condition of conditions) {
-      if (Array.isArray(condition)) {
-        this._conditions(items, condition as WhereCriteria);
-      } else {
-        this._conditions(items, [condition]);
+    if (Array.isArray(conditions)) {
+      for (const condition of conditions) {
+        if (Array.isArray(condition)) {
+          this._conditions(items, condition as WhereCriteria);
+        } else {
+          this._conditions(items, [condition]);
+        }
+      }
+    } else {
+      for (const [key, value] of Object.entries(conditions)) {
+        const one = [];
+        this._conditions(one, [key, value]);
+        items.push(one[0]);
       }
     }
     const joined = items.join(' OR ');
@@ -698,7 +759,9 @@ export default class SelectBuilder {
    * Add WHERE conditions to place inside an OR block (See _conditions for usage)
    * @param conditions  A list or object where each item is an array with parameters that would be taken by where()
    */
-  orWhere(conditions: WhereCriteria[] | Record<string, any>[]) {
+  orWhere(
+    conditions: WhereCriteria[] | Record<string, any>[] | Record<string, any>
+  ) {
     const joined = this._orConditions(conditions);
     this.where(`(${joined})`);
     return this;
@@ -708,7 +771,9 @@ export default class SelectBuilder {
    * Add an OR with conditions under the HAVING clause
    * @param conditions  A list or object where each item is an array with parameters that would be taken by having()
    */
-  orHaving(conditions: WhereCriteria[] | Record<string, any>[]) {
+  orHaving(
+    conditions: WhereCriteria[] | Record<string, any>[] | Record<string, any>
+  ) {
     const joined = this._orConditions(conditions);
     this.having(`(${joined})`);
     return this;
@@ -842,10 +907,4 @@ export default class SelectBuilder {
     }
     return this;
   }
-
-  fetch(engine) {
-    if (engine.$queryRawUnsafe) {
-      //
-    }
-  }
 }

package/src/extractGrouped/extractGrouped.spec.ts

@@ -0,0 +1,43 @@
+import extractGrouped from './extractGrouped';
+
+describe('extractGrouped()', () => {
+  it('should handle grouping by string', () => {
+    const records = [
+      { id: 1, name: 'John', dept: 'Marketing' },
+      { id: 2, name: 'Jane', dept: 'Finance' },
+      { id: 3, name: 'Tim', dept: 'Marketing' },
+    ];
+    const grouped = extractGrouped('dept', records);
+    expect(grouped).toEqual({
+      Marketing: [
+        { id: 1, name: 'John', dept: 'Marketing' },
+        { id: 3, name: 'Tim', dept: 'Marketing' },
+      ],
+      Finance: [{ id: 2, name: 'Jane', dept: 'Finance' }],
+    });
+  });
+  it('should handle grouping by integer', () => {
+    const records = [
+      { id: 1, name: 'John', deptId: 1 },
+      { id: 2, name: 'Jane', deptId: 2 },
+      { id: 3, name: 'Tim', deptId: 1 },
+    ];
+    const grouped = extractGrouped('deptId', records);
+    expect(grouped).toEqual({
+      1: [
+        { id: 1, name: 'John', deptId: 1 },
+        { id: 3, name: 'Tim', deptId: 1 },
+      ],
+      2: [{ id: 2, name: 'Jane', deptId: 2 }],
+    });
+  });
+  it('should throw error if column is not present in every record', () => {
+    const records = [
+      { id: 1, name: 'John', deptId: 1 },
+      { id: 2, name: 'Jane', deptId: 2 },
+      { id: 3, name: 'Tim' },
+    ];
+    const thrower = () => extractGrouped('deptId', records);
+    expect(thrower).toThrow();
+  });
+});

package/src/extractGrouped/extractGrouped.ts

@@ -0,0 +1,36 @@
+/**
+ * Group database rows by a column value
+ * @param field  The database column to group by
+ * @param records  Records from the database
+ * @example
+ * extractGrouped('org', users); // result:
+ * {
+ *     "Marketing": [
+ *         { id: 1, name: "John", org: "Marketing" },
+ *         { id: 2, name: "Jane", org: "Marketing" },
+ *     ],
+ *     "Finance": [
+ *         { id: 3, name: "Jose", org: "Finance" },
+ *     ],
+ * }
+ */
+export default function extractGrouped<DbRecord extends Record<string, any>>(
+  field: keyof DbRecord,
+  records: DbRecord[]
+): Record<string, DbRecord[]> {
+  let idx = 0;
+  const grouped: Record<string, DbRecord[]> = {};
+  for (const record of records) {
+    if (!(field in record)) {
+      throw new Error(
+        `Column "${String(field)}" is not present in record ${idx}`
+      );
+    }
+    if (!grouped[record[field]]) {
+      grouped[record[field]] = [];
+    }
+    grouped[record[field]].push(record);
+    idx++;
+  }
+  return grouped;
+}

package/src/extractIndexed/extractIndexed.spec.ts

@@ -0,0 +1,40 @@
+import extractIndexed from './extractIndexed';
+
+describe('extractIndexed()', () => {
+  it('should handle indexing by string', () => {
+    const records = [
+      { uuid: '2d49f286-790d-4aee-b38b-94d0872e9bd8', name: 'John' },
+      { uuid: '7d02664a-d03e-4882-88e2-23c701c314b5', name: 'Jane' },
+    ];
+    const indexed = extractIndexed('uuid', records);
+    expect(indexed).toEqual({
+      '2d49f286-790d-4aee-b38b-94d0872e9bd8': {
+        uuid: '2d49f286-790d-4aee-b38b-94d0872e9bd8',
+        name: 'John',
+      },
+      '7d02664a-d03e-4882-88e2-23c701c314b5': {
+        uuid: '7d02664a-d03e-4882-88e2-23c701c314b5',
+        name: 'Jane',
+      },
+    });
+  });
+  it('should handle indexing by integer', () => {
+    const records = [
+      { id: 1, name: 'John' },
+      { id: 2, name: 'Jane' },
+    ];
+    const indexed = extractIndexed('id', records);
+    expect(indexed).toEqual({
+      1: { id: 1, name: 'John' },
+      2: { id: 2, name: 'Jane' },
+    });
+  });
+  it('should throw error if column is not present in every record', () => {
+    const records = [
+      { id: 1, name: 'John', employeeId: 'js102' },
+      { id: 2, name: 'Jane' },
+    ];
+    const thrower = () => extractIndexed('employeeId', records);
+    expect(thrower).toThrow();
+  });
+});

package/src/extractIndexed/extractIndexed.ts

@@ -0,0 +1,28 @@
+/**
+ * Index each database row by a column value
+ * @param field  The database column to index by
+ * @param records  Records from the database
+ * @example
+ * extractIndexed('id', users); // result:
+ * {
+ *   "1": { id: 1, name: "John" },
+ *   "2": { id: 2, name: "Jane" },
+ * }
+ */
+export default function extractIndexed<DbRecord extends Record<string, any>>(
+  field: keyof DbRecord,
+  records: DbRecord[]
+) {
+  let idx = 0;
+  const indexed: Record<string, DbRecord> = {};
+  for (const record of records) {
+    if (!(field in record)) {
+      throw new Error(
+        `Column "${String(field)}" is not present in record ${idx}`
+      );
+    }
+    indexed[record[field]] = record;
+    idx++;
+  }
+  return indexed;
+}