pqb 0.0.1

package/src/columnSchema/columnsSchema.ts

@@ -0,0 +1,100 @@
+import { ColumnInput, ColumnOutput, ColumnType } from './columnType';
+import { Operators } from '../operators';
+import { UnionToIntersection } from '../utils';
+
+export type ColumnsShape = Record<string, ColumnType>;
+
+export type ColumnShapeOutput<Shape extends ColumnsShape> = {
+  [K in keyof Shape]: ColumnOutput<Shape[K]>;
+};
+
+export type ColumnShapeInput<Shape extends ColumnsShape> = {
+  [K in keyof Shape]: ColumnInput<Shape[K]>;
+};
+
+export class ColumnsObject<Shape extends ColumnsShape> extends ColumnType<
+  { [K in keyof Shape]: Shape[K]['type'] },
+  typeof Operators.any
+> {
+  dataType = 'object';
+  operators = Operators.any;
+
+  constructor(public shape: Shape) {
+    super();
+  }
+}
+
+export class ArrayOfColumnsObjects<
+  Shape extends ColumnsShape,
+> extends ColumnType<
+  { [K in keyof Shape]: Shape[K]['type'] }[],
+  typeof Operators.any
+> {
+  dataType = 'array';
+  operators = Operators.any;
+
+  constructor(public shape: Shape) {
+    super();
+  }
+}
+
+type UnionKeyofToOvlds<S, U> = UnionToIntersection<
+  U extends keyof S ? (f: U) => void : never
+>;
+
+type PopKeyofColumnShapeUnion<
+  S extends ColumnsShape,
+  U extends keyof S,
+> = UnionKeyofToOvlds<S, U> extends (a: infer A extends keyof S) => void
+  ? A
+  : never;
+
+type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+
+export type UnionToArray<
+  S extends ColumnsShape,
+  T extends keyof S,
+  A extends [...(keyof S)[]] = [],
+> = IsUnion<T> extends true
+  ? UnionToArray<
+      S,
+      Exclude<T, PopKeyofColumnShapeUnion<S, T>>,
+      [PopKeyofColumnShapeUnion<S, T>, ...A]
+    >
+  : [T, ...A];
+
+type GetPrimaryKeys<S extends ColumnsShape> = UnionToArray<
+  S,
+  { [K in keyof S]: S[K] extends { isPrimaryKey: true } ? K : never }[keyof S]
+>;
+
+type GetPrimaryTypes<
+  S extends ColumnsShape,
+  Keys extends [...(keyof S | string)[]] = GetPrimaryKeys<S>,
+> = GetTypesFromKeys<S, Keys>;
+
+type GetTypesFromKeys<
+  S extends ColumnsShape,
+  T extends [...(keyof S)[]],
+> = T extends [
+  infer Head extends keyof S,
+  ...infer Tail extends [...(keyof S)[]],
+]
+  ? [GetTypeFromKey<S, Head>, ...GetTypesFromKeys<S, Tail>]
+  : [];
+
+type GetTypeFromKey<S extends ColumnsShape, T extends keyof S> = S[T]['type'];
+
+export class TableSchema<Shape extends ColumnsShape> {
+  primaryKeys: string extends keyof Shape ? string[] : GetPrimaryKeys<Shape>;
+  primaryTypes!: GetPrimaryTypes<Shape>;
+
+  constructor(public shape: Shape) {
+    this.primaryKeys = Object.entries(this.shape)
+      .filter(([, column]) => {
+        return column.isPrimaryKey;
+      })
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .map(([key]) => key) as any;
+  }
+}

package/src/columnSchema/commonMethods.ts

@@ -0,0 +1,130 @@
+import { BaseStringData } from './string';
+import { BaseNumberData } from './number';
+
+export type ArrayMethods = typeof arrayMethods;
+
+export const arrayMethods = {
+  min<T extends { data: { min?: number } }, Value extends number>(
+    this: T,
+    value: Value,
+  ) {
+    this.data.min = value;
+    return this as T & { data: Omit<T['data'], 'min'> & { min: Value } };
+  },
+
+  max<T extends { data: { max?: number } }, Value extends number>(
+    this: T,
+    value: Value,
+  ) {
+    this.data.max = value;
+    return this as T & { data: Omit<T['data'], 'max'> & { max: Value } };
+  },
+
+  length<T extends { data: { length?: number } }, Value extends number>(
+    this: T,
+    value: Value,
+  ) {
+    this.data.length = value;
+    return this as T & { data: Omit<T['data'], 'length'> & { length: Value } };
+  },
+};
+
+export const stringTypeMethods = <Base extends { data: BaseStringData }>() => ({
+  ...arrayMethods,
+
+  email<T extends Base>(this: T) {
+    this.data.email = true;
+    return this as T & { data: Omit<T['data'], 'email'> & { email: true } };
+  },
+
+  url<T extends Base>(this: T) {
+    this.data.url = true;
+    return this as T & { data: Omit<T['data'], 'url'> & { url: true } };
+  },
+
+  uuid<T extends Base>(this: T) {
+    this.data.uuid = true;
+    return this as T & { data: Omit<T['data'], 'uuid'> & { uuid: true } };
+  },
+
+  cuid<T extends Base>(this: T) {
+    this.data.cuid = true;
+    return this as T & { data: Omit<T['data'], 'cuid'> & { cuid: true } };
+  },
+
+  regex<T extends Base, Value extends RegExp>(this: T, value: Value) {
+    this.data.regex = value;
+    return this as T & { data: Omit<T['data'], 'regex'> & { regex: Value } };
+  },
+
+  trim<T extends Base>(this: T) {
+    this.data.trim = true;
+    return this as T & { data: Omit<T['data'], 'cuid'> & { trim: true } };
+  },
+});
+
+export const numberTypeMethods = <Base extends { data: BaseNumberData }>() => ({
+  lt<T extends Base, Value extends number>(this: T, value: Value) {
+    this.data.lt = value;
+    return this as T & { data: Omit<T['data'], 'lt'> & { lt: Value } };
+  },
+
+  lte<T extends Base, Value extends number>(this: T, value: Value) {
+    this.data.lte = value;
+    return this as T & { data: Omit<T['data'], 'lte'> & { lte: Value } };
+  },
+
+  max<T extends Base, Value extends number>(this: T, value: Value) {
+    this.data.lte = value;
+    return this as T & { data: Omit<T['data'], 'lte'> & { lte: Value } };
+  },
+
+  gt<T extends Base, Value extends number>(this: T, value: Value) {
+    this.data.gt = value;
+    return this as T & { data: Omit<T['data'], 'gt'> & { gt: Value } };
+  },
+
+  gte<T extends Base, Value extends number>(this: T, value: Value) {
+    this.data.gte = value;
+    return this as T & { data: Omit<T['data'], 'gte'> & { gte: Value } };
+  },
+
+  min<T extends Base, Value extends number>(this: T, value: Value) {
+    this.data.gte = value;
+    return this as T & { data: Omit<T['data'], 'gte'> & { gte: Value } };
+  },
+
+  positive<T extends Base>(this: T) {
+    this.data.gt = 0;
+    return this as T & { data: Omit<T['data'], 'gt'> & { gt: 0 } };
+  },
+
+  nonNegative<T extends Base>(this: T) {
+    this.data.gte = 0;
+    return this as T & { data: Omit<T['data'], 'gte'> & { gte: 0 } };
+  },
+
+  negative<T extends Base>(this: T) {
+    this.data.lt = 0;
+    return this as T & { data: Omit<T['data'], 'lt'> & { lt: 0 } };
+  },
+
+  nonPositive<T extends Base>(this: T) {
+    this.data.lte = 0;
+    return this as T & { data: Omit<T['data'], 'lte'> & { lte: 0 } };
+  },
+
+  multipleOf<T extends Base, Value extends number>(this: T, value: Value) {
+    this.data.multipleOf = value;
+    return this as T & {
+      data: Omit<T['data'], 'multipleOf'> & { multipleOf: Value };
+    };
+  },
+
+  step<T extends Base, Value extends number>(this: T, value: Value) {
+    this.data.multipleOf = value;
+    return this as T & {
+      data: Omit<T['data'], 'multipleOf'> & { multipleOf: Value };
+    };
+  },
+});

package/src/columnSchema/dateTime.ts

@@ -0,0 +1,104 @@
+import { ColumnType } from './columnType';
+import { Operators } from '../operators';
+import { joinTruthy } from '../utils';
+
+// date	4 bytes	date (no time of day)	4713 BC	5874897 AD	1 day
+export class DateColumn extends ColumnType<string, typeof Operators.date> {
+  dataType = 'date' as const;
+  operators = Operators.date;
+}
+
+export interface DateTimeColumnData {
+  precision?: number;
+}
+
+export abstract class DateTimeBaseClass<
+  Precision extends number | undefined = undefined,
+> extends ColumnType<string, typeof Operators.date, string | number | Date> {
+  data: DateTimeColumnData & { precision: Precision };
+  operators = Operators.date;
+
+  constructor(precision?: Precision) {
+    super();
+
+    this.data = { precision } as DateTimeColumnData & { precision: Precision };
+  }
+
+  toSQL() {
+    return joinTruthy(
+      this.dataType,
+      this.data.precision !== undefined && `(${this.data.precision})`,
+    );
+  }
+}
+
+export abstract class DateTimeWithTimeZoneBaseClass<
+  Precision extends number | undefined = undefined,
+> extends DateTimeBaseClass<Precision> {
+  abstract baseDataType: string;
+
+  toSQL() {
+    return joinTruthy(
+      this.baseDataType,
+      this.data.precision !== undefined && `(${this.data.precision})`,
+      ' with time zone',
+    );
+  }
+}
+
+// timestamp [ (p) ] [ without time zone ]	8 bytes	both date and time (no time zone)	4713 BC	294276 AD	1 microsecond
+export class TimestampColumn<
+  Precision extends number | undefined = undefined,
+> extends DateTimeBaseClass<Precision> {
+  dataType = 'timestamp' as const;
+}
+
+// timestamp [ (p) ] with time zone	8 bytes	both date and time, with time zone	4713 BC	294276 AD	1 microsecond
+export class TimestampWithTimeZoneColumn<
+  Precision extends number | undefined = undefined,
+> extends DateTimeWithTimeZoneBaseClass<Precision> {
+  dataType = 'timestamp with time zone' as const;
+  baseDataType = 'timestamp' as const;
+}
+
+// time [ (p) ] [ without time zone ]	8 bytes	time of day (no date)	00:00:00	24:00:00	1 microsecond
+export class TimeColumn<
+  Precision extends number | undefined = undefined,
+> extends DateTimeBaseClass<Precision> {
+  dataType = 'time' as const;
+}
+
+// time [ (p) ] with time zone	12 bytes	time of day (no date), with time zone	00:00:00+1559	24:00:00-1559	1 microsecond
+export class TimeWithTimeZoneColumn<
+  Precision extends number | undefined = undefined,
+> extends DateTimeWithTimeZoneBaseClass<Precision> {
+  dataType = 'time with time zone' as const;
+  baseDataType = 'time' as const;
+}
+
+// interval [ fields ] [ (p) ]	16 bytes	time interval	-178000000 years	178000000 years	1 microsecond
+export class IntervalColumn<
+  Fields extends string | undefined = undefined,
+  Precision extends number | undefined = undefined,
+> extends ColumnType<string, typeof Operators.date> {
+  dataType = 'interval' as const;
+  data: DateTimeColumnData & { fields: Fields; precision: Precision };
+  operators = Operators.date;
+
+  constructor(fields?: Fields, precision?: Precision) {
+    super();
+
+    this.data = { fields, precision } as DateTimeColumnData & {
+      fields: Fields;
+      precision: Precision;
+    };
+  }
+
+  toSQL() {
+    return joinTruthy(
+      this.dataType,
+      this.data.fields && ` ${this.data.fields}`,
+      this.data.precision !== undefined && ` (${this.data.precision})`,
+    );
+  }
+}

package/src/columnSchema/enum.ts

@@ -0,0 +1,13 @@
+import { ColumnType } from './columnType';
+import { Operators } from '../operators';
+
+export class EnumColumn<DataType extends string, Type> extends ColumnType<
+  Type,
+  typeof Operators.any
+> {
+  operators = Operators.any;
+
+  constructor(public dataType: DataType) {
+    super();
+  }
+}

package/src/columnSchema/index.ts

@@ -0,0 +1,11 @@
+export * from './columnType';
+export * from './columnTypes';
+export * from './columnsSchema';
+export * as columnUtils from './utils';
+export * from './number';
+export * from './string';
+export * from './dateTime';
+export * from './boolean';
+export * from './enum';
+export * from './json';
+export * from './array';

package/src/columnSchema/json/array.ts

@@ -0,0 +1,55 @@
+import {
+  constructType,
+  DeepPartial,
+  JSONType,
+  JSONTypeAny,
+  JSONTypeData,
+} from './typeBase';
+import { arrayMethods, ArrayMethods } from '../commonMethods';
+
+export type ArrayCardinality = 'many' | 'atLeastOne';
+
+type arrayOutputType<
+  T extends JSONTypeAny,
+  Cardinality extends ArrayCardinality = 'many',
+> = Cardinality extends 'atLeastOne'
+  ? [T['type'], ...T['type'][]]
+  : T['type'][];
+
+export interface JSONArray<
+  Type extends JSONTypeAny,
+  Cardinality extends ArrayCardinality = 'many',
+> extends JSONType<arrayOutputType<Type, Cardinality>, 'array'>,
+    ArrayMethods {
+  data: JSONTypeData & {
+    min?: number;
+    max?: number;
+    length?: number;
+  };
+  element: Type;
+  deepPartial(): JSONArray<DeepPartial<Type>, Cardinality>;
+  nonEmpty(
+    this: JSONArray<Type>,
+  ): JSONArray<Type, 'atLeastOne'> & { data: { min: 1 } };
+}
+
+export const array = <Type extends JSONTypeAny>(
+  element: Type,
+): JSONArray<Type> => {
+  return constructType<JSONArray<Type>>({
+    dataType: 'array' as const,
+    element,
+    deepPartial(this: JSONArray<Type>) {
+      return {
+        ...this,
+        element: this.element.deepPartial(),
+      };
+    },
+    nonEmpty(this: JSONArray<Type>) {
+      return this.min(1) as unknown as JSONArray<Type, 'atLeastOne'> & {
+        data: { min: 1 };
+      };
+    },
+    ...arrayMethods,
+  });
+};

package/src/columnSchema/json/discriminatedUnion.ts

@@ -0,0 +1,91 @@
+import { constructType, JSONType, Primitive } from './typeBase';
+import { JSONObject } from './object';
+import { JSONLiteral } from './literal';
+
+export interface JSONDiscriminatedUnion<
+  Discriminator extends string,
+  Options extends DiscriminatedOptions<Discriminator>,
+> extends JSONType<Options[number]['type'], 'discriminatedUnion'> {
+  discriminator: Discriminator;
+  options: OptionsMap<Discriminator, Options>;
+  // TODO: gave up on deepPartial type
+  // deepPartial(): JSONDiscriminatedUnion<
+  //   Discriminator,
+  //   {
+  //     [Index in keyof Options]: {
+  //       [K in keyof Options[Index]['shape']]: K extends Discriminator
+  //         ? Options[Index]['shape'][K]
+  //         : JSONOptional<Options[Index]['shape'][K]>;
+  //     } extends JSONObject<Record<Discriminator, JSONLiteral<Primitive>>>
+  //       ? JSONObject<
+  //           {
+  //             [K in keyof Options[Index]['shape']]: K extends Discriminator
+  //               ? Options[Index]['shape'][K]
+  //               : JSONOptional<Options[Index]['shape'][K]>;
+  //           },
+  //           Options[Index]['unknownKeys'],
+  //           Options[Index]['catchAllType']
+  //         >
+  //       : Options[Index];
+  //   } & {
+  //     length: Options['length'];
+  //   }
+  // >;
+}
+
+type JSONDiscriminatedObject<Discriminator extends string> = JSONObject<
+  Record<Discriminator, JSONLiteral<Primitive>>
+>;
+
+type DiscriminatedOptions<Discriminator extends string> = readonly [
+  JSONDiscriminatedObject<Discriminator>,
+  JSONDiscriminatedObject<Discriminator>,
+  ...JSONDiscriminatedObject<Discriminator>[],
+];
+
+type OptionsMap<
+  Discriminator extends string,
+  Options extends DiscriminatedOptions<Discriminator>,
+> = Map<Options[number]['shape'][Discriminator]['value'], Options[number]>;
+
+export const discriminatedUnion = <
+  Discriminator extends string,
+  Options extends DiscriminatedOptions<Discriminator>,
+>(
+  discriminator: Discriminator,
+  options: Options,
+) => {
+  const optionsMap: OptionsMap<
+    Discriminator,
+    DiscriminatedOptions<Discriminator>
+  > = new Map();
+
+  options.forEach((option) => {
+    const discriminatorValue = option.shape[discriminator].value;
+    optionsMap.set(discriminatorValue, option);
+  });
+
+  return constructType<JSONDiscriminatedUnion<Discriminator, Options>>({
+    dataType: 'discriminatedUnion',
+    discriminator,
+    options: optionsMap,
+    deepPartial(this: JSONDiscriminatedUnion<Discriminator, Options>) {
+      const newOptionsMap: OptionsMap<
+        Discriminator,
+        DiscriminatedOptions<Discriminator>
+      > = new Map();
+
+      optionsMap.forEach((option, key) => {
+        const partial =
+          option.deepPartial() as unknown as JSONDiscriminatedObject<Discriminator>;
+        partial.shape[discriminator] = option.shape[discriminator];
+        newOptionsMap.set(key, partial);
+      });
+
+      return {
+        ...this,
+        options: newOptionsMap,
+      };
+    },
+  });
+};

package/src/columnSchema/json/enum.ts

@@ -0,0 +1,29 @@
+import { constructType, JSONType } from './typeBase';
+
+export interface JSONEnum<T extends EnumValues>
+  extends JSONType<T[number], 'enum'> {
+  enum: { [k in T[number]]: k };
+  options: T;
+}
+
+type EnumValues = readonly [string, ...string[]];
+
+export const arrayToEnum = <T extends string, U extends readonly [T, ...T[]]>(
+  items: U,
+) => {
+  const obj = {} as { [k in U[number]]: k };
+  for (const item of items) {
+    obj[item] = item;
+  }
+  return obj;
+};
+
+export const enumType = <T extends readonly [string, ...string[]]>(
+  options: T,
+) => {
+  return constructType<JSONEnum<T>>({
+    dataType: 'enum',
+    enum: arrayToEnum(options),
+    options,
+  });
+};

package/src/columnSchema/json/instanceOf.ts

@@ -0,0 +1,16 @@
+import { constructType, JSONType } from './typeBase';
+
+export interface JSONInstanceOf<T extends Class>
+  extends JSONType<T, 'instanceOf'> {
+  class: T;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Class = new (...args: any[]) => any;
+
+export const instanceOf = <T extends Class>(cls: T) => {
+  return constructType<JSONInstanceOf<T>>({
+    dataType: 'instanceOf',
+    class: cls,
+  });
+};

package/src/columnSchema/json/intersection.ts

@@ -0,0 +1,23 @@
+import { constructType, JSONType, JSONTypeAny } from './typeBase';
+
+export type JSONIntersection<
+  Left extends JSONTypeAny,
+  Right extends JSONTypeAny,
+> = JSONType<Left['type'] & Right['type'], 'intersection'> & {
+  left: Left;
+  right: Right;
+};
+
+export const intersection = <
+  Left extends JSONTypeAny,
+  Right extends JSONTypeAny,
+>(
+  left: Left,
+  right: Right,
+) => {
+  return constructType<JSONIntersection<Left, Right>>({
+    dataType: 'intersection',
+    left,
+    right,
+  });
+};

package/src/columnSchema/json/lazy.ts

@@ -0,0 +1,22 @@
+import { constructType, JSONType, JSONTypeAny } from './typeBase';
+
+export interface JSONLazy<T extends JSONTypeAny>
+  extends JSONType<T['type'], 'lazy'> {
+  typeCache?: T;
+  getter(): T;
+  deepPartial(): JSONLazy<ReturnType<T['deepPartial']>>;
+}
+
+export const lazy = <T extends JSONTypeAny>(fn: () => T) => {
+  constructType<JSONLazy<T>>({
+    dataType: 'lazy',
+    getter: fn,
+    deepPartial(this: JSONLazy<T>) {
+      return {
+        ...this,
+        typeCache: undefined,
+        getter: () => this.getter().deepPartial(),
+      };
+    },
+  });
+};

package/src/columnSchema/json/literal.ts

@@ -0,0 +1,12 @@
+import { constructType, JSONType, Primitive } from './typeBase';
+
+export interface JSONLiteral<T extends Primitive>
+  extends JSONType<T, 'literal'> {
+  value: Primitive;
+}
+
+export const literal = <T extends Primitive>(value: T) =>
+  constructType<JSONLiteral<T>>({
+    dataType: 'literal',
+    value,
+  });

package/src/columnSchema/json/map.ts

@@ -0,0 +1,29 @@
+import { constructType, JSONType, JSONTypeAny } from './typeBase';
+
+export interface JSONMap<Key extends JSONTypeAny, Value extends JSONTypeAny>
+  extends JSONType<Map<Key['type'], Value['type']>, 'map'> {
+  keyType: Key;
+  valueType: Value;
+  deepPartial(): JSONMap<
+    ReturnType<Key['deepPartial']>,
+    ReturnType<Value['deepPartial']>
+  >;
+}
+
+export const map = <Key extends JSONTypeAny, Value extends JSONTypeAny>(
+  keyType: Key,
+  valueType: Value,
+) => {
+  return constructType<JSONMap<Key, Value>>({
+    dataType: 'map',
+    keyType: keyType,
+    valueType: valueType,
+    deepPartial(this: JSONMap<Key, Value>) {
+      return {
+        ...this,
+        keyType: this.keyType.deepPartial(),
+        valueType: this.valueType.deepPartial(),
+      };
+    },
+  });
+};

package/src/columnSchema/json/nativeEnum.ts

@@ -0,0 +1,30 @@
+import { constructType, JSONType } from './typeBase';
+
+export interface JSONNativeEnum<T extends EnumLike>
+  extends JSONType<T[keyof T], 'nativeEnum'> {
+  dataType: 'nativeEnum';
+  enum: T;
+  options: (number | string)[];
+}
+
+type EnumLike = { [k: string]: string | number; [nu: number]: string };
+
+export const getValidEnumValues = (obj: EnumLike) => {
+  const values: (number | string)[] = [];
+  Object.keys(obj).forEach((k) => {
+    if (typeof obj[obj[k]] !== 'number' && !values.includes(obj[k])) {
+      values.push(obj[k]);
+    }
+  });
+  return values;
+};
+
+export const nativeEnum = <T extends EnumLike>(givenEnum: T) => {
+  const options = getValidEnumValues(givenEnum);
+
+  return constructType<JSONNativeEnum<T>>({
+    dataType: 'nativeEnum',
+    enum: givenEnum,
+    options,
+  });
+};