@carno.js/core 0.2.6 → 0.2.8

package/dist/commons/decorators/http.decorators.js

@@ -4,6 +4,11 @@ exports.Patch = exports.Delete = exports.Put = exports.Post = exports.Get = expo
 exports.createParamDecorator = createParamDecorator;
 const Metadata_1 = require("../../domain/Metadata");
 const constants_1 = require("../../constants");
+const PARAM_TYPE_KEY = "__carnoParamType";
+const markParamType = (func, paramType) => {
+    func[PARAM_TYPE_KEY] = paramType;
+    return func;
+};
 const createMethodDecorator = (methodType) => {
     return (path = "") => {
         return (target, propertyKey) => {
@@ -27,16 +32,30 @@ const createMethodDecorator = (methodType) => {
 function createParamDecorator(func) {
     return (data) => (target, propertyKey, parameterIndex) => {
         const existingArgs = Metadata_1.Metadata.get(constants_1.ROUTE_PARAM, target.constructor, propertyKey) || {};
-        existingArgs[parameterIndex] = { fun: func, param: data };
+        existingArgs[parameterIndex] = {
+            fun: func,
+            param: data,
+            type: func[PARAM_TYPE_KEY],
+        };
         Metadata_1.Metadata.set(constants_1.ROUTE_PARAM, existingArgs, target.constructor, propertyKey);
     };
 }
-exports.Body = createParamDecorator((context, data) => data ? context.body[data] : context.body || {});
-exports.Query = createParamDecorator((context, data) => data ? context.query[data] : context.query || {});
-exports.Param = createParamDecorator((context, data) => data ? context.param[data] : null);
-exports.Req = createParamDecorator((context) => context.req);
-exports.Headers = createParamDecorator((context, data) => data ? (context.headers.has(data) ? context.headers.get(data) : undefined) : context.headers || {});
-exports.Locals = createParamDecorator((context) => context.locals || {});
+const bodyResolver = markParamType((context, data) => data ? context.body[data] : context.body || {}, "body");
+const queryResolver = markParamType((context, data) => data ? context.query[data] : context.query || {}, "query");
+const paramResolver = markParamType((context, data) => data ? context.param[data] : null, "param");
+const reqResolver = markParamType((context) => context.req, "req");
+const headersResolver = markParamType((context, data) => data
+    ? context.headers.has(data)
+        ? context.headers.get(data)
+        : undefined
+    : context.headers || {}, "headers");
+const localsResolver = markParamType((context) => context.locals || {}, "locals");
+exports.Body = createParamDecorator(bodyResolver);
+exports.Query = createParamDecorator(queryResolver);
+exports.Param = createParamDecorator(paramResolver);
+exports.Req = createParamDecorator(reqResolver);
+exports.Headers = createParamDecorator(headersResolver);
+exports.Locals = createParamDecorator(localsResolver);
 exports.Get = createMethodDecorator("GET");
 exports.Post = createMethodDecorator("POST");
 exports.Put = createMethodDecorator("PUT");

package/dist/container/MethodInvoker.d.ts

@@ -12,6 +12,9 @@ export declare class MethodInvoker {
     private cacheMethodInfo;
     private setCachedMethod;
     private resolveMethodServices;
+    private ensureBodyParsed;
+    private hasBodyParam;
+    private isBodyParam;
     private resolveService;
     private validateAndTransform;
 }

package/dist/container/MethodInvoker.js

@@ -15,6 +15,7 @@ class MethodInvoker {
     }
     async invoke(instance, methodName, locals, context, invokeCallback) {
         const methodInfo = this.getMethodInfo(instance, methodName);
+        await this.ensureBodyParsed(methodInfo, context);
         const services = this.resolveMethodServices(methodInfo, context, locals, invokeCallback);
         return instance[methodName](...services);
     }
@@ -29,7 +30,8 @@ class MethodInvoker {
     cacheMethodInfo(instance, methodName) {
         const args = (0, getMethodArgTypes_1.getMethodArgTypes)(instance, methodName);
         const params = Metadata_1.Metadata.getParamDecoratorFunc(instance, methodName);
-        const methodInfo = { args, params };
+        const needsBody = this.hasBodyParam(params);
+        const methodInfo = { args, params, needsBody };
         this.setCachedMethod(instance, methodName, methodInfo);
         return methodInfo;
     }
@@ -47,6 +49,30 @@ class MethodInvoker {
         }
         return services;
     }
+    async ensureBodyParsed(methodInfo, context) {
+        if (!methodInfo.needsBody) {
+            return;
+        }
+        if (context.isBodyParsed()) {
+            return;
+        }
+        await context.getBody();
+    }
+    hasBodyParam(params) {
+        if (!params) {
+            return false;
+        }
+        return Object.values(params).some((param) => this.isBodyParam(param));
+    }
+    isBodyParam(param) {
+        if (param?.type === "body") {
+            return true;
+        }
+        if (!param?.fun) {
+            return false;
+        }
+        return String(param.fun).includes("context.body");
+    }
     resolveService(token, param, context, locals, invokeCallback) {
         if (!param) {
             return invokeCallback((0, getClassOrSymbol_1.getClassOrSymbol)(token), locals);
@@ -59,7 +85,8 @@ class MethodInvoker {
     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 não o objeto class-validator inteiro.
+        // 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);
         }

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/route/ParamResolverFactory.d.ts

@@ -1,12 +1,14 @@
 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;
     param?: any;
+    type?: ParamDecoratorType;
 }
 export interface ParamInfo {
-    type: 'body' | 'query' | 'param' | 'headers' | 'req' | 'locals' | 'di';
+    type: ParamDecoratorType | 'di';
     key?: string;
     needsValidation: boolean;
     token?: any;

package/dist/route/ParamResolverFactory.js

@@ -12,28 +12,46 @@ function analyzeParamDecorator(decoratorMeta, token) {
     if (!decoratorMeta) {
         return { type: 'di', needsValidation: false, token };
     }
-    const funcStr = decoratorMeta.fun.toString();
+    const paramType = resolveParamType(decoratorMeta);
     const key = decoratorMeta.param;
     const needsValidation = typeof token === 'function' && (0, ValidationCache_1.isValidatable)(token);
+    if (paramType) {
+        return {
+            type: paramType,
+            key,
+            needsValidation,
+            token,
+        };
+    }
+    return { type: 'di', needsValidation: false, token };
+}
+function resolveParamType(decoratorMeta) {
+    if (decoratorMeta.type) {
+        return decoratorMeta.type;
+    }
+    return inferTypeFromSource(decoratorMeta.fun);
+}
+function inferTypeFromSource(resolver) {
+    const funcStr = resolver.toString();
     if (funcStr.includes('context.body')) {
-        return { type: 'body', key, needsValidation, token };
+        return 'body';
     }
     if (funcStr.includes('context.query')) {
-        return { type: 'query', key, needsValidation, token };
+        return 'query';
     }
     if (funcStr.includes('context.param')) {
-        return { type: 'param', key, needsValidation, token };
+        return 'param';
     }
     if (funcStr.includes('context.headers')) {
-        return { type: 'headers', key, needsValidation, token };
+        return 'headers';
     }
     if (funcStr.includes('context.req')) {
-        return { type: 'req', needsValidation: false, token };
+        return 'req';
     }
     if (funcStr.includes('context.locals')) {
-        return { type: 'locals', needsValidation: false, token };
+        return 'locals';
     }
-    return { type: 'di', needsValidation: false, token };
+    return null;
 }
 function createValidationResolver(extractFn, token, validationConfig) {
     return (context) => {

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/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

@@ -13,3 +13,4 @@ export * from './isPrimitiveType';
 export * from './setValue';
 export * from './isClass';
 export * from './methodsOf';
+export * from './formatValidationErrors';

package/dist/utils/index.js

@@ -29,3 +29,4 @@ __exportStar(require("./isPrimitiveType"), exports);
 __exportStar(require("./setValue"), exports);
 __exportStar(require("./isClass"), exports);
 __exportStar(require("./methodsOf"), exports);
+__exportStar(require("./formatValidationErrors"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carno.js/core",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "description": "Carno.js is a framework for building web applications object oriented with TypeScript and Bun.sh",
   "keywords": [
     "bun",
@@ -51,5 +51,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "64eb08eb95a337f93062486b545e27ab9b30a643"
+  "gitHead": "2793d412b70bb432d2c825bae58522ccac87baff"
 }