@kanjijs/core 0.2.0-beta.12 → 0.2.0-beta.14

package/dist/context.d.ts

@@ -0,0 +1,7 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+export interface RequestContext {
+    requestId: string;
+    [key: string]: any;
+}
+export declare const kanjijsContext: AsyncLocalStorage<RequestContext>;
+export declare function getRequestId(): string | undefined;

package/dist/decorators.d.ts

@@ -0,0 +1,29 @@
+import type { ContractSpec } from "@kanjijs/contracts";
+import { type ModuleMetadata } from "./metadata";
+/**
+ * @Module({ controllers: [...] })
+ */
+export declare function Module(metadata: ModuleMetadata): ClassDecorator;
+/**
+ * @Contract({ ... })
+ */
+export declare function Contract(spec: ContractSpec): MethodDecorator;
+/**
+ * @Controller('/users')
+ */
+export declare function Controller(prefix?: string): ClassDecorator;
+export declare function Injectable(): ClassDecorator;
+export declare const Get: (path?: string) => MethodDecorator;
+export declare const Post: (path?: string) => MethodDecorator;
+export declare const Put: (path?: string) => MethodDecorator;
+export declare const Delete: (path?: string) => MethodDecorator;
+export declare const Patch: (path?: string) => MethodDecorator;
+/**
+ * @Inject("DATABASE_CLIENT")
+ */
+export declare function Inject(token: any): ParameterDecorator;
+/**
+ * @Use(middleware1, middleware2)
+ * Attaches middlewares to a controller or method.
+ */
+export declare function Use(...middlewares: any[]): MethodDecorator & ClassDecorator;

package/dist/di/container.d.ts

@@ -0,0 +1,26 @@
+import { type Constructor } from "../metadata";
+import "reflect-metadata";
+export declare class KanjijsIoC {
+    private static providers;
+    static register<T>(target: Constructor<T>): void;
+    static register(token: any, provider: {
+        useValue?: any;
+        useClass?: Constructor;
+    }): void;
+    static resolve<T>(target: Constructor<T> | any): T;
+    static clear(): void;
+}
+/**
+ * V2 STRICT CONTAINER
+ * Instance-based, no auto-registration, explicit visibility.
+ */
+export declare class Container {
+    private providers;
+    register(token: any, provider: {
+        useValue?: any;
+        useClass?: Constructor;
+        useFactory?: Function;
+        inject?: any[];
+    }): void;
+    resolve<T>(token: Constructor<T> | any): T;
+}

package/dist/di/module-compiler.d.ts

@@ -0,0 +1,11 @@
+import { type Constructor } from "../metadata";
+import { Container } from "./container";
+export declare class ModuleCompiler {
+    private nodes;
+    private globalExportedTokens;
+    compile(rootModule: Constructor): Container;
+    private scan;
+    private processProviders;
+    private validate;
+    private checkDependencies;
+}

package/dist/exceptions/exception.filter.d.ts

@@ -0,0 +1,3 @@
+export interface ExceptionFilter<T = any, C = any> {
+    catch(exception: T, context: C): void | Promise<void> | any;
+}

package/dist/exceptions/http.exception.d.ts

@@ -0,0 +1,7 @@
+export declare class HttpException extends Error {
+    readonly response: string | object;
+    readonly status: number;
+    constructor(response: string | object, status: number);
+    getResponse(): string | object;
+    getStatus(): number;
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./decorators";
+export * from "./metadata";
+export * from "./di/container";
+export * from "./context";
+export * from "./exceptions/http.exception";
+export * from "./exceptions/exception.filter";
+export * from "./di/module-compiler";
+export * from "@kanjijs/contracts";
+export declare const GLOBAL_MIDDLEWARE_TOKEN: unique symbol;

package/dist/index.js

@@ -1336,7 +1336,7 @@ class ModuleCompiler {
       const paramTypes = Reflect.getMetadata("design:paramtypes", clazz) || [];
       const injectionTokens = MetadataStorage.getInjections(clazz) || new Map;
       dependencies = paramTypes.map((t, i) => injectionTokens.get(i) || t);
-    } else if ("useFactory" in provider && provider.useFactory) {
+    } else if ("useFactory" in provider) {
       targetName = provider.provide?.name || String(provider.provide);
       dependencies = provider.inject || [];
     }

package/dist/metadata.d.ts

@@ -0,0 +1,56 @@
+import type { ContractSpec } from "@kanjijs/contracts";
+import "reflect-metadata";
+export type Constructor<T = any> = new (...args: any[]) => T;
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+export interface RouteMetadata {
+    method: HttpMethod;
+    path: string;
+    contract?: ContractSpec;
+    middlewares?: any[];
+}
+export interface ControllerMetadata {
+    prefix: string;
+    middlewares?: any[];
+}
+export type Token<T = any> = string | symbol | Constructor<T>;
+export type Provider<T = any> = Constructor<T> | {
+    provide: Token<T>;
+    useValue: T;
+} | {
+    provide: Token<T>;
+    useClass: Constructor<T>;
+} | {
+    provide: Token<T>;
+    useFactory: (...args: any[]) => T | Promise<T>;
+    inject?: Token[];
+};
+export interface DynamicModule {
+    module: Constructor;
+    providers?: Provider[];
+    imports?: Array<Constructor | DynamicModule>;
+    exports?: Token[];
+    global?: boolean;
+}
+export interface ModuleMetadata {
+    controllers?: Constructor[];
+    providers?: Provider[];
+    imports?: Array<Constructor | DynamicModule>;
+    exports?: Token[];
+    global?: boolean;
+}
+export interface IMetadataStorage {
+    addRoute(target: object, methodName: string, meta: RouteMetadata): void;
+    addContract(target: object, methodName: string, contract: ContractSpec): void;
+    addMiddleware(target: object, middleware: any, methodName?: string): void;
+    getRoutes(target: object): Map<string, RouteMetadata> | undefined;
+    setController(target: object, meta: ControllerMetadata): void;
+    getController(target: object): ControllerMetadata | undefined;
+    defineModule(target: object, meta: ModuleMetadata): void;
+    getModule(target: object): ModuleMetadata | undefined;
+    addInjection(target: object, index: number, token: any): void;
+    getInjections(target: object): Map<number, any> | undefined;
+}
+declare global {
+    var KANJI_METADATA_STORAGE: IMetadataStorage | undefined;
+}
+export declare const MetadataStorage: IMetadataStorage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kanjijs/core",
-  "version": "0.2.0-beta.12",
+  "version": "0.2.0-beta.14",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -10,12 +10,12 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target bun",
+    "build": "bun build src/index.ts --outdir dist --target bun && tsc --emitDeclarationOnly --declaration --outDir dist && tsc --emitDeclarationOnly --declaration --outDir dist",
     "test": "bun test"
   },
   "dependencies": {
-    "@kanjijs/common": "^0.2.0-beta.12",
-    "@kanjijs/contracts": "^0.2.0-beta.12",
+    "@kanjijs/common": "^0.2.0-beta.14",
+    "@kanjijs/contracts": "^0.2.0-beta.14",
     "reflect-metadata": "^0.2.0"
   },
   "devDependencies": {