pqb 0.0.1

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "pqb",
+  "version": "0.0.1",
+  "description": "Postgres query builder",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/romeerez/porm"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.esm.js",
+  "typings": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.js",
+      "import": "./dist/index.esm.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "jest": {
+    "setupFiles": [
+      "dotenv/config"
+    ],
+    "globalSetup": "../../jest-global-setup.ts",
+    "setupFilesAfterEnv": [
+      "../../jest-setup.ts"
+    ],
+    "transform": {
+      "^.+\\.ts$": "@swc/jest"
+    }
+  },
+  "keywords": [
+    "postgres",
+    "query-builder"
+  ],
+  "author": "Roman Kushyn",
+  "license": "ISC",
+  "dependencies": {},
+  "devDependencies": {
+    "rollup": "^2.79.0",
+    "rollup-plugin-dts": "^4.2.2",
+    "rollup-plugin-esbuild": "^4.10.1",
+    "@swc/core": "^1.2.210",
+    "@swc/jest": "^0.2.21",
+    "@types/jest": "^28.1.2",
+    "@types/node": "^18.0.1",
+    "@types/pg": "^8.6.5",
+    "dotenv": "^16.0.1",
+    "jest": "^28.1.2",
+    "pg": "^8.7.3",
+    "pg-transactional-tests": "^1.0.3",
+    "rimraf": "^3.0.2",
+    "tslib": "^2.4.0",
+    "typescript": "^4.7.4"
+  },
+  "scripts": {
+    "test": "jest",
+    "build": "rimraf ./dist/ && rollup -c --rollup.config"
+  }
+}

package/rollup.config.js

@@ -0,0 +1,35 @@
+import dts from 'rollup-plugin-dts';
+import esbuild from 'rollup-plugin-esbuild';
+
+export default [
+  {
+    input: 'src/index.ts',
+    plugins: [esbuild()],
+    output: [
+      {
+        file: 'dist/index.js',
+        format: 'cjs',
+        sourcemap: true,
+      },
+    ],
+  },
+  {
+    input: 'src/index.ts',
+    plugins: [esbuild()],
+    output: [
+      {
+        file: 'dist/index.esm.js',
+        format: 'es',
+        sourcemap: true,
+      },
+    ],
+  },
+  {
+    input: 'src/index.ts',
+    plugins: [dts()],
+    output: {
+      file: `dist/index.d.ts`,
+      format: 'es',
+    },
+  },
+];

package/src/adapter.test.ts

@@ -0,0 +1,10 @@
+import { adapter } from './test-utils';
+
+describe('adapter', () => {
+  it('should run query and close connection by calling .destroy()', async () => {
+    const result = await adapter.query('SELECT 1 as num');
+    expect(result.rows).toEqual([{ num: 1 }]);
+
+    await adapter.destroy();
+  });
+});

package/src/adapter.ts

@@ -0,0 +1,171 @@
+import { Pool, PoolClient, PoolConfig, types } from 'pg';
+
+export interface QueryResultRow {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [column: string]: any;
+}
+
+export type TypeParsers = Record<number, (input: string) => unknown>;
+
+type Query = string | { text: string; values?: unknown[] };
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type QueryResult<T extends QueryResultRow = any> = {
+  rowCount: number;
+  rows: T[];
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type QueryArraysResult<R extends any[] = any[]> = {
+  rowCount: number;
+  rows: R[];
+  fields: { name: string }[];
+};
+
+const defaultTypeParsers: TypeParsers = {};
+
+for (const key in types.builtins) {
+  const id = types.builtins[key as keyof typeof types.builtins];
+  defaultTypeParsers[id] = types.getTypeParser(id);
+}
+
+[
+  types.builtins.DATE,
+  types.builtins.TIMESTAMP,
+  types.builtins.TIMESTAMPTZ,
+  types.builtins.TIME,
+].forEach((id) => {
+  delete defaultTypeParsers[id];
+});
+
+const returnArg = (arg: unknown) => arg;
+
+export type AdapterOptions = Omit<PoolConfig, 'types'> & {
+  types?: TypeParsers;
+};
+
+export class Adapter {
+  types: TypeParsers;
+  pool: Pool;
+
+  constructor({ types = defaultTypeParsers, ...config }: AdapterOptions) {
+    this.types = types;
+    this.pool = new Pool(config);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async query<T extends QueryResultRow = any>(
+    query: Query,
+    types: TypeParsers = this.types,
+  ): Promise<QueryResult<T>> {
+    const client = await this.pool.connect();
+    try {
+      return await performQuery<T>(client, query, types);
+    } finally {
+      client.release();
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async arrays<R extends any[] = any[]>(
+    query: Query,
+    types: TypeParsers = this.types,
+  ): Promise<QueryArraysResult<R>> {
+    const client = await this.pool.connect();
+    try {
+      return await performQueryArrays<R>(client, query, types);
+    } finally {
+      client.release();
+    }
+  }
+
+  async transaction<Result>(
+    cb: (adapter: Adapter) => Promise<Result>,
+  ): Promise<Result> {
+    const client = await this.pool.connect();
+    try {
+      await performQuery(client, { text: 'BEGIN' }, this.types);
+      const result = await cb(
+        new TransactionAdapter(this.pool, client, this.types),
+      );
+      await performQuery(client, { text: 'COMMIT' }, this.types);
+      return result;
+    } catch (err) {
+      await performQuery(client, { text: 'ROLLBACK' }, this.types);
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+  destroy(): Promise<void> {
+    return this.pool.end();
+  }
+}
+
+const performQuery = <T extends QueryResultRow>(
+  client: PoolClient,
+  query: Query,
+  types: TypeParsers,
+) => {
+  return client.query<T>({
+    text: typeof query === 'string' ? query : query.text,
+    values: typeof query === 'string' ? undefined : query.values,
+    types: types && {
+      getTypeParser(id: number) {
+        return types[id] || returnArg;
+      },
+    },
+  });
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const performQueryArrays = <T extends any[] = any[]>(
+  client: PoolClient,
+  query: Query,
+  types: TypeParsers,
+) => {
+  return client.query<T>({
+    text: typeof query === 'string' ? query : query.text,
+    values: typeof query === 'string' ? undefined : query.values,
+    rowMode: 'array',
+    types: types && {
+      getTypeParser(id: number) {
+        return types[id] || returnArg;
+      },
+    },
+  });
+};
+
+export class TransactionAdapter implements Adapter {
+  constructor(
+    public pool: Pool,
+    public client: PoolClient,
+    public types: TypeParsers,
+  ) {}
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async query<T extends QueryResultRow = any>(
+    query: Query,
+    types: TypeParsers = this.types,
+  ): Promise<QueryResult<T>> {
+    return await performQuery<T>(this.client, query, types);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async arrays<R extends any[] = any[]>(
+    query: Query,
+    types: TypeParsers = this.types,
+  ): Promise<QueryArraysResult<R>> {
+    return await performQueryArrays<R>(this.client, query, types);
+  }
+
+  async transaction<Result>(
+    cb: (adapter: Adapter) => Promise<Result>,
+  ): Promise<Result> {
+    return await cb(this);
+  }
+
+  destroy() {
+    return this.pool.end();
+  }
+}

package/src/columnSchema/array.ts

@@ -0,0 +1,21 @@
+import { ColumnType } from './columnType';
+import { Operators } from '../operators';
+
+export class ArrayColumn<Item extends ColumnType> extends ColumnType<
+  Item['type'][],
+  typeof Operators.array
+> {
+  dataType = 'array' as const;
+  operators = Operators.array;
+  data: { item: Item };
+
+  constructor(item: Item) {
+    super();
+
+    this.data = { item };
+  }
+
+  toSQL() {
+    return `${this.data.item.toSQL()}[]`;
+  }
+}

package/src/columnSchema/boolean.ts

@@ -0,0 +1,10 @@
+import { ColumnType } from './columnType';
+import { Operators } from '../operators';
+
+export class BooleanColumn extends ColumnType<
+  boolean,
+  typeof Operators.boolean
+> {
+  dataType = 'boolean' as const;
+  operators = Operators.boolean;
+}

package/src/columnSchema/columnType.test.ts

@@ -0,0 +1,129 @@
+import { ColumnType } from './columnType';
+import { Operators } from '../operators';
+import {
+  adapter,
+  AssertEqual,
+  db,
+  expectSql,
+  User,
+  userData,
+  useTestDatabase,
+} from '../test-utils';
+import { createDb } from '../db';
+
+describe('column base', () => {
+  useTestDatabase();
+
+  class Column extends ColumnType {
+    dataType = 'test';
+    operators = Operators.any;
+  }
+  const column = new Column();
+
+  describe('.primaryKey', () => {
+    it('should mark column as a primary key', () => {
+      expect(column.isPrimaryKey).toBe(false);
+      expect(column.primaryKey().isPrimaryKey).toBe(true);
+    });
+  });
+
+  describe('.hidden', () => {
+    it('should mark column as hidden', () => {
+      expect(column.isHidden).toBe(false);
+      expect(column.hidden().isHidden).toBe(true);
+    });
+
+    test('model with hidden column should omit from select it by default', () => {
+      const User = db('user', (t) => ({
+        id: t.serial().primaryKey(),
+        name: t.text(),
+        password: t.text().hidden(),
+      }));
+
+      const q = User.all();
+      expectSql(
+        q.toSql(),
+        `
+          SELECT
+            "user"."id",
+            "user"."name"
+          FROM "user"
+        `,
+      );
+    });
+
+    test('model with hidden column still allows to select it', () => {
+      const User = db('user', (t) => ({
+        id: t.serial().primaryKey(),
+        name: t.text(),
+        password: t.text().hidden(),
+      }));
+
+      const q = User.select('id', 'name', 'password');
+      expectSql(
+        q.toSql(),
+        `
+          SELECT
+            "user"."id",
+            "user"."name",
+            "user"."password"
+          FROM "user"
+        `,
+      );
+    });
+  });
+
+  describe('.nullable', () => {
+    it('should mark column as nullable', () => {
+      expect(column.isNullable).toBe(false);
+      expect(column.nullable().isNullable).toBe(true);
+    });
+  });
+
+  describe('.encodeFn', () => {
+    it('should set a function to encode value for this column', () => {
+      expect(column.encodeFn).toBe(undefined);
+      const fn = (input: number) => input.toString();
+      const withEncode = column.encode(fn);
+      expect(withEncode.encodeFn).toBe(fn);
+      const eq: AssertEqual<typeof withEncode.inputType, number> = true;
+      expect(eq).toBeTruthy();
+    });
+  });
+
+  describe('.parseFn', () => {
+    it('should set a function to encode value for this column', () => {
+      expect(column.parseFn).toBe(undefined);
+      const fn = () => 123;
+      const withEncode = column.parse(fn);
+      expect(withEncode.parseFn).toBe(fn);
+      const eq: AssertEqual<typeof withEncode.type, number> = true;
+      expect(eq).toBeTruthy();
+    });
+
+    describe('parsing columns', () => {
+      beforeEach(async () => {
+        await User.insert(userData);
+      });
+
+      it('should return column data as returned from db if not set', async () => {
+        const db = createDb({ adapter });
+
+        const UserWithPlainTimestamp = db('user', (t) => ({
+          createdAt: t.timestamp(),
+        }));
+
+        expect(typeof (await UserWithPlainTimestamp.take()).createdAt).toBe(
+          'string',
+        );
+      });
+
+      it('should parse all columns', async () => {
+        expect((await User.all())[0].createdAt instanceof Date).toBe(true);
+        expect((await User.take()).createdAt instanceof Date).toBe(true);
+        const idx = Object.keys(User.shape).indexOf('createdAt');
+        expect((await User.rows())[0][idx] instanceof Date).toBe(true);
+      });
+    });
+  });
+});

package/src/columnSchema/columnType.ts

@@ -0,0 +1,77 @@
+import { Operator, Operators } from '../operators';
+import { EmptyObject } from './utils';
+
+export type ColumnOutput<T extends ColumnType> = T['type'];
+
+export type ColumnInput<T extends ColumnType> = T['inputType'];
+
+export type NullableColumn<T extends ColumnType> = Omit<
+  T,
+  'type' | 'operators'
+> & {
+  type: T['type'] | null;
+  isNullable: true;
+  operators: Omit<T['operators'], 'equals' | 'not'> & {
+    equals: Operator<T['type'] | null>;
+    not: Operator<T['type'] | null>;
+  };
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AnyColumnType = ColumnType<any, Record<string, Operator<any>>>;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AnyColumnTypeCreator = (...args: any[]) => AnyColumnType;
+
+export abstract class ColumnType<
+  Type = unknown,
+  Ops extends Operators = Operators,
+  InputType = Type,
+> {
+  abstract dataType: string;
+  abstract operators: Ops;
+
+  type!: Type;
+  inputType!: InputType;
+  data = {} as EmptyObject;
+  isPrimaryKey = false;
+  isHidden = false;
+  isNullable = false;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  encodeFn?: (input: any) => unknown;
+  parseFn?: (input: unknown) => unknown;
+
+  primaryKey<T extends ColumnType>(this: T): T & { isPrimaryKey: true } {
+    return Object.assign(this, { isPrimaryKey: true as const });
+  }
+
+  hidden<T extends ColumnType>(this: T): T & { isHidden: true } {
+    return Object.assign(this, { isHidden: true as const });
+  }
+
+  nullable<T extends ColumnType>(this: T): NullableColumn<T> {
+    this.isNullable = true;
+    return this as unknown as NullableColumn<T>;
+  }
+
+  encode<T extends ColumnType, Input>(
+    this: T,
+    fn: (input: Input) => unknown,
+  ): Omit<T, 'inputType'> & { inputType: Input } {
+    const self = this as unknown as Omit<T, 'inputType'> & { inputType: Input };
+    self.encodeFn = fn;
+    return self;
+  }
+
+  parse<T extends ColumnType, Output>(
+    this: T,
+    fn: (input: T['type']) => Output,
+  ): Omit<T, 'type'> & { type: Output } {
+    this.parseFn = fn;
+    return this as unknown as Omit<T, 'type'> & { type: Output };
+  }
+
+  toSQL() {
+    return this.dataType;
+  }
+}

package/src/columnSchema/columnTypes.ts

@@ -0,0 +1,145 @@
+import {
+  BigIntColumn,
+  BigSerialColumn,
+  DecimalBigIntColumn,
+  DecimalColumn,
+  DoublePrecisionColumn,
+  IntegerColumn,
+  RealColumn,
+  SerialColumn,
+  SmallIntColumn,
+  SmallSerialColumn,
+} from './number';
+import {
+  BitColumn,
+  BitVaryingColumn,
+  BoxColumn,
+  ByteaColumn,
+  CharColumn,
+  CidrColumn,
+  CircleColumn,
+  InetColumn,
+  LineColumn,
+  LsegColumn,
+  MacAddrColumn,
+  MacAddr8Column,
+  MoneyColumn,
+  PathColumn,
+  PointColumn,
+  PolygonColumn,
+  TextColumn,
+  TsQueryColumn,
+  TsVectorColumn,
+  UUIDColumn,
+  VarCharColumn,
+  XMLColumn,
+} from './string';
+import {
+  DateColumn,
+  IntervalColumn,
+  TimeColumn,
+  TimestampColumn,
+  TimestampWithTimeZoneColumn,
+  TimeWithTimeZoneColumn,
+} from './dateTime';
+import { BooleanColumn } from './boolean';
+import { EnumColumn } from './enum';
+import { JSONColumn, JSONTextColumn, JSONTypes } from './json';
+import { JSONTypeAny } from './json/typeBase';
+import { ArrayColumn } from './array';
+import { ColumnType } from './columnType';
+
+export type ColumnTypes = typeof columnTypes;
+
+export const columnTypes = {
+  smallint: () => new SmallIntColumn(),
+  integer: () => new IntegerColumn(),
+  bigint: () => new BigIntColumn(),
+  numeric: <
+    Precision extends number | undefined = undefined,
+    Scale extends number | undefined = undefined,
+  >(
+    precision?: Precision,
+    scale?: Scale,
+  ) => new DecimalColumn(precision, scale),
+  numericBigInt: <
+    Precision extends number | undefined = undefined,
+    Scale extends number | undefined = undefined,
+  >(
+    precision?: Precision,
+    scale?: Scale,
+  ) => new DecimalBigIntColumn(precision, scale),
+  decimal: <
+    Precision extends number | undefined = undefined,
+    Scale extends number | undefined = undefined,
+  >(
+    precision?: Precision,
+    scale?: Scale,
+  ) => new DecimalColumn(precision, scale),
+  decimalBigInt: <
+    Precision extends number | undefined = undefined,
+    Scale extends number | undefined = undefined,
+  >(
+    precision?: Precision,
+    scale?: Scale,
+  ) => new DecimalBigIntColumn(precision, scale),
+  real: () => new RealColumn(),
+  doublePrecision: () => new DoublePrecisionColumn(),
+  smallSerial: () => new SmallSerialColumn(),
+  serial: () => new SerialColumn(),
+  bigserial: () => new BigSerialColumn(),
+  money: () => new MoneyColumn(),
+  varchar: <Limit extends number | undefined = undefined>(limit?: Limit) =>
+    new VarCharColumn(limit),
+  char: <Limit extends number | undefined = undefined>(limit?: Limit) =>
+    new CharColumn(limit),
+  text: () => new TextColumn(),
+  bytea: () => new ByteaColumn(),
+  date: () => new DateColumn(),
+  timestamp: <Precision extends number | undefined = undefined>(
+    precision?: Precision,
+  ) => new TimestampColumn(precision),
+  timestampWithTimeZone: <Precision extends number | undefined = undefined>(
+    precision?: Precision,
+  ) => new TimestampWithTimeZoneColumn(precision),
+  time: <Precision extends number | undefined = undefined>(
+    precision?: Precision,
+  ) => new TimeColumn(precision),
+  timeWithTimeZone: <Precision extends number | undefined = undefined>(
+    precision?: Precision,
+  ) => new TimeWithTimeZoneColumn(precision),
+  interval: <
+    Fields extends string | undefined = undefined,
+    Precision extends number | undefined = undefined,
+  >(
+    fields?: Fields,
+    precision?: Precision,
+  ) => new IntervalColumn(fields, precision),
+  boolean: () => new BooleanColumn(),
+  enum: <DataType extends string, Type>(dataType: DataType) =>
+    new EnumColumn<DataType, Type>(dataType),
+  point: () => new PointColumn(),
+  line: () => new LineColumn(),
+  lseg: () => new LsegColumn(),
+  box: () => new BoxColumn(),
+  path: () => new PathColumn(),
+  polygon: () => new PolygonColumn(),
+  circle: () => new CircleColumn(),
+  cidr() {
+    return new CidrColumn();
+  },
+  inet: () => new InetColumn(),
+  macaddr: () => new MacAddrColumn(),
+  macaddr8: () => new MacAddr8Column(),
+  bit: () => new BitColumn(),
+  bitVarying: () => new BitVaryingColumn(),
+  tsvector: () => new TsVectorColumn(),
+  tsquery: () => new TsQueryColumn(),
+  uuid: () => new UUIDColumn(),
+  xml: () => new XMLColumn(),
+  json: <Type extends JSONTypeAny>(
+    schemaOrFn: Type | ((j: JSONTypes) => Type),
+  ) => new JSONColumn(schemaOrFn),
+  jsonText: () => new JSONTextColumn(),
+  array: <Item extends ColumnType>(item: Item) => new ArrayColumn(item),
+};

package/src/columnSchema/columnsSchema.test.ts

@@ -0,0 +1,32 @@
+import { AssertEqual } from '../test-utils';
+import { TableSchema } from './columnsSchema';
+import { columnTypes } from './columnTypes';
+
+describe('columnsSchema', () => {
+  describe('schema methods', () => {
+    const createSchema = () => {
+      return new TableSchema({
+        a: columnTypes.integer().primaryKey(),
+        b: columnTypes.decimal().primaryKey(),
+        c: columnTypes.text(),
+      });
+    };
+
+    describe('.primaryKeys', () => {
+      it('should be array of primary key names', () => {
+        const schema = createSchema();
+        const eq: AssertEqual<typeof schema.primaryKeys, ['a', 'b']> = true;
+        expect(eq).toBe(true);
+        expect(schema.primaryKeys).toEqual(['a', 'b']);
+      });
+    });
+
+    describe('.primaryTypes', () => {
+      const schema = createSchema();
+      const eq: AssertEqual<typeof schema.primaryTypes, [number, number]> =
+        true;
+      expect(eq).toBe(true);
+      expect(schema.primaryTypes).toEqual(undefined);
+    });
+  });
+});