orchid-orm-schema-to-zod 0.4.44 → 0.5.0

package/dist/index.d.ts

@@ -1,93 +1,127 @@
-import * as orchid_core from 'orchid-core';
-import { JSONDiscriminatedUnion, JSONType, ColumnTypeBase, JSONUnion, JSONArray, JSONEnum, JSONLiteral, JSONNativeEnum, JSONTuple, JSONTupleItems, JSONObject, JSONObjectShape, UnknownKeysParam, JSONRecord, JSONString, JSONNumber, JSONIntersection, ColumnsShapeBase } from 'orchid-core';
-import { EnumColumn, ArrayColumn, JSONColumn, VirtualColumn } from 'pqb';
-import { z } from 'zod';
-import { Buffer } from 'node:buffer';
+import { ParseColumn, EncodeColumn, AsTypeArg, ColumnTypeBase, ErrorMessage, NullableColumn, StringTypeData, ColumnSchemaGetterTableClass, ErrorMessages, ColumnSchemaGetterColumns, Code } from 'orchid-core';
+import { EnumColumn, ArrayColumnValue, DateBaseColumn, ColumnType, OperatorsJson, ColumnData, ArrayColumn } from 'pqb';
+import { ZodTypeAny, ZodEnum, ZodNullable, ZodUnknown, ZodBoolean, ZodType, ZodNever, ZodString, ZodNumber, ZodDate, ZodObject, ZodOptional, ZodArray } from 'zod';
 
-type NumberType = 'smallint' | 'integer' | 'real' | 'smallserial' | 'serial' | 'money';
-type BigIntType = 'bigint' | 'numeric' | 'decimal' | 'double precision' | 'bigserial';
-type StringType = 'varchar' | 'char' | 'text' | 'string' | 'xml' | 'json';
-type DateTimeType = 'date' | 'timestamp' | 'timestamptz';
-type TimeType = 'time' | 'time with time zone';
-type GeometryType = 'point' | 'line' | 'lseg' | 'box' | 'path' | 'polygon' | 'circle';
-type NetworkType = 'cidr' | 'inet' | 'macaddr' | 'macaddr8';
-type BitStringType = 'bit' | 'bit varying';
-type FullTextSearchType = 'tsvector' | 'tsquery';
-type UUIDType = 'uuid';
-type ByteaType = 'bytea';
-type SchemaToZod<T extends ColumnTypeBase, D = T['dataType']> = T['data']['isNullable'] extends true ? z.ZodNullable<SchemaToZod<Omit<T, 'data'> & {
-    data: Omit<T['data'], 'isNullable'> & {
-        isNullable: false;
-    };
-}>> : D extends NumberType ? z.ZodNumber : D extends BigIntType | StringType | TimeType | GeometryType | NetworkType | BitStringType | FullTextSearchType | UUIDType ? z.ZodString : D extends ByteaType ? z.ZodType<Buffer> : D extends DateTimeType ? z.ZodDate : D extends 'interval' ? typeof interval : D extends 'boolean' ? z.ZodBoolean : T extends EnumColumn<any, any> ? z.ZodEnum<T['options']> : T extends ArrayColumn<any> ? z.ZodArray<SchemaToZod<T['data']['item']>> : T extends JSONColumn<JSONType> ? JsonToZod<T['data']['schema']> : T extends VirtualColumn ? z.ZodNever : never;
-declare module 'orchid-core' {
-    interface JSONType {
-        zod: z.ZodTypeAny;
-    }
-    interface JSONUnknown {
-        zod: z.ZodUnknown;
-    }
-    interface JSONBoolean {
-        zod: z.ZodBoolean;
-    }
-    interface JSONNull {
-        zod: z.ZodNull;
-    }
-    interface JSONNumber {
-        zod: z.ZodNumber;
-    }
-    interface JSONString {
-        zod: z.ZodString;
-    }
+type ParseDateToNumber = ParseColumn<DateBaseColumn<ZodSchemaConfig>, ZodNumber, number>;
+type ParseDateToDate = ParseColumn<DateBaseColumn<ZodSchemaConfig>, ZodDate, Date>;
+declare class ZodJSONColumn<ZodSchema extends ZodTypeAny> extends ColumnType<ZodSchemaConfig, ZodSchema['_output'], ZodSchema, OperatorsJson> {
+    dataType: "jsonb";
+    operators: OperatorsJson;
+    data: ColumnData;
+    constructor(schema: ZodSchema);
+    toCode(t: string): Code;
 }
-type JsonToZod<T extends JSONType> = T['data']['nullable'] extends true ? z.ZodNullable<JsonNotNullableToZod<T>> : JsonNotNullableToZod<T>;
-type JsonNotNullableToZod<T extends JSONType> = T['data']['optional'] extends true ? z.ZodOptional<JsonNotOptionalToZod<T>> : JsonNotOptionalToZod<T>;
-type JsonNotOptionalToZod<T extends JSONType> = T extends JSONUnion<any> ? z.ZodUnion<MapUnionArgs<T['data']['types']>> : T extends JSONArray<JSONType> ? z.ZodArray<JsonToZod<T['data']['item']>> : T extends JSONEnum<any, any> ? z.ZodEnum<T['data']['options']> : T extends JSONLiteral<any> ? z.ZodLiteral<T['data']['value']> : T extends JSONNativeEnum<any> ? z.ZodNativeEnum<T['data']['enum']> : T extends JSONTuple<JSONTupleItems, JSONType | undefined> ? z.ZodTuple<MapJsonTuple<T['data']['items']>, T['data']['rest'] extends JSONType ? JsonToZod<T['data']['rest']> : null> : T extends JSONObject<JSONObjectShape, UnknownKeysParam> ? z.ZodObject<{
-    [K in keyof T['data']['shape']]: JsonToZod<T['data']['shape'][K]>;
-}, T['data']['unknownKeys'], JsonToZod<T['data']['catchAll']>> : T extends JSONRecord<JSONString | JSONNumber, JSONType> ? T['data']['key'] extends JSONString ? z.ZodRecord<z.ZodString, JsonToZod<T['data']['value']>> : z.ZodRecord<z.ZodNumber, JsonToZod<T['data']['value']>> : T extends JSONIntersection<JSONType, JSONType> ? z.ZodIntersection<JsonToZod<T['data']['left']>, JsonToZod<T['data']['right']>> : T extends JSONDiscriminatedUnion<string, any> ? MapDiscriminatedUnion<T> : T['zod'];
-type MapDiscriminatedUnion<T extends JSONDiscriminatedUnion<string, any>, Options = MapJsonTuple<T['data']['types']>> = z.ZodDiscriminatedUnion<T['data']['discriminator'], Options extends z.ZodDiscriminatedUnionOption<T['data']['discriminator']>[] ? Options : never>;
-type MapUnionArgs<T extends unknown[]> = T extends [
-    infer F extends JSONType,
-    infer S extends JSONType,
-    ...infer Tail
-] ? [JsonToZod<F>, JsonToZod<S>, ...MapJsonTuple<Tail>] : never;
-type MapJsonTuple<T extends unknown[]> = T extends [infer Head, ...infer Tail] ? [Head extends JSONType ? JsonToZod<Head> : never, ...MapJsonTuple<Tail>] : [];
-type Columns = {
-    shape: ColumnsShapeBase;
-};
-type Table = {
-    columns: ColumnsShapeBase;
+type ArrayMethods<Value> = {
+    min<T extends ColumnTypeBase>(this: T, value: Value, params?: ErrorMessage): T;
+    max<T extends ColumnTypeBase>(this: T, value: Value, params?: ErrorMessage): T;
+    length<T extends ColumnTypeBase>(this: T, value: Value, params?: ErrorMessage): T;
+    nonEmpty<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
 };
-type TableClass<T extends Table> = {
-    new (): T;
-    instance(): unknown;
+interface ZodArrayColumn<Item extends ArrayColumnValue> extends ArrayColumn<ZodSchemaConfig, Item, ZodArray<Item['inputSchema']>, ZodArray<Item['outputSchema']>, ZodArray<Item['querySchema']>>, ArrayMethods<number> {
+}
+declare class ZodArrayColumn<Item extends ArrayColumnValue> extends ArrayColumn<ZodSchemaConfig, Item, ZodArray<Item['inputSchema']>, ZodArray<Item['outputSchema']>, ZodArray<Item['querySchema']>> {
+    constructor(item: Item);
+}
+type ZodSchemaConfig = {
+    type: ZodTypeAny;
+    parse<T extends {
+        type: unknown;
+    }, OutputSchema extends ZodTypeAny, Output = OutputSchema['_output']>(this: T, _schema: OutputSchema, fn: (input: T['type']) => Output): ParseColumn<T, OutputSchema, Output>;
+    encode<T extends {
+        type: unknown;
+    }, InputSchema extends ZodTypeAny, Input = InputSchema['_output']>(this: T, _schema: InputSchema, fn: (input: Input) => unknown): EncodeColumn<T, InputSchema, Input>;
+    asType<T, Types extends AsTypeArg<ZodTypeAny>, TypeSchema extends ZodTypeAny = Types extends {
+        type: ZodTypeAny;
+    } ? Types['type'] : never, Type = TypeSchema['_output']>(this: T, types: Types): Omit<T, 'type' | 'inputType' | 'inputSchema' | 'outputType' | 'outputSchema' | 'queryType' | 'querySchema'> & {
+        type: Type;
+        inputType: Types['input'] extends ZodTypeAny ? Types['input']['_output'] : Type;
+        inputSchema: Types['input'] extends ZodTypeAny ? Types['input'] : TypeSchema;
+        outputType: Types['output'] extends ZodTypeAny ? Types['output']['_output'] : Type;
+        outputSchema: Types['output'] extends ZodTypeAny ? Types['output'] : TypeSchema;
+        queryType: Types['query'] extends ZodTypeAny ? Types['query']['_output'] : Type;
+        querySchema: Types['query'] extends ZodTypeAny ? Types['query'] : TypeSchema;
+    };
+    dateAsNumber(): ParseDateToNumber;
+    dateAsDate(): ParseDateToDate;
+    dateMethods: {
+        min<T extends ColumnTypeBase>(this: T, value: Date, params?: ErrorMessage): T;
+        max<T extends ColumnTypeBase>(this: T, value: Date, params?: ErrorMessage): T;
+    };
+    enum<U extends string, T extends [U, ...U[]]>(dataType: string, type: T): EnumColumn<ZodSchemaConfig, ZodEnum<T>, U, T>;
+    array<Item extends ArrayColumnValue>(item: Item): ZodArrayColumn<Item>;
+    nullable<T extends ColumnTypeBase>(this: T): NullableColumn<T, ZodNullable<T['inputSchema']>, ZodNullable<T['outputSchema']>, ZodNullable<T['querySchema']>>;
+    json<ZodSchema extends ZodTypeAny = ZodUnknown>(schema?: ZodSchema): ZodJSONColumn<ZodSchema>;
+    boolean: ZodBoolean;
+    buffer: ZodType<Buffer>;
+    unknown: ZodUnknown;
+    never: ZodNever;
+    string: ZodString;
+    stringMin(max: number): ZodString;
+    stringMax(max: number): ZodString;
+    stringMinMax(min: number, max: number): ZodString;
+    stringMethods: ArrayMethods<number> & {
+        email<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+        url<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+        emoji<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+        uuid<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+        cuid<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+        cuid2<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+        ulid<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+        regex<T extends ColumnTypeBase>(this: T, value: RegExp, params?: ErrorMessage): T;
+        includes<T extends ColumnTypeBase, Value extends string>(this: T, value: Value, params?: ErrorMessage): T;
+        startsWith<T extends ColumnTypeBase, Value extends string>(this: T, value: Value, params?: ErrorMessage): T;
+        endsWith<T extends ColumnTypeBase, Value extends string>(this: T, value: Value, params?: ErrorMessage): T;
+        datetime<T extends ColumnTypeBase>(this: T, params?: StringTypeData['datetime'] & Exclude<ErrorMessage, string>): T;
+        ip<T extends ColumnTypeBase>(this: T, params?: StringTypeData['ip'] & Exclude<ErrorMessage, string>): T;
+        trim<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+        toLowerCase<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+        toUpperCase<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+    };
+    number: ZodNumber;
+    numberMethods: {
+        lt<T extends ColumnTypeBase>(this: T, value: number, params?: ErrorMessage): T;
+        lte<T extends ColumnTypeBase>(this: T, value: number, params?: ErrorMessage): T;
+        max<T extends ColumnTypeBase>(this: T, value: number, params?: ErrorMessage): T;
+        gt<T extends ColumnTypeBase>(this: T, value: number, params?: ErrorMessage): T;
+        gte<T extends ColumnTypeBase>(this: T, value: number, params?: ErrorMessage): T;
+        min<T extends ColumnTypeBase>(this: T, value: number, params?: ErrorMessage): T;
+        positive<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+        nonNegative<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+        negative<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+        nonPositive<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+        step<T extends ColumnTypeBase>(this: T, value: number, params?: ErrorMessage): T;
+        int<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+        finite<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+        safe<T extends ColumnTypeBase>(this: T, params?: ErrorMessage): T;
+    };
+    int: ZodNumber;
+    stringNumberDate: ZodDate;
+    timeInterval: ZodObject<{
+        years: ZodOptional<ZodNumber>;
+        months: ZodOptional<ZodNumber>;
+        days: ZodOptional<ZodNumber>;
+        hours: ZodOptional<ZodNumber>;
+        minutes: ZodOptional<ZodNumber>;
+        seconds: ZodOptional<ZodNumber>;
+    }>;
+    bit(max: number): ZodString;
+    uuid: ZodString;
+    inputSchema<T extends ColumnSchemaGetterTableClass>(this: T): MapSchema<T, 'inputSchema'>;
+    outputSchema<T extends ColumnSchemaGetterTableClass>(this: T): MapSchema<T, 'outputSchema'>;
+    querySchema<T extends ColumnSchemaGetterTableClass>(this: T): MapSchema<T, 'querySchema'>;
+    updateSchema<T extends ColumnSchemaGetterTableClass>(this: T): UpdateSchema<T>;
+    pkeySchema<T extends ColumnSchemaGetterTableClass>(this: T): PkeySchema<T>;
+    errors<T extends ColumnTypeBase>(this: T, errors: ErrorMessages): T;
 };
-type InstanceToZod<T extends Columns> = z.ZodObject<{
-    [K in keyof T['shape']]: SchemaToZod<T['shape'][K]>;
-}>;
-declare const instanceToZod: <T extends Columns>({ shape, }: T) => InstanceToZod<T>;
-declare const zodSchemaProvider: <T extends Table>(this: TableClass<T>) => InstanceToZod<{
-    shape: T["columns"];
-}>;
-declare const columnToZod: <T extends ColumnTypeBase<unknown, orchid_core.BaseOperators, unknown, unknown, unknown, orchid_core.ColumnDataBase>>(column: T) => SchemaToZod<T, T["dataType"]>;
-declare const interval: z.ZodObject<{
-    years: z.ZodOptional<z.ZodNumber>;
-    months: z.ZodOptional<z.ZodNumber>;
-    days: z.ZodOptional<z.ZodNumber>;
-    hours: z.ZodOptional<z.ZodNumber>;
-    seconds: z.ZodOptional<z.ZodNumber>;
-}, "strict", z.ZodTypeAny, {
-    years?: number | undefined;
-    months?: number | undefined;
-    days?: number | undefined;
-    hours?: number | undefined;
-    seconds?: number | undefined;
-}, {
-    years?: number | undefined;
-    months?: number | undefined;
-    days?: number | undefined;
-    hours?: number | undefined;
-    seconds?: number | undefined;
-}>;
+declare const zodSchemaConfig: ZodSchemaConfig;
+type MapSchema<T extends ColumnSchemaGetterTableClass, Key extends 'inputSchema' | 'outputSchema' | 'querySchema'> = ZodObject<{
+    [K in keyof ColumnSchemaGetterColumns<T>]: ColumnSchemaGetterColumns<T>[K][Key];
+}, 'strip'>;
+type UpdateSchema<T extends ColumnSchemaGetterTableClass> = ZodObject<{
+    [K in keyof ColumnSchemaGetterColumns<T>]: ZodOptional<ColumnSchemaGetterColumns<T>[K]['inputSchema']>;
+}, 'strip'>;
+type PkeySchema<T extends ColumnSchemaGetterTableClass> = ZodObject<{
+    [K in keyof ColumnSchemaGetterColumns<T> as ColumnSchemaGetterColumns<T>[K]['data']['isPrimaryKey'] extends true ? K : never]: ColumnSchemaGetterColumns<T>[K]['inputSchema'];
+}, 'strip'>;
 
-export { InstanceToZod, MapDiscriminatedUnion, columnToZod, instanceToZod, zodSchemaProvider };
+export { ZodSchemaConfig, zodSchemaConfig };