@venok/core 1.0.1-canary.5 → 2.0.0

package/dist/storage/handler-metadata.storage.js

@@ -0,0 +1,42 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = 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 __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/storage/handler-metadata.storage.ts
+import { PROVIDER_ID_KEY } from "../injector/constants.js";
+var HANDLER_METADATA_SYMBOL = Symbol.for("handler_metadata:cache");
+
+class HandlerMetadataStorage {
+  [HANDLER_METADATA_SYMBOL] = new Map;
+  set(instance, methodName, metadata) {
+    const metadataKey = this.getMetadataKey(instance, methodName);
+    this[HANDLER_METADATA_SYMBOL].set(metadataKey, metadata);
+  }
+  get(instance, methodName) {
+    const metadataKey = this.getMetadataKey(instance, methodName);
+    return this[HANDLER_METADATA_SYMBOL].get(metadataKey);
+  }
+  getMetadataKey(instance, methodName) {
+    const ctor = instance.constructor;
+    const controllerKey = ctor && (ctor[PROVIDER_ID_KEY] || ctor.name);
+    return controllerKey + methodName;
+  }
+}
+export {
+  HandlerMetadataStorage,
+  HANDLER_METADATA_SYMBOL
+};

package/dist/storage/meta-host.storage.js

@@ -0,0 +1,62 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = 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 __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/storage/meta-host.storage.ts
+class MetaHostStorage {
+  static metaHostLinks = new Map;
+  static providersByMetaKey = new WeakMap;
+  static addClassMetaHostLink(target, metadataKey) {
+    this.metaHostLinks.set(target, metadataKey);
+  }
+  static inspectProvider(hostContainerRef, instanceWrapper) {
+    return this.inspectInstanceWrapper(hostContainerRef, instanceWrapper, this.providersByMetaKey);
+  }
+  static insertByMetaKey(metaKey, instanceWrapper, collection) {
+    if (collection.has(metaKey)) {
+      const wrappers = collection.get(metaKey);
+      wrappers.add(instanceWrapper);
+    } else {
+      const wrappers = new Set;
+      wrappers.add(instanceWrapper);
+      collection.set(metaKey, wrappers);
+    }
+  }
+  static getProvidersByMetaKey(hostContainerRef, metaKey) {
+    const wrappersByMetaKey = this.providersByMetaKey.get(hostContainerRef);
+    return wrappersByMetaKey?.get(metaKey) ?? new Set;
+  }
+  static inspectInstanceWrapper(hostContainerRef, instanceWrapper, wrapperByMetaKeyMap) {
+    const metaKey = MetaHostStorage.getMetaKeyByInstanceWrapper(instanceWrapper);
+    if (!metaKey)
+      return;
+    let collection;
+    if (wrapperByMetaKeyMap.has(hostContainerRef)) {
+      collection = wrapperByMetaKeyMap.get(hostContainerRef);
+    } else {
+      collection = new Map;
+      wrapperByMetaKeyMap.set(hostContainerRef, collection);
+    }
+    this.insertByMetaKey(metaKey, instanceWrapper, collection);
+  }
+  static getMetaKeyByInstanceWrapper(instanceWrapper) {
+    return this.metaHostLinks.get(instanceWrapper.metatype || instanceWrapper.inject ? instanceWrapper.instance?.constructor ?? instanceWrapper.metatype : instanceWrapper.metatype);
+  }
+}
+export {
+  MetaHostStorage
+};

package/package.json

@@ -1,40 +1,52 @@
-{
-  "name": "@venok/core",
-  "version": "1.0.1-canary.5",
-  "description": "",
-  "author": "0x303133",
-  "homepage": "",
-  "main": "index.js",
-  "types": "./index.d.ts",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/venokjs/venok.git",
-    "directory": "packages/core"
-  },
-  "scripts": {
-    "build": "venok build",
-    "postbuild": "ts-node ../../tools/move.ts core",
-    "test": "mocha test/**/*.spec.ts"
-  },
-  "dependencies": {
-    "fast-safe-stringify": "^2.1.1",
-    "uid": "^2.0.2",
-    "uuid": "^9.0.1"
-  },
-  "peerDependencies": {
-    "reflect-metadata": "^0.1.13",
-    "rxjs": "^7.8.1"
-  },
-  "mocha": {
-    "require": [
-      "ts-node/register",
-      "tsconfig-paths/register",
-      "../../node_modules/reflect-metadata/Reflect.js",
-      "../../hooks/mocha-init-hook.ts"
-    ],
-    "exit": true
-  }
-}
+{
+  "name": "@venok/core",
+  "version": "2.0.0",
+  "description": "",
+  "author": "shiz-ceo",
+  "type": "module",
+  "homepage": "",
+  "files": ["package.json", "dist"],
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./*": {
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/*"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/*"
+      }
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/venokjs/venok.git",
+    "directory": "packages/core"
+  },
+  "scripts": {
+    "build": "venok build",
+    "test": "mocha test_old/**/*.spec.ts"
+  },
+  "dependencies": {
+    "fast-safe-stringify": "^2.1.1"
+  },
+  "peerDependencies": {
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1",
+    "uid": "^2.0.2",
+    "uuid": "^13.0.0"
+  }
+}

package/application/config.d.ts

@@ -1,35 +0,0 @@
-import { CanActivate } from "@venok/core/interfaces/features/guards.interface";
-import { InstanceWrapper } from "@venok/core/injector/instance/wrapper";
-import { PipeTransform } from "@venok/core/interfaces/features/pipes.interface";
-import { ExceptionFilter } from "@venok/core/interfaces/features/exception-filter.interface";
-import { VenokInterceptor } from "@venok/core/interfaces/features/interceptor.interface";
-export declare class ApplicationConfig {
-    private globalPipes;
-    private globalFilters;
-    private globalInterceptors;
-    private globalGuards;
-    private readonly globalRequestPipes;
-    private readonly globalRequestFilters;
-    private readonly globalRequestInterceptors;
-    private readonly globalRequestGuards;
-    addGlobalPipe(pipe: PipeTransform<any>): void;
-    useGlobalPipes(...pipes: PipeTransform<any>[]): void;
-    getGlobalFilters(): ExceptionFilter[];
-    addGlobalFilter(filter: ExceptionFilter): void;
-    useGlobalFilters(...filters: ExceptionFilter[]): void;
-    getGlobalPipes(): PipeTransform<any>[];
-    getGlobalInterceptors(): VenokInterceptor[];
-    addGlobalInterceptor(interceptor: VenokInterceptor): void;
-    useGlobalInterceptors(...interceptors: VenokInterceptor[]): void;
-    getGlobalGuards(): CanActivate[];
-    addGlobalGuard(guard: CanActivate): void;
-    useGlobalGuards(...guards: CanActivate[]): void;
-    addGlobalRequestInterceptor(wrapper: InstanceWrapper<VenokInterceptor>): void;
-    getGlobalRequestInterceptors(): InstanceWrapper<VenokInterceptor>[];
-    addGlobalRequestPipe(wrapper: InstanceWrapper<PipeTransform>): void;
-    getGlobalRequestPipes(): InstanceWrapper<PipeTransform>[];
-    addGlobalRequestFilter(wrapper: InstanceWrapper<ExceptionFilter>): void;
-    getGlobalRequestFilters(): InstanceWrapper<ExceptionFilter>[];
-    addGlobalRequestGuard(wrapper: InstanceWrapper<CanActivate>): void;
-    getGlobalRequestGuards(): InstanceWrapper<CanActivate>[];
-}

package/application/config.js

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApplicationConfig = void 0;
-class ApplicationConfig {
-    constructor() {
-        this.globalPipes = [];
-        this.globalFilters = [];
-        this.globalInterceptors = [];
-        this.globalGuards = [];
-        this.globalRequestPipes = [];
-        this.globalRequestFilters = [];
-        this.globalRequestInterceptors = [];
-        this.globalRequestGuards = [];
-    }
-    // constructor(private ioAdapter: WebSocketAdapter | null = null) {}
-    //
-    // public setIoAdapter(ioAdapter: WebSocketAdapter) {
-    //   this.ioAdapter = ioAdapter;
-    // }
-    //
-    // public getIoAdapter(): WebSocketAdapter {
-    //   return this.ioAdapter;
-    // }
-    addGlobalPipe(pipe) {
-        this.globalPipes.push(pipe);
-    }
-    useGlobalPipes(...pipes) {
-        this.globalPipes = this.globalPipes.concat(pipes);
-    }
-    getGlobalFilters() {
-        return this.globalFilters;
-    }
-    addGlobalFilter(filter) {
-        this.globalFilters.push(filter);
-    }
-    useGlobalFilters(...filters) {
-        this.globalFilters = this.globalFilters.concat(filters);
-    }
-    getGlobalPipes() {
-        return this.globalPipes;
-    }
-    getGlobalInterceptors() {
-        return this.globalInterceptors;
-    }
-    addGlobalInterceptor(interceptor) {
-        this.globalInterceptors.push(interceptor);
-    }
-    useGlobalInterceptors(...interceptors) {
-        this.globalInterceptors = this.globalInterceptors.concat(interceptors);
-    }
-    getGlobalGuards() {
-        return this.globalGuards;
-    }
-    addGlobalGuard(guard) {
-        this.globalGuards.push(guard);
-    }
-    useGlobalGuards(...guards) {
-        this.globalGuards = this.globalGuards.concat(guards);
-    }
-    addGlobalRequestInterceptor(wrapper) {
-        this.globalRequestInterceptors.push(wrapper);
-    }
-    getGlobalRequestInterceptors() {
-        return this.globalRequestInterceptors;
-    }
-    addGlobalRequestPipe(wrapper) {
-        this.globalRequestPipes.push(wrapper);
-    }
-    getGlobalRequestPipes() {
-        return this.globalRequestPipes;
-    }
-    addGlobalRequestFilter(wrapper) {
-        this.globalRequestFilters.push(wrapper);
-    }
-    getGlobalRequestFilters() {
-        return this.globalRequestFilters;
-    }
-    addGlobalRequestGuard(wrapper) {
-        this.globalRequestGuards.push(wrapper);
-    }
-    getGlobalRequestGuards() {
-        return this.globalRequestGuards;
-    }
-}
-exports.ApplicationConfig = ApplicationConfig;

package/application/context.d.ts

@@ -1,198 +0,0 @@
-import { AbstractInstanceResolver } from "@venok/core/injector/instance/resolver";
-import { Injector } from "@venok/core/injector/injector";
-import { Logger, LoggerService, LogLevel } from "@venok/core/services/logger.service";
-import { InstanceLinksHost } from "@venok/core/injector/instance/links-host";
-import { Module } from "@venok/core/injector/module/module";
-import { DynamicModule, Type } from "@venok/core/interfaces";
-import { VenokContainer } from "@venok/core/injector/container";
-import { ContextId } from "@venok/core/injector/instance/wrapper";
-import { ApplicationContextOptions } from "@venok/core/interfaces/application/context-options.interface";
-import { VenokApplicationContext } from "@venok/core/interfaces/application/context.interface";
-import { ApplicationConfig } from "@venok/core/application/config";
-import { VenokInterceptor } from "@venok/core/interfaces/features/interceptor.interface";
-import { CanActivate } from "@venok/core/interfaces/features/guards.interface";
-import { ExceptionFilter } from "@venok/core/interfaces/features/exception-filter.interface";
-import { PipeTransform } from "@venok/core/interfaces/features/pipes.interface";
-/**
- * System signals which shut down a process
- */
-export declare enum ShutdownSignal {
-    SIGHUP = "SIGHUP",
-    SIGINT = "SIGINT",
-    SIGQUIT = "SIGQUIT",
-    SIGILL = "SIGILL",
-    SIGTRAP = "SIGTRAP",
-    SIGABRT = "SIGABRT",
-    SIGBUS = "SIGBUS",
-    SIGFPE = "SIGFPE",
-    SIGSEGV = "SIGSEGV",
-    SIGUSR2 = "SIGUSR2",
-    SIGTERM = "SIGTERM"
-}
-export type ShutdownSignalKeys = keyof typeof ShutdownSignal;
-/**
- * @publicApi
- */
-export declare class ApplicationContext<TOptions extends ApplicationContextOptions = ApplicationContextOptions> extends AbstractInstanceResolver implements VenokApplicationContext {
-    protected readonly container: VenokContainer;
-    protected readonly config: ApplicationConfig;
-    protected readonly appOptions: TOptions;
-    private contextModule;
-    private readonly scope;
-    protected isInitialized: boolean;
-    protected injector: Injector;
-    protected readonly logger: Logger;
-    private shouldFlushLogsOnOverride;
-    private readonly activeShutdownSignals;
-    private readonly moduleCompiler;
-    private shutdownCleanupRef?;
-    private _instanceLinksHost;
-    private _moduleRefsForHooksByDistance?;
-    protected get instanceLinksHost(): InstanceLinksHost;
-    constructor(container: VenokContainer, config: ApplicationConfig, appOptions?: TOptions, contextModule?: Module, scope?: Type<any>[]);
-    selectContextModule(): void;
-    /**
-     * Allows navigating through the modules tree, for example, to pull out a specific instance from the selected module.
-     * @returns {VenokApplicationContext}
-     */
-    select<T>(moduleType: Type<T> | DynamicModule): VenokApplicationContext;
-    /**
-     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
-     * @returns {TResult}
-     */
-    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol): TResult;
-    /**
-     * Retrieves an instance of either injectable or controller, otherwise, throws exception.
-     * @returns {TResult}
-     */
-    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
-        strict?: boolean;
-        each?: undefined | false;
-    }): TResult;
-    /**
-     * Retrieves a list of instances of either injectables or controllers, otherwise, throws exception.
-     * @returns {Array<TResult>}
-     */
-    get<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, options: {
-        strict?: boolean;
-        each: true;
-    }): Array<TResult>;
-    /**
-     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
-     * @returns {Array<TResult>}
-     */
-    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol): Promise<TResult>;
-    /**
-     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
-     * @returns {Array<TResult>}
-     */
-    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
-        id: number;
-    }): Promise<TResult>;
-    /**
-     * Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
-     * @returns {Array<TResult>}
-     */
-    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
-        id: number;
-    }, options?: {
-        strict?: boolean;
-        each?: undefined | false;
-    }): Promise<TResult>;
-    /**
-     * Resolves transient or request-scoped instances of either injectables or controllers, otherwise, throws exception.
-     * @returns {Array<TResult>}
-     */
-    resolve<TInput = any, TResult = TInput>(typeOrToken: Type<TInput> | Function | string | symbol, contextId?: {
-        id: number;
-    }, options?: {
-        strict?: boolean;
-        each: true;
-    }): Promise<Array<TResult>>;
-    /**
-     * Registers the request/context object for a given context ID (DI container sub-tree).
-     * @returns {void}
-     */
-    registerRequestByContextId<T = any>(request: T, contextId: ContextId): void;
-    /**
-     * Initializes the Venok application.
-     * Calls the Venok lifecycle events.
-     *
-     * @returns {Promise<this>} The ApplicationContext instance as Promise
-     */
-    init(): Promise<this>;
-    /**
-     * Terminates the application
-     * @returns {Promise<void>}
-     */
-    close(signal?: string): Promise<void>;
-    /**
-     * Sets custom logger service.
-     * Flushes buffered logs if auto flush is on.
-     * @returns {void}
-     */
-    useLogger(logger: LoggerService | LogLevel[] | false): void;
-    useGlobalFilters(...filters: ExceptionFilter[]): this;
-    useGlobalPipes(...pipes: PipeTransform<any>[]): this;
-    useGlobalInterceptors(...interceptors: VenokInterceptor[]): this;
-    useGlobalGuards(...guards: CanActivate[]): this;
-    /**
-     * Prints buffered logs and detaches buffer.
-     * @returns {void}
-     */
-    flushLogs(): void;
-    /**
-     * Define that it must flush logs right after defining a custom logger.
-     */
-    flushLogsOnOverride(): void;
-    /**
-     * Enables the usage of shutdown hooks. Will call the
-     * `onApplicationShutdown` function of a provider if the
-     * process receives a shutdown signal.
-     *
-     * @param {ShutdownSignal[]} [signals=[]] The system signals it should listen to
-     *
-     * @returns {this} The Venok application context instance
-     */
-    enableShutdownHooks(signals?: (ShutdownSignal | string)[]): this;
-    protected dispose(): Promise<void>;
-    /**
-     * Listens to shutdown signals by listening to
-     * process events
-     *
-     * @param {string[]} signals The system signals it should listen to
-     */
-    protected listenToShutdownSignals(signals: string[]): void;
-    /**
-     * Unsubscribes from shutdown signals (process events)
-     */
-    protected unsubscribeFromProcessSignals(): void;
-    /**
-     * Calls the `onModuleInit` function on the registered
-     * modules and its children.
-     */
-    protected callInitHook(): Promise<void>;
-    /**
-     * Calls the `onModuleDestroy` function on the registered
-     * modules and its children.
-     */
-    protected callDestroyHook(): Promise<void>;
-    /**
-     * Calls the `onApplicationBootstrap` function on the registered
-     * modules and its children.
-     */
-    protected callBootstrapHook(): Promise<void>;
-    /**
-     * Calls the `onApplicationShutdown` function on the registered
-     * modules and children.
-     */
-    protected callShutdownHook(signal?: string): Promise<void>;
-    /**
-     * Calls the `beforeApplicationShutdown` function on the registered
-     * modules and children.
-     */
-    protected callBeforeShutdownHook(signal?: string): Promise<void>;
-    protected assertNotInPreviewMode(methodName: string): void;
-    private getModulesToTriggerHooksOn;
-    private printInPreviewModeWarning;
-}