pqb 0.0.1 → 0.0.3

package/README.md

@@ -0,0 +1,5 @@
+# pqb
+
+A query builder for Postgres database focused on type safety with TypeScript.
+
+[Read docs here](https://porm.netlify.app/guide/query-builder.html).

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "pqb",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Postgres query builder",
+  "homepage": "https://porm.netlify.app/guide/query-builder.html",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/romeerez/porm"
+    "url": "git+https://github.com/romeerez/porm/tree/main/packages/pqb"
   },
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
@@ -29,6 +30,7 @@
     }
   },
   "keywords": [
+    "pg",
     "postgres",
     "query-builder"
   ],
@@ -39,6 +41,7 @@
     "rollup": "^2.79.0",
     "rollup-plugin-dts": "^4.2.2",
     "rollup-plugin-esbuild": "^4.10.1",
+    "esbuild": "^0.15.10",
     "@swc/core": "^1.2.210",
     "@swc/jest": "^0.2.21",
     "@types/jest": "^28.1.2",

package/rollup.config.js

@@ -1,35 +1,3 @@
-import dts from 'rollup-plugin-dts';
-import esbuild from 'rollup-plugin-esbuild';
+import config from '../../rollup.config';
 
-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',
-    },
-  },
-];
+export default config;

package/src/adapter.ts

@@ -7,7 +7,7 @@ export interface QueryResultRow {
 
 export type TypeParsers = Record<number, (input: string) => unknown>;
 
-type Query = string | { text: string; values?: unknown[] };
+export type QueryInput = string | { text: string; values?: unknown[] };
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type QueryResult<T extends QueryResultRow = any> = {
@@ -34,6 +34,7 @@ for (const key in types.builtins) {
   types.builtins.TIMESTAMP,
   types.builtins.TIMESTAMPTZ,
   types.builtins.TIME,
+  types.builtins.CIRCLE,
 ].forEach((id) => {
   delete defaultTypeParsers[id];
 });
@@ -55,7 +56,7 @@ export class Adapter {
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   async query<T extends QueryResultRow = any>(
-    query: Query,
+    query: QueryInput,
     types: TypeParsers = this.types,
   ): Promise<QueryResult<T>> {
     const client = await this.pool.connect();
@@ -68,7 +69,7 @@ export class Adapter {
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   async arrays<R extends any[] = any[]>(
-    query: Query,
+    query: QueryInput,
     types: TypeParsers = this.types,
   ): Promise<QueryArraysResult<R>> {
     const client = await this.pool.connect();
@@ -80,7 +81,7 @@ export class Adapter {
   }
 
   async transaction<Result>(
-    cb: (adapter: Adapter) => Promise<Result>,
+    cb: (adapter: TransactionAdapter) => Promise<Result>,
   ): Promise<Result> {
     const client = await this.pool.connect();
     try {
@@ -97,6 +98,7 @@ export class Adapter {
       client.release();
     }
   }
+
   destroy(): Promise<void> {
     return this.pool.end();
   }
@@ -104,7 +106,7 @@ export class Adapter {
 
 const performQuery = <T extends QueryResultRow>(
   client: PoolClient,
-  query: Query,
+  query: QueryInput,
   types: TypeParsers,
 ) => {
   return client.query<T>({
@@ -121,7 +123,7 @@ const performQuery = <T extends QueryResultRow>(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const performQueryArrays = <T extends any[] = any[]>(
   client: PoolClient,
-  query: Query,
+  query: QueryInput,
   types: TypeParsers,
 ) => {
   return client.query<T>({
@@ -145,7 +147,7 @@ export class TransactionAdapter implements Adapter {
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   async query<T extends QueryResultRow = any>(
-    query: Query,
+    query: QueryInput,
     types: TypeParsers = this.types,
   ): Promise<QueryResult<T>> {
     return await performQuery<T>(this.client, query, types);
@@ -153,14 +155,14 @@ export class TransactionAdapter implements Adapter {
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   async arrays<R extends any[] = any[]>(
-    query: Query,
+    query: QueryInput,
     types: TypeParsers = this.types,
   ): Promise<QueryArraysResult<R>> {
     return await performQueryArrays<R>(this.client, query, types);
   }
 
   async transaction<Result>(
-    cb: (adapter: Adapter) => Promise<Result>,
+    cb: (adapter: TransactionAdapter) => Promise<Result>,
   ): Promise<Result> {
     return await cb(this);
   }

package/src/columnSchema/array.ts

@@ -1,5 +1,20 @@
-import { ColumnType } from './columnType';
-import { Operators } from '../operators';
+import { ColumnData, ColumnType } from './columnType';
+import { Operators } from '../columnsOperators';
+import { assignMethodsToClass } from './utils';
+import { arrayMethods } from './commonMethods';
+
+export type ArrayData<Item extends ColumnType> = ColumnData & {
+  item: Item;
+  min?: number;
+  max?: number;
+  length?: number;
+};
+
+type ArrayMethods = typeof arrayMethods;
+
+export interface ArrayColumn<Item extends ColumnType>
+  extends ColumnType<Item['type'][], typeof Operators.array>,
+    ArrayMethods {}
 
 export class ArrayColumn<Item extends ColumnType> extends ColumnType<
   Item['type'][],
@@ -7,7 +22,7 @@ export class ArrayColumn<Item extends ColumnType> extends ColumnType<
 > {
   dataType = 'array' as const;
   operators = Operators.array;
-  data: { item: Item };
+  data: ArrayData<Item>;
 
   constructor(item: Item) {
     super();
@@ -18,4 +33,101 @@ export class ArrayColumn<Item extends ColumnType> extends ColumnType<
   toSQL() {
     return `${this.data.item.toSQL()}[]`;
   }
+
+  parseFn = (input: unknown) => {
+    const entries: unknown[] = [];
+    parseArray(
+      input as string,
+      0,
+      (input as string).length,
+      entries,
+      false,
+      this.data.item,
+    );
+    return entries;
+  };
 }
+
+const parseArray = (
+  input: string,
+  pos: number,
+  len: number,
+  entries: unknown[],
+  nested: boolean,
+  item: ColumnType,
+): number => {
+  if (input[0] === '[') {
+    while (pos < len) {
+      let char = input[pos++];
+      if (char === '\\') {
+        char = input[pos++];
+      }
+      if (char === '=') break;
+    }
+  }
+
+  let quote = false;
+  let start = pos;
+  while (pos < len) {
+    let char = input[pos++];
+    const escaped = char === '\\';
+    if (escaped) {
+      char = input[pos++];
+    }
+
+    if (char === '"' && !escaped) {
+      if (quote) {
+        pushEntry(input, start, pos, entries, item);
+      } else {
+        start = pos;
+      }
+      quote = !quote;
+    } else if (char === ',' && !quote) {
+      if (start !== pos) {
+        pushEntry(input, start, pos, entries, item);
+      }
+      start = pos;
+    } else if (char === '{' && !quote) {
+      let array: unknown[];
+      let nestedItem = item;
+      if (nested) {
+        array = [];
+        entries.push(array);
+        if ('item' in item.data) {
+          nestedItem = (item as ArrayColumn<ColumnType>).data
+            .item as ColumnType;
+        }
+      } else {
+        array = entries;
+      }
+      pos = parseArray(input, pos, len, array, true, nestedItem);
+      start = pos + 1;
+    } else if (char === '}' && !quote) {
+      if (start !== pos) {
+        pushEntry(input, start, pos, entries, item);
+      }
+      start = pos + 1;
+      break;
+    }
+  }
+
+  return pos;
+};
+
+assignMethodsToClass(ArrayColumn, arrayMethods);
+
+const pushEntry = (
+  input: string,
+  start: number,
+  pos: number,
+  entries: unknown[],
+  item: ColumnType,
+) => {
+  let entry: unknown = input.slice(start, pos - 1);
+  if (entry === 'NULL') {
+    entry = null;
+  } else if (item.parseItem) {
+    entry = item.parseItem(entry as string);
+  }
+  entries.push(entry);
+};

package/src/columnSchema/boolean.ts

@@ -1,10 +1,13 @@
 import { ColumnType } from './columnType';
-import { Operators } from '../operators';
+import { Operators } from '../columnsOperators';
 
+// 1 byte, true or false
 export class BooleanColumn extends ColumnType<
   boolean,
   typeof Operators.boolean
 > {
   dataType = 'boolean' as const;
   operators = Operators.boolean;
+
+  parseItem = (input: string) => input[0] === 't';
 }

package/src/columnSchema/columnType.test.ts

@@ -1,5 +1,5 @@
 import { ColumnType } from './columnType';
-import { Operators } from '../operators';
+import { Operators } from '../columnsOperators';
 import {
   adapter,
   AssertEqual,

package/src/columnSchema/columnType.ts

@@ -1,5 +1,8 @@
-import { Operator, Operators } from '../operators';
-import { EmptyObject } from './utils';
+import { Operator, Operators } from '../columnsOperators';
+import { JSONTypeAny } from './json/typeBase';
+import { ColumnsShape } from './columnsSchema';
+import { RawExpression, StringKey } from '../common';
+import { MaybeArray } from '../utils';
 
 export type ColumnOutput<T extends ColumnType> = T['type'];
 
@@ -7,9 +10,10 @@ export type ColumnInput<T extends ColumnType> = T['inputType'];
 
 export type NullableColumn<T extends ColumnType> = Omit<
   T,
-  'type' | 'operators'
+  'type' | 'inputType' | 'operators'
 > & {
   type: T['type'] | null;
+  inputType: T['inputType'] | null;
   isNullable: true;
   operators: Omit<T['operators'], 'equals' | 'not'> & {
     equals: Operator<T['type'] | null>;
@@ -20,8 +24,90 @@ export type NullableColumn<T extends ColumnType> = Omit<
 // 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, @typescript-eslint/ban-types
+export type AnyColumnTypeCreator = (...args: any[]) => AnyColumnType | {};
+
+export type ColumnTypesBase = Record<
+  string,
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  AnyColumnTypeCreator
+>;
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type AnyColumnTypeCreator = (...args: any[]) => AnyColumnType;
+export type ValidationContext = any;
+
+export type ColumnData = {
+  default?: unknown;
+  validationDefault?: unknown;
+  index?: Omit<SingleColumnIndexOptions, 'column'>;
+  comment?: string;
+  collate?: string;
+  compression?: string;
+  foreignKey?: ForeignKey<string, string[]>;
+};
+
+type ForeignKeyMatch = 'FULL' | 'PARTIAL' | 'SIMPLE';
+
+type ForeignKeyAction =
+  | 'NO ACTION'
+  | 'RESTRICT'
+  | 'CASCADE'
+  | 'SET NULL'
+  | 'SET DEFAULT';
+
+export type ForeignKey<Table extends string, Columns extends string[]> = (
+  | {
+      fn(): new () => { table: Table };
+    }
+  | {
+      table: Table;
+    }
+) & {
+  columns: Columns;
+} & ForeignKeyOptions;
+
+export type DropMode = 'CASCADE' | 'RESTRICT';
+
+export type ForeignKeyOptions = {
+  name?: string;
+  match?: ForeignKeyMatch;
+  onUpdate?: ForeignKeyAction;
+  onDelete?: ForeignKeyAction;
+  dropMode?: DropMode;
+};
+
+export type IndexColumnOptions = {
+  column: string;
+  expression?: number | string;
+  collate?: string;
+  operator?: string;
+  order?: string;
+};
+
+export type IndexOptions = {
+  name?: string;
+  unique?: boolean;
+  using?: string;
+  include?: MaybeArray<string>;
+  with?: string;
+  tablespace?: string;
+  where?: string;
+  dropMode?: 'CASCADE' | 'RESTRICT';
+};
+
+export type SingleColumnIndexOptions = IndexColumnOptions & IndexOptions;
+
+export type ForeignKeyModel = new () => {
+  table: string;
+};
+
+export type ForeignKeyModelWithColumns = new () => {
+  table: string;
+  columns: { shape: ColumnsShape };
+};
+
+export type ColumnNameOfModel<Model extends ForeignKeyModelWithColumns> =
+  StringKey<keyof InstanceType<Model>['columns']['shape']>;
 
 export abstract class ColumnType<
   Type = unknown,
@@ -33,18 +119,68 @@ export abstract class ColumnType<
 
   type!: Type;
   inputType!: InputType;
-  data = {} as EmptyObject;
+  data = {} as ColumnData;
   isPrimaryKey = false;
   isHidden = false;
   isNullable = false;
+
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   encodeFn?: (input: any) => unknown;
   parseFn?: (input: unknown) => unknown;
+  // parse item in array:
+  parseItem?: (input: string) => unknown;
+
+  chain = [] as (
+    | ['transform', (input: unknown, ctx: ValidationContext) => unknown]
+    | ['to', (input: unknown) => JSONTypeAny | undefined, JSONTypeAny]
+    | ['refine', (input: unknown) => unknown]
+    | ['superRefine', (input: unknown, ctx: ValidationContext) => unknown]
+  )[];
 
   primaryKey<T extends ColumnType>(this: T): T & { isPrimaryKey: true } {
     return Object.assign(this, { isPrimaryKey: true as const });
   }
 
+  foreignKey<
+    T extends ColumnType,
+    Model extends ForeignKeyModelWithColumns,
+    Column extends ColumnNameOfModel<Model>,
+  >(
+    this: T,
+    fn: () => Model,
+    column: Column,
+    options?: ForeignKeyOptions,
+  ): Omit<T, 'foreignKeyData'> & {
+    foreignKeyData: ForeignKey<InstanceType<Model>['table'], [Column]>;
+  };
+  foreignKey<T extends ColumnType, Table extends string, Column extends string>(
+    this: T,
+    table: Table,
+    column: Column,
+    options?: ForeignKeyOptions,
+  ): Omit<T, 'foreignKeyData'> & {
+    foreignKeyData: ForeignKey<Table, [Column]>;
+  };
+  foreignKey(
+    fnOrTable: (() => ForeignKeyModel) | string,
+    column: string,
+    options: ForeignKeyOptions = {},
+  ) {
+    const cloned = Object.create(this);
+    if (typeof fnOrTable === 'string') {
+      cloned.data = {
+        ...this.data,
+        foreignKey: { table: fnOrTable, columns: [column], ...options },
+      };
+    } else {
+      cloned.data = {
+        ...this.data,
+        foreignKey: { fn: fnOrTable, columns: [column], ...options },
+      };
+    }
+    return cloned;
+  }
+
   hidden<T extends ColumnType>(this: T): T & { isHidden: true } {
     return Object.assign(this, { isHidden: true as const });
   }
@@ -68,10 +204,96 @@ export abstract class ColumnType<
     fn: (input: T['type']) => Output,
   ): Omit<T, 'type'> & { type: Output } {
     this.parseFn = fn;
+    this.parseItem = fn;
     return this as unknown as Omit<T, 'type'> & { type: Output };
   }
 
   toSQL() {
     return this.dataType;
   }
+
+  default<T extends ColumnType>(this: T, value: T['type'] | RawExpression): T {
+    const cloned = Object.create(this);
+    cloned.data = { ...cloned.data, default: value };
+    return cloned;
+  }
+
+  index<T extends ColumnType>(
+    this: T,
+    options: Omit<SingleColumnIndexOptions, 'column'> = {},
+  ) {
+    const cloned = Object.create(this);
+    cloned.data = { ...cloned.data, index: options };
+    return cloned;
+  }
+
+  unique<T extends ColumnType>(
+    this: T,
+    options: Omit<SingleColumnIndexOptions, 'column' | 'unique'> = {},
+  ): T {
+    const cloned = Object.create(this);
+    cloned.data = { ...cloned.data, index: { ...options, unique: true } };
+    return cloned;
+  }
+
+  comment<T extends ColumnType>(this: T, comment: string): T {
+    const cloned = Object.create(this);
+    cloned.data = { ...cloned.data, comment };
+    return cloned;
+  }
+
+  validationDefault<T extends ColumnType>(this: T, value: T['type']): T {
+    const cloned = Object.create(this);
+    cloned.data = { ...cloned.data, validationDefault: value };
+    return cloned;
+  }
+
+  compression<T extends ColumnType>(this: T, compression: string): T {
+    const cloned = Object.create(this);
+    cloned.data = { ...cloned.data, compression };
+    return cloned;
+  }
+
+  collate<T extends ColumnType>(this: T, collate: string): T {
+    const cloned = Object.create(this);
+    cloned.data = { ...cloned.data, collate };
+    return cloned;
+  }
+
+  transform<T extends ColumnType, Transformed>(
+    this: T,
+    fn: (input: T['type'], ctx: ValidationContext) => Transformed,
+  ): Omit<T, 'type'> & { type: Transformed } {
+    const cloned = Object.create(this);
+    cloned.chain = [...this.chain, ['transform', fn]];
+    return cloned as Omit<T, 'type'> & { type: Transformed };
+  }
+
+  to<T extends ColumnType, ToType extends ColumnType>(
+    this: T,
+    fn: (input: T['type']) => ToType['type'] | undefined,
+    type: ToType,
+  ): ToType {
+    const cloned = Object.create(type);
+    cloned.chain = [...this.chain, ['to', fn, type], ...cloned.chain];
+    return cloned as ToType;
+  }
+
+  refine<T extends ColumnType, RefinedOutput extends T['type']>(
+    this: T,
+    check: (arg: T['type']) => unknown,
+  ): T & { type: RefinedOutput } {
+    const cloned = Object.create(this);
+    cloned.chain = [...this.chain, ['refine', check]];
+    return cloned as T & { type: RefinedOutput };
+  }
+
+  superRefine<T extends ColumnType, RefinedOutput extends T['type']>(
+    this: T,
+    check: (arg: T['type'], ctx: ValidationContext) => unknown,
+  ): T & { type: RefinedOutput } {
+    const cloned = Object.create(this);
+    cloned.chain = [...this.chain, ['superRefine', check]];
+    return cloned as T & { type: RefinedOutput };
+  }
 }