pqb 0.0.1

package/src/columnSchema/json/nullable.ts

@@ -0,0 +1,33 @@
+import { JSONTypeAny } from './typeBase';
+
+export type JSONNullable<T extends JSONTypeAny> = Omit<T, 'type' | 'data'> & {
+  type: T['type'] | null;
+  data: T['data'] & { nullable: true };
+};
+
+export const nullable = <T extends JSONTypeAny>(type: T): JSONNullable<T> => {
+  return {
+    ...type,
+    data: { ...type.data, nullable: true },
+  };
+};
+
+export type JSONNotNullable<T extends JSONTypeAny> = Omit<
+  T,
+  'type' | 'data'
+> & {
+  type: Exclude<T['type'], null>;
+  data: Omit<T['data'], 'nullable'>;
+};
+
+export const notNullable = <T extends JSONTypeAny>(
+  type: T,
+): JSONNotNullable<T> => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { nullable: _, ...data } = type.data;
+
+  return {
+    ...type,
+    data,
+  } as JSONNotNullable<T>;
+};

package/src/columnSchema/json/nullish.ts

@@ -0,0 +1,30 @@
+import { JSONTypeAny } from './typeBase';
+
+export type JSONNullish<T extends JSONTypeAny> = Omit<T, 'type' | 'data'> & {
+  type: T['type'] | undefined | null;
+  data: T['data'] & { nullable: true };
+};
+
+export const nullish = <T extends JSONTypeAny>(type: T): JSONNullish<T> => {
+  return {
+    ...type,
+    data: { ...type.data, nullable: true, optional: true },
+  };
+};
+
+export type JSONNotNullish<T extends JSONTypeAny> = Omit<T, 'type' | 'data'> & {
+  type: Exclude<T['type'], undefined | null>;
+  data: Omit<T['data'], 'nullable'>;
+};
+
+export const notNullish = <T extends JSONTypeAny>(
+  type: T,
+): JSONNotNullish<T> => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { nullable, optional, ...data } = type.data;
+
+  return {
+    ...type,
+    data,
+  } as JSONNotNullish<T>;
+};

package/src/columnSchema/json/object.ts

@@ -0,0 +1,206 @@
+import { constructType, DeepPartial, JSONType, JSONTypeAny } from './typeBase';
+import { JSONOptional, optional } from './optional';
+
+export type JSONObjectShape = Record<string, JSONTypeAny>;
+
+export type UnknownKeysParam = 'passthrough' | 'strict' | 'strip';
+
+type FullyPartial<T extends JSONObjectShape> = {
+  [K in keyof T]: JSONOptional<T[K]>;
+};
+
+type PartiallyPartial<T extends JSONObjectShape, P extends keyof T> = {
+  [K in keyof T]: K extends P ? JSONOptional<T[K]> : T[K];
+};
+
+export type identity<T> = T;
+
+export type flatten<T extends object> = identity<{ [k in keyof T]: T[k] }>;
+
+type optionalKeys<T extends object> = {
+  [k in keyof T]: undefined extends T[k] ? k : never;
+}[keyof T];
+
+type requiredKeys<T extends object> = {
+  [k in keyof T]: undefined extends T[k] ? never : k;
+}[keyof T];
+
+export type addQuestionMarks<T extends object> = Partial<
+  Pick<T, optionalKeys<T>>
+> &
+  Pick<T, requiredKeys<T>>;
+
+export type baseObjectOutputType<Shape extends JSONObjectShape> = flatten<
+  addQuestionMarks<{
+    [k in keyof Shape]: Shape[k]['type'];
+  }>
+>;
+
+type objectOutputType<
+  Shape extends JSONObjectShape,
+  Catchall extends JSONTypeAny,
+> = JSONTypeAny extends Catchall
+  ? baseObjectOutputType<Shape>
+  : flatten<baseObjectOutputType<Shape> & { [k: string]: Catchall['type'] }>;
+
+export type IsEqual<T, U> = (<G>() => G extends T ? 1 : 2) extends <
+  G,
+>() => G extends U ? 1 : 2
+  ? true
+  : false;
+
+type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true
+  ? never
+  : KeyType extends ExcludeType
+  ? never
+  : KeyType;
+
+export type Except<ObjectType, KeysType extends keyof ObjectType> = {
+  [KeyType in keyof ObjectType as Filter<
+    KeyType,
+    KeysType
+  >]: ObjectType[KeyType];
+};
+
+export type Merge<FirstType, SecondType> = Except<
+  FirstType,
+  Extract<keyof FirstType, keyof SecondType>
+> &
+  SecondType;
+
+export interface JSONObject<
+  T extends JSONObjectShape,
+  UnknownKeys extends UnknownKeysParam = 'strip',
+  Catchall extends JSONTypeAny = JSONTypeAny,
+  Output = objectOutputType<T, Catchall>,
+> extends JSONType<Output, 'object'> {
+  shape: T;
+  unknownKeys: UnknownKeys;
+  catchAllType: Catchall;
+  extend<S extends JSONObjectShape>(
+    shape: S,
+  ): JSONObject<Merge<T, S>, UnknownKeys, Catchall>;
+  merge<
+    S extends JSONObjectShape,
+    U extends UnknownKeysParam,
+    C extends JSONTypeAny,
+  >(
+    obj: JSONObject<S, U, C>,
+  ): JSONObject<Merge<T, S>, U, C>;
+  pick<K extends keyof T>(
+    ...arr: K[]
+  ): JSONObject<Pick<T, K>, UnknownKeys, Catchall>;
+  omit<K extends keyof T>(
+    ...arr: K[]
+  ): JSONObject<Omit<T, K>, UnknownKeys, Catchall>;
+  partial(): JSONObject<FullyPartial<T>, UnknownKeys, Catchall>;
+  partial<P extends keyof T>(
+    ...arr: P[]
+  ): JSONObject<PartiallyPartial<T, P>, UnknownKeys, Catchall>;
+  deepPartial(): JSONObject<
+    { [k in keyof T]: JSONOptional<DeepPartial<T[k]>> },
+    UnknownKeys,
+    Catchall
+  >;
+  passthrough(): JSONObject<T, 'passthrough', Catchall>;
+  strict(): JSONObject<T, 'strict', Catchall>;
+  strip(): JSONObject<T, 'strip', Catchall>;
+  catchAll<C extends JSONTypeAny>(type: C): JSONObject<T, UnknownKeys, C>;
+}
+
+export const object = <
+  T extends JSONObjectShape,
+  UnknownKeys extends UnknownKeysParam = 'strip',
+  Catchall extends JSONTypeAny = JSONTypeAny,
+>(
+  shape: T,
+): JSONObject<T, UnknownKeys, Catchall> => {
+  return constructType<JSONObject<T, UnknownKeys, Catchall>>({
+    dataType: 'object' as const,
+    shape,
+    unknownKeys: 'strip' as UnknownKeys,
+    catchAllType: undefined as unknown as Catchall,
+    extend<S extends JSONObjectShape>(add: S) {
+      return object<Merge<T, S>, UnknownKeys, Catchall>(
+        Object.assign({ ...this.shape }, add),
+      );
+    },
+    merge<
+      S extends JSONObjectShape,
+      U extends UnknownKeysParam,
+      C extends JSONTypeAny,
+    >(obj: JSONObject<S, U, C>) {
+      return object<Merge<T, S>, U, C>(
+        Object.assign({ ...this.shape }, obj.shape),
+      );
+    },
+    pick<K extends keyof T>(...arr: K[]) {
+      const picked = {} as Pick<T, K>;
+      arr.forEach((key) => (picked[key] = this.shape[key]));
+      return object<Pick<T, K>, UnknownKeys, Catchall>(picked);
+    },
+    omit<K extends keyof T>(...arr: K[]) {
+      const picked = {} as Omit<T, K>;
+      for (const key in this.shape) {
+        if (!arr.includes(key as unknown as K)) {
+          (picked as T)[key] = this.shape[key];
+        }
+      }
+      return object<Omit<T, K>, UnknownKeys, Catchall>(picked);
+    },
+    partial<P extends keyof T>(...arr: P[]) {
+      const mapped = { ...this.shape };
+
+      if (arr.length) {
+        arr.forEach((key) => {
+          mapped[key] = mapped[key].optional();
+        });
+      } else {
+        for (const key in mapped) {
+          mapped[key] = mapped[key].optional();
+        }
+      }
+
+      return object<typeof mapped, UnknownKeys, Catchall>(mapped);
+    },
+    deepPartial(this: JSONObject<T, UnknownKeys, Catchall>) {
+      const newShape: JSONObjectShape = {};
+
+      for (const key in this.shape) {
+        newShape[key] = optional(this.shape[key].deepPartial());
+      }
+
+      return {
+        ...this,
+        shape: newShape,
+      };
+    },
+    passthrough(this: JSONObject<T, UnknownKeys, Catchall>) {
+      return {
+        ...this,
+        unknownKeys: 'passthrough',
+      } as JSONObject<T, 'passthrough', Catchall>;
+    },
+    strict(this: JSONObject<T, UnknownKeys, Catchall>) {
+      return {
+        ...this,
+        unknownKeys: 'strict',
+      } as JSONObject<T, 'strict', Catchall>;
+    },
+    strip(this: JSONObject<T, UnknownKeys, Catchall>) {
+      return {
+        ...this,
+        unknownKeys: 'strip',
+      } as JSONObject<T, 'strip', Catchall>;
+    },
+    catchAll<C extends JSONTypeAny>(
+      this: JSONObject<T, UnknownKeys, C>,
+      type: C,
+    ) {
+      return {
+        ...this,
+        catchAllType: type,
+      };
+    },
+  });
+};

package/src/columnSchema/json/optional.ts

@@ -0,0 +1,28 @@
+import { JSONTypeAny } from './typeBase';
+
+export type JSONOptional<T extends JSONTypeAny> = Omit<T, 'type' | 'data'> & {
+  type: T['type'] | undefined;
+  data: T['data'] & { optional: true };
+};
+
+export const optional = <T extends JSONTypeAny>(type: T): JSONOptional<T> => {
+  return {
+    ...type,
+    data: { ...type.data, optional: true },
+  };
+};
+
+export type JSONRequired<T extends JSONTypeAny> = Omit<T, 'type' | 'data'> & {
+  type: Exclude<T['type'], undefined>;
+  data: Omit<T['data'], 'optional'>;
+};
+
+export const required = <T extends JSONTypeAny>(type: T): JSONRequired<T> => {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { optional: _, ...data } = type.data;
+
+  return {
+    ...type,
+    data,
+  } as JSONRequired<T>;
+};

package/src/columnSchema/json/record.ts

@@ -0,0 +1,40 @@
+import { constructType, JSONType, JSONTypeAny } from './typeBase';
+import { JSONNumber, JSONString, scalarTypes } from './scalarTypes';
+
+export interface JSONRecord<Key extends KeyType, Value extends JSONTypeAny>
+  extends JSONType<Record<Key['type'], Value['type']>, 'record'> {
+  keyType: Key;
+  valueType: Value;
+  deepPartial(): JSONRecord<Key, ReturnType<Value['deepPartial']>>;
+}
+
+type KeyType = JSONType<string | number, 'string' | 'number'>;
+type Args<Key extends KeyType, Value extends JSONTypeAny> =
+  | Args2<Key, Value>
+  | Args1<Key>;
+
+type Args2<Key extends KeyType, Value extends JSONTypeAny> = [
+  key: Key,
+  value: Value,
+];
+type Args1<Value extends JSONTypeAny> = [value: Value];
+
+export function record(
+  ...args: Args<JSONString | JSONNumber, JSONTypeAny>
+): JSONRecord<JSONString | JSONNumber, JSONTypeAny> {
+  const [keyType, valueType] = (
+    args.length === 1 ? [scalarTypes.string(), args[0]] : args
+  ) as Args2<JSONString | JSONNumber, JSONTypeAny>;
+
+  return constructType<JSONRecord<JSONString | JSONNumber, JSONTypeAny>>({
+    dataType: 'record',
+    keyType,
+    valueType,
+    deepPartial(this: JSONRecord<JSONString, JSONTypeAny>) {
+      return {
+        ...this,
+        valueType: this.valueType.deepPartial(),
+      };
+    },
+  });
+}

package/src/columnSchema/json/scalarTypes.ts

@@ -0,0 +1,117 @@
+import { constructType, JSONType, JSONTypeAny } from './typeBase';
+import { BaseNumberData } from '../number';
+import { BaseStringData } from '../string';
+import { numberTypeMethods, stringTypeMethods } from '../commonMethods';
+
+export type JSONAny = JSONTypeAny & {
+  dataType: 'any';
+};
+const any = () => {
+  return constructType<JSONAny>({
+    dataType: 'any',
+  });
+};
+
+export type JSONBigInt = JSONType<bigint, 'bigint'> & {
+  data: BaseNumberData;
+} & typeof bigIntMethods;
+const bigIntMethods = {
+  dataType: 'bigint' as const,
+  ...numberTypeMethods<JSONType<bigint, 'bigint'> & { data: BaseNumberData }>(),
+};
+const bigint = () => {
+  return constructType<JSONBigInt>(bigIntMethods);
+};
+
+export type JSONBoolean = JSONType<boolean, 'boolean'>;
+const boolean = () => {
+  return constructType<JSONBoolean>({
+    dataType: 'boolean',
+  });
+};
+
+export type JSONNaN = JSONType<number, 'nan'>;
+const nan = () => {
+  return constructType<JSONNaN>({
+    dataType: 'nan',
+  });
+};
+
+export type JSONNever = JSONType<unknown, 'never'>;
+const never = () => {
+  return constructType<JSONNever>({
+    dataType: 'never',
+  });
+};
+
+export type JSONNull = JSONType<null, 'null'>;
+const nullType = () => {
+  return constructType<JSONNull>({
+    dataType: 'null',
+  });
+};
+
+export type JSONNumber = JSONType<number, 'number'> & {
+  data: BaseNumberData;
+} & typeof numberMethods;
+const numberMethods = {
+  ...numberTypeMethods<JSONType<number, 'number'> & { data: BaseNumberData }>(),
+  dataType: 'number' as const,
+};
+const number = () => {
+  return constructType<JSONNumber>(numberMethods);
+};
+
+export type JSONDate = JSONType<Date, 'date'>;
+const date = () => {
+  return constructType<JSONDate>({
+    dataType: 'date',
+  });
+};
+
+export type JSONString = JSONType<string, 'string'> & {
+  data: BaseStringData;
+} & typeof stringMethods;
+const stringMethods = {
+  ...stringTypeMethods<JSONType<number, 'string'> & { data: BaseStringData }>(),
+  dataType: 'string' as const,
+};
+const string = () => {
+  return constructType<JSONString>(stringMethods);
+};
+
+export type JSONUndefined = JSONType<undefined, 'undefined'>;
+const undefinedType = () => {
+  return constructType<JSONUndefined>({
+    dataType: 'undefined',
+  });
+};
+
+export type JSONUnknown = JSONType<unknown, 'unknown'>;
+const unknown = () => {
+  return constructType<JSONUnknown>({
+    dataType: 'unknown',
+  });
+};
+
+export type JSONVoid = JSONType<void, 'void'>;
+const voidType = () => {
+  return constructType<JSONVoid>({
+    dataType: 'void',
+  });
+};
+
+export const scalarTypes = {
+  any,
+  bigint,
+  boolean,
+  date,
+  nan,
+  never,
+  null: nullType,
+  number,
+  string,
+  undefined: undefinedType,
+  unknown,
+  void: voidType,
+};

package/src/columnSchema/json/set.ts

@@ -0,0 +1,34 @@
+import { constructType, JSONType, JSONTypeAny, JSONTypeData } from './typeBase';
+import { ArrayMethods, arrayMethods } from '../commonMethods';
+
+export interface JSONSet<Value extends JSONTypeAny>
+  extends JSONType<Set<Value['type']>, 'set'>,
+    ArrayMethods {
+  data: JSONTypeData & {
+    min?: number;
+    max?: number;
+    length?: number;
+  };
+  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,
+    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 };
+      };
+    },
+    ...arrayMethods,
+  });
+};

package/src/columnSchema/json/tuple.ts

@@ -0,0 +1,40 @@
+import { constructType, DeepPartial, JSONType, JSONTypeAny } from './typeBase';
+
+export interface JSONTuple<
+  T extends JSONTupleItems | [] = JSONTupleItems,
+  Rest extends JSONTypeAny | null = null,
+> extends JSONType<OutputTypeOfTupleWithRest<T, Rest>, 'tuple'> {
+  items: T;
+  deepPartial(): {
+    [k in keyof T]: T[k] extends JSONTypeAny ? DeepPartial<T[k]> : never;
+  } extends infer PI
+    ? PI extends JSONTupleItems
+      ? JSONTuple<PI>
+      : never
+    : never;
+}
+
+export type JSONTupleItems = [JSONTypeAny, ...JSONTypeAny[]];
+export type AssertArray<T> = T extends unknown[] ? T : never;
+export type OutputTypeOfTuple<T extends JSONTupleItems | []> = AssertArray<{
+  [k in keyof T]: T[k] extends JSONTypeAny ? T[k]['type'] : never;
+}>;
+export type OutputTypeOfTupleWithRest<
+  T extends JSONTupleItems | [],
+  Rest extends JSONTypeAny | null = null,
+> = Rest extends JSONTypeAny
+  ? [...OutputTypeOfTuple<T>, ...Rest['type'][]]
+  : OutputTypeOfTuple<T>;
+
+export const tuple = <T extends JSONTupleItems | []>(items: T) => {
+  return constructType<JSONTuple<T>>({
+    dataType: 'tuple',
+    items,
+    deepPartial(this: JSONTuple<T>) {
+      return {
+        ...this,
+        items: this.items.map((item) => item.deepPartial()),
+      };
+    },
+  });
+};