pqb 0.0.1 → 0.0.3

package/src/columnSchema/columnTypes.ts

@@ -1,7 +1,6 @@
 import {
   BigIntColumn,
   BigSerialColumn,
-  DecimalBigIntColumn,
   DecimalColumn,
   DoublePrecisionColumn,
   IntegerColumn,
@@ -47,10 +46,58 @@ import { EnumColumn } from './enum';
 import { JSONColumn, JSONTextColumn, JSONTypes } from './json';
 import { JSONTypeAny } from './json/typeBase';
 import { ArrayColumn } from './array';
-import { ColumnType } from './columnType';
+import {
+  ColumnNameOfModel,
+  ColumnType,
+  ColumnTypesBase,
+  ForeignKeyModel,
+  IndexColumnOptions,
+  IndexOptions,
+  ForeignKeyOptions,
+  ForeignKeyModelWithColumns,
+} from './columnType';
+import { emptyObject, EmptyObject, MaybeArray, toArray } from '../utils';
+import { ColumnsShape } from './columnsSchema';
+import { raw } from '../common';
 
 export type ColumnTypes = typeof columnTypes;
 
+export type TableData = {
+  primaryKey?: { columns: string[]; options?: { name?: string } };
+  indexes: { columns: IndexColumnOptions[]; options: IndexOptions }[];
+  foreignKeys: {
+    columns: string[];
+    fnOrTable: (() => ForeignKeyModel) | string;
+    foreignColumns: string[];
+    options: ForeignKeyOptions;
+  }[];
+};
+
+export const newTableData = (): TableData => ({
+  indexes: [],
+  foreignKeys: [],
+});
+
+let tableData: TableData = newTableData();
+
+export const getTableData = () => tableData;
+
+export const resetTableData = (data: TableData = newTableData()) => {
+  tableData = data;
+};
+
+export const getColumnTypes = <
+  CT extends ColumnTypesBase,
+  Shape extends ColumnsShape,
+>(
+  types: CT,
+  fn: (t: CT) => Shape,
+  data: TableData = newTableData(),
+) => {
+  resetTableData(data);
+  return fn(types);
+};
+
 export const columnTypes = {
   smallint: () => new SmallIntColumn(),
   integer: () => new IntegerColumn(),
@@ -62,13 +109,6 @@ export const columnTypes = {
     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,
@@ -76,24 +116,18 @@ export const columnTypes = {
     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(),
+  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(),
+  string: () => new TextColumn(),
   bytea: () => new ByteaColumn(),
   date: () => new DateColumn(),
   timestamp: <Precision extends number | undefined = undefined>(
@@ -116,8 +150,8 @@ export const columnTypes = {
     precision?: Precision,
   ) => new IntervalColumn(fields, precision),
   boolean: () => new BooleanColumn(),
-  enum: <DataType extends string, Type>(dataType: DataType) =>
-    new EnumColumn<DataType, Type>(dataType),
+  enum: <U extends string, T extends [U, ...U[]]>(dataType: string, type: T) =>
+    new EnumColumn<U, T>(dataType, type),
   point: () => new PointColumn(),
   line: () => new LineColumn(),
   lseg: () => new LsegColumn(),
@@ -125,14 +159,14 @@ export const columnTypes = {
   path: () => new PathColumn(),
   polygon: () => new PolygonColumn(),
   circle: () => new CircleColumn(),
-  cidr() {
-    return new CidrColumn();
-  },
+  cidr: () => new CidrColumn(),
   inet: () => new InetColumn(),
   macaddr: () => new MacAddrColumn(),
   macaddr8: () => new MacAddr8Column(),
-  bit: () => new BitColumn(),
-  bitVarying: () => new BitVaryingColumn(),
+  bit: <Length extends number>(length: Length) => new BitColumn(length),
+  bitVarying: <Length extends number | undefined = undefined>(
+    length?: Length,
+  ) => new BitVaryingColumn(length),
   tsvector: () => new TsVectorColumn(),
   tsquery: () => new TsQueryColumn(),
   uuid: () => new UUIDColumn(),
@@ -142,4 +176,82 @@ export const columnTypes = {
   ) => new JSONColumn(schemaOrFn),
   jsonText: () => new JSONTextColumn(),
   array: <Item extends ColumnType>(item: Item) => new ArrayColumn(item),
+
+  timestamps: () => ({
+    createdAt: new TimestampColumn().default(raw('now()')),
+    updatedAt: new TimestampColumn().default(raw('now()')),
+  }),
+
+  primaryKey(columns: string[], options?: { name?: string }) {
+    tableData.primaryKey = { columns, options };
+    return emptyObject;
+  },
+
+  index(
+    columns: MaybeArray<string | IndexColumnOptions>,
+    options: IndexOptions = {},
+  ) {
+    const index = {
+      columns: toArray(columns).map((column) =>
+        typeof column === 'string' ? { column } : column,
+      ),
+      options,
+    };
+
+    tableData.indexes.push(index);
+    return emptyObject;
+  },
+
+  unique(
+    columns: MaybeArray<string | IndexColumnOptions>,
+    options: IndexOptions = {},
+  ) {
+    const index = {
+      columns: toArray(columns).map((column) =>
+        typeof column === 'string' ? { column } : column,
+      ),
+      options: { ...options, unique: true },
+    };
+
+    tableData.indexes.push(index);
+
+    return emptyObject;
+  },
+
+  foreignKey,
 };
+
+function foreignKey<
+  Model extends ForeignKeyModelWithColumns,
+  Columns extends [ColumnNameOfModel<Model>, ...ColumnNameOfModel<Model>[]],
+>(
+  columns: string[],
+  fn: () => Model,
+  foreignColumns: Columns,
+  options?: ForeignKeyOptions,
+): EmptyObject;
+function foreignKey<
+  Table extends string,
+  Columns extends [string, ...string[]],
+>(
+  columns: string[],
+  table: Table,
+  foreignColumns: Columns,
+  options?: ForeignKeyOptions,
+): EmptyObject;
+function foreignKey(
+  columns: string[],
+  fnOrTable: (() => ForeignKeyModel) | string,
+  foreignColumns: string[],
+  options: ForeignKeyOptions = {},
+) {
+  const foreignKey = {
+    columns,
+    fnOrTable,
+    foreignColumns,
+    options,
+  };
+
+  tableData.foreignKeys.push(foreignKey);
+  return emptyObject;
+}

package/src/columnSchema/columnsSchema.ts

@@ -1,5 +1,5 @@
 import { ColumnInput, ColumnOutput, ColumnType } from './columnType';
-import { Operators } from '../operators';
+import { Operators } from '../columnsOperators';
 import { UnionToIntersection } from '../utils';
 
 export type ColumnsShape = Record<string, ColumnType>;

package/src/columnSchema/commonMethods.ts

@@ -1,130 +1,212 @@
-import { BaseStringData } from './string';
-import { BaseNumberData } from './number';
+export const setDataValue = <
+  T extends { data: object },
+  Key extends string,
+  Value,
+>(
+  item: T,
+  key: Key,
+  value: Value,
+) => {
+  const cloned = Object.create(item);
+  cloned.data = { ...item.data, [key]: value };
+  return cloned as Omit<T, 'data'> & {
+    data: Omit<T['data'], Key> & { [K in Key]: Value };
+  };
+};
+
+function min<T extends { data: { min?: number } }, Value extends number>(
+  this: T,
+  value: Value,
+) {
+  return setDataValue(this, 'min', value);
+}
+
+function max<T extends { data: { max?: number } }, Value extends number>(
+  this: T,
+  value: Value,
+) {
+  return setDataValue(this, 'max', value);
+}
+
+function length<T extends { data: { length?: number } }, Value extends number>(
+  this: T,
+  value: Value,
+) {
+  return setDataValue(this, 'length', value);
+}
+
+function size<T extends { data: { size?: number } }, Value extends number>(
+  this: T,
+  value: Value,
+) {
+  return setDataValue(this, 'size', value);
+}
+
+function nonempty<T extends { data: { min?: number } }>(this: T) {
+  return setDataValue(this, 'min', 1);
+}
 
 export type ArrayMethods = typeof arrayMethods;
 
 export const arrayMethods = {
-  min<T extends { data: { min?: number } }, Value extends number>(
+  min,
+  max,
+  length,
+  nonempty,
+};
+
+export type SetMethods = typeof setMethods;
+
+export const setMethods = {
+  min,
+  max,
+  size,
+  nonempty,
+};
+
+export const stringTypeMethods = () => ({
+  ...arrayMethods,
+
+  email<T extends { data: { email?: boolean } }>(this: T) {
+    return setDataValue(this, 'email', true);
+  },
+
+  url<T extends { data: { url?: boolean } }>(this: T) {
+    return setDataValue(this, 'url', true);
+  },
+
+  uuid<T extends { data: { uuid?: boolean } }>(this: T) {
+    return setDataValue(this, 'uuid', true);
+  },
+
+  cuid<T extends { data: { cuid?: boolean } }>(this: T) {
+    return setDataValue(this, 'cuid', true);
+  },
+
+  regex<T extends { data: { regex?: RegExp } }, Value extends RegExp>(
     this: T,
     value: Value,
   ) {
-    this.data.min = value;
-    return this as T & { data: Omit<T['data'], 'min'> & { min: Value } };
+    return setDataValue(this, 'regex', value);
   },
 
-  max<T extends { data: { max?: number } }, Value extends number>(
+  startsWith<T extends { data: { startsWith?: string } }, Value extends string>(
     this: T,
     value: Value,
   ) {
-    this.data.max = value;
-    return this as T & { data: Omit<T['data'], 'max'> & { max: Value } };
+    return setDataValue(this, 'startsWith', value);
   },
 
-  length<T extends { data: { length?: number } }, Value extends number>(
+  endsWith<T extends { data: { endsWith?: string } }, Value extends string>(
     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 } };
+    return setDataValue(this, 'endsWith', value);
   },
 
-  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 } };
+  trim<T extends { data: { trim?: boolean } }>(this: T) {
+    return setDataValue(this, 'trim', true);
   },
+});
 
-  cuid<T extends Base>(this: T) {
-    this.data.cuid = true;
-    return this as T & { data: Omit<T['data'], 'cuid'> & { cuid: true } };
+export const numberTypeMethods = {
+  lt<T extends { data: { lt?: number } }, Value extends number>(
+    this: T,
+    value: Value,
+  ) {
+    return setDataValue(this, 'lt', value);
   },
 
-  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 } };
+  lte<T extends { data: { lte?: number } }, Value extends number>(
+    this: T,
+    value: Value,
+  ) {
+    return setDataValue(this, 'lte', value);
   },
 
-  trim<T extends Base>(this: T) {
-    this.data.trim = true;
-    return this as T & { data: Omit<T['data'], 'cuid'> & { trim: true } };
+  max<T extends { data: { lte?: number } }, Value extends number>(
+    this: T,
+    value: Value,
+  ) {
+    return setDataValue(this, 'lte', value);
   },
-});
 
-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 } };
+  gt<T extends { data: { gt?: number } }, Value extends number>(
+    this: T,
+    value: Value,
+  ) {
+    return setDataValue(this, 'gt', 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 } };
+  gte<T extends { data: { gte?: number } }, Value extends number>(
+    this: T,
+    value: Value,
+  ) {
+    return setDataValue(this, 'gte', 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 } };
+  min<T extends { data: { gte?: number } }, Value extends number>(
+    this: T,
+    value: Value,
+  ) {
+    return setDataValue(this, 'gte', 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 } };
+  positive<T extends { data: { gt?: number } }>(this: T) {
+    return setDataValue(this, 'gt', 0);
   },
 
-  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 } };
+  nonNegative<T extends { data: { gte?: number } }>(this: T) {
+    return setDataValue(this, 'gte', 0);
   },
 
-  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 } };
+  negative<T extends { data: { lt?: number } }>(this: T) {
+    return setDataValue(this, 'lt', 0);
   },
 
-  positive<T extends Base>(this: T) {
-    this.data.gt = 0;
-    return this as T & { data: Omit<T['data'], 'gt'> & { gt: 0 } };
+  nonPositive<T extends { data: { lte?: number } }>(this: T) {
+    return setDataValue(this, 'lte', 0);
   },
 
-  nonNegative<T extends Base>(this: T) {
-    this.data.gte = 0;
-    return this as T & { data: Omit<T['data'], 'gte'> & { gte: 0 } };
+  multipleOf<T extends { data: { multipleOf?: number } }, Value extends number>(
+    this: T,
+    value: Value,
+  ) {
+    return setDataValue(
+      this,
+      'multipleOf',
+      Array.isArray(value) ? value[0] : value,
+    );
   },
 
-  negative<T extends Base>(this: T) {
-    this.data.lt = 0;
-    return this as T & { data: Omit<T['data'], 'lt'> & { lt: 0 } };
+  step<T extends { data: { multipleOf?: number } }, Value extends number>(
+    this: T,
+    value: Value,
+  ) {
+    return setDataValue(
+      this,
+      'multipleOf',
+      Array.isArray(value) ? value[0] : value,
+    );
   },
 
-  nonPositive<T extends Base>(this: T) {
-    this.data.lte = 0;
-    return this as T & { data: Omit<T['data'], 'lte'> & { lte: 0 } };
+  int<T extends { data: { int?: boolean } }>(this: T) {
+    return setDataValue(this, 'int', true);
   },
+};
 
-  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 };
-    };
+export const dateTypeMethods = {
+  min<T extends { data: { min?: Date } }, Value extends Date>(
+    this: T,
+    value: Value,
+  ) {
+    return setDataValue(this, 'min', Array.isArray(value) ? value[0] : 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 };
-    };
+  max<T extends { data: { max?: Date } }, Value extends Date>(
+    this: T,
+    value: Value,
+  ) {
+    return setDataValue(this, 'max', Array.isArray(value) ? value[0] : value);
   },
-});
+};

package/src/columnSchema/dateTime.ts

@@ -1,22 +1,44 @@
-import { ColumnType } from './columnType';
-import { Operators } from '../operators';
+import { ColumnData, ColumnType } from './columnType';
+import { Operators } from '../columnsOperators';
 import { joinTruthy } from '../utils';
+import { dateTypeMethods } from './commonMethods';
+import { assignMethodsToClass } from './utils';
+
+export type DateColumnData = ColumnData & {
+  min?: Date;
+  max?: Date;
+};
+
+type DateMethods = typeof dateTypeMethods;
+
+export interface DateBaseColumn
+  extends ColumnType<string, typeof Operators.date, string | Date>,
+    DateMethods {}
+
+export abstract class DateBaseColumn extends ColumnType<
+  string,
+  typeof Operators.date,
+  string | Date
+> {
+  data = {} as DateColumnData;
+  operators = Operators.date;
+}
 
-// date	4 bytes	date (no time of day)	4713 BC	5874897 AD	1 day
-export class DateColumn extends ColumnType<string, typeof Operators.date> {
+assignMethodsToClass(DateBaseColumn, dateTypeMethods);
+
+// date	4 bytes	date (no time of day)	4713 BC	5874897 AD 1 day
+export class DateColumn extends DateBaseColumn {
   dataType = 'date' as const;
-  operators = Operators.date;
 }
 
-export interface DateTimeColumnData {
+export type DateTimeColumnData = DateColumnData & {
   precision?: number;
-}
+};
 
 export abstract class DateTimeBaseClass<
   Precision extends number | undefined = undefined,
-> extends ColumnType<string, typeof Operators.date, string | number | Date> {
+> extends DateBaseColumn {
   data: DateTimeColumnData & { precision: Precision };
-  operators = Operators.date;
 
   constructor(precision?: Precision) {
     super();
@@ -76,11 +98,20 @@ export class TimeWithTimeZoneColumn<
   baseDataType = 'time' as const;
 }
 
+export type TimeInterval = {
+  years?: number;
+  months?: number;
+  days?: number;
+  hours?: number;
+  minutes?: number;
+  seconds?: number;
+};
+
 // 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> {
+> extends ColumnType<TimeInterval, typeof Operators.date> {
   dataType = 'interval' as const;
   data: DateTimeColumnData & { fields: Fields; precision: Precision };
   operators = Operators.date;

package/src/columnSchema/enum.ts

@@ -1,13 +1,18 @@
 import { ColumnType } from './columnType';
-import { Operators } from '../operators';
+import { Operators } from '../columnsOperators';
 
-export class EnumColumn<DataType extends string, Type> extends ColumnType<
-  Type,
-  typeof Operators.any
-> {
+export class EnumColumn<
+  U extends string = string,
+  T extends [U, ...U[]] = [U],
+> extends ColumnType<T[number], typeof Operators.any> {
   operators = Operators.any;
+  dataType = 'enum';
 
-  constructor(public dataType: DataType) {
+  constructor(public enumName: string, public options: T) {
     super();
   }
+
+  toSql() {
+    return this.enumName;
+  }
 }