@veloxts/validation 0.7.1 → 0.7.2

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @veloxts/validation
 
+## 0.7.2
+
+### Patch Changes
+
+- chore(auth,core,create,cli,client,orm,mcp,router,validation,web): simplify code for clarity and maintainability
+- Updated dependencies
+  - @veloxts/core@0.7.2
+
 ## 0.7.1
 
 ### Patch Changes

package/dist/middleware.d.ts

@@ -7,7 +7,7 @@
  * @module middleware
  */
 import { ValidationError } from '@veloxts/core';
-import { ZodError, type ZodType } from 'zod';
+import type { ZodError, ZodType } from 'zod';
 import type { AnySchema, AnyZodSchema, SafeParseResult } from './types.js';
 /**
  * Transforms Zod validation issues into a field-error map

package/dist/middleware.js

@@ -7,11 +7,27 @@
  * @module middleware
  */
 import { ValidationError } from '@veloxts/core';
-import { ZodError } from 'zod';
 import { isSchema, isZodSchema } from './types.js';
 // ============================================================================
 // Error Transformation
 // ============================================================================
+/**
+ * Filters symbol keys from a Zod issue path, keeping only string and number segments.
+ * Zod 4 issue paths use `PropertyKey[]` which may include symbols.
+ */
+function filterIssuePath(path) {
+    return path.filter((p) => typeof p !== 'symbol');
+}
+/**
+ * Converts Zod issues into framework-friendly ValidationIssue objects
+ */
+function zodIssuesToValidationIssues(issues) {
+    return issues.map((issue) => ({
+        path: filterIssuePath(issue.path),
+        message: issue.message,
+        code: issue.code,
+    }));
+}
 /**
  * Transforms Zod validation issues into a field-error map
  *
@@ -22,7 +38,6 @@ export function formatZodErrors(issues) {
     const fields = {};
     for (const issue of issues) {
         const path = issue.path.join('.') || '_root';
-        // Only keep the first error for each field
         if (!(path in fields)) {
             fields[path] = issue.message;
         }
@@ -37,12 +52,8 @@ export function formatZodErrors(issues) {
  * @returns ValidationError with field-specific errors
  */
 export function zodErrorToValidationError(error, customMessage) {
-    const fields = formatZodErrors(error.issues.map((i) => ({
-        path: i.path.filter((p) => typeof p !== 'symbol'),
-        message: i.message,
-    })));
-    const message = customMessage ?? 'Validation failed';
-    return new ValidationError(message, fields);
+    const fields = formatZodErrors(zodIssuesToValidationIssues(error.issues));
+    return new ValidationError(customMessage ?? 'Validation failed', fields);
 }
 // ============================================================================
 // Validation Functions
@@ -68,28 +79,21 @@ export function zodErrorToValidationError(error, customMessage) {
  * ```
  */
 export function parse(schema, data, errorMessage) {
-    try {
-        if (isSchema(schema)) {
-            const result = schema.safeParse(data);
-            if (result.success) {
-                return result.data;
-            }
-            throw new ValidationError(errorMessage ?? 'Validation failed', formatZodErrors(result.error));
-        }
-        if (isZodSchema(schema)) {
-            return schema.parse(data);
+    if (isSchema(schema)) {
+        const result = schema.safeParse(data);
+        if (result.success) {
+            return result.data;
         }
-        throw new Error('Invalid schema provided to parse()');
+        throw new ValidationError(errorMessage ?? 'Validation failed', formatZodErrors(result.error));
     }
-    catch (error) {
-        if (error instanceof ValidationError) {
-            throw error;
-        }
-        if (error instanceof ZodError) {
-            throw zodErrorToValidationError(error, errorMessage);
+    if (isZodSchema(schema)) {
+        const result = schema.safeParse(data);
+        if (result.success) {
+            return result.data;
         }
-        throw error;
+        throw zodErrorToValidationError(result.error, errorMessage);
     }
+    throw new Error('Invalid schema provided to parse()');
 }
 /**
  * Safely parses data without throwing
@@ -116,18 +120,13 @@ export function safeParse(schema, data) {
         return schema.safeParse(data);
     }
     if (isZodSchema(schema)) {
-        const zodSchema = schema;
-        const result = zodSchema.safeParse(data);
+        const result = schema.safeParse(data);
         if (result.success) {
             return { success: true, data: result.data };
         }
         return {
             success: false,
-            error: result.error.issues.map((issue) => ({
-                path: issue.path.filter((p) => typeof p !== 'symbol'),
-                message: issue.message,
-                code: issue.code,
-            })),
+            error: zodIssuesToValidationIssues(result.error.issues),
         };
     }
     return {

package/dist/naming.js

@@ -76,7 +76,5 @@ export function inferMethodFromName(procedureName) {
  * ```
  */
 export function isQueryProcedure(procedureName) {
-    return (procedureName.startsWith('get') ||
-        procedureName.startsWith('list') ||
-        procedureName.startsWith('find'));
+    return inferMethodFromName(procedureName) === 'GET';
 }

package/dist/schemas/query.js

@@ -8,6 +8,7 @@
  * @module schemas/query
  */
 import { z } from 'zod';
+import { createPaginationSchema } from './pagination.js';
 export function queryNumber(defaultValue) {
     const base = z.coerce.number();
     return defaultValue !== undefined ? base.default(defaultValue) : base;
@@ -88,19 +89,23 @@ export function queryArray(options = {}) {
         .filter(Boolean));
     // Apply min/max constraints via refinement if needed
     if (min !== undefined || max !== undefined) {
+        let message;
+        if (min !== undefined && max !== undefined) {
+            message = `Array must have ${min}-${max} items`;
+        }
+        else if (min !== undefined) {
+            message = `Array must have at least ${min} item(s)`;
+        }
+        else {
+            message = `Array must have at most ${max} item(s)`;
+        }
         return baseSchema.refine((arr) => {
             if (min !== undefined && arr.length < min)
                 return false;
             if (max !== undefined && arr.length > max)
                 return false;
             return true;
-        }, {
-            message: min !== undefined && max !== undefined
-                ? `Array must have ${min}-${max} items`
-                : min !== undefined
-                    ? `Array must have at least ${min} item(s)`
-                    : `Array must have at most ${max} item(s)`,
-        });
+        }, { message });
     }
     return baseSchema;
 }
@@ -140,9 +145,5 @@ export function queryEnum(values, defaultValue) {
  * ```
  */
 export function pagination(options = {}) {
-    const { defaultPage = 1, defaultLimit = 20, maxLimit = 100 } = options;
-    return z.object({
-        page: z.coerce.number().int().positive().default(defaultPage),
-        limit: z.coerce.number().int().positive().max(maxLimit).default(defaultLimit),
-    });
+    return createPaginationSchema(options);
 }

package/dist/schemas/serialization.js

@@ -10,6 +10,29 @@ import { z } from 'zod';
 // ============================================================================
 // Prisma Decimal Helpers
 // ============================================================================
+/**
+ * Converts a Prisma Decimal, number, or string to a number.
+ * Shared conversion logic for all prismaDecimal variants.
+ */
+function coerceToNumber(val) {
+    if (typeof val === 'object' &&
+        val !== null &&
+        'toNumber' in val &&
+        typeof val.toNumber === 'function') {
+        return val.toNumber();
+    }
+    if (typeof val === 'number') {
+        return val;
+    }
+    if (typeof val === 'string') {
+        const num = Number.parseFloat(val);
+        if (Number.isNaN(num)) {
+            throw new Error(`Cannot convert "${val}" to number`);
+        }
+        return num;
+    }
+    throw new Error(`Cannot convert ${typeof val} to number`);
+}
 /**
  * Creates a field that accepts Prisma Decimal and transforms to number
  *
@@ -30,23 +53,7 @@ export function prismaDecimal() {
         if (val === null || val === undefined) {
             throw new Error('Expected Decimal, got null/undefined');
         }
-        // Prisma Decimal has toNumber() method
-        if (typeof val === 'object' && 'toNumber' in val && typeof val.toNumber === 'function') {
-            return val.toNumber();
-        }
-        // Already a number
-        if (typeof val === 'number') {
-            return val;
-        }
-        // String (from JSON)
-        if (typeof val === 'string') {
-            const num = Number.parseFloat(val);
-            if (Number.isNaN(num)) {
-                throw new Error(`Cannot convert "${val}" to number`);
-            }
-            return num;
-        }
-        throw new Error(`Cannot convert ${typeof val} to number`);
+        return coerceToNumber(val);
     });
 }
 /**
@@ -59,20 +66,7 @@ export function prismaDecimalNullable() {
         if (val === null || val === undefined) {
             return null;
         }
-        if (typeof val === 'object' && 'toNumber' in val && typeof val.toNumber === 'function') {
-            return val.toNumber();
-        }
-        if (typeof val === 'number') {
-            return val;
-        }
-        if (typeof val === 'string') {
-            const num = Number.parseFloat(val);
-            if (Number.isNaN(num)) {
-                throw new Error(`Cannot convert "${val}" to number`);
-            }
-            return num;
-        }
-        throw new Error(`Cannot convert ${typeof val} to number`);
+        return coerceToNumber(val);
     });
 }
 /**
@@ -85,20 +79,7 @@ export function prismaDecimalOptional() {
         if (val === null || val === undefined) {
             return undefined;
         }
-        if (typeof val === 'object' && 'toNumber' in val && typeof val.toNumber === 'function') {
-            return val.toNumber();
-        }
-        if (typeof val === 'number') {
-            return val;
-        }
-        if (typeof val === 'string') {
-            const num = Number.parseFloat(val);
-            if (Number.isNaN(num)) {
-                throw new Error(`Cannot convert "${val}" to number`);
-            }
-            return num;
-        }
-        throw new Error(`Cannot convert ${typeof val} to number`);
+        return coerceToNumber(val);
     });
 }
 // ============================================================================

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@veloxts/validation",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Zod integration and validation middleware for VeloxTS framework",
   "type": "module",
   "main": "dist/index.js",
@@ -23,7 +23,7 @@
   },
   "dependencies": {
     "zod": "4.3.6",
-    "@veloxts/core": "0.7.1"
+    "@veloxts/core": "0.7.2"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "4.0.18",