sql-love 1.0.2 → 1.0.4

package/src/runMysql/runMysql.ts

@@ -1,106 +0,0 @@
-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]);
-    });
-  });
-}
-
-/**
- * Run the given query with mysql and return the results
- * @param mysqlClient  A client created with mysql.createConnection()  or mysql.createPool()
- * @param query  The SelectBuilder query to run
- */
-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);
-}
-
-/**
- * Run the given query with mysql and return the results, count, and pagination
- * @param mysqlClient  A client created with mysql.createConnection()  or mysql.createPool()
- * @param query  The SelectBuilder query to run
- * @param options
- * @param options.countExpr  The SQL expression to use for the count (default "*")
- */
-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

@@ -1,99 +0,0 @@
-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,
-    });
-  });
-  it('should handle when recordset is empty', async () => {
-    const prisma = {
-      $queryRawUnsafe: vi.fn(() => []),
-    };
-    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).toStrictEqual([]);
-    expect(total).toBe(0);
-    expect(pagination).toEqual({
-      page: null,
-      prevPage: null,
-      nextPage: null,
-      perPage: 2,
-      numPages: 0,
-      total: 0,
-      isFirst: false,
-      isLast: false,
-    });
-  });
-});

package/src/runPrisma/runPrisma.ts

@@ -1,75 +0,0 @@
-import type SelectBuilder from '../SelectBuilder/SelectBuilder';
-import type { EngineStyle } from '../SelectBuilder/SelectBuilder';
-import getPagination from '../getPagination/getPagination';
-import { toSafeJsonValue } from '../toSafeJson/toSafeJson';
-
-interface PrismaClient {
-  $queryRawUnsafe: (
-    sql: string,
-    ...bindings: any[]
-  ) => Promise<Array<Record<string, any>>>;
-}
-
-/**
- * Run the given query with prisma and return the results
- * @param prisma  The prisma client instance
- * @param query  The SelectBuilder query to run
- * @param options
- * @param options.engine  The engine style to use ("mssql" | "mysql" | "oracle" | "pg")
- */
-export async function runPrisma<
-  T extends Array<Record<string, any>> = Array<Record<string, any>>,
->(
-  prisma: PrismaClient,
-  query: SelectBuilder,
-  { engine = undefined }: { engine?: EngineStyle } = {}
-): Promise<T> {
-  const { sql, bindings } = query.compile({ engine });
-  return prisma.$queryRawUnsafe(sql, ...bindings) as unknown as Promise<T>;
-}
-
-/**
- * Run the given query with prisma and return the results, count, and pagination
- * @param prisma  The prisma client instance
- * @param query  The SelectBuilder query to run
- * @param options
- * @param options.engine  The engine style to use ("mssql" | "mysql" | "oracle" | "pg")
- * @param options.countExpr  The SQL expression to use for the count (default "*")
- */
-export async function runPrismaWithCount<
-  T extends Array<Record<string, any>> = Array<Record<string, any>>,
->(
-  prisma: PrismaClient,
-  query: SelectBuilder,
-  {
-    engine = undefined,
-    countExpr = '*',
-  }: { engine?: EngineStyle; countExpr?: string } = {}
-): Promise<{
-  records: T;
-  total: number;
-  pagination: {
-    page: number;
-    prevPage: number;
-    nextPage: number;
-    perPage: number;
-    numPages: number;
-    total: number;
-    isFirst: boolean;
-    isLast: boolean;
-  };
-}> {
-  const { sql, bindings } = query.compile({ engine });
-  const records = (await prisma.$queryRawUnsafe(
-    sql,
-    ...bindings
-  )) as unknown as T;
-  if (records.length > 0) {
-    const { sql, bindings } = query.compileCount({ engine, countExpr });
-    const result = await prisma.$queryRawUnsafe(sql, ...bindings);
-    const total = toSafeJsonValue(result[0].found_rows);
-    return { records, total, pagination: getPagination(query, total) };
-  } else {
-    return { records, total: 0, pagination: getPagination(query, 0) };
-  }
-}

package/src/substrCount/substrCount.spec.ts

@@ -1,29 +0,0 @@
-import substrCount from './substrCount';
-
-describe('substrCount', function () {
-  it('should see 0', function () {
-    const haystack = 'hello world';
-    const needle = '?';
-    expect(substrCount(haystack, needle)).toBe(0);
-  });
-  it('should see 0 from empty string', function () {
-    const haystack = '';
-    const needle = '?';
-    expect(substrCount(haystack, needle)).toBe(0);
-  });
-  it('should see 1', function () {
-    const haystack = 'hello world?';
-    const needle = '?';
-    expect(substrCount(haystack, needle)).toBe(1);
-  });
-  it('should see 2 adjacent', function () {
-    const haystack = 'hello world??';
-    const needle = '?';
-    expect(substrCount(haystack, needle)).toBe(2);
-  });
-  it('should see 3', function () {
-    const haystack = '?hello world??';
-    const needle = '?';
-    expect(substrCount(haystack, needle)).toBe(3);
-  });
-});

package/src/substrCount/substrCount.ts

@@ -1,14 +0,0 @@
-/**
- * Count the number of times a substring appears in a string
- * @param haystack
- * @param needle
- */
-export default function substrCount(haystack: string, needle: string) {
-  let count = 0;
-  let pos = haystack.indexOf(needle);
-  while (pos !== -1) {
-    count += 1;
-    pos = haystack.indexOf(needle, pos + 1);
-  }
-  return count;
-}

package/src/toSafeJson/toSafeJson.spec.ts

@@ -1,28 +0,0 @@
-import { toSafeJsonRecords, toSafeJsonString } from './toSafeJson';
-
-describe('toSafeJsonString()', () => {
-  it('should convert small BigInt to Number', () => {
-    const records = [{ found_rows: 30n }];
-    const json = toSafeJsonString(records);
-    expect(json).toBe('[{"found_rows":30}]');
-  });
-  it('should convert large BigInt to String', () => {
-    const myBigInt = BigInt(String(Number.MAX_SAFE_INTEGER) + '0');
-    const records = [{ found_rows: myBigInt }];
-    const json = toSafeJsonString(records);
-    expect(json).toBe(`[{"found_rows":"${myBigInt.toString()}"}]`);
-  });
-});
-describe('jsonSafePrisma()', () => {
-  it('should convert small BigInt to Number', () => {
-    const records = [{ found_rows: 30n }];
-    const json = toSafeJsonRecords(records);
-    expect(json).toStrictEqual([{ found_rows: 30 }]);
-  });
-  it('should convert large BigInt to String', () => {
-    const myBigInt = BigInt(String(Number.MAX_SAFE_INTEGER) + '0');
-    const records = [{ found_rows: myBigInt }];
-    const json = toSafeJsonRecords(records);
-    expect(json).toStrictEqual([{ found_rows: myBigInt.toString() }]);
-  });
-});

package/src/toSafeJson/toSafeJson.ts

@@ -1,56 +0,0 @@
-type SafeValue<T> = T extends BigInt ? number | string : T;
-type SafeRecord<T> = Record<string, SafeValue<T>>;
-type SafeRecords<T> = Array<SafeRecord<T>>;
-
-/**
- * Convert a value to a value that can be safely serialized to JSON
- * @param value
- */
-export function toSafeJsonValue<T>(value: T): SafeValue<T> {
-  if (typeof value === 'bigint') {
-    const asNumber = Number(value);
-    // Use double equals instead of triple equals below to check if the BigInt
-    //   is too big to fit in a JS Number.
-    //   If so, then return it as a string, otherwise return it as a Number
-    // @ts-expect-error
-    return value == asNumber ? asNumber : value.toString();
-  }
-  return value as SafeValue<T>;
-}
-
-/**
- * Convert a record to one that can be safely serialized to JSON
- * @param record
- */
-export function toSafeJsonRecord<T extends Record<string, any>>(
-  record: T
-): SafeRecord<T> {
-  const newRecord: SafeValue<T> = {} as any;
-  for (const key in record) {
-    /* v8 ignore next 3 */
-    if (!Object.prototype.hasOwnProperty.call(record, key)) {
-      continue;
-    }
-    newRecord[key] = toSafeJsonValue(record[key]);
-  }
-  return newRecord;
-}
-
-/**
- * Convert a recordset to one that can be safely serialized to JSON
- * @param records
- */
-export function toSafeJsonRecords<T extends Record<string, any>>(
-  records: T[]
-): SafeRecords<T> {
-  return records.map(toSafeJsonRecord);
-}
-
-/**
- * JSON stringify a value or data structure, ensuring first that all values are
- *   safe to serialize
- * @param records
- */
-export function toSafeJsonString(records: Array<Record<string, any>>) {
-  return JSON.stringify(records, (_, value: any) => toSafeJsonValue(value));
-}

package/tsconfig.build.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "exclude": [
-    "node_modules",
-    "src/**/*.spec.ts",
-    "src/**/*.type.ts",
-    "src/**/*.interface.ts",
-    "src/mocks"
-  ]
-}

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "ESNext",
-    "target": "ESNext",
-    "outDir": "./dist",
-    "declaration": true,
-    "removeComments": false,
-    "noEmit": false,
-    "pretty": true,
-    "isolatedModules": true,
-    "lib": ["DOM", "DOM.Iterable", "ESNext"],
-    "sourceMap": false,
-    "skipLibCheck": true,
-    "moduleResolution": "node",
-    "allowSyntheticDefaultImports": true,
-	"types": ["vitest/globals"]
-  },
-  "include": [
-    "src/**/*.ts"
-  ],
-  "files": ["index.ts"]
-}

package/vitest.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    include: ['src/**/*.spec.ts'],
-    coverage: {
-      exclude: ['index.ts'],
-    },
-    globals: true,
-  },
-});