@naturalcycles/js-lib 15.20.0 → 15.22.0

package/cfg/frontend/tsconfig.json

@@ -59,9 +59,9 @@
     "jsx": "preserve",
     "pretty": true,
     "newLine": "lf",
-    "experimentalDecorators": true,
+    "experimentalDecorators": true
     // "emitDecoratorMetadata": true // use if needed
-  },
+  }
   // Need to be specified in the project tsconfig
   // "include": ["src"],
   // "exclude": ["**/__exclude", "**/@linked"]

package/dist/datetime/localTime.d.ts

@@ -291,7 +291,7 @@ declare class LocalTimeFactory {
     /**
      * Throws on invalid value.
      */
-    private validateDateTimeObject;
+    validateDateTimeObject(o: DateTimeObject): void;
     isDateTimeObjectValid(o: DateTimeObject): boolean;
     isTimeObjectValid({ hour, minute, second }: TimeObject): boolean;
     fromDate(date: Date): LocalTime;

package/dist/validation/validation.d.ts

@@ -17,6 +17,16 @@ import type { AppError } from '../error/error.util.js';
 export type ValidationFunction<T, ERR extends AppError> = (input: T, opt?: ValidationFunctionOptions) => ValidationFunctionResult<T, ERR>;
 export type ValidationFunctionResult<T, ERR extends AppError> = [err: ERR | null, output: T];
 export interface ValidationFunctionOptions {
+    /**
+     * Defaults to false,
+     * which means that the ValidationFunction IS NOT ALLOWED to mutate the input.
+     * If set to true - the ValidationFunction HAS TO mutate the input
+     * if it needs to apply transformations, such as:
+     * - stripping unknown properties
+     * - converting types (e.g. string to number)
+     * - applying transformations (which as string trim, toLowerCase, etc)
+     */
+    mutateInput?: boolean;
     /**
      * E.g User
      * Used for error message printing.

package/dist/zod/zod.shared.schemas.d.ts

@@ -1,44 +1,47 @@
+import type { ZodString } from 'zod';
 import { z } from 'zod';
 import type { IsoDate, UnixTimestamp, UnixTimestampMillis } from '../types.js';
 type ZodBranded<T, B> = T & Record<'_zod', Record<'output', number & B>>;
 export type ZodBrandedString<B> = ZodBranded<z.ZodString, B>;
 export type ZodBrandedInt<B> = ZodBranded<z.ZodInt, B>;
 export type ZodBrandedNumber<B> = ZodBranded<z.ZodNumber, B>;
-export declare const TS_2500 = 16725225600;
-export declare const TS_2000 = 946684800;
-export declare const zUnixTimestamp: () => ZodBrandedInt<UnixTimestamp>;
-export declare const zUnixTimestamp2000: () => ZodBrandedInt<UnixTimestamp>;
-export declare const zUnixTimestampMillis: () => ZodBranded<z.ZodNumber, UnixTimestampMillis>;
-export declare const zUnixTimestampMillis2000: () => ZodBrandedInt<UnixTimestampMillis>;
-export declare const zSemVer: () => z.ZodString;
-export declare const zIsoDate: () => ZodBrandedString<IsoDate>;
-export declare const zEmail: () => z.ZodEmail;
-export declare const BASE62_REGEX: RegExp;
-export declare const BASE64_REGEX: RegExp;
-export declare const BASE64URL_REGEX: RegExp;
-export declare const zBase62: () => z.ZodString;
-export declare const zBase64: () => z.ZodString;
-export declare const zBase64Url: () => z.ZodString;
-export declare const JWT_REGEX: RegExp;
-export declare const zJwt: () => z.ZodString;
+declare function unixTimestamp(): ZodBrandedInt<UnixTimestamp>;
+declare function unixTimestamp2000(): ZodBrandedInt<UnixTimestamp>;
+declare function unixTimestampMillis(): ZodBranded<z.ZodNumber, UnixTimestampMillis>;
+declare function unixTimestampMillis2000(): ZodBrandedInt<UnixTimestampMillis>;
+declare function semVer(): z.ZodString;
+declare function isoDate(): ZodBrandedString<IsoDate>;
+declare function email(): z.ZodEmail;
+declare function base62(): z.ZodString;
+declare function base64(): z.ZodString;
+declare function base64Url(): z.ZodString;
+declare function jwt(): z.ZodString;
 /**
  * "Slug" - a valid URL, filename, etc.
  */
-export declare const zSlug: () => z.ZodString;
-export declare const zIanaTimezone: () => z.ZodEnum;
+declare function slug(): z.ZodString;
+declare function ianaTimezone(): z.ZodEnum;
+type BaseDBEntityZodShape = {
+    id: ZodString;
+    created: ZodBrandedInt<UnixTimestamp>;
+    updated: ZodBrandedInt<UnixTimestamp>;
+};
+declare function dbEntity(): z.ZodObject<BaseDBEntityZodShape>;
+declare function dbEntity<T extends z.ZodRawShape>(shape: T): z.ZodObject<BaseDBEntityZodShape & T>;
 export declare const customZodSchemas: {
-    base62: () => z.ZodString;
-    base64: () => z.ZodString;
-    base64Url: () => z.ZodString;
-    email: () => z.ZodEmail;
-    ianaTimezone: () => z.ZodEnum;
-    isoDate: () => ZodBrandedString<IsoDate>;
-    jwt: () => z.ZodString;
-    slug: () => z.ZodString;
-    semver: () => z.ZodString;
-    unixTimestamp: () => ZodBrandedInt<UnixTimestamp>;
-    unixTimestamp2000: () => ZodBrandedInt<UnixTimestamp>;
-    unixTimestampMillis: () => ZodBranded<z.ZodNumber, UnixTimestampMillis>;
-    unixTimestampMillis2000: () => ZodBrandedInt<UnixTimestampMillis>;
+    base62: typeof base62;
+    base64: typeof base64;
+    base64Url: typeof base64Url;
+    dbEntity: typeof dbEntity;
+    email: typeof email;
+    ianaTimezone: typeof ianaTimezone;
+    isoDate: typeof isoDate;
+    jwt: typeof jwt;
+    slug: typeof slug;
+    semver: typeof semVer;
+    unixTimestamp: typeof unixTimestamp;
+    unixTimestamp2000: typeof unixTimestamp2000;
+    unixTimestampMillis: typeof unixTimestampMillis;
+    unixTimestampMillis2000: typeof unixTimestampMillis2000;
 };
 export {};

package/dist/zod/zod.shared.schemas.js

@@ -1,71 +1,106 @@
 import { z } from 'zod';
-export const TS_2500 = 16725225600; // 2500-01-01
-export const TS_2000 = 946684800; // 2000-01-01
-export const zUnixTimestamp = () => z
-    .number()
-    .int()
-    .min(0)
-    .max(TS_2500, 'Must be a UnixTimestamp number')
-    .describe('UnixTimestamp');
-export const zUnixTimestamp2000 = () => z
-    .number()
-    .int()
-    .min(TS_2000)
-    .max(TS_2500, 'Must be a UnixTimestamp number after 2000-01-01')
-    .describe('UnixTimestamp2000');
-export const zUnixTimestampMillis = () => z
-    .number()
-    .int()
-    .min(0)
-    .max(TS_2500 * 1000, 'Must be a UnixTimestampMillis number')
-    .describe('UnixTimestampMillis');
-export const zUnixTimestampMillis2000 = () => z
-    .number()
-    .int()
-    .min(TS_2000 * 1000)
-    .max(TS_2500 * 1000, 'Must be a UnixTimestampMillis number after 2000-01-01')
-    .describe('UnixTimestampMillis2000');
-export const zSemVer = () => z
-    .string()
-    .regex(/^[0-9]+\.[0-9]+\.[0-9]+$/, 'Must be a SemVer string')
-    .describe('SemVer');
-export const zIsoDate = () => z
-    .string()
-    .refine(v => {
-    return /^\d{4}-\d{2}-\d{2}$/.test(v);
-}, 'Must be an IsoDateString')
-    .describe('IsoDateString');
-export const zEmail = () => z.email().describe('Email');
-export const BASE62_REGEX = /^[a-zA-Z0-9]+$/;
-export const BASE64_REGEX = /^[A-Za-z0-9+/]+={0,2}$/;
-export const BASE64URL_REGEX = /^[\w\-/]+$/;
-export const zBase62 = () => z.string().regex(BASE62_REGEX, 'Must be a base62 string').describe('Base62String');
-export const zBase64 = () => z.string().regex(BASE64_REGEX, 'Must be a base64 string').describe('Base64String');
-export const zBase64Url = () => z.string().regex(BASE64URL_REGEX, 'Must be a base64url string').describe('Base64UrlString');
-export const JWT_REGEX = /^[\w-]+\.[\w-]+\.[\w-]+$/;
-export const zJwt = () => z.string().regex(JWT_REGEX, 'Must be a JWT string').describe('JWTString');
+const TS_2500 = 16725225600; // 2500-01-01
+const TS_2000 = 946684800; // 2000-01-01
+function unixTimestamp() {
+    return z
+        .number()
+        .int()
+        .min(0)
+        .max(TS_2500, 'Must be a UnixTimestamp number')
+        .describe('UnixTimestamp');
+}
+function unixTimestamp2000() {
+    return z
+        .number()
+        .int()
+        .min(TS_2000)
+        .max(TS_2500, 'Must be a UnixTimestamp number after 2000-01-01')
+        .describe('UnixTimestamp2000');
+}
+function unixTimestampMillis() {
+    return z
+        .number()
+        .int()
+        .min(0)
+        .max(TS_2500 * 1000, 'Must be a UnixTimestampMillis number')
+        .describe('UnixTimestampMillis');
+}
+function unixTimestampMillis2000() {
+    return z
+        .number()
+        .int()
+        .min(TS_2000 * 1000)
+        .max(TS_2500 * 1000, 'Must be a UnixTimestampMillis number after 2000-01-01')
+        .describe('UnixTimestampMillis2000');
+}
+function semVer() {
+    return z
+        .string()
+        .regex(/^[0-9]+\.[0-9]+\.[0-9]+$/, 'Must be a SemVer string')
+        .describe('SemVer');
+}
+function isoDate() {
+    return z
+        .string()
+        .refine(v => {
+        return /^\d{4}-\d{2}-\d{2}$/.test(v);
+    }, 'Must be an IsoDateString')
+        .describe('IsoDateString');
+}
+function email() {
+    return z.email().describe('Email');
+}
+const BASE62_REGEX = /^[a-zA-Z0-9]+$/;
+const BASE64_REGEX = /^[A-Za-z0-9+/]+={0,2}$/;
+const BASE64URL_REGEX = /^[\w\-/]+$/;
+function base62() {
+    return z.string().regex(BASE62_REGEX, 'Must be a base62 string').describe('Base62String');
+}
+function base64() {
+    return z.string().regex(BASE64_REGEX, 'Must be a base64 string').describe('Base64String');
+}
+function base64Url() {
+    return z.string().regex(BASE64URL_REGEX, 'Must be a base64url string').describe('Base64UrlString');
+}
+const JWT_REGEX = /^[\w-]+\.[\w-]+\.[\w-]+$/;
+function jwt() {
+    return z.string().regex(JWT_REGEX, 'Must be a JWT string').describe('JWTString');
+}
 /**
  * "Slug" - a valid URL, filename, etc.
  */
-export const zSlug = () => z
-    .string()
-    .regex(/^[a-z0-9-]{1,255}$/, 'Must be a slug string')
-    .describe('Slug');
-export const zIanaTimezone = () => z
-    // UTC is added to assist unit-testing, which uses UTC by default (not technically a valid Iana timezone identifier)
-    .enum([...Intl.supportedValuesOf('timeZone'), 'UTC']);
+function slug() {
+    return z
+        .string()
+        .regex(/^[a-z0-9-]{1,255}$/, 'Must be a slug string')
+        .describe('Slug');
+}
+function ianaTimezone() {
+    return (z
+        // UTC is added to assist unit-testing, which uses UTC by default (not technically a valid Iana timezone identifier)
+        .enum([...Intl.supportedValuesOf('timeZone'), 'UTC']));
+}
+const baseDBEntitySchema = z.object({
+    id: z.string(),
+    created: unixTimestamp2000(),
+    updated: unixTimestamp2000(),
+});
+function dbEntity(shape) {
+    return baseDBEntitySchema.extend(shape ?? {});
+}
 export const customZodSchemas = {
-    base62: zBase62,
-    base64: zBase64,
-    base64Url: zBase64Url,
-    email: zEmail,
-    ianaTimezone: zIanaTimezone,
-    isoDate: zIsoDate,
-    jwt: zJwt,
-    slug: zSlug,
-    semver: zSemVer,
-    unixTimestamp: zUnixTimestamp,
-    unixTimestamp2000: zUnixTimestamp2000,
-    unixTimestampMillis: zUnixTimestampMillis,
-    unixTimestampMillis2000: zUnixTimestampMillis2000,
+    base62,
+    base64,
+    base64Url,
+    dbEntity,
+    email,
+    ianaTimezone,
+    isoDate,
+    jwt,
+    slug,
+    semver: semVer,
+    unixTimestamp,
+    unixTimestamp2000,
+    unixTimestampMillis,
+    unixTimestampMillis2000,
 };

package/dist/zod/zod.util.d.ts

@@ -1,7 +1,8 @@
 import type { ZodError, ZodType } from 'zod';
 import type { ErrorData } from '../error/error.model.js';
 import { AppError } from '../error/error.util.js';
-import type { ValidationFunctionResult } from '../validation/validation.js';
+import type { ValidationFunction, ValidationFunctionResult } from '../validation/validation.js';
+export declare function getZodValidationFunction<T>(schema: ZodType<T>): ValidationFunction<T, ZodValidationError>;
 export declare function zIsValid<T>(value: T, schema: ZodType<T>): boolean;
 export declare function zValidate<T>(value: T, schema: ZodType<T>): T;
 export declare function zSafeValidate<T>(input: T, schema: ZodType<T>): ValidationFunctionResult<T, ZodValidationError>;

package/dist/zod/zod.util.js

@@ -1,5 +1,12 @@
+import { _assert } from '../error/assert.js';
 import { AppError } from '../error/error.util.js';
 import { _stringify } from '../string/stringify.js';
+export function getZodValidationFunction(schema) {
+    return (input, opt) => {
+        _assert(!opt?.mutateInput, 'mutateInput=true is not yet supported with Zod');
+        return zSafeValidate(input, schema);
+    };
+}
 export function zIsValid(value, schema) {
     const { success } = schema.safeParse(value);
     return success;
@@ -27,9 +34,9 @@ export class ZodValidationError extends AppError {
 function createZodErrorMessage(err, schema, value) {
     let objectTitle = schema.description;
     if (typeof value === 'object' && value) {
-        const objectName = schema.description || value.constructor?.name;
-        const objectId = value['id'];
-        objectTitle = [objectName, objectId].filter(Boolean).join('.');
+        const inputName = schema.description || value.constructor?.name;
+        const inputId = value['id'];
+        objectTitle = [inputName, inputId].filter(Boolean).join('.');
     }
     objectTitle ||= 'data';
     return [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/js-lib",
   "type": "module",
-  "version": "15.20.0",
+  "version": "15.22.0",
   "dependencies": {
     "tslib": "^2",
     "zod": "^4"
@@ -12,7 +12,7 @@
     "@types/semver": "^7",
     "crypto-js": "^4",
     "dayjs": "^1",
-    "@naturalcycles/dev-lib": "19.14.0"
+    "@naturalcycles/dev-lib": "19.22.0"
   },
   "exports": {
     ".": "./dist/index.js",

package/src/datetime/localTime.ts

@@ -932,7 +932,7 @@ class LocalTimeFactory {
   /**
    * Throws on invalid value.
    */
-  private validateDateTimeObject(o: DateTimeObject): void {
+  validateDateTimeObject(o: DateTimeObject): void {
     _assert(
       this.isDateTimeObjectValid(o),
       `Cannot construct LocalTime from: ${o.year}-${o.month}-${o.day} ${o.hour}:${o.minute}:${o.second}`,

package/src/validation/validation.ts

@@ -23,6 +23,16 @@ export type ValidationFunction<T, ERR extends AppError> = (
 export type ValidationFunctionResult<T, ERR extends AppError> = [err: ERR | null, output: T]
 
 export interface ValidationFunctionOptions {
+  /**
+   * Defaults to false,
+   * which means that the ValidationFunction IS NOT ALLOWED to mutate the input.
+   * If set to true - the ValidationFunction HAS TO mutate the input
+   * if it needs to apply transformations, such as:
+   * - stripping unknown properties
+   * - converting types (e.g. string to number)
+   * - applying transformations (which as string trim, toLowerCase, etc)
+   */
+  mutateInput?: boolean
   /**
    * E.g User
    * Used for error message printing.

package/src/zod/zod.shared.schemas.ts

@@ -1,3 +1,4 @@
+import type { ZodString } from 'zod'
 import { z } from 'zod'
 import type { IsoDate, UnixTimestamp, UnixTimestampMillis } from '../types.js'
 
@@ -6,100 +7,138 @@ export type ZodBrandedString<B> = ZodBranded<z.ZodString, B>
 export type ZodBrandedInt<B> = ZodBranded<z.ZodInt, B>
 export type ZodBrandedNumber<B> = ZodBranded<z.ZodNumber, B>
 
-export const TS_2500 = 16725225600 // 2500-01-01
-export const TS_2000 = 946684800 // 2000-01-01
+const TS_2500 = 16725225600 // 2500-01-01
+const TS_2000 = 946684800 // 2000-01-01
 
-export const zUnixTimestamp = (): ZodBrandedInt<UnixTimestamp> =>
-  z
+function unixTimestamp(): ZodBrandedInt<UnixTimestamp> {
+  return z
     .number()
     .int()
     .min(0)
     .max(TS_2500, 'Must be a UnixTimestamp number')
     .describe('UnixTimestamp') as ZodBrandedInt<UnixTimestamp>
+}
 
-export const zUnixTimestamp2000 = (): ZodBrandedInt<UnixTimestamp> =>
-  z
+function unixTimestamp2000(): ZodBrandedInt<UnixTimestamp> {
+  return z
     .number()
     .int()
     .min(TS_2000)
     .max(TS_2500, 'Must be a UnixTimestamp number after 2000-01-01')
     .describe('UnixTimestamp2000') as ZodBrandedInt<UnixTimestamp>
+}
 
-export const zUnixTimestampMillis = (): ZodBranded<z.ZodNumber, UnixTimestampMillis> =>
-  z
+function unixTimestampMillis(): ZodBranded<z.ZodNumber, UnixTimestampMillis> {
+  return z
     .number()
     .int()
     .min(0)
     .max(TS_2500 * 1000, 'Must be a UnixTimestampMillis number')
     .describe('UnixTimestampMillis') as ZodBrandedInt<UnixTimestampMillis>
+}
 
-export const zUnixTimestampMillis2000 = (): ZodBrandedInt<UnixTimestampMillis> =>
-  z
+function unixTimestampMillis2000(): ZodBrandedInt<UnixTimestampMillis> {
+  return z
     .number()
     .int()
     .min(TS_2000 * 1000)
     .max(TS_2500 * 1000, 'Must be a UnixTimestampMillis number after 2000-01-01')
     .describe('UnixTimestampMillis2000') as ZodBrandedInt<UnixTimestampMillis>
+}
 
-export const zSemVer = (): z.ZodString =>
-  z
+function semVer(): z.ZodString {
+  return z
     .string()
     .regex(/^[0-9]+\.[0-9]+\.[0-9]+$/, 'Must be a SemVer string')
     .describe('SemVer')
+}
 
-export const zIsoDate = (): ZodBrandedString<IsoDate> =>
-  z
+function isoDate(): ZodBrandedString<IsoDate> {
+  return z
     .string()
     .refine(v => {
       return /^\d{4}-\d{2}-\d{2}$/.test(v)
     }, 'Must be an IsoDateString')
     .describe('IsoDateString') as ZodBrandedString<IsoDate>
+}
 
-export const zEmail = (): z.ZodEmail => z.email().describe('Email')
+function email(): z.ZodEmail {
+  return z.email().describe('Email')
+}
 
-export const BASE62_REGEX = /^[a-zA-Z0-9]+$/
-export const BASE64_REGEX = /^[A-Za-z0-9+/]+={0,2}$/
-export const BASE64URL_REGEX = /^[\w\-/]+$/
+const BASE62_REGEX = /^[a-zA-Z0-9]+$/
+const BASE64_REGEX = /^[A-Za-z0-9+/]+={0,2}$/
+const BASE64URL_REGEX = /^[\w\-/]+$/
 
-export const zBase62 = (): z.ZodString =>
-  z.string().regex(BASE62_REGEX, 'Must be a base62 string').describe('Base62String')
+function base62(): z.ZodString {
+  return z.string().regex(BASE62_REGEX, 'Must be a base62 string').describe('Base62String')
+}
 
-export const zBase64 = (): z.ZodString =>
-  z.string().regex(BASE64_REGEX, 'Must be a base64 string').describe('Base64String')
+function base64(): z.ZodString {
+  return z.string().regex(BASE64_REGEX, 'Must be a base64 string').describe('Base64String')
+}
 
-export const zBase64Url = (): z.ZodString =>
-  z.string().regex(BASE64URL_REGEX, 'Must be a base64url string').describe('Base64UrlString')
+function base64Url(): z.ZodString {
+  return z.string().regex(BASE64URL_REGEX, 'Must be a base64url string').describe('Base64UrlString')
+}
 
-export const JWT_REGEX = /^[\w-]+\.[\w-]+\.[\w-]+$/
-export const zJwt = (): z.ZodString =>
-  z.string().regex(JWT_REGEX, 'Must be a JWT string').describe('JWTString')
+const JWT_REGEX = /^[\w-]+\.[\w-]+\.[\w-]+$/
+
+function jwt(): z.ZodString {
+  return z.string().regex(JWT_REGEX, 'Must be a JWT string').describe('JWTString')
+}
 
 /**
  * "Slug" - a valid URL, filename, etc.
  */
-export const zSlug = (): z.ZodString =>
-  z
+function slug(): z.ZodString {
+  return z
     .string()
     .regex(/^[a-z0-9-]{1,255}$/, 'Must be a slug string')
     .describe('Slug')
+}
+
+function ianaTimezone(): z.ZodEnum {
+  return (
+    z
+      // UTC is added to assist unit-testing, which uses UTC by default (not technically a valid Iana timezone identifier)
+      .enum([...Intl.supportedValuesOf('timeZone'), 'UTC'])
+  )
+}
 
-export const zIanaTimezone = (): z.ZodEnum =>
-  z
-    // UTC is added to assist unit-testing, which uses UTC by default (not technically a valid Iana timezone identifier)
-    .enum([...Intl.supportedValuesOf('timeZone'), 'UTC'])
+const baseDBEntitySchema = z.object({
+  id: z.string(),
+  created: unixTimestamp2000(),
+  updated: unixTimestamp2000(),
+})
+
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+type BaseDBEntityZodShape = {
+  id: ZodString
+  created: ZodBrandedInt<UnixTimestamp>
+  updated: ZodBrandedInt<UnixTimestamp>
+}
+
+function dbEntity(): z.ZodObject<BaseDBEntityZodShape>
+function dbEntity<T extends z.ZodRawShape>(shape: T): z.ZodObject<BaseDBEntityZodShape & T>
+
+function dbEntity<T extends z.ZodRawShape>(shape?: T): z.ZodObject<BaseDBEntityZodShape & T> {
+  return baseDBEntitySchema.extend(shape ?? {}) as z.ZodObject<BaseDBEntityZodShape & T>
+}
 
 export const customZodSchemas = {
-  base62: zBase62,
-  base64: zBase64,
-  base64Url: zBase64Url,
-  email: zEmail,
-  ianaTimezone: zIanaTimezone,
-  isoDate: zIsoDate,
-  jwt: zJwt,
-  slug: zSlug,
-  semver: zSemVer,
-  unixTimestamp: zUnixTimestamp,
-  unixTimestamp2000: zUnixTimestamp2000,
-  unixTimestampMillis: zUnixTimestampMillis,
-  unixTimestampMillis2000: zUnixTimestampMillis2000,
+  base62,
+  base64,
+  base64Url,
+  dbEntity,
+  email,
+  ianaTimezone,
+  isoDate,
+  jwt,
+  slug,
+  semver: semVer,
+  unixTimestamp,
+  unixTimestamp2000,
+  unixTimestampMillis,
+  unixTimestampMillis2000,
 }

package/src/zod/zod.util.ts

@@ -1,8 +1,18 @@
 import type { ZodError, ZodType } from 'zod'
+import { _assert } from '../error/assert.js'
 import type { ErrorData } from '../error/error.model.js'
 import { AppError } from '../error/error.util.js'
 import { _stringify } from '../string/stringify.js'
-import type { ValidationFunctionResult } from '../validation/validation.js'
+import type { ValidationFunction, ValidationFunctionResult } from '../validation/validation.js'
+
+export function getZodValidationFunction<T>(
+  schema: ZodType<T>,
+): ValidationFunction<T, ZodValidationError> {
+  return (input, opt) => {
+    _assert(!opt?.mutateInput, 'mutateInput=true is not yet supported with Zod')
+    return zSafeValidate(input, schema)
+  }
+}
 
 export function zIsValid<T>(value: T, schema: ZodType<T>): boolean {
   const { success } = schema.safeParse(value)
@@ -18,7 +28,7 @@ export function zValidate<T>(value: T, schema: ZodType<T>): T {
 export function zSafeValidate<T>(
   input: T,
   schema: ZodType<T>,
-  // objectName?: string,
+  // inputName?: string,
 ): ValidationFunctionResult<T, ZodValidationError> {
   const r = schema.safeParse(input)
   if (r.success) {
@@ -28,19 +38,7 @@ export function zSafeValidate<T>(
   return [new ZodValidationError(r.error, input, schema), r.data ?? input]
 }
 
-export interface ZodValidationErrorData extends ErrorData {
-  // issues: $ZodIssue[]
-  // joiValidationObjectName?: string
-  // joiValidationObjectId?: string
-  /**
-   * Error "annotation" is stripped in Error.message.
-   * This field contains the "full" annotation.
-   *
-   * This field is non-enumerable, won't be printed or included in JSON by default,
-   * but still accessible programmatically (via `err.data.annotation`) when needed!
-   */
-  // annotation?: string
-}
+export interface ZodValidationErrorData extends ErrorData {}
 
 export class ZodValidationError extends AppError<ZodValidationErrorData> {
   constructor(zodError: ZodError, value: any, schema: ZodType) {
@@ -54,9 +52,9 @@ function createZodErrorMessage<T>(err: ZodError<T>, schema: ZodType<T>, value: T
   let objectTitle = schema.description
 
   if (typeof value === 'object' && value) {
-    const objectName = schema.description || value.constructor?.name
-    const objectId = (value as any)['id'] as string
-    objectTitle = [objectName, objectId].filter(Boolean).join('.')
+    const inputName = schema.description || value.constructor?.name
+    const inputId = (value as any)['id'] as string
+    objectTitle = [inputName, inputId].filter(Boolean).join('.')
   }
 
   objectTitle ||= 'data'