pqb 0.7.13 → 0.8.1

package/src/columnSchema/columnType.ts

@@ -1,8 +1,8 @@
 import { Operator, Operators } from '../columnsOperators';
-import { JSONTypeAny } from './json/typeBase';
+import { JSONTypeAny } from './json';
 import { ColumnsShape } from './columnsSchema';
 import { RawExpression, StringKey } from '../common';
-import { MaybeArray } from '../utils';
+import { MaybeArray, singleQuote, toArray } from '../utils';
 import { Query } from '../query';
 
 export type ColumnOutput<T extends ColumnType> = T['type'];
@@ -100,17 +100,17 @@ export type IndexOptions = {
 
 export type SingleColumnIndexOptions = IndexColumnOptions & IndexOptions;
 
-export type ForeignKeyModel = new () => {
+export type ForeignKeyTable = new () => {
   table: string;
 };
 
-export type ForeignKeyModelWithColumns = new () => {
+export type ForeignKeyTableWithColumns = new () => {
   table: string;
   columns: { shape: ColumnsShape };
 };
 
-export type ColumnNameOfModel<Model extends ForeignKeyModelWithColumns> =
-  StringKey<keyof InstanceType<Model>['columns']['shape']>;
+export type ColumnNameOfTable<Table extends ForeignKeyTableWithColumns> =
+  StringKey<keyof InstanceType<Table>['columns']['shape']>;
 
 const addColumnData = <T extends ColumnType, K extends keyof ColumnData>(
   q: T,
@@ -122,6 +122,177 @@ const addColumnData = <T extends ColumnType, K extends keyof ColumnData>(
   return cloned;
 };
 
+export type Code = string | Code[];
+
+export const columnChainToCode = (
+  chain: ColumnChain,
+  t: string,
+  code: Code,
+  append: Code,
+): Code => {
+  const result = toArray(code) as Code[];
+  if (typeof append === 'string') {
+    if (append) {
+      if (result.length === 1 && typeof result[0] === 'string') {
+        result[0] += append;
+      } else {
+        result.push(append);
+      }
+    }
+  } else {
+    if (append.length) result.push(...append);
+  }
+
+  for (const item of chain) {
+    if (item[0] === 'transform') {
+      result.push(`.transform(${item[1].toString()})`);
+    } else if (item[0] === 'to') {
+      const type = toArray(item[2].toCode(t));
+      result.push(`.to(${item[1].toString()}, `, ...type, ')');
+    } else if (item[0] === 'refine') {
+      result.push(`.refine(${item[1].toString()})`);
+    } else if (item[0] === 'superRefine') {
+      result.push(`.superRefine(${item[1].toString()})`);
+    }
+  }
+
+  return result.length === 1 && typeof result[0] === 'string'
+    ? result[0]
+    : result;
+};
+
+export const columnCode = (type: ColumnType, t: string, code: Code): Code => {
+  const append: Code[] = [];
+
+  const { foreignKey, index, validationDefault } = type.data;
+
+  if (type.isPrimaryKey) append.push('.primaryKey()');
+
+  if (foreignKey) {
+    append.push(`.foreignKey(`);
+    if ('fn' in foreignKey) {
+      append.push(foreignKey.fn.toString());
+    } else {
+      append.push(singleQuote(foreignKey.table));
+    }
+    append.push(`, ${singleQuote(foreignKey.columns[0])}`);
+
+    const hasOptions =
+      foreignKey.name ||
+      foreignKey.match ||
+      foreignKey.onUpdate ||
+      foreignKey.onDelete;
+
+    if (hasOptions) {
+      const arr: string[] = [];
+
+      if (foreignKey.name) arr.push(`name: ${singleQuote(foreignKey.name)},`);
+      if (foreignKey.match)
+        arr.push(`match: ${singleQuote(foreignKey.match)},`);
+      if (foreignKey.onUpdate)
+        arr.push(`onUpdate: ${singleQuote(foreignKey.onUpdate)},`);
+      if (foreignKey.onDelete)
+        arr.push(`onDelete: ${singleQuote(foreignKey.onDelete)},`);
+
+      append.push(', {', arr, '}');
+    }
+
+    append.push(')');
+  }
+
+  if (type.isHidden) append.push('.hidden()');
+
+  if (type.isNullable) append.push('.nullable()');
+
+  if ('isNonEmpty' in type.data) append.push('.nonEmpty()');
+
+  if (type.encodeFn) append.push(`.encode(${type.encodeFn.toString()})`);
+
+  if (type.parseFn && !('hideFromCode' in type.parseFn))
+    append.push(`.parse(${type.parseFn.toString()})`);
+
+  if (type.data.as) append.push(`.as(${type.data.as.toCode(t)})`);
+
+  if (type.data.default)
+    append.push(`.default(${JSON.stringify(type.data.default)})`);
+
+  if (index) {
+    append.push(`.${index.unique ? 'unique' : 'index'}(`);
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    for (const key in index) {
+      if (key === 'unique') continue;
+
+      const arr: string[] = [];
+
+      if (index.expression)
+        arr.push(
+          `expression: ${
+            typeof index.expression === 'string'
+              ? singleQuote(index.expression)
+              : index.expression
+          },`,
+        );
+      if (index.collate) arr.push(`collate: ${singleQuote(index.collate)},`);
+      if (index.operator) arr.push(`operator: ${singleQuote(index.operator)},`);
+      if (index.order) arr.push(`order: ${singleQuote(index.order)},`);
+      if (index.name) arr.push(`name: ${singleQuote(index.name)},`);
+      if (index.unique) arr.push(`unique: true,`);
+      if (index.using) arr.push(`using: ${singleQuote(index.using)},`);
+      if (index.include)
+        arr.push(
+          `include: ${
+            typeof index.include === 'string'
+              ? singleQuote(index.include)
+              : `[${index.include.map(singleQuote).join(', ')}]`
+          },`,
+        );
+      if (index.with) arr.push(`with: ${singleQuote(index.with)},`);
+      if (index.tablespace)
+        arr.push(`tablespace: ${singleQuote(index.tablespace)},`);
+      if (index.where) arr.push(`where: ${singleQuote(index.where)},`);
+
+      append.push('{', arr, '}');
+      break;
+    }
+
+    append.push(')');
+  }
+
+  if (type.data.comment)
+    append.push(`.comment(${singleQuote(type.data.comment)})`);
+
+  if (validationDefault) {
+    append.push(
+      `.validationDefault(${
+        typeof validationDefault === 'function'
+          ? validationDefault.toString()
+          : typeof validationDefault === 'string'
+          ? singleQuote(validationDefault)
+          : JSON.stringify(validationDefault)
+      })`,
+    );
+  }
+
+  if (type.data.compression)
+    append.push(`.compression(${singleQuote(type.data.compression)})`);
+
+  if (type.data.collate)
+    append.push(`.collate(${singleQuote(type.data.collate)})`);
+
+  if (type.data.modifyQuery)
+    append.push(`.modifyQuery(${type.data.modifyQuery.toString()})`);
+
+  return columnChainToCode(type.chain, t, code, append);
+};
+
+export type ColumnChain = (
+  | ['transform', (input: unknown, ctx: ValidationContext) => unknown]
+  | ['to', (input: unknown) => JSONTypeAny | undefined, JSONTypeAny]
+  | ['refine', (input: unknown) => unknown]
+  | ['superRefine', (input: unknown, ctx: ValidationContext) => unknown]
+)[];
+
 export abstract class ColumnType<
   Type = unknown,
   Ops extends Operators = Operators,
@@ -129,6 +300,7 @@ export abstract class ColumnType<
 > {
   abstract dataType: string;
   abstract operators: Ops;
+  abstract toCode(t: string): Code;
 
   type!: Type;
   inputType!: InputType;
@@ -144,28 +316,24 @@ export abstract class ColumnType<
   // 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]
-  )[];
+  chain = [] as ColumnChain;
 
   primaryKey<T extends ColumnType>(this: T): T & { isPrimaryKey: true } {
-    return Object.assign(this, { isPrimaryKey: true as const });
+    const cloned = Object.create(this);
+    return Object.assign(cloned, { isPrimaryKey: true as const });
   }
 
   foreignKey<
     T extends ColumnType,
-    Model extends ForeignKeyModelWithColumns,
-    Column extends ColumnNameOfModel<Model>,
+    Table extends ForeignKeyTableWithColumns,
+    Column extends ColumnNameOfTable<Table>,
   >(
     this: T,
-    fn: () => Model,
+    fn: () => Table,
     column: Column,
     options?: ForeignKeyOptions,
   ): Omit<T, 'foreignKeyData'> & {
-    foreignKeyData: ForeignKey<InstanceType<Model>['table'], [Column]>;
+    foreignKeyData: ForeignKey<InstanceType<Table>['table'], [Column]>;
   };
   foreignKey<T extends ColumnType, Table extends string, Column extends string>(
     this: T,
@@ -176,7 +344,7 @@ export abstract class ColumnType<
     foreignKeyData: ForeignKey<Table, [Column]>;
   };
   foreignKey(
-    fnOrTable: (() => ForeignKeyModel) | string,
+    fnOrTable: (() => ForeignKeyTable) | string,
     column: string,
     options: ForeignKeyOptions = {},
   ) {
@@ -196,30 +364,32 @@ export abstract class ColumnType<
   }
 
   hidden<T extends ColumnType>(this: T): T & { isHidden: true } {
-    return Object.assign(this, { isHidden: true as const });
+    return Object.assign(Object.create(this), { isHidden: true as const });
   }
 
   nullable<T extends ColumnType>(this: T): NullableColumn<T> {
-    this.isNullable = true;
-    return this as unknown as NullableColumn<T>;
+    return Object.assign(Object.create(this), {
+      isNullable: true,
+    }) 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;
+    return Object.assign(Object.create(this), {
+      encodeFn: fn,
+    }) as unknown as Omit<T, 'inputType'> & { inputType: Input };
   }
 
   parse<T extends ColumnType, Output>(
     this: T,
     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 };
+    return Object.assign(Object.create(this), {
+      parseFn: fn,
+      parseItem: fn,
+    }) as unknown as Omit<T, 'type'> & { type: Output };
   }
 
   as<
@@ -290,7 +460,7 @@ export abstract class ColumnType<
     fn: (input: T['type']) => ToType['type'] | undefined,
     type: ToType,
   ): ToType {
-    const cloned = Object.create(type);
+    const cloned = Object.create(this);
     cloned.chain = [...this.chain, ['to', fn, type], ...cloned.chain];
     return cloned as ToType;
   }

package/src/columnSchema/columnTypes.ts

@@ -43,18 +43,17 @@ import {
 } from './dateTime';
 import { BooleanColumn } from './boolean';
 import { EnumColumn } from './enum';
-import { JSONColumn, JSONTextColumn, JSONTypes } from './json';
-import { JSONTypeAny } from './json/typeBase';
+import { JSONColumn, JSONTextColumn, JSONTypes, JSONTypeAny } from './json';
 import { ArrayColumn } from './array';
 import {
-  ColumnNameOfModel,
+  ColumnNameOfTable,
   ColumnType,
   ColumnTypesBase,
-  ForeignKeyModel,
+  ForeignKeyTable,
   IndexColumnOptions,
   IndexOptions,
   ForeignKeyOptions,
-  ForeignKeyModelWithColumns,
+  ForeignKeyTableWithColumns,
 } from './columnType';
 import { emptyObject, EmptyObject, MaybeArray, toArray } from '../utils';
 import { ColumnsShape } from './columnsSchema';
@@ -63,15 +62,29 @@ import { timestamps } from './timestamps';
 export type ColumnTypes = typeof columnTypes;
 
 export type TableData = {
-  primaryKey?: { columns: string[]; options?: { name?: string } };
-  indexes: { columns: IndexColumnOptions[]; options: IndexOptions }[];
-  foreignKeys: {
+  primaryKey?: TableData.PrimaryKey;
+  indexes: TableData.Index[];
+  foreignKeys: TableData.ForeignKey[];
+};
+
+export namespace TableData {
+  export type PrimaryKey = {
+    columns: string[];
+    options?: { name?: string };
+  };
+
+  export type Index = {
+    columns: IndexColumnOptions[];
+    options: IndexOptions;
+  };
+
+  export type ForeignKey = {
     columns: string[];
-    fnOrTable: (() => ForeignKeyModel) | string;
+    fnOrTable: (() => ForeignKeyTable) | string;
     foreignColumns: string[];
     options: ForeignKeyOptions;
-  }[];
-};
+  };
+}
 
 export const newTableData = (): TableData => ({
   indexes: [],
@@ -221,11 +234,11 @@ export const columnTypes = {
 };
 
 function foreignKey<
-  Model extends ForeignKeyModelWithColumns,
-  Columns extends [ColumnNameOfModel<Model>, ...ColumnNameOfModel<Model>[]],
+  Table extends ForeignKeyTableWithColumns,
+  Columns extends [ColumnNameOfTable<Table>, ...ColumnNameOfTable<Table>[]],
 >(
   columns: string[],
-  fn: () => Model,
+  fn: () => Table,
   foreignColumns: Columns,
   options?: ForeignKeyOptions,
 ): EmptyObject;
@@ -240,7 +253,7 @@ function foreignKey<
 ): EmptyObject;
 function foreignKey(
   columns: string[],
-  fnOrTable: (() => ForeignKeyModel) | string,
+  fnOrTable: (() => ForeignKeyTable) | string,
   foreignColumns: string[],
   options: ForeignKeyOptions = {},
 ) {

package/src/columnSchema/columnsSchema.ts

@@ -24,11 +24,13 @@ export type ColumnShapeInput<Shape extends ColumnsShape> = SetOptional<
   OptionalColumnsForInput<Shape>
 >;
 
-export class ColumnsObject<Shape extends ColumnsShape> extends ColumnType<
+export abstract class ColumnsObject<
+  Shape extends ColumnsShape,
+> extends ColumnType<
   { [K in keyof Shape]: Shape[K]['type'] },
   typeof Operators.any
 > {
-  dataType = 'object';
+  dataType = 'object' as const;
   operators = Operators.any;
 
   constructor(public shape: Shape) {
@@ -36,13 +38,13 @@ export class ColumnsObject<Shape extends ColumnsShape> extends ColumnType<
   }
 }
 
-export class ArrayOfColumnsObjects<
+export abstract class ArrayOfColumnsObjects<
   Shape extends ColumnsShape,
 > extends ColumnType<
   { [K in keyof Shape]: Shape[K]['type'] }[],
   typeof Operators.any
 > {
-  dataType = 'array';
+  dataType = 'array' as const;
   operators = Operators.any;
 
   constructor(public shape: Shape) {

package/src/columnSchema/commonMethods.ts

@@ -42,8 +42,15 @@ function size<T extends { data: { size?: number } }, Value extends number>(
   return setDataValue(this, 'size', value);
 }
 
-function nonempty<T extends { data: { min?: number } }>(this: T) {
-  return setDataValue(this, 'min', 1);
+export type NonEmptyBase = { data: { min?: number; isNonEmpty?: true } };
+export type NonEmptyResult<T extends NonEmptyBase> = Omit<T, 'data'> & {
+  data: Omit<T['data'], 'min'> & { min: 1; isNonEmpty: true };
+};
+
+function nonEmpty<T extends NonEmptyBase>(this: T): NonEmptyResult<T> {
+  const cloned = setDataValue(this, 'min', 1);
+  cloned.data.isNonEmpty = true;
+  return cloned as NonEmptyResult<T>;
 }
 
 export type ArrayMethods = typeof arrayMethods;
@@ -52,7 +59,7 @@ export const arrayMethods = {
   min,
   max,
   length,
-  nonempty,
+  nonEmpty,
 };
 
 export type SetMethods = typeof setMethods;
@@ -61,7 +68,7 @@ export const setMethods = {
   min,
   max,
   size,
-  nonempty,
+  nonEmpty,
 };
 
 export const stringTypeMethods = () => ({