@bool-ts/core 1.9.1 → 1.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bool-ts/core",
-    "version": "1.9.1",
+    "version": "1.9.2",
     "description": "",
     "main": "dist/index.js",
     "scripts": {
@@ -21,12 +21,12 @@
         "@bool-ts/date-time": "^1.0.0",
         "qs": "^6.14.0",
         "reflect-metadata": "^0.2.2",
-        "zod": "^3.24.1"
+        "zod": "^3.24.2"
     },
     "devDependencies": {
         "@types/bun": "latest",
         "@types/qs": "^6.9.18",
-        "typescript": "^5.7.3"
+        "typescript": "^5.8.2"
     },
     "private": "false"
 }

package/src/decorators/arguments.ts

@@ -2,6 +2,7 @@ import * as Zod from "zod";
 import {
     argumentsKey,
     contextArgsKey,
+    httpServerArgsKey,
     paramArgsKey,
     paramsArgsKey,
     queryArgsKey,
@@ -64,6 +65,10 @@ export type TArgumentsMetadata =
     | {
           index: number;
           type: typeof routeModelArgsKey;
+      }
+    | {
+          index: number;
+          type: typeof httpServerArgsKey;
       };
 
 export type TArgumentsMetadataCollection = Record<`argumentIndexes.${number}`, TArgumentsMetadata>;
@@ -306,3 +311,25 @@ export const RouteModel =
 
         Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
     };
+
+export const HttpServer =
+    () => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const metadata: TArgumentsMetadataCollection =
+            Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+
+        metadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: httpServerArgsKey
+        } satisfies Extract<
+            TArgumentsMetadata,
+            {
+                type: typeof httpServerArgsKey;
+            }
+        >;
+
+        Reflect.defineMetadata(argumentsKey, metadata, target.constructor, methodName);
+    };

package/src/decorators/container.ts

@@ -1,45 +1,60 @@
 import type { IModule } from "../interfaces";
 
-import { containerKey, dispatcherKey, guardKey, injectableKey, middlewareKey } from "../keys";
+import { containerKey, guardKey, injectableKey, middlewareKey, moduleKey } from "../keys";
 
 type TInstances = Array<new (...args: any[]) => any>;
 type TLoaders<TConfig extends {} = {}> = Record<
     string | symbol,
     (args: { config: TConfig }) => [string | symbol, any] | Promise<[string | symbol, any]>
 >;
+export type TContainerConfig<TConfig> =
+    | TConfig
+    | (() => TConfig | Promise<TConfig>)
+    | Readonly<{
+          key: symbol;
+          value: TConfig | (() => TConfig | Promise<TConfig>);
+      }>;
 
 export type TContainerOptions<TConfig extends {} = {}> =
-    | (Required<{
+    | Partial<{
+          config: TContainerConfig<TConfig>;
           modules: TInstances;
-      }> &
-          Partial<{
-              config: TConfig | (() => TConfig | Promise<TConfig>);
-              dependencies: TInstances;
-              loaders: TLoaders<TConfig>;
-              middlewares: TInstances;
-              guards: TInstances;
-              dispatchers: TInstances;
-          }>)
+          dependencies: TInstances;
+          loaders: TLoaders<TConfig>;
+          middlewares: TInstances;
+          guards: TInstances;
+      }>
     | undefined;
 
 export type TContainerMetadata<TConfig extends {} = {}> =
-    | (Required<{
+    | Partial<{
           modules: TInstances;
-      }> &
-          Partial<{
-              config: TConfig | ((...args: any[]) => TConfig | Promise<TConfig>);
-              dependencies: TInstances;
-              loaders: TLoaders<TConfig>;
-              middlewares: TInstances;
-              guards: TInstances;
-              dispatchers: TInstances;
-          }>)
+          config: TContainerConfig<TConfig>;
+          dependencies: TInstances;
+          loaders: TLoaders<TConfig>;
+          middlewares: TInstances;
+          guards: TInstances;
+      }>
     | undefined;
 
 export const Container =
     <TConfig extends {} = {}>(args?: TContainerOptions<TConfig>) =>
     <T extends { new (...args: any[]): IModule }>(target: T) => {
-        const { middlewares, guards, dispatchers, dependencies } = args || {};
+        const { modules, middlewares, guards, dependencies } = args || {};
+
+        if (Reflect.hasOwnMetadata(moduleKey, target)) {
+            throw new Error(
+                `Conflict detected! ${target.name} class cannot be both a Module and a Container.`
+            );
+        }
+
+        if (modules) {
+            for (let i = 0; i < modules.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(modules[i]).includes(moduleKey)) {
+                    throw Error(`${modules[i].name} is not a module.`);
+                }
+            }
+        }
 
         if (middlewares) {
             for (let i = 0; i < middlewares.length; i++) {
@@ -49,18 +64,18 @@ export const Container =
             }
         }
 
-        if (guards) {
-            for (let i = 0; i < guards.length; i++) {
-                if (!Reflect.getOwnMetadataKeys(guards[i]).includes(guardKey)) {
-                    throw Error(`${guards[i].name} is not a guard.`);
+        if (middlewares) {
+            for (let i = 0; i < middlewares.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(middlewares[i]).includes(middlewareKey)) {
+                    throw Error(`${middlewares[i].name} is not a middleware.`);
                 }
             }
         }
 
-        if (dispatchers) {
-            for (let i = 0; i < dispatchers.length; i++) {
-                if (!Reflect.getOwnMetadataKeys(dispatchers[i]).includes(dispatcherKey)) {
-                    throw Error(`${dispatchers[i].name} is not a dispatcher.`);
+        if (guards) {
+            for (let i = 0; i < guards.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(guards[i]).includes(guardKey)) {
+                    throw Error(`${guards[i].name} is not a guard.`);
                 }
             }
         }

package/src/decorators/index.ts

@@ -1,5 +1,6 @@
 export {
     Context,
+    HttpServer,
     Param,
     Params,
     Query,
@@ -10,6 +11,7 @@ export {
     ResponseHeaders,
     RouteModel
 } from "./arguments";
+export { Container } from "./container";
 export { Controller } from "./controller";
 export { Dispatcher } from "./dispatcher";
 export { Guard } from "./guard";
@@ -29,11 +31,12 @@ export { WebSocketEvent } from "./webSocketEvent";
 export { ZodSchema } from "./zodSchema";
 
 export type { TArgumentsMetadata } from "./arguments";
+export type { TContainerConfig, TContainerMetadata, TContainerOptions } from "./container";
 export type { TControllerMetadata } from "./controller";
 export type { TDispatcherMetadata } from "./dispatcher";
 export type { TGuardMetadata } from "./guard";
 export type { THttpMetadata } from "./http";
 export type { TMiddlewareMetadata } from "./middleware";
-export type { TModuleMetadata, TModuleOptions } from "./module";
+export type { TModuleConfig, TModuleMetadata, TModuleOptions } from "./module";
 export type { TWebSocketMetadata } from "./webSocket";
 export type { TWebSocketEventHandlerMetadata, TWebSocketEventMetadata } from "./webSocketEvent";

package/src/decorators/module.ts

@@ -1,6 +1,7 @@
 import type { IModule } from "../interfaces";
 
 import {
+    containerKey,
     controllerKey,
     dispatcherKey,
     guardKey,
@@ -15,10 +16,17 @@ type TLoaders<TConfig extends {} = {}> = Record<
     string | symbol,
     (args: { config: TConfig }) => [string | symbol, any] | Promise<[string | symbol, any]>
 >;
+export type TModuleConfig<TConfig> =
+    | TConfig
+    | (() => TConfig | Promise<TConfig>)
+    | Readonly<{
+          key: symbol;
+          value: TConfig | (() => TConfig | Promise<TConfig>);
+      }>;
 
 export type TModuleOptions<TConfig extends {} = {}> =
     | Partial<{
-          config: TConfig | (() => TConfig | Promise<TConfig>);
+          config: TModuleConfig<TConfig>;
           prefix: string;
           dependencies: TInstances;
           loaders: TLoaders<TConfig>;
@@ -32,7 +40,7 @@ export type TModuleOptions<TConfig extends {} = {}> =
 
 export type TModuleMetadata<TConfig extends {} = {}> =
     | Partial<{
-          config: TConfig | ((...args: any[]) => TConfig | Promise<TConfig>);
+          config: TModuleConfig<TConfig>;
           prefix: string;
           dependencies: TInstances;
           loaders: TLoaders<TConfig>;
@@ -47,6 +55,12 @@ export type TModuleMetadata<TConfig extends {} = {}> =
 export const Module =
     <TConfig extends {} = {}>(args?: TModuleOptions<TConfig>) =>
     <T extends { new (...args: any[]): IModule }>(target: T) => {
+        if (Reflect.hasOwnMetadata(containerKey, target)) {
+            throw new Error(
+                `Conflict detected! ${target.name} class cannot be both a Module and a Container.`
+            );
+        }
+
         const { middlewares, guards, dispatchers, controllers, dependencies, webSockets } =
             args || {};
 

package/src/index.ts

@@ -3,7 +3,7 @@ import "reflect-metadata";
 export type { THttpRouteModel } from "./entities";
 
 export * from "./decorators";
-export * from "./hooks";
 export * from "./http";
 export * from "./interfaces";
 export * as Keys from "./keys";
+export * from "./producers";

package/src/interfaces/context.ts

@@ -1,4 +1,11 @@
+export type TContextOptions = Partial<{
+    isStatic: boolean;
+    isPassthrough: boolean;
+}>;
+
 export interface IContext {
-    get: (key: symbol) => any;
-    set: (key: symbol, value: any) => void;
+    get: <T = unknown>(key: symbol, options?: TContextOptions) => T;
+    has: (key: symbol, options?: TContextOptions) => boolean;
+    set: <T = unknown>(key: symbol, value: T, options?: TContextOptions) => ThisType<IContext>;
+    setOptions: (options: TContextOptions) => ThisType<IContext>;
 }

package/src/interfaces/index.ts

@@ -1,4 +1,4 @@
-export type { IContext } from "./context";
+export type { IContext, TContextOptions } from "./context";
 export type { IController } from "./controller";
 export type { IDispatcher } from "./dispatcher";
 export type { IGuard } from "./guard";

package/src/keys/index.ts

@@ -32,3 +32,5 @@ export const responseHeadersArgsKey = Symbol("__bool:httpArguments:responseHeade
 export const contextArgsKey = Symbol("__bool:httpArguments:context__");
 export const routeModelArgsKey = Symbol("__bool:httpArguments:routeModel__");
 export const responseBodyArgsKey = Symbol("__bool:httpArguments:responseBody__");
+export const responseStatusArgsKey = Symbol("__bool:httpArguments:responseStatus__");
+export const responseStatusTextArgsKey = Symbol("__bool:httpArguments:responseStatusText__");

package/src/producers/context.ts

@@ -0,0 +1,63 @@
+import type { IContext, TContextOptions } from "../interfaces";
+
+export class Context implements IContext {
+    private readonly _staticMap = new Map<symbol, any>();
+    private readonly _dynamicMap = new Map<symbol, any>();
+
+    private _options?: TContextOptions = undefined;
+
+    constructor(...contexts: Array<Context>) {
+        contexts.forEach((context) => {
+            context.staticEntries.forEach(([key, value]) =>
+                this.set(key, value, { isStatic: true, isPassthrough: true })
+            );
+            context.dynamicEntries.forEach(([key, value]) =>
+                this.set(key, value, { isStatic: false })
+            );
+        });
+    }
+
+    get<T = unknown>(key: symbol, options?: TContextOptions) {
+        const temporaryOptions = options || this._options;
+
+        return !temporaryOptions?.isStatic
+            ? (this._dynamicMap.get(key) as T)
+            : (this._staticMap.get(key) as T);
+    }
+
+    has(key: symbol, options?: TContextOptions) {
+        const temporaryOptions = options || this._options;
+
+        return !temporaryOptions?.isStatic ? this._dynamicMap.has(key) : this._staticMap.has(key);
+    }
+
+    set(key: symbol, value: any, options?: TContextOptions) {
+        const temporaryOptions = options || this._options;
+
+        if (!temporaryOptions?.isStatic) {
+            this._dynamicMap.set(key, value);
+        } else {
+            if (!this._staticMap.has(key)) {
+                this._staticMap.set(key, value);
+            } else if (!temporaryOptions.isPassthrough) {
+                throw Error(`${String(key)} already exists in context static collection.`);
+            }
+        }
+
+        return this;
+    }
+
+    setOptions(options: TContextOptions) {
+        this._options = options;
+
+        return this;
+    }
+
+    get staticEntries() {
+        return [...this._staticMap.entries()];
+    }
+
+    get dynamicEntries() {
+        return [...this._dynamicMap.entries()];
+    }
+}