pqb 0.0.1

package/src/queryMethods/with.test.ts

@@ -0,0 +1,191 @@
+import { WithOptions } from '../sql';
+import { expectQueryNotMutated, expectSql, User } from '../test-utils';
+import { columnTypes, NumberColumn } from '../columnSchema';
+import { raw } from '../common';
+
+describe('with', () => {
+  const options: (
+    | undefined
+    | (Omit<WithOptions, 'columns'> & { columns?: boolean | string[] })
+  )[] = [
+    undefined,
+    { columns: true },
+    { columns: ['custom', 'columns', 'list'] },
+    { recursive: true },
+    { materialized: true },
+    { notMaterialized: true },
+  ];
+
+  const getExpectedWithSql = (
+    sql: string,
+    columns: string[],
+    opts: typeof options[number],
+  ) => {
+    return `
+        WITH${opts?.recursive ? ' RECURSIVE' : ''} "withAlias"${
+      opts?.columns
+        ? `(${(opts.columns === true ? columns : opts.columns)
+            .map((column) => `"${column}"`)
+            .join(', ')})`
+        : ''
+    } AS ${
+      opts?.materialized
+        ? 'MATERIALIZED '
+        : opts?.notMaterialized
+        ? 'NOT MATERIALIZED '
+        : ''
+    } (
+          ${sql}
+        )
+        SELECT *
+        FROM "withAlias"
+      `;
+  };
+
+  const columnShape = { one: columnTypes.integer(), two: columnTypes.text() };
+
+  it('accepts raw parameter preceded by columns shape', () => {
+    const q = User.all();
+
+    options.forEach((options) => {
+      const args: Parameters<typeof q.with> = [
+        'withAlias',
+        columnShape,
+        raw(`(VALUES (1, 'two')) t(one, two)`),
+      ];
+
+      if (options) {
+        (args as unknown[]).splice(1, 0, options);
+      }
+
+      expectSql(
+        q
+          .with(...args)
+          .from('withAlias')
+          .toSql(),
+        getExpectedWithSql(
+          `(VALUES (1, 'two')) t(one, two)`,
+          ['one', 'two'],
+          options,
+        ),
+      );
+    });
+
+    expectQueryNotMutated(q);
+  });
+
+  it('accepts query', () => {
+    const q = User.all();
+
+    options.forEach((options) => {
+      const args: Parameters<typeof q.with> = ['withAlias', User.all()];
+
+      if (options) {
+        (args as unknown[]).splice(1, 0, options);
+      }
+
+      expectSql(
+        q
+          .with(...args)
+          .from('withAlias')
+          .toSql(),
+        getExpectedWithSql(
+          'SELECT * FROM "user"',
+          Object.keys(User.shape),
+          options,
+        ),
+      );
+    });
+
+    expectQueryNotMutated(q);
+  });
+
+  it('accepts callback for query builder', () => {
+    const q = User.all();
+
+    options.forEach((options) => {
+      const args: Parameters<typeof q.with> = [
+        'withAlias',
+        (qb) => qb.select({ one: raw<NumberColumn>('1') }),
+      ];
+
+      if (options) {
+        (args as unknown[]).splice(1, 0, options);
+      }
+
+      expectSql(
+        q
+          .with(...args)
+          .from('withAlias')
+          .toSql(),
+        getExpectedWithSql(
+          `SELECT 1 AS "one"`,
+          // columns: true will produce empty columns list because there is no way to get it from query builder result
+          [],
+          options,
+        ),
+      );
+    });
+
+    expectQueryNotMutated(q);
+  });
+
+  it('can be referenced in .join', () => {
+    const q = User.all();
+
+    const received1 = q
+      .with('withAlias', User.all())
+      .join('withAlias', 'id', '=', 'user.id')
+      .select('withAlias.id')
+      .toSql();
+
+    const received2 = q
+      .with('withAlias', User.all())
+      .join('withAlias', 'withAlias.id', '=', 'user.id')
+      .select('withAlias.id')
+      .toSql();
+
+    const received3 = q
+      .with('withAlias', User.all())
+      .join('withAlias', raw(`"withAlias"."id" = "user"."id"`))
+      .select('withAlias.id')
+      .toSql();
+
+    const received4 = q
+      .with('withAlias', User.all())
+      .join('withAlias', (qb) => qb.on('withAlias.id', '=', 'user.id'))
+      .select('withAlias.id')
+      .toSql();
+
+    const expected = `
+      WITH "withAlias" AS (
+        SELECT * FROM "user"
+      )
+      SELECT "withAlias"."id" FROM "user"
+      JOIN "withAlias" ON "withAlias"."id" = "user"."id"
+    `;
+
+    expectSql(received1, expected);
+    expectSql(received2, expected);
+    expectSql(received3, expected);
+    expectSql(received4, expected);
+
+    expectQueryNotMutated(q);
+  });
+
+  it('can be used in .from', () => {
+    const q = User.all();
+
+    expectSql(
+      q.with('withAlias', User.all()).from('withAlias').select('id').toSql(),
+      `
+        WITH "withAlias" AS (
+          SELECT * FROM "user"
+        )
+        SELECT "withAlias"."id" FROM "withAlias"
+      `,
+    );
+
+    expectQueryNotMutated(q);
+  });
+});

package/src/queryMethods/with.ts

@@ -0,0 +1,92 @@
+import { WithOptions } from '../sql';
+import { ColumnShapeOutput, ColumnsShape, ColumnTypes } from '../columnSchema';
+import { EMPTY_OBJECT, isRaw, RawExpression } from '../common';
+import { AddQueryWith, Query } from '../query';
+import { Db } from '../db';
+import { pushQueryValue, setQueryObjectValue } from '../queryDataUtils';
+
+type WithArgsOptions = Omit<WithOptions, 'columns'> & {
+  columns?: boolean | string[];
+};
+
+type WithArgs =
+  | [string, ColumnsShape, RawExpression]
+  | [string, WithArgsOptions, ColumnsShape, RawExpression]
+  | [string, Query | ((qb: Db) => Query)]
+  | [string, WithArgsOptions, Query | ((qb: Db) => Query)];
+
+type WithShape<Args extends WithArgs> = Args[1] extends Query
+  ? Args[1]['result']
+  : Args[1] extends (qb: Db) => Query
+  ? ReturnType<Args[1]>['result']
+  : Args[2] extends Query
+  ? Args[2]['result']
+  : Args[2] extends (qb: Db) => Query
+  ? ReturnType<Args[2]>['result']
+  : Args[1] extends ColumnsShape
+  ? Args[1]
+  : Args[2] extends ColumnsShape
+  ? Args[2]
+  : Args[2] extends (t: ColumnTypes) => ColumnsShape
+  ? ReturnType<Args[2]>
+  : never;
+
+type WithResult<
+  T extends Query,
+  Args extends WithArgs,
+  Shape extends ColumnsShape,
+> = AddQueryWith<
+  T,
+  {
+    table: Args[0];
+    shape: Shape;
+    type: ColumnShapeOutput<Shape>;
+  }
+>;
+
+export class With {
+  with<
+    T extends Query,
+    Args extends WithArgs,
+    Shape extends ColumnsShape = WithShape<Args>,
+  >(this: T, ...args: Args): WithResult<T, Args, Shape> {
+    return this.clone()._with<T, Args, Shape>(...args);
+  }
+
+  _with<
+    T extends Query,
+    Args extends WithArgs,
+    Shape extends ColumnsShape = WithShape<Args>,
+  >(this: T, ...args: Args): WithResult<T, Args, Shape> {
+    let options =
+      (args.length === 3 && !isRaw(args[2])) || args.length === 4
+        ? (args[1] as WithArgsOptions | WithOptions)
+        : undefined;
+
+    const last = args[args.length - 1] as
+      | Query
+      | ((qb: Db) => Query)
+      | RawExpression;
+
+    const query = typeof last === 'function' ? last(this.queryBuilder) : last;
+
+    const shape =
+      args.length === 4 ? (args[2] as ColumnsShape) : (query as Query).shape;
+
+    if (options?.columns === true) {
+      options = {
+        ...options,
+        columns: Object.keys(shape),
+      };
+    }
+
+    pushQueryValue(this, 'with', [args[0], options || EMPTY_OBJECT, query]);
+
+    return setQueryObjectValue(
+      this,
+      'withShapes',
+      args[0],
+      shape,
+    ) as unknown as WithResult<T, Args, Shape>;
+  }
+}

package/src/quote.ts

@@ -0,0 +1,36 @@
+const singleQuoteRegex = /'/g;
+const doubleQuoteRegex = /"/g;
+
+// eslint-disable-next-line
+type Value = any
+
+const quoteValue = (value: Value): string => {
+  const type = typeof value;
+  if (type === 'number') return String(value);
+  else if (type === 'string')
+    return `"${(value as string)
+      .replace(doubleQuoteRegex, '\\"')
+      .replace(singleQuoteRegex, "''")}"`;
+  else if (type === 'boolean') return value ? 'true' : 'false';
+  else if (value instanceof Date) return `"${value.toISOString()}"`;
+  else if (Array.isArray(value)) return quoteArray(value);
+  else if (type === null || type === undefined) return 'NULL';
+  else
+    return `"${JSON.stringify(value)
+      .replace(doubleQuoteRegex, '\\"')
+      .replace(singleQuoteRegex, "''")}"`;
+};
+
+const quoteArray = (array: Value[]) => `'{${array.map(quoteValue).join(',')}}'`;
+
+export const quote = (value: Value): string => {
+  const type = typeof value;
+  if (type === 'number') return `${value}`;
+  else if (type === 'string')
+    return `'${(value as string).replace(singleQuoteRegex, "''")}'`;
+  else if (type === 'boolean') return value ? 'true' : 'false';
+  else if (value instanceof Date) return `'${value.toISOString()}'`;
+  else if (Array.isArray(value)) return quoteArray(value);
+  else if (value === null || value === undefined) return 'NULL';
+  else return `'${JSON.stringify(value).replace(singleQuoteRegex, "''")}'`;
+};

package/src/relations.ts

@@ -0,0 +1,194 @@
+import { defaultsKey, Query, QueryBase, QueryWithTable } from './query';
+import { WhereArg } from './queryMethods/where';
+import { MaybeArray } from './utils';
+import { UpdateData } from './queryMethods/update';
+
+export type NestedInsertOneItem = {
+  create?: Record<string, unknown>;
+  connect?: WhereArg<QueryBase>;
+};
+
+export type NestedInsertManyItems = {
+  create?: Record<string, unknown>[];
+  connect?: WhereArg<QueryBase>[];
+  connectOrCreate?: {
+    where: WhereArg<QueryBase>;
+    create: Record<string, unknown>;
+  }[];
+};
+
+export type NestedInsertItem = NestedInsertOneItem | NestedInsertManyItems;
+
+export type BelongsToNestedInsert = (
+  query: Query,
+  relationData: NestedInsertOneItem[],
+) => Promise<Record<string, unknown>[]>;
+
+export type HasOneNestedInsert = (
+  query: Query,
+  data: [
+    selfData: Record<string, unknown>,
+    relationData: NestedInsertOneItem,
+  ][],
+) => Promise<void>;
+
+export type HasManyNestedInsert = (
+  query: Query,
+  data: [
+    selfData: Record<string, unknown>,
+    relationData: NestedInsertManyItems,
+  ][],
+) => Promise<void>;
+
+export type NestedUpdateOneItem = {
+  disconnect?: boolean;
+  set?: WhereArg<QueryBase>;
+  delete?: boolean;
+  update?: UpdateData<Query>;
+  upsert?: {
+    update: UpdateData<Query>;
+    create: Record<string, unknown>;
+  };
+  create: Record<string, unknown>;
+};
+
+export type NestedUpdateManyItems = {
+  disconnect?: MaybeArray<WhereArg<QueryBase>>;
+  set?: MaybeArray<WhereArg<QueryBase>>;
+  delete?: MaybeArray<WhereArg<QueryBase>>;
+  update?: {
+    where: MaybeArray<WhereArg<QueryBase>>;
+    data: UpdateData<Query>;
+  };
+  create: Record<string, unknown>[];
+};
+
+export type NestedUpdateItem = NestedUpdateOneItem | NestedUpdateManyItems;
+
+export type BelongsToNestedUpdate = (
+  q: Query,
+  update: Record<string, unknown>,
+  params: NestedUpdateOneItem,
+  state: {
+    updateLater?: Record<string, unknown>;
+    updateLaterPromises?: Promise<void>[];
+  },
+) => boolean;
+
+export type HasOneNestedUpdate = (
+  query: Query,
+  data: Record<string, unknown>[],
+  relationData: NestedUpdateOneItem,
+) => Promise<void>;
+
+export type HasManyNestedUpdate = (
+  query: Query,
+  data: Record<string, unknown>[],
+  relationData: NestedUpdateManyItems,
+) => Promise<void>;
+
+export type BaseRelation = {
+  type: string;
+  key: string;
+  model: QueryWithTable;
+  joinQuery: Query;
+  nestedCreateQuery: Query;
+  nestedInsert?:
+    | BelongsToNestedInsert
+    | HasOneNestedInsert
+    | HasManyNestedInsert;
+  nestedUpdate?:
+    | BelongsToNestedUpdate
+    | HasOneNestedUpdate
+    | HasManyNestedUpdate;
+  primaryKey: string;
+  options: {
+    scope?(q: QueryWithTable): QueryWithTable;
+    required?: boolean;
+  };
+};
+
+export interface BelongsToRelation extends BaseRelation {
+  type: 'belongsTo';
+  returns: 'one';
+  options: BaseRelation['options'] & {
+    primaryKey: string;
+    foreignKey: string;
+  };
+}
+
+export interface HasOneRelation extends BaseRelation {
+  type: 'hasOne';
+  returns: 'one';
+  options: BaseRelation['options'] &
+    (
+      | {
+          primaryKey: string;
+          foreignKey: string;
+        }
+      | {
+          through: string;
+          source: string;
+        }
+    );
+}
+
+export interface HasManyRelation extends BaseRelation {
+  type: 'hasMany';
+  returns: 'many';
+  options: BaseRelation['options'] &
+    (
+      | {
+          primaryKey: string;
+          foreignKey: string;
+        }
+      | {
+          through: string;
+          source: string;
+        }
+    );
+}
+
+export interface HasAndBelongsToManyRelation extends BaseRelation {
+  type: 'hasAndBelongsToMany';
+  returns: 'many';
+  options: BaseRelation['options'] & {
+    primaryKey: string;
+    foreignKey: string;
+    associationPrimaryKey: string;
+    associationForeignKey: string;
+    joinTable: string;
+  };
+}
+
+export type Relation =
+  | BelongsToRelation
+  | HasOneRelation
+  | HasManyRelation
+  | HasAndBelongsToManyRelation;
+
+export type RelationsBase = Record<never, Relation>;
+
+export type relationQueryKey = typeof relationQueryKey;
+export const relationQueryKey = Symbol('relationQuery');
+
+export type isRequiredRelationKey = typeof isRequiredRelationKey;
+export const isRequiredRelationKey = Symbol('isRequiredRelation');
+
+export type RelationQueryBase = Query & {
+  [relationQueryKey]: string;
+  [isRequiredRelationKey]: boolean;
+};
+
+export type RelationQuery<
+  RelationName extends PropertyKey = string,
+  Params extends Record<string, unknown> = never,
+  Populate extends string = never,
+  T extends Query = Query,
+  Required extends boolean = boolean,
+  Q extends RelationQueryBase = Omit<T, 'tableAlias'> & {
+    tableAlias: RelationName extends string ? RelationName : never;
+    [isRequiredRelationKey]: Required;
+    [relationQueryKey]: string;
+  },
+> = ((params: Params) => Q & { [defaultsKey]: Pick<T['type'], Populate> }) & Q;

package/src/sql/aggregate.ts

@@ -0,0 +1,80 @@
+import { AggregateItem } from './types';
+import { addValue, expressionToSql, q } from './common';
+import { EMPTY_OBJECT, Expression, getRaw, isRaw } from '../common';
+import { windowToSql } from './window';
+import { pushOrderBySql } from './orderBy';
+import { whereToSql } from './where';
+import { Query } from '../query';
+
+export const aggregateToSql = (
+  model: Pick<
+    Query,
+    'whereQueryBuilder' | 'onQueryBuilder' | 'as' | 'shape' | 'relations'
+  >,
+  values: unknown[],
+  item: AggregateItem,
+  quotedAs?: string,
+) => {
+  const sql: string[] = [`${item.function}(`];
+
+  const options = item.options || EMPTY_OBJECT;
+
+  if (options.distinct && !options.withinGroup) sql.push('DISTINCT ');
+
+  if (typeof item.arg === 'object') {
+    if (Array.isArray(item.arg)) {
+      sql.push(
+        `${expressionToSql(item.arg[0], values, quotedAs)}, ${addValue(
+          values,
+          item.arg[1],
+        )}`,
+      );
+    } else if (isRaw(item.arg)) {
+      sql.push(getRaw(item.arg, values));
+    } else {
+      const args: string[] = [];
+      for (const key in item.arg) {
+        args.push(
+          // ::text is needed to bypass "could not determine data type of parameter" postgres error
+          `${addValue(values, key)}::text, ${expressionToSql(
+            item.arg[key as keyof typeof item.arg] as unknown as Expression,
+            values,
+            quotedAs,
+          )}`,
+        );
+      }
+      sql.push(args.join(', '));
+    }
+  } else if (item.arg) {
+    sql.push(expressionToSql(item.arg, values, quotedAs));
+  }
+
+  if (options.withinGroup) sql.push(') WITHIN GROUP (');
+  else if (options.order) sql.push(' ');
+
+  if (options.order) pushOrderBySql(sql, values, quotedAs, options.order);
+
+  sql.push(')');
+
+  if (options.filter || options.filterOr) {
+    const whereSql = whereToSql(
+      model,
+      {
+        and: options.filter ? [options.filter] : undefined,
+        or: options.filterOr?.map((item) => [item]),
+      },
+      values,
+      quotedAs,
+    );
+
+    sql.push(` FILTER (WHERE ${whereSql})`);
+  }
+
+  if (options.over) {
+    sql.push(` OVER ${windowToSql(options.over, values, quotedAs)}`);
+  }
+
+  if (options.as) sql.push(` AS ${q(options.as)}`);
+
+  return sql.join('');
+};

package/src/sql/columnInfo.ts

@@ -0,0 +1,22 @@
+import { ColumnInfoQueryData } from './types';
+import { addValue } from './common';
+
+export const pushColumnInfoSql = (
+  sql: string[],
+  values: unknown[],
+  table: string,
+  query: ColumnInfoQueryData,
+) => {
+  sql.push(
+    `SELECT * FROM information_schema.columns WHERE table_name = ${addValue(
+      values,
+      table,
+    )} AND table_catalog = current_database() AND table_schema = ${
+      query.schema || 'current_schema()'
+    }`,
+  );
+
+  if (query.column) {
+    sql.push(`AND column_name = ${addValue(values, query.column)}`);
+  }
+};

package/src/sql/common.ts

@@ -0,0 +1,42 @@
+// quote table or column
+import { Query } from '../query';
+import { Expression, getRaw, isRaw } from '../common';
+
+export const q = (sql: string) => `"${sql}"`;
+
+// quote column with table or as
+export const qc = (column: string, quotedAs?: string) =>
+  quotedAs ? `${quotedAs}.${q(column)}` : column;
+
+export const quoteFullColumn = (fullColumn: string, quotedAs?: string) => {
+  const index = fullColumn.indexOf('.');
+  if (index !== -1) {
+    return `${q(fullColumn.slice(0, index))}.${q(fullColumn.slice(index + 1))}`;
+  } else if (quotedAs) {
+    return `${quotedAs}.${q(fullColumn)}`;
+  } else {
+    return q(fullColumn);
+  }
+};
+
+export const expressionToSql = <T extends Query>(
+  expr: Expression<T>,
+  values: unknown[],
+  quotedAs?: string,
+) => {
+  return typeof expr === 'object' && isRaw(expr)
+    ? getRaw(expr, values)
+    : quoteFullColumn(expr as string, quotedAs);
+};
+
+export const quoteSchemaAndTable = (
+  schema: string | undefined,
+  table: string,
+) => {
+  return schema ? `${q(schema)}.${q(table)}` : q(table);
+};
+
+export const addValue = (values: unknown[], value: unknown) => {
+  values.push(value);
+  return `$${values.length}`;
+};

package/src/sql/delete.ts

@@ -0,0 +1,41 @@
+import { Query } from '../query';
+import { DeleteQueryData } from './types';
+import { pushWhereSql } from './where';
+import { pushReturningSql } from './insert';
+import { processJoinItem } from './join';
+
+export const pushDeleteSql = (
+  sql: string[],
+  values: unknown[],
+  model: Query,
+  query: DeleteQueryData,
+  quotedAs: string,
+) => {
+  sql.push(`DELETE FROM ${quotedAs}`);
+
+  let conditions: string | undefined;
+  if (query.join?.length) {
+    const items = query.join.map((item) =>
+      processJoinItem(model, query, values, item.args, quotedAs),
+    );
+
+    sql.push(`USING ${items.map((item) => item.target).join(', ')}`);
+
+    conditions = items
+      .map((item) => item.conditions)
+      .filter(Boolean)
+      .join(' AND ');
+  }
+
+  pushWhereSql(sql, model, query, values, quotedAs);
+
+  if (conditions?.length) {
+    if (query.and?.length || query.or?.length) {
+      sql.push('AND', conditions);
+    } else {
+      sql.push('WHERE', conditions);
+    }
+  }
+
+  pushReturningSql(sql, model, query, values, quotedAs);
+};