pqb 0.7.13 → 0.8.1

package/src/columnSchema/json/index.ts

@@ -1,19 +1,19 @@
-export * from './array'
-export * from './discriminatedUnion'
-export * from './enum'
-export * from './instanceOf'
-export * from './intersection'
-export * from './lazy'
-export * from './literal'
-export * from './map'
-export * from './nativeEnum'
-export * from './nullable'
-export * from './nullish'
-export * from './object'
-export * from './optional'
-export * from './record'
-export * from './scalarTypes'
-export * from './set'
-export * from './tuple'
-export * from './typeBase'
-export * from './union'
+export * from './array';
+export * from './discriminatedUnion';
+export * from './enum';
+export * from './instanceOf';
+export * from './intersection';
+export * from './lazy';
+export * from './literal';
+export * from './map';
+export * from './nativeEnum';
+export * from './nullable';
+export * from './nullish';
+export * from './object';
+export * from './optional';
+export * from './record';
+export * from './scalarTypes';
+export * from './set';
+export * from './tuple';
+export * from './typeBase';
+export * from './union';

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

@@ -0,0 +1,8 @@
+import { instanceOf } from './instanceOf';
+
+describe('instanceOf', () => {
+  it('should have toCode', () => {
+    class A {}
+    expect(instanceOf(A).toCode('t')).toBe('t.instanceOf(A)');
+  });
+});

package/src/columnSchema/json/instanceOf.ts

@@ -1,4 +1,4 @@
-import { constructType, JSONType } from './typeBase';
+import { constructType, JSONType, toCode } from './typeBase';
 
 export interface JSONInstanceOf<T extends Class>
   extends JSONType<T, 'instanceOf'> {
@@ -12,5 +12,8 @@ export const instanceOf = <T extends Class>(cls: T) => {
   return constructType<JSONInstanceOf<T>>({
     dataType: 'instanceOf',
     class: cls,
+    toCode(this: JSONInstanceOf<T>, t: string) {
+      return toCode(this, t, `${t}.instanceOf(${this.class.name})`);
+    },
   });
 };

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

@@ -0,0 +1,19 @@
+import { intersection } from './intersection';
+import { object } from './object';
+import { scalarTypes } from './scalarTypes';
+
+describe('intersection', () => {
+  it('should have toCode', () => {
+    expect(
+      intersection(
+        object({ name: scalarTypes.string() }),
+        object({ age: scalarTypes.number() }),
+      ).toCode('t'),
+    ).toEqual([
+      ['t.object({', ['name: t.string(),'], '})'],
+      '.and(',
+      ['t.object({', ['age: t.number(),'], '})'],
+      ')',
+    ]);
+  });
+});

package/src/columnSchema/json/intersection.ts

@@ -1,4 +1,4 @@
-import { constructType, JSONType, JSONTypeAny } from './typeBase';
+import { constructType, JSONType, JSONTypeAny, toCode } from './typeBase';
 
 export type JSONIntersection<
   Left extends JSONTypeAny,
@@ -19,5 +19,13 @@ export const intersection = <
     dataType: 'intersection',
     left,
     right,
+    toCode(this: JSONIntersection<Left, Right>, t: string) {
+      return toCode(this, t, [
+        this.left.toCode(t),
+        '.and(',
+        this.right.toCode(t),
+        ')',
+      ]);
+    },
   });
 };

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

@@ -0,0 +1,22 @@
+import { lazy } from './lazy';
+import { scalarTypes } from './scalarTypes';
+
+describe('lazy', () => {
+  it('should have toCode', () => {
+    expect(lazy(() => scalarTypes.string()).toCode('t')).toEqual([
+      't.lazy(() => ',
+      't.string()',
+      ')',
+    ]);
+    expect(
+      lazy(() => scalarTypes.string())
+        .deepPartial()
+        .toCode('t'),
+    ).toEqual([
+      't.lazy(() => ',
+      't.string().optional()',
+      ')',
+      '.deepPartial()',
+    ]);
+  });
+});

package/src/columnSchema/json/lazy.ts

@@ -1,7 +1,17 @@
-import { constructType, JSONType, JSONTypeAny } from './typeBase';
+import {
+  constructType,
+  JSONType,
+  JSONTypeAny,
+  JSONTypeData,
+  toCode,
+} from './typeBase';
+import { toArray } from '../../utils';
 
 export interface JSONLazy<T extends JSONTypeAny>
   extends JSONType<T['type'], 'lazy'> {
+  data: JSONTypeData & {
+    isDeepPartial?: boolean;
+  };
   typeCache?: T;
   getter(): T;
   deepPartial(): JSONLazy<ReturnType<T['deepPartial']>>;
@@ -13,9 +23,20 @@ export const lazy = <T extends JSONTypeAny>(fn: () => T): JSONLazy<T> => {
     getter() {
       return this.typeCache || (this.typeCache = fn());
     },
+    toCode(this: JSONLazy<T>, t: string) {
+      return toCode(this, t, [
+        `${t}.lazy(() => `,
+        ...toArray(this.getter().toCode(t)),
+        ')',
+      ]);
+    },
     deepPartial(this: JSONLazy<T>) {
       return {
         ...this,
+        data: {
+          ...this.data,
+          isDeepPartial: true,
+        },
         typeCache: undefined,
         getter: () => this.getter().deepPartial(),
       };

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

@@ -0,0 +1,7 @@
+import { literal } from './literal';
+
+describe('literal', () => {
+  it('should have toCode', () => {
+    expect(literal('ko').toCode('t')).toBe(`t.literal('ko')`);
+  });
+});

package/src/columnSchema/json/literal.ts

@@ -1,4 +1,5 @@
-import { constructType, JSONType, Primitive } from './typeBase';
+import { constructType, JSONType, Primitive, toCode } from './typeBase';
+import { singleQuote } from '../../utils';
 
 export interface JSONLiteral<T extends Primitive>
   extends JSONType<T, 'literal'> {
@@ -9,4 +10,14 @@ export const literal = <T extends Primitive>(value: T) =>
   constructType<JSONLiteral<T>>({
     dataType: 'literal',
     value,
+    toCode(this: JSONLiteral<T>, t: string) {
+      const { value } = this;
+      return toCode(
+        this,
+        t,
+        `${t}.literal(${
+          typeof value === 'string' ? singleQuote(value) : value
+        })`,
+      );
+    },
   });

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

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

package/src/columnSchema/json/map.ts

@@ -1,7 +1,16 @@
-import { constructType, JSONType, JSONTypeAny } from './typeBase';
+import {
+  constructType,
+  JSONType,
+  JSONTypeAny,
+  JSONTypeData,
+  toCode,
+} from './typeBase';
 
 export interface JSONMap<Key extends JSONTypeAny, Value extends JSONTypeAny>
   extends JSONType<Map<Key['type'], Value['type']>, 'map'> {
+  data: JSONTypeData & {
+    isDeepPartial?: boolean;
+  };
   keyType: Key;
   valueType: Value;
   deepPartial(): JSONMap<
@@ -18,9 +27,20 @@ export const map = <Key extends JSONTypeAny, Value extends JSONTypeAny>(
     dataType: 'map',
     keyType: keyType,
     valueType: valueType,
+    toCode(this: JSONMap<Key, Value>, t: string) {
+      return toCode(
+        this,
+        t,
+        `${t}.map(${this.keyType.toCode(t)}, ${this.valueType.toCode(t)})`,
+      );
+    },
     deepPartial(this: JSONMap<Key, Value>) {
       return {
         ...this,
+        data: {
+          ...this.data,
+          isDeepPartial: true,
+        },
         keyType: this.keyType.deepPartial(),
         valueType: this.valueType.deepPartial(),
       };

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

@@ -0,0 +1,10 @@
+import { nativeEnum } from './nativeEnum';
+
+describe('nativeEnum', () => {
+  it('should have toCode', () => {
+    enum A {
+      a,
+    }
+    expect(nativeEnum(A).toCode('t')).toBe('t.nativeEnum(enum)');
+  });
+});

package/src/columnSchema/json/nativeEnum.ts

@@ -1,4 +1,4 @@
-import { constructType, JSONType } from './typeBase';
+import { constructType, JSONType, toCode } from './typeBase';
 
 export interface JSONNativeEnum<T extends EnumLike>
   extends JSONType<T[keyof T], 'nativeEnum'> {
@@ -26,5 +26,8 @@ export const nativeEnum = <T extends EnumLike>(givenEnum: T) => {
     dataType: 'nativeEnum',
     enum: givenEnum,
     options,
+    toCode(this: JSONNativeEnum<T>, t: string) {
+      return toCode(this, t, `${t}.nativeEnum(enum)`);
+    },
   });
 };

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

@@ -0,0 +1,18 @@
+import { notNullable, nullable } from './nullable';
+import { scalarTypes } from './scalarTypes';
+
+describe('nullable', () => {
+  it('should have toCode', () => {
+    expect(nullable(scalarTypes.string()).toCode('t')).toBe(
+      't.string().nullable()',
+    );
+  });
+});
+
+describe('notNullable', () => {
+  it('should have toCode', () => {
+    expect(notNullable(scalarTypes.string().nullable()).toCode('t')).toBe(
+      't.string()',
+    );
+  });
+});

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

@@ -0,0 +1,18 @@
+import { notNullish, nullish } from './nullish';
+import { scalarTypes } from './scalarTypes';
+
+describe('nullish', () => {
+  it('should have toCode', () => {
+    expect(nullish(scalarTypes.string()).toCode('t')).toBe(
+      't.string().nullish()',
+    );
+  });
+});
+
+describe('notNullish', () => {
+  it('should have toCode', () => {
+    expect(notNullish(scalarTypes.string().nullish()).toCode('t')).toBe(
+      't.string()',
+    );
+  });
+});

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

@@ -0,0 +1,77 @@
+import { object } from './object';
+import { scalarTypes } from './scalarTypes';
+
+describe('object', () => {
+  it('should have toCode', () => {
+    const shape = { key: scalarTypes.string() };
+    const other = { other: scalarTypes.number() };
+
+    expect(object(shape).toCode('t')).toEqual([
+      't.object({',
+      ['key: t.string(),'],
+      '})',
+    ]);
+
+    expect(object(shape).extend(other).toCode('t')).toEqual([
+      't.object({',
+      ['key: t.string(),', 'other: t.number(),'],
+      '})',
+    ]);
+
+    expect(object(shape).merge(object(other)).toCode('t')).toEqual([
+      't.object({',
+      ['key: t.string(),', 'other: t.number(),'],
+      '})',
+    ]);
+
+    expect(
+      object({ ...shape, ...other })
+        .pick('key')
+        .toCode('t'),
+    ).toEqual(['t.object({', ['key: t.string(),'], '})']);
+
+    expect(
+      object({ ...shape, ...other })
+        .omit('key')
+        .toCode('t'),
+    ).toEqual(['t.object({', ['other: t.number(),'], '})']);
+
+    expect(
+      object({ ...shape, ...other })
+        .partial()
+        .toCode('t'),
+    ).toEqual([
+      't.object({',
+      ['key: t.string().optional(),', 'other: t.number().optional(),'],
+      '})',
+    ]);
+
+    expect(
+      object({ ...shape, ...other })
+        .deepPartial()
+        .toCode('t'),
+    ).toEqual([
+      't.object({',
+      ['key: t.string().optional(),', 'other: t.number().optional(),'],
+      '})',
+    ]);
+
+    expect(object(shape).passthrough().toCode('t')).toEqual([
+      't.object({',
+      ['key: t.string(),'],
+      '}).passthrough()',
+    ]);
+
+    expect(object(shape).strict().toCode('t')).toEqual([
+      't.object({',
+      ['key: t.string(),'],
+      '}).strict()',
+    ]);
+
+    expect(object(shape).catchAll(scalarTypes.string()).toCode('t')).toEqual([
+      't.object({',
+      ['key: t.string(),'],
+      '}).catchAll(t.string())',
+    ]);
+  });
+});

package/src/columnSchema/json/object.ts

@@ -1,5 +1,12 @@
-import { constructType, DeepPartial, JSONType, JSONTypeAny } from './typeBase';
+import {
+  constructType,
+  DeepPartial,
+  JSONType,
+  JSONTypeAny,
+  toCode,
+} from './typeBase';
 import { JSONOptional, optional } from './optional';
+import { Code } from '../columnType';
 
 export type JSONObjectShape = Record<string, JSONTypeAny>;
 
@@ -36,7 +43,7 @@ export type baseObjectOutputType<Shape extends JSONObjectShape> = flatten<
   }>
 >;
 
-type objectOutputType<
+type ObjectOutputType<
   Shape extends JSONObjectShape,
   Catchall extends JSONTypeAny,
 > = JSONTypeAny extends Catchall
@@ -72,7 +79,7 @@ export interface JSONObject<
   T extends JSONObjectShape,
   UnknownKeys extends UnknownKeysParam = 'strip',
   Catchall extends JSONTypeAny = JSONTypeAny,
-  Output = objectOutputType<T, Catchall>,
+  Output = ObjectOutputType<T, Catchall>,
 > extends JSONType<Output, 'object'> {
   shape: T;
   unknownKeys: UnknownKeys;
@@ -120,6 +127,27 @@ export const object = <
     shape,
     unknownKeys: 'strip' as UnknownKeys,
     catchAllType: undefined as unknown as Catchall,
+    toCode(this: JSONObject<JSONObjectShape, UnknownKeysParam>, t: string) {
+      const { shape } = this;
+      const arr: Code[] = [];
+
+      for (const key in shape) {
+        arr.push(`${key}: ${shape[key].toCode(t)},`);
+      }
+
+      let lastLine = '})';
+      if (this.unknownKeys === 'passthrough') {
+        lastLine += '.passthrough()';
+      } else if (this.unknownKeys === 'strict') {
+        lastLine += '.strict()';
+      }
+
+      if (this.catchAllType) {
+        lastLine += `.catchAll(${this.catchAllType.toCode(t)})`;
+      }
+
+      return toCode(this, t, [`${t}.object({`, arr, lastLine]);
+    },
     extend<S extends JSONObjectShape>(add: S) {
       return object<Merge<T, S>, UnknownKeys, Catchall>(
         Object.assign({ ...this.shape }, add),

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

@@ -0,0 +1,18 @@
+import { scalarTypes } from './scalarTypes';
+import { optional, required } from './optional';
+
+describe('optional', () => {
+  it('should have toCode', () => {
+    expect(optional(scalarTypes.string()).toCode('t')).toBe(
+      't.string().optional()',
+    );
+  });
+});
+
+describe('required', () => {
+  it('should have toCode', () => {
+    expect(required(scalarTypes.string().optional()).toCode('t')).toBe(
+      't.string()',
+    );
+  });
+});

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

@@ -0,0 +1,14 @@
+import { record } from './record';
+import { scalarTypes } from './scalarTypes';
+
+describe('record', () => {
+  it('should have toCode', () => {
+    expect(record(scalarTypes.number()).toCode('t')).toBe(
+      't.record(t.number())',
+    );
+
+    expect(record(scalarTypes.number(), scalarTypes.number()).toCode('t')).toBe(
+      't.record(t.number(), t.number())',
+    );
+  });
+});

package/src/columnSchema/json/record.ts

@@ -1,4 +1,4 @@
-import { constructType, JSONType, JSONTypeAny } from './typeBase';
+import { constructType, JSONType, JSONTypeAny, toCode } from './typeBase';
 import { JSONNumber, JSONString, scalarTypes } from './scalarTypes';
 
 export interface JSONRecord<
@@ -33,6 +33,17 @@ export function record<
     dataType: 'record',
     keyType,
     valueType,
+    toCode(this: JSONRecord<KeyType, ValueType>, t: string) {
+      return toCode(
+        this,
+        t,
+        `${t}.record(${
+          args.length === 1
+            ? this.valueType.toCode(t)
+            : `${this.keyType.toCode(t)}, ${this.valueType.toCode(t)}`
+        })`,
+      );
+    },
     deepPartial(this: JSONRecord<KeyType, ValueType>) {
       return {
         ...this,

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

@@ -0,0 +1,133 @@
+import { scalarTypes } from './scalarTypes';
+
+describe('scalarTypes', () => {
+  describe('any', () => {
+    it('should have toCode', () => {
+      expect(scalarTypes.any().toCode('t')).toBe('t.any()');
+    });
+  });
+
+  describe('bigint', () => {
+    it('should have toCode', () => {
+      expect(scalarTypes.bigint().toCode('t')).toBe('t.bigint()');
+    });
+  });
+
+  describe('boolean', () => {
+    it('should have toCode', () => {
+      expect(scalarTypes.boolean().toCode('t')).toBe('t.boolean()');
+    });
+  });
+
+  describe('nan', () => {
+    it('should have toCode', () => {
+      expect(scalarTypes.nan().toCode('t')).toBe('t.nan()');
+    });
+  });
+
+  describe('never', () => {
+    it('should have toCode', () => {
+      expect(scalarTypes.never().toCode('t')).toBe('t.never()');
+    });
+  });
+
+  describe('null', () => {
+    it('should have toCode', () => {
+      expect(scalarTypes.null().toCode('t')).toBe('t.null()');
+    });
+  });
+
+  describe('number', () => {
+    it('should have toCode', () => {
+      expect(scalarTypes.number().toCode('t')).toBe('t.number()');
+
+      expect(
+        scalarTypes
+          .number()
+          .lt(1)
+          .lte(2)
+          .gt(3)
+          .gte(4)
+          .multipleOf(5)
+          .int()
+          .toCode('t'),
+      ).toBe('t.number().min(4).gt(3).max(2).lt(1).step(5).int()');
+
+      expect(
+        scalarTypes
+          .number()
+          .positive()
+          .nonNegative()
+          .negative()
+          .nonPositive()
+          .toCode('t'),
+      ).toBe('t.number().min(0).gt(0).max(0).lt(0)');
+
+      expect(scalarTypes.number().min(1).max(2).step(3).toCode('t')).toBe(
+        't.number().min(1).max(2).step(3)',
+      );
+    });
+  });
+
+  describe('date', () => {
+    it('should have toCode', () => {
+      expect(scalarTypes.date().toCode('t')).toBe('t.date()');
+
+      const now = new Date();
+      const s = now.toISOString();
+      expect(scalarTypes.date().min(now).max(now).toCode('t')).toBe(
+        `t.date().min(new Date('${s}')).max(new Date('${s}'))`,
+      );
+    });
+  });
+
+  describe('string', () => {
+    it('should have toCode', () => {
+      expect(scalarTypes.string().toCode('t')).toBe('t.string()');
+
+      expect(scalarTypes.string().nonEmpty().toCode('t')).toBe(
+        't.string().nonEmpty()',
+      );
+
+      expect(
+        scalarTypes
+          .string()
+          .min(1)
+          .max(10)
+          .length(15)
+          .email()
+          .url()
+          .uuid()
+          .cuid()
+          .startsWith('start')
+          .endsWith('end')
+          .trim()
+          .toCode('t'),
+      ).toBe(
+        `t.string().min(1).max(10).length(15).email().url().uuid().cuid().startsWith('start').endsWith('end').trim()`,
+      );
+
+      expect(scalarTypes.string().regex(/\d+/g).toCode('t')).toBe(
+        `t.string().regex(/\\d+/g)`,
+      );
+    });
+  });
+
+  describe('undefined', () => {
+    it('should have toCode', () => {
+      expect(scalarTypes.undefined().toCode('t')).toBe('t.undefined()');
+    });
+  });
+
+  describe('unknown', () => {
+    it('should have toCode', () => {
+      expect(scalarTypes.unknown().toCode('t')).toBe('t.unknown()');
+    });
+  });
+
+  describe('void', () => {
+    it('should have toCode', () => {
+      expect(scalarTypes.void().toCode('t')).toBe('t.void()');
+    });
+  });
+});