sql-love 0.9.4 → 0.9.6

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;
+}

package/src/getPagination/getPagination.spec.ts

@@ -0,0 +1,61 @@
+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').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: 1,
+      prevPage: null,
+      nextPage: null,
+      perPage: 10,
+      numPages: 0,
+      total: 0,
+      isFirst: true,
+      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: 1,
+      prevPage: null,
+      nextPage: null,
+      perPage: NaN,
+      numPages: 0,
+      total: 42,
+      isFirst: true,
+      isLast: false,
+    });
+  });
+});

package/src/getPagination/getPagination.ts

@@ -0,0 +1,30 @@
+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 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/src/runMysql/runMysql.spec.ts

@@ -0,0 +1,164 @@
+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 also 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 invoke client.query with correct args (async)', 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 also run with count (async)', 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(client.query).toHaveBeenCalledWith(
+      'SELECT\n  *\nFROM users\nWHERE dept = ?\nOFFSET 8\nLIMIT 2',
+      ['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,
+    });
+    expect(fields).toEqual(mockFields1);
+  });
+});

package/src/runMysql/runMysql.ts

@@ -0,0 +1,94 @@
+import type SelectBuilder from '../SelectBuilder/SelectBuilder';
+import type { EngineStyle } from '../SelectBuilder/SelectBuilder';
+import getPagination from '../getPagination/getPagination';
+
+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[]]>;
+}
+
+function _queryToPromise(
+  mysqlClient: MysqlClient,
+  sql: string,
+  bindings: any[]
+): Promise<[Array<Record<string, any>>, any[]]> {
+  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: MysqlClient,
+  query: SelectBuilder
+): Promise<[Array<Record<string, any>>, any[]]> {
+  const { sql, bindings } = query.compile({ engine: 'mysql' });
+  return _queryToPromise(mysqlClient, sql, bindings);
+}
+
+export async function runMysqlWithCount(
+  mysqlClient: MysqlClient,
+  query: SelectBuilder,
+  { countExpr = '*' }: { countExpr?: string } = {}
+) {
+  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: MysqlAsyncClient,
+  query: SelectBuilder
+): Promise<[Array<Record<string, any>>, any[]]> {
+  const { sql, bindings } = query.compile({ engine: 'mysql' });
+  return mysqlClient.query(sql, bindings);
+}
+
+export async function runMysqlAsyncWithCount(
+  mysqlClient: MysqlAsyncClient,
+  query: SelectBuilder,
+  {
+    engine = 'mysql',
+    countExpr = '*',
+  }: { engine?: EngineStyle; countExpr?: string } = {}
+) {
+  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/src/runPrisma/runPrisma.spec.ts

@@ -0,0 +1,67 @@
+import { vi } from 'vitest';
+import SelectBuilder from '../SelectBuilder/SelectBuilder';
+import { runPrisma, runPrismaWithCount } from './runPrisma';
+
+describe('runPrisma', () => {
+  it('should invoke prisma.$queryRawUnsafe with correct args', async () => {
+    const mockResults = [
+      { id: 1, name: 'John', dept: 'Marketing' },
+      { id: 2, name: 'Jane', dept: 'Marketing' },
+    ];
+    const prisma = {
+      $queryRawUnsafe: vi.fn(() => mockResults),
+    };
+    const query = new SelectBuilder('SELECT * FROM users');
+    query.where('dept', 'Marketing');
+    // @ts-expect-error
+    const results = await runPrisma(prisma, query);
+    expect(prisma.$queryRawUnsafe).toHaveBeenCalledWith(
+      'SELECT\n  *\nFROM users\nWHERE dept = ?',
+      'Marketing'
+    );
+    expect(results).toBe(mockResults);
+  });
+  it('should also run with count', async () => {
+    const mockResults1 = [
+      { id: 1, name: 'John', dept: 'Marketing' },
+      { id: 2, name: 'Jane', dept: 'Marketing' },
+    ];
+    const mockResults2 = [{ found_rows: 9 }];
+    let callCount = 0;
+    const prisma = {
+      $queryRawUnsafe: vi.fn(() => {
+        if (++callCount === 1) {
+          return mockResults1;
+        }
+        return mockResults2;
+      }),
+    };
+    const query = new SelectBuilder('SELECT * FROM users')
+      .where('dept', 'Marketing')
+      .limit(2)
+      .page(5);
+    const { records, total, pagination } = await runPrismaWithCount(
+      // @ts-expect-error
+      prisma,
+      query
+    );
+    // @ts-expect-error
+    expect(prisma.$queryRawUnsafe.mock.calls[0][0]).toBe(
+      'SELECT\n  *\nFROM users\nWHERE dept = ?\nOFFSET 8\nLIMIT 2'
+    );
+    // @ts-expect-error
+    expect(prisma.$queryRawUnsafe.mock.calls[0][1]).toBe('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,
+    });
+  });
+});

package/src/runPrisma/runPrisma.ts

@@ -0,0 +1,39 @@
+import type SelectBuilder from '../SelectBuilder/SelectBuilder';
+import type { EngineStyle } from '../SelectBuilder/SelectBuilder';
+import getPagination from '../getPagination/getPagination';
+
+interface PrismaClient {
+  $queryRawUnsafe: (
+    sql: string,
+    ...bindings: any[]
+  ) => Promise<Array<Record<string, any>>>;
+}
+
+export async function runPrisma(
+  prisma: PrismaClient,
+  query: SelectBuilder,
+  { engine = undefined }: { engine?: EngineStyle } = {}
+): Promise<Array<Record<string, any>>> {
+  const { sql, bindings } = query.compile({ engine });
+  return prisma.$queryRawUnsafe(sql, ...bindings);
+}
+
+export async function runPrismaWithCount(
+  prisma: PrismaClient,
+  query: SelectBuilder,
+  {
+    engine = undefined,
+    countExpr = '*',
+  }: { engine?: EngineStyle; countExpr?: string } = {}
+) {
+  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) };
+  }
+}