@naturalcycles/js-lib 15.3.0 → 15.5.0

package/dist/zod/index.d.ts

@@ -1,6 +1,6 @@
 export * from './zod.shared.schemas.js';
 export * from './zod.util.js';
-import type { ZodIssue } from 'zod';
-import { z, ZodError, ZodSchema } from 'zod';
-export { z, ZodError, ZodSchema };
-export type { ZodIssue };
+import type { ZodJSONSchema } from 'zod/v4';
+import { z, ZodType } from 'zod/v4';
+export { z, ZodType };
+export type { ZodJSONSchema };

package/dist/zod/index.js

@@ -1,4 +1,4 @@
 export * from './zod.shared.schemas.js';
 export * from './zod.util.js';
-import { z, ZodError, ZodSchema } from 'zod';
-export { z, ZodError, ZodSchema };
+import { z, ZodType } from 'zod/v4';
+export { z, ZodType };

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod/v4';
 export declare const TS_2500 = 16725225600;
 export declare const TS_2000 = 946684800;
 export declare const zUnixTimestamp: z.ZodNumber;
@@ -6,8 +6,9 @@ export declare const zUnixTimestamp2000: z.ZodNumber;
 export declare const zUnixTimestampMillis: z.ZodNumber;
 export declare const zUnixTimestampMillis2000: z.ZodNumber;
 export declare const zSemVer: z.ZodString;
-export declare const zIsoDateString: z.ZodEffects<z.ZodString, string, string>;
-export declare const zEmail: z.ZodEffects<z.ZodString, string, string>;
+export declare const zIsoDate: z.ZodString;
+export declare const zEmail: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+export declare const zEmailNoLowercase: z.ZodString;
 export declare const BASE62_REGEX: RegExp;
 export declare const BASE64_REGEX: RegExp;
 export declare const BASE64URL_REGEX: RegExp;
@@ -28,12 +29,4 @@ export declare const zBaseDBEntity: z.ZodObject<{
     id: z.ZodString;
     created: z.ZodOptional<z.ZodNumber>;
     updated: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    created?: number | undefined;
-    updated?: number | undefined;
-}, {
-    id: string;
-    created?: number | undefined;
-    updated?: number | undefined;
-}>;
+}, z.core.$strip>;

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import { z } from 'zod/v4';
 export const TS_2500 = 16725225600; // 2500-01-01
 export const TS_2000 = 946684800; // 2000-01-01
 export const zUnixTimestamp = z
@@ -6,40 +6,51 @@ export const zUnixTimestamp = z
     .int()
     .min(0)
     .max(TS_2500, 'Must be a UnixTimestamp number')
+    // .transform(v => v as UnixTimestamp) // breaks jsonSchema
     .describe('UnixTimestamp');
 export const zUnixTimestamp2000 = z
     .number()
     .int()
     .min(TS_2000)
     .max(TS_2500, 'Must be a UnixTimestamp number after 2000-01-01')
+    // .transform(v => v as UnixTimestamp)
     .describe('UnixTimestamp2000');
 export const zUnixTimestampMillis = z
     .number()
     .int()
     .min(0)
     .max(TS_2500 * 1000, 'Must be a UnixTimestampMillis number')
+    // .transform(v => v as UnixTimestampMillis)
     .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')
+    // .transform(v => v as UnixTimestampMillis)
     .describe('UnixTimestampMillis2000');
 export const zSemVer = z
     .string()
     .regex(/^[0-9]+\.[0-9]+\.[0-9]+$/, 'Must be a SemVer string')
     .describe('SemVer');
-export const zIsoDateString = z
+export const zIsoDate = z
     .string()
     .refine(v => {
     return /^\d{4}-\d{2}-\d{2}$/.test(v);
 }, 'Must be an IsoDateString')
+    // .transform(v => v as IsoDate)
     .describe('IsoDateString');
 export const zEmail = z
     .string()
     .trim()
-    .email()
-    .transform(s => s.toLowerCase())
+    .email() // keeping as-is, so trim happens before email validation
+    .transform(s => s.toLowerCase()) // breaks toJsonSchema
+    .describe('Email');
+export const zEmailNoLowercase = z
+    .string()
+    .trim()
+    .email() // keeping as-is, so trim happens before email validation
+    // .transform(s => s.toLowerCase()) // breaks toJsonSchema
     .describe('Email');
 export const BASE62_REGEX = /^[a-zA-Z0-9]+$/;
 export const BASE64_REGEX = /^[A-Za-z0-9+/]+={0,2}$/;
@@ -60,7 +71,7 @@ export const JWT_REGEX = /^[\w-]+\.[\w-]+\.[\w-]+$/;
 export const zJwt = z.string().regex(JWT_REGEX, 'Must be a JWT string').describe('JWTString');
 export const zId = z
     .string()
-    .regex(/^[a-zA-Z0-9_]{6,64}$/, 'Must be an id string')
+    .regex(/^[a-zA-Z0-9_]{6,64}$/, 'Must be an id string (6 to 64 chars long)')
     .describe('IdString');
 export const zIdBase62 = z
     .string()

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

@@ -1,21 +1,21 @@
-import { ZodError, type ZodIssue, type ZodSchema } from 'zod';
+import type { ZodError, ZodType } from 'zod/v4';
+import type { ErrorData } from '../error/error.model.js';
+import { AppError } from '../error/error.util.js';
 export interface ZodErrorResult<T> {
     success: false;
     data?: T;
-    error: ZodValidationError<T>;
+    error: ZodValidationError;
 }
 export interface ZodSuccessResult<T> {
     success: true;
     data: T;
-    error?: ZodValidationError<T>;
+    error?: ZodValidationError;
 }
-export declare function zIsValid<T>(value: T, schema: ZodSchema<T>): boolean;
-export declare function zValidate<T>(value: T, schema: ZodSchema<T>): T;
-export declare function zSafeValidate<T>(value: T, schema: ZodSchema<T>): ZodSuccessResult<T> | ZodErrorResult<T>;
-export declare class ZodValidationError<T> extends ZodError<T> {
-    value: T;
-    schema: ZodSchema<T>;
-    constructor(issues: ZodIssue[], value: T, schema: ZodSchema<T>);
-    get message(): string;
-    annotate(): string;
+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>(value: T, schema: ZodType<T>): ZodSuccessResult<T> | ZodErrorResult<T>;
+export interface ZodValidationErrorData extends ErrorData {
+}
+export declare class ZodValidationError extends AppError<ZodValidationErrorData> {
+    constructor(zodError: ZodError, value: any, schema: ZodType);
 }

package/dist/zod/zod.util.js

@@ -1,4 +1,4 @@
-import { ZodError } from 'zod';
+import { AppError } from '../error/error.util.js';
 import { _stringify } from '../string/stringify.js';
 export function zIsValid(value, schema) {
     const { success } = schema.safeParse(value);
@@ -18,37 +18,32 @@ export function zSafeValidate(value, schema) {
     }
     return {
         success: false,
-        error: new ZodValidationError(r.error.issues, value, schema),
+        error: new ZodValidationError(r.error, value, schema),
     };
 }
-export class ZodValidationError extends ZodError {
-    value;
-    schema;
-    constructor(issues, value, schema) {
-        super(issues);
-        this.value = value;
-        this.schema = schema;
+export class ZodValidationError extends AppError {
+    constructor(zodError, value, schema) {
+        const message = createZodErrorMessage(zodError, schema, value);
+        // const message = z.prettifyError(zodError) // todo: consider adopting it instead
+        super(message, {}, { name: 'ZodValidationError' });
     }
-    get message() {
-        return this.annotate();
-    }
-    annotate() {
-        let objectTitle = this.schema.description;
-        if (typeof this.value === 'object' && this.value) {
-            const objectName = this.schema.description || this.value.constructor?.name;
-            const objectId = this.value['id'];
-            objectTitle = [objectName, objectId].filter(Boolean).join('.');
-        }
-        objectTitle ||= 'data';
-        return [
-            `Invalid ${objectTitle}`,
-            '',
-            'Input:',
-            _stringify(this.value),
-            this.issues.length > 1 ? `\n${this.issues.length} issues:` : '',
-            ...this.issues.slice(0, 100).map(i => {
-                return [i.path.join('.'), i.message].filter(Boolean).join(': ');
-            }),
-        ].join('\n');
+}
+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('.');
     }
+    objectTitle ||= 'data';
+    return [
+        `Invalid ${objectTitle}`,
+        '',
+        'Input:',
+        _stringify(value),
+        err.issues.length > 1 ? `\n${err.issues.length} issues:` : '',
+        ...err.issues.slice(0, 100).map(i => {
+            return [i.path.join('.'), i.message].filter(Boolean).join(': ');
+        }),
+    ].join('\n');
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/js-lib",
   "type": "module",
-  "version": "15.3.0",
+  "version": "15.5.0",
   "dependencies": {
     "tslib": "^2",
     "zod": "^3"

package/src/zod/index.ts

@@ -1,7 +1,7 @@
 export * from './zod.shared.schemas.js'
 export * from './zod.util.js'
-import type { ZodIssue } from 'zod'
-import { z, ZodError, ZodSchema } from 'zod'
+import type { ZodJSONSchema } from 'zod/v4'
+import { z, ZodType } from 'zod/v4'
 
-export { z, ZodError, ZodSchema }
-export type { ZodIssue }
+export { z, ZodType }
+export type { ZodJSONSchema }

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

@@ -1,4 +1,4 @@
-import { z } from 'zod'
+import { z } from 'zod/v4'
 
 export const TS_2500 = 16725225600 // 2500-01-01
 export const TS_2000 = 946684800 // 2000-01-01
@@ -8,24 +8,28 @@ export const zUnixTimestamp = z
   .int()
   .min(0)
   .max(TS_2500, 'Must be a UnixTimestamp number')
+  // .transform(v => v as UnixTimestamp) // breaks jsonSchema
   .describe('UnixTimestamp')
 export const zUnixTimestamp2000 = z
   .number()
   .int()
   .min(TS_2000)
   .max(TS_2500, 'Must be a UnixTimestamp number after 2000-01-01')
+  // .transform(v => v as UnixTimestamp)
   .describe('UnixTimestamp2000')
 export const zUnixTimestampMillis = z
   .number()
   .int()
   .min(0)
   .max(TS_2500 * 1000, 'Must be a UnixTimestampMillis number')
+  // .transform(v => v as UnixTimestampMillis)
   .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')
+  // .transform(v => v as UnixTimestampMillis)
   .describe('UnixTimestampMillis2000')
 
 export const zSemVer = z
@@ -33,18 +37,26 @@ export const zSemVer = z
   .regex(/^[0-9]+\.[0-9]+\.[0-9]+$/, 'Must be a SemVer string')
   .describe('SemVer')
 
-export const zIsoDateString = z
+export const zIsoDate = z
   .string()
   .refine(v => {
     return /^\d{4}-\d{2}-\d{2}$/.test(v)
   }, 'Must be an IsoDateString')
+  // .transform(v => v as IsoDate)
   .describe('IsoDateString')
 
 export const zEmail = z
   .string()
   .trim()
-  .email()
-  .transform(s => s.toLowerCase())
+  .email() // keeping as-is, so trim happens before email validation
+  .transform(s => s.toLowerCase()) // breaks toJsonSchema
+  .describe('Email')
+
+export const zEmailNoLowercase = z
+  .string()
+  .trim()
+  .email() // keeping as-is, so trim happens before email validation
+  // .transform(s => s.toLowerCase()) // breaks toJsonSchema
   .describe('Email')
 
 export const BASE62_REGEX = /^[a-zA-Z0-9]+$/
@@ -68,7 +80,7 @@ export const zJwt = z.string().regex(JWT_REGEX, 'Must be a JWT string').describe
 
 export const zId = z
   .string()
-  .regex(/^[a-zA-Z0-9_]{6,64}$/, 'Must be an id string')
+  .regex(/^[a-zA-Z0-9_]{6,64}$/, 'Must be an id string (6 to 64 chars long)')
   .describe('IdString')
 export const zIdBase62 = z
   .string()

package/src/zod/zod.util.ts

@@ -1,24 +1,26 @@
-import { ZodError, type ZodIssue, type ZodSchema } from 'zod'
+import type { ZodError, ZodType } from 'zod/v4'
+import type { ErrorData } from '../error/error.model.js'
+import { AppError } from '../error/error.util.js'
 import { _stringify } from '../string/stringify.js'
 
 export interface ZodErrorResult<T> {
   success: false
   data?: T
-  error: ZodValidationError<T>
+  error: ZodValidationError
 }
 
 export interface ZodSuccessResult<T> {
   success: true
   data: T
-  error?: ZodValidationError<T>
+  error?: ZodValidationError
 }
 
-export function zIsValid<T>(value: T, schema: ZodSchema<T>): boolean {
+export function zIsValid<T>(value: T, schema: ZodType<T>): boolean {
   const { success } = schema.safeParse(value)
   return success
 }
 
-export function zValidate<T>(value: T, schema: ZodSchema<T>): T {
+export function zValidate<T>(value: T, schema: ZodType<T>): T {
   const r = zSafeValidate(value, schema)
   if (r.success) {
     return r.data
@@ -29,7 +31,7 @@ export function zValidate<T>(value: T, schema: ZodSchema<T>): T {
 
 export function zSafeValidate<T>(
   value: T,
-  schema: ZodSchema<T>,
+  schema: ZodType<T>,
   // objectName?: string,
 ): ZodSuccessResult<T> | ZodErrorResult<T> {
   const r = schema.safeParse(value)
@@ -39,43 +41,51 @@ export function zSafeValidate<T>(
 
   return {
     success: false,
-    error: new ZodValidationError<T>(r.error.issues, value, schema),
+    error: new ZodValidationError(r.error, value, schema),
   }
 }
 
-export class ZodValidationError<T> extends ZodError<T> {
-  constructor(
-    issues: ZodIssue[],
-    public value: T,
-    public schema: ZodSchema<T>,
-  ) {
-    super(issues)
-  }
+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
+}
 
-  override get message(): string {
-    return this.annotate()
+export class ZodValidationError extends AppError<ZodValidationErrorData> {
+  constructor(zodError: ZodError, value: any, schema: ZodType) {
+    const message = createZodErrorMessage(zodError, schema, value)
+    // const message = z.prettifyError(zodError) // todo: consider adopting it instead
+    super(message, {}, { name: 'ZodValidationError' })
   }
+}
 
-  annotate(): string {
-    let objectTitle = this.schema.description
+function createZodErrorMessage<T>(err: ZodError<T>, schema: ZodType<T>, value: T): string {
+  let objectTitle = schema.description
 
-    if (typeof this.value === 'object' && this.value) {
-      const objectName = this.schema.description || this.value.constructor?.name
-      const objectId = (this.value as any)['id'] as string
-      objectTitle = [objectName, objectId].filter(Boolean).join('.')
-    }
+  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('.')
+  }
 
-    objectTitle ||= 'data'
+  objectTitle ||= 'data'
 
-    return [
-      `Invalid ${objectTitle}`,
-      '',
-      'Input:',
-      _stringify(this.value),
-      this.issues.length > 1 ? `\n${this.issues.length} issues:` : '',
-      ...this.issues.slice(0, 100).map(i => {
-        return [i.path.join('.'), i.message].filter(Boolean).join(': ')
-      }),
-    ].join('\n')
-  }
+  return [
+    `Invalid ${objectTitle}`,
+    '',
+    'Input:',
+    _stringify(value),
+    err.issues.length > 1 ? `\n${err.issues.length} issues:` : '',
+    ...err.issues.slice(0, 100).map(i => {
+      return [i.path.join('.'), i.message].filter(Boolean).join(': ')
+    }),
+  ].join('\n')
 }