@carno.js/core 0.2.5 → 0.2.7

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/InjectorService.js

@@ -49,10 +49,10 @@ let InjectorService = InjectorService_1 = class InjectorService {
         this.saveInjector();
         this.routeResolver.resolveControllers();
         this.cacheControllerScopes();
-        this.preInstantiateSingletonControllers();
         this.cacheHooks();
-        this.compileRoutes();
         await this.callHook(on_event_1.EventType.OnApplicationInit);
+        this.preInstantiateSingletonControllers();
+        this.compileRoutes();
     }
     initializeResolvers() {
         this.routeResolver = new RouteResolver_1.RouteResolver(this.router, this.applicationConfig.globalMiddlewares);

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carno.js/core",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "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": "2be3063988696f2cd3eb13363e1f679b9f58c2f1"
+  "gitHead": "4abd763d3be38f53df2073a55bbc03e5deb3eeb6"
 }