@carno.js/core 0.2.11 → 1.0.2

package/dist/route/memoirist.js

@@ -1,373 +0,0 @@
-"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,
-    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 = [];
-        this.routeCache = new Map();
-    }
-    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.invalidateCache();
-        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) {
-        let methodCache = this.routeCache.get(url);
-        if (methodCache && methodCache[method] !== undefined) {
-            return methodCache[method];
-        }
-        const root = this.root[method];
-        if (!root)
-            return null;
-        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);
-        if (!node) {
-            return false;
-        }
-        if (node.store === oldStore) {
-            node.store = newStore;
-            this.updateHistoryStore(method, path, newStore);
-            this.invalidateCache();
-            return true;
-        }
-        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);
-            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++) {
-            const [m, p] = this.history[i];
-            if (m === method && this.normalizePath(p) === normalizedPath) {
-                this.history[i] = [method, p, newStore];
-                break;
-            }
-        }
-    }
-    normalizePath(path) {
-        if (path === '') {
-            return '/';
-        }
-        return path[0] !== '/' ? `/${path}` : path;
-    }
-    findNode(method, path) {
-        if (path === '') {
-            path = '/';
-        }
-        else if (path[0] !== '/') {
-            path = `/${path}`;
-        }
-        const isWildcard = path[path.length - 1] === '*';
-        if (isWildcard) {
-            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 = this.root[method];
-        if (!node) {
-            return null;
-        }
-        let paramPartsIndex = 0;
-        for (let i = 0; i < inertParts.length; ++i) {
-            let part = inertParts[i];
-            if (i > 0) {
-                paramPartsIndex++;
-                if (!node.params?.inert) {
-                    return null;
-                }
-                node = node.params.inert;
-            }
-            for (let j = 0;;) {
-                if (j === part.length) {
-                    break;
-                }
-                if (j === node.part.length) {
-                    if (!node.inert?.has(part.charCodeAt(j))) {
-                        return null;
-                    }
-                    node = node.inert.get(part.charCodeAt(j));
-                    part = part.slice(j);
-                    j = 0;
-                    continue;
-                }
-                if (part[j] !== node.part[j]) {
-                    return null;
-                }
-                ++j;
-            }
-        }
-        return node;
-    }
-}
-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: EMPTY_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);
-                    const paramValue = url.substring(endIndex, slashIndex);
-                    if (route.params === EMPTY_PARAMS) {
-                        route.params = { [paramName]: paramValue };
-                    }
-                    else {
-                        route.params[paramName] = paramValue;
-                    }
-                    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

@@ -1,23 +0,0 @@
-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

@@ -1,47 +0,0 @@
-"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 || {};
-        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/testing/core-testing.d.ts

@@ -1,24 +0,0 @@
-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

@@ -1,102 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCoreTestHarness = createCoreTestHarness;
-exports.withCoreApplication = withCoreApplication;
-const Carno_1 = require("../Carno");
-async function createCoreTestHarness(options = {}) {
-    const config = { ...options.config };
-    if (config.disableStartupLog === undefined) {
-        config.disableStartupLog = true;
-    }
-    const app = new Carno_1.Carno(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

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

package/dist/testing/index.js

@@ -1,17 +0,0 @@
-"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/ValidationCache.d.ts

@@ -1,5 +0,0 @@
-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,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setValidatorAdapter = setValidatorAdapter;
-exports.isValidatable = isValidatable;
-exports.preloadValidationForParams = preloadValidationForParams;
-exports.clearValidationCache = clearValidationCache;
-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 = currentAdapter.hasValidation(token);
-        cache.set(token, result);
-    }
-    return result;
-}
-function preloadValidationForParams(args) {
-    const indices = [];
-    for (let i = 0; i < args.length; i++) {
-        if (typeof args[i] === 'function' && isValidatable(args[i])) {
-            indices.push(i);
-        }
-    }
-    return indices;
-}
-function clearValidationCache() {
-    cache.clear();
-}

package/dist/utils/ancestorOf.d.ts

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

package/dist/utils/ancestorOf.js

@@ -1,10 +0,0 @@
-"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

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

package/dist/utils/ancestorsOf.js

@@ -1,20 +0,0 @@
-"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

@@ -1,13 +0,0 @@
-/**
- * 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;