sql-love 1.0.2 → 1.0.4

package/src/extractGrouped/extractGrouped.spec.ts

@@ -1,43 +0,0 @@
-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

@@ -1,36 +0,0 @@
-/**
- * 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

@@ -1,40 +0,0 @@
-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

@@ -1,28 +0,0 @@
-/**
- * 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;
-}

package/src/extractLookup/extractLookup.spec.ts

@@ -1,38 +0,0 @@
-import extractLookup from './extractLookup';
-
-describe('extractLookup()', () => {
-  it('should handle lookup by number', () => {
-    const records = [
-      { id: 1, name: 'John', age: 30 },
-      { id: 2, name: 'Jane', age: 35 },
-    ];
-    const nameById = extractLookup('id', 'name', records);
-    expect(nameById).toEqual({ '1': 'John', '2': 'Jane' });
-  });
-  it('should handle lookups with non-unique fields', () => {
-    const records = [
-      { id: 1, name: 'John', age: 30 },
-      { id: 2, name: 'Jane', age: 30 },
-    ];
-    const ageById = extractLookup('age', 'name', records);
-    expect(ageById).toEqual({ '30': 'Jane' });
-  });
-  it('should throw if key field is not present', () => {
-    const records = [
-      { id: 1, name: 'John', age: 30 },
-      { id: 2, name: 'Jane' },
-    ];
-    // @ts-expect-error
-    const thrower = () => extractLookup('age', 'name', records);
-    expect(thrower).toThrow();
-  });
-  it('should throw if value field is not present', () => {
-    const records = [
-      { id: 1, name: 'John', age: 30 },
-      { id: 2, name: 'Jane' },
-    ];
-    // @ts-expect-error
-    const thrower = () => extractLookup('id', 'age', records);
-    expect(thrower).toThrow();
-  });
-});

package/src/extractLookup/extractLookup.ts

@@ -1,33 +0,0 @@
-/**
- * Given an array of records, extract an object with keyField-valueField pairs
- * @param records  An array of records
- * @param keyField  The field to use as the key
- * @param valueField  The field to use as the value
- */
-export default function extractLookup<
-  T extends Array<Record<K | V, any>>,
-  K extends keyof T[number],
-  V extends keyof T[number],
->(
-  keyField: K,
-  valueField: V,
-  records: T
-): { [key in T[number][K]]: T[number][V] } {
-  const lookup: { [key in T[number][K]]: T[number][V] } = {} as any;
-  let idx = 0;
-  for (const record of records) {
-    if (!(keyField in record)) {
-      throw new Error(
-        `Column "${String(keyField)}" is not present in record ${idx}`
-      );
-    }
-    if (!(valueField in record)) {
-      throw new Error(
-        `Column "${String(valueField)}" is not present in record ${idx}`
-      );
-    }
-    idx++;
-    lookup[String(record[keyField])] = record[valueField];
-  }
-  return lookup;
-}

package/src/getPagination/getPagination.spec.ts

@@ -1,75 +0,0 @@
-import SelectBuilder from '../SelectBuilder/SelectBuilder';
-import getPagination from './getPagination';
-
-describe('getPagination()', () => {
-  it('should handle 42 results with no offset', () => {
-    const query = new SelectBuilder('SELECT * FROM users LIMIT 10');
-    const pagination = getPagination(query, 42);
-    expect(pagination).toEqual({
-      page: 1,
-      prevPage: null,
-      nextPage: 2,
-      perPage: 10,
-      numPages: 5,
-      total: 42,
-      isFirst: true,
-      isLast: false,
-    });
-  });
-  it('should handle 42 results with offset', () => {
-    const query = new SelectBuilder('SELECT * FROM users LIMIT 10').offset(20);
-    const pagination = getPagination(query, 42n);
-    expect(pagination).toEqual({
-      page: 3,
-      prevPage: 2,
-      nextPage: 4,
-      perPage: 10,
-      numPages: 5,
-      total: 42,
-      isFirst: false,
-      isLast: false,
-    });
-  });
-  it('should handle 42 results with page', () => {
-    const query = new SelectBuilder('SELECT * FROM users LIMIT 10').page(3);
-    const pagination = getPagination(query, 42n);
-    expect(pagination).toEqual({
-      page: 3,
-      prevPage: 2,
-      nextPage: 4,
-      perPage: 10,
-      numPages: 5,
-      total: 42,
-      isFirst: false,
-      isLast: false,
-    });
-  });
-  it('should handle 0 results', () => {
-    const query = new SelectBuilder('SELECT * FROM users LIMIT 10');
-    const pagination = getPagination(query, 0);
-    expect(pagination).toEqual({
-      page: null,
-      prevPage: null,
-      nextPage: null,
-      perPage: 10,
-      numPages: 0,
-      total: 0,
-      isFirst: false,
-      isLast: false,
-    });
-  });
-  it('should handle when no limit is present', () => {
-    const query = new SelectBuilder('SELECT * FROM users');
-    const pagination = getPagination(query, 42);
-    expect(pagination).toEqual({
-      page: null,
-      prevPage: null,
-      nextPage: null,
-      perPage: null,
-      numPages: 0,
-      total: 42,
-      isFirst: false,
-      isLast: false,
-    });
-  });
-});

package/src/getPagination/getPagination.ts

@@ -1,42 +0,0 @@
-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
-) {
-  total = Number(total) || 0;
-  const perPage = Number(query._limit) || null;
-  let page: number | null = null;
-  if (total === 0) {
-    page = null;
-  } else if (query._page) {
-    page = Number(query._page);
-  } else if (query._limit && query._offset) {
-    page = Math.floor(Number(query._offset) / Number(query._limit)) + 1;
-  } else if (query._limit && !query._offset) {
-    page = 1;
-  } else {
-    page = null;
-  }
-  const numPages =
-    total === 0 || perPage === null ? 0 : Math.ceil(total / perPage) || 0;
-  const isFirst = page === 1;
-  const isLast = numPages > 0 && page === numPages;
-  const prevPage = numPages === 0 ? null : page - 1 || null;
-  const nextPage = numPages > 0 && page + 1 <= numPages ? page + 1 : null;
-  return {
-    page,
-    prevPage,
-    nextPage,
-    perPage,
-    numPages,
-    total,
-    isFirst,
-    isLast,
-  };
-}

package/src/runMysql/runMysql.spec.ts

@@ -1,286 +0,0 @@
-import { vi } from 'vitest';
-import SelectBuilder from '../SelectBuilder/SelectBuilder';
-import {
-  runMysql,
-  runMysqlAsync,
-  runMysqlAsyncWithCount,
-  runMysqlWithCount,
-} from './runMysql';
-
-describe('runMysql', () => {
-  it('should invoke client.query with correct args', async () => {
-    const mockResults = [
-      { id: 1, name: 'John', dept: 'Marketing' },
-      { id: 2, name: 'Jane', dept: 'Marketing' },
-    ];
-    const mockFields = [{ name: 'id' }, { name: 'name' }, { name: 'dept' }];
-    const client = {
-      query: vi.fn(
-        (
-          sql: string,
-          bindings: any[],
-          callback: (
-            err: Error | null,
-            rows: Array<Record<string, any>>,
-            fields: any[]
-          ) => void
-        ) => {
-          callback(null, mockResults, mockFields);
-        }
-      ),
-    };
-    const query = new SelectBuilder('SELECT * FROM users').where(
-      'dept',
-      'Marketing'
-    );
-    const [results, fields] = await runMysql(client, query);
-    expect(client.query.mock.calls[0][0]).toBe(
-      'SELECT\n  *\nFROM users\nWHERE dept = ?'
-    );
-    expect(client.query.mock.calls[0][1]).toEqual(['Marketing']);
-    expect(results).toBe(mockResults);
-    expect(fields).toBe(mockFields);
-  });
-  it('should handle errors', async () => {
-    const client = {
-      query: vi.fn(
-        (
-          sql: string,
-          bindings: any[],
-          callback: (
-            err: Error | null,
-            rows: Array<Record<string, any>>,
-            fields: any[]
-          ) => void
-        ) => {
-          callback(new Error('Test Error'), [], []);
-        }
-      ),
-    };
-    const query = new SelectBuilder('SELECT * FROM users').where(
-      'dept',
-      'Marketing'
-    );
-    try {
-      await runMysql(client, query);
-    } catch (e) {
-      expect(e.message).toBe('Test Error');
-    }
-  });
-  it('should run with count', async () => {
-    const mockResults1 = [
-      { id: 1, name: 'John', dept: 'Marketing' },
-      { id: 2, name: 'Jane', dept: 'Marketing' },
-    ];
-    const mockFields1 = [{ name: 'id' }, { name: 'name' }, { name: 'dept' }];
-    const mockResults2 = [{ found_rows: 9 }];
-    const mockFields2 = [{ name: 'found_rows' }];
-    let callCount = 0;
-    const client = {
-      query: vi.fn(
-        (
-          sql: string,
-          bindings: any[],
-          callback: (
-            err: Error | null,
-            rows: Array<Record<string, any>>,
-            fields: any[]
-          ) => void
-        ) => {
-          if (++callCount === 1) {
-            callback(null, mockResults1, mockFields1);
-          }
-          callback(null, mockResults2, mockFields2);
-        }
-      ),
-    };
-    const query = new SelectBuilder('SELECT * FROM users')
-      .where('dept', 'Marketing')
-      .limit(2)
-      .page(5);
-    const { records, total, pagination } = await runMysqlWithCount(
-      client,
-      query
-    );
-    expect(client.query.mock.calls[0][0]).toBe(
-      'SELECT\n  *\nFROM users\nWHERE dept = ?\nOFFSET 8\nLIMIT 2'
-    );
-    expect(client.query.mock.calls[0][1]).toEqual(['Marketing']);
-    expect(records).toBe(mockResults1);
-    expect(total).toBe(9);
-    expect(pagination).toEqual({
-      page: 5,
-      prevPage: 4,
-      nextPage: null,
-      perPage: 2,
-      numPages: 5,
-      total: 9,
-      isFirst: false,
-      isLast: true,
-    });
-  });
-  it('should run when count is 0', async () => {
-    const mockResults1 = [];
-    const mockFields1 = [{ name: 'id' }, { name: 'name' }, { name: 'dept' }];
-    const mockResults2 = [{ found_rows: 0 }];
-    const mockFields2 = [{ name: 'found_rows' }];
-    let callCount = 0;
-    const client = {
-      query: vi.fn(
-        (
-          sql: string,
-          bindings: any[],
-          callback: (
-            err: Error | null,
-            rows: Array<Record<string, any>>,
-            fields: any[]
-          ) => void
-        ) => {
-          if (++callCount === 1) {
-            callback(null, mockResults1, mockFields1);
-          }
-          callback(null, mockResults2, mockFields2);
-        }
-      ),
-    };
-    const query = new SelectBuilder('SELECT * FROM users')
-      .where('dept', 'Marketing')
-      .limit(2)
-      .page(5);
-    const { records, total, pagination } = await runMysqlWithCount(
-      client,
-      query
-    );
-    expect(callCount).toBe(1);
-    expect(records).toBe(mockResults1);
-    expect(total).toBe(0);
-    expect(pagination).toEqual({
-      page: null,
-      prevPage: null,
-      nextPage: null,
-      perPage: 2,
-      numPages: 0,
-      total: 0,
-      isFirst: false,
-      isLast: false,
-    });
-  });
-  it('should invoke client.query with correct args (promises)', async () => {
-    const mockResults = [
-      { id: 1, name: 'John', dept: 'Marketing' },
-      { id: 2, name: 'Jane', dept: 'Marketing' },
-    ];
-    const mockFields = [{ name: 'id' }, { name: 'name' }, { name: 'dept' }];
-    const client = {
-      query: vi.fn((sql: string, bindings: any[]) => {
-        return Promise.resolve([mockResults, mockFields]);
-      }),
-    };
-    const query = new SelectBuilder('SELECT * FROM users').where(
-      'dept',
-      'Marketing'
-    );
-    // @ts-expect-error
-    const [results, fields] = await runMysqlAsync(client, query);
-    expect(client.query).toHaveBeenCalledWith(
-      'SELECT\n  *\nFROM users\nWHERE dept = ?',
-      ['Marketing']
-    );
-    expect(results).toBe(mockResults);
-    expect(fields).toBe(mockFields);
-  });
-  it('should run with count (promises)', async () => {
-    const mockResults1 = [
-      { id: 1, name: 'John', dept: 'Marketing' },
-      { id: 2, name: 'Jane', dept: 'Marketing' },
-    ];
-    const mockFields1 = [{ name: 'id' }, { name: 'name' }, { name: 'dept' }];
-    const mockResults2 = [{ found_rows: 9 }];
-    const mockFields2 = [{ name: 'found_rows' }];
-    let callCount = 0;
-    const client = {
-      query: vi.fn((sql: string, bindings: any[]) => {
-        if (++callCount === 1) {
-          return Promise.resolve([mockResults1, mockFields1]);
-        }
-        return Promise.resolve([mockResults2, mockFields2]);
-      }),
-    };
-    const query = new SelectBuilder('SELECT * FROM users')
-      .where('dept', 'Marketing')
-      .limit(2)
-      .page(5);
-    const { records, total, pagination, fields } = await runMysqlAsyncWithCount(
-      // @ts-expect-error
-      client,
-      query
-    );
-    expect(callCount).toBe(2);
-    expect(records).toBe(mockResults1);
-    expect(total).toBe(9);
-    expect(pagination).toEqual({
-      page: 5,
-      prevPage: 4,
-      nextPage: null,
-      perPage: 2,
-      numPages: 5,
-      total: 9,
-      isFirst: false,
-      isLast: true,
-    });
-    expect(fields).toEqual(mockFields1);
-  });
-  it('should run with count of zero (promises)', async () => {
-    const mockResults1 = [];
-    const mockFields1 = [{ name: 'id' }, { name: 'name' }, { name: 'dept' }];
-    const mockResults2 = [{ found_rows: 0 }];
-    const mockFields2 = [{ name: 'found_rows' }];
-    let callCount = 0;
-    const client = {
-      query: vi.fn((sql: string, bindings: any[]) => {
-        if (++callCount === 1) {
-          return Promise.resolve([mockResults1, mockFields1]);
-        }
-        return Promise.resolve([mockResults2, mockFields2]);
-      }),
-    };
-    const query = new SelectBuilder('SELECT * FROM users')
-      .where('dept', 'Marketing')
-      .limit(2)
-      .page(5);
-    const { records, total, pagination } = await runMysqlAsyncWithCount(
-      // @ts-expect-error
-      client,
-      query
-    );
-    expect(callCount).toBe(1);
-    expect(records).toBe(mockResults1);
-    expect(total).toBe(0);
-    expect(pagination).toEqual({
-      page: null,
-      prevPage: null,
-      nextPage: null,
-      perPage: 2,
-      numPages: 0,
-      total: 0,
-      isFirst: false,
-      isLast: false,
-    });
-  });
-  it('should handle errors (promises)', async () => {
-    const client = {
-      query: vi.fn((sql: string, bindings: any[]) => {
-        return Promise.reject('Test Test');
-      }),
-    };
-    const query = new SelectBuilder('SELECT * FROM users').where(
-      'dept',
-      'Marketing'
-    );
-    try {
-      await runMysqlAsync(client, query);
-    } catch (e) {
-      expect(e).toBe('Test Test');
-    }
-  });
-});