@atom8n/json-schema-to-zod 1.6.6 → 1.6.8

package/dist/esm/parsers/parse-one-of.js

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-import { parseSchema } from './parse-schema';
-export const parseOneOf = (jsonSchema, refs) => {
-    if (!jsonSchema.oneOf.length) {
-        return z.any();
-    }
-    if (jsonSchema.oneOf.length === 1) {
-        return parseSchema(jsonSchema.oneOf[0], {
-            ...refs,
-            path: [...refs.path, 'oneOf', 0],
-        });
-    }
-    return z.any().superRefine((x, ctx) => {
-        const schemas = jsonSchema.oneOf.map((schema, i) => parseSchema(schema, {
-            ...refs,
-            path: [...refs.path, 'oneOf', i],
-        }));
-        const unionErrors = schemas.reduce((errors, schema) => ((result) => (result.error ? [...errors, result.error] : errors))(schema.safeParse(x)), []);
-        if (schemas.length - unionErrors.length !== 1) {
-            ctx.addIssue({
-                path: ctx.path,
-                code: 'invalid_union',
-                unionErrors,
-                message: 'Invalid input: Should pass single schema',
-            });
-        }
-    });
-};

package/dist/esm/parsers/parse-schema.js

@@ -1,122 +0,0 @@
-import * as z from 'zod';
-import { parseAllOf } from './parse-all-of';
-import { parseAnyOf } from './parse-any-of';
-import { parseArray } from './parse-array';
-import { parseBoolean } from './parse-boolean';
-import { parseConst } from './parse-const';
-import { parseDefault } from './parse-default';
-import { parseEnum } from './parse-enum';
-import { parseIfThenElse } from './parse-if-then-else';
-import { parseMultipleType } from './parse-multiple-type';
-import { parseNot } from './parse-not';
-import { parseNull } from './parse-null';
-import { parseNullable } from './parse-nullable';
-import { parseNumber } from './parse-number';
-import { parseObject } from './parse-object';
-import { parseOneOf } from './parse-one-of';
-import { parseString } from './parse-string';
-import { its } from '../utils/its';
-const addDescribes = (jsonSchema, zodSchema) => {
-    if (jsonSchema.description) {
-        zodSchema = zodSchema.describe(jsonSchema.description);
-    }
-    return zodSchema;
-};
-const addDefaults = (jsonSchema, zodSchema) => {
-    if (jsonSchema.default !== undefined) {
-        zodSchema = zodSchema.default(jsonSchema.default);
-    }
-    return zodSchema;
-};
-const addAnnotations = (jsonSchema, zodSchema) => {
-    if (jsonSchema.readOnly) {
-        zodSchema = zodSchema.readonly();
-    }
-    return zodSchema;
-};
-const selectParser = (schema, refs) => {
-    if (its.a.nullable(schema)) {
-        return parseNullable(schema, refs);
-    }
-    else if (its.an.object(schema)) {
-        return parseObject(schema, refs);
-    }
-    else if (its.an.array(schema)) {
-        return parseArray(schema, refs);
-    }
-    else if (its.an.anyOf(schema)) {
-        return parseAnyOf(schema, refs);
-    }
-    else if (its.an.allOf(schema)) {
-        return parseAllOf(schema, refs);
-    }
-    else if (its.a.oneOf(schema)) {
-        return parseOneOf(schema, refs);
-    }
-    else if (its.a.not(schema)) {
-        return parseNot(schema, refs);
-    }
-    else if (its.an.enum(schema)) {
-        return parseEnum(schema); //<-- needs to come before primitives
-    }
-    else if (its.a.const(schema)) {
-        return parseConst(schema);
-    }
-    else if (its.a.multipleType(schema)) {
-        return parseMultipleType(schema, refs);
-    }
-    else if (its.a.primitive(schema, 'string')) {
-        return parseString(schema);
-    }
-    else if (its.a.primitive(schema, 'number') || its.a.primitive(schema, 'integer')) {
-        return parseNumber(schema);
-    }
-    else if (its.a.primitive(schema, 'boolean')) {
-        return parseBoolean(schema);
-    }
-    else if (its.a.primitive(schema, 'null')) {
-        return parseNull(schema);
-    }
-    else if (its.a.conditional(schema)) {
-        return parseIfThenElse(schema, refs);
-    }
-    else {
-        return parseDefault(schema);
-    }
-};
-export const parseSchema = (jsonSchema, refs = { seen: new Map(), path: [] }, blockMeta) => {
-    if (typeof jsonSchema !== 'object')
-        return jsonSchema ? z.any() : z.never();
-    if (refs.parserOverride) {
-        const custom = refs.parserOverride(jsonSchema, refs);
-        if (custom instanceof z.ZodType) {
-            return custom;
-        }
-    }
-    let seen = refs.seen.get(jsonSchema);
-    if (seen) {
-        if (seen.r !== undefined) {
-            return seen.r;
-        }
-        if (refs.depth === undefined || seen.n >= refs.depth) {
-            return z.any();
-        }
-        seen.n += 1;
-    }
-    else {
-        seen = { r: undefined, n: 0 };
-        refs.seen.set(jsonSchema, seen);
-    }
-    let parsedZodSchema = selectParser(jsonSchema, refs);
-    if (!blockMeta) {
-        if (!refs.withoutDescribes) {
-            parsedZodSchema = addDescribes(jsonSchema, parsedZodSchema);
-        }
-        if (!refs.withoutDefaults) {
-            parsedZodSchema = addDefaults(jsonSchema, parsedZodSchema);
-        }
-        parsedZodSchema = addAnnotations(jsonSchema, parsedZodSchema);
-    }
-    seen.r = parsedZodSchema;
-    return parsedZodSchema;
-};

package/dist/esm/parsers/parse-string.js

@@ -1,38 +0,0 @@
-import { z } from 'zod';
-import { extendSchemaWithMessage } from '../utils/extend-schema';
-export const parseString = (jsonSchema) => {
-    let zodSchema = z.string();
-    zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'format', (zs, format, errorMsg) => {
-        switch (format) {
-            case 'email':
-                return zs.email(errorMsg);
-            case 'ip':
-                return zs.ip(errorMsg);
-            case 'ipv4':
-                return zs.ip({ version: 'v4', message: errorMsg });
-            case 'ipv6':
-                return zs.ip({ version: 'v6', message: errorMsg });
-            case 'uri':
-                return zs.url(errorMsg);
-            case 'uuid':
-                return zs.uuid(errorMsg);
-            case 'date-time':
-                return zs.datetime({ offset: true, message: errorMsg });
-            case 'time':
-                return zs.time(errorMsg);
-            case 'date':
-                return zs.date(errorMsg);
-            case 'binary':
-                return zs.base64(errorMsg);
-            case 'duration':
-                return zs.duration(errorMsg);
-            default:
-                return zs;
-        }
-    });
-    zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'contentEncoding', (zs, _, errorMsg) => zs.base64(errorMsg));
-    zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'pattern', (zs, pattern, errorMsg) => zs.regex(new RegExp(pattern), errorMsg));
-    zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'minLength', (zs, minLength, errorMsg) => zs.min(minLength, errorMsg));
-    zodSchema = extendSchemaWithMessage(zodSchema, jsonSchema, 'maxLength', (zs, maxLength, errorMsg) => zs.max(maxLength, errorMsg));
-    return zodSchema;
-};

package/dist/esm/types.js

@@ -1 +0,0 @@
-export {};

package/dist/esm/utils/extend-schema.js

@@ -1,8 +0,0 @@
-export function extendSchemaWithMessage(zodSchema, jsonSchema, key, extend) {
-    const value = jsonSchema[key];
-    if (value !== undefined) {
-        const errorMessage = jsonSchema.errorMessage?.[key];
-        return extend(zodSchema, value, errorMessage);
-    }
-    return zodSchema;
-}

package/dist/esm/utils/half.js

@@ -1,3 +0,0 @@
-export const half = (arr) => {
-    return [arr.slice(0, arr.length / 2), arr.slice(arr.length / 2)];
-};

package/dist/esm/utils/its.js

@@ -1,20 +0,0 @@
-export const its = {
-    an: {
-        object: (x) => x.type === 'object',
-        array: (x) => x.type === 'array',
-        anyOf: (x) => x.anyOf !== undefined,
-        allOf: (x) => x.allOf !== undefined,
-        enum: (x) => x.enum !== undefined,
-    },
-    a: {
-        nullable: (x) => 
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
-        x.nullable === true,
-        multipleType: (x) => Array.isArray(x.type),
-        not: (x) => x.not !== undefined,
-        const: (x) => x.const !== undefined,
-        primitive: (x, p) => x.type === p,
-        conditional: (x) => Boolean('if' in x && x.if && 'then' in x && 'else' in x && x.then && x.else),
-        oneOf: (x) => x.oneOf !== undefined,
-    },
-};

package/dist/esm/utils/omit.js

@@ -1,6 +0,0 @@
-export const omit = (obj, ...keys) => Object.keys(obj).reduce((acc, key) => {
-    if (!keys.includes(key)) {
-        acc[key] = obj[key];
-    }
-    return acc;
-}, {});

package/dist/types/index.d.ts

@@ -1,2 +0,0 @@
-export type * from './types';
-export { jsonSchemaToZod } from './json-schema-to-zod';

package/dist/types/json-schema-to-zod.d.ts

@@ -1,3 +0,0 @@
-import type { z } from 'zod';
-import type { JsonSchemaToZodOptions, JsonSchema } from './types';
-export declare const jsonSchemaToZod: <T extends z.ZodTypeAny = z.ZodTypeAny>(schema: JsonSchema, options?: JsonSchemaToZodOptions) => T;

package/dist/types/parsers/parse-all-of.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-import type { JsonSchemaObject, JsonSchema, Refs } from '../types';
-export declare function parseAllOf(jsonSchema: JsonSchemaObject & {
-    allOf: JsonSchema[];
-}, refs: Refs): z.ZodTypeAny;

package/dist/types/parsers/parse-any-of.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-import type { JsonSchemaObject, JsonSchema, Refs } from '../types';
-export declare const parseAnyOf: (jsonSchema: JsonSchemaObject & {
-    anyOf: JsonSchema[];
-}, refs: Refs) => z.ZodTypeAny;

package/dist/types/parsers/parse-array.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-import type { JsonSchemaObject, Refs } from '../types';
-export declare const parseArray: (jsonSchema: JsonSchemaObject & {
-    type: "array";
-}, refs: Refs) => z.ZodArray<z.ZodTypeAny, "many"> | z.ZodTuple<[z.ZodTypeAny], null>;

package/dist/types/parsers/parse-boolean.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-import type { JsonSchemaObject } from '../types';
-export declare const parseBoolean: (_jsonSchema: JsonSchemaObject & {
-    type: "boolean";
-}) => z.ZodBoolean;

package/dist/types/parsers/parse-const.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-import type { JsonSchemaObject, Serializable } from '../types';
-export declare const parseConst: (jsonSchema: JsonSchemaObject & {
-    const: Serializable;
-}) => z.ZodLiteral<z.Primitive>;

package/dist/types/parsers/parse-default.d.ts

@@ -1,3 +0,0 @@
-import { z } from 'zod';
-import type { JsonSchemaObject } from '../types';
-export declare const parseDefault: (_jsonSchema: JsonSchemaObject) => z.ZodAny;

package/dist/types/parsers/parse-enum.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-import type { JsonSchemaObject, Serializable } from '../types';
-export declare const parseEnum: (jsonSchema: JsonSchemaObject & {
-    enum: Serializable[];
-}) => z.ZodNever | z.ZodUnion<[z.ZodTypeAny, z.ZodTypeAny]> | z.ZodLiteral<z.Primitive> | z.ZodEnum<[string]>;

package/dist/types/parsers/parse-if-then-else.d.ts

@@ -1,7 +0,0 @@
-import { z } from 'zod';
-import type { JsonSchemaObject, JsonSchema, Refs } from '../types';
-export declare const parseIfThenElse: (jsonSchema: JsonSchemaObject & {
-    if: JsonSchema;
-    then: JsonSchema;
-    else: JsonSchema;
-}, refs: Refs) => z.ZodEffects<z.ZodUnion<[z.ZodTypeAny, z.ZodTypeAny]>, any, any>;

package/dist/types/parsers/parse-multiple-type.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-import type { JsonSchemaObject, Refs } from '../types';
-export declare const parseMultipleType: (jsonSchema: JsonSchemaObject & {
-    type: string[];
-}, refs: Refs) => z.ZodUnion<[z.ZodTypeAny, z.ZodTypeAny]>;

package/dist/types/parsers/parse-not.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-import type { JsonSchemaObject, JsonSchema, Refs } from '../types';
-export declare const parseNot: (jsonSchema: JsonSchemaObject & {
-    not: JsonSchema;
-}, refs: Refs) => z.ZodEffects<z.ZodAny, any, any>;

package/dist/types/parsers/parse-null.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-import type { JsonSchemaObject } from '../types';
-export declare const parseNull: (_jsonSchema: JsonSchemaObject & {
-    type: "null";
-}) => z.ZodNull;

package/dist/types/parsers/parse-nullable.d.ts

@@ -1,7 +0,0 @@
-import type { JsonSchemaObject, Refs } from '../types';
-/**
- * For compatibility with open api 3.0 nullable
- */
-export declare const parseNullable: (jsonSchema: JsonSchemaObject & {
-    nullable: true;
-}, refs: Refs) => import("zod").ZodNullable<import("zod").ZodTypeAny>;

package/dist/types/parsers/parse-number.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-import type { JsonSchemaObject } from '../types';
-export declare const parseNumber: (jsonSchema: JsonSchemaObject & {
-    type: "number" | "integer";
-}) => z.ZodNumber;

package/dist/types/parsers/parse-object.d.ts

@@ -1,5 +0,0 @@
-import * as z from 'zod';
-import type { JsonSchemaObject, Refs } from '../types';
-export declare function parseObject(objectSchema: JsonSchemaObject & {
-    type: 'object';
-}, refs: Refs): z.ZodTypeAny;

package/dist/types/parsers/parse-one-of.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-import type { JsonSchemaObject, JsonSchema, Refs } from '../types';
-export declare const parseOneOf: (jsonSchema: JsonSchemaObject & {
-    oneOf: JsonSchema[];
-}, refs: Refs) => z.ZodTypeAny;

package/dist/types/parsers/parse-schema.d.ts

@@ -1,3 +0,0 @@
-import * as z from 'zod';
-import type { Refs, JsonSchema } from '../types';
-export declare const parseSchema: (jsonSchema: JsonSchema, refs?: Refs, blockMeta?: boolean) => z.ZodTypeAny;

package/dist/types/parsers/parse-string.d.ts

@@ -1,5 +0,0 @@
-import { z } from 'zod';
-import type { JsonSchemaObject } from '../types';
-export declare const parseString: (jsonSchema: JsonSchemaObject & {
-    type: "string";
-}) => z.ZodString;

package/dist/types/types.d.ts

@@ -1,66 +0,0 @@
-import type { ZodTypeAny } from 'zod';
-export type Serializable = {
-    [key: string]: Serializable;
-} | Serializable[] | string | number | boolean | null;
-export type JsonSchema = JsonSchemaObject | boolean;
-export type JsonSchemaObject = {
-    type?: string | string[];
-    properties?: {
-        [key: string]: JsonSchema;
-    };
-    additionalProperties?: JsonSchema;
-    unevaluatedProperties?: JsonSchema;
-    patternProperties?: {
-        [key: string]: JsonSchema;
-    };
-    minProperties?: number;
-    maxProperties?: number;
-    required?: string[] | boolean;
-    propertyNames?: JsonSchema;
-    items?: JsonSchema | JsonSchema[];
-    additionalItems?: JsonSchema;
-    minItems?: number;
-    maxItems?: number;
-    uniqueItems?: boolean;
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    format?: string;
-    minimum?: number;
-    maximum?: number;
-    exclusiveMinimum?: number | boolean;
-    exclusiveMaximum?: number | boolean;
-    multipleOf?: number;
-    anyOf?: JsonSchema[];
-    allOf?: JsonSchema[];
-    oneOf?: JsonSchema[];
-    if?: JsonSchema;
-    then?: JsonSchema;
-    else?: JsonSchema;
-    const?: Serializable;
-    enum?: Serializable[];
-    errorMessage?: {
-        [key: string]: string | undefined;
-    };
-    description?: string;
-    default?: Serializable;
-    readOnly?: boolean;
-    not?: JsonSchema;
-    contentEncoding?: string;
-    nullable?: boolean;
-};
-export type ParserSelector = (schema: JsonSchemaObject, refs: Refs) => ZodTypeAny;
-export type ParserOverride = (schema: JsonSchemaObject, refs: Refs) => ZodTypeAny | undefined;
-export type JsonSchemaToZodOptions = {
-    withoutDefaults?: boolean;
-    withoutDescribes?: boolean;
-    parserOverride?: ParserOverride;
-    depth?: number;
-};
-export type Refs = JsonSchemaToZodOptions & {
-    path: Array<string | number>;
-    seen: Map<object | boolean, {
-        n: number;
-        r: ZodTypeAny | undefined;
-    }>;
-};

package/dist/types/utils/extend-schema.d.ts

@@ -1,3 +0,0 @@
-import type { z } from 'zod';
-import type { JsonSchemaObject } from '../types';
-export declare function extendSchemaWithMessage<TZod extends z.ZodTypeAny, TJson extends JsonSchemaObject, TKey extends keyof TJson>(zodSchema: TZod, jsonSchema: TJson, key: TKey, extend: (zodSchema: TZod, value: NonNullable<TJson[TKey]>, errorMessage?: string) => TZod): TZod;

package/dist/types/utils/half.d.ts

@@ -1 +0,0 @@
-export declare const half: <T>(arr: T[]) => [T[], T[]];

package/dist/types/utils/its.d.ts

@@ -1,45 +0,0 @@
-import type { JsonSchema, JsonSchemaObject, Serializable } from '../types';
-export declare const its: {
-    an: {
-        object: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            type: "object";
-        };
-        array: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            type: "array";
-        };
-        anyOf: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            anyOf: JsonSchema[];
-        };
-        allOf: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            allOf: JsonSchema[];
-        };
-        enum: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            enum: Serializable | Serializable[];
-        };
-    };
-    a: {
-        nullable: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            nullable: true;
-        };
-        multipleType: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            type: string[];
-        };
-        not: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            not: JsonSchema;
-        };
-        const: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            const: Serializable;
-        };
-        primitive: <T extends "string" | "number" | "integer" | "boolean" | "null">(x: JsonSchemaObject, p: T) => x is JsonSchemaObject & {
-            type: T;
-        };
-        conditional: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            if: JsonSchema;
-            then: JsonSchema;
-            else: JsonSchema;
-        };
-        oneOf: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            oneOf: JsonSchema[];
-        };
-    };
-};

package/dist/types/utils/omit.d.ts

@@ -1 +0,0 @@
-export declare const omit: <T extends object, K extends keyof T>(obj: T, ...keys: K[]) => Omit<T, K>;