@quentinadam/zod 0.1.3 → 0.1.5

package/dist/zod.d.ts

@@ -1,35 +1,47 @@
+type Path = (string | number)[];
+type Context = {
+    path: Path;
+    errors: {
+        path: Path;
+        message: string;
+    }[];
+};
+type Result<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+};
+export declare function getType(value: unknown): string;
 export declare class Schema<T> {
-    #private;
-    readonly inputType: string;
-    constructor({ inputType, parseFn }: {
-        inputType: string;
-        parseFn: (value: unknown) => T;
-    });
+    protected readonly safeParseFn: (value: unknown, context?: Context) => Result<T>;
+    constructor(safeParseFn: (value: unknown, context?: Context) => Result<T>);
     parse(value: unknown): T;
     safeParse(value: unknown): {
         success: true;
         data: T;
     } | {
         success: false;
-        error: unknown;
+        message: string;
+        errors: {
+            path: Path;
+            message: string;
+        }[];
     };
+    internalSafeParse(value: unknown, context?: Context): Result<T>;
     transform<U>(transform: (value: T) => U): Schema<U>;
     optional(): Schema<T | undefined>;
     nullable(): Schema<T | null>;
+    nullish(): Schema<T | null | undefined>;
 }
 export declare class ObjectSchema<T extends Record<string, unknown>> extends Schema<T> {
     #private;
+    get shape(): {
+        [K in keyof T]: Schema<T[K]>;
+    };
     constructor(schema: {
         [K in keyof T]: Schema<T[K]>;
     }, strict?: boolean);
-    extend<U extends Record<string, unknown>>(newSchema: {
-        [K in keyof U]: Schema<U[K]>;
-    }): ObjectSchema<T & U>;
-    strict(): ObjectSchema<T>;
-    strip(): ObjectSchema<T>;
-    partial(): ObjectSchema<{
-        [K in keyof T]: T[K] | undefined;
-    }>;
 }
 declare function createArraySchema<T>(schema: Schema<T>): Schema<T[]>;
 declare function createBigIntSchema(): Schema<bigint>;
@@ -39,13 +51,19 @@ declare function createInstanceofSchema<T>(schema: {
     new (...args: any[]): T;
 }): Schema<T>;
 declare function createLazySchema<T>(fn: () => Schema<T>): Schema<T>;
-declare function createLiteralSchema<T extends string | number | boolean | null>(litteral: T): Schema<T>;
+declare function createLiteralSchema<T extends string | number | boolean | null | undefined>(literal: T | T[]): Schema<T>;
 declare function createObjectSchema<T extends Record<string, unknown>>(schema: {
     [K in keyof T]: Schema<T[K]>;
-}): ObjectSchema<T>;
+}): Schema<T>;
+declare function createOptionalSchema<T>(schema: Schema<T>): Schema<T | undefined>;
+declare function createNullableSchema<T>(schema: Schema<T>): Schema<T | null>;
 declare function createNullSchema(): Schema<null>;
+declare function createNullishSchema<T>(schema: Schema<T>): Schema<T | null | undefined>;
 declare function createNumberSchema(): Schema<number>;
 declare function createRecordSchema<T>(schema: Schema<T>): Schema<Record<string, T>>;
+declare function createStrictObjectSchema<T extends Record<string, unknown>>(schema: {
+    [K in keyof T]: Schema<T[K]>;
+}): Schema<T>;
 declare function createStringSchema(): Schema<string>;
 declare function createTupleSchema<T extends unknown[]>(schema: {
     [K in keyof T]: Schema<T[K]>;
@@ -55,4 +73,4 @@ declare function createUnionSchema<T extends unknown[]>(schemas: {
     [K in keyof T]: Schema<T[K]>;
 }): Schema<T[number]>;
 declare function createUnknownSchema(): Schema<unknown>;
-export { createArraySchema as array, createBigIntSchema as bigint, createBooleanSchema as boolean, createDateSchema as date, createInstanceofSchema as instanceof, createLazySchema as lazy, createLiteralSchema as literal, createNullSchema as null, createNumberSchema as number, createObjectSchema as object, createRecordSchema as record, createStringSchema as string, createTupleSchema as tuple, createUndefinedSchema as undefined, createUnionSchema as union, createUnknownSchema as unknown, };
+export { createArraySchema as array, createBigIntSchema as bigint, createBooleanSchema as boolean, createDateSchema as date, createInstanceofSchema as instanceof, createLazySchema as lazy, createLiteralSchema as literal, createNullableSchema as nullable, createNullishSchema as nullish, createNullSchema as null, createNumberSchema as number, createObjectSchema as object, createOptionalSchema as optional, createRecordSchema as record, createStrictObjectSchema as strictObject, createStringSchema as string, createTupleSchema as tuple, createUndefinedSchema as undefined, createUnionSchema as union, createUnknownSchema as unknown, };

package/dist/zod.js

@@ -1,259 +1,360 @@
+export function getType(value) {
+    if (value === undefined)
+        return 'undefined';
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}
 export class Schema {
-    #parseFn;
-    inputType;
-    constructor({ inputType, parseFn }) {
-        this.#parseFn = parseFn;
-        this.inputType = inputType;
+    safeParseFn;
+    constructor(safeParseFn) {
+        this.safeParseFn = safeParseFn;
     }
     parse(value) {
-        return this.#parseFn(value);
+        const result = this.safeParse(value);
+        if (result.success) {
+            return result.data;
+        }
+        throw new Error(result.message);
     }
     safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error };
+        const context = { path: [], errors: [] };
+        const result = this.safeParseFn(value, context);
+        if (result.success) {
+            return result;
         }
+        return {
+            success: false,
+            message: `Validation failed: ${context.errors.map((e) => `${e.message} (at path /${e.path.join('/')})`).join(', ')}`,
+            errors: context.errors,
+        };
+    }
+    internalSafeParse(value, context) {
+        return this.safeParseFn(value, context);
     }
     transform(transform) {
-        return new Schema({ inputType: this.inputType, parseFn: (value) => transform(this.parse(value)) });
+        return new Schema((value, context) => {
+            try {
+                const result = this.internalSafeParse(value, context);
+                if (result.success) {
+                    return { success: true, data: transform(result.data) };
+                }
+                return result;
+            }
+            catch (error) {
+                if (context !== undefined) {
+                    context.errors.push({ path: context.path, message: error instanceof Error ? error.message : String(error) });
+                }
+                return { success: false };
+            }
+        });
     }
     optional() {
-        return new Schema({
-            inputType: `${this.inputType} | undefined`,
-            parseFn: (value) => value === undefined ? undefined : this.parse(value),
-        });
+        return createOptionalSchema(this);
     }
     nullable() {
-        return new Schema({
-            inputType: `${this.inputType} | null`,
-            parseFn: (value) => value === null ? null : this.parse(value),
-        });
+        return createNullableSchema(this);
+    }
+    nullish() {
+        return createNullishSchema(this);
     }
 }
 export class ObjectSchema extends Schema {
     #schema;
-    #strict;
+    get shape() {
+        return this.#schema;
+    }
     constructor(schema, strict = false) {
-        const inputType = `{ ${Object.entries(schema).map(([key, schema]) => `"${key}": ${schema.inputType}`).join(', ')} }`;
-        super({
-            inputType,
-            parseFn: (value) => {
-                if (typeof value !== 'object' || value === null) {
-                    throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+        super((value, context) => {
+            if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+                if (context !== undefined) {
+                    context.errors.push({ path: context.path, message: `Expected object, got ${getType(value)}` });
                 }
-                return ((value) => {
-                    if (strict) {
-                        for (const key of Object.keys(value)) {
-                            if (!(key in schema)) {
-                                throw new Error(`Expected strict ${this.inputType}, got ${JSON.stringify(value)}`);
-                            }
+                return { success: false };
+            }
+            const object = value;
+            const result = (() => {
+                const parsedObject = {};
+                for (const [key, valueSchema] of Object.entries(schema)) {
+                    const result = valueSchema.internalSafeParse(object[key]);
+                    if (!result.success) {
+                        return result;
+                    }
+                    parsedObject[key] = result.data;
+                }
+                if (strict) {
+                    for (const key of Object.keys(object)) {
+                        if (!(key in schema)) {
+                            return { success: false };
                         }
                     }
-                    const result = {};
-                    Object.entries(schema).forEach(([key, schema]) => {
-                        result[key] = schema.parse(value[key]);
-                    });
-                    return result;
-                })(value);
-            },
+                }
+                return { success: true, data: parsedObject };
+            })();
+            if (result.success) {
+                return result;
+            }
+            if (context !== undefined) {
+                for (const [key, valueSchema] of Object.entries(schema)) {
+                    valueSchema.internalSafeParse(object[key], { path: [...context.path, key], errors: context.errors });
+                }
+                if (strict) {
+                    const unrecognizedKeys = new Array();
+                    for (const key of Object.keys(object)) {
+                        if (!(key in schema)) {
+                            unrecognizedKeys.push(key);
+                        }
+                    }
+                    if (unrecognizedKeys.length > 0) {
+                        context.errors.push({ path: context.path, message: `Unrecognized keys: ${unrecognizedKeys.join(', ')}` });
+                    }
+                }
+            }
+            return { success: false };
         });
         this.#schema = schema;
-        this.#strict = strict;
-    }
-    extend(newSchema) {
-        return new ObjectSchema({ ...this.#schema, ...newSchema }, this.#strict);
-    }
-    strict() {
-        return new ObjectSchema(this.#schema, true);
-    }
-    strip() {
-        return new ObjectSchema(this.#schema, false);
-    }
-    partial() {
-        const schema = Object.fromEntries(Object.entries(this.#schema).map(([key, schema]) => [key, schema.optional()]));
-        return new ObjectSchema(schema, this.#strict);
     }
 }
 function createArraySchema(schema) {
-    const inputType = `Array<${schema.inputType}>`;
-    return new Schema({
-        inputType,
-        parseFn: (value) => {
-            if (!Array.isArray(value)) {
-                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+    return new Schema((value, context) => {
+        if (!Array.isArray(value)) {
+            if (context !== undefined) {
+                context.errors.push({ path: context.path, message: `Expected array, got ${getType(value)}` });
             }
-            return value.map((item) => schema.parse(item));
-        },
+            return { success: false };
+        }
+        const result = (() => {
+            const parsedItems = new Array();
+            for (const item of value) {
+                const result = schema.internalSafeParse(item);
+                if (!result.success) {
+                    return result;
+                }
+                else {
+                    parsedItems.push(result.data);
+                }
+            }
+            return { success: true, data: parsedItems };
+        })();
+        if (result.success) {
+            return result;
+        }
+        if (context !== undefined) {
+            for (let index = 0; index < value.length; index++) {
+                const item = value[index];
+                schema.internalSafeParse(item, { path: [...context.path, index], errors: context.errors });
+            }
+        }
+        return { success: false };
     });
 }
 function createBigIntSchema() {
-    const inputType = 'bigint';
-    return new Schema({
-        inputType,
-        parseFn: (value) => {
-            if (typeof value !== 'bigint') {
-                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+    return new Schema((value, context) => {
+        if (typeof value !== 'bigint') {
+            if (context !== undefined) {
+                context.errors.push({ path: context.path, message: `Expected bigint, got ${getType(value)}` });
             }
-            return value;
-        },
+            return { success: false };
+        }
+        return { success: true, data: value };
     });
 }
 function createBooleanSchema() {
-    const inputType = 'boolean';
-    return new Schema({
-        inputType,
-        parseFn: (value) => {
-            if (typeof value !== 'boolean') {
-                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+    return new Schema((value, context) => {
+        if (typeof value !== 'boolean') {
+            if (context !== undefined) {
+                context.errors.push({ path: context.path, message: `Expected boolean, got ${getType(value)}` });
             }
-            return value;
-        },
+            return { success: false };
+        }
+        return { success: true, data: value };
     });
 }
 function createDateSchema() {
-    const inputType = 'Date';
-    return new Schema({
-        inputType,
-        parseFn: (value) => {
-            if (!(value instanceof Date)) {
-                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
-            }
-            return value;
-        },
-    });
+    return createInstanceofSchema(Date);
 }
 // deno-lint-ignore no-explicit-any
 function createInstanceofSchema(schema) {
-    const inputType = schema.name;
-    return new Schema({
-        inputType,
-        parseFn: (value) => {
-            if (!(value instanceof schema)) {
-                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+    return new Schema((value, context) => {
+        if (!(value instanceof schema)) {
+            if (context !== undefined) {
+                context.errors.push({
+                    path: context.path,
+                    message: `Expected instance of ${schema.name}, got ${getType(value)}`,
+                });
             }
-            return value;
-        },
+            return { success: false };
+        }
+        return { success: true, data: value };
     });
 }
 function createLazySchema(fn) {
-    return new Schema({
-        inputType: '(lazy)',
-        parseFn: (value) => fn().parse(value),
-    });
+    return new Schema((value, context) => fn().internalSafeParse(value, context));
 }
-function createLiteralSchema(litteral) {
-    const inputType = JSON.stringify(litteral);
-    return new Schema({
-        inputType,
-        parseFn: (value) => {
-            if (value !== litteral) {
-                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+function createLiteralSchema(literal) {
+    if (Array.isArray(literal)) {
+        return createUnionSchema(literal.map((item) => createLiteralSchema(item)));
+    }
+    return new Schema((value, context) => {
+        if (value !== literal) {
+            if (context !== undefined) {
+                context.errors.push({ path: context.path, message: `Expected literal ${literal}, got ${getType(value)}` });
             }
-            return litteral;
-        },
+            return { success: false };
+        }
+        return { success: true, data: literal };
     });
 }
 function createObjectSchema(schema) {
-    return new ObjectSchema(schema);
+    return new ObjectSchema(schema, false);
+}
+function createOptionalSchema(schema) {
+    return createUnionSchema([createUndefinedSchema(), schema]);
+}
+function createNullableSchema(schema) {
+    return createUnionSchema([createNullSchema(), schema]);
 }
 function createNullSchema() {
-    const inputType = 'null';
-    return new Schema({
-        inputType,
-        parseFn: (value) => {
-            if (value !== null) {
-                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+    return new Schema((value, context) => {
+        if (value !== null) {
+            if (context !== undefined) {
+                context.errors.push({ path: context.path, message: `Expected null, got ${getType(value)}` });
             }
-            return value;
-        },
+            return { success: false };
+        }
+        return { success: true, data: value };
     });
 }
+function createNullishSchema(schema) {
+    return createUnionSchema([createNullSchema(), createUndefinedSchema(), schema]);
+}
 function createNumberSchema() {
-    const inputType = 'number';
-    return new Schema({
-        inputType,
-        parseFn: (value) => {
-            if (typeof value !== 'number') {
-                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+    return new Schema((value, context) => {
+        if (typeof value !== 'number') {
+            if (context !== undefined) {
+                context.errors.push({ path: context.path, message: `Expected number, got ${getType(value)}` });
             }
-            return value;
-        },
+            return { success: false };
+        }
+        return { success: true, data: value };
     });
 }
 function createRecordSchema(schema) {
-    const inputType = `Record<string, ${schema.inputType}>`;
-    return new Schema({
-        inputType,
-        parseFn: (value) => {
-            if (typeof value !== 'object' || value === null) {
-                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+    return new Schema((record, context) => {
+        if (typeof record !== 'object' || record === null || Array.isArray(record)) {
+            throw new Error(`Expected object, got ${getType(record)}`);
+        }
+        const result = (() => {
+            const parsedObject = {};
+            for (const [key, value] of Object.entries(record)) {
+                const result = schema.internalSafeParse(value);
+                if (!result.success) {
+                    return result;
+                }
+                parsedObject[key] = result.data;
+            }
+            return { success: true, data: parsedObject };
+        })();
+        if (result.success) {
+            return result;
+        }
+        if (context !== undefined) {
+            for (const [key, value] of Object.entries(record)) {
+                schema.internalSafeParse(value, { path: [...context.path, key], errors: context.errors });
             }
-            return Object.fromEntries(Object.entries(value).map(([key, value]) => [key, schema.parse(value)]));
-        },
+        }
+        return { success: false };
     });
 }
+function createStrictObjectSchema(schema) {
+    return new ObjectSchema(schema, true);
+}
 function createStringSchema() {
-    const inputType = 'string';
-    return new Schema({
-        inputType,
-        parseFn: (value) => {
-            if (typeof value !== 'string') {
-                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+    return new Schema((value, context) => {
+        if (typeof value !== 'string') {
+            if (context !== undefined) {
+                context.errors.push({ path: context.path, message: `Expected string, got ${getType(value)}` });
             }
-            return value;
-        },
+            return { success: false };
+        }
+        return { success: true, data: value };
     });
 }
 function createTupleSchema(schema) {
-    const inputType = `[ ${schema.map((schema) => schema.inputType).join(', ')} ]`;
-    return new Schema({
-        inputType,
-        parseFn: (value) => {
-            if (!Array.isArray(value) || value.length !== schema.length) {
-                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+    return new Schema((value, context) => {
+        if (!Array.isArray(value)) {
+            if (context !== undefined) {
+                context.errors.push({ path: context.path, message: `Expected array, got ${getType(value)}` });
+            }
+            return { success: false };
+        }
+        if (value.length !== schema.length) {
+            if (context !== undefined) {
+                context.errors.push({
+                    path: context.path,
+                    message: `Expected array of length ${schema.length}, got array of length ${value.length}`,
+                });
+            }
+            return { success: false };
+        }
+        const result = (() => {
+            const parsedItems = [];
+            let index = 0;
+            for (const itemSchema of schema) {
+                const result = itemSchema.internalSafeParse(value[index]);
+                if (!result.success) {
+                    return result;
+                }
+                parsedItems.push(result.data);
+                index++;
             }
-            return schema.map((schema, index) => schema.parse(value[index]));
-        },
+            return { success: true, data: parsedItems };
+        })();
+        if (result.success) {
+            return result;
+        }
+        if (context !== undefined) {
+            let index = 0;
+            for (const itemSchema of schema) {
+                itemSchema.internalSafeParse(value[index], { path: [...context.path, index], errors: context.errors });
+                index++;
+            }
+        }
+        return { success: false };
     });
 }
 function createUndefinedSchema() {
-    const inputType = 'undefined';
-    return new Schema({
-        inputType,
-        parseFn: (value) => {
-            if (value !== undefined) {
-                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+    return new Schema((value, context) => {
+        if (value !== undefined) {
+            if (context !== undefined) {
+                context.errors.push({ path: context.path, message: `Expected undefined, got ${getType(value)}` });
             }
-            return value;
-        },
+            return { success: false };
+        }
+        return { success: true, data: value };
     });
 }
 function createUnionSchema(schemas) {
-    const inputType = schemas.map((schema) => schema.inputType).join(' | ');
-    return new Schema({
-        inputType,
-        parseFn: (value) => {
+    return new Schema((value, context) => {
+        for (const schema of schemas) {
+            const result = schema.internalSafeParse(value);
+            if (result.success) {
+                return result;
+            }
+        }
+        if (context !== undefined) {
             for (const schema of schemas) {
-                try {
-                    return schema.parse(value);
-                }
-                catch (_) {
-                    continue;
-                }
+                schema.internalSafeParse(value, context);
             }
-            throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
-        },
+        }
+        return { success: false };
     });
 }
 function createUnknownSchema() {
-    const inputType = 'unknown';
-    return new Schema({
-        inputType,
-        parseFn: (value) => {
-            return value;
-        },
+    return new Schema((value) => {
+        return { success: true, data: value };
     });
 }
-export { createArraySchema as array, createBigIntSchema as bigint, createBooleanSchema as boolean, createDateSchema as date, createInstanceofSchema as instanceof, createLazySchema as lazy, createLiteralSchema as literal, createNullSchema as null, createNumberSchema as number, createObjectSchema as object, createRecordSchema as record, createStringSchema as string, createTupleSchema as tuple, createUndefinedSchema as undefined, createUnionSchema as union, createUnknownSchema as unknown, };
+export { createArraySchema as array, createBigIntSchema as bigint, createBooleanSchema as boolean, createDateSchema as date, createInstanceofSchema as instanceof, createLazySchema as lazy, createLiteralSchema as literal, createNullableSchema as nullable, createNullishSchema as nullish, createNullSchema as null, createNumberSchema as number, createObjectSchema as object, createOptionalSchema as optional, createRecordSchema as record, createStrictObjectSchema as strictObject, createStringSchema as string, createTupleSchema as tuple, createUndefinedSchema as undefined, createUnionSchema as union, createUnknownSchema as unknown, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quentinadam/zod",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "A simple library to parse data, inspired by zod",
   "license": "MIT",
   "author": "Quentin Adam",