pqb 0.0.1

package/src/sql/distinct.ts

@@ -0,0 +1,19 @@
+import { SelectQueryData } from './types';
+import { expressionToSql } from './common';
+
+export const pushDistinctSql = (
+  sql: string[],
+  values: unknown[],
+  distinct: Exclude<SelectQueryData['distinct'], undefined>,
+  quotedAs?: string,
+) => {
+  sql.push('DISTINCT');
+
+  if (distinct.length) {
+    const columns: string[] = [];
+    distinct?.forEach((item) => {
+      columns.push(expressionToSql(item, values, quotedAs));
+    });
+    sql.push(`ON (${columns.join(', ')})`);
+  }
+};

package/src/sql/fromAndAs.ts

@@ -0,0 +1,51 @@
+import { getRaw, isRaw } from '../common';
+import { quoteSchemaAndTable } from './common';
+import { Query } from '../query';
+import { queryKeysOfNotSimpleQuery, SelectQueryData } from './types';
+
+export const pushFromAndAs = (
+  sql: string[],
+  model: Query,
+  query: SelectQueryData,
+  values: unknown[],
+  quotedAs?: string,
+) => {
+  sql.push('FROM');
+  if (query.fromOnly) sql.push('ONLY');
+
+  const from = getFrom(model, query, values);
+  sql.push(from);
+
+  if (query.as && quotedAs && quotedAs !== from) {
+    sql.push('AS', quotedAs as string);
+  }
+};
+
+const getFrom = (model: Query, query: SelectQueryData, values: unknown[]) => {
+  if (query.from) {
+    if (typeof query.from === 'object') {
+      if (isRaw(query.from)) {
+        return getRaw(query.from, values);
+      }
+
+      if (!query.from.table) {
+        const sql = query.from.toSql(values);
+        return `(${sql.text})`;
+      }
+
+      const q = query.from.query;
+      const keys = Object.keys(q) as (keyof SelectQueryData)[];
+      // if query contains more than just schema return (SELECT ...)
+      if (keys.some((key) => queryKeysOfNotSimpleQuery.includes(key))) {
+        const sql = query.from.toSql(values);
+        return `(${sql.text})`;
+      }
+
+      return quoteSchemaAndTable(q.schema, query.from.table);
+    }
+
+    return quoteSchemaAndTable(query.schema, query.from);
+  }
+
+  return quoteSchemaAndTable(query.schema, model.table as string);
+};

package/src/sql/having.ts

@@ -0,0 +1,140 @@
+import { AggregateItemOptions, HavingItem, SelectQueryData } from './types';
+import { EMPTY_OBJECT, getRaw, isRaw, RawExpression } from '../common';
+import { Operator } from '../operators';
+import { aggregateToSql } from './aggregate';
+import { Query } from '../query';
+import { addValue, q } from './common';
+
+const aggregateOptionNames: (keyof AggregateItemOptions)[] = [
+  'distinct',
+  'order',
+  'filter',
+  'filterOr',
+  'withinGroup',
+];
+
+export const pushHavingSql = (
+  sql: string[],
+  model: Pick<
+    Query,
+    'whereQueryBuilder' | 'onQueryBuilder' | 'as' | 'shape' | 'relations'
+  >,
+  query: SelectQueryData,
+  values: unknown[],
+  quotedAs?: string,
+) => {
+  const conditions = havingToSql(model, query, values, quotedAs);
+  if (conditions.length) sql.push('HAVING', conditions);
+};
+
+export const havingToSql = (
+  model: Pick<
+    Query,
+    'whereQueryBuilder' | 'onQueryBuilder' | 'as' | 'shape' | 'relations'
+  >,
+  query: SelectQueryData,
+  values: unknown[],
+  quotedAs?: string,
+): string => {
+  const or =
+    query.having && query.havingOr
+      ? [query.having, ...query.havingOr]
+      : query.having
+      ? [query.having]
+      : query.havingOr;
+  if (!or?.length) return '';
+
+  const ors: string[] = [];
+  or.forEach((and) => {
+    const ands: string[] = [];
+    and.forEach((item) => {
+      if ('prototype' in item || '__model' in item) {
+        const query = item as Query;
+        const sql = havingToSql(
+          query,
+          query.query as SelectQueryData,
+          values,
+          query.table && q(query.table),
+        );
+        if (sql.length) ands.push(`(${sql})`);
+        return;
+      }
+
+      if (isRaw(item)) {
+        ands.push(getRaw(item, values));
+        return;
+      }
+
+      for (const key in item) {
+        const columns = item[key as keyof Exclude<HavingItem, RawExpression>];
+        if (typeof columns === 'object') {
+          for (const column in columns) {
+            const valueOrOptions = columns[column as keyof typeof columns];
+            if (
+              typeof valueOrOptions === 'object' &&
+              valueOrOptions !== null &&
+              valueOrOptions !== undefined
+            ) {
+              for (const op in valueOrOptions) {
+                if (
+                  !aggregateOptionNames.includes(
+                    op as keyof AggregateItemOptions,
+                  )
+                ) {
+                  const operator = model.shape[column].operators[
+                    op
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                  ] as Operator<any>;
+                  if (!operator) {
+                    // TODO: custom error classes
+                    throw new Error(
+                      `Unknown operator ${op} provided to condition`,
+                    );
+                  }
+
+                  const expression = aggregateToSql(
+                    model,
+                    values,
+                    {
+                      function: key,
+                      arg: column,
+                      options: valueOrOptions as AggregateItemOptions,
+                    },
+                    quotedAs,
+                  );
+
+                  ands.push(
+                    operator(
+                      expression,
+                      valueOrOptions[op as keyof typeof valueOrOptions],
+                      values,
+                    ),
+                  );
+                }
+              }
+            } else {
+              ands.push(
+                `${aggregateToSql(
+                  model,
+                  values,
+                  {
+                    function: key,
+                    arg: column,
+                    options: EMPTY_OBJECT,
+                  },
+                  quotedAs,
+                )} = ${addValue(values, valueOrOptions)}`,
+              );
+            }
+          }
+        } else {
+          ands.push(`${key}(*) = ${columns}`);
+        }
+      }
+    });
+
+    ors.push(ands.join(' AND '));
+  });
+
+  return ors.join(' OR ');
+};

package/src/sql/index.ts

@@ -0,0 +1,2 @@
+export * from './toSql';
+export * from './types';

package/src/sql/insert.ts

@@ -0,0 +1,102 @@
+import { InsertQueryData, QueryData } from './types';
+import { addValue, q } from './common';
+import { getRaw, isRaw } from '../common';
+import { pushWhereSql } from './where';
+import { Query } from '../query';
+import { selectToSql } from './select';
+
+export const pushInsertSql = (
+  sql: string[],
+  values: unknown[],
+  model: Pick<
+    Query,
+    'whereQueryBuilder' | 'onQueryBuilder' | 'as' | 'shape' | 'relations'
+  >,
+  query: InsertQueryData,
+  quotedAs: string,
+) => {
+  const quotedColumns = query.columns.map(q);
+
+  sql.push(
+    `INSERT INTO ${quotedAs}(${quotedColumns.join(', ')}) VALUES ${
+      isRaw(query.values)
+        ? getRaw(query.values, values)
+        : query.values
+            .map(
+              (row) =>
+                `(${row
+                  .map((value) =>
+                    value === undefined ? 'DEFAULT' : addValue(values, value),
+                  )
+                  .join(', ')})`,
+            )
+            .join(', ')
+    }`,
+  );
+
+  if (query.onConflict) {
+    sql.push('ON CONFLICT');
+
+    const { expr, type } = query.onConflict;
+    if (expr) {
+      if (typeof expr === 'string') {
+        sql.push(`(${q(expr)})`);
+      } else if (Array.isArray(expr)) {
+        sql.push(`(${expr.map(q).join(', ')})`);
+      } else {
+        sql.push(getRaw(expr, values));
+      }
+    } else {
+      sql.push(`(${quotedColumns.join(', ')})`);
+    }
+
+    if (type === 'ignore') {
+      sql.push('DO NOTHING');
+    } else if (type === 'merge') {
+      let set: string;
+
+      const { update } = query.onConflict;
+      if (update) {
+        if (typeof update === 'string') {
+          set = `${q(update)} = excluded.${q(update)}`;
+        } else if (Array.isArray(update)) {
+          set = update
+            .map((column) => `${q(column)} = excluded.${q(column)}`)
+            .join(', ');
+        } else if (isRaw(update)) {
+          set = getRaw(update, values);
+        } else {
+          const arr: string[] = [];
+          for (const key in update) {
+            arr.push(`${q(key)} = ${addValue(values, update[key])}`);
+          }
+          set = arr.join(', ');
+        }
+      } else {
+        set = quotedColumns
+          .map((column) => `${column} = excluded.${column}`)
+          .join(', ');
+      }
+
+      sql.push('DO UPDATE SET', set);
+    }
+  }
+
+  pushWhereSql(sql, model, query, values, quotedAs);
+  pushReturningSql(sql, model, query, values, quotedAs);
+};
+
+export const pushReturningSql = (
+  sql: string[],
+  model: Pick<
+    Query,
+    'whereQueryBuilder' | 'onQueryBuilder' | 'as' | 'shape' | 'relations'
+  >,
+  query: QueryData,
+  values: unknown[],
+  quotedAs: string,
+) => {
+  if (query.select) {
+    sql.push(`RETURNING ${selectToSql(model, query, values, quotedAs)}`);
+  }
+};

package/src/sql/join.ts

@@ -0,0 +1,242 @@
+import { q, quoteFullColumn, quoteSchemaAndTable } from './common';
+import { getRaw, isRaw, RawExpression } from '../common';
+import { JoinItem, QueryData } from './types';
+import { Query, QueryBase } from '../query';
+import { whereToSql } from './where';
+import { Relation } from '../relations';
+
+type ItemOf3Or4Length =
+  | [
+      _: unknown,
+      leftColumn: string | RawExpression,
+      rightColumn: string | RawExpression,
+    ]
+  | [
+      _: unknown,
+      leftColumn: string | RawExpression,
+      op: string,
+      rightColumn?: string | RawExpression,
+    ];
+
+export const processJoinItem = (
+  model: Pick<
+    Query,
+    'whereQueryBuilder' | 'onQueryBuilder' | 'table' | 'shape' | 'relations'
+  >,
+  query: Pick<QueryData, 'as'>,
+  values: unknown[],
+  args: JoinItem['args'],
+  quotedAs?: string,
+): { target: string; conditions?: string } => {
+  const [first] = args;
+  if (typeof first === 'string') {
+    if (first in model.relations) {
+      const { key, joinQuery } = (model.relations as Record<string, Relation>)[
+        first
+      ];
+
+      const table = (
+        typeof joinQuery.query.from === 'string'
+          ? joinQuery.query.from
+          : joinQuery.table
+      ) as string;
+
+      let target = quoteSchemaAndTable(joinQuery.query.schema, table);
+
+      const as = joinQuery.query.as || key;
+      if (as !== table) {
+        target += ` AS ${q(as as string)}`;
+      }
+
+      const queryData = {
+        and: [],
+        or: [],
+      } as {
+        and: Exclude<QueryData['and'], undefined>;
+        or: Exclude<QueryData['or'], undefined>;
+      };
+
+      if (joinQuery.query.and) queryData.and.push(...joinQuery.query.and);
+      if (joinQuery.query.or) queryData.or.push(...joinQuery.query.or);
+
+      const arg = (args[1] as ((q: unknown) => QueryBase) | undefined)?.(
+        new model.onQueryBuilder({ table: model.table, query }, args[0]),
+      ).query;
+
+      if (arg) {
+        if (arg.and) queryData.and.push(...arg.and);
+        if (arg.or) queryData.or.push(...arg.or);
+      }
+
+      const joinAs = q(as as string);
+      const onConditions = whereToSql(
+        joinQuery,
+        queryData,
+        values,
+        quotedAs,
+        joinAs,
+      );
+      const conditions = onConditions ? onConditions : undefined;
+
+      return { target, conditions };
+    }
+
+    const target = q(first);
+    let conditions: string | undefined;
+
+    if (args.length === 2) {
+      const arg = args[1];
+      if (typeof arg === 'function') {
+        const joinQuery = arg(
+          new model.onQueryBuilder({ table: model.table, query }, args[0]),
+        );
+        const onConditions = whereToSql(
+          model,
+          joinQuery.query,
+          values,
+          quotedAs,
+          target,
+        );
+        if (onConditions) conditions = onConditions;
+      } else {
+        conditions = getObjectOrRawConditions(arg, values, quotedAs, target);
+      }
+    } else if (args.length >= 3) {
+      conditions = getConditionsFor3Or4LengthItem(
+        target,
+        values,
+        quotedAs,
+        args as ItemOf3Or4Length,
+      );
+    }
+
+    return { target, conditions };
+  }
+
+  const joinTarget = first;
+  const joinQuery = joinTarget.query;
+
+  const quotedFrom =
+    typeof joinQuery?.from === 'string' ? q(joinQuery.from) : undefined;
+
+  let target =
+    quotedFrom || quoteSchemaAndTable(joinQuery?.schema, joinTarget.table);
+
+  let joinAs = quotedFrom || q(joinTarget.table);
+  if (joinQuery?.as) {
+    const quoted = q(joinQuery.as);
+    if (quoted !== joinAs) {
+      joinAs = quoted;
+      target += ` AS ${quoted}`;
+    }
+  }
+
+  let conditions: string | undefined;
+
+  if (args.length === 2) {
+    const arg = args[1];
+    if (typeof arg === 'function') {
+      const joinQuery = arg(
+        new model.onQueryBuilder({ table: model.table, query }, args[0]),
+      );
+      const onConditions = whereToSql(
+        model,
+        joinQuery.query,
+        values,
+        quotedAs,
+        joinAs,
+      );
+      if (onConditions) conditions = onConditions;
+    } else {
+      conditions = getObjectOrRawConditions(arg, values, quotedAs, joinAs);
+    }
+  } else if (args.length >= 3) {
+    conditions = getConditionsFor3Or4LengthItem(
+      joinAs,
+      values,
+      quotedAs,
+      args as ItemOf3Or4Length,
+    );
+  }
+
+  if (joinQuery) {
+    const whereSql = whereToSql(model, joinQuery, values, joinAs, quotedAs);
+    if (whereSql) {
+      if (conditions) conditions += ` AND ${whereSql}`;
+      else conditions = whereSql;
+    }
+  }
+
+  return { target, conditions };
+};
+
+const getConditionsFor3Or4LengthItem = (
+  target: string,
+  values: unknown[],
+  quotedAs: string | undefined,
+  args: ItemOf3Or4Length,
+): string => {
+  const [, leftColumn, opOrRightColumn, maybeRightColumn] = args;
+
+  const op = maybeRightColumn ? opOrRightColumn : '=';
+  const rightColumn = maybeRightColumn ? maybeRightColumn : opOrRightColumn;
+
+  return `${
+    typeof leftColumn === 'string'
+      ? quoteFullColumn(leftColumn, target)
+      : getRaw(leftColumn, values)
+  } ${op} ${
+    typeof rightColumn === 'string'
+      ? quoteFullColumn(rightColumn, quotedAs)
+      : getRaw(rightColumn, values)
+  }`;
+};
+
+const getObjectOrRawConditions = (
+  data: Record<string, string | RawExpression> | RawExpression,
+  values: unknown[],
+  quotedAs: string | undefined,
+  joinAs: string | undefined,
+): string => {
+  if (isRaw(data)) {
+    return getRaw(data, values);
+  } else {
+    const pairs: string[] = [];
+    for (const key in data) {
+      const value = data[key];
+
+      pairs.push(
+        `${quoteFullColumn(key, joinAs)} = ${
+          typeof value === 'string'
+            ? quoteFullColumn(value, quotedAs)
+            : getRaw(value, values)
+        }`,
+      );
+    }
+
+    return pairs.join(', ');
+  }
+};
+
+export const pushJoinSql = (
+  sql: string[],
+  model: Query,
+  query: QueryData & {
+    join: JoinItem[];
+  },
+  values: unknown[],
+  quotedAs?: string,
+) => {
+  query.join.forEach((item) => {
+    const { target, conditions } = processJoinItem(
+      model,
+      query,
+      values,
+      item.args,
+      quotedAs,
+    );
+
+    sql.push(item.type, target);
+    if (conditions) sql.push('ON', conditions);
+  });
+};

package/src/sql/orderBy.ts

@@ -0,0 +1,41 @@
+import { OrderItem, SelectQueryData } from './types';
+import { getRaw, isRaw } from '../common';
+import { qc } from './common';
+
+export const pushOrderBySql = (
+  sql: string[],
+  values: unknown[],
+  quotedAs: string | undefined,
+  order: Exclude<SelectQueryData['order'], undefined>,
+) => {
+  sql.push(
+    `ORDER BY ${order
+      .map((item) => orderByToSql(item, values, quotedAs))
+      .join(', ')}`,
+  );
+};
+
+export const orderByToSql = (
+  order: OrderItem,
+  values: unknown[],
+  quotedAs?: string,
+) => {
+  if (typeof order === 'string') {
+    return `${qc(order, quotedAs)} ASC`;
+  }
+
+  if (isRaw(order)) {
+    return getRaw(order, values);
+  }
+
+  const sql: string[] = [];
+  for (const key in order) {
+    const value = order[key];
+    if (typeof value === 'string') {
+      sql.push(`${qc(key, quotedAs)} ${value}`);
+    } else if (value) {
+      sql.push(`${qc(key, quotedAs)} ${value.dir} NULLS ${value.nulls}`);
+    }
+  }
+  return sql.join(', ');
+};