pqb 0.0.1

package/src/queryMethods/select.ts

@@ -0,0 +1,249 @@
+import {
+  AddQuerySelect,
+  ColumnParser,
+  Query,
+  QueryBase,
+  QuerySelectAll,
+} from '../query';
+import {
+  ArrayOfColumnsObjects,
+  ColumnsObject,
+  NullableColumn,
+} from '../columnSchema';
+import { getQueryParsers, isRaw, RawExpression } from '../common';
+import { pushQueryArray } from '../queryDataUtils';
+import { parseRecord } from './then';
+import { QueryData, SelectItem, SelectQueryData } from '../sql';
+import { FilterTuple, getQueryAs, SimpleSpread } from '../utils';
+import {
+  isRequiredRelationKey,
+  Relation,
+  RelationQueryBase,
+  relationQueryKey,
+} from '../relations';
+
+export type SelectArg<T extends QueryBase> =
+  | keyof T['selectable']
+  | (T['relations'] extends Record<string, Relation>
+      ? keyof T['relations']
+      : never)
+  | RelationQueryBase
+  | SelectAsArg<T>;
+
+type SelectAsArg<T extends QueryBase> = Record<
+  string,
+  keyof T['selectable'] | Query | RawExpression
+>;
+
+type SelectResult<
+  T extends Query,
+  Args extends SelectArg<T>[],
+  SelectAsArgs = SimpleSpread<FilterTuple<Args, SelectAsArg<QueryBase>>>,
+> = AddQuerySelect<
+  T,
+  {
+    [Arg in Args[number] as Arg extends keyof T['selectable']
+      ? T['selectable'][Arg]['as']
+      : Arg extends keyof T['relations']
+      ? Arg
+      : Arg extends RelationQueryBase
+      ? Arg['tableAlias'] extends string
+        ? Arg['tableAlias']
+        : never
+      : never]: Arg extends keyof T['selectable']
+      ? T['selectable'][Arg]['column']
+      : Arg extends RelationQueryBase
+      ? Arg['returnType'] extends 'all'
+        ? ArrayOfColumnsObjects<Arg['result']>
+        : Arg['returnType'] extends 'valueOrThrow'
+        ? Arg['result']['value']
+        : Arg[isRequiredRelationKey] extends true
+        ? ColumnsObject<Arg['result']>
+        : NullableColumn<ColumnsObject<Arg['result']>>
+      : T['relations'] extends Record<string, Relation>
+      ? Arg extends keyof T['relations']
+        ? T['relations'][Arg]['returns'] extends 'many'
+          ? ArrayOfColumnsObjects<T['relations'][Arg]['model']['result']>
+          : T['relations'][Arg]['options']['required'] extends true
+          ? ColumnsObject<T['relations'][Arg]['model']['result']>
+          : NullableColumn<
+              ColumnsObject<T['relations'][Arg]['model']['result']>
+            >
+        : never
+      : never;
+  } & {
+    [K in keyof SelectAsArgs]: SelectAsArgs[K] extends keyof T['selectable']
+      ? T['selectable'][SelectAsArgs[K]]['column']
+      : SelectAsArgs[K] extends RawExpression
+      ? SelectAsArgs[K]['__column']
+      : SelectAsArgs[K] extends Query
+      ? SelectAsArgs[K]['returnType'] extends 'all'
+        ? ArrayOfColumnsObjects<SelectAsArgs[K]['result']>
+        : ColumnsObject<SelectAsArgs[K]['result']>
+      : never;
+  }
+>;
+
+export const addParserForRawExpression = (
+  q: Query,
+  key: string,
+  raw: RawExpression,
+) => {
+  const parser = raw.__column?.parseFn;
+  if (parser) addParserToQuery(q.query, key, parser);
+};
+
+export const addParserForSelectItem = <T extends Query>(
+  q: T,
+  as: string | undefined,
+  key: string,
+  item: keyof T['selectable'] | Query | RawExpression,
+) => {
+  if (typeof item === 'object') {
+    if (isRaw(item)) {
+      addParserForRawExpression(q, key, item);
+    } else {
+      const parsers = getQueryParsers(item);
+      if (parsers) {
+        if (item.query.take) {
+          addParserToQuery(q.query, key, (item) => parseRecord(parsers, item));
+        } else {
+          addParserToQuery(q.query, key, (items) =>
+            (items as unknown[]).map((item) => parseRecord(parsers, item)),
+          );
+        }
+      }
+    }
+  } else {
+    const index = (item as string).indexOf('.');
+    if (index !== -1) {
+      const table = (item as string).slice(0, index);
+      const column = (item as string).slice(index + 1);
+
+      if (table === as) {
+        const parser = q.columnsParsers?.[column];
+        if (parser) addParserToQuery(q.query, key, parser);
+      } else {
+        const parser = (q.query as SelectQueryData).joinedParsers?.[table]?.[
+          column
+        ];
+        if (parser) addParserToQuery(q.query, key, parser);
+      }
+    } else {
+      const parser = q.columnsParsers?.[item as string];
+      if (parser) addParserToQuery(q.query, key, parser);
+    }
+  }
+};
+
+export const addParserToQuery = (
+  query: QueryData,
+  key: string,
+  parser: ColumnParser,
+) => {
+  if (query.parsers) query.parsers[key] = parser;
+  else query.parsers = { [key]: parser };
+};
+
+export const processSelectArg = <T extends Query>(
+  q: T,
+  as: string | undefined,
+  item: SelectArg<T>,
+): SelectItem => {
+  if (typeof item === 'string') {
+    if ((q.relations as Record<string, Relation>)[item]) {
+      item = (q as unknown as Record<string, RelationQueryBase>)[item];
+    } else {
+      const index = item.indexOf('.');
+      if (index !== -1) {
+        const table = item.slice(0, index);
+        const column = item.slice(index + 1);
+
+        if (table === as) {
+          const parser = q.columnsParsers?.[column];
+          if (parser) addParserToQuery(q.query, column, parser);
+        } else {
+          const parser = (q.query as SelectQueryData).joinedParsers?.[table]?.[
+            column
+          ];
+          if (parser) addParserToQuery(q.query, column, parser);
+        }
+      } else {
+        const parser = q.columnsParsers?.[item];
+        if (parser) addParserToQuery(q.query, item, parser);
+      }
+      return item;
+    }
+  }
+
+  if ((item as { query?: QueryData }).query?.[relationQueryKey]) {
+    const relation = item as RelationQueryBase;
+    const parsers = relation.query.parsers || relation.columnsParsers;
+    if (parsers) {
+      addParserToQuery(q.query, getQueryAs(relation), (input) => {
+        if (Array.isArray(input)) {
+          input.forEach((record: unknown) => {
+            for (const key in parsers) {
+              const value = (record as Record<string, unknown>)[key];
+              if (value !== null) {
+                (record as Record<string, unknown>)[key] = parsers[key](value);
+              }
+            }
+          });
+        } else {
+          for (const key in parsers) {
+            const value = (input as Record<string, unknown>)[key];
+            if (value !== null) {
+              (input as Record<string, unknown>)[key] = parsers[key](value);
+            }
+          }
+        }
+        return input;
+      });
+    }
+  } else {
+    for (const key in item as SelectAsArg<QueryBase>) {
+      addParserForSelectItem(q, as, key, (item as SelectAsArg<QueryBase>)[key]);
+    }
+
+    return { selectAs: item } as SelectItem;
+  }
+
+  return item as SelectItem;
+};
+
+export class Select {
+  select<T extends Query, K extends SelectArg<T>[]>(
+    this: T,
+    ...args: K
+  ): SelectResult<T, K> {
+    return this.clone()._select(...args) as unknown as SelectResult<T, K>;
+  }
+
+  _select<T extends Query, K extends SelectArg<T>[]>(
+    this: T,
+    ...args: K
+  ): SelectResult<T, K> {
+    if (!args.length) {
+      return this as unknown as SelectResult<T, K>;
+    }
+
+    const as = this.query.as || this.table;
+    const selectArgs = args.map((item) => processSelectArg(this, as, item));
+
+    return pushQueryArray(
+      this,
+      'select',
+      selectArgs,
+    ) as unknown as SelectResult<T, K>;
+  }
+
+  selectAll<T extends Query>(this: T): QuerySelectAll<T> {
+    return this.clone()._selectAll();
+  }
+
+  _selectAll<T extends Query>(this: T): QuerySelectAll<T> {
+    this.query.select = ['*'];
+    return this as unknown as QuerySelectAll<T>;
+  }
+}

package/src/queryMethods/then.ts

@@ -0,0 +1,236 @@
+import { ColumnsParsers, Query, QueryReturnType } from '../query';
+import { getQueryParsers } from '../common';
+import { NotFoundError } from '../errors';
+import { QueryArraysResult, QueryResult } from '../adapter';
+import { CommonQueryData, Sql } from '../sql';
+import { AfterCallback, BeforeCallback } from './callbacks';
+
+export type ThenResult<Res> = <T extends Query>(
+  this: T,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  resolve?: (value: Res) => any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  reject?: (error: any) => any,
+) => Promise<Res | never>;
+
+export const queryMethodByReturnType: Record<
+  QueryReturnType,
+  'query' | 'arrays'
+> = {
+  all: 'query',
+  one: 'query',
+  oneOrThrow: 'query',
+  rows: 'arrays',
+  pluck: 'arrays',
+  value: 'arrays',
+  valueOrThrow: 'arrays',
+  rowCount: 'arrays',
+  void: 'arrays',
+};
+
+export class Then {
+  then(
+    this: Query,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    resolve?: (result: any) => any,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    reject?: (error: any) => any,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ): Promise<any> {
+    if (this.query.wrapInTransaction && !this.query.inTransaction) {
+      return this.transaction((q) => then(q, resolve, reject));
+    } else {
+      return then(this, resolve, reject);
+    }
+  }
+}
+
+export const handleResult: CommonQueryData['handleResult'] = async (
+  q,
+  result: QueryResult,
+) => {
+  return parseResult(q, q.query.returnType, result);
+};
+
+const then = async (
+  q: Query,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  resolve?: (result: any) => any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  reject?: (error: any) => any,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+): Promise<any> => {
+  let sql: Sql | undefined;
+  let logData: unknown | undefined;
+  try {
+    let beforeCallbacks: BeforeCallback<Query>[] | undefined;
+    let afterCallbacks: AfterCallback<Query>[] | undefined;
+    if (q.query.type === 'insert') {
+      beforeCallbacks = q.query.beforeInsert;
+      afterCallbacks = q.query.afterInsert;
+    } else if (q.query.type === 'update') {
+      beforeCallbacks = q.query.beforeUpdate;
+      afterCallbacks = q.query.afterUpdate;
+    }
+
+    if (beforeCallbacks) {
+      await Promise.all(beforeCallbacks.map((cb) => cb(q)));
+    }
+
+    if (q.query.beforeQuery) {
+      await Promise.all(q.query.beforeQuery.map((cb) => cb(q)));
+    }
+
+    sql = q.toSql();
+
+    if (q.query.log) {
+      logData = q.query.log?.beforeQuery(q, sql);
+    }
+
+    const queryResult = await q.query.adapter[
+      queryMethodByReturnType[q.query.returnType] as 'query'
+    ](sql);
+
+    if (q.query.log) {
+      q.query.log?.afterQuery(q, sql, logData);
+      // set sql to be undefined to prevent logging on error in case if afterCallbacks throws
+      sql = undefined;
+    }
+
+    const result = await q.query.handleResult(q, queryResult);
+
+    if (afterCallbacks?.length || q.query.afterQuery?.length) {
+      if (q.query.afterQuery?.length) {
+        await Promise.all(q.query.afterQuery.map((query) => query(q, result)));
+      }
+
+      if (afterCallbacks?.length) {
+        await Promise.all(afterCallbacks.map((query) => query(q, result)));
+      }
+    }
+
+    resolve?.(result);
+  } catch (error) {
+    if (q.query.log && sql && logData) {
+      q.query.log.onError(error as Error, q, sql, logData);
+    }
+    reject?.(error);
+  }
+};
+
+export const parseResult = (
+  q: Query,
+  returnType: QueryReturnType,
+  result: QueryResult,
+): unknown => {
+  switch (returnType) {
+    case 'all': {
+      if (q.query.throwOnNotFound && result.rows.length === 0)
+        throw new NotFoundError();
+
+      const parsers = getQueryParsers(q);
+      return parsers
+        ? result.rows.map((row) => parseRecord(parsers, row))
+        : result.rows;
+    }
+    case 'one': {
+      const row = result.rows[0];
+      if (!row) return;
+
+      const parsers = getQueryParsers(q);
+      return parsers ? parseRecord(parsers, row) : row;
+    }
+    case 'oneOrThrow': {
+      const row = result.rows[0];
+      if (!row) throw new NotFoundError();
+
+      const parsers = getQueryParsers(q);
+      return parsers ? parseRecord(parsers, row) : row;
+    }
+    case 'rows': {
+      const parsers = getQueryParsers(q);
+      return parsers
+        ? parseRows(
+            parsers,
+            (result as unknown as QueryArraysResult).fields,
+            result.rows,
+          )
+        : result.rows;
+    }
+    case 'pluck': {
+      const parsers = getQueryParsers(q);
+      if (parsers?.pluck) {
+        return result.rows.map((row) => parsers.pluck(row[0]));
+      }
+      return result.rows.map((row) => row[0]);
+    }
+    case 'value': {
+      const value = result.rows[0]?.[0];
+      return value !== undefined
+        ? parseValue(value, (result as unknown as QueryArraysResult).fields, q)
+        : undefined;
+    }
+    case 'valueOrThrow': {
+      const value = result.rows[0]?.[0];
+      if (value === undefined) throw new NotFoundError();
+
+      return parseValue(
+        value,
+        (result as unknown as QueryArraysResult).fields,
+        q,
+      );
+    }
+    case 'rowCount': {
+      if (q.query.throwOnNotFound && result.rowCount === 0) {
+        throw new NotFoundError();
+      }
+      return result.rowCount;
+    }
+    case 'void': {
+      return;
+    }
+  }
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const parseRecord = (parsers: ColumnsParsers, row: any) => {
+  for (const key in parsers) {
+    if (row[key] !== null && row[key] !== undefined) {
+      row[key] = parsers[key](row[key]);
+    }
+  }
+  return row;
+};
+
+const parseRows = (
+  parsers: ColumnsParsers,
+  fields: { name: string }[],
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  rows: any[],
+) => {
+  fields.forEach((field, i) => {
+    const parser = parsers[field.name];
+    if (parser) {
+      rows.forEach((row) => {
+        row[i] = parser(row[i]);
+      });
+    }
+  });
+  return rows;
+};
+
+const parseValue = (
+  value: unknown,
+  fields: { name: string }[],
+  query: Query,
+) => {
+  const field = fields[0];
+  if (value !== null) {
+    const parsers = getQueryParsers(query);
+    const parser = parsers?.[field.name];
+    if (parser) {
+      return parser(value);
+    }
+  }
+  return value;
+};

package/src/queryMethods/transaction.test.ts

@@ -0,0 +1,66 @@
+import { db, User } from '../test-utils';
+import { Client } from 'pg';
+
+describe('transaction', () => {
+  beforeEach(() => jest.clearAllMocks());
+
+  it('should start and commit transaction', async () => {
+    const spy = jest.spyOn(Client.prototype, 'query');
+
+    const result = await db.transaction(async (db) => {
+      expect(db.query.inTransaction).toBe(true);
+
+      const {
+        rows: [{ a }],
+      } = await db.adapter.query('SELECT 1 AS a');
+      const {
+        rows: [{ b }],
+      } = await db.adapter.query('SELECT 2 AS b');
+      return a + b;
+    });
+
+    expect(result).toBe(3);
+
+    expect(
+      spy.mock.calls.map(
+        (call) => (call[0] as unknown as { text: string }).text,
+      ),
+    ).toEqual(['BEGIN', 'SELECT 1 AS a', 'SELECT 2 AS b', 'COMMIT']);
+  });
+
+  it('should rollback if error happens', async () => {
+    const spy = jest.spyOn(Client.prototype, 'query');
+
+    let error: Error | undefined;
+
+    await db
+      .transaction(async () => {
+        throw new Error('error');
+      })
+      .catch((err) => (error = err));
+
+    expect(error?.message).toBe('error');
+
+    expect(
+      spy.mock.calls.map(
+        (call) => (call[0] as unknown as { text: string }).text,
+      ),
+    ).toEqual(['BEGIN', 'ROLLBACK']);
+  });
+
+  describe('transacting', () => {
+    it('should use provided adapter to perform queries', async () => {
+      const spy = jest.spyOn(Client.prototype, 'query');
+
+      await db.transaction(async (trx) => {
+        return User.transacting(trx).all();
+      });
+
+      expect(
+        spy.mock.calls.map(
+          (call) => (call[0] as unknown as { text: string }).text,
+        ),
+      ).toEqual(['BEGIN', 'SELECT * FROM "user"', 'COMMIT']);
+    });
+  });
+});

package/src/queryMethods/transaction.ts

@@ -0,0 +1,66 @@
+import { Query } from '../query';
+
+const beginSql = {
+  text: 'BEGIN',
+  values: [],
+};
+
+const commitSql = {
+  text: 'COMMIT',
+  values: [],
+};
+
+const rollbackSql = {
+  text: 'ROLLBACK',
+  values: [],
+};
+
+export class Transaction {
+  async transaction<T extends Query, Result>(
+    this: T,
+    cb: (query: T) => Promise<Result>,
+  ): Promise<Result> {
+    const log = this.query.log;
+    let logData: unknown | undefined;
+    if (log) {
+      logData = log.beforeQuery(this, beginSql);
+    }
+    const t = this.query.adapter.transaction((adapter) => {
+      if (log) {
+        log.afterQuery(this, beginSql, logData);
+      }
+
+      const q = this.clone();
+      q.query.adapter = adapter;
+      q.query.inTransaction = true;
+
+      if (log) {
+        logData = log.beforeQuery(this, commitSql);
+      }
+      return cb(q);
+    });
+
+    if (log) {
+      t.then(
+        () => {
+          log.afterQuery(this, commitSql, logData);
+        },
+        () => {
+          log.afterQuery(this, rollbackSql, logData);
+        },
+      );
+    }
+
+    return t;
+  }
+
+  transacting<T extends Query>(this: T, query: Query): T {
+    return this.clone()._transacting(query);
+  }
+
+  _transacting<T extends Query>(this: T, query: Query): T {
+    this.query.adapter = query.query.adapter;
+    this.query.inTransaction = true;
+    return this;
+  }
+}

package/src/queryMethods/union.test.ts

@@ -0,0 +1,59 @@
+import { Chat, expectQueryNotMutated, expectSql, User } from '../test-utils';
+import { raw } from '../common';
+
+['union', 'intersect', 'except'].forEach((what) => {
+  const upper = what.toUpperCase();
+  describe(what, () => {
+    it(`adds ${what}`, () => {
+      const q = User.all();
+      let query = q.select('id');
+      query = query[what as 'union']([Chat.select('id'), raw('SELECT 1')]);
+      query = query[
+        (what + 'All') as 'unionAll' | 'intersectAll' | 'exceptAll'
+      ]([raw('SELECT 2')], true);
+
+      const wrapped = query.wrap(User.select('id'));
+
+      expectSql(
+        wrapped.toSql(),
+        `
+          SELECT "t"."id" FROM (
+            SELECT "user"."id" FROM "user"
+            ${upper}
+            SELECT "chat"."id" FROM "chat"
+            ${upper}
+            SELECT 1
+            ${upper} ALL
+            (SELECT 2)
+          ) AS "t"
+        `,
+      );
+
+      expectQueryNotMutated(q);
+    });
+
+    it('has modifier', () => {
+      const q = User.select('id');
+      q[`_${what}` as '_union']([raw('SELECT 1')]);
+      expectSql(
+        q.toSql(),
+        `
+          SELECT "user"."id" FROM "user"
+          ${upper}
+          SELECT 1
+        `,
+      );
+      q[`_${what}All` as '_unionAll']([raw('SELECT 2')], true);
+      expectSql(
+        q.toSql(),
+        `
+        SELECT "user"."id" FROM "user"
+        ${upper}
+        SELECT 1
+        ${upper} ALL
+        (SELECT 2)
+      `,
+      );
+    });
+  });
+});