pqb 0.0.1

package/src/sql/update.ts

@@ -0,0 +1,62 @@
+import { Query } from '../query';
+import { UpdateQueryData } from './types';
+import { addValue, q, quoteSchemaAndTable } from './common';
+import { getRaw, isRaw, RawExpression } from '../common';
+import { pushReturningSql } from './insert';
+import { pushWhereSql } from './where';
+
+export const pushUpdateSql = (
+  sql: string[],
+  values: unknown[],
+  model: Query,
+  query: UpdateQueryData,
+  quotedAs: string,
+) => {
+  const quotedTable = quoteSchemaAndTable(query.schema, model.table as string);
+  sql.push(`UPDATE ${quotedTable}`);
+
+  if (query.as && quotedTable !== quotedAs) {
+    sql.push(`AS ${quotedAs}`);
+  }
+
+  sql.push('SET');
+
+  query.data.forEach((item) => {
+    if (isRaw(item)) {
+      sql.push(getRaw(item, values));
+    } else {
+      const set: string[] = [];
+
+      for (const key in item) {
+        const value = item[key];
+        if (value !== undefined) {
+          set.push(`${q(key)} = ${processValue(values, key, value)}`);
+        }
+      }
+
+      sql.push(set.join(', '));
+    }
+  });
+
+  pushWhereSql(sql, model, query, values, quotedAs);
+  pushReturningSql(sql, model, query, values, quotedAs);
+};
+
+const processValue = (
+  values: unknown[],
+  key: string,
+  value: Exclude<UpdateQueryData['data'][number], RawExpression>[string],
+) => {
+  if (value && typeof value === 'object') {
+    if (isRaw(value)) {
+      return getRaw(value, values);
+    } else if ('op' in value && 'arg' in value) {
+      return `${q(key)} ${(value as { op: string }).op} ${addValue(
+        values,
+        (value as { arg: unknown }).arg,
+      )}`;
+    }
+  }
+
+  return addValue(values, value);
+};

package/src/sql/where.ts

@@ -0,0 +1,314 @@
+import { Query } from '../query';
+import {
+  JoinItem,
+  QueryData,
+  WhereInItem,
+  WhereItem,
+  WhereJsonPathEqualsItem,
+  WhereOnItem,
+} from './types';
+import { addValue, q, qc, quoteFullColumn } from './common';
+import { EMPTY_OBJECT, getRaw, isRaw, RawExpression } from '../common';
+import { getQueryAs, MaybeArray, toArray } from '../utils';
+import { processJoinItem } from './join';
+
+export const pushWhereSql = (
+  sql: string[],
+  model: Pick<
+    Query,
+    'whereQueryBuilder' | 'onQueryBuilder' | 'as' | 'shape' | 'relations'
+  >,
+  query: Pick<QueryData, 'as' | 'and' | 'or'>,
+  values: unknown[],
+  quotedAs?: string,
+  otherTableQuotedAs?: string,
+) => {
+  const whereConditions = whereToSql(
+    model,
+    query,
+    values,
+    quotedAs,
+    otherTableQuotedAs,
+  );
+  if (whereConditions) {
+    sql.push('WHERE', whereConditions);
+  }
+};
+
+export const whereToSql = (
+  model: Pick<
+    Query,
+    'whereQueryBuilder' | 'onQueryBuilder' | 'table' | 'shape' | 'relations'
+  >,
+  query: Pick<QueryData, 'as' | 'and' | 'or'>,
+  values: unknown[],
+  quotedAs?: string,
+  otherTableQuotedAs?: string,
+  not?: boolean,
+): string => {
+  const or =
+    query.and && query.or
+      ? [query.and, ...query.or]
+      : query.and
+      ? [query.and]
+      : query.or;
+  if (!or?.length) return '';
+
+  const ors: string[] = [];
+  or.forEach((and) => {
+    const ands: string[] = [];
+    and.forEach((data) => {
+      const prefix = not ? 'NOT ' : '';
+
+      if (typeof data === 'function') {
+        const qb = data(new model.whereQueryBuilder(model.table, query.as));
+
+        const sql = whereToSql(
+          model,
+          {
+            as: query.as,
+            and: qb.query.and,
+            or: qb.query.or,
+          },
+          values,
+          quotedAs,
+          otherTableQuotedAs,
+          not,
+        );
+        if (sql) ands.push(sql);
+        return;
+      }
+
+      if ('prototype' in data || '__model' in data) {
+        const query = data as Query;
+        const sql = whereToSql(
+          query,
+          query.query || EMPTY_OBJECT,
+          values,
+          query.table && q(query.table),
+        );
+        if (sql) {
+          ands.push(`${prefix}(${sql})`);
+        }
+        return;
+      }
+
+      if (isRaw(data)) {
+        ands.push(`${prefix}(${getRaw(data, values)})`);
+        return;
+      }
+
+      for (const key in data) {
+        const value = (data as Record<string, unknown>)[key];
+        const handler = whereHandlers[key];
+        if (handler) {
+          handler(
+            value,
+            ands,
+            prefix,
+            model,
+            query,
+            values,
+            quotedAs,
+            otherTableQuotedAs,
+            not,
+          );
+        } else if (
+          typeof value === 'object' &&
+          value !== null &&
+          value !== undefined
+        ) {
+          if (isRaw(value)) {
+            ands.push(
+              `${prefix}${quoteFullColumn(key, quotedAs)} = ${getRaw(
+                value,
+                values,
+              )}`,
+            );
+          } else {
+            const column = model.shape[key];
+            if (!column) {
+              // TODO: custom error classes
+              throw new Error(`Unknown column ${key} provided to condition`);
+            }
+
+            for (const op in value) {
+              const operator = column.operators[op];
+              if (!operator) {
+                // TODO: custom error classes
+                throw new Error(`Unknown operator ${op} provided to condition`);
+              }
+
+              ands.push(
+                `${prefix}${operator(
+                  qc(key, quotedAs),
+                  value[op as keyof typeof value],
+                  values,
+                )}`,
+              );
+            }
+          }
+        } else {
+          ands.push(
+            `${prefix}${quoteFullColumn(key, quotedAs)} ${
+              value === null ? 'IS NULL' : `= ${addValue(values, value)}`
+            }`,
+          );
+        }
+      }
+    });
+
+    ors.push(ands.join(' AND '));
+  });
+
+  return ors.join(' OR ');
+};
+
+const whereHandlers: Record<
+  string,
+  | ((
+      value: unknown,
+      ands: string[],
+      prefix: string,
+      ...params: Parameters<typeof whereToSql>
+    ) => void)
+  | undefined
+> = {
+  AND(value, ands, _, model, _q, values, quotedAs, otherTableQuotedAs, not) {
+    const sql = whereToSql(
+      model,
+      {
+        and: toArray(value as MaybeArray<WhereItem>),
+      },
+      values,
+      quotedAs,
+      otherTableQuotedAs,
+      not,
+    );
+    if (sql) ands.push(sql);
+  },
+  OR(value, ands, _, model, _q, values, quotedAs, otherTableQuotedAs, not) {
+    const sql = whereToSql(
+      model,
+      {
+        or: (value as MaybeArray<WhereItem>[]).map(toArray),
+      },
+      values,
+      quotedAs,
+      otherTableQuotedAs,
+      not,
+    );
+    if (sql) ands.push(sql);
+  },
+  NOT(value, ands, _, model, _q, values, quotedAs, otherTableQuotedAs, not) {
+    const sql = whereToSql(
+      model,
+      {
+        and: toArray(value as MaybeArray<WhereItem>),
+      },
+      values,
+      quotedAs,
+      otherTableQuotedAs,
+      !not,
+    );
+    if (sql) ands.push(sql);
+  },
+  ON(value, ands, prefix, _, _q, values, quotedAs, otherTableQuotedAs) {
+    if (Array.isArray(value)) {
+      const item = value as WhereJsonPathEqualsItem;
+      const leftColumn = quoteFullColumn(item[0], quotedAs);
+      const leftPath = item[1];
+      const rightColumn = quoteFullColumn(item[2], otherTableQuotedAs);
+      const rightPath = item[3];
+
+      ands.push(
+        `${prefix}jsonb_path_query_first(${leftColumn}, ${addValue(
+          values,
+          leftPath,
+        )}) = jsonb_path_query_first(${rightColumn}, ${addValue(
+          values,
+          rightPath,
+        )})`,
+      );
+    } else {
+      const item = value as WhereOnItem;
+      const leftColumn = quoteFullColumn(
+        item.on[0],
+        typeof item.joinTo === 'string'
+          ? q(item.joinTo)
+          : q(getQueryAs(item.joinTo)),
+      );
+
+      const joinTo =
+        typeof item.joinFrom === 'string'
+          ? item.joinFrom
+          : q(getQueryAs(item.joinFrom));
+
+      const [op, rightColumn] =
+        item.on.length === 2
+          ? ['=', quoteFullColumn(item.on[1], joinTo)]
+          : [item.on[1], quoteFullColumn(item.on[2], joinTo)];
+
+      ands.push(`${prefix}${leftColumn} ${op} ${rightColumn}`);
+    }
+  },
+  IN(value, ands, prefix, _, _q, values, quotedAs) {
+    toArray(value as MaybeArray<WhereInItem>).forEach((item) => {
+      pushIn(ands, prefix, quotedAs, values, item);
+    });
+  },
+  EXISTS(value, ands, prefix, model, query, values, quotedAs) {
+    const joinItems = Array.isArray((value as unknown[])[0]) ? value : [value];
+    (joinItems as JoinItem['args'][]).forEach((item) => {
+      const { target, conditions } = processJoinItem(
+        model,
+        query,
+        values,
+        item,
+        quotedAs,
+      );
+
+      ands.push(
+        `${prefix}EXISTS (SELECT 1 FROM ${target} WHERE ${conditions} LIMIT 1)`,
+      );
+    });
+  },
+};
+
+const pushIn = (
+  ands: string[],
+  prefix: string,
+  quotedAs: string | undefined,
+  values: unknown[],
+  arg: {
+    columns: string[];
+    values: unknown[][] | Query | RawExpression;
+  },
+) => {
+  let value: string;
+
+  if (Array.isArray(arg.values)) {
+    value = `${arg.values
+      .map(
+        (arr) => `(${arr.map((value) => addValue(values, value)).join(', ')})`,
+      )
+      .join(', ')}`;
+
+    if (arg.columns.length > 1) value = `(${value})`;
+  } else if (isRaw(arg.values)) {
+    value = getRaw(arg.values, values);
+  } else {
+    const sql = arg.values.toSql(values);
+    value = `(${sql.text})`;
+  }
+
+  const columnsSql = arg.columns
+    .map((column) => quoteFullColumn(column, quotedAs))
+    .join(', ');
+
+  ands.push(
+    `${prefix}${
+      arg.columns.length > 1 ? `(${columnsSql})` : columnsSql
+    } IN ${value}`,
+  );
+};

package/src/sql/window.ts

@@ -0,0 +1,38 @@
+import { Query } from '../query';
+import { WindowDeclaration } from './types';
+import { getRaw, isRaw, RawExpression } from '../common';
+import { expressionToSql, q } from './common';
+import { orderByToSql } from './orderBy';
+
+export const windowToSql = <T extends Query>(
+  window: T['windows'][number] | WindowDeclaration | RawExpression,
+  values: unknown[],
+  quotedAs?: string,
+) => {
+  if (typeof window === 'object') {
+    if (isRaw(window)) {
+      return `(${getRaw(window, values)})`;
+    } else {
+      const sql: string[] = [];
+      if (window.partitionBy) {
+        sql.push(
+          `PARTITION BY ${
+            Array.isArray(window.partitionBy)
+              ? window.partitionBy
+                  .map((partitionBy) =>
+                    expressionToSql(partitionBy, values, quotedAs),
+                  )
+                  .join(', ')
+              : expressionToSql(window.partitionBy, values, quotedAs)
+          }`,
+        );
+      }
+      if (window.order) {
+        sql.push(`ORDER BY ${orderByToSql(window.order, values, quotedAs)}`);
+      }
+      return `(${sql.join(' ')})`;
+    }
+  } else {
+    return q(window as string);
+  }
+};

package/src/sql/with.ts

@@ -0,0 +1,32 @@
+import { QueryData } from './types';
+import { q } from './common';
+import { isRaw, getRaw } from '../common';
+
+export const pushWithSql = (
+  sql: string[],
+  values: unknown[],
+  withData: Exclude<QueryData['with'], undefined>,
+) => {
+  withData.forEach((withItem) => {
+    const [name, options, query] = withItem;
+
+    let inner: string;
+    if (isRaw(query)) {
+      inner = getRaw(query, values);
+    } else {
+      inner = query.toSql(values).text;
+    }
+
+    sql.push(
+      `WITH ${options.recursive ? 'RECURSIVE ' : ''}${q(name)}${
+        options.columns ? `(${options.columns.map(q).join(', ')})` : ''
+      } AS ${
+        options.materialized
+          ? 'MATERIALIZED '
+          : options.notMaterialized
+          ? 'NOT MATERIALIZED '
+          : ''
+      }(${inner})`,
+    );
+  });
+};

package/src/test-utils.ts

@@ -0,0 +1,172 @@
+import { Query } from './query';
+import { createDb } from './db';
+import {
+  patchPgForTransactions,
+  rollbackTransaction,
+  startTransaction,
+  unpatchPgForTransactions,
+} from 'pg-transactional-tests';
+import { Client } from 'pg';
+import { quote } from './quote';
+import { columnTypes } from './columnSchema';
+import { MaybeArray, toArray } from './utils';
+import { Adapter } from './adapter';
+
+export const dbOptions = { connectionString: process.env.DATABASE_URL };
+
+export const dbClient = new Client(dbOptions);
+
+export const adapter = new Adapter(dbOptions);
+
+export const db = createDb({
+  adapter,
+  columnTypes: {
+    ...columnTypes,
+    timestamp() {
+      return columnTypes.timestamp().parse((input) => new Date(input));
+    },
+  },
+});
+
+export const User = db('user', (t) => ({
+  id: t.serial().primaryKey(),
+  name: t.text(),
+  password: t.text(),
+  picture: t.text().nullable(),
+  data: t
+    .json((j) =>
+      j.object({
+        name: j.string(),
+        tags: j.string().array(),
+      }),
+    )
+    .nullable(),
+  age: t.integer().nullable(),
+  active: t.boolean().nullable(),
+  createdAt: t.timestamp(),
+  updatedAt: t.timestamp(),
+}));
+
+export const Profile = db('profile', (t) => ({
+  id: t.serial().primaryKey(),
+  userId: t.integer(),
+  bio: t.text().nullable(),
+  createdAt: t.timestamp(),
+  updatedAt: t.timestamp(),
+}));
+
+export const Chat = db('chat', (t) => ({
+  id: t.serial().primaryKey(),
+  title: t.text(),
+  createdAt: t.timestamp(),
+  updatedAt: t.timestamp(),
+}));
+
+export const Message = db('message', (t) => ({
+  id: t.serial().primaryKey(),
+  chatId: t.integer(),
+  authorId: t.integer(),
+  text: t.text(),
+  createdAt: t.timestamp(),
+  updatedAt: t.timestamp(),
+}));
+
+export const line = (s: string) =>
+  s.trim().replace(/\s+/g, ' ').replace(/\( /g, '(').replace(/ \)/g, ')');
+
+export const expectSql = (
+  sql: MaybeArray<{ text: string; values: unknown[] }>,
+  text: string,
+  values: unknown[] = [],
+) => {
+  toArray(sql).forEach((item) => {
+    expect(item.text).toBe(line(text));
+    expect(item.values).toEqual(values);
+  });
+};
+
+export const expectQueryNotMutated = (q: Query) => {
+  expectSql(q.toSql(), `SELECT * FROM "${q.table}"`);
+};
+
+export const expectMatchObjectWithTimestamps = (
+  actual: { createdAt: Date; updatedAt: Date },
+  expected: { createdAt: Date; updatedAt: Date },
+) => {
+  expect({
+    ...actual,
+    createdAt: actual.createdAt.toISOString(),
+    updatedAt: actual.updatedAt.toISOString(),
+  }).toMatchObject({
+    ...expected,
+    createdAt: expected.createdAt.toISOString(),
+    updatedAt: expected.updatedAt.toISOString(),
+  });
+};
+
+export type AssertEqual<T, Expected> = [T] extends [Expected]
+  ? [Expected] extends [T]
+    ? true
+    : false
+  : false;
+
+export const insert = async <
+  T extends Record<string, unknown> & { id: number },
+>(
+  table: string,
+  record: T,
+): Promise<T> => {
+  const columns = Object.keys(record);
+  const result = await dbClient.query<{ id: number }>(
+    `INSERT INTO "${table}"(${columns
+      .map((column) => `"${column}"`)
+      .join(', ')}) VALUES (${columns
+      .map((column) => quote(record[column]))
+      .join(', ')}) RETURNING "id"`,
+  );
+
+  record.id = result.rows[0].id;
+  return record;
+};
+
+export const now = new Date();
+export const userData = {
+  name: 'name',
+  password: 'password',
+  createdAt: now,
+  updatedAt: now,
+};
+
+export const profileData = {
+  bio: 'text',
+  createdAt: now,
+  updatedAt: now,
+};
+
+export const chatData = {
+  title: 'title',
+  createdAt: now,
+  updatedAt: now,
+};
+
+export const messageData = {
+  text: 'text',
+  createdAt: now,
+  updatedAt: now,
+};
+
+export const useTestDatabase = () => {
+  beforeAll(() => {
+    patchPgForTransactions();
+  });
+  beforeEach(async () => {
+    await startTransaction(dbClient);
+  });
+  afterEach(async () => {
+    await rollbackTransaction(dbClient);
+  });
+  afterAll(async () => {
+    unpatchPgForTransactions();
+    await dbClient.end();
+  });
+};