pqb 0.0.1

package/src/common.ts

@@ -0,0 +1,86 @@
+import { Query, Selectable } from './query';
+import { ColumnOutput, ColumnType } from './columnSchema';
+
+export type AliasOrTable<T extends Pick<Query, 'tableAlias' | 'table'>> =
+  T['tableAlias'] extends string
+    ? T['tableAlias']
+    : T['table'] extends string
+    ? T['table']
+    : never;
+
+export type StringKey<K extends PropertyKey> = Exclude<K, symbol | number>;
+
+export type RawExpression<C extends ColumnType = ColumnType> = {
+  __raw: string;
+  __values: unknown[];
+  __column: C;
+};
+
+export type Expression<
+  T extends Query = Query,
+  C extends ColumnType = ColumnType,
+> = keyof T['selectable'] | RawExpression<C>;
+
+export type ExpressionOfType<T extends Query, C extends ColumnType, Type> =
+  | {
+      [K in keyof T['selectable']]: ColumnOutput<
+        T['selectable'][K]['column']
+      > extends Type | null
+        ? K
+        : never;
+    }[Selectable<T>]
+  | RawExpression<C>;
+
+export type NumberExpression<
+  T extends Query,
+  C extends ColumnType = ColumnType,
+> = ExpressionOfType<T, C, number>;
+
+export type StringExpression<
+  T extends Query,
+  C extends ColumnType = ColumnType,
+> = ExpressionOfType<T, C, string>;
+
+export type BooleanExpression<
+  T extends Query,
+  C extends ColumnType = ColumnType,
+> = ExpressionOfType<T, C, boolean>;
+
+export type ExpressionOutput<
+  T extends Query,
+  Expr extends Expression<T>,
+> = Expr extends keyof T['selectable']
+  ? T['selectable'][Expr]['column']
+  : Expr extends RawExpression<infer ColumnType>
+  ? ColumnType
+  : never;
+
+export const raw = <C extends ColumnType>(sql: string, ...values: unknown[]) =>
+  ({
+    __raw: sql,
+    __values: values,
+  } as RawExpression<C>);
+
+export const rawColumn = <C extends ColumnType>(
+  column: C,
+  sql: string,
+  ...values: unknown[]
+) =>
+  ({
+    __column: column,
+    __raw: sql,
+    __values: values,
+  } as RawExpression<C>);
+
+export const isRaw = (obj: object): obj is RawExpression => '__raw' in obj;
+
+export const getRaw = (raw: RawExpression, values: unknown[]) => {
+  values.push(...raw.__values);
+  return raw.__raw;
+};
+
+export const EMPTY_OBJECT = {};
+
+export const getQueryParsers = (q: Query) => {
+  return q.query.parsers || q.columnsParsers;
+};

package/src/db.test.ts

@@ -0,0 +1,67 @@
+import {
+  adapter,
+  AssertEqual,
+  db,
+  expectSql,
+  User,
+  userData,
+  useTestDatabase,
+} from './test-utils';
+import { createDb } from './db';
+import { columnTypes } from './columnSchema';
+
+describe('db', () => {
+  useTestDatabase();
+
+  it('supports table without schema', () => {
+    const table = db('table');
+    const query = table.select('id', 'name').where({ foo: 'bar' });
+    expectSql(
+      query.toSql(),
+      `
+        SELECT "table"."id", "table"."name" FROM "table"
+        WHERE "table"."foo" = $1
+      `,
+      ['bar'],
+    );
+  });
+
+  describe('overriding column types', () => {
+    it('should return date as string by default', async () => {
+      await User.insert(userData);
+
+      const db = createDb({ adapter });
+      const table = db('user', (t) => ({
+        createdAt: t.timestamp(),
+      }));
+
+      const result = await table.take().get('createdAt');
+      expect(typeof result).toBe('string');
+
+      const eq: AssertEqual<typeof result, string> = true;
+      expect(eq).toBe(true);
+    });
+
+    it('should return date as Date when overridden', async () => {
+      await User.insert(userData);
+
+      const db = createDb({
+        adapter,
+        columnTypes: {
+          timestamp() {
+            return columnTypes.timestamp().parse((input) => new Date(input));
+          },
+        },
+      });
+      const table = db('user', (t) => ({
+        createdAt: t.timestamp(),
+      }));
+
+      const result = await table.take().get('createdAt');
+      expect(result instanceof Date).toBe(true);
+
+      const eq: AssertEqual<typeof result, Date> = true;
+      expect(eq).toBe(true);
+    });
+  });
+});

package/src/db.ts

@@ -0,0 +1,212 @@
+import {
+  ColumnsParsers,
+  DefaultSelectColumns,
+  defaultsKey,
+  Query,
+} from './query';
+import { QueryMethods } from './queryMethods/queryMethods';
+import { QueryData, SelectQueryData, Sql } from './sql';
+import { AdapterOptions, Adapter } from './adapter';
+import {
+  ColumnsShape,
+  columnTypes,
+  ColumnShapeOutput,
+  TableSchema,
+  AnyColumnTypeCreator,
+  ColumnShapeInput,
+  ColumnTypes,
+} from './columnSchema';
+import { applyMixins } from './utils';
+import { StringKey } from './common';
+import { handleResult, ThenResult } from './queryMethods/then';
+import { WhereQueryBuilder } from './queryMethods/where';
+import { OnQueryBuilder } from './queryMethods/join';
+import { logParamToLogObject, QueryLogOptions } from './queryMethods/log';
+
+export type DbTableOptions = {
+  schema?: string;
+} & QueryLogOptions;
+
+export interface Db<
+  Table extends string | undefined = undefined,
+  Shape extends ColumnsShape = Record<string, never>,
+  Relations extends Query['relations'] = Query['relations'],
+> extends QueryMethods {
+  new (
+    adapter: Adapter,
+    queryBuilder: Db,
+    table?: Table,
+    shape?: Shape,
+    options?: DbTableOptions,
+  ): this;
+
+  adapter: Adapter;
+  queryBuilder: Db;
+  whereQueryBuilder: Query['whereQueryBuilder'];
+  table: Table;
+  shape: Shape;
+  schema: TableSchema<Shape>;
+  type: ColumnShapeOutput<Shape>;
+  inputType: ColumnShapeInput<Shape>;
+  returnType: 'all';
+  then: ThenResult<
+    Pick<ColumnShapeOutput<Shape>, DefaultSelectColumns<Shape>[number]>[]
+  >;
+  query: QueryData;
+  columns: (keyof ColumnShapeOutput<Shape>)[];
+  defaultSelectColumns: DefaultSelectColumns<Shape>;
+  columnsParsers?: ColumnsParsers;
+  result: Pick<Shape, DefaultSelectColumns<Shape>[number]>;
+  hasSelect: false;
+  hasWhere: false;
+  selectable: { [K in keyof Shape]: { as: K; column: Shape[K] } } & {
+    [K in keyof Shape as `${Table}.${StringKey<K>}`]: {
+      as: K;
+      column: Shape[K];
+    };
+  };
+  tableAlias: undefined;
+  windows: PropertyKey[];
+  withData: Query['withData'];
+  joinedTables: Query['joinedTables'];
+  relations: Relations;
+  [defaultsKey]: Query[defaultsKey];
+}
+
+export class Db<
+  Table extends string | undefined = undefined,
+  Shape extends ColumnsShape = Record<string, never>,
+  Relations extends Query['relations'] = Query['relations'],
+> implements Query
+{
+  whereQueryBuilder = WhereQueryBuilder;
+  onQueryBuilder = OnQueryBuilder;
+
+  constructor(
+    public adapter: Adapter,
+    public queryBuilder: Db,
+    public table: Table = undefined as Table,
+    public shape: Shape = {} as Shape,
+    options: DbTableOptions,
+  ) {
+    this.__model = this;
+
+    const logger = options.logger || console;
+    this.query = {
+      adapter,
+      handleResult: handleResult,
+      returnType: 'all',
+      logger,
+      log: logParamToLogObject(logger, options.log),
+    } as QueryData;
+
+    if (options?.schema) {
+      this.query.schema = options.schema;
+    }
+
+    this.schema = new TableSchema(shape);
+    const columns = Object.keys(
+      shape,
+    ) as unknown as (keyof ColumnShapeOutput<Shape>)[];
+    const { toSql } = this;
+
+    this.columns = columns as (keyof ColumnShapeOutput<Shape>)[];
+    this.defaultSelectColumns = columns.filter(
+      (column) => !shape[column as keyof typeof shape].isHidden,
+    ) as DefaultSelectColumns<Shape>;
+
+    const defaultSelect =
+      this.defaultSelectColumns.length === columns.length
+        ? undefined
+        : this.defaultSelectColumns;
+
+    const columnsParsers: ColumnsParsers = {};
+    let hasParsers = false;
+    for (const key in shape) {
+      const column = shape[key];
+      if (column.parseFn) {
+        hasParsers = true;
+        columnsParsers[key] = column.parseFn;
+      }
+    }
+    this.columnsParsers = hasParsers ? columnsParsers : undefined;
+
+    this.toSql = defaultSelect
+      ? function <T extends Query>(this: T, values?: unknown[]): Sql {
+          const q = this.clone();
+          if (!(q.query as SelectQueryData).select) {
+            (q.query as SelectQueryData).select = defaultSelect as string[];
+          }
+          return toSql.call(q, values);
+        }
+      : toSql;
+
+    this.relations = {} as Relations;
+  }
+}
+
+applyMixins(Db, [QueryMethods]);
+Db.prototype.constructor = Db;
+
+type DbResult<CT extends Record<string, AnyColumnTypeCreator>> = Db & {
+  <Table extends string, Shape extends ColumnsShape = ColumnsShape>(
+    table: Table,
+    shape?: ((t: CT) => Shape) | Shape,
+    options?: DbTableOptions,
+  ): Db<Table, Shape>;
+
+  adapter: Adapter;
+  destroy: Adapter['destroy'];
+};
+
+export type DbOptions<
+  CT extends Record<string, AnyColumnTypeCreator> = ColumnTypes,
+> = ({ adapter: Adapter } | Omit<AdapterOptions, 'log'>) &
+  QueryLogOptions & {
+    columnTypes?: CT;
+  };
+
+export const createDb = <CT extends Record<string, AnyColumnTypeCreator>>({
+  log,
+  logger,
+  columnTypes: ct = columnTypes as unknown as CT,
+  ...options
+}: DbOptions<CT>): DbResult<CT> => {
+  const adapter = 'adapter' in options ? options.adapter : new Adapter(options);
+  const commonOptions = { log, logger };
+
+  const qb = new Db(
+    adapter,
+    undefined as unknown as Db,
+    undefined,
+    {},
+    commonOptions,
+  );
+  qb.queryBuilder = qb;
+
+  const db = Object.assign(
+    <Table extends string, Shape extends ColumnsShape = ColumnsShape>(
+      table: Table,
+      shape?: ((t: CT) => Shape) | Shape,
+      options?: DbTableOptions,
+    ): Db<Table, Shape> => {
+      return new Db<Table, Shape>(
+        adapter,
+        qb,
+        table as Table,
+        typeof shape === 'function' ? shape(ct) : shape,
+        { ...commonOptions, ...options },
+      );
+    },
+    qb,
+    { adapter, destroy: () => adapter.destroy() },
+  );
+
+  // Set all methods from prototype to the db instance (needed for transaction at least):
+  Object.getOwnPropertyNames(Db.prototype).forEach((name) => {
+    (db as unknown as Record<string, unknown>)[name] =
+      Db.prototype[name as keyof typeof Db.prototype];
+  });
+
+  return db as DbResult<CT>;
+};

package/src/errors.ts

@@ -0,0 +1,7 @@
+export class NotFoundError extends Error {
+  constructor(message = 'Record is not found') {
+    super(message);
+  }
+}
+
+export class MoreThanOneRowError extends Error {}

package/src/index.ts

@@ -0,0 +1,18 @@
+export * from './columnSchema';
+export * from './sql';
+export * from './adapter';
+export * from './common';
+export * from './db';
+export * from './operators';
+export * from './query';
+export * from './queryMethods/insert';
+export * from './queryMethods/join';
+export * from './queryMethods/transaction';
+export * from './queryMethods/queryMethods';
+export * from './queryMethods/columnInfo';
+export * from './quote';
+export * from './utils';
+export * from './queryDataUtils';
+export * from './queryMethods/then';
+export * from './errors';
+export * from './relations';