@carno.js/core 0.2.9 → 0.2.11

package/dist/route/JITCompiler.js

@@ -2,137 +2,244 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compileRouteHandler = compileRouteHandler;
 exports.compileValidatedHandler = compileValidatedHandler;
+const TEXT_HEADERS = Object.freeze({
+    'Content-Type': 'text/html'
+});
+const JSON_HEADERS = Object.freeze({
+    'Content-Type': 'application/json'
+});
+function isBodyInitResult(result) {
+    if (!result) {
+        return false;
+    }
+    if (result instanceof ReadableStream) {
+        return true;
+    }
+    if (result instanceof Blob || result instanceof ArrayBuffer) {
+        return true;
+    }
+    if (ArrayBuffer.isView(result)) {
+        return true;
+    }
+    return result instanceof FormData || result instanceof URLSearchParams;
+}
+/**
+ * Cria handler inline com response building integrado.
+ * Usado quando não há parâmetros.
+ */
+function createInlineResponseHandler(handler, isAsync) {
+    if (isAsync) {
+        return async (c) => {
+            const r = await handler();
+            const s = c.getResponseStatus() || 200;
+            if (typeof r === 'string')
+                return new Response(r, { status: s, headers: TEXT_HEADERS });
+            if (r instanceof Response)
+                return r;
+            if (r == null)
+                return new Response('', { status: s, headers: TEXT_HEADERS });
+            if (typeof r === 'number' || typeof r === 'boolean') {
+                return new Response(String(r), { status: s, headers: TEXT_HEADERS });
+            }
+            if (isBodyInitResult(r)) {
+                return new Response(r, { status: s });
+            }
+            return new Response(JSON.stringify(r), { status: s, headers: JSON_HEADERS });
+        };
+    }
+    return (c) => {
+        const r = handler();
+        const s = c.getResponseStatus() || 200;
+        if (typeof r === 'string')
+            return new Response(r, { status: s, headers: TEXT_HEADERS });
+        if (r instanceof Response)
+            return r;
+        if (r == null)
+            return new Response('', { status: s, headers: TEXT_HEADERS });
+        if (typeof r === 'number' || typeof r === 'boolean') {
+            return new Response(String(r), { status: s, headers: TEXT_HEADERS });
+        }
+        if (isBodyInitResult(r)) {
+            return new Response(r, { status: s });
+        }
+        return new Response(JSON.stringify(r), { status: s, headers: JSON_HEADERS });
+    };
+}
 function escapeKey(key) {
-    return key.replace(/['"\\]/g, '\\$&');
+    return key.replace(/['\"\\]/g, '\\$&');
 }
-function buildArgExpression(param, index) {
+/**
+ * Gera expressão de acesso a parâmetro inline.
+ * Otimizado para evitar chamadas de função quando possível.
+ */
+function buildArgExpression(param) {
     const key = param.key ? escapeKey(param.key) : undefined;
     switch (param.type) {
         case 'param':
-            return key ? `ctx.param['${key}']` : 'ctx.param';
+            return key ? `c.param['${key}']` : 'c.param';
         case 'query':
-            return key ? `ctx.query['${key}']` : 'ctx.query';
+            return key ? `c.query['${key}']` : 'c.query';
         case 'body':
-            return key ? `ctx.body['${key}']` : 'ctx.body';
+            return key ? `c.body['${key}']` : 'c.body';
         case 'headers':
-            return key
-                ? `ctx.headers.get('${key}')`
-                : 'ctx.headers';
+            return key ? `c.headers.get('${key}')` : 'c.headers';
         case 'req':
-            return 'ctx.req';
+            return 'c.req';
         case 'locals':
-            return 'ctx.locals';
-        case 'di':
-            return `resolvers[${index}](ctx)`;
+            return 'c.locals';
         default:
-            return `resolvers[${index}](ctx)`;
+            return 'undefined';
     }
 }
+/**
+ * Compila route handler em função otimizada.
+ *
+ * Estratégias de otimização:
+ * - Inline de acesso a parâmetros
+ * - Bind do handler no compile time
+ * - Código gerado monomórfico
+ * - Sem overhead de resolvers array
+ */
+/**
+ * Compila route handler em função otimizada que retorna Response inline.
+ *
+ * Estratégias de otimização:
+ * - Inline de acesso a parâmetros
+ * - Inline de response building (elimina executeFastPath)
+ * - Bind do handler no compile time
+ * - Código gerado monomórfico
+ * - Headers pré-frozen para otimização V8
+ */
 function compileRouteHandler(instance, methodName, paramInfos) {
     const handler = instance[methodName].bind(instance);
     if (paramInfos.length === 0) {
-        return () => handler();
+        return createInlineResponseHandler(handler, false);
     }
-    const hasBodyParam = paramInfos.some((p) => p.type === 'body');
     const hasDIParam = paramInfos.some((p) => p.type === 'di');
     if (hasDIParam) {
         return createFallbackHandler(handler, paramInfos);
     }
+    const hasBodyParam = paramInfos.some((p) => p.type === 'body');
     const argExpressions = paramInfos.map(buildArgExpression);
+    const argsCode = argExpressions.join(',');
     if (hasBodyParam) {
-        return createAsyncHandler(handler, argExpressions);
+        const code = `return async function(c){
+await c.getBody();
+const r=await h(${argsCode});
+const s=c.getResponseStatus()||200;
+if(typeof r==='string')return new Response(r,{status:s,headers:TH});
+if(r instanceof Response)return r;
+if(r==null)return new Response('',{status:s,headers:TH});
+if(typeof r==='number'||typeof r==='boolean')return new Response(String(r),{status:s,headers:TH});
+if(isBI(r))return new Response(r,{status:s});
+return new Response(JSON.stringify(r),{status:s,headers:JH});
+}`;
+        return new Function('h', 'TH', 'JH', 'isBI', code)(handler, TEXT_HEADERS, JSON_HEADERS, isBodyInitResult);
     }
-    return createSyncHandler(handler, argExpressions);
-}
-function createSyncHandler(handler, argExpressions) {
-    const code = `
-    return function compiledHandler(ctx) {
-      return handler(${argExpressions.join(', ')});
-    }
-  `;
-    return new Function('handler', code)(handler);
-}
-function createAsyncHandler(handler, argExpressions) {
-    const code = `
-    return async function compiledHandler(ctx) {
-      await ctx.getBody();
-      return handler(${argExpressions.join(', ')});
-    }
-  `;
-    return new Function('handler', code)(handler);
+    const code = `return function(c){
+const r=h(${argsCode});
+const s=c.getResponseStatus()||200;
+if(typeof r==='string')return new Response(r,{status:s,headers:TH});
+if(r instanceof Response)return r;
+if(r==null)return new Response('',{status:s,headers:TH});
+if(typeof r==='number'||typeof r==='boolean')return new Response(String(r),{status:s,headers:TH});
+if(isBI(r))return new Response(r,{status:s});
+return new Response(JSON.stringify(r),{status:s,headers:JH});
+}`;
+    return new Function('h', 'TH', 'JH', 'isBI', code)(handler, TEXT_HEADERS, JSON_HEADERS, isBodyInitResult);
 }
+/**
+ * Handler fallback para casos com DI.
+ */
 function createFallbackHandler(handler, paramInfos) {
     return (ctx) => {
-        const args = [];
-        for (const param of paramInfos) {
-            switch (param.type) {
-                case 'param':
-                    args.push(param.key ? ctx.param[param.key] : ctx.param);
-                    break;
-                case 'query':
-                    args.push(param.key ? ctx.query[param.key] : ctx.query);
-                    break;
-                case 'body':
-                    args.push(param.key ? ctx.body[param.key] : ctx.body);
-                    break;
-                case 'headers':
-                    args.push(param.key ? ctx.headers.get(param.key) : ctx.headers);
-                    break;
-                case 'req':
-                    args.push(ctx.req);
-                    break;
-                case 'locals':
-                    args.push(ctx.locals);
-                    break;
-                default:
-                    args.push(undefined);
-                    break;
-            }
-        }
+        const args = resolveArgs(paramInfos, ctx);
         return handler(...args);
     };
 }
-function compileValidatedHandler(instance, methodName, paramInfos, validators) {
+/**
+ * Resolve argumentos para fallback handler.
+ */
+function resolveArgs(paramInfos, ctx) {
+    const args = new Array(paramInfos.length);
+    let i = 0;
+    for (const param of paramInfos) {
+        args[i++] = resolveArg(param, ctx);
+    }
+    return args;
+}
+/**
+ * Resolve um argumento individual.
+ */
+function resolveArg(param, ctx) {
+    switch (param.type) {
+        case 'param':
+            return param.key ? ctx.param[param.key] : ctx.param;
+        case 'query':
+            return param.key ? ctx.query[param.key] : ctx.query;
+        case 'body':
+            return param.key ? ctx.body[param.key] : ctx.body;
+        case 'headers':
+            return param.key ? ctx.headers.get(param.key) : ctx.headers;
+        case 'req':
+            return ctx.req;
+        case 'locals':
+            return ctx.locals;
+        default:
+            return undefined;
+    }
+}
+/**
+ * Compila handler com validação inline.
+ */
+function compileValidatedHandler(instance, methodName, paramInfos, validatorAdapter) {
     const handler = instance[methodName].bind(instance);
     const hasBodyParam = paramInfos.some((p) => p.type === 'body');
-    const resolveArg = (ctx, param, index) => {
-        let value;
-        switch (param.type) {
-            case 'param':
-                value = param.key ? ctx.param[param.key] : ctx.param;
-                break;
-            case 'query':
-                value = param.key ? ctx.query[param.key] : ctx.query;
-                break;
-            case 'body':
-                value = param.key ? ctx.body[param.key] : ctx.body;
-                break;
-            case 'headers':
-                value = param.key ? ctx.headers.get(param.key) : ctx.headers;
-                break;
-            case 'req':
-                value = ctx.req;
-                break;
-            case 'locals':
-                value = ctx.locals;
-                break;
-            default:
-                value = undefined;
-        }
-        if (param.needsValidation && validators[index]) {
-            return validators[index](value);
-        }
-        return value;
-    };
+    if (paramInfos.length === 0) {
+        return createInlineResponseHandler(handler, false);
+    }
+    const { argAssignments, argList, tokenParams, tokenValues, } = buildValidatedArgs(paramInfos);
     if (hasBodyParam) {
-        return async (ctx) => {
-            await ctx.getBody();
-            const args = paramInfos.map((p, i) => resolveArg(ctx, p, i));
-            return handler(...args);
-        };
+        const code = `return async function(c){\nawait c.getBody();\n${argAssignments}\nconst r=await h(${argList});\nconst s=c.getResponseStatus()||200;\nif(typeof r==='string')return new Response(r,{status:s,headers:TH});\nif(r instanceof Response)return r;\nif(r==null)return new Response('',{status:s,headers:TH});\nif(typeof r==='number'||typeof r==='boolean')return new Response(String(r),{status:s,headers:TH});\nif(isBI(r))return new Response(r,{status:s});\nreturn new Response(JSON.stringify(r),{status:s,headers:JH});\n}`;
+        return new Function('h', 'va', ...tokenParams, 'TH', 'JH', 'isBI', code)(handler, validatorAdapter, ...tokenValues, TEXT_HEADERS, JSON_HEADERS, isBodyInitResult);
     }
-    return (ctx) => {
-        const args = paramInfos.map((p, i) => resolveArg(ctx, p, i));
-        return handler(...args);
+    const code = `return function(c){\n${argAssignments}\nconst r=h(${argList});\nconst s=c.getResponseStatus()||200;\nif(typeof r==='string')return new Response(r,{status:s,headers:TH});\nif(r instanceof Response)return r;\nif(r==null)return new Response('',{status:s,headers:TH});\nif(typeof r==='number'||typeof r==='boolean')return new Response(String(r),{status:s,headers:TH});\nif(isBI(r))return new Response(r,{status:s});\nreturn new Response(JSON.stringify(r),{status:s,headers:JH});\n}`;
+    return new Function('h', 'va', ...tokenParams, 'TH', 'JH', 'isBI', code)(handler, validatorAdapter, ...tokenValues, TEXT_HEADERS, JSON_HEADERS, isBodyInitResult);
+}
+function buildValidatedArgs(paramInfos) {
+    const assignments = [];
+    const args = [];
+    const tokenParams = [];
+    const tokenValues = [];
+    let index = 0;
+    for (const param of paramInfos) {
+        const argName = `a${index}`;
+        const argExpr = buildArgExpression(param);
+        const tokenName = getTokenParamName(param, index, tokenParams, tokenValues);
+        const valueExpr = buildValidatedExpression(argExpr, tokenName);
+        assignments.push(`const ${argName}=${valueExpr};`);
+        args.push(argName);
+        index += 1;
+    }
+    return {
+        argAssignments: assignments.join('\n'),
+        argList: args.join(','),
+        tokenParams,
+        tokenValues,
     };
 }
+function buildValidatedExpression(argExpr, tokenName) {
+    if (!tokenName) {
+        return argExpr;
+    }
+    return `va.validateAndTransform(${tokenName}, ${argExpr})`;
+}
+function getTokenParamName(param, index, tokenParams, tokenValues) {
+    if (!param.needsValidation || !param.token) {
+        return null;
+    }
+    const tokenName = `t${index}`;
+    tokenParams.push(tokenName);
+    tokenValues.push(param.token);
+    return tokenName;
+}

package/dist/route/Matcher.d.ts

@@ -1,16 +1,11 @@
 import { TokenRouteWithProvider, TokenRouteWithProviderMap } from "../container";
 import { Context } from "../domain";
+interface ParsedUrl {
+    pathname: string;
+}
 declare class Matcher {
     match(request: Request, routes: TokenRouteWithProviderMap, context: Context): TokenRouteWithProvider;
-    /**
-     * Identify route by url path.
-     * The route can have params (:param) and wildcards (*).
-     *
-     * @param route
-     * @param url
-     * @param context
-     */
-    identifyRoute(route: TokenRouteWithProvider, url: URL, context: Context): boolean;
+    identifyRoute(route: TokenRouteWithProvider, url: ParsedUrl, context: Context): boolean;
 }
 export declare const RouteResolver: Matcher;
 export {};

package/dist/route/Matcher.js

@@ -1,7 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouteResolver = void 0;
-const parseUrl = require('parseurl-fast');
+function parseUrl(request) {
+    const url = request.url;
+    const startIndex = url.indexOf('/', 12);
+    const queryIndex = url.indexOf('?', startIndex);
+    if (queryIndex === -1) {
+        return { pathname: startIndex === -1 ? '/' : url.slice(startIndex) };
+    }
+    return { pathname: url.slice(startIndex, queryIndex) };
+}
 class Matcher {
     match(request, routes, context) {
         const method = request.method.toLowerCase();
@@ -10,20 +18,12 @@ class Matcher {
         }
         const routeMethod = routes.get(method);
         const url = parseUrl(request);
-        const route = routeMethod?.find(route => this.identifyRoute(route, url, context));
+        const route = routeMethod?.find((route) => this.identifyRoute(route, url, context));
         if (!route) {
             throw new Error('Method not allowed');
         }
         return route;
     }
-    /**
-     * Identify route by url path.
-     * The route can have params (:param) and wildcards (*).
-     *
-     * @param route
-     * @param url
-     * @param context
-     */
     identifyRoute(route, url, context) {
         const urlPath = url.pathname.split('/');
         const routePathSegments = route.path.split('/');

package/dist/route/RouteCompiler.d.ts

@@ -25,5 +25,4 @@ export declare class RouteCompiler {
     private createStandardRoute;
     private createComplexRoute;
     private createFallbackRoute;
-    private createValidatedHandler;
 }

package/dist/route/RouteCompiler.js

@@ -67,7 +67,7 @@ class RouteCompiler {
         const hasBodyParam = paramInfos.some((p) => p.type === 'body');
         let boundHandler;
         if (hasValidation) {
-            boundHandler = this.createValidatedHandler(instance, route.methodName, paramInfos, hasBodyParam);
+            boundHandler = (0, JITCompiler_1.compileValidatedHandler)(instance, route.methodName, paramInfos, this.validatorAdapter);
         }
         else {
             boundHandler = (0, JITCompiler_1.compileRouteHandler)(instance, route.methodName, paramInfos);
@@ -153,48 +153,5 @@ class RouteCompiler {
             original: route,
         };
     }
-    createValidatedHandler(instance, methodName, paramInfos, hasBodyParam) {
-        const handler = instance[methodName].bind(instance);
-        const resolveArg = (ctx, param) => {
-            let value;
-            switch (param.type) {
-                case 'param':
-                    value = param.key ? ctx.param[param.key] : ctx.param;
-                    break;
-                case 'query':
-                    value = param.key ? ctx.query[param.key] : ctx.query;
-                    break;
-                case 'body':
-                    value = param.key ? ctx.body[param.key] : ctx.body;
-                    break;
-                case 'headers':
-                    value = param.key ? ctx.headers.get(param.key) : ctx.headers;
-                    break;
-                case 'req':
-                    value = ctx.req;
-                    break;
-                case 'locals':
-                    value = ctx.locals;
-                    break;
-                default:
-                    value = undefined;
-            }
-            if (param.needsValidation && param.token) {
-                return this.validatorAdapter.validateAndTransform(param.token, value);
-            }
-            return value;
-        };
-        if (hasBodyParam) {
-            return async (ctx) => {
-                await ctx.getBody();
-                const args = paramInfos.map((p) => resolveArg(ctx, p));
-                return handler(...args);
-            };
-        }
-        return (ctx) => {
-            const args = paramInfos.map((p) => resolveArg(ctx, p));
-            return handler(...args);
-        };
-    }
 }
 exports.RouteCompiler = RouteCompiler;

package/dist/route/RouteExecutor.d.ts

@@ -2,13 +2,11 @@ import { InjectorService, TokenRouteWithProvider } from "../container";
 import { Context, LocalsContainer } from "../domain";
 import type { CompiledRoute } from "./CompiledRoute";
 declare class Router {
-    private readonly jsonHeaders;
     private readonly textHeaders;
     executeRoute(routeStore: CompiledRoute | TokenRouteWithProvider, injector: InjectorService, context: Context, locals: LocalsContainer): Promise<Response>;
     mountResponse(result: unknown, context: Context): Response;
     private isNativeResponse;
     private isBodyInit;
-    private createJsonResponse;
 }
 export declare const RouteExecutor: Router;
 export {};

package/dist/route/RouteExecutor.js

@@ -4,7 +4,6 @@ exports.RouteExecutor = void 0;
 const events_1 = require("../events");
 class Router {
     constructor() {
-        this.jsonHeaders = { "Content-Type": "application/json" };
         this.textHeaders = { "Content-Type": "text/html" };
     }
     async executeRoute(routeStore, injector, context, locals) {
@@ -24,7 +23,24 @@ class Router {
         if (injector.hasOnResponseHook()) {
             await injector.callHook(events_1.EventType.OnResponse, { context, result });
         }
-        return this.mountResponse(result, context);
+        const status = context.getResponseStatus() || 200;
+        if (result instanceof Response) {
+            return result;
+        }
+        if (result === null || result === undefined) {
+            return new Response("", { status, headers: this.textHeaders });
+        }
+        const resultType = typeof result;
+        if (resultType === "string") {
+            return new Response(result, { status, headers: this.textHeaders });
+        }
+        if (resultType === "number" || resultType === "boolean") {
+            return new Response(String(result), { status, headers: this.textHeaders });
+        }
+        if (this.isBodyInit(result)) {
+            return new Response(result, { status });
+        }
+        return Response.json(result, { status });
     }
     mountResponse(result, context) {
         const status = context.getResponseStatus() || 200;
@@ -44,7 +60,7 @@ class Router {
         if (this.isBodyInit(result)) {
             return new Response(result, { status });
         }
-        return this.createJsonResponse(result, status);
+        return Response.json(result, { status });
     }
     isNativeResponse(result) {
         return result instanceof Response;
@@ -64,15 +80,5 @@ class Router {
         }
         return result instanceof FormData || result instanceof URLSearchParams;
     }
-    createJsonResponse(body, status) {
-        try {
-            const json = JSON.stringify(body);
-            return new Response(json, { status, headers: this.jsonHeaders });
-        }
-        catch (error) {
-            const fallback = JSON.stringify({ error: "Serialization failed" });
-            return new Response(fallback, { status: 500, headers: this.jsonHeaders });
-        }
-    }
 }
 exports.RouteExecutor = new Router();

package/dist/route/memoirist.d.ts

@@ -18,10 +18,12 @@ export interface Node<T> {
 export declare class Memoirist<T> {
     root: Record<string, Node<T>>;
     history: [string, string, T][];
+    private routeCache;
     private static regex;
     add(method: string, path: string, store: T): FindResult<T>['store'];
     find(method: string, url: string): FindResult<T> | null;
     updateStore(method: string, path: string, oldStore: T, newStore: T): boolean;
+    private invalidateCache;
     private updateHistoryStore;
     private normalizePath;
     private findNode;

package/dist/route/memoirist.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Memoirist = void 0;
+/**
+ * * Empty object shared for static routes without parameters.
+ * * Frozen for V8 optimization and immutability.
+ * * Avoid allocating an empty object on every request in static routes.
+ * */
+const EMPTY_PARAMS = Object.freeze({});
 const createNode = (part, inert) => ({
     part,
     store: null,
@@ -54,6 +60,7 @@ class Memoirist {
     constructor() {
         this.root = {};
         this.history = [];
+        this.routeCache = new Map();
     }
     add(method, path, store) {
         if (typeof path !== 'string')
@@ -62,6 +69,7 @@ class Memoirist {
             path = '/';
         else if (path[0] !== '/')
             path = `/${path}`;
+        this.invalidateCache();
         this.history.push([method, path, store]);
         const isWildcard = path[path.length - 1] === '*';
         if (isWildcard) {
@@ -162,10 +170,20 @@ class Memoirist {
         return node.store;
     }
     find(method, url) {
+        let methodCache = this.routeCache.get(url);
+        if (methodCache && methodCache[method] !== undefined) {
+            return methodCache[method];
+        }
         const root = this.root[method];
         if (!root)
             return null;
-        return matchRoute(url, url.length, root, 0);
+        const result = matchRoute(url, url.length, root, 0);
+        if (!methodCache) {
+            methodCache = {};
+            this.routeCache.set(url, methodCache);
+        }
+        methodCache[method] = result;
+        return result;
     }
     updateStore(method, path, oldStore, newStore) {
         const node = this.findNode(method, path);
@@ -175,6 +193,7 @@ class Memoirist {
         if (node.store === oldStore) {
             node.store = newStore;
             this.updateHistoryStore(method, path, newStore);
+            this.invalidateCache();
             return true;
         }
         if (node.params?.store === oldStore) {
@@ -184,15 +203,20 @@ class Memoirist {
                 node.params.names.set(newStore, paramName);
             }
             this.updateHistoryStore(method, path, newStore);
+            this.invalidateCache();
             return true;
         }
         if (node.wildcardStore === oldStore) {
             node.wildcardStore = newStore;
             this.updateHistoryStore(method, path, newStore);
+            this.invalidateCache();
             return true;
         }
         return false;
     }
+    invalidateCache() {
+        this.routeCache.clear();
+    }
     updateHistoryStore(method, path, newStore) {
         const normalizedPath = this.normalizePath(path);
         for (let i = 0; i < this.history.length; i++) {
@@ -288,7 +312,7 @@ const matchRoute = (url, urlLength, node, startIndex) => {
         if (node.store !== null)
             return {
                 store: node.store,
-                params: {}
+                params: EMPTY_PARAMS
             };
         if (node.wildcardStore !== null)
             return {
@@ -325,7 +349,13 @@ const matchRoute = (url, urlLength, node, startIndex) => {
                 const route = matchRoute(url, urlLength, param.inert, slashIndex);
                 if (route !== null) {
                     const paramName = resolveParamName(param, route.store);
-                    route.params[paramName] = url.substring(endIndex, slashIndex);
+                    const paramValue = url.substring(endIndex, slashIndex);
+                    if (route.params === EMPTY_PARAMS) {
+                        route.params = { [paramName]: paramValue };
+                    }
+                    else {
+                        route.params[paramName] = paramValue;
+                    }
                     return route;
                 }
             }

package/dist/services/logger.service.js

@@ -9,13 +9,6 @@ class LoggerService {
     constructor(injector) {
         this.injector = injector;
         const pinoConfig = this.injector.applicationConfig.logger || {};
-        pinoConfig['transport'] = pinoConfig.transport || {
-            target: 'pino-pretty',
-            options: {
-                colorize: true,
-                ignore: 'pid,hostname',
-            },
-        };
         this.logger = (0, pino_1.default)(pinoConfig);
     }
     child(bindings) {