pqb 0.0.1

package/src/sql/select.ts

@@ -0,0 +1,153 @@
+import { JsonItem, SelectFunctionItem, SelectQueryData } from './types';
+import { Expression, getRaw, isRaw } from '../common';
+import { Query } from '../query';
+import { addValue, q, quoteFullColumn } from './common';
+import { aggregateToSql } from './aggregate';
+import { getQueryAs } from '../utils';
+import { RelationQuery, relationQueryKey } from '../relations';
+
+const jsonColumnOrMethodToSql = (
+  column: string | JsonItem,
+  values: unknown[],
+  quotedAs?: string,
+) => {
+  return typeof column === 'string'
+    ? quoteFullColumn(column, quotedAs)
+    : jsonToSql(column, values, quotedAs);
+};
+
+const jsonToSql = (
+  item: JsonItem,
+  values: unknown[],
+  quotedAs?: string,
+): string => {
+  const json = item.__json;
+  if (json[0] === 'pathQuery') {
+    const [, , , column, path, options] = json;
+    return `jsonb_path_query(${jsonColumnOrMethodToSql(
+      column,
+      values,
+      quotedAs,
+    )}, ${addValue(values, path)}${
+      options?.vars ? `, ${addValue(values, options.vars)}` : ''
+    }${options?.silent ? ', true' : ''})`;
+  } else if (json[0] === 'set') {
+    const [, , , column, path, value, options] = json;
+    return `jsonb_set(${jsonColumnOrMethodToSql(
+      column,
+      values,
+      quotedAs,
+    )}, '{${path.join(', ')}}', ${addValue(values, JSON.stringify(value))}${
+      options?.createIfMissing ? ', true' : ''
+    })`;
+  } else if (json[0] === 'insert') {
+    const [, , , column, path, value, options] = json;
+    return `jsonb_insert(${jsonColumnOrMethodToSql(
+      column,
+      values,
+      quotedAs,
+    )}, '{${path.join(', ')}}', ${addValue(values, JSON.stringify(value))}${
+      options?.insertAfter ? ', true' : ''
+    })`;
+  } else if (json[0] === 'remove') {
+    const [, , , column, path] = json;
+    return `${jsonColumnOrMethodToSql(
+      column,
+      values,
+      quotedAs,
+    )} #- '{${path.join(', ')}}'`;
+  }
+  return '';
+};
+
+export const pushSelectSql = (
+  sql: string[],
+  model: Pick<
+    Query,
+    'whereQueryBuilder' | 'onQueryBuilder' | 'as' | 'shape' | 'relations'
+  >,
+  query: Pick<SelectQueryData, 'select' | 'join'>,
+  values: unknown[],
+  quotedAs?: string,
+) => {
+  sql.push(selectToSql(model, query, values, quotedAs));
+};
+
+export const selectToSql = (
+  model: Pick<
+    Query,
+    'whereQueryBuilder' | 'onQueryBuilder' | 'as' | 'shape' | 'relations'
+  >,
+  query: Pick<SelectQueryData, 'select' | 'join'>,
+  values: unknown[],
+  quotedAs?: string,
+): string => {
+  if (query.select) {
+    const list: string[] = [];
+    query.select.forEach((item) => {
+      if (typeof item === 'string') {
+        list.push(
+          item === '*'
+            ? query.join?.length
+              ? `${quotedAs}.*`
+              : '*'
+            : quoteFullColumn(item, quotedAs),
+        );
+      } else if ((item as Query).query?.[relationQueryKey]) {
+        let relationQuery = (item as RelationQuery).clone();
+        const as = q(getQueryAs(relationQuery));
+        relationQuery._as(relationQuery.query[relationQueryKey] as string);
+
+        const { returnType } = relationQuery.query;
+        if (
+          returnType === 'all' ||
+          returnType === 'one' ||
+          returnType === 'oneOrThrow'
+        ) {
+          relationQuery = relationQuery._json() as unknown as RelationQuery;
+        }
+
+        list.push(`(${relationQuery.toSql(values).text}) AS ${as}`);
+      } else {
+        if ('selectAs' in item) {
+          const obj = item.selectAs as Record<string, Expression | Query>;
+          for (const as in obj) {
+            const value = obj[as];
+            if (typeof value === 'object') {
+              if (isRaw(value)) {
+                list.push(`${getRaw(value, values)} AS ${q(as)}`);
+              } else {
+                const sql = (value as Query).json().toSql(values);
+                list.push(`(${sql.text}) AS ${q(as)}`);
+              }
+            } else {
+              list.push(
+                `${quoteFullColumn(value as string, quotedAs)} AS ${q(as)}`,
+              );
+            }
+          }
+        } else if ('__json' in item) {
+          list.push(
+            `${jsonToSql(item, values, quotedAs)} AS ${q(item.__json[1])}`,
+          );
+        } else if (isRaw(item)) {
+          list.push(getRaw(item, values));
+        } else if ('arguments' in item) {
+          list.push(
+            `${(item as SelectFunctionItem).function}(${selectToSql(
+              model,
+              { select: item.arguments },
+              values,
+              quotedAs,
+            )})${item.as ? ` AS ${q((item as { as: string }).as)}` : ''}`,
+          );
+        } else {
+          list.push(aggregateToSql(model, values, item, quotedAs));
+        }
+      }
+    });
+    return list.join(', ');
+  } else {
+    return query.join?.length ? `${quotedAs}.*` : '*';
+  }
+};

package/src/sql/toSql.ts

@@ -0,0 +1,153 @@
+import { getRaw, isRaw } from '../common';
+import { Query } from '../query';
+import { addValue, q, qc } from './common';
+import { JoinItem, QueryData, Sql } from './types';
+import { pushDistinctSql } from './distinct';
+import { pushSelectSql } from './select';
+import { windowToSql } from './window';
+import { pushJoinSql } from './join';
+import { pushWhereSql } from './where';
+import { pushHavingSql } from './having';
+import { pushWithSql } from './with';
+import { pushFromAndAs } from './fromAndAs';
+import { pushInsertSql } from './insert';
+import { pushUpdateSql } from './update';
+import { pushDeleteSql } from './delete';
+import { pushTruncateSql } from './truncate';
+import { pushColumnInfoSql } from './columnInfo';
+import { pushOrderBySql } from './orderBy';
+
+export const toSql = (model: Query, values: unknown[] = []): Sql => {
+  const query = model.query;
+  const sql: string[] = [];
+
+  if (query.with) {
+    pushWithSql(sql, values, query.with);
+  }
+
+  if (query.type) {
+    if (query.type === 'truncate') {
+      if (!model.table) throw new Error('Table is missing for truncate');
+
+      pushTruncateSql(sql, model.table, query);
+      return { text: sql.join(' '), values };
+    }
+
+    if (query.type === 'columnInfo') {
+      if (!model.table) throw new Error('Table is missing for truncate');
+
+      pushColumnInfoSql(sql, values, model.table, query);
+      return { text: sql.join(' '), values };
+    }
+
+    if (!model.table) throw new Error(`Table is missing for ${query.type}`);
+
+    const quotedAs = q(query.as || model.table);
+
+    if (query.type === 'insert') {
+      pushInsertSql(sql, values, model, query, q(model.table));
+      return { text: sql.join(' '), values };
+    }
+
+    if (query.type === 'update') {
+      pushUpdateSql(sql, values, model, query, quotedAs);
+      return { text: sql.join(' '), values };
+    }
+
+    if (query.type === 'delete') {
+      pushDeleteSql(sql, values, model, query, q(model.table));
+      return { text: sql.join(' '), values };
+    }
+  }
+
+  const quotedAs = model.table && q(query.as || model.table);
+
+  sql.push('SELECT');
+
+  if (query.distinct) {
+    pushDistinctSql(sql, values, query.distinct, quotedAs);
+  }
+
+  pushSelectSql(sql, model, query, values, quotedAs);
+
+  if (model.table || query.from) {
+    pushFromAndAs(sql, model, query, values, quotedAs);
+  }
+
+  if (query.join) {
+    pushJoinSql(
+      sql,
+      model,
+      query as QueryData & { join: JoinItem[] },
+      values,
+      quotedAs,
+    );
+  }
+
+  if (query.and || query.or) {
+    pushWhereSql(sql, model, query, values, quotedAs);
+  }
+
+  if (query.group) {
+    const group = query.group.map((item) =>
+      typeof item === 'object' && isRaw(item)
+        ? getRaw(item, values)
+        : qc(item as string, quotedAs),
+    );
+    sql.push(`GROUP BY ${group.join(', ')}`);
+  }
+
+  if (query.having || query.havingOr) {
+    pushHavingSql(sql, model, query, values, quotedAs);
+  }
+
+  if (query.window) {
+    const window: string[] = [];
+    query.window.forEach((item) => {
+      for (const key in item) {
+        window.push(`${q(key)} AS ${windowToSql(item[key], values, quotedAs)}`);
+      }
+    });
+    sql.push(`WINDOW ${window.join(', ')}`);
+  }
+
+  if (query.union) {
+    query.union.forEach((item) => {
+      let itemSql: string;
+      if (isRaw(item.arg)) {
+        itemSql = getRaw(item.arg, values);
+      } else {
+        const argSql = item.arg.toSql(values);
+        itemSql = argSql.text;
+      }
+      sql.push(`${item.kind} ${item.wrap ? `(${itemSql})` : itemSql}`);
+    });
+  }
+
+  if (query.order) {
+    pushOrderBySql(sql, values, quotedAs, query.order);
+  }
+
+  if (query.take || query.limit !== undefined) {
+    sql.push(`LIMIT ${addValue(values, query.take ? 1 : query.limit)}`);
+  }
+
+  if (query.offset) {
+    sql.push(`OFFSET ${addValue(values, query.offset)}`);
+  }
+
+  if (query.for) {
+    sql.push('FOR', query.for.type);
+    const { tableNames } = query.for;
+    if (tableNames) {
+      if (isRaw(tableNames)) {
+        sql.push('OF', getRaw(tableNames, values));
+      } else {
+        sql.push('OF', tableNames.map(q).join(', '));
+      }
+    }
+    if (query.for.mode) sql.push(query.for.mode);
+  }
+
+  return { text: sql.join(' '), values };
+};

package/src/sql/truncate.ts

@@ -0,0 +1,13 @@
+import { TruncateQueryData } from './types';
+import { quoteSchemaAndTable } from './common';
+
+export const pushTruncateSql = (
+  sql: string[],
+  table: string,
+  query: TruncateQueryData,
+) => {
+  sql.push('TRUNCATE', quoteSchemaAndTable(query.schema, table));
+
+  if (query.restartIdentity) sql.push('RESTART IDENTITY');
+  if (query.cascade) sql.push('CASCADE');
+};

package/src/sql/types.ts

@@ -0,0 +1,355 @@
+import {
+  ColumnsParsers,
+  Query,
+  QueryBase,
+  QueryReturnType,
+  QueryWithTable,
+  SelectableBase,
+} from '../query';
+import { Expression, RawExpression } from '../common';
+import { ColumnsShape, ColumnType } from '../columnSchema';
+import { RelationQuery, relationQueryKey } from '../relations';
+import { Adapter, QueryResult } from '../adapter';
+import { MaybeArray } from '../utils';
+import { QueryLogger, QueryLogObject } from '../queryMethods/log';
+import { AfterCallback, BeforeCallback } from '../queryMethods/callbacks';
+
+export type Sql = {
+  text: string;
+  values: unknown[];
+};
+
+// used in `from` logic to decide if convert query to sql or just write table name
+export const queryKeysOfNotSimpleQuery: (keyof SelectQueryData)[] = [
+  'take',
+  'with',
+  'as',
+  'from',
+  'and',
+  'or',
+  'select',
+  'distinct',
+  'fromOnly',
+  'join',
+  'group',
+  'having',
+  'havingOr',
+  'window',
+  'union',
+  'order',
+  'limit',
+  'offset',
+  'for',
+];
+
+export type CommonQueryData = {
+  adapter: Adapter;
+  handleResult(q: Query, result: QueryResult): Promise<unknown>;
+  returnType: QueryReturnType;
+  [relationQueryKey]?: string;
+  inTransaction?: boolean;
+  wrapInTransaction?: boolean;
+  throwOnNotFound?: boolean;
+  take?: boolean;
+  with?: WithItem[];
+  withShapes?: Record<string, ColumnsShape>;
+  schema?: string;
+  select?: SelectItem[];
+  as?: string;
+  from?: string | Query | RawExpression;
+  and?: WhereItem[];
+  or?: WhereItem[][];
+  parsers?: ColumnsParsers;
+  defaults?: Record<string, unknown>;
+  beforeQuery?: BeforeCallback<Query>[];
+  afterQuery?: AfterCallback<Query>[];
+  log?: QueryLogObject;
+  logger: QueryLogger;
+};
+
+export type SelectQueryData = CommonQueryData & {
+  type: undefined;
+  distinct?: Expression[];
+  fromOnly?: boolean;
+  join?: JoinItem[];
+  joinedParsers?: Record<string, ColumnsParsers>;
+  group?: (string | RawExpression)[];
+  having?: HavingItem[];
+  havingOr?: HavingItem[][];
+  window?: WindowItem[];
+  union?: { arg: UnionItem; kind: UnionKind; wrap?: boolean }[];
+  order?: OrderItem[];
+  limit?: number;
+  offset?: number;
+  for?: {
+    type: 'UPDATE' | 'NO KEY UPDATE' | 'SHARE' | 'KEY SHARE';
+    tableNames?: string[] | RawExpression;
+    mode?: 'NO WAIT' | 'SKIP LOCKED';
+  };
+};
+
+export type InsertQueryData = CommonQueryData & {
+  type: 'insert';
+  columns: string[];
+  values: unknown[][] | RawExpression;
+  using?: JoinItem[];
+  join?: JoinItem[];
+  joinedParsers?: Record<string, ColumnsParsers>;
+  onConflict?:
+    | {
+        type: 'ignore';
+        expr?: OnConflictItem;
+      }
+    | {
+        type: 'merge';
+        expr?: OnConflictItem;
+        update?: OnConflictMergeUpdate;
+      };
+  beforeInsert?: BeforeCallback<Query>[];
+  afterInsert?: AfterCallback<Query>[];
+};
+
+export type UpdateQueryData = CommonQueryData & {
+  type: 'update';
+  data: (
+    | Record<string, RawExpression | { op: string; arg: unknown } | unknown>
+    | RawExpression
+  )[];
+  beforeUpdate?: BeforeCallback<Query>[];
+  afterUpdate?: AfterCallback<Query>[];
+};
+
+export type DeleteQueryData = CommonQueryData & {
+  type: 'delete';
+  join?: JoinItem[];
+  joinedParsers?: Record<string, ColumnsParsers>;
+};
+
+export type TruncateQueryData = CommonQueryData & {
+  type: 'truncate';
+  restartIdentity?: boolean;
+  cascade?: boolean;
+};
+
+export type ColumnInfoQueryData = CommonQueryData & {
+  type: 'columnInfo';
+  column?: string;
+};
+
+export type QueryData =
+  | SelectQueryData
+  | InsertQueryData
+  | UpdateQueryData
+  | DeleteQueryData
+  | TruncateQueryData
+  | ColumnInfoQueryData;
+
+export type WithItem = [
+  as: string,
+  options: WithOptions,
+  query: Query | RawExpression,
+];
+
+export type WithOptions = {
+  columns?: string[];
+  recursive?: true;
+  materialized?: true;
+  notMaterialized?: true;
+};
+
+export type JsonItem<
+  As extends string = string,
+  Type extends ColumnType = ColumnType,
+> = {
+  __json:
+    | [
+        kind: 'set',
+        as: As,
+        type: Type,
+        column: string | JsonItem,
+        path: Array<string | number>,
+        value: unknown,
+        options?: {
+          createIfMissing?: boolean;
+        },
+      ]
+    | [
+        kind: 'insert',
+        as: As,
+        type: Type,
+        column: string | JsonItem,
+        path: Array<string | number>,
+        value: unknown,
+        options?: {
+          insertAfter?: boolean;
+        },
+      ]
+    | [
+        kind: 'remove',
+        as: As,
+        type: Type,
+        column: string | JsonItem,
+        path: Array<string | number>,
+      ]
+    | [
+        kind: 'pathQuery',
+        as: As,
+        type: Type,
+        column: string | JsonItem,
+        path: string,
+        options?: {
+          vars?: string;
+          silent?: boolean;
+        },
+      ];
+};
+
+export type SelectItem =
+  | string
+  | RelationQuery
+  | AggregateItem
+  | { selectAs: Record<string, string | Query | RawExpression> }
+  | SelectFunctionItem
+  | JsonItem
+  | RawExpression;
+
+export type SelectFunctionItem = {
+  function: string;
+  arguments: SelectItem[];
+  as?: string;
+};
+
+export type JoinItem = {
+  type: string;
+  args:
+    | [relation: string]
+    | [
+        arg: string | QueryWithTable,
+        conditions:
+          | Record<string, string | RawExpression>
+          | RawExpression
+          | ((q: unknown) => QueryBase),
+      ]
+    | [
+        arg: string | QueryWithTable,
+        leftColumn: string | RawExpression,
+        rightColumn: string | RawExpression,
+      ]
+    | [
+        arg: string | QueryWithTable,
+        leftColumn: string | RawExpression,
+        op: string,
+        rightColumn: string | RawExpression,
+      ];
+};
+
+export type WhereItem =
+  | (Omit<
+      Record<
+        string,
+        | unknown
+        | Record<string, unknown | Query | RawExpression>
+        | RawExpression
+      >,
+      'NOT' | 'AND' | 'OR' | 'IN' | 'EXISTS' | 'ON' | 'ON_JSON_PATH_EQUALS'
+    > & {
+      NOT?: MaybeArray<WhereItem>;
+      AND?: MaybeArray<WhereItem>;
+      OR?: MaybeArray<WhereItem>[];
+      IN?: MaybeArray<WhereInItem>;
+      EXISTS?: MaybeArray<JoinItem['args']>;
+      ON?: WhereOnItem | WhereJsonPathEqualsItem;
+    })
+  | ((q: unknown) => QueryBase)
+  | Query
+  | RawExpression;
+
+export type WhereInItem = {
+  columns: string[];
+  values: unknown[][] | Query | RawExpression;
+};
+
+export type WhereJsonPathEqualsItem = [
+  leftColumn: string,
+  leftPath: string,
+  rightColumn: string,
+  rightPath: string,
+];
+
+export type WhereOnItem = {
+  joinFrom: { table?: string; query: { as?: string } } | string;
+  joinTo: { table?: string; query: { as?: string } } | string;
+  on:
+    | [leftFullColumn: string, rightFullColumn: string]
+    | [leftFullColumn: string, op: string, rightFullColumn: string];
+};
+
+export type AggregateItemOptions = {
+  as?: string;
+  distinct?: boolean;
+  order?: OrderItem[];
+  filter?: WhereItem;
+  filterOr?: WhereItem[];
+  withinGroup?: boolean;
+  over?: string;
+  window?: WindowItem;
+};
+
+export type SortDir = 'ASC' | 'DESC';
+
+export type OrderItem =
+  | string
+  | Record<string, SortDir | { dir: SortDir; nulls: 'FIRST' | 'LAST' }>
+  | RawExpression;
+
+export type AggregateItemArg =
+  | Expression
+  | Record<string, Expression>
+  | [Expression, string];
+
+export type AggregateItem = {
+  function: string;
+  arg?: AggregateItemArg;
+  options: AggregateItemOptions;
+};
+
+export type ColumnOperators<
+  S extends SelectableBase,
+  Column extends keyof S,
+> = {
+  [O in keyof S[Column]['column']['operators']]?:
+    | S[Column]['column']['operators'][O]['type'];
+};
+
+type HavingItemObject = Record<string, unknown>;
+
+export type HavingItem =
+  | Record<string, HavingItemObject>
+  | { count?: number | HavingItemObject }
+  | Query
+  | RawExpression;
+
+export type WindowItem = Record<string, WindowDeclaration | RawExpression>;
+
+export type WindowDeclaration = {
+  partitionBy?: Expression | Expression[];
+  order?: OrderItem;
+};
+
+export type UnionItem = Query | RawExpression;
+
+type UnionKind =
+  | 'UNION'
+  | 'UNION ALL'
+  | 'INTERSECT'
+  | 'INTERSECT ALL'
+  | 'EXCEPT'
+  | 'EXCEPT ALL';
+
+export type OnConflictItem = string | string[] | RawExpression;
+
+export type OnConflictMergeUpdate =
+  | string
+  | string[]
+  | Record<string, unknown>
+  | RawExpression;