pqb 0.7.13 → 0.8.1

package/src/columnSchema/json/scalarTypes.ts

@@ -1,4 +1,4 @@
-import { constructType, JSONType, JSONTypeAny } from './typeBase';
+import { constructType, JSONType, JSONTypeAny, toCode } from './typeBase';
 import { BaseNumberData } from '../number';
 import { BaseStringData } from '../string';
 import {
@@ -7,6 +7,7 @@ import {
   stringTypeMethods,
 } from '../commonMethods';
 import { DateColumnData } from '../dateTime';
+import { singleQuote } from '../../utils';
 
 export type JSONAny = JSONTypeAny & {
   dataType: 'any';
@@ -14,6 +15,9 @@ export type JSONAny = JSONTypeAny & {
 const any = () => {
   return constructType<JSONAny>({
     dataType: 'any',
+    toCode(this: JSONAny, t: string) {
+      return toCode(this, t, `${t}.any()`);
+    },
   });
 };
 
@@ -23,6 +27,9 @@ export type JSONBigInt = JSONType<bigint, 'bigint'> & {
 const bigIntMethods = {
   dataType: 'bigint' as const,
   ...numberTypeMethods,
+  toCode(this: JSONTypeAny, t: string) {
+    return toCode(this, t, `${t}.bigint()`);
+  },
 };
 const bigint = () => {
   return constructType<JSONBigInt>(bigIntMethods);
@@ -32,6 +39,9 @@ export type JSONBoolean = JSONType<boolean, 'boolean'>;
 const boolean = () => {
   return constructType<JSONBoolean>({
     dataType: 'boolean',
+    toCode(this: JSONBoolean, t: string) {
+      return toCode(this, t, `${t}.boolean()`);
+    },
   });
 };
 
@@ -39,6 +49,9 @@ export type JSONNaN = JSONType<number, 'nan'>;
 const nan = () => {
   return constructType<JSONNaN>({
     dataType: 'nan',
+    toCode(this: JSONNaN, t: string) {
+      return toCode(this, t, `${t}.nan()`);
+    },
   });
 };
 
@@ -46,6 +59,9 @@ export type JSONNever = JSONType<unknown, 'never'>;
 const never = () => {
   return constructType<JSONNever>({
     dataType: 'never',
+    toCode(this: JSONNever, t: string) {
+      return toCode(this, t, `${t}.never()`);
+    },
   });
 };
 
@@ -53,6 +69,9 @@ export type JSONNull = JSONType<null, 'null'>;
 const nullType = () => {
   return constructType<JSONNull>({
     dataType: 'null',
+    toCode(this: JSONNull, t: string) {
+      return toCode(this, t, `${t}.null()`);
+    },
   });
 };
 
@@ -62,6 +81,24 @@ export type JSONNumber = JSONType<number, 'number'> & {
 const numberMethods = {
   ...numberTypeMethods,
   dataType: 'number' as const,
+  toCode(
+    this: JSONType<number, 'number'> & {
+      data: BaseNumberData;
+    },
+    t: string,
+  ) {
+    let code = `${t}.number()`;
+
+    if (this.data.gte !== undefined) code += `.min(${this.data.gte})`;
+    if (this.data.gt !== undefined) code += `.gt(${this.data.gt})`;
+    if (this.data.lte !== undefined) code += `.max(${this.data.lte})`;
+    if (this.data.lt !== undefined) code += `.lt(${this.data.lt})`;
+    if (this.data.multipleOf !== undefined)
+      code += `.step(${this.data.multipleOf})`;
+    if (this.data.int) code += `.int()`;
+
+    return toCode(this, t, code);
+  },
 };
 const number = () => {
   return constructType<JSONNumber>(numberMethods);
@@ -73,6 +110,21 @@ export type JSONDate = JSONType<Date, 'date'> & {
 const dateMethods = {
   ...dateTypeMethods,
   dataType: 'date' as const,
+  toCode(
+    this: JSONType<Date, 'date'> & {
+      data: DateColumnData;
+    },
+    t: string,
+  ) {
+    let code = `${t}.date()`;
+
+    if (this.data.min)
+      code += `.min(new Date('${this.data.min.toISOString()}'))`;
+    if (this.data.max)
+      code += `.max(new Date('${this.data.max.toISOString()}'))`;
+
+    return toCode(this, t, code);
+  },
 };
 const date = () => {
   return constructType<JSONDate>(dateMethods);
@@ -84,6 +136,34 @@ export type JSONString = JSONType<string, 'string'> & {
 const stringMethods = {
   ...stringTypeMethods(),
   dataType: 'string' as const,
+  toCode(
+    this: JSONType<string, 'string'> & {
+      data: BaseStringData;
+    },
+    t: string,
+  ) {
+    let code = `${t}.string()`;
+
+    const { min, isNonEmpty } = this.data;
+
+    if (min !== undefined && (!isNonEmpty || (isNonEmpty && min !== 1)))
+      code += `.min(${min})`;
+
+    if (this.data.max !== undefined) code += `.max(${this.data.max})`;
+    if (this.data.length !== undefined) code += `.length(${this.data.length})`;
+    if (this.data.email !== undefined) code += `.email()`;
+    if (this.data.url !== undefined) code += `.url()`;
+    if (this.data.uuid !== undefined) code += `.uuid()`;
+    if (this.data.cuid !== undefined) code += `.cuid()`;
+    if (this.data.regex) code += `.regex(${this.data.regex.toString()})`;
+    if (this.data.startsWith !== undefined)
+      code += `.startsWith(${singleQuote(this.data.startsWith)})`;
+    if (this.data.endsWith !== undefined)
+      code += `.endsWith(${singleQuote(this.data.endsWith)})`;
+    if (this.data.cuid !== undefined) code += `.trim()`;
+
+    return toCode(this, t, code);
+  },
 };
 const string = () => {
   return constructType<JSONString>(stringMethods);
@@ -93,6 +173,9 @@ export type JSONUndefined = JSONType<undefined, 'undefined'>;
 const undefinedType = () => {
   return constructType<JSONUndefined>({
     dataType: 'undefined',
+    toCode(this: JSONUndefined, t: string) {
+      return toCode(this, t, `${t}.undefined()`);
+    },
   });
 };
 
@@ -100,6 +183,9 @@ export type JSONUnknown = JSONType<unknown, 'unknown'>;
 const unknown = () => {
   return constructType<JSONUnknown>({
     dataType: 'unknown',
+    toCode(this: JSONUnknown, t: string) {
+      return toCode(this, t, `${t}.unknown()`);
+    },
   });
 };
 
@@ -107,6 +193,9 @@ export type JSONVoid = JSONType<void, 'void'>;
 const voidType = () => {
   return constructType<JSONVoid>({
     dataType: 'void',
+    toCode(this: JSONVoid, t: string) {
+      return toCode(this, t, `${t}.void()`);
+    },
   });
 };
 

package/src/columnSchema/json/set.test.ts

@@ -0,0 +1,29 @@
+import { set } from './set';
+import { scalarTypes } from './scalarTypes';
+
+const { number } = scalarTypes;
+
+describe('set', () => {
+  it('should have toCode', () => {
+    expect(set(number()).toCode('t')).toEqual(['t.set(', 't.number()', ')']);
+
+    expect(set(number()).deepPartial().toCode('t')).toEqual([
+      't.set(',
+      't.number().optional()',
+      ')',
+    ]);
+
+    expect(set(number()).nonEmpty().toCode('t')).toEqual([
+      't.set(',
+      't.number()',
+      ')',
+      '.nonEmpty()',
+    ]);
+
+    expect(set(number()).min(1).max(10).size(15).toCode('t')).toEqual([
+      't.set(',
+      't.number()',
+      ').min(1).max(10).size(15)',
+    ]);
+  });
+});

package/src/columnSchema/json/set.ts

@@ -1,5 +1,12 @@
-import { constructType, JSONType, JSONTypeAny, JSONTypeData } from './typeBase';
+import {
+  constructType,
+  JSONType,
+  JSONTypeAny,
+  JSONTypeData,
+  toCode,
+} from './typeBase';
 import { SetMethods, setMethods } from '../commonMethods';
+import { toArray } from '../../utils';
 
 export interface JSONSet<Value extends JSONTypeAny>
   extends JSONType<Set<Value['type']>, 'set'>,
@@ -11,24 +18,36 @@ export interface JSONSet<Value extends JSONTypeAny>
   };
   valueType: Value;
   deepPartial(): JSONSet<ReturnType<Value['deepPartial']>>;
-  nonEmpty(this: JSONSet<Value>): JSONSet<Value> & { data: { min: 1 } };
 }
 
 export const set = <Value extends JSONTypeAny>(valueType: Value) => {
   return constructType<JSONSet<Value>>({
     dataType: 'set',
     valueType,
+    toCode(this: JSONSet<Value>, t: string) {
+      let append = ')';
+
+      const { min, max, size, isNonEmpty } = this.data;
+
+      if (min !== undefined && (!isNonEmpty || (isNonEmpty && min !== 1)))
+        append += `.min(${min})`;
+
+      if (max !== undefined) append += `.max(${max})`;
+
+      if (size !== undefined) append += `.size(${size})`;
+
+      return toCode(this, t, [
+        `${t}.set(`,
+        ...toArray(this.valueType.toCode(t)),
+        append,
+      ]);
+    },
     deepPartial(this: JSONSet<Value>) {
       return {
         ...this,
         valueType: this.valueType.deepPartial(),
       };
     },
-    nonEmpty(this: JSONSet<Value>) {
-      return this.min(1) as unknown as JSONSet<Value> & {
-        data: { min: 1 };
-      };
-    },
     ...setMethods,
   });
 };

package/src/columnSchema/json/tuple.test.ts

@@ -0,0 +1,17 @@
+import { tuple } from './tuple';
+import { scalarTypes } from './scalarTypes';
+
+describe('tuple', () => {
+  it('should have toCode', () => {
+    expect(
+      tuple([scalarTypes.string(), scalarTypes.number()]).toCode('t'),
+    ).toBe('t.tuple([t.string(), t.number()])');
+
+    expect(
+      tuple(
+        [scalarTypes.string(), scalarTypes.number()],
+        scalarTypes.boolean(),
+      ).toCode('t'),
+    ).toBe('t.tuple([t.string(), t.number()], t.boolean())');
+  });
+});

package/src/columnSchema/json/tuple.ts

@@ -1,4 +1,10 @@
-import { constructType, DeepPartial, JSONType, JSONTypeAny } from './typeBase';
+import {
+  constructType,
+  DeepPartial,
+  JSONType,
+  JSONTypeAny,
+  toCode,
+} from './typeBase';
 
 export interface JSONTuple<
   T extends JSONTupleItems | [] = JSONTupleItems,
@@ -39,6 +45,15 @@ export const tuple = <
     dataType: 'tuple',
     items,
     restType: rest,
+    toCode(this: JSONTuple<T, Rest>, t: string) {
+      return toCode(
+        this,
+        t,
+        `${t}.tuple([${this.items.map((item) => item.toCode(t)).join(', ')}]${
+          this.restType ? `, ${this.restType.toCode(t)}` : ''
+        })`,
+      );
+    },
     rest<Rest extends JSONTypeAny | null>(rest: Rest): JSONTuple<T, Rest> {
       return {
         ...this,

package/src/columnSchema/json/typeBase.test.ts

@@ -0,0 +1,123 @@
+import { scalarTypes } from './scalarTypes';
+
+const { string, number } = scalarTypes;
+
+describe('typeBase', () => {
+  describe('optional', () => {
+    it('should have toCode', () => {
+      expect(string().optional().toCode('t')).toBe('t.string().optional()');
+    });
+  });
+
+  describe('required', () => {
+    it('should have toCode', () => {
+      expect(string().optional().required().toCode('t')).toBe('t.string()');
+    });
+  });
+
+  describe('nullable', () => {
+    it('should have toCode', () => {
+      expect(string().nullable().toCode('t')).toBe('t.string().nullable()');
+    });
+  });
+
+  describe('notNullable', () => {
+    it('should have toCode', () => {
+      expect(string().nullable().notNullable().toCode('t')).toBe('t.string()');
+    });
+  });
+
+  describe('nullish', () => {
+    it('should have toCode', () => {
+      expect(string().nullish().toCode('t')).toBe('t.string().nullish()');
+    });
+  });
+
+  describe('notNullish', () => {
+    it('should have toCode', () => {
+      expect(string().nullish().notNullish().toCode('t')).toBe('t.string()');
+    });
+  });
+
+  describe('deepPartial', () => {
+    it('should have toCode', () => {
+      expect(string().deepPartial().toCode('t')).toBe('t.string().optional()');
+    });
+  });
+
+  describe('transform', () => {
+    it('should have toCode', () => {
+      expect(
+        string()
+          .transform((s) => s)
+          .toCode('t'),
+      ).toEqual(['t.string()', '.transform((s)=>s)']);
+    });
+  });
+
+  describe('to', () => {
+    it('should have toCode', () => {
+      expect(
+        string()
+          .to((s) => parseInt(s), number())
+          .toCode('t'),
+      ).toEqual(['t.string()', '.to((s)=>parseInt(s), ', 't.number()', ')']);
+    });
+  });
+
+  describe('refine', () => {
+    it('should have toCode', () => {
+      expect(
+        string()
+          .refine((s) => s.length > 0)
+          .toCode('t'),
+      ).toEqual(['t.string()', '.refine((s)=>s.length > 0)']);
+    });
+  });
+
+  describe('superRefine', () => {
+    it('should have toCode', () => {
+      expect(
+        string()
+          .superRefine((s) => s)
+          .toCode('t'),
+      ).toEqual(['t.string()', '.superRefine((s)=>s)']);
+    });
+  });
+
+  describe('and', () => {
+    it('should have toCode', () => {
+      expect(string().and(number()).toCode('t')).toEqual([
+        't.string()',
+        '.and(',
+        't.number()',
+        ')',
+      ]);
+    });
+  });
+
+  describe('or', () => {
+    it('should have toCode', () => {
+      expect(string().or(number()).toCode('t')).toEqual([
+        't.string()',
+        '.or(',
+        't.number()',
+        ')',
+      ]);
+    });
+  });
+
+  describe('default', () => {
+    it('should have toCode', () => {
+      expect(string().default('value').toCode('t')).toBe(
+        't.string().default("value")',
+      );
+    });
+  });
+
+  describe('array', () => {
+    it('should have toCode', () => {
+      expect(string().array().toCode('t')).toEqual(['t.string()', '.array()']);
+    });
+  });
+});

package/src/columnSchema/json/typeBase.ts

@@ -9,10 +9,16 @@ import { JSONNotNullish, JSONNullish, notNullish, nullish } from './nullish';
 import { intersection, JSONIntersection } from './intersection';
 import { array, JSONArray } from './array';
 import { union } from './union';
-import { ColumnData, ValidationContext } from '../columnType';
+import {
+  Code,
+  ColumnChain,
+  columnChainToCode,
+  ColumnData,
+  ValidationContext,
+} from '../columnType';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type JSONTypeAny = JSONType<any, string>;
+export type JSONTypeAny = JSONType<any>;
 
 export type DeepPartial<T extends JSONTypeAny> = ReturnType<
   JSONTypeAny['deepPartial']
@@ -23,6 +29,8 @@ export type DeepPartial<T extends JSONTypeAny> = ReturnType<
 export type JSONTypeData = ColumnData & {
   optional?: true;
   nullable?: true;
+  isDeepPartial?: true;
+  isNonEmpty?: true;
 };
 
 export type Primitive = string | number | bigint | boolean | null | undefined;
@@ -31,12 +39,9 @@ export type JSONType<Type, DataType extends string = string> = {
   type: Type;
   data: JSONTypeData;
   dataType: DataType;
-  chain: (
-    | ['transform', (input: unknown, ctx: ValidationContext) => unknown]
-    | ['to', (input: unknown) => JSONTypeAny | undefined, JSONTypeAny]
-    | ['refine', (input: unknown) => unknown]
-    | ['superRefine', (input: unknown, ctx: ValidationContext) => unknown]
-  )[];
+  chain: ColumnChain;
+
+  toCode(t: string): Code;
 
   optional<T extends JSONTypeAny>(this: T): JSONOptional<T>;
   required<T extends JSONTypeAny>(this: T): JSONRequired<T>;
@@ -90,6 +95,32 @@ export type JSONType<Type, DataType extends string = string> = {
   array<T extends JSONTypeAny>(this: T): JSONArray<T>;
 };
 
+export const toCode = (type: JSONTypeAny, t: string, code: Code) => {
+  let append = '';
+
+  if (type.data.nullable && type.data.optional) {
+    append += '.nullish()';
+  } else if (type.data.nullable) {
+    append += '.nullable()';
+  } else if (type.data.optional) {
+    append += '.optional()';
+  }
+
+  if (type.data.isDeepPartial) {
+    append += '.deepPartial()';
+  }
+
+  if (type.data.isNonEmpty) {
+    append += '.nonEmpty()';
+  }
+
+  if (type.data.default) {
+    append += `.default(${JSON.stringify(type.data.default)})`;
+  }
+
+  return columnChainToCode(type.chain, t, code, append);
+};
+
 const baseTypeMethods: JSONTypeAny = {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   type: undefined as any,
@@ -97,6 +128,10 @@ const baseTypeMethods: JSONTypeAny = {
   dataType: 'any',
   chain: [],
 
+  toCode() {
+    throw new Error('toCode is not implemented');
+  },
+
   optional<T extends JSONTypeAny>(this: T) {
     return optional(this);
   },
@@ -122,7 +157,7 @@ const baseTypeMethods: JSONTypeAny = {
   },
 
   deepPartial() {
-    return this;
+    return this.optional();
   },
 
   transform<T extends JSONTypeAny, Transformed>(
@@ -135,11 +170,15 @@ const baseTypeMethods: JSONTypeAny = {
     };
   },
 
-  to(fn, type) {
+  to<T extends JSONTypeAny, ToType extends JSONTypeAny>(
+    this: T,
+    fn: (input: T['type']) => ToType['type'] | undefined,
+    type: ToType,
+  ): ToType {
     return {
-      ...type,
+      ...this,
       chain: [...this.chain, ['to', fn, type], ...type.chain],
-    };
+    } as unknown as ToType;
   },
 
   refine(check) {
@@ -177,7 +216,7 @@ const baseTypeMethods: JSONTypeAny = {
 };
 
 type BaseTypeProps<T extends JSONTypeAny> = Omit<
-  JSONType<T['type'], string>,
+  JSONType<T['type']>,
   'dataType'
 >;
 export type OwnTypeProps<T extends JSONTypeAny> = Omit<

package/src/columnSchema/json/union.test.ts

@@ -0,0 +1,10 @@
+import { union } from './union';
+import { scalarTypes } from './scalarTypes';
+
+describe('union', () => {
+  it('should have toCode', () => {
+    expect(
+      union([scalarTypes.string(), scalarTypes.number()]).toCode('t'),
+    ).toEqual(['t.string()', '.or(', 't.number()', ')']);
+  });
+});

package/src/columnSchema/json/union.ts

@@ -1,4 +1,5 @@
-import { constructType, JSONType, JSONTypeAny } from './typeBase';
+import { constructType, JSONType, JSONTypeAny, toCode } from './typeBase';
+import { toArray } from '../../utils';
 
 export interface JSONUnion<
   T extends [JSONTypeAny, JSONTypeAny, ...JSONTypeAny[]],
@@ -12,5 +13,21 @@ export const union = <T extends [JSONTypeAny, JSONTypeAny, ...JSONTypeAny[]]>(
   return constructType<JSONUnion<T>>({
     dataType: 'union',
     types,
+    toCode(this: JSONUnion<T>, t: string) {
+      const last = this.types.length - 1;
+      return toCode(
+        this,
+        t,
+        this.types.flatMap((type, i) => {
+          const item = [...toArray(type.toCode(t))];
+          if (i < last) {
+            item.push(`${i > 0 ? ')' : ''}.or(`);
+          } else {
+            item.push(')');
+          }
+          return item;
+        }),
+      );
+    },
   });
 };

package/src/columnSchema/json.test.ts

@@ -0,0 +1,17 @@
+import { JSONColumn, JSONTextColumn } from './json';
+
+describe('json columns', () => {
+  describe('json', () => {
+    it('should have toCode', () => {
+      expect(new JSONColumn((t) => t.string()).toCode('t')).toBe(
+        't.json((t) => t.string())',
+      );
+    });
+  });
+
+  describe('jsonText', () => {
+    it('should have toCode', () => {
+      expect(new JSONTextColumn().toCode('t')).toBe('t.jsonText()');
+    });
+  });
+});

package/src/columnSchema/json.ts

@@ -1,4 +1,4 @@
-import { ColumnData, ColumnType } from './columnType';
+import { Code, columnCode, ColumnData, ColumnType } from './columnType';
 import { Operators } from '../columnsOperators';
 import {
   scalarTypes,
@@ -20,7 +20,7 @@ import {
   tuple,
   union,
   JSONTypeAny,
-} from './json/index';
+} from './json';
 
 export * from './json/index';
 
@@ -60,9 +60,17 @@ export class JSONColumn<
       typeof schemaOrFn === 'function' ? schemaOrFn(jsonTypes) : schemaOrFn;
     this.data = { schema };
   }
+
+  toCode(t: string): Code {
+    const { schema } = this.data;
+    return columnCode(this, t, `${t}.json((t) => ${schema.toCode('t')})`);
+  }
 }
 
 export class JSONTextColumn extends ColumnType<string, typeof Operators.text> {
   dataType = 'json' as const;
   operators = Operators.text;
+  toCode(t: string): Code {
+    return columnCode(this, t, `${t}.jsonText()`);
+  }
 }