@weser/schema 0.0.18 → 1.0.1

package/README.md

@@ -1,3 +1,3 @@
 # @weser/schema
 
-[Documentation](https://packages.weser.io/schema)
+[Documentation](https://stack.weser.io/schema)

package/dist/src/builders.d.ts

@@ -0,0 +1,33 @@
+import { T_JSONSchemaEnum, T_JSONSchemaString, T_JSONSchemaNumber, T_JSONSchemaBoolean, T_JSONSchemaArray, T_JSONSchemaObject, T_JSONSchema } from './types.js';
+export declare function createEnumSchema(values: ReadonlyArray<string>, options?: {
+    description?: string;
+    default?: string;
+}): T_JSONSchemaEnum;
+export declare function createStringSchema(options?: {
+    minLength?: number;
+    maxLength?: number;
+    format?: 'date' | 'uri' | 'email';
+    description?: string;
+    default?: string;
+}): T_JSONSchemaString;
+export declare function createNumberSchema(options?: {
+    minimum?: number;
+    maximum?: number;
+    description?: string;
+    default?: number;
+}): T_JSONSchemaNumber;
+export declare function createBooleanSchema(options?: {
+    description?: string;
+    default?: boolean;
+}): T_JSONSchemaBoolean;
+export declare function createArraySchema<T>(items: T_JSONSchema, options?: {
+    description?: string;
+    default?: Array<T>;
+}): T_JSONSchemaArray<T>;
+export declare function createObjectSchema<T extends Record<string, any>>(properties: {
+    [K in keyof T]: T_JSONSchema;
+}, options?: {
+    required?: Array<keyof T>;
+    description?: string;
+    default?: T;
+}): T_JSONSchemaObject<T>;

package/dist/src/builders.js

@@ -0,0 +1,18 @@
+export function createEnumSchema(values, options = {}) {
+    return { enum: [...values], ...options };
+}
+export function createStringSchema(options = {}) {
+    return { type: 'string', ...options };
+}
+export function createNumberSchema(options = {}) {
+    return { type: 'number', ...options };
+}
+export function createBooleanSchema(options = {}) {
+    return { type: 'boolean', ...options };
+}
+export function createArraySchema(items, options = {}) {
+    return { type: 'array', items, ...options };
+}
+export function createObjectSchema(properties, options = {}) {
+    return { type: 'object', properties, ...options };
+}

package/dist/src/fromZod.d.ts

@@ -0,0 +1,3 @@
+import { ZodType } from 'zod';
+import { T_JSONSchema } from './types.js';
+export default function fromZod(schema: ZodType): T_JSONSchema;

package/dist/src/fromZod.js

@@ -0,0 +1,4 @@
+import z from 'zod';
+export default function fromZod(schema) {
+    return z.toJSONSchema(schema);
+}

package/dist/src/guards.d.ts

@@ -0,0 +1,7 @@
+import { T_JSONSchema, T_JSONSchemaBoolean, T_JSONSchemaEnum, T_JSONSchemaNumber, T_JSONSchemaObject, T_JSONSchemaArray, T_JSONSchemaString } from './types.js';
+export declare function isEnumSchema(schema: T_JSONSchema): schema is T_JSONSchemaEnum;
+export declare function isStringSchema(schema: T_JSONSchema): schema is T_JSONSchemaString;
+export declare function isNumberSchema(schema: T_JSONSchema): schema is T_JSONSchemaNumber;
+export declare function isBooleanSchema(schema: T_JSONSchema): schema is T_JSONSchemaBoolean;
+export declare function isObjectSchema(schema: T_JSONSchema): schema is T_JSONSchemaObject;
+export declare function isArraySchema(schema: T_JSONSchema): schema is T_JSONSchemaArray;

package/dist/src/guards.js

@@ -0,0 +1,18 @@
+export function isEnumSchema(schema) {
+    return schema.enum !== undefined;
+}
+export function isStringSchema(schema) {
+    return schema.type === 'string';
+}
+export function isNumberSchema(schema) {
+    return schema.type === 'number';
+}
+export function isBooleanSchema(schema) {
+    return schema.type === 'boolean';
+}
+export function isObjectSchema(schema) {
+    return schema.type === 'object';
+}
+export function isArraySchema(schema) {
+    return schema.type === 'array';
+}

package/dist/src/index.d.ts

@@ -0,0 +1,7 @@
+export { default as fromZod } from './fromZod.js';
+export { default as toZod } from './toZod.js';
+export * from './toZod.js';
+export * from './guards.js';
+export * from './types.js';
+export * from './validators.js';
+export * from './builders.js';

package/dist/src/index.js

@@ -0,0 +1,7 @@
+export { default as fromZod } from './fromZod.js';
+export { default as toZod } from './toZod.js';
+export * from './toZod.js';
+export * from './guards.js';
+export * from './types.js';
+export * from './validators.js';
+export * from './builders.js';

package/dist/src/toZod.d.ts

@@ -0,0 +1,21 @@
+import z from 'zod';
+import { T_JSONSchema, T_JSONSchemaBoolean, T_JSONSchemaEnum, T_JSONSchemaNumber, T_JSONSchemaObject, T_JSONSchemaArray, T_JSONSchemaString } from './types.js';
+export default function toZod(schema: T_JSONSchema): z.ZodEnum<{
+    [x: string]: string;
+}> | z.ZodDefault<z.ZodEnum<{
+    [x: string]: string;
+}>> | z.ZodString | z.ZodDefault<z.ZodString> | z.ZodNumber | z.ZodDefault<z.ZodNumber> | z.ZodBoolean | z.ZodDefault<z.ZodBoolean> | z.ZodObject<{
+    [x: string]: z.ZodType<unknown, unknown>;
+}, {}, {}> | z.ZodArray<z.ZodAny> | z.ZodDefault<z.ZodArray<z.ZodAny>>;
+export declare function toZodString({ minLength, maxLength, description, default: _default, format, ...meta }: T_JSONSchemaString): z.ZodString | z.ZodDefault<z.ZodString>;
+export declare function toZodEnum({ enum: _enum, description, default: _default, ...meta }: T_JSONSchemaEnum): z.ZodEnum<{
+    [x: string]: string;
+}> | z.ZodDefault<z.ZodEnum<{
+    [x: string]: string;
+}>>;
+export declare function toZodNumber({ minimum, maximum, description, default: _default, ...meta }: T_JSONSchemaNumber): z.ZodNumber | z.ZodDefault<z.ZodNumber>;
+export declare function toZodBoolean({ description, default: _default, ...meta }: T_JSONSchemaBoolean): z.ZodBoolean | z.ZodDefault<z.ZodBoolean>;
+export declare function toZodObject({ properties, required, description, ...meta }: T_JSONSchemaObject): z.ZodObject<{
+    [x: string]: z.ZodType<unknown, unknown>;
+}, {}, {}>;
+export declare function toZodArray({ items, description, default: _default, ...meta }: T_JSONSchemaArray): z.ZodArray<z.ZodAny> | z.ZodDefault<z.ZodArray<z.ZodAny>>;

package/dist/src/toZod.js

@@ -0,0 +1,114 @@
+import z from 'zod';
+import { isBooleanSchema, isEnumSchema, isNumberSchema, isObjectSchema, isArraySchema, isStringSchema, } from './guards.js';
+export default function toZod(schema) {
+    if (isEnumSchema(schema)) {
+        return toZodEnum(schema);
+    }
+    if (isStringSchema(schema)) {
+        return toZodString(schema);
+    }
+    if (isNumberSchema(schema)) {
+        return toZodNumber(schema);
+    }
+    if (isBooleanSchema(schema)) {
+        return toZodBoolean(schema);
+    }
+    if (isObjectSchema(schema)) {
+        return toZodObject(schema);
+    }
+    if (isArraySchema(schema)) {
+        return toZodArray(schema);
+    }
+    throw new Error('Error converting JSON schema to Zod type.');
+}
+export function toZodString({ minLength, maxLength, description, default: _default, format, ...meta }) {
+    let type = z.string();
+    if (format === 'uri') {
+        type = type.url();
+    }
+    else if (format === 'date') {
+        type = type.date();
+    }
+    else if (format === 'email') {
+        type = type.email();
+    }
+    type = type.meta({ ...meta, ...(format ? { format } : {}) });
+    if (description) {
+        type = type.describe(description);
+    }
+    if (minLength) {
+        type = type.min(minLength);
+    }
+    if (maxLength) {
+        type = type.max(maxLength);
+    }
+    if (_default) {
+        return type.default(_default);
+    }
+    return type;
+}
+export function toZodEnum({ enum: _enum, description, default: _default, ...meta }) {
+    let type = z.enum(_enum);
+    type = type.meta(meta);
+    if (description) {
+        type = type.describe(description);
+    }
+    if (_default) {
+        return type.default(_default);
+    }
+    return type;
+}
+export function toZodNumber({ minimum, maximum, description, default: _default, ...meta }) {
+    let type = z.number();
+    type = type.meta(meta);
+    if (description) {
+        type = type.describe(description);
+    }
+    if (minimum) {
+        type = type.min(minimum);
+    }
+    if (maximum) {
+        type = type.max(maximum);
+    }
+    if (_default) {
+        return type.default(_default);
+    }
+    return type;
+}
+export function toZodBoolean({ description, default: _default, ...meta }) {
+    let type = z.boolean();
+    type = type.meta(meta);
+    if (description) {
+        type = type.describe(description);
+    }
+    if (_default) {
+        return type.default(_default);
+    }
+    return type;
+}
+export function toZodObject({ properties, required, description, ...meta }) {
+    const props = Object.entries(properties).reduce((props, [property, schema]) => {
+        const type = toZod(schema);
+        if (type) {
+            props[property] = type;
+        }
+        return props;
+    }, {});
+    let type = z.object(props);
+    type = type.meta(meta);
+    if (description) {
+        type = type.describe(description);
+    }
+    return type;
+}
+export function toZodArray({ items, description, default: _default, ...meta }) {
+    let type = z.array(toZod(items));
+    type = type.meta(meta);
+    if (description) {
+        type = type.describe(description);
+    }
+    if (_default) {
+        return type.default(_default);
+    }
+    return type;
+}

package/dist/src/types.d.ts

@@ -0,0 +1,41 @@
+export type T_JSONValue = string | number | boolean | null | JSONObject | Array<T_JSONValue>;
+export type JSONObject = {
+    [key: string]: T_JSONValue;
+};
+export type T_JSONSchemaRaw = {
+    description?: string;
+    [key: string]: any;
+};
+export type T_JSONSchemaEnum = T_JSONSchemaRaw & {
+    enum: Array<string>;
+    default?: string;
+};
+export type T_JSONSchemaString = T_JSONSchemaRaw & {
+    type: 'string';
+    minLength?: number;
+    maxLength?: number;
+    format?: 'date' | 'uri' | 'email';
+    default?: string;
+};
+export type T_JSONSchemaNumber = T_JSONSchemaRaw & {
+    type: 'number';
+    minimum?: number;
+    maximum?: number;
+    default?: number;
+};
+export type T_JSONSchemaBoolean = T_JSONSchemaRaw & {
+    type: 'boolean';
+    default?: boolean;
+};
+export interface T_JSONSchemaArray<T = T_JSONValue> extends T_JSONSchemaRaw {
+    type: 'array';
+    items: T_JSONSchema;
+    default?: Array<T>;
+}
+export interface T_JSONSchemaObject<T extends Record<string, any> = Record<string, T_JSONValue>> extends T_JSONSchemaRaw {
+    type: 'object';
+    required?: Array<keyof T>;
+    properties: Record<string, T_JSONSchema>;
+    default?: T;
+}
+export type T_JSONSchema = T_JSONSchemaEnum | T_JSONSchemaString | T_JSONSchemaNumber | T_JSONSchemaBoolean | T_JSONSchemaObject | T_JSONSchemaArray;

package/dist/src/types.js

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

package/dist/src/validators.d.ts

@@ -0,0 +1,8 @@
+import { T_JSONSchemaEnum, T_JSONSchemaString, T_JSONSchemaNumber, T_JSONSchemaBoolean, T_JSONSchemaObject, T_JSONSchemaArray, T_JSONSchema } from './types.js';
+export declare function isValidEnumSchema(schema: T_JSONSchema): schema is T_JSONSchemaEnum;
+export declare function isValidStringSchema(schema: T_JSONSchema): schema is T_JSONSchemaString;
+export declare function isValidNumberSchema(schema: T_JSONSchema): schema is T_JSONSchemaNumber;
+export declare function isValidBooleanSchema(schema: T_JSONSchema): schema is T_JSONSchemaBoolean;
+export declare function isValidArraySchema(schema: T_JSONSchema): schema is T_JSONSchemaArray;
+export declare function isValidObjectSchema(schema: T_JSONSchema): schema is T_JSONSchemaObject;
+export declare function isValidSchema(schema: T_JSONSchema): schema is T_JSONSchema;

package/dist/src/validators.js

@@ -0,0 +1,77 @@
+import z from 'zod';
+const enumValidator = z
+    .object({
+    enum: z.array(z.string()),
+    description: z.string().optional(),
+    default: z.string().optional(),
+})
+    .passthrough();
+export function isValidEnumSchema(schema) {
+    return enumValidator.safeParse(schema).success;
+}
+const stringValidator = z
+    .object({
+    type: z.literal('string'),
+    minLength: z.number().optional(),
+    maxLength: z.number().optional(),
+    format: z.enum(['date', 'uri']).optional(),
+    description: z.string().optional(),
+    default: z.string().optional(),
+})
+    .passthrough();
+export function isValidStringSchema(schema) {
+    return stringValidator.safeParse(schema).success;
+}
+const numberValidator = z
+    .object({
+    type: z.literal('number'),
+    minimum: z.number().optional(),
+    maximum: z.number().optional(),
+    description: z.string().optional(),
+    default: z.number().optional(),
+})
+    .passthrough();
+export function isValidNumberSchema(schema) {
+    return numberValidator.safeParse(schema).success;
+}
+const booleanValidator = z
+    .object({
+    type: z.literal('boolean'),
+    description: z.string().optional(),
+    default: z.boolean().optional(),
+})
+    .passthrough();
+export function isValidBooleanSchema(schema) {
+    return booleanValidator.safeParse(schema).success;
+}
+const arrayValidator = z
+    .object({
+    type: z.literal('array'),
+    items: z.any(),
+    description: z.string().optional(),
+    default: z.array(z.any()).optional(),
+})
+    .passthrough();
+export function isValidArraySchema(schema) {
+    return arrayValidator.safeParse(schema).success;
+}
+const objectValidator = z
+    .object({
+    type: z.literal('object'),
+    properties: z.record(z.string(), z.any()),
+    required: z.array(z.string()).optional(),
+    description: z.string().optional(),
+    default: z.record(z.string(), z.any()).optional(),
+})
+    .passthrough();
+export function isValidObjectSchema(schema) {
+    return objectValidator.safeParse(schema).success;
+}
+export function isValidSchema(schema) {
+    return (isValidEnumSchema(schema) ||
+        isValidStringSchema(schema) ||
+        isValidNumberSchema(schema) ||
+        isValidBooleanSchema(schema) ||
+        isValidObjectSchema(schema) ||
+        isValidArraySchema(schema));
+}

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/builders.ts","../src/fromzod.ts","../src/guards.ts","../src/index.ts","../src/tozod.ts","../src/types.ts","../src/validators.ts"],"version":"5.9.2"}
+{"root":["../vitest.config.ts","../src/builders.ts","../src/fromzod.ts","../src/guards.ts","../src/index.ts","../src/tozod.ts","../src/types.ts","../src/validators.ts"],"version":"5.9.3"}

package/dist/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/dist/vitest.config.js

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+export default defineConfig({
+    test: {
+        include: ['**/__tests__/**/*.{js,ts}'],
+        globals: false,
+    },
+    esbuild: {
+        target: 'esnext',
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weser/schema",
-  "version": "0.0.18",
+  "version": "1.0.1",
   "description": "Helpers for working with Zod and JSON Schema",
   "author": "Robin Weser <robin@weser.io>",
   "license": "MIT",
@@ -33,7 +33,7 @@
     "clean": "rimraf dist",
     "build": "tsc -b",
     "dev": "pnpm build -w",
-    "test": "ava"
+    "test": "vitest run"
   },
   "keywords": [
     "zod",
@@ -46,10 +46,10 @@
     "zod": "*"
   },
   "devDependencies": {
-    "ava": "^6.1.3",
     "rimraf": "^3.0.2",
     "typescript": "^5.4.5",
+    "vitest": "^2.1.8",
     "zod": "4.0.0-beta.20250505T195954"
   },
-  "gitHead": "4dd312c8cf505d0c06d25ca489b893a6c6c0d9fe"
+  "gitHead": "490b5b37e8da7f0cac2880543874914c6f6be5d6"
 }