@carno.js/core 0.2.7 → 0.2.9

package/dist/Carno.d.ts

@@ -1,27 +1,29 @@
 import { Server } from "bun";
-import { ValidatorOptions } from "class-validator";
 import * as pino from "pino";
+import type { ValidationConfig, ValidatorAdapterConstructor } from "./validation/ValidatorAdapter";
 import { TokenRouteWithProvider } from "./container/ContainerConfiguration";
 import { CorsConfig } from "./domain/cors-config";
 import Memoirist from "./route/memoirist";
 import { type CompiledRoute } from "./route/CompiledRoute";
-export interface ApplicationConfig {
-    validation?: ValidatorOptions;
+export interface ApplicationConfig<TAdapter extends ValidatorAdapterConstructor = ValidatorAdapterConstructor> {
+    validation?: ValidationConfig<TAdapter>;
     logger?: pino.LoggerOptions;
     exports?: any[];
     providers?: any[];
     cors?: CorsConfig;
     globalMiddlewares?: any[];
 }
-export declare class Carno {
-    config: ApplicationConfig;
+export declare class Carno<TAdapter extends ValidatorAdapterConstructor = ValidatorAdapterConstructor> {
+    config: ApplicationConfig<TAdapter>;
     router: Memoirist<CompiledRoute | TokenRouteWithProvider>;
     private injector;
     private corsCache?;
     private readonly emptyLocals;
+    private validatorAdapter;
     private fetch;
     private server;
-    constructor(config?: ApplicationConfig);
+    constructor(config?: ApplicationConfig<TAdapter>);
+    private resolveValidatorAdapter;
     /**
      * Use the Carno plugin.
      *
@@ -49,7 +51,7 @@ export declare class Carno {
     listen(port?: number): Promise<void>;
     private registerShutdownHandlers;
     getHttpServer(): Server<any>;
-    getInjector(): import(".").InjectorService;
+    getInjector(): import("./container").InjectorService;
     private createHttpServer;
     private fetcher;
     private catcher;

package/dist/Carno.js

@@ -5,6 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Carno = void 0;
 const node_process_1 = __importDefault(require("node:process"));
+const ZodAdapter_1 = require("./validation/adapters/ZodAdapter");
+const ValidationCache_1 = require("./utils/ValidationCache");
 const index_1 = require("./commons/index");
 const constants_1 = require("./constants");
 const createContainer_1 = require("./container/createContainer");
@@ -56,11 +58,21 @@ class Carno {
             console.error("Unhandled error:", error);
             return new Response("Internal Server Error", { status: 500 });
         };
+        this.validatorAdapter = this.resolveValidatorAdapter();
         if (config.cors) {
             this.corsCache = new cors_headers_cache_1.CorsHeadersCache(config.cors);
         }
         void this.bootstrapApplication();
     }
+    resolveValidatorAdapter() {
+        const config = this.config.validation;
+        if (!config?.adapter) {
+            return new ZodAdapter_1.ZodAdapter();
+        }
+        const AdapterClass = config.adapter;
+        const options = config.options || {};
+        return new AdapterClass(options);
+    }
     /**
      * Use the Carno plugin.
      *
@@ -148,8 +160,9 @@ class Carno {
         };
     }
     async init() {
+        (0, ValidationCache_1.setValidatorAdapter)(this.validatorAdapter);
         this.loadProvidersAndControllers();
-        await this.injector.loadModule((0, createContainer_1.createContainer)(), this.config, this.router);
+        await this.injector.loadModule((0, createContainer_1.createContainer)(), this.config, this.router, this.validatorAdapter);
     }
     async listen(port = 3000) {
         this.registerShutdownHandlers();

package/dist/commons/decorators/index.d.ts

@@ -3,3 +3,4 @@ export * from './http.decorators';
 export * from './service.decorator';
 export * from './middleware.decorator';
 export * from './Injectable.decorator';
+export * from './validation.decorator';

package/dist/commons/decorators/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./http.decorators"), exports);
 __exportStar(require("./service.decorator"), exports);
 __exportStar(require("./middleware.decorator"), exports);
 __exportStar(require("./Injectable.decorator"), exports);
+__exportStar(require("./validation.decorator"), exports);

package/dist/commons/decorators/validation.decorator.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+/**
+ * Decorator to attach a Zod schema to a DTO class
+ * The schema will be used for validation when the DTO is used in route handlers
+ *
+ * @example
+ * ```typescript
+ * const CreateUserSchema = z.object({
+ *   name: z.string().min(3),
+ *   email: z.string().email()
+ * });
+ *
+ * @ZodSchema(CreateUserSchema)
+ * class CreateUserDto {
+ *   name: string;
+ *   email: string;
+ * }
+ *
+ * @Controller('/users')
+ * class UserController {
+ *   @Post()
+ *   create(@Body() dto: CreateUserDto) {
+ *     // dto is validated and typed
+ *     return dto;
+ *   }
+ * }
+ * ```
+ *
+ * @param schema - The Zod schema to use for validation
+ * @returns Class decorator
+ */
+export declare function ZodSchema<T extends z.ZodType>(schema: T): ClassDecorator;

package/dist/commons/decorators/validation.decorator.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZodSchema = ZodSchema;
+const Metadata_1 = require("../../domain/Metadata");
+const constants_1 = require("../../constants");
+/**
+ * Decorator to attach a Zod schema to a DTO class
+ * The schema will be used for validation when the DTO is used in route handlers
+ *
+ * @example
+ * ```typescript
+ * const CreateUserSchema = z.object({
+ *   name: z.string().min(3),
+ *   email: z.string().email()
+ * });
+ *
+ * @ZodSchema(CreateUserSchema)
+ * class CreateUserDto {
+ *   name: string;
+ *   email: string;
+ * }
+ *
+ * @Controller('/users')
+ * class UserController {
+ *   @Post()
+ *   create(@Body() dto: CreateUserDto) {
+ *     // dto is validated and typed
+ *     return dto;
+ *   }
+ * }
+ * ```
+ *
+ * @param schema - The Zod schema to use for validation
+ * @returns Class decorator
+ */
+function ZodSchema(schema) {
+    return (target) => {
+        Metadata_1.Metadata.set(constants_1.VALIDATION_ZOD_SCHEMA, schema, target);
+    };
+}

package/dist/constants.d.ts

@@ -5,3 +5,4 @@ export declare const CONTROLLER_EVENTS = "carno:controller:events";
 export declare const ROUTE_PARAM = "carno:route:param";
 export declare const ROUTE_MIDDLEWARES = "carno:route:middlewares";
 export declare const PROVIDER = "carno:provider";
+export declare const VALIDATION_ZOD_SCHEMA = "carno:validation:zod";

package/dist/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROVIDER = exports.ROUTE_MIDDLEWARES = exports.ROUTE_PARAM = exports.CONTROLLER_EVENTS = exports.CONTROLLER_MIDDLEWARES = exports.CONTROLLER_ROUTES = exports.CONTROLLER = void 0;
+exports.VALIDATION_ZOD_SCHEMA = exports.PROVIDER = exports.ROUTE_MIDDLEWARES = exports.ROUTE_PARAM = exports.CONTROLLER_EVENTS = exports.CONTROLLER_MIDDLEWARES = exports.CONTROLLER_ROUTES = exports.CONTROLLER = void 0;
 exports.CONTROLLER = "carno:controller";
 exports.CONTROLLER_ROUTES = "carno:controller:routes";
 exports.CONTROLLER_MIDDLEWARES = "carno:controller:middlewares";
@@ -8,3 +8,4 @@ exports.CONTROLLER_EVENTS = "carno:controller:events";
 exports.ROUTE_PARAM = "carno:route:param";
 exports.ROUTE_MIDDLEWARES = "carno:route:middlewares";
 exports.PROVIDER = "carno:provider";
+exports.VALIDATION_ZOD_SCHEMA = "carno:validation:zod";

package/dist/container/InjectorService.d.ts

@@ -1,5 +1,6 @@
 import type { ApplicationConfig } from "../Carno";
 import { TokenProvider } from "../commons/registries/ProviderControl";
+import type { ValidatorAdapter } from "../validation/ValidatorAdapter";
 import { Context } from "../domain/Context";
 import { LocalsContainer } from "../domain/LocalsContainer";
 import { Provider } from "../domain/provider";
@@ -20,7 +21,8 @@ export declare class InjectorService {
     private routeResolver;
     private dependencyResolver;
     private methodInvoker;
-    loadModule(container: Container, applicationConfig: ApplicationConfig, router: Memoirist<any>): Promise<void>;
+    private validatorAdapter;
+    loadModule(container: Container, applicationConfig: ApplicationConfig, router: Memoirist<any>, validatorAdapter: ValidatorAdapter): Promise<void>;
     private initializeResolvers;
     private ensureProvider;
     get(token: TokenProvider): Provider | undefined;

package/dist/container/InjectorService.js

@@ -40,10 +40,11 @@ let InjectorService = InjectorService_1 = class InjectorService {
         this._hasOnResponseHook = false;
         this.controllerScopes = new Map();
     }
-    async loadModule(container, applicationConfig, router) {
+    async loadModule(container, applicationConfig, router, validatorAdapter) {
         this.container = container;
         this.router = router;
         this.applicationConfig = applicationConfig;
+        this.validatorAdapter = validatorAdapter;
         this.initializeResolvers();
         this.removeUnknownProviders();
         this.saveInjector();
@@ -57,7 +58,7 @@ let InjectorService = InjectorService_1 = class InjectorService {
     initializeResolvers() {
         this.routeResolver = new RouteResolver_1.RouteResolver(this.router, this.applicationConfig.globalMiddlewares);
         this.dependencyResolver = new DependencyResolver_1.DependencyResolver(this.container);
-        this.methodInvoker = new MethodInvoker_1.MethodInvoker(this.applicationConfig);
+        this.methodInvoker = new MethodInvoker_1.MethodInvoker(this.applicationConfig, this.validatorAdapter);
     }
     ensureProvider(token) {
         if (!this.container.has(token) && ProviderControl_1.GlobalProvider.has(token)) {
@@ -175,7 +176,7 @@ let InjectorService = InjectorService_1 = class InjectorService {
         const compiler = new RouteCompiler_1.RouteCompiler({
             container: this.container,
             controllerScopes: this.controllerScopes,
-            validationConfig: this.applicationConfig.validation,
+            validatorAdapter: this.validatorAdapter,
             hasOnRequestHook: this._hasOnRequestHook,
             hasOnResponseHook: this._hasOnResponseHook,
         });

package/dist/container/MethodInvoker.d.ts

@@ -2,10 +2,12 @@ import { ApplicationConfig } from "../Carno";
 import { TokenProvider } from "../commons/registries/ProviderControl";
 import { Context } from "../domain/Context";
 import { LocalsContainer } from "../domain/LocalsContainer";
+import type { ValidatorAdapter } from "../validation/ValidatorAdapter";
 export declare class MethodInvoker {
     private applicationConfig;
+    private validatorAdapter;
     private historyMethods;
-    constructor(applicationConfig: ApplicationConfig);
+    constructor(applicationConfig: ApplicationConfig, validatorAdapter: ValidatorAdapter);
     invoke(instance: any, methodName: string, locals: LocalsContainer, context: Context, invokeCallback: (token: TokenProvider, locals: LocalsContainer) => any): Promise<any>;
     private getMethodInfo;
     private getCachedMethod;
@@ -16,5 +18,4 @@ export declare class MethodInvoker {
     private hasBodyParam;
     private isBodyParam;
     private resolveService;
-    private validateAndTransform;
 }

package/dist/container/MethodInvoker.js

@@ -1,16 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MethodInvoker = void 0;
-const class_transformer_1 = require("class-transformer");
-const class_validator_1 = require("class-validator");
 const Metadata_1 = require("../domain/Metadata");
-const HttpException_1 = require("../exceptions/HttpException");
 const getClassOrSymbol_1 = require("../utils/getClassOrSymbol");
 const getMethodArgTypes_1 = require("../utils/getMethodArgTypes");
-const isClassValidator_1 = require("../utils/isClassValidator");
 class MethodInvoker {
-    constructor(applicationConfig) {
+    constructor(applicationConfig, validatorAdapter) {
         this.applicationConfig = applicationConfig;
+        this.validatorAdapter = validatorAdapter;
         this.historyMethods = new WeakMap();
     }
     async invoke(instance, methodName, locals, context, invokeCallback) {
@@ -78,19 +75,9 @@ class MethodInvoker {
             return invokeCallback((0, getClassOrSymbol_1.getClassOrSymbol)(token), locals);
         }
         const value = param.fun(context, param.param);
-        return (0, isClassValidator_1.isClassValidator)(token)
-            ? this.validateAndTransform(token, value)
+        return this.validatorAdapter.hasValidation(token)
+            ? this.validatorAdapter.validateAndTransform(token, value)
             : value;
     }
-    validateAndTransform(token, value) {
-        const obj = (0, class_transformer_1.plainToInstance)(token, value);
-        const errors = (0, class_validator_1.validateSync)(obj, this.applicationConfig.validation);
-        // todo: deve retornar apenas os erros e no o objeto class-validator intei
-        // ro.
-        if (errors.length > 0) {
-            throw new HttpException_1.HttpException(errors, 400);
-        }
-        return obj;
-    }
 }
 exports.MethodInvoker = MethodInvoker;

package/dist/exceptions/HttpException.js

@@ -9,12 +9,12 @@ class HttpException {
         this.initMessage();
     }
     initMessage() {
-        if ((0, utils_1.isObject)(this.response)) {
-            this.message = this.response;
-        }
-        else {
-            this.message = this.response;
+        const formatted = (0, utils_1.formatValidationErrors)(this.response);
+        if ((0, utils_1.isObject)(formatted)) {
+            this.message = formatted;
+            return;
         }
+        this.message = formatted;
     }
     getResponse() {
         return this.message;

package/dist/index.d.ts

@@ -13,3 +13,4 @@ export * from "./services/logger.service";
 export * from "./cache/cache.service";
 export * from "./cache/bento-cache.driver";
 export * from "./testing";
+export * from "./validation";

package/dist/index.js

@@ -29,3 +29,4 @@ __exportStar(require("./services/logger.service"), exports);
 __exportStar(require("./cache/cache.service"), exports);
 __exportStar(require("./cache/bento-cache.driver"), exports);
 __exportStar(require("./testing"), exports);
+__exportStar(require("./validation"), exports);

package/dist/route/ParamResolverFactory.d.ts

@@ -1,6 +1,4 @@
-import { type ValidatorOptions } from 'class-validator';
 import type { Context } from '../domain/Context';
-import type { ParamResolver, AsyncParamResolver } from './CompiledRoute';
 export type ParamDecoratorType = 'body' | 'query' | 'param' | 'headers' | 'req' | 'locals';
 export interface ParamDecoratorMeta {
     fun: (context: Context, data?: any) => any;
@@ -14,6 +12,3 @@ export interface ParamInfo {
     token?: any;
 }
 export declare function analyzeParamDecorator(decoratorMeta: ParamDecoratorMeta | undefined, token: any): ParamInfo;
-export declare function createParamResolver(decoratorMeta: ParamDecoratorMeta | undefined, token: any, validationConfig?: ValidatorOptions): ParamResolver | AsyncParamResolver | null;
-export declare function createParamResolvers(paramMetas: Record<number, ParamDecoratorMeta> | undefined, argTypes: any[], validationConfig?: ValidatorOptions): (ParamResolver | AsyncParamResolver | null)[];
-export declare function hasAnyDIParam(resolvers: (ParamResolver | AsyncParamResolver | null)[]): boolean;

package/dist/route/ParamResolverFactory.js

@@ -1,12 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeParamDecorator = analyzeParamDecorator;
-exports.createParamResolver = createParamResolver;
-exports.createParamResolvers = createParamResolvers;
-exports.hasAnyDIParam = hasAnyDIParam;
-const class_transformer_1 = require("class-transformer");
-const class_validator_1 = require("class-validator");
-const HttpException_1 = require("../exceptions/HttpException");
 const ValidationCache_1 = require("../utils/ValidationCache");
 function analyzeParamDecorator(decoratorMeta, token) {
     if (!decoratorMeta) {
@@ -53,37 +47,3 @@ function inferTypeFromSource(resolver) {
     }
     return null;
 }
-function createValidationResolver(extractFn, token, validationConfig) {
-    return (context) => {
-        const value = extractFn(context);
-        const obj = (0, class_transformer_1.plainToInstance)(token, value);
-        const errors = (0, class_validator_1.validateSync)(obj, validationConfig);
-        if (errors.length > 0) {
-            throw new HttpException_1.HttpException(errors, 400);
-        }
-        return obj;
-    };
-}
-function createParamResolver(decoratorMeta, token, validationConfig) {
-    if (!decoratorMeta) {
-        return null;
-    }
-    const extractFn = (context) => decoratorMeta.fun(context, decoratorMeta.param);
-    const needsValidation = typeof token === 'function' && (0, ValidationCache_1.isValidatable)(token);
-    if (needsValidation) {
-        return createValidationResolver(extractFn, token, validationConfig);
-    }
-    return extractFn;
-}
-function createParamResolvers(paramMetas, argTypes, validationConfig) {
-    const resolvers = [];
-    for (let i = 0; i < argTypes.length; i++) {
-        const meta = paramMetas?.[i];
-        const token = argTypes[i];
-        resolvers.push(createParamResolver(meta, token, validationConfig));
-    }
-    return resolvers;
-}
-function hasAnyDIParam(resolvers) {
-    return resolvers.some((r) => r === null);
-}

package/dist/route/RouteCompiler.d.ts

@@ -1,19 +1,19 @@
-import { type ValidatorOptions } from 'class-validator';
 import type { TokenRouteWithProvider } from '../container/ContainerConfiguration';
+import type { ValidatorAdapter } from '../validation/ValidatorAdapter';
 import type { Container } from '../container/container';
 import { ProviderScope } from '../domain/provider-scope';
 import { type CompiledRoute } from './CompiledRoute';
 export interface RouteCompilerOptions {
     container: Container;
     controllerScopes: Map<any, ProviderScope>;
-    validationConfig?: ValidatorOptions;
+    validatorAdapter: ValidatorAdapter;
     hasOnRequestHook: boolean;
     hasOnResponseHook: boolean;
 }
 export declare class RouteCompiler {
     private container;
     private controllerScopes;
-    private validationConfig?;
+    private validatorAdapter;
     private hasOnRequestHook;
     private hasOnResponseHook;
     constructor(options: RouteCompilerOptions);

package/dist/route/RouteCompiler.js

@@ -1,11 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouteCompiler = void 0;
-const class_transformer_1 = require("class-transformer");
-const class_validator_1 = require("class-validator");
 const provider_scope_1 = require("../domain/provider-scope");
 const Metadata_1 = require("../domain/Metadata");
-const HttpException_1 = require("../exceptions/HttpException");
 const getMethodArgTypes_1 = require("../utils/getMethodArgTypes");
 const CompiledRoute_1 = require("./CompiledRoute");
 const ParamResolverFactory_1 = require("./ParamResolverFactory");
@@ -14,7 +11,7 @@ class RouteCompiler {
     constructor(options) {
         this.container = options.container;
         this.controllerScopes = options.controllerScopes;
-        this.validationConfig = options.validationConfig;
+        this.validatorAdapter = options.validatorAdapter;
         this.hasOnRequestHook = options.hasOnRequestHook;
         this.hasOnResponseHook = options.hasOnResponseHook;
     }
@@ -158,7 +155,6 @@ class RouteCompiler {
     }
     createValidatedHandler(instance, methodName, paramInfos, hasBodyParam) {
         const handler = instance[methodName].bind(instance);
-        const config = this.validationConfig;
         const resolveArg = (ctx, param) => {
             let value;
             switch (param.type) {
@@ -184,12 +180,7 @@ class RouteCompiler {
                     value = undefined;
             }
             if (param.needsValidation && param.token) {
-                const obj = (0, class_transformer_1.plainToInstance)(param.token, value);
-                const errors = (0, class_validator_1.validateSync)(obj, config);
-                if (errors.length > 0) {
-                    throw new HttpException_1.HttpException(errors, 400);
-                }
-                return obj;
+                return this.validatorAdapter.validateAndTransform(param.token, value);
             }
             return value;
         };

package/dist/route/memoirist.js

@@ -179,6 +179,10 @@ class Memoirist {
         }
         if (node.params?.store === oldStore) {
             node.params.store = newStore;
+            const paramName = node.params.names.get(oldStore);
+            if (paramName) {
+                node.params.names.set(newStore, paramName);
+            }
             this.updateHistoryStore(method, path, newStore);
             return true;
         }

package/dist/utils/ValidationCache.d.ts

@@ -1,3 +1,5 @@
+import type { ValidatorAdapter } from '../validation/ValidatorAdapter';
+export declare function setValidatorAdapter(adapter: ValidatorAdapter): void;
 export declare function isValidatable(token: Function): boolean;
 export declare function preloadValidationForParams(args: any[]): number[];
 export declare function clearValidationCache(): void;

package/dist/utils/ValidationCache.js

@@ -1,14 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.setValidatorAdapter = setValidatorAdapter;
 exports.isValidatable = isValidatable;
 exports.preloadValidationForParams = preloadValidationForParams;
 exports.clearValidationCache = clearValidationCache;
-const isClassValidator_1 = require("./isClassValidator");
+let currentAdapter = null;
 const cache = new Map();
+function setValidatorAdapter(adapter) {
+    currentAdapter = adapter;
+    cache.clear();
+}
 function isValidatable(token) {
+    if (!currentAdapter) {
+        throw new Error('Validator adapter not initialized. Call setValidatorAdapter() first.');
+    }
     let result = cache.get(token);
     if (result === undefined) {
-        result = (0, isClassValidator_1.isClassValidator)(token);
+        result = currentAdapter.hasValidation(token);
         cache.set(token, result);
     }
     return result;

package/dist/utils/formatValidationErrors.d.ts

@@ -0,0 +1,5 @@
+export type ValidationIssue = {
+    field: string;
+    messages: string[];
+};
+export declare function formatValidationErrors(value: unknown): unknown;

package/dist/utils/formatValidationErrors.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatValidationErrors = formatValidationErrors;
+function formatValidationErrors(value) {
+    if (!shouldFormatErrors(value)) {
+        return value;
+    }
+    return collectIssues(value);
+}
+function shouldFormatErrors(value) {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    if (value.length === 0) {
+        return false;
+    }
+    return isValidationError(value[0]);
+}
+function isValidationError(value) {
+    if (!value) {
+        return false;
+    }
+    if (typeof value !== "object") {
+        return false;
+    }
+    return hasValidationShape(value);
+}
+function hasValidationShape(value) {
+    if ("constraints" in value) {
+        return true;
+    }
+    if ("property" in value) {
+        return true;
+    }
+    if ("children" in value) {
+        return true;
+    }
+    return false;
+}
+function collectIssues(errors) {
+    const issues = [];
+    for (const error of errors) {
+        appendIssues(error, "", issues);
+    }
+    return issues;
+}
+function appendIssues(error, prefix, issues) {
+    const field = buildField(prefix, error.property);
+    appendConstraints(error, field, issues);
+    appendChildren(error, field, issues);
+}
+function appendConstraints(error, field, issues) {
+    const constraints = error.constraints;
+    if (!constraints) {
+        return;
+    }
+    const messages = Object.values(constraints);
+    if (messages.length === 0) {
+        return;
+    }
+    issues.push({ field, messages });
+}
+function appendChildren(error, prefix, issues) {
+    const children = error.children;
+    if (!children || children.length === 0) {
+        return;
+    }
+    for (const child of children) {
+        appendIssues(child, prefix, issues);
+    }
+}
+function buildField(prefix, property) {
+    if (!property) {
+        return prefix || "body";
+    }
+    if (!prefix) {
+        return property;
+    }
+    return `${prefix}.${property}`;
+}

package/dist/utils/index.d.ts

@@ -4,7 +4,6 @@ export * from './isString';
 export * from './isFunction';
 export * from './getConstructorArgNames';
 export * from './getValue';
-export * from './isClassValidator';
 export * from './getMethodArgTypes';
 export * from './getClassOrSymbol';
 export * from './isRequestScope';
@@ -13,3 +12,4 @@ export * from './isPrimitiveType';
 export * from './setValue';
 export * from './isClass';
 export * from './methodsOf';
+export * from './formatValidationErrors';

package/dist/utils/index.js

@@ -20,7 +20,6 @@ __exportStar(require("./isString"), exports);
 __exportStar(require("./isFunction"), exports);
 __exportStar(require("./getConstructorArgNames"), exports);
 __exportStar(require("./getValue"), exports);
-__exportStar(require("./isClassValidator"), exports);
 __exportStar(require("./getMethodArgTypes"), exports);
 __exportStar(require("./getClassOrSymbol"), exports);
 __exportStar(require("./isRequestScope"), exports);
@@ -29,3 +28,4 @@ __exportStar(require("./isPrimitiveType"), exports);
 __exportStar(require("./setValue"), exports);
 __exportStar(require("./isClass"), exports);
 __exportStar(require("./methodsOf"), exports);
+__exportStar(require("./formatValidationErrors"), exports);