@carno.js/core 0.2.3

package/dist/domain/provider.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Provider = void 0;
+const provider_type_1 = require("./provider-type");
+const provider_scope_1 = require("./provider-scope");
+const methodsOf_1 = require("../utils/methodsOf");
+const utils_1 = require("../utils");
+class Provider {
+    constructor(token, options = {}) {
+        /**
+         * Token group provider to retrieve all provider from the same type
+         */
+        this.type = provider_type_1.ProviderType.PROVIDER;
+        this.deps = [];
+        /**
+         * Scope used by the injector to build the provider.
+         */
+        this.scope = provider_scope_1.ProviderScope.SINGLETON;
+        this.children = [];
+        this.provide = token;
+        this.useClass = token;
+        Object.assign(this, options);
+    }
+    get token() {
+        return this._provide;
+    }
+    get useClass() {
+        return this._useClass;
+    }
+    /**
+     * Create a new store if the given value is a class. Otherwise the value is ignored.
+     * @param value
+     */
+    set useClass(value) {
+        if ((0, utils_1.isClass)(value)) {
+            this._useClass = (0, utils_1.classOf)(value);
+            this.hooks = (0, methodsOf_1.methodsOf)(this._useClass).reduce((hooks, { propertyKey }) => {
+                if (String(propertyKey).startsWith("$")) {
+                    return {
+                        ...hooks,
+                        [propertyKey]: (instance, ...args) => instance[propertyKey](...args),
+                    };
+                }
+                return hooks;
+            }, {});
+        }
+    }
+    get useValue() {
+        return this._useValue;
+    }
+    set useValue(value) {
+        this._useValue = value();
+    }
+    get provide() {
+        return this._provide;
+    }
+    set provide(value) {
+        if (!value) {
+            return;
+        }
+        this._provide = value;
+    }
+    clone() {
+        return new ((0, utils_1.classOf)(this))(this._provide, this);
+    }
+    isChild() {
+        return !!this.parent;
+    }
+}
+exports.Provider = Provider;

package/dist/events/hooks.decorator.d.ts

@@ -0,0 +1,3 @@
+export declare function OnApplicationInit(priority?: number): MethodDecorator;
+export declare function OnApplicationShutdown(priority?: number): MethodDecorator;
+export declare function OnApplicationBoot(priority?: number): (target: Function, propertyKey: any) => void;

package/dist/events/hooks.decorator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnApplicationInit = OnApplicationInit;
+exports.OnApplicationShutdown = OnApplicationShutdown;
+exports.OnApplicationBoot = OnApplicationBoot;
+const constants_1 = require("../constants");
+const Metadata_1 = require("../domain/Metadata");
+const on_event_1 = require("./on-event");
+function OnApplicationInit(priority = 0) {
+    return (target, propertyKey) => {
+        const anotherEvents = Metadata_1.Metadata.get(constants_1.CONTROLLER_EVENTS, Reflect) || [];
+        anotherEvents.push({ methodName: propertyKey, eventName: on_event_1.EventType.OnApplicationInit, target: target.constructor, priority });
+        Metadata_1.Metadata.set(constants_1.CONTROLLER_EVENTS, anotherEvents, Reflect);
+    };
+}
+function OnApplicationShutdown(priority = 0) {
+    return (target, propertyKey) => {
+        const anotherEvents = Metadata_1.Metadata.get(constants_1.CONTROLLER_EVENTS, Reflect) || [];
+        anotherEvents.push({ methodName: propertyKey, eventName: on_event_1.EventType.OnApplicationShutdown, target: target.constructor, priority });
+        Metadata_1.Metadata.set(constants_1.CONTROLLER_EVENTS, anotherEvents, Reflect);
+    };
+}
+function OnApplicationBoot(priority = 0) {
+    return (target, propertyKey) => {
+        const anotherEvents = Metadata_1.Metadata.get(constants_1.CONTROLLER_EVENTS, Reflect) || [];
+        anotherEvents.push({ methodName: propertyKey, eventName: on_event_1.EventType.OnApplicationBoot, target: target.constructor, priority });
+        Metadata_1.Metadata.set(constants_1.CONTROLLER_EVENTS, anotherEvents, Reflect);
+    };
+}

package/dist/events/index.d.ts

@@ -0,0 +1,2 @@
+export * from './on-event';
+export * from './hooks.decorator';

package/dist/events/index.js

@@ -0,0 +1,18 @@
+"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("./on-event"), exports);
+__exportStar(require("./hooks.decorator"), exports);

package/dist/events/on-event.d.ts

@@ -0,0 +1,13 @@
+export declare enum EventType {
+    OnApplicationBoot = "OnApplicationBoot",
+    OnApplicationInit = "OnApplicationInit",
+    OnApplicationShutdown = "OnApplicationShutdown",
+    OnRequest = "OnRequest",
+    OnResponse = "OnResponse"
+}
+export interface OnEvent {
+    methodName: string;
+    eventName: EventType;
+    target: Object;
+    priority: number;
+}

package/dist/events/on-event.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventType = void 0;
+var EventType;
+(function (EventType) {
+    EventType["OnApplicationBoot"] = "OnApplicationBoot";
+    EventType["OnApplicationInit"] = "OnApplicationInit";
+    EventType["OnApplicationShutdown"] = "OnApplicationShutdown";
+    EventType["OnRequest"] = "OnRequest";
+    EventType["OnResponse"] = "OnResponse";
+})(EventType || (exports.EventType = EventType = {}));

package/dist/exceptions/HttpException.d.ts

@@ -0,0 +1,9 @@
+export declare class HttpException {
+    response: any;
+    statusCode: any;
+    message: string | object;
+    constructor(response: any, statusCode: any);
+    initMessage(): void;
+    getResponse(): string | object;
+    getStatus(): number;
+}

package/dist/exceptions/HttpException.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpException = void 0;
+const utils_1 = require("../utils");
+class HttpException {
+    constructor(response, statusCode) {
+        this.response = response;
+        this.statusCode = statusCode;
+        this.initMessage();
+    }
+    initMessage() {
+        if ((0, utils_1.isObject)(this.response)) {
+            this.message = this.response;
+        }
+        else {
+            this.message = this.response;
+        }
+    }
+    getResponse() {
+        return this.message;
+    }
+    getStatus() {
+        return this.statusCode;
+    }
+}
+exports.HttpException = HttpException;

package/dist/exceptions/index.d.ts

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

package/dist/exceptions/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("./HttpException"), exports);

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./commons";
+export * from "./container";
+export * from "./domain";
+export * from "./route/Matcher";
+export * from "./route/RouteExecutor";
+export * from "./exceptions";
+export * from "./Carno";
+export * from "./events";
+export * from "./constants";
+export * from "./utils";
+export * from "./default-routes-carno";
+export * from "./services/logger.service";
+export * from "./services/request-logger.service";
+export * from "./cache/cache.service";
+export * from "./cache/bento-cache.driver";
+export * from "./testing";

package/dist/index.js

@@ -0,0 +1,32 @@
+"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("./commons"), exports);
+__exportStar(require("./container"), exports);
+__exportStar(require("./domain"), exports);
+__exportStar(require("./route/Matcher"), exports);
+__exportStar(require("./route/RouteExecutor"), exports);
+__exportStar(require("./exceptions"), exports);
+__exportStar(require("./Carno"), exports);
+__exportStar(require("./events"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./default-routes-carno"), exports);
+__exportStar(require("./services/logger.service"), exports);
+__exportStar(require("./services/request-logger.service"), exports);
+__exportStar(require("./cache/cache.service"), exports);
+__exportStar(require("./cache/bento-cache.driver"), exports);
+__exportStar(require("./testing"), exports);

package/dist/route/Matcher.d.ts

@@ -0,0 +1,16 @@
+import { TokenRouteWithProvider, TokenRouteWithProviderMap } from "../container";
+import { Context } from "../domain";
+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;
+}
+export declare const RouteResolver: Matcher;
+export {};

package/dist/route/Matcher.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteResolver = void 0;
+const parseUrl = require('parseurl-fast');
+class Matcher {
+    match(request, routes, context) {
+        const method = request.method.toLowerCase();
+        if (!routes) {
+            throw new Error(`Method not allowed for ${request.url}`);
+        }
+        const routeMethod = routes.get(method);
+        const url = parseUrl(request);
+        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('/');
+        if (urlPath.length !== routePathSegments.length) {
+            return false;
+        }
+        return routePathSegments.every((path, index) => {
+            if (path === '*') {
+                return true;
+            }
+            if (path.startsWith(':')) {
+                context.setParam({
+                    ...context.param,
+                    [path.replace(':', '')]: urlPath[index]
+                });
+                return true;
+            }
+            return path === urlPath[index];
+        });
+    }
+}
+exports.RouteResolver = new Matcher();

package/dist/route/RouteExecutor.d.ts

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

package/dist/route/RouteExecutor.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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(route, injector, context, locals) {
+        const provider = injector.invoke(route.provider, locals);
+        route.provider.instance = provider;
+        // @ts-ignore
+        if (!provider[route.methodName]) {
+            throw new Error("Controller not found");
+        }
+        const result = await injector.invokeRoute(route, context, locals);
+        await injector.callHook(events_1.EventType.OnResponse, { context, result });
+        return this.mountResponse(result, context);
+    }
+    mountResponse(result, context) {
+        const status = context.getResponseStatus() || 200;
+        if (this.isNativeResponse(result)) {
+            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 this.createJsonResponse(result, status);
+    }
+    isNativeResponse(result) {
+        return result instanceof Response;
+    }
+    isBodyInit(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;
+    }
+    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

@@ -0,0 +1,25 @@
+export interface FindResult<T> {
+    store: T;
+    params: Record<string, any>;
+}
+export interface ParamNode<T> {
+    paramName: string | null;
+    names: Map<T, string>;
+    store: T | null;
+    inert: Node<T> | null;
+}
+export interface Node<T> {
+    part: string;
+    store: T | null;
+    inert: Map<number, Node<T>> | null;
+    params: ParamNode<T> | null;
+    wildcardStore: T | null;
+}
+export declare class Memoirist<T> {
+    root: Record<string, Node<T>>;
+    history: [string, string, T][];
+    private static regex;
+    add(method: string, path: string, store: T): FindResult<T>['store'];
+    find(method: string, url: string): FindResult<T> | null;
+}
+export default Memoirist;