export function minizod() { type UnknownInput = unknown | undefined | null; type ZType = | ZAny | ZUnknown | ZPromise | ZFunction | ZString | ZTuple< [ ZType, ...ZType[], ] | [] > | ZArray | ZObject> | ZRecord; type Infer = T["type"] extends "unknown" ? unknown : T["type"] extends "string" ? string : T extends ZTuple ? InferTuple : T["type"] extends "object" ? InferObject : T extends ZRecord ? InferRecord : T["type"] extends "array" ? InferArray : T["type"] extends "promise" ? InferPromise : T["type"] extends "any" ? any : "invalid type"; type InferPromise = T extends ZPromise ? Promise> : never; type InferArray = T extends ZArray ? Array> : never; type InferRecord = T extends ZRecord ? Record> : never; type InferObject = T extends ZObject> ? { [k in keyof Obj]: Infer; } : never; type InferFunction = T extends ZFunction< infer Args extends ZTuple< [ ZType, ...ZType[], ] | [] >, infer Ret extends ZType > ? (...args: InferTuple) => Infer : never; type InferForEach = T extends [] ? [] : T extends [ infer First extends ZType, ] ? [ Infer, ] : T extends [ infer First extends ZType, ...infer Rest extends ZType[], ] ? [ Infer, ...InferForEach, ] : []; type InferTuple< T extends ZTuple< [] | [ ZType, ...ZType[], ] >, > = T extends ZTuple<[]> ? [] : T extends ZTuple<[ infer First extends ZType, ...infer Rest extends ZType[], ]> ? [ Infer, ...InferForEach, ] : []; class ZRecord { type: "record" = "record"; __vals: V; constructor(__vals: V) { this.__vals = __vals; } async parse(val: UnknownInput): Promise>> { if (val === undefined || val === null) throw new Error("undefined"); for (const key in val) { if (typeof key !== "string") throw new Error(`Key ${key} is not a string`); // @ts-expect-error await this.__vals.parse(val[key]); } return val as any; } parseSync(val: UnknownInput): Record> { if (val === undefined || val === null) throw new Error("undefined"); for (const key in val) { if (typeof key !== "string") throw new Error(`Key ${key} is not a string`); // @ts-expect-error this.__vals.parse(val[key]); } return val as any; } toTs(): string { return `Record`; } } class ZAny { type: "any" = "any"; async parse(val: UnknownInput): Promise { return val; } parseSync(val: UnknownInput): any { return val; } toTs(): string { return `any`; } } class ZPromise { type: "promise" = "promise"; __inner: T; constructor(__inner: T) { this.__inner = __inner; } return(ty: NewT): ZPromise { return new ZPromise(ty); } async parse(val: UnknownInput): Promise { if (val === undefined || val === null) throw new Error("undefined"); const result = await val; return this.__inner.parse(result) as any; } parseSync(val: UnknownInput): undefined { throw new Error("Promise input invalid in parseSync"); } toTs(): string { return `Promise<${this.__inner.toTs()}>`; } } class ZArray { type: "array" = "array"; __element: T; constructor(__element: T) { this.__element = __element; } element(el: NewT): ZArray { return new ZArray(el); } async parse(value: unknown): Promise>> { if (Array.isArray(value)) { const arr = value.map((v) => this.__element.parse(v)); return Promise.all(arr) as any; } throw new Error("value is not an array"); } parseSync(value: unknown): Array> { if (Array.isArray(value)) { const arr = value.map((v) => this.__element.parseSync(v)); return arr as any; } throw new Error("value is not an array"); } toTs(): string { return `Array<${this.__element.toTs()}>`; } } class ZUnknown { type: "unknown" = "unknown"; async parse(val: unknown): Promise { return val; } parseSync(val: unknown): unknown { return val; } toTs(): string { return `unknown`; } } class ZString { type: "string" = "string"; async parse(val: unknown): Promise { return this.parseSync(val); } parseSync(val: unknown): string { if (typeof val === "string") { return val; } throw new Error("Not a string"); } toTs(): string { return `string`; } } class ZObject> { type: "object" = "object"; __fields: R; constructor(__fields: R) { this.__fields = __fields; } async parse(val: UnknownInput): Promise>> { if (val === undefined || val === null) throw new Error("undefined or null"); const obj: any = {} as unknown as any; for (const key of Object.keys(this.__fields)) { const actualVal = (val as any)[key]; const ty = this.__fields[key]!; // $ts-expect-error obj[key] = await ty.parse(actualVal); } return obj; } parseSync(val: UnknownInput): InferObject> { if (val === undefined || val === null) throw new Error("undefined or null"); const obj: InferObject> = {} as unknown as any; for (const key of Object.keys(this.__fields)) { const actualVal = (val as any)[key]; const ty = this.__fields[key]!; (obj as any)[key] = ty.parseSync(actualVal) as any; } return obj as any; } toTs(): string { const buf: string[] = []; buf.push("{"); for (const [key, val] of Object.entries(this.__fields)) { buf.push(key); buf.push(":"); buf.push(val.toTs()); buf.push(","); } buf.push("}"); return buf.join(""); } } class ZTuple< T extends [ ZType, ...ZType[], ] | [] = [ ZType, ...ZType[], ], > { type: "tuple" = "tuple"; __values: T; constructor(__values: T) { this.__values = __values; } empty(): ZTuple<[]> { return new ZTuple([]); } item(item: New): ZTuple<[ ...T, New, ]> { return new ZTuple<[ ...T, New, ]>([...this.__values, item]); } async parse(value: unknown): Promise>> { if (!Array.isArray(value)) throw new Error("Not a an array"); if (value.length !== this.__values.length) throw new Error("Invalid length"); const arr: InferTuple> = []; for (let i = 0; i < this.__values.length; i++) { const actualVal = value[i]; const zty = this.__values[i]; // $ts-expect-error arr.push((await zty.parse(actualVal)) as any); } return arr; } parseSync(value: unknown): InferTuple> { if (!Array.isArray(value)) throw new Error("Not a an array"); if (value.length !== this.__values.length) throw new Error("Invalid length"); const arr: InferTuple> = []; for (let i = 0; i < this.__values.length; i++) { const actualVal = value[i]; const zty = this.__values[i]; // $ts-expect-error arr.push(zty.parseSync(actualVal)); } return arr as any; } toTs(): string { const buf: string[] = []; buf.push("["); for (const item of this.__values) { buf.push(item.toTs()); buf.push(","); } buf.push("]"); return buf.join(""); } } type WrapPromise = Promise>; type ZFunctionImpl< Args extends ZTuple< [ ZType, ...ZType[], ] | [] >, Ret extends ZType, > = ((...args: InferTuple) => WrapPromise>) & { minizodSchema: () => ZFunction; json: () => () => Promise; }; type ZFunctionImplSync< Args extends ZTuple< [ ZType, ...ZType[], ] | [] >, Ret extends ZType, > = ((...args: InferTuple) => Infer) & { minizodSchema: () => ZFunction; json: () => () => unknown; }; class ZFunction< Args extends ZTuple< [ ZType, ...ZType[], ] | [] >, Ret extends ZType, > { type: "function" = "function"; __args: Args; __ret: Ret; constructor(__args: Args, __ret: Ret) { this.__args = __args; this.__ret = __ret; } args< NewArgs extends ZTuple< [ ZType, ...ZType[], ] | [] >, >(args: NewArgs): ZFunction { return new ZFunction(args, this.__ret); } ret(r: NewRet): ZFunction { return new ZFunction(this.__args, r); } parse(value: unknown): Promise>> { throw new Error("parsing function not supported"); } parseSync(value: unknown): InferFunction> { throw new Error("parsing function not supported"); } impl( fn: (...args: InferTuple) => Infer, ): ZFunctionImpl { const theFn = async (...args: InferTuple): Promise> => { const parsedArgs = (await this.__args.parse(args)) as any; const result = await fn(...parsedArgs); if (this.__ret.type !== "unknown") { const parsedResult = (await this.__ret.parse(result)) as any; return parsedResult; } return result; }; const minizodSchema: () => ZFunction = () => this; Object.assign(theFn, { minizodSchema, json: () => async (...args: InferTuple): Promise => { const result = await theFn(...args); return new Response(JSON.stringify(result), { headers: { "Content-Type": "application/json" }, }); }, }); return theFn as any; } implSync( fn: (...args: InferTuple) => Infer, ): ZFunctionImplSync { const theFn = (...args: InferTuple): Infer => { const parsedArgs = this.__args.parseSync(args) as any; const result = fn(...parsedArgs); if (this.__ret.type !== "unknown") { const parsedResult = this.__ret.parseSync(result) as any; return parsedResult; } return result; }; const minizodSchema: () => ZFunction = () => this; Object.assign(theFn, { minizodSchema, json: () => (...args: InferTuple): unknown => { const result = theFn(...args); return new Response(JSON.stringify(result), { headers: { "Content-Type": "application/json" }, }); }, }); return theFn as any; } toTs(): string { throw new Error("Not implemented"); } } type ZodImpl = { func: () => ZFunction, ZUnknown>; tuple: () => ZTuple<[]>; object: >(obj: R) => ZObject; string: () => ZString; promise: () => ZPromise; any: () => ZAny; record: (value: V) => ZRecord; }; type Zod = ZodImpl & { chain: (fn: (zod: ZodImpl) => Ret) => Ret; __ztype: ZType; __zfunctionimpl: < Args extends ZTuple< [] | [ ZType, ...ZType[], ] >, Ret extends ZType, >() => ZFunctionImplSync; __zfunction: < Args extends ZTuple< [] | [ ZType, ...ZType[], ] >, Ret extends ZType, >() => ZFunction; __ztuple: ZTuple< [] | [ ZType, ...ZType[], ] >; }; const minizodImpl = (): Zod => { const func = (): ZFunction, ZUnknown> => new ZFunction(new ZTuple<[]>([]), new ZUnknown()); const tuple = (): ZTuple<[]> => new ZTuple([]); const object = >(obj: R): ZObject => new ZObject(obj); const string = (): ZString => new ZString(); const promise = (): ZPromise => new ZPromise(new ZUnknown()); const any = (): ZAny => new ZAny(); const record = (value: V): ZRecord => new ZRecord(value); const z = { func, tuple, object, string, promise, any, record, }; const __ztype: ZType = undefined as any; const __zfunctionimpl: < Args extends ZTuple< [ ZType, ...ZType[], ] | [] >, Ret extends ZType, >() => ZFunctionImplSync = () => undefined as any; const __zfunction: < Args extends ZTuple< [ ZType, ...ZType[], ] | [] >, Ret extends ZType, >() => ZFunction = () => undefined as any; const __ztuple: ZTuple< [ ZType, ...ZType[], ] | [] > = undefined as any; return { ...z, __ztype, __ztuple, __zfunctionimpl, __zfunction, chain: (fn) => { return fn(z); }, }; }; return minizodImpl(); }