pqb 0.0.1

package/src/columnSchema/json/typeBase.ts

@@ -0,0 +1,202 @@
+import { JSONOptional, JSONRequired, optional, required } from './optional';
+import {
+  JSONNotNullable,
+  JSONNullable,
+  notNullable,
+  nullable,
+} from './nullable';
+import { JSONNotNullish, JSONNullish, notNullish, nullish } from './nullish';
+import { intersection, JSONIntersection } from './intersection';
+import { array, JSONArray } from './array';
+import { union } from './union';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type JSONTypeAny = JSONType<any, string>;
+
+export type DeepPartial<T extends JSONTypeAny> = ReturnType<
+  JSONTypeAny['deepPartial']
+> extends ReturnType<T['deepPartial']>
+  ? T
+  : ReturnType<T['deepPartial']>;
+
+export type JSONTypeData = {
+  optional?: true;
+  nullable?: true;
+};
+
+export type Primitive = string | number | bigint | boolean | null | undefined;
+
+export type JSONType<Type, DataType> = {
+  type: Type;
+  data: JSONTypeData;
+  dataType: DataType;
+  chain: (
+    | ['transform', (input: unknown) => unknown]
+    | ['to', (input: unknown) => JSONTypeAny | undefined, JSONTypeAny]
+    | ['refine', (input: unknown) => unknown]
+    | ['superRefine', (input: unknown) => unknown]
+  )[];
+
+  optional<T extends JSONTypeAny>(this: T): JSONOptional<T>;
+  required<T extends JSONTypeAny>(this: T): JSONRequired<T>;
+  nullable<T extends JSONTypeAny>(this: T): JSONNullable<T>;
+  notNullable<T extends JSONTypeAny>(this: T): JSONNotNullable<T>;
+  nullish<T extends JSONTypeAny>(this: T): JSONNullish<T>;
+  notNullish<T extends JSONTypeAny>(this: T): JSONNotNullish<T>;
+  deepPartial(): JSONTypeAny;
+
+  transform<T extends JSONTypeAny, Transformed>(
+    this: T,
+    fn: (input: T['type']) => Transformed,
+  ): JSONType<
+    Transformed extends PromiseLike<unknown>
+      ? Awaited<Transformed>
+      : Transformed,
+    T['dataType']
+  >;
+
+  to<T extends JSONTypeAny, ToType extends JSONTypeAny>(
+    this: T,
+    fn: (input: T['type']) => ToType['type'] | undefined,
+    type: ToType,
+  ): ToType;
+
+  refine<T extends JSONTypeAny, RefinedOutput extends T['type']>(
+    this: T,
+    check: (arg: T['type']) => unknown,
+  ): T & { type: RefinedOutput };
+
+  superRefine<T extends JSONTypeAny, RefinedOutput extends T['type']>(
+    this: T,
+    check: (arg: T['type']) => unknown,
+  ): T & { type: RefinedOutput };
+
+  and<A extends JSONTypeAny, B extends JSONTypeAny>(
+    this: A,
+    type: B,
+  ): JSONIntersection<A, B>;
+
+  or<T extends JSONTypeAny, U extends [JSONTypeAny, ...JSONTypeAny[]]>(
+    this: T,
+    ...types: U
+  ): T | U[number];
+
+  default<T extends JSONTypeAny>(
+    this: T,
+    value: T['type'] | (() => T['type']),
+  ): JSONNotNullish<T>;
+
+  array<T extends JSONTypeAny>(this: T): JSONArray<T>;
+};
+
+const baseTypeMethods: JSONTypeAny = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  type: undefined as any,
+  data: {},
+  dataType: 'any',
+  chain: [],
+
+  optional<T extends JSONTypeAny>(this: T) {
+    return optional(this);
+  },
+
+  required<T extends JSONTypeAny>(this: T) {
+    return required(this);
+  },
+
+  nullable<T extends JSONTypeAny>(this: T) {
+    return nullable(this);
+  },
+
+  notNullable<T extends JSONTypeAny>(this: T) {
+    return notNullable(this);
+  },
+
+  nullish<T extends JSONTypeAny>(this: T) {
+    return nullish(this);
+  },
+
+  notNullish<T extends JSONTypeAny>(this: T) {
+    return notNullish(this);
+  },
+
+  deepPartial() {
+    return this;
+  },
+
+  transform<T extends JSONTypeAny, Transformed>(
+    this: T,
+    fn: (input: unknown) => Transformed,
+  ) {
+    return {
+      ...this,
+      chain: [...this.chain, ['transform', fn]],
+    };
+  },
+
+  to(fn, type) {
+    return {
+      ...type,
+      chain: [...this.chain, ['to', fn, type], ...type.chain],
+    };
+  },
+
+  refine(check) {
+    return {
+      ...this,
+      chain: [...this.chain, ['refine', check]],
+    };
+  },
+
+  superRefine(check) {
+    return {
+      ...this,
+      chain: [...this.chain, ['superRefine', check]],
+    };
+  },
+
+  and(type) {
+    return intersection(this, type);
+  },
+
+  or(...args) {
+    const [type, ...types] = args;
+    return union([this, type, ...types]);
+  },
+
+  default(value) {
+    const defaultFn =
+      typeof value === 'function'
+        ? (input: unknown) => input ?? (value as () => unknown)()
+        : (input: unknown) => input ?? value;
+
+    return notNullish({
+      ...this,
+      chain: ['transform', defaultFn],
+    });
+  },
+
+  array() {
+    return array(this);
+  },
+};
+
+type BaseTypeProps<T extends JSONTypeAny> = Omit<
+  JSONType<T['type'], string>,
+  'dataType'
+>;
+export type OwnTypeProps<T extends JSONTypeAny> = Omit<
+  T,
+  keyof BaseTypeProps<T>
+> & {
+  [k in keyof BaseTypeProps<T>]?: BaseTypeProps<T>[k];
+};
+
+export const constructType = <T extends JSONTypeAny>(
+  type: OwnTypeProps<T>,
+): T => {
+  return {
+    ...(baseTypeMethods as BaseTypeProps<T>),
+    ...type,
+  } as T;
+};

package/src/columnSchema/json/union.ts

@@ -0,0 +1,16 @@
+import { constructType, JSONType, JSONTypeAny } from './typeBase';
+
+export interface JSONUnion<
+  T extends [JSONTypeAny, JSONTypeAny, ...JSONTypeAny[]],
+> extends JSONType<T[number]['type'], 'union'> {
+  types: T;
+}
+
+export const union = <T extends [JSONTypeAny, JSONTypeAny, ...JSONTypeAny[]]>(
+  types: T,
+): T[number] => {
+  return constructType<JSONUnion<T>>({
+    dataType: 'union',
+    types,
+  });
+};

package/src/columnSchema/json.ts

@@ -0,0 +1,64 @@
+import { ColumnType } from './columnType';
+import { Operators } from '../operators';
+import { scalarTypes } from './json/scalarTypes';
+import { array } from './json/array';
+import { discriminatedUnion } from './json/discriminatedUnion';
+import { enumType } from './json/enum';
+import { instanceOf } from './json/instanceOf';
+import { intersection } from './json/intersection';
+import { lazy } from './json/lazy';
+import { literal } from './json/literal';
+import { map } from './json/map';
+import { nativeEnum } from './json/nativeEnum';
+import { nullable } from './json/nullable';
+import { nullish } from './json/nullish';
+import { object } from './json/object';
+import { optional } from './json/optional';
+import { record } from './json/record';
+import { set } from './json/set';
+import { tuple } from './json/tuple';
+import { union } from './json/union';
+import { JSONTypeAny } from './json/typeBase';
+
+export type JSONTypes = typeof jsonTypes;
+const jsonTypes = {
+  array,
+  discriminatedUnion,
+  enum: enumType,
+  instanceOf,
+  intersection,
+  lazy,
+  literal,
+  map,
+  nativeEnum,
+  nullable,
+  nullish,
+  object,
+  optional,
+  record,
+  ...scalarTypes,
+  set,
+  tuple,
+  union,
+};
+
+export class JSONColumn<
+  Type extends JSONTypeAny = JSONTypeAny,
+> extends ColumnType<Type['type'], typeof Operators.json> {
+  dataType = 'jsonb' as const;
+  operators = Operators.json;
+  data: { schema: Type };
+
+  constructor(schemaOrFn: Type | ((j: JSONTypes) => Type)) {
+    super();
+
+    const schema =
+      typeof schemaOrFn === 'function' ? schemaOrFn(jsonTypes) : schemaOrFn;
+    this.data = { schema };
+  }
+}
+
+export class JSONTextColumn extends ColumnType<string, typeof Operators.text> {
+  dataType = 'json' as const;
+  operators = Operators.text;
+}

package/src/columnSchema/number.ts

@@ -0,0 +1,122 @@
+import { Operators } from '../operators';
+import { ColumnType } from './columnType';
+import { joinTruthy } from '../utils';
+import { assignMethodsToClass } from './utils';
+import { numberTypeMethods } from './commonMethods';
+
+export interface BaseNumberData {
+  lt?: number;
+  lte?: number;
+  gt?: number;
+  gte?: number;
+  multipleOf?: number;
+}
+
+export type NumberColumn = ColumnType<number>;
+
+export type NumberColumnData = BaseNumberData;
+
+type NumberMethods = typeof numberMethods;
+const numberMethods = numberTypeMethods<ColumnType>();
+
+export interface NumberBaseColumn<Type>
+  extends ColumnType<Type, typeof Operators.number>,
+    NumberMethods {}
+
+export abstract class NumberBaseColumn<Type> extends ColumnType<
+  Type,
+  typeof Operators.number
+> {
+  data = {} as NumberColumnData;
+  operators = Operators.number;
+}
+
+assignMethodsToClass(NumberBaseColumn, numberMethods);
+
+export interface DecimalColumnData extends NumberColumnData {
+  precision?: number;
+  scale?: number;
+}
+
+export class DecimalBaseColumn<
+  Type extends number | bigint,
+  Precision extends number | undefined = undefined,
+  Scale extends number | undefined = undefined,
+> extends NumberBaseColumn<Type> {
+  data: DecimalColumnData & { precision: Precision; scale: Scale };
+  dataType = 'decimal' as const;
+
+  constructor(precision?: Precision, scale?: Scale) {
+    super();
+
+    this.data = {
+      precision,
+      scale,
+    } as DecimalColumnData & { precision: Precision; scale: Scale };
+  }
+
+  toSQL() {
+    const { precision, scale } = this.data;
+
+    return joinTruthy(
+      this.dataType,
+      precision
+        ? scale
+          ? `(${precision}, ${scale})`
+          : `(${precision})`
+        : undefined,
+    );
+  }
+}
+
+// signed two-byte integer
+export class SmallIntColumn extends NumberBaseColumn<number> {
+  dataType = 'smallint' as const;
+}
+
+// signed four-byte integer
+export class IntegerColumn extends NumberBaseColumn<number> {
+  dataType = 'integer' as const;
+}
+
+// signed eight-byte integer
+export class BigIntColumn extends NumberBaseColumn<bigint> {
+  dataType = 'bigint' as const;
+}
+
+// exact numeric of selectable precision
+export class DecimalColumn<
+  Precision extends number | undefined = undefined,
+  Scale extends number | undefined = undefined,
+> extends DecimalBaseColumn<number, Precision, Scale> {}
+
+// exact numeric of selectable precision, bigint JS type
+export class DecimalBigIntColumn<
+  Precision extends number | undefined = undefined,
+  Scale extends number | undefined = undefined,
+> extends DecimalBaseColumn<bigint, Precision, Scale> {}
+
+// single precision floating-point number (4 bytes)
+export class RealColumn extends NumberBaseColumn<number> {
+  dataType = 'real' as const;
+}
+
+// double precision floating-point number (8 bytes)
+export class DoublePrecisionColumn extends NumberBaseColumn<bigint> {
+  dataType = 'double precision' as const;
+}
+
+// autoincrementing two-byte integer
+export class SmallSerialColumn extends NumberBaseColumn<number> {
+  dataType = 'smallserial' as const;
+}
+
+// autoincrementing four-byte integer
+export class SerialColumn extends NumberBaseColumn<number> {
+  dataType = 'serial' as const;
+}
+
+// autoincrementing eight-byte integer
+export class BigSerialColumn extends NumberBaseColumn<bigint> {
+  dataType = 'bigserial' as const;
+}

package/src/columnSchema/string.ts

@@ -0,0 +1,222 @@
+import { ColumnType } from './columnType';
+import { Operators } from '../operators';
+import { joinTruthy } from '../utils';
+import { NumberBaseColumn } from './number';
+import { assignMethodsToClass } from './utils';
+import { stringTypeMethods } from './commonMethods';
+
+export interface BaseStringData {
+  min?: number;
+  max?: number;
+  length?: number;
+  email?: boolean;
+  url?: boolean;
+  uuid?: boolean;
+  cuid?: boolean;
+  regex?: RegExp;
+  trim?: boolean;
+}
+
+export type StringColumn = ColumnType<string>;
+
+export type TextColumnData = BaseStringData;
+
+type TextMethods = typeof textMethods;
+const textMethods = stringTypeMethods<ColumnType<string>>();
+
+export interface TextBaseColumn
+  extends ColumnType<string, typeof Operators.text>,
+    TextMethods {}
+
+export abstract class TextBaseColumn extends ColumnType<
+  string,
+  typeof Operators.text
+> {
+  data = {} as TextColumnData;
+  operators = Operators.text;
+}
+
+assignMethodsToClass(TextBaseColumn, textMethods);
+
+export abstract class LimitedTextBaseColumn<
+  Limit extends number | undefined = undefined,
+> extends TextBaseColumn {
+  data: TextColumnData & { max: Limit };
+
+  constructor(limit?: Limit) {
+    super();
+
+    this.data = { max: limit } as TextColumnData & { max: Limit };
+  }
+
+  toSQL() {
+    return joinTruthy(
+      this.dataType,
+      this.data.max !== undefined && `(${this.data.max})`,
+    );
+  }
+}
+
+// character varying(n), varchar(n)	variable-length with limit
+export class VarCharColumn<
+  Limit extends number | undefined = undefined,
+> extends LimitedTextBaseColumn<Limit> {
+  dataType = 'varchar' as const;
+}
+
+// character(n), char(n)	fixed-length, blank padded
+export class CharColumn<
+  Limit extends number | undefined = undefined,
+> extends LimitedTextBaseColumn<Limit> {
+  dataType = 'char' as const;
+}
+
+// text	variable unlimited length
+export class TextColumn extends ColumnType<string> {
+  dataType = 'text' as const;
+  operators = Operators.text;
+}
+
+// To store binary strings
+export class ByteaColumn extends NumberBaseColumn<string> {
+  dataType = 'bytea' as const;
+}
+
+// point	16 bytes	Point on a plane	(x,y)
+export class PointColumn extends ColumnType<string, typeof Operators.text> {
+  dataType = 'point' as const;
+  operators = Operators.text;
+}
+
+// line	32 bytes	Infinite line	{A,B,C}
+export class LineColumn extends ColumnType<string, typeof Operators.text> {
+  dataType = 'point' as const;
+  operators = Operators.text;
+}
+
+// lseg	32 bytes	Finite line segment	((x1,y1),(x2,y2))
+export class LsegColumn extends ColumnType<string, typeof Operators.text> {
+  dataType = 'point' as const;
+  operators = Operators.text;
+}
+
+// box	32 bytes	Rectangular box	((x1,y1),(x2,y2))
+export class BoxColumn extends ColumnType<string, typeof Operators.text> {
+  dataType = 'point' as const;
+  operators = Operators.text;
+}
+
+// path	16+16n bytes	Closed path (similar to polygon)	((x1,y1),...)
+// path	16+16n bytes	Open path	[(x1,y1),...]
+export class PathColumn extends ColumnType<string, typeof Operators.text> {
+  dataType = 'point' as const;
+  operators = Operators.text;
+}
+
+// polygon	40+16n bytes	Polygon (similar to closed path)	((x1,y1),...)
+export class PolygonColumn extends ColumnType<string, typeof Operators.text> {
+  dataType = 'point' as const;
+  operators = Operators.text;
+}
+
+// circle	24 bytes	Circle	<(x,y),r> (center point and radius)
+export class CircleColumn extends ColumnType<string, typeof Operators.text> {
+  dataType = 'point' as const;
+  operators = Operators.text;
+}
+
+export class MoneyColumn extends NumberBaseColumn<string> {
+  dataType = 'money' as const;
+}
+
+// cidr	7 or 19 bytes	IPv4 and IPv6 networks
+export class CidrColumn extends ColumnType<string, typeof Operators.text> {
+  dataType = 'cidr' as const;
+  operators = Operators.text;
+}
+
+// inet	7 or 19 bytes	IPv4 and IPv6 hosts and networks
+export class InetColumn extends ColumnType<string, typeof Operators.text> {
+  dataType = 'inet' as const;
+  operators = Operators.text;
+}
+
+// macaddr	6 bytes	MAC addresses
+export class MacAddrColumn extends ColumnType<string, typeof Operators.text> {
+  dataType = 'macaddr' as const;
+  operators = Operators.text;
+}
+
+// macaddr8	8 bytes	MAC addresses (EUI-64 format)
+export class MacAddr8Column extends ColumnType<string, typeof Operators.text> {
+  dataType = 'macaddr8' as const;
+  operators = Operators.text;
+}
+
+// Bit strings are strings of 1's and 0's.
+// They can be used to store or visualize bit masks.
+// There are two SQL bit types: bit(n) and bit varying(n), where n is a positive integer.
+export class BitColumn<
+  Length extends number | undefined = undefined,
+> extends ColumnType<string, typeof Operators.text> {
+  dataType = 'bit' as const;
+  operators = Operators.text;
+  data: { length: Length };
+
+  constructor(length?: Length) {
+    super();
+
+    this.data = { length } as { length: Length };
+  }
+
+  toSQL() {
+    return joinTruthy(
+      this.dataType,
+      this.data.length && `(${this.data.length})`,
+    );
+  }
+}
+
+export class BitVaryingColumn<
+  Length extends number | undefined = undefined,
+> extends ColumnType<string, typeof Operators.text> {
+  dataType = 'bit varying' as const;
+  operators = Operators.text;
+  data: { length: Length };
+
+  constructor(length?: Length) {
+    super();
+
+    this.data = { length } as { length: Length };
+  }
+
+  toSQL() {
+    return joinTruthy(
+      this.dataType,
+      this.data.length && `(${this.data.length})`,
+    );
+  }
+}
+
+// A tsvector value is a sorted list of distinct lexemes
+export class TsVectorColumn extends ColumnType<string, typeof Operators.text> {
+  dataType = 'tsvector' as const;
+  operators = Operators.text;
+}
+
+// A tsquery value stores lexemes that are to be searched for
+export class TsQueryColumn extends ColumnType<string, typeof Operators.text> {
+  dataType = 'tsquery' as const;
+  operators = Operators.text;
+}
+
+// A tsquery value stores lexemes that are to be searched for
+export class UUIDColumn extends ColumnType<string, typeof Operators.text> {
+  dataType = 'uuid' as const;
+  operators = Operators.text;
+}
+
+export class XMLColumn extends ColumnType<string, typeof Operators.text> {
+  dataType = 'uuid' as const;
+  operators = Operators.text;
+}

package/src/columnSchema/utils.ts

@@ -0,0 +1,27 @@
+export type EmptyObject = Record<never, never>;
+
+export const cloneInstance = <T>(instance: T): T => {
+  return Object.assign(
+    Object.create(Object.getPrototypeOf(instance)),
+    instance,
+  );
+};
+
+export const assignMethodsToClass = <Methods extends Record<string, unknown>>(
+  klass: { prototype: unknown },
+  methods: Methods,
+) => {
+  for (const name in methods) {
+    Object.defineProperty(klass.prototype, name, {
+      configurable: true,
+      enumerable: false,
+      writable: true,
+      value(...args: unknown[]) {
+        const cloned = cloneInstance(this);
+        return (
+          methods as unknown as Record<string, (...args: unknown[]) => unknown>
+        )[name].call(cloned, args);
+      },
+    });
+  }
+};