pqb 0.0.1

package/src/queryMethods/log.test.ts

@@ -0,0 +1,172 @@
+import { createDb } from '../db';
+import { adapter, dbOptions, userData, useTestDatabase } from '../test-utils';
+import { logColors } from './log';
+import { noop } from '../utils';
+
+describe('query log', () => {
+  useTestDatabase();
+
+  it('should not have `log` query object by default', () => {
+    const db = createDb(dbOptions);
+
+    expect(db('user').query.log).toBe(undefined);
+  });
+
+  it('should set `log` query object when configuring db instance', () => {
+    const db = createDb({
+      ...dbOptions,
+      log: true,
+    });
+
+    expect(db('user').query.log).toBeTruthy();
+  });
+
+  it('should set `log` query object for a table', () => {
+    const db = createDb(dbOptions);
+    const table = db('user', undefined, { log: true });
+
+    expect(table.query.log).toBeTruthy();
+  });
+
+  it('should set `log` query object with query method', () => {
+    const db = createDb(dbOptions);
+    const table = db('user');
+
+    expect(table.log().query.log).toBeTruthy();
+  });
+
+  it('should log elapsed time, sql and binding values', async () => {
+    const hrtime = jest.spyOn(process, 'hrtime');
+    hrtime.mockReturnValueOnce([0, 0]);
+    hrtime.mockReturnValueOnce([1, 1000000]);
+
+    const logger = {
+      log: jest.fn(),
+      error: jest.fn(),
+    };
+
+    const db = createDb({ adapter, log: true, logger });
+
+    await db('user').where({ name: 'name' });
+
+    expect(logger.log.mock.calls).toEqual([
+      [
+        `${logColors.boldCyanBright('(1s 1.0ms)')} ${logColors.boldBlue(
+          `SELECT * FROM "user" WHERE "user"."name" = $1`,
+        )} ${logColors.boldYellow(`['name']`)}`,
+      ],
+    ]);
+  });
+
+  it('should log elapsed time, sql and binding values without colors', async () => {
+    const hrtime = jest.spyOn(process, 'hrtime');
+    hrtime.mockReturnValueOnce([0, 0]);
+    hrtime.mockReturnValueOnce([1, 1000000]);
+
+    const logger = {
+      log: jest.fn(),
+      error: jest.fn(),
+    };
+
+    const db = createDb({ adapter, log: { colors: false }, logger });
+
+    await db('user').where({ name: 'name' });
+
+    expect(logger.log.mock.calls).toEqual([
+      [`(1s 1.0ms) SELECT * FROM "user" WHERE "user"."name" = $1 ['name']`],
+    ]);
+  });
+
+  it('should log in red in case of error', async () => {
+    const hrtime = jest.spyOn(process, 'hrtime');
+    hrtime.mockReturnValueOnce([0, 0]);
+    hrtime.mockReturnValueOnce([1, 1000000]);
+
+    const logger = {
+      log: jest.fn(),
+      error: jest.fn(),
+    };
+
+    const db = createDb({ adapter, log: true, logger });
+
+    await db('user').where({ wrongColumn: 'value' }).then(noop, noop);
+
+    expect(logger.error.mock.calls).toEqual([
+      [
+        `${logColors.boldMagenta('(1s 1.0ms)')} ${logColors.boldRed(
+          `SELECT * FROM "user" WHERE "user"."wrongColumn" = $1`,
+        )} ${logColors.boldYellow(`['value']`)} ${logColors.boldRed(
+          'Error: column user.wrongColumn does not exist',
+        )}`,
+      ],
+    ]);
+  });
+
+  it('should log in red in case of error without colors', async () => {
+    const hrtime = jest.spyOn(process, 'hrtime');
+    hrtime.mockReturnValueOnce([0, 0]);
+    hrtime.mockReturnValueOnce([1, 1000000]);
+
+    const logger = {
+      log: jest.fn(),
+      error: jest.fn(),
+    };
+
+    const db = createDb({ adapter, log: { colors: false }, logger });
+
+    await db('user').where({ wrongColumn: 'value' }).then(noop, noop);
+
+    expect(logger.error.mock.calls).toEqual([
+      [
+        `(1s 1.0ms) SELECT * FROM "user" WHERE "user"."wrongColumn" = $1 ['value'] Error: column user.wrongColumn does not exist`,
+      ],
+    ]);
+  });
+
+  it('should log successful transaction', async () => {
+    const hrtime = jest.spyOn(process, 'hrtime');
+    hrtime.mockReturnValue([0, 0]);
+    hrtime.mockReturnValue([1, 1000000]);
+
+    const logger = {
+      log: jest.fn(),
+      error: jest.fn(),
+    };
+
+    const db = createDb({ adapter, log: { colors: false }, logger });
+
+    await db.transaction(async (q) => {
+      await db('user').transacting(q).insert(userData);
+    });
+
+    expect(logger.log.mock.calls).toEqual([
+      ['(1s 1.0ms) BEGIN'],
+      [expect.stringContaining('INSERT INTO "user"')],
+      ['(1s 1.0ms) COMMIT'],
+    ]);
+  });
+
+  it('should log failed transaction', async () => {
+    const hrtime = jest.spyOn(process, 'hrtime');
+    hrtime.mockReturnValue([0, 0]);
+    hrtime.mockReturnValue([1, 1000000]);
+
+    const logger = {
+      log: jest.fn(),
+      error: jest.fn(),
+    };
+
+    const db = createDb({ adapter, log: { colors: false }, logger });
+
+    await expect(
+      db.transaction(async (q) => {
+        await db('user').transacting(q).insert({ name: 'name' });
+      }),
+    ).rejects.toThrow();
+
+    expect(logger.log.mock.calls).toEqual([
+      ['(1s 1.0ms) BEGIN'],
+      ['(1s 1.0ms) ROLLBACK'],
+    ]);
+  });
+});

package/src/queryMethods/log.ts

@@ -0,0 +1,123 @@
+import { Query } from '../query';
+import { Sql } from '../sql';
+import { quote } from '../quote';
+
+export type QueryLogObject = {
+  colors: boolean;
+  beforeQuery(q: Query, sql: Sql): unknown;
+  afterQuery(q: Query, sql: Sql, logData: unknown): void;
+  onError(error: Error, q: Query, sql: Sql, logData: unknown): void;
+};
+
+export type QueryLogger = {
+  log(message: string): void;
+  error(message: string): void;
+};
+
+export type QueryLogOptions = {
+  log?: boolean | Partial<QueryLogObject>;
+  logger?: QueryLogger;
+};
+
+export const logColors = {
+  boldCyanBright: (message: string) =>
+    `\u001b[1m\u001b[96m${message}\u001b[39m\u001b[22m`,
+
+  boldBlue: (message: string) =>
+    `\u001b[1m\u001b[34m${message}\u001b[39m\u001b[22m`,
+
+  boldYellow: (message: string) =>
+    `\u001b[1m\u001b[33m${message}\u001b[39m\u001b[22m`,
+
+  boldMagenta: (message: string) =>
+    `\u001b[1m\u001b[33m${message}\u001b[39m\u001b[22m`,
+
+  boldRed: (message: string) =>
+    `\u001b[1m\u001b[31m${message}\u001b[39m\u001b[22m`,
+};
+
+const makeMessage = (
+  colors: boolean,
+  timeColor: (message: string) => string,
+  time: [number, number],
+  sqlColor: (message: string) => string,
+  sql: string,
+  valuesColor: (message: string) => string,
+  values: unknown[],
+): string => {
+  const elapsed = process.hrtime(time);
+  const formattedTime = `(${elapsed[0] ? `${elapsed[0]}s ` : ''}${(
+    elapsed[1] / 1000000
+  ).toFixed(1)}ms)`;
+
+  const result = `${colors ? timeColor(formattedTime) : formattedTime} ${
+    colors ? sqlColor(sql) : sql
+  }`;
+
+  if (!values.length) {
+    return result;
+  }
+
+  const formattedValues = `[${values.map(quote).join(', ')}]`;
+
+  return `${result} ${colors ? valuesColor(formattedValues) : formattedValues}`;
+};
+
+export const logParamToLogObject = (
+  logger: QueryLogger,
+  log: QueryLogOptions['log'],
+): QueryLogObject | undefined => {
+  if (!log) return;
+  const logObject = Object.assign(
+    {
+      colors: true,
+      beforeQuery() {
+        return process.hrtime();
+      },
+      afterQuery(_, sql, time: [number, number]) {
+        logger.log(
+          makeMessage(
+            colors,
+            logColors.boldCyanBright,
+            time,
+            logColors.boldBlue,
+            sql.text,
+            logColors.boldYellow,
+            sql.values,
+          ),
+        );
+      },
+      onError(error, _, sql, time: [number, number]) {
+        const message = `Error: ${error.message}`;
+
+        logger.error(
+          `${makeMessage(
+            colors,
+            logColors.boldMagenta,
+            time,
+            logColors.boldRed,
+            sql.text,
+            logColors.boldYellow,
+            sql.values,
+          )} ${colors ? logColors.boldRed(message) : message}`,
+        );
+      },
+    } as QueryLogObject,
+    log === true ? {} : log,
+  );
+
+  const colors = logObject.colors;
+
+  return logObject;
+};
+
+export class QueryLog {
+  log<T extends Query>(this: T, log = true): T {
+    return this.clone()._log(log);
+  }
+
+  _log<T extends Query>(this: T, log = true): T {
+    this.query.log = logParamToLogObject(this.query.logger, log);
+    return this;
+  }
+}