@carno.js/core 0.2.3

package/dist/route/memoirist.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memoirist = void 0;
+const createNode = (part, inert) => ({
+    part,
+    store: null,
+    inert: inert !== undefined
+        ? new Map(inert.map((child) => [child.part.charCodeAt(0), child]))
+        : null,
+    params: null,
+    wildcardStore: null
+});
+const cloneNode = (node, part) => ({
+    ...node,
+    part
+});
+const createParamNode = () => ({
+    paramName: null,
+    names: new Map(),
+    store: null,
+    inert: null
+});
+const ensureSameNameForStore = (param, store, name) => {
+    const existing = param.names.get(store);
+    if (!existing || existing === name)
+        return;
+    throw new Error(`Route already registered with parameter "${existing}" for this handler`);
+};
+const ensureDefaultName = (param, name) => {
+    if (param.paramName)
+        return;
+    param.paramName = name;
+};
+const persistStoreName = (param, store, name) => {
+    if (param.names.has(store))
+        return;
+    param.names.set(store, name);
+};
+const registerParamName = (param, store, name) => {
+    ensureSameNameForStore(param, store, name);
+    ensureDefaultName(param, name);
+    persistStoreName(param, store, name);
+};
+const resolveParamName = (param, store) => {
+    if (store && param.names.has(store)) {
+        return param.names.get(store);
+    }
+    if (param.paramName) {
+        return param.paramName;
+    }
+    throw new Error('Unable to resolve parameter name for route');
+};
+class Memoirist {
+    constructor() {
+        this.root = {};
+        this.history = [];
+    }
+    add(method, path, store) {
+        if (typeof path !== 'string')
+            throw new TypeError('Route path must be a string');
+        if (path === '')
+            path = '/';
+        else if (path[0] !== '/')
+            path = `/${path}`;
+        this.history.push([method, path, store]);
+        const isWildcard = path[path.length - 1] === '*';
+        if (isWildcard) {
+            // Slice off trailing '*'
+            path = path.slice(0, -1);
+        }
+        const inertParts = path.split(Memoirist.regex.static);
+        const paramParts = path.match(Memoirist.regex.params) || [];
+        if (inertParts[inertParts.length - 1] === '')
+            inertParts.pop();
+        let node;
+        if (!this.root[method])
+            node = this.root[method] = createNode('/');
+        else
+            node = this.root[method];
+        let paramPartsIndex = 0;
+        for (let i = 0; i < inertParts.length; ++i) {
+            let part = inertParts[i];
+            if (i > 0) {
+                // Set param on the node
+                const param = paramParts[paramPartsIndex++].slice(1);
+                if (node.params === null) {
+                    node.params = createParamNode();
+                }
+                registerParamName(node.params, store, param);
+                const params = node.params;
+                if (params.inert === null) {
+                    node = params.inert = createNode(part);
+                    continue;
+                }
+                node = params.inert;
+            }
+            for (let j = 0;;) {
+                if (j === part.length) {
+                    if (j < node.part.length) {
+                        // Move the current node down
+                        const childNode = cloneNode(node, node.part.slice(j));
+                        Object.assign(node, createNode(part, [childNode]));
+                    }
+                    break;
+                }
+                if (j === node.part.length) {
+                    // Add static child
+                    if (node.inert === null)
+                        node.inert = new Map();
+                    else if (node.inert.has(part.charCodeAt(j))) {
+                        // Re-run loop with existing static node
+                        node = node.inert.get(part.charCodeAt(j));
+                        part = part.slice(j);
+                        j = 0;
+                        continue;
+                    }
+                    // Create new node
+                    const childNode = createNode(part.slice(j));
+                    node.inert.set(part.charCodeAt(j), childNode);
+                    node = childNode;
+                    break;
+                }
+                if (part[j] !== node.part[j]) {
+                    // Split the node
+                    const existingChild = cloneNode(node, node.part.slice(j));
+                    const newChild = createNode(part.slice(j));
+                    Object.assign(node, createNode(node.part.slice(0, j), [
+                        existingChild,
+                        newChild
+                    ]));
+                    node = newChild;
+                    break;
+                }
+                ++j;
+            }
+        }
+        if (paramPartsIndex < paramParts.length) {
+            // The final part is a parameter
+            const param = paramParts[paramPartsIndex];
+            const paramName = param.slice(1);
+            if (node.params === null) {
+                node.params = createParamNode();
+            }
+            registerParamName(node.params, store, paramName);
+            if (node.params.store === null) {
+                node.params.store = store;
+            }
+            else if (node.params.store !== store) {
+                throw new Error(`Route "${path}" already registered`);
+            }
+            return node.params.store;
+        }
+        if (isWildcard) {
+            // The final part is a wildcard
+            if (node.wildcardStore === null)
+                node.wildcardStore = store;
+            return node.wildcardStore;
+        }
+        // The final part is static
+        if (node.store === null)
+            node.store = store;
+        return node.store;
+    }
+    find(method, url) {
+        const root = this.root[method];
+        if (!root)
+            return null;
+        return matchRoute(url, url.length, root, 0);
+    }
+}
+exports.Memoirist = Memoirist;
+Memoirist.regex = {
+    static: /:.+?(?=\/|$)/,
+    params: /:.+?(?=\/|$)/g
+};
+const matchRoute = (url, urlLength, node, startIndex) => {
+    const part = node?.part;
+    const endIndex = startIndex + part.length;
+    // Only check the pathPart if its length is > 1 since the parent has
+    // already checked that the url matches the first character
+    if (part.length > 1) {
+        if (endIndex > urlLength)
+            return null;
+        if (part.length < 15) {
+            // Using a loop is faster for short strings
+            for (let i = 1, j = startIndex + 1; i < part.length; ++i, ++j)
+                if (part.charCodeAt(i) !== url.charCodeAt(j))
+                    return null;
+        }
+        else if (url.substring(startIndex, endIndex) !== part)
+            return null;
+    }
+    if (endIndex === urlLength) {
+        // Reached the end of the URL
+        if (node.store !== null)
+            return {
+                store: node.store,
+                params: {}
+            };
+        if (node.wildcardStore !== null)
+            return {
+                store: node.wildcardStore,
+                params: { '*': '' }
+            };
+        return null;
+    }
+    if (node.inert !== null) {
+        const inert = node.inert.get(url.charCodeAt(endIndex));
+        if (inert !== undefined) {
+            const route = matchRoute(url, urlLength, inert, endIndex);
+            if (route !== null)
+                return route;
+        }
+    }
+    if (node.params !== null) {
+        const param = node.params;
+        const slashIndex = url.indexOf('/', endIndex);
+        if (slashIndex !== endIndex) {
+            // Params cannot be empty
+            if (slashIndex === -1 || slashIndex >= urlLength) {
+                if (param.store !== null) {
+                    const params = {};
+                    const paramName = resolveParamName(param, param.store);
+                    params[paramName] = url.substring(endIndex, urlLength);
+                    return {
+                        store: param.store,
+                        params
+                    };
+                }
+            }
+            else if (param.inert !== null) {
+                const route = matchRoute(url, urlLength, param.inert, slashIndex);
+                if (route !== null) {
+                    const paramName = resolveParamName(param, route.store);
+                    route.params[paramName] = url.substring(endIndex, slashIndex);
+                    return route;
+                }
+            }
+        }
+    }
+    if (node.wildcardStore !== null)
+        return {
+            store: node.wildcardStore,
+            params: {
+                '*': url.substring(endIndex, urlLength)
+            }
+        };
+    return null;
+};
+exports.default = Memoirist;

package/dist/services/logger.service.d.ts

@@ -0,0 +1,23 @@
+import Pino from "pino";
+import { InjectorService } from "../container/InjectorService";
+export interface LoggerAdapter {
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+    fatal(message: string, ...args: any[]): void;
+    trace(message: string, ...args: any[]): void;
+}
+export declare class LoggerService implements LoggerAdapter {
+    private injector;
+    private logger;
+    constructor(injector: InjectorService);
+    child(bindings: Record<string, any>): LoggerAdapter;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+    fatal(message: string, ...args: any[]): void;
+    trace(message: string, ...args: any[]): void;
+    getLogger(): Pino.Logger;
+}

package/dist/services/logger.service.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerService = void 0;
+const pino_1 = __importDefault(require("pino"));
+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) {
+        const child = this.logger.child(bindings);
+        return {
+            info: (message, ...args) => child.info(message, ...args),
+            warn: (message, ...args) => child.warn(message, ...args),
+            error: (message, ...args) => child.error(message, ...args),
+            debug: (message, ...args) => child.debug(message, ...args),
+            fatal: (message, ...args) => child.fatal(message, ...args),
+            trace: (message, ...args) => child.trace(message, ...args),
+        };
+    }
+    info(message, ...args) {
+        this.logger.info(message, ...args);
+    }
+    warn(message, ...args) {
+        this.logger.warn(message, ...args);
+    }
+    error(message, ...args) {
+        this.logger.error(message, ...args);
+    }
+    debug(message, ...args) {
+        this.logger.debug(message, ...args);
+    }
+    fatal(message, ...args) {
+        this.logger.fatal(message, ...args);
+    }
+    trace(message, ...args) {
+        this.logger.trace(message, ...args);
+    }
+    getLogger() {
+        return this.logger;
+    }
+}
+exports.LoggerService = LoggerService;

package/dist/services/request-logger.service.d.ts

@@ -0,0 +1,15 @@
+import { Context } from "../domain/Context";
+import { LoggerService, LoggerAdapter } from "./logger.service";
+export declare class RequestLogger implements LoggerAdapter {
+    private logger;
+    private context;
+    private childLogger;
+    constructor(logger: LoggerService, context: Context);
+    private initializeChildLogger;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+    fatal(message: string, ...args: any[]): void;
+    trace(message: string, ...args: any[]): void;
+}

package/dist/services/request-logger.service.js

@@ -0,0 +1,50 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestLogger = void 0;
+const Injectable_decorator_1 = require("../commons/decorators/Injectable.decorator");
+const provider_scope_1 = require("../domain/provider-scope");
+const Context_1 = require("../domain/Context");
+const logger_service_1 = require("./logger.service");
+let RequestLogger = class RequestLogger {
+    constructor(logger, context) {
+        this.logger = logger;
+        this.context = context;
+        this.initializeChildLogger();
+    }
+    initializeChildLogger() {
+        this.childLogger = this.logger.child({ trackingId: this.context.trackingId });
+    }
+    info(message, ...args) {
+        this.childLogger.info(message, ...args);
+    }
+    warn(message, ...args) {
+        this.childLogger.warn(message, ...args);
+    }
+    error(message, ...args) {
+        this.childLogger.error(message, ...args);
+    }
+    debug(message, ...args) {
+        this.childLogger.debug(message, ...args);
+    }
+    fatal(message, ...args) {
+        this.childLogger.fatal(message, ...args);
+    }
+    trace(message, ...args) {
+        this.childLogger.trace(message, ...args);
+    }
+};
+exports.RequestLogger = RequestLogger;
+exports.RequestLogger = RequestLogger = __decorate([
+    (0, Injectable_decorator_1.Injectable)({ scope: provider_scope_1.ProviderScope.REQUEST }),
+    __metadata("design:paramtypes", [logger_service_1.LoggerService,
+        Context_1.Context])
+], RequestLogger);

package/dist/testing/core-testing.d.ts

@@ -0,0 +1,24 @@
+import type { Server } from 'bun';
+import { Carno, ApplicationConfig } from '../Carno';
+import { TokenProvider, Type } from '../commons';
+import { InjectorService } from '../container/InjectorService';
+export type CoreTestOptions = {
+    config?: ApplicationConfig;
+    listen?: boolean | number;
+    port?: number;
+    plugins?: CoreTestPlugin[];
+};
+export type CoreTestPlugin = Carno | (() => Carno);
+export type CoreTestHarness = {
+    app: Carno;
+    injector: InjectorService;
+    server?: Server<any>;
+    port?: number;
+    resolve<T>(token: Type<T>): T;
+    resolve<T>(token: TokenProvider<T>): T;
+    request(target: string | URL, init?: RequestInit): Promise<Response>;
+    close(): Promise<void>;
+};
+export type CoreTestRoutine = (harness: CoreTestHarness) => Promise<void>;
+export declare function createCoreTestHarness(options?: CoreTestOptions): Promise<CoreTestHarness>;
+export declare function withCoreApplication(routine: CoreTestRoutine, options?: CoreTestOptions): Promise<void>;

package/dist/testing/core-testing.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCoreTestHarness = createCoreTestHarness;
+exports.withCoreApplication = withCoreApplication;
+const Carno_1 = require("../Carno");
+async function createCoreTestHarness(options = {}) {
+    const app = new Carno_1.Carno(options.config);
+    applyPlugins(app, options.plugins);
+    const boot = await bootApplication(app, options);
+    const injector = app.getInjector();
+    const resolve = (token) => {
+        return injector.invoke(token);
+    };
+    const request = async (target, init) => {
+        if (!boot.server) {
+            throw new Error('HTTP server is not running. Enable the listen option to issue requests.');
+        }
+        const url = buildRequestUrl(boot.port ?? boot.server.port, target);
+        return fetch(url, init);
+    };
+    const close = async () => shutdown(app, boot.server);
+    return {
+        app,
+        injector,
+        server: boot.server,
+        port: boot.port ?? boot.server?.port,
+        resolve,
+        request,
+        close,
+    };
+}
+async function withCoreApplication(routine, options = {}) {
+    const harness = await createCoreTestHarness(options);
+    try {
+        await routine(harness);
+    }
+    finally {
+        await harness.close();
+    }
+}
+async function bootApplication(app, options) {
+    if (!shouldListen(options.listen)) {
+        await app.init();
+        return {};
+    }
+    const port = resolveListenPort(options);
+    await app.listen(port);
+    const server = app.getHttpServer();
+    const runningPort = server?.port ?? port;
+    return { server, port: runningPort };
+}
+function shouldListen(value) {
+    if (typeof value === 'number') {
+        return true;
+    }
+    return Boolean(value);
+}
+function resolveListenPort(options) {
+    if (typeof options.listen === 'number') {
+        return options.listen;
+    }
+    if (typeof options.port === 'number') {
+        return options.port;
+    }
+    return 0;
+}
+function buildRequestUrl(port, target) {
+    if (target instanceof URL) {
+        return target.toString();
+    }
+    if (isAbsoluteUrl(target)) {
+        return target;
+    }
+    const path = target.startsWith('/') ? target : `/${target}`;
+    return `http://127.0.0.1:${port}${path}`;
+}
+function isAbsoluteUrl(target) {
+    return /^https?:\/\//i.test(target);
+}
+async function shutdown(app, server) {
+    if (!server) {
+        app.close();
+        return;
+    }
+    app.close(true);
+}
+function applyPlugins(app, plugins) {
+    if (!plugins?.length) {
+        return;
+    }
+    plugins.forEach((plugin) => app.use(resolvePlugin(plugin)));
+}
+function resolvePlugin(entry) {
+    if (typeof entry === 'function') {
+        return entry();
+    }
+    return entry;
+}

package/dist/testing/index.d.ts

@@ -0,0 +1 @@
+export * from './core-testing';

package/dist/testing/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./core-testing"), exports);

package/dist/utils/ancestorOf.d.ts

@@ -0,0 +1,2 @@
+export declare function ancestorOf(target: any): any;
+export declare function getInheritedClass(target: any): any;

package/dist/utils/ancestorOf.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ancestorOf = ancestorOf;
+exports.getInheritedClass = getInheritedClass;
+function ancestorOf(target) {
+    return target && Object.getPrototypeOf(target);
+}
+function getInheritedClass(target) {
+    return ancestorOf(target);
+}

package/dist/utils/ancestorsOf.d.ts

@@ -0,0 +1,6 @@
+/**
+ *
+ * @param target
+ * @returns {Array}
+ */
+export declare function ancestorsOf(target: any): any[];

package/dist/utils/ancestorsOf.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ancestorsOf = ancestorsOf;
+const classOf_1 = require("./classOf");
+const ancestorOf_1 = require("./ancestorOf");
+const nameOf_1 = require("./nameOf");
+/**
+ *
+ * @param target
+ * @returns {Array}
+ */
+function ancestorsOf(target) {
+    const classes = [];
+    let currentTarget = (0, classOf_1.classOf)(target);
+    while (currentTarget && (0, nameOf_1.nameOf)(currentTarget) !== "") {
+        classes.unshift(currentTarget);
+        currentTarget = (0, ancestorOf_1.getInheritedClass)(currentTarget);
+    }
+    return classes;
+}

package/dist/utils/classOf.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Get the provide constructor if target is an instance.
+ * @param target
+ * @returns {*}
+ */
+export declare function getClass(target: any): any;
+/**
+ * Get the provide constructor if target is an instance.
+ * @param target
+ * @returns {*}
+ * @alias getClass
+ */
+export declare function classOf(target: any): any;

package/dist/utils/classOf.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClass = getClass;
+exports.classOf = classOf;
+/**
+ * Get the provide constructor if target is an instance.
+ * @param target
+ * @returns {*}
+ */
+function getClass(target) {
+    return target.prototype ? target : target.constructor;
+}
+/**
+ * Get the provide constructor if target is an instance.
+ * @param target
+ * @returns {*}
+ * @alias getClass
+ */
+function classOf(target) {
+    return getClass(target);
+}

package/dist/utils/cleanObject.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Remove undefined value
+ * @param obj
+ * @param ignore
+ */
+export declare function cleanObject(obj: any, ignore?: string[]): any;

package/dist/utils/cleanObject.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanObject = cleanObject;
+const isProtectedKey_1 = require("./isProtectedKey");
+/**
+ * Remove undefined value
+ * @param obj
+ * @param ignore
+ */
+function cleanObject(obj, ignore = []) {
+    return Object.entries(obj).reduce((obj, [key, value]) => {
+        if ((0, isProtectedKey_1.isProtectedKey)(key) || ignore.includes(key)) {
+            return obj;
+        }
+        return value === undefined
+            ? obj
+            : {
+                ...obj,
+                [key]: value
+            };
+    }, {});
+}

package/dist/utils/constructorOf.d.ts

@@ -0,0 +1,11 @@
+import { Type } from "../commons";
+/**
+ * Get the class constructor
+ * @param target
+ */
+export declare function getConstructor(target: any): Type<any>;
+/**
+ * Get the class constructor
+ * @param target
+ */
+export declare function constructorOf(target: any): Type<any>;

package/dist/utils/constructorOf.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConstructor = getConstructor;
+exports.constructorOf = constructorOf;
+/**
+ * Get the class constructor
+ * @param target
+ */
+function getConstructor(target) {
+    return typeof target === "function" ? target : target.constructor;
+}
+/**
+ * Get the class constructor
+ * @param target
+ */
+function constructorOf(target) {
+    return getConstructor(target);
+}