@tstdl/base 0.93.55 → 0.93.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.55",
+  "version": "0.93.57",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -103,6 +103,7 @@
     "./schema/converters": "./schema/converters/index.js",
     "./schema/converters/open-api": "./schema/converters/open-api-converter.js",
     "./schema/converters/zod": "./schema/converters/zod-converter.js",
+    "./schema/converters/zod-v3": "./schema/converters/zod-v3-converter.js",
     "./serializer": "./serializer/index.js",
     "./serializer/handlers": "./serializer/handlers/index.js",
     "./signals": "./signals/index.js",

package/schema/converters/zod-converter.js

@@ -138,8 +138,7 @@ function convertToZodSchemaBase(schema, options) {
         // Zod nativeEnum or enum doesn't support numbers directly without hacks or native TS enums.
         // Use union of literals for mixed or number enums.
         if (isArray(s.enumeration) && s.enumeration.some((v) => isNumber(v))) {
-            const types = s.allowedValues.map((value) => z.literal(value));
-            return z.union(types);
+            return z.literal(s.allowedValues);
         }
         // enumeration is either EnumerationObject or string-only EnumerationArray, both is fine for z.enum
         // using `as`, as z.enum is overloaded and only one type per overload
@@ -212,7 +211,7 @@ function convertToZodSchemaBase(schema, options) {
         throw new NotSupportedError(`Schema "${schema.name}" cannot be converted to Zod schema.`);
     });
     if (isNotNull(schema.description)) {
-        zodSchema = zodSchema.describe(schema.description);
+        zodSchema = zodSchema.meta({ description: schema.description });
     }
     return zodSchema;
 }

package/schema/converters/zod-v3-converter.d.ts

@@ -0,0 +1,10 @@
+import { z, type ZodTypeDef } from 'zod/v3';
+import type { SchemaTestable } from '../schema.js';
+export type SchemaConversionOptions = {
+    /** Default coerce option if not specified in schema */
+    coerce?: boolean;
+    /** Default mask option if not specified in schema */
+    mask?: boolean;
+};
+/** WARNING: *DOES NOT* cover all schemas and options. Meant for usage in schema generators like genkit, not for full schema testing in APIs etc. */
+export declare function convertToZodV3Schema<O, I = unknown>(testable: SchemaTestable<O>, options?: SchemaConversionOptions): z.ZodType<O, ZodTypeDef, I>;

package/schema/converters/zod-v3-converter.js

@@ -0,0 +1,131 @@
+import { match, P } from 'ts-pattern';
+import { z } from 'zod/v3';
+import { NotSupportedError } from '../../errors/not-supported.error.js';
+import { objectEntries } from '../../utils/object/object.js';
+import { isArray, isNotNull, isNumber } from '../../utils/type-guards.js';
+import { any, AnySchema, ArraySchema, BigIntSchema, BooleanSchema, DateSchema, DefaultSchema, DeferredSchema, EnumerationSchema, InstanceSchema, LiteralSchema, NeverSchema, NullableSchema, NumberSchema, ObjectSchema, OneOrManySchema, OptionalSchema, ReadableStreamSchema, StringSchema, SymbolSchema, TransformSchema, UnionSchema, UnknownSchema } from '../schemas/index.js';
+import { schemaTestableToSchema } from '../testable.js';
+/** WARNING: *DOES NOT* cover all schemas and options. Meant for usage in schema generators like genkit, not for full schema testing in APIs etc. */
+export function convertToZodV3Schema(testable, options) {
+    const schema = schemaTestableToSchema(testable);
+    return convertToZodSchemaBase(schema, options);
+}
+function convertToZodSchemaBase(schema, options) {
+    let zodSchema = match(schema)
+        .with(P.instanceOf(AnySchema), () => z.any())
+        .with(P.instanceOf(UnknownSchema), () => z.unknown())
+        .with(P.instanceOf(NeverSchema), () => z.never())
+        .with(P.instanceOf(NullableSchema), (s) => convertToZodSchemaBase(s.schema, options).nullable())
+        .with(P.instanceOf(OptionalSchema), (s) => convertToZodSchemaBase(s.schema, options).optional())
+        .with(P.instanceOf(OneOrManySchema), (s) => {
+        const innerSchema = convertToZodSchemaBase(s.schema, options);
+        return innerSchema.or(innerSchema.array());
+    })
+        .with(P.instanceOf(StringSchema), (s) => {
+        let zodSchema = (s.coerce ?? options?.coerce ?? false) ? z.coerce.string() : z.string();
+        if (isNumber(s.minimumLength)) {
+            zodSchema = zodSchema.min(s.minimumLength);
+        }
+        if (isNumber(s.maximumLength)) {
+            zodSchema = zodSchema.max(s.maximumLength);
+        }
+        if (isNotNull(s.pattern)) {
+            zodSchema = zodSchema.regex(s.pattern);
+        }
+        if (s.trim) {
+            zodSchema = zodSchema.trim();
+        }
+        if (s.lowercase) {
+            zodSchema = zodSchema.toLowerCase();
+        }
+        return zodSchema;
+    })
+        .with(P.instanceOf(NumberSchema), (s) => {
+        let zodSchema = (s.coerce ?? options?.coerce ?? false) ? z.coerce.number() : z.number();
+        if (s.integer) {
+            zodSchema = zodSchema.int();
+        }
+        if (isNumber(s.minimum)) {
+            zodSchema = zodSchema.gte(s.minimum);
+        }
+        if (isNumber(s.maximum)) {
+            zodSchema = zodSchema.lte(s.maximum);
+        }
+        return zodSchema;
+    })
+        .with(P.instanceOf(BooleanSchema), (s) => (s.coerce ?? options?.coerce ?? false) ? z.coerce.boolean() : z.boolean())
+        .with(P.instanceOf(BigIntSchema), (s) => (s.coerce ?? options?.coerce ?? false) ? z.coerce.bigint() : z.bigint())
+        .with(P.instanceOf(SymbolSchema), () => z.symbol())
+        .with(P.instanceOf(DateSchema), (s) => {
+        let zodSchema = (s.coerce ?? options?.coerce ?? false) ? z.coerce.date() : z.date();
+        if (isNotNull(s.minimum)) {
+            zodSchema = zodSchema.min(s.minimum);
+        }
+        if (isNotNull(s.maximum)) {
+            zodSchema = zodSchema.max(s.maximum);
+        }
+        return zodSchema;
+    })
+        .with(P.instanceOf(LiteralSchema), (s) => z.literal(s.value))
+        .with(P.instanceOf(ArraySchema), (s) => {
+        const itemSchema = convertToZodSchemaBase(s.itemSchema, options);
+        let zodSchema = z.array(itemSchema);
+        if (isNumber(s.minimum)) {
+            zodSchema = zodSchema.min(s.minimum);
+        }
+        if (isNumber(s.maximum)) {
+            zodSchema = zodSchema.max(s.maximum);
+        }
+        return zodSchema;
+    })
+        .with(P.instanceOf(ObjectSchema), (s) => {
+        const propertyEntries = objectEntries(s.properties);
+        // Handle generic records (no specific properties, but has unknownProperties/Key)
+        if ((propertyEntries.length == 0) && (isNotNull(s.unknownPropertiesKey) || isNotNull(s.unknownProperties))) {
+            return z.record(convertToZodV3Schema(s.unknownPropertiesKey ?? any()), convertToZodV3Schema(s.unknownProperties ?? any()));
+        }
+        const shape = {};
+        for (const [key, propertySchema] of propertyEntries) {
+            shape[key] = convertToZodSchemaBase(propertySchema, options);
+        }
+        const loose = isNotNull(s.unknownPropertiesKey) || isNotNull(s.unknownProperties);
+        let zodSchema = z.object(shape);
+        if (loose) {
+            zodSchema = zodSchema.passthrough();
+        }
+        if (!loose && !(s.mask ?? options?.mask ?? false)) {
+            zodSchema = zodSchema.strict();
+        }
+        if (isNotNull(s.unknownProperties)) {
+            zodSchema = zodSchema.catchall(convertToZodSchemaBase(s.unknownProperties, options));
+        }
+        return zodSchema;
+    })
+        .with(P.instanceOf(UnionSchema), (s) => {
+        const schemas = s.schemas.map((subSchema) => convertToZodSchemaBase(subSchema, options));
+        return z.union(schemas);
+    })
+        .with(P.instanceOf(EnumerationSchema), (s) => {
+        // Zod nativeEnum or enum doesn't support numbers directly without hacks or native TS enums.
+        // Use union of literals for mixed or number enums.
+        if (isArray(s.enumeration) && s.enumeration.some((v) => isNumber(v))) {
+            const literals = s.allowedValues.map((value) => z.literal(value));
+            return z.union(literals);
+        }
+        // enumeration is either EnumerationObject or string-only EnumerationArray, both is fine for z.enum
+        // using `as`, as z.enum is overloaded and only one type per overload
+        return z.enum(s.allowedValues);
+    })
+        .with(P.instanceOf(DefaultSchema), (s) => convertToZodSchemaBase(s.schema, options).default(s.defaultValue))
+        .with(P.instanceOf(TransformSchema), (s) => convertToZodSchemaBase(s.schema, options).transform((input) => s.transformFn(input)))
+        .with(P.instanceOf(DeferredSchema), (s) => z.lazy(() => convertToZodSchemaBase(s.schema, options)))
+        .with(P.instanceOf(ReadableStreamSchema), () => z.instanceof(ReadableStream))
+        .with(P.instanceOf(InstanceSchema), (s) => z.instanceof(s.type))
+        .otherwise(() => {
+        throw new NotSupportedError(`Schema "${schema.name}" cannot be converted to Zod schema.`);
+    });
+    if (isNotNull(schema.description)) {
+        zodSchema = zodSchema.describe(schema.description);
+    }
+    return zodSchema;
+}