@forinda/kickjs-core 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Felix Orinda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/adapter.d.ts

@@ -0,0 +1,63 @@
+import { Container } from './container.js';
+import './interfaces.js';
+
+/**
+ * Where in the middleware pipeline an adapter's middleware should be inserted.
+ *
+ *   beforeGlobal  → runs before any user-defined global middleware
+ *   afterGlobal   → runs after global middleware, before module routes
+ *   beforeRoutes  → just before module routes are mounted
+ *   afterRoutes   → after module routes but before error handlers
+ */
+type MiddlewarePhase = 'beforeGlobal' | 'afterGlobal' | 'beforeRoutes' | 'afterRoutes';
+/** A middleware entry contributed by an adapter */
+interface AdapterMiddleware {
+    /** Express-compatible handler: (req, res, next) => void */
+    handler: any;
+    /** Which phase to insert into (default: 'afterGlobal') */
+    phase?: MiddlewarePhase;
+    /** Optional path to scope the middleware to (e.g. '/api/v1/auth') */
+    path?: string;
+}
+/**
+ * Adapters plug into the Application lifecycle.
+ * Implement this to add WebSocket, database, rate limiting, docs, etc.
+ *
+ * @example
+ * ```ts
+ * class RateLimitAdapter implements AppAdapter {
+ *   middleware() {
+ *     return [
+ *       { path: '/api/v1/auth', handler: rateLimit({ max: 10 }), phase: 'beforeRoutes' },
+ *       { handler: rateLimit({ max: 200 }), phase: 'beforeRoutes' },
+ *     ]
+ *   }
+ * }
+ * ```
+ */
+interface AppAdapter {
+    /** Human-readable name for logging */
+    name?: string;
+    /**
+     * Return middleware entries to be inserted into the pipeline.
+     * The `phase` controls ordering relative to global middleware and routes.
+     */
+    middleware?(): AdapterMiddleware[];
+    /** Called before global middleware — register early routes (docs UI, health) */
+    beforeMount?(app: any, container: Container): void;
+    /**
+     * Called for each module route that gets mounted.
+     * Use this to collect route metadata (e.g. for OpenAPI spec generation).
+     */
+    onRouteMount?(controllerClass: any, mountPath: string): void;
+    /** Called after modules registered, before HTTP server starts */
+    beforeStart?(app: any, container: Container): void;
+    /** Called after the HTTP server is listening — attach to the raw http.Server */
+    afterStart?(server: any, container: Container): void;
+    /** Called on shutdown — clean up connections */
+    shutdown?(): void | Promise<void>;
+}
+/** Constructor type for AppAdapter classes */
+type AppAdapterClass = new () => AppAdapter;
+
+export type { AdapterMiddleware, AppAdapter, AppAdapterClass, MiddlewarePhase };

package/dist/adapter.js

@@ -0,0 +1 @@
+//# sourceMappingURL=adapter.js.map

package/dist/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/app-module.d.ts

@@ -0,0 +1,31 @@
+import { Container } from './container.js';
+import './interfaces.js';
+
+/**
+ * Route set returned by a module's routes() method.
+ * Combined with versioning: /{apiPrefix}/v{version}{path}
+ */
+interface ModuleRoutes {
+    /** URL prefix (e.g. '/users') */
+    path: string;
+    /** Express Router instance (from buildRoutes) */
+    router: any;
+    /** Optional API version override (defaults to Application.defaultVersion) */
+    version?: number;
+    /** Controller class for OpenAPI introspection */
+    controller?: any;
+}
+/**
+ * Interface that every feature module must implement.
+ * Modules register their DI bindings and declare their routes.
+ */
+interface AppModule {
+    /** Bind interfaces to implementations in the container */
+    register(container: Container): void;
+    /** Return route definitions for this module */
+    routes(): ModuleRoutes | ModuleRoutes[];
+}
+/** Constructor type for AppModule classes */
+type AppModuleClass = new () => AppModule;
+
+export type { AppModule, AppModuleClass, ModuleRoutes };

package/dist/app-module.js

@@ -0,0 +1 @@
+//# sourceMappingURL=app-module.js.map

package/dist/app-module.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-7QVYU63E.js

@@ -0,0 +1,7 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+export {
+  __name
+};
+//# sourceMappingURL=chunk-7QVYU63E.js.map

package/dist/chunk-7QVYU63E.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-AZH3H6VS.js

@@ -0,0 +1,171 @@
+import {
+  METADATA,
+  Scope
+} from "./chunk-RYMYKGZK.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/container.ts
+import "reflect-metadata";
+function tokenName(token) {
+  if (typeof token === "symbol") return token.toString();
+  return token?.name || String(token);
+}
+__name(tokenName, "tokenName");
+var Container = class _Container {
+  static {
+    __name(this, "Container");
+  }
+  static instance;
+  registrations = /* @__PURE__ */ new Map();
+  resolving = /* @__PURE__ */ new Set();
+  /** Callback set by the decorators module to flush pending registrations */
+  static _onReady = null;
+  static getInstance() {
+    if (!_Container.instance) {
+      _Container.instance = new _Container();
+    }
+    if (_Container._onReady) {
+      _Container._onReady(_Container.instance);
+      _Container._onReady = null;
+    }
+    return _Container.instance;
+  }
+  /**
+  * Resets the container by replacing the singleton with a fresh instance.
+  * Useful for testing to ensure a clean slate between test runs.
+  */
+  static reset() {
+    _Container.instance = new _Container();
+  }
+  /** Register a class constructor under the given token */
+  register(token, target, scope = Scope.SINGLETON) {
+    this.registrations.set(token, {
+      target,
+      scope
+    });
+  }
+  /** Register a factory function under the given token */
+  registerFactory(token, factory, scope = Scope.SINGLETON) {
+    this.registrations.set(token, {
+      target: Object,
+      scope,
+      factory
+    });
+  }
+  /** Register a pre-constructed singleton instance */
+  registerInstance(token, instance) {
+    this.registrations.set(token, {
+      target: instance.constructor,
+      scope: Scope.SINGLETON,
+      instance
+    });
+  }
+  /** Check if a binding exists for the given token */
+  has(token) {
+    return this.registrations.has(token);
+  }
+  /** Resolve a dependency by its token */
+  resolve(token) {
+    const reg = this.registrations.get(token);
+    if (!reg) {
+      throw new Error(`No binding found for: ${tokenName(token)}`);
+    }
+    if (reg.scope === Scope.SINGLETON && reg.instance !== void 0) {
+      return reg.instance;
+    }
+    if (reg.factory) {
+      const instance = reg.factory();
+      if (reg.scope === Scope.SINGLETON) {
+        reg.instance = instance;
+      }
+      return instance;
+    }
+    if (this.resolving.has(token)) {
+      const chain = [
+        ...this.resolving
+      ].map(tokenName);
+      chain.push(tokenName(token));
+      throw new Error(`Circular dependency detected: ${chain.join(" -> ")}`);
+    }
+    this.resolving.add(token);
+    try {
+      const instance = this.createInstance(reg);
+      if (reg.scope === Scope.SINGLETON) {
+        reg.instance = instance;
+      }
+      return instance;
+    } finally {
+      this.resolving.delete(token);
+    }
+  }
+  /** Process all @Configuration classes and invoke their @Bean methods */
+  bootstrap() {
+    for (const [, reg] of this.registrations) {
+      const isConfig = Reflect.getMetadata(METADATA.CONFIGURATION, reg.target);
+      if (isConfig) {
+        this.processConfiguration(reg.target);
+      }
+    }
+  }
+  createInstance(reg) {
+    const paramTypes = Reflect.getMetadata(METADATA.PARAM_TYPES, reg.target) || [];
+    const args = paramTypes.map((paramType, index) => {
+      const injectTokens = Reflect.getMetadata(METADATA.INJECT, reg.target) || {};
+      const token = injectTokens[index] || paramType;
+      return this.resolve(token);
+    });
+    const instance = new reg.target(...args);
+    this.injectProperties(instance, reg.target);
+    const postConstruct = Reflect.getMetadata(METADATA.POST_CONSTRUCT, reg.target.prototype);
+    if (postConstruct && typeof instance[postConstruct] === "function") {
+      instance[postConstruct]();
+    }
+    return instance;
+  }
+  injectProperties(instance, target) {
+    const autowiredProps = Reflect.getMetadata(METADATA.AUTOWIRED, target.prototype) || /* @__PURE__ */ new Map();
+    for (const [prop, token] of autowiredProps) {
+      const resolvedToken = token || Reflect.getMetadata(METADATA.PROPERTY_TYPE, target.prototype, prop);
+      if (resolvedToken) {
+        Object.defineProperty(instance, prop, {
+          get: /* @__PURE__ */ __name(() => this.resolve(resolvedToken), "get"),
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+    const valueProps = Reflect.getMetadata(METADATA.VALUE, target.prototype) || /* @__PURE__ */ new Map();
+    for (const [prop, config] of valueProps) {
+      Object.defineProperty(instance, prop, {
+        get() {
+          const val = process.env[config.envKey];
+          if (val !== void 0) return val;
+          if (config.defaultValue !== void 0) return config.defaultValue;
+          throw new Error(`@Value('${config.envKey}'): Environment variable "${config.envKey}" is not set and no default was provided.`);
+        },
+        enumerable: true,
+        configurable: true
+      });
+    }
+  }
+  processConfiguration(target) {
+    const instance = this.resolve(target);
+    const prototype = target.prototype;
+    for (const key of Object.getOwnPropertyNames(prototype)) {
+      if (key === "constructor") continue;
+      const beanMeta = Reflect.getMetadata(METADATA.BEAN, prototype, key);
+      if (!beanMeta) continue;
+      const options = Reflect.getMetadata(METADATA.BEAN_OPTIONS, prototype, key) || {};
+      const returnType = Reflect.getMetadata(METADATA.RETURN_TYPE, prototype, key);
+      const token = returnType || key;
+      this.registerFactory(token, () => instance[key](), options.scope || Scope.SINGLETON);
+    }
+  }
+};
+
+export {
+  Container
+};
+//# sourceMappingURL=chunk-AZH3H6VS.js.map

package/dist/chunk-AZH3H6VS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/container.ts"],"sourcesContent":["import 'reflect-metadata'\nimport { Constructor, Scope, METADATA } from './interfaces'\n\n/** Internal registration entry that tracks how a dependency should be resolved */\ninterface Registration {\n  target: Constructor\n  scope: Scope\n  instance?: any\n  factory?: () => any\n}\n\n/** Format a token for display in error messages */\nfunction tokenName(token: any): string {\n  if (typeof token === 'symbol') return token.toString()\n  return token?.name || String(token)\n}\n\n/**\n * Inversion-of-Control (IoC) container that manages dependency registration,\n * resolution, and lifecycle. Implements the Singleton pattern so all parts of\n * the application share a single container instance.\n *\n * Supports constructor injection, property injection (@Autowired),\n * factory-based beans (@Bean), and lifecycle hooks (@PostConstruct).\n */\nexport class Container {\n  private static instance: Container\n  private registrations = new Map<any, Registration>()\n  private resolving = new Set<any>()\n\n  /** Callback set by the decorators module to flush pending registrations */\n  static _onReady: ((container: Container) => void) | null = null\n\n  static getInstance(): Container {\n    if (!Container.instance) {\n      Container.instance = new Container()\n    }\n    // Flush any decorator registrations that queued before the container existed\n    if (Container._onReady) {\n      Container._onReady(Container.instance)\n      Container._onReady = null\n    }\n    return Container.instance\n  }\n\n  /**\n   * Resets the container by replacing the singleton with a fresh instance.\n   * Useful for testing to ensure a clean slate between test runs.\n   */\n  static reset(): void {\n    Container.instance = new Container()\n  }\n\n  /** Register a class constructor under the given token */\n  register(token: any, target: Constructor, scope: Scope = Scope.SINGLETON): void {\n    this.registrations.set(token, { target, scope })\n  }\n\n  /** Register a factory function under the given token */\n  registerFactory(token: any, factory: () => any, scope: Scope = Scope.SINGLETON): void {\n    this.registrations.set(token, { target: Object as any, scope, factory })\n  }\n\n  /** Register a pre-constructed singleton instance */\n  registerInstance(token: any, instance: any): void {\n    this.registrations.set(token, {\n      target: instance.constructor,\n      scope: Scope.SINGLETON,\n      instance,\n    })\n  }\n\n  /** Check if a binding exists for the given token */\n  has(token: any): boolean {\n    return this.registrations.has(token)\n  }\n\n  /** Resolve a dependency by its token */\n  resolve<T = any>(token: any): T {\n    const reg = this.registrations.get(token)\n    if (!reg) {\n      throw new Error(`No binding found for: ${tokenName(token)}`)\n    }\n\n    if (reg.scope === Scope.SINGLETON && reg.instance !== undefined) {\n      return reg.instance\n    }\n\n    if (reg.factory) {\n      const instance = reg.factory()\n      if (reg.scope === Scope.SINGLETON) {\n        reg.instance = instance\n      }\n      return instance\n    }\n\n    if (this.resolving.has(token)) {\n      const chain = [...this.resolving].map(tokenName)\n      chain.push(tokenName(token))\n      throw new Error(`Circular dependency detected: ${chain.join(' -> ')}`)\n    }\n    this.resolving.add(token)\n\n    try {\n      const instance = this.createInstance(reg)\n      if (reg.scope === Scope.SINGLETON) {\n        reg.instance = instance\n      }\n      return instance\n    } finally {\n      this.resolving.delete(token)\n    }\n  }\n\n  /** Process all @Configuration classes and invoke their @Bean methods */\n  bootstrap(): void {\n    for (const [, reg] of this.registrations) {\n      const isConfig = Reflect.getMetadata(METADATA.CONFIGURATION, reg.target)\n      if (isConfig) {\n        this.processConfiguration(reg.target)\n      }\n    }\n  }\n\n  private createInstance(reg: Registration): any {\n    const paramTypes: Constructor[] = Reflect.getMetadata(METADATA.PARAM_TYPES, reg.target) || []\n\n    const args = paramTypes.map((paramType, index) => {\n      // Check for @Inject token override on constructor parameter\n      const injectTokens: Record<number, any> =\n        Reflect.getMetadata(METADATA.INJECT, reg.target) || {}\n      const token = injectTokens[index] || paramType\n      return this.resolve(token)\n    })\n\n    const instance = new reg.target(...args)\n\n    // Property injection via @Autowired\n    this.injectProperties(instance, reg.target)\n\n    // @PostConstruct lifecycle hook\n    const postConstruct = Reflect.getMetadata(METADATA.POST_CONSTRUCT, reg.target.prototype)\n    if (postConstruct && typeof instance[postConstruct] === 'function') {\n      instance[postConstruct]()\n    }\n\n    return instance\n  }\n\n  private injectProperties(instance: any, target: Constructor): void {\n    // @Autowired — lazy DI property injection\n    const autowiredProps: Map<string, any> =\n      Reflect.getMetadata(METADATA.AUTOWIRED, target.prototype) || new Map()\n\n    for (const [prop, token] of autowiredProps) {\n      const resolvedToken =\n        token || Reflect.getMetadata(METADATA.PROPERTY_TYPE, target.prototype, prop)\n      if (resolvedToken) {\n        Object.defineProperty(instance, prop, {\n          get: () => this.resolve(resolvedToken),\n          enumerable: true,\n          configurable: true,\n        })\n      }\n    }\n\n    // @Value — lazy environment variable injection\n    const valueProps: Map<string, { envKey: string; defaultValue?: any }> =\n      Reflect.getMetadata(METADATA.VALUE, target.prototype) || new Map()\n\n    for (const [prop, config] of valueProps) {\n      Object.defineProperty(instance, prop, {\n        get() {\n          const val = process.env[config.envKey]\n          if (val !== undefined) return val\n          if (config.defaultValue !== undefined) return config.defaultValue\n          throw new Error(\n            `@Value('${config.envKey}'): Environment variable \"${config.envKey}\" is not set and no default was provided.`,\n          )\n        },\n        enumerable: true,\n        configurable: true,\n      })\n    }\n  }\n\n  private processConfiguration(target: Constructor): void {\n    const instance = this.resolve(target)\n    const prototype = target.prototype\n\n    for (const key of Object.getOwnPropertyNames(prototype)) {\n      if (key === 'constructor') continue\n      const beanMeta = Reflect.getMetadata(METADATA.BEAN, prototype, key)\n      if (!beanMeta) continue\n\n      const options = Reflect.getMetadata(METADATA.BEAN_OPTIONS, prototype, key) || {}\n      const returnType = Reflect.getMetadata(METADATA.RETURN_TYPE, prototype, key)\n      const token = returnType || key\n\n      this.registerFactory(token, () => instance[key](), options.scope || Scope.SINGLETON)\n    }\n  }\n}\n"],"mappings":"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","names":["tokenName","token","toString","name","String","Container","instance","registrations","Map","resolving","Set","_onReady","getInstance","reset","register","target","scope","Scope","SINGLETON","set","registerFactory","factory","Object","registerInstance","has","resolve","reg","get","Error","undefined","chain","map","push","join","add","createInstance","delete","bootstrap","isConfig","Reflect","getMetadata","METADATA","CONFIGURATION","processConfiguration","paramTypes","PARAM_TYPES","args","paramType","index","injectTokens","INJECT","injectProperties","postConstruct","POST_CONSTRUCT","prototype","autowiredProps","AUTOWIRED","prop","resolvedToken","PROPERTY_TYPE","defineProperty","enumerable","configurable","valueProps","VALUE","config","val","process","env","envKey","defaultValue","key","getOwnPropertyNames","beanMeta","BEAN","options","BEAN_OPTIONS","returnType","RETURN_TYPE"]}

package/dist/chunk-GAO2TPCH.js

@@ -0,0 +1,230 @@
+import {
+  Container
+} from "./chunk-AZH3H6VS.js";
+import {
+  METADATA,
+  Scope
+} from "./chunk-RYMYKGZK.js";
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/decorators.ts
+import "reflect-metadata";
+var pendingRegistrations = [];
+var containerRef = null;
+function flushPending(container) {
+  containerRef = container;
+  for (const { target, scope } of pendingRegistrations) {
+    if (!container.has(target)) {
+      container.register(target, target, scope);
+    }
+  }
+  pendingRegistrations.length = 0;
+}
+__name(flushPending, "flushPending");
+Container._onReady = flushPending;
+function registerInContainer(target, scope) {
+  Reflect.defineMetadata(METADATA.INJECTABLE, true, target);
+  Reflect.defineMetadata(METADATA.SCOPE, scope, target);
+  if (containerRef) {
+    if (!containerRef.has(target)) {
+      containerRef.register(target, target, scope);
+    }
+  } else {
+    pendingRegistrations.push({
+      target,
+      scope
+    });
+  }
+}
+__name(registerInContainer, "registerInContainer");
+function Injectable(options) {
+  return (target) => {
+    registerInContainer(target, options?.scope ?? Scope.SINGLETON);
+  };
+}
+__name(Injectable, "Injectable");
+function Service(options) {
+  return (target) => {
+    registerInContainer(target, options?.scope ?? Scope.SINGLETON);
+  };
+}
+__name(Service, "Service");
+function Component(options) {
+  return (target) => {
+    registerInContainer(target, options?.scope ?? Scope.SINGLETON);
+  };
+}
+__name(Component, "Component");
+function Repository(options) {
+  return (target) => {
+    registerInContainer(target, options?.scope ?? Scope.SINGLETON);
+  };
+}
+__name(Repository, "Repository");
+function Configuration() {
+  return (target) => {
+    registerInContainer(target, Scope.SINGLETON);
+    Reflect.defineMetadata(METADATA.CONFIGURATION, true, target);
+  };
+}
+__name(Configuration, "Configuration");
+function Controller(path) {
+  return (target) => {
+    registerInContainer(target, Scope.SINGLETON);
+    Reflect.defineMetadata(METADATA.CONTROLLER_PATH, path || "/", target);
+  };
+}
+__name(Controller, "Controller");
+function Bean(options) {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(METADATA.BEAN, true, target, propertyKey);
+    if (options) {
+      Reflect.defineMetadata(METADATA.BEAN_OPTIONS, options, target, propertyKey);
+    }
+  };
+}
+__name(Bean, "Bean");
+function PostConstruct() {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(METADATA.POST_CONSTRUCT, propertyKey, target);
+  };
+}
+__name(PostConstruct, "PostConstruct");
+function Transactional() {
+  return (_target, _propertyKey, descriptor) => {
+    const original = descriptor.value;
+    descriptor.value = async function(...args) {
+      if (!containerRef) {
+        throw new Error("@Transactional: Container not initialized. Call bootstrap() first.");
+      }
+      const txManager = containerRef.resolve(/* @__PURE__ */ Symbol.for("TransactionManager"));
+      const tx = await txManager.begin();
+      try {
+        const result = await original.apply(this, args);
+        await txManager.commit(tx);
+        return result;
+      } catch (err) {
+        await txManager.rollback(tx);
+        throw err;
+      }
+    };
+    return descriptor;
+  };
+}
+__name(Transactional, "Transactional");
+function Autowired(token) {
+  return (target, propertyKey) => {
+    const existing = Reflect.getMetadata(METADATA.AUTOWIRED, target) || /* @__PURE__ */ new Map();
+    existing.set(propertyKey, token);
+    Reflect.defineMetadata(METADATA.AUTOWIRED, existing, target);
+  };
+}
+__name(Autowired, "Autowired");
+function Inject(token) {
+  return (target, _propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata(METADATA.INJECT, target) || {};
+    existing[parameterIndex] = token;
+    Reflect.defineMetadata(METADATA.INJECT, existing, target);
+  };
+}
+__name(Inject, "Inject");
+function Value(envKey, defaultValue) {
+  return (target, propertyKey) => {
+    const existing = Reflect.getMetadata(METADATA.VALUE, target) || /* @__PURE__ */ new Map();
+    existing.set(propertyKey, {
+      envKey,
+      defaultValue
+    });
+    Reflect.defineMetadata(METADATA.VALUE, existing, target);
+  };
+}
+__name(Value, "Value");
+function createRouteDecorator(method) {
+  return (path, validation) => {
+    return (target, propertyKey) => {
+      const routes = Reflect.getMetadata(METADATA.ROUTES, target.constructor) || [];
+      routes.push({
+        method,
+        path: path || "/",
+        handlerName: propertyKey,
+        validation
+      });
+      Reflect.defineMetadata(METADATA.ROUTES, routes, target.constructor);
+    };
+  };
+}
+__name(createRouteDecorator, "createRouteDecorator");
+var Get = createRouteDecorator("GET");
+var Post = createRouteDecorator("POST");
+var Put = createRouteDecorator("PUT");
+var Delete = createRouteDecorator("DELETE");
+var Patch = createRouteDecorator("PATCH");
+function Middleware(...handlers) {
+  return (target, propertyKey) => {
+    if (propertyKey) {
+      const existing = Reflect.getMetadata(METADATA.METHOD_MIDDLEWARES, target.constructor, propertyKey) || [];
+      Reflect.defineMetadata(METADATA.METHOD_MIDDLEWARES, [
+        ...existing,
+        ...handlers
+      ], target.constructor, propertyKey);
+    } else {
+      const existing = Reflect.getMetadata(METADATA.CLASS_MIDDLEWARES, target) || [];
+      Reflect.defineMetadata(METADATA.CLASS_MIDDLEWARES, [
+        ...existing,
+        ...handlers
+      ], target);
+    }
+  };
+}
+__name(Middleware, "Middleware");
+function FileUpload(config) {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(METADATA.FILE_UPLOAD, config, target.constructor, propertyKey);
+  };
+}
+__name(FileUpload, "FileUpload");
+function Builder(target) {
+  Reflect.defineMetadata(METADATA.BUILDER, true, target);
+  target.builder = function() {
+    const props = {};
+    const proxy = new Proxy({}, {
+      get(_, key) {
+        if (key === "build") {
+          return () => Object.assign(new target(), props);
+        }
+        return (value) => {
+          props[key] = value;
+          return proxy;
+        };
+      }
+    });
+    return proxy;
+  };
+}
+__name(Builder, "Builder");
+
+export {
+  Injectable,
+  Service,
+  Component,
+  Repository,
+  Configuration,
+  Controller,
+  Bean,
+  PostConstruct,
+  Transactional,
+  Autowired,
+  Inject,
+  Value,
+  Get,
+  Post,
+  Put,
+  Delete,
+  Patch,
+  Middleware,
+  FileUpload,
+  Builder
+};
+//# sourceMappingURL=chunk-GAO2TPCH.js.map

package/dist/chunk-GAO2TPCH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/decorators.ts"],"sourcesContent":["import 'reflect-metadata'\nimport { METADATA, Scope, type BeanOptions, type ServiceOptions } from './interfaces'\nimport { Container } from './container'\n\n// ── Deferred Registration Queue ─────────────────────────────────────────\n// Decorators execute at class-definition time (module load). The Container\n// may not exist yet when the first decorator fires. We queue registrations\n// and flush them on first Container.getInstance() call.\n\ntype PendingRegistration = { target: any; scope: Scope }\nconst pendingRegistrations: PendingRegistration[] = []\nlet containerRef: any = null\n\nfunction flushPending(container: any): void {\n  containerRef = container\n  for (const { target, scope } of pendingRegistrations) {\n    if (!container.has(target)) {\n      container.register(target, target, scope)\n    }\n  }\n  pendingRegistrations.length = 0\n}\n\n// Wire up synchronously — Container._onReady is called on first getInstance()\nContainer._onReady = flushPending\n\n// ── Class Decorators ────────────────────────────────────────────────────\n\nfunction registerInContainer(target: any, scope: Scope): void {\n  Reflect.defineMetadata(METADATA.INJECTABLE, true, target)\n  Reflect.defineMetadata(METADATA.SCOPE, scope, target)\n\n  if (containerRef) {\n    // Container already initialized — register immediately\n    if (!containerRef.has(target)) {\n      containerRef.register(target, target, scope)\n    }\n  } else {\n    // Container not ready yet — queue for later\n    pendingRegistrations.push({ target, scope })\n  }\n}\n\n/** Mark a class as injectable with lifecycle scope */\nexport function Injectable(options?: ServiceOptions): ClassDecorator {\n  return (target: any) => {\n    registerInContainer(target, options?.scope ?? Scope.SINGLETON)\n  }\n}\n\n/** Mark a class as a service (semantic alias for Injectable) */\nexport function Service(options?: ServiceOptions): ClassDecorator {\n  return (target: any) => {\n    registerInContainer(target, options?.scope ?? Scope.SINGLETON)\n  }\n}\n\n/** Mark a class as a generic managed component */\nexport function Component(options?: ServiceOptions): ClassDecorator {\n  return (target: any) => {\n    registerInContainer(target, options?.scope ?? Scope.SINGLETON)\n  }\n}\n\n/** Mark a class as a repository */\nexport function Repository(options?: ServiceOptions): ClassDecorator {\n  return (target: any) => {\n    registerInContainer(target, options?.scope ?? Scope.SINGLETON)\n  }\n}\n\n/** Mark a class as a configuration provider for @Bean methods */\nexport function Configuration(): ClassDecorator {\n  return (target: any) => {\n    registerInContainer(target, Scope.SINGLETON)\n    Reflect.defineMetadata(METADATA.CONFIGURATION, true, target)\n  }\n}\n\n/** Mark a class as an HTTP controller with an optional route prefix */\nexport function Controller(path?: string): ClassDecorator {\n  return (target: any) => {\n    registerInContainer(target, Scope.SINGLETON)\n    Reflect.defineMetadata(METADATA.CONTROLLER_PATH, path || '/', target)\n  }\n}\n\n// ── Method Decorators ───────────────────────────────────────────────────\n\n/** Mark a method inside @Configuration as a bean factory */\nexport function Bean(options?: BeanOptions): MethodDecorator {\n  return (target, propertyKey) => {\n    Reflect.defineMetadata(METADATA.BEAN, true, target, propertyKey)\n    if (options) {\n      Reflect.defineMetadata(METADATA.BEAN_OPTIONS, options, target, propertyKey)\n    }\n  }\n}\n\n/** Mark a method as a lifecycle hook called after instantiation */\nexport function PostConstruct(): MethodDecorator {\n  return (target, propertyKey) => {\n    Reflect.defineMetadata(METADATA.POST_CONSTRUCT, propertyKey, target)\n  }\n}\n\n/** Wrap a method in a database transaction with auto commit/rollback */\nexport function Transactional(): MethodDecorator {\n  return (_target, _propertyKey, descriptor: PropertyDescriptor) => {\n    const original = descriptor.value\n    descriptor.value = async function (this: any, ...args: any[]) {\n      if (!containerRef) {\n        throw new Error('@Transactional: Container not initialized. Call bootstrap() first.')\n      }\n      const txManager = containerRef.resolve(Symbol.for('TransactionManager'))\n      const tx = await txManager.begin()\n      try {\n        const result = await original.apply(this, args)\n        await txManager.commit(tx)\n        return result\n      } catch (err) {\n        await txManager.rollback(tx)\n        throw err\n      }\n    }\n    return descriptor\n  }\n}\n\n// ── Property Decorators ─────────────────────────────────────────────────\n\n/** Property injection — resolved lazily from the container */\nexport function Autowired(token?: any): PropertyDecorator {\n  return (target, propertyKey) => {\n    const existing: Map<string, any> = Reflect.getMetadata(METADATA.AUTOWIRED, target) || new Map()\n    existing.set(propertyKey as string, token)\n    Reflect.defineMetadata(METADATA.AUTOWIRED, existing, target)\n  }\n}\n\n/** Constructor parameter injection with explicit token */\nexport function Inject(token: any): ParameterDecorator {\n  return (target, _propertyKey, parameterIndex) => {\n    const existing: Record<number, any> = Reflect.getMetadata(METADATA.INJECT, target) || {}\n    existing[parameterIndex] = token\n    Reflect.defineMetadata(METADATA.INJECT, existing, target)\n  }\n}\n\n/**\n * Inject an environment variable value. Evaluated lazily so the env\n * is available at access time, not at decoration time.\n *\n * If no default is provided and the env var is missing, throws at access time\n * to catch misconfiguration early instead of returning undefined.\n *\n * Uses metadata + instance getter to work correctly with `useDefineForClassFields`.\n */\nexport function Value(envKey: string, defaultValue?: any): PropertyDecorator {\n  return (target, propertyKey) => {\n    const existing: Map<string, { envKey: string; defaultValue?: any }> =\n      Reflect.getMetadata(METADATA.VALUE, target) || new Map()\n    existing.set(propertyKey as string, { envKey, defaultValue })\n    Reflect.defineMetadata(METADATA.VALUE, existing, target)\n  }\n}\n\n// ── HTTP Route Decorators ───────────────────────────────────────────────\n\nexport interface RouteDefinition {\n  method: string\n  path: string\n  handlerName: string\n  validation?: {\n    body?: any\n    query?: any\n    params?: any\n  }\n}\n\nfunction createRouteDecorator(method: string) {\n  return (path?: string, validation?: RouteDefinition['validation']): MethodDecorator => {\n    return (target, propertyKey) => {\n      const routes: RouteDefinition[] =\n        Reflect.getMetadata(METADATA.ROUTES, target.constructor) || []\n      routes.push({\n        method,\n        path: path || '/',\n        handlerName: propertyKey as string,\n        validation,\n      })\n      Reflect.defineMetadata(METADATA.ROUTES, routes, target.constructor)\n    }\n  }\n}\n\nexport const Get = createRouteDecorator('GET')\nexport const Post = createRouteDecorator('POST')\nexport const Put = createRouteDecorator('PUT')\nexport const Delete = createRouteDecorator('DELETE')\nexport const Patch = createRouteDecorator('PATCH')\n\n// ── Middleware Decorators ───────────────────────────────────────────────\n\nexport type MiddlewareHandler = (ctx: any, next: () => void) => void | Promise<void>\n\n/** Attach middleware handlers to a class or method */\nexport function Middleware(...handlers: MiddlewareHandler[]): ClassDecorator & MethodDecorator {\n  return (target: any, propertyKey?: string | symbol) => {\n    if (propertyKey) {\n      // Method-level middleware\n      const existing: MiddlewareHandler[] =\n        Reflect.getMetadata(METADATA.METHOD_MIDDLEWARES, target.constructor, propertyKey) || []\n      Reflect.defineMetadata(\n        METADATA.METHOD_MIDDLEWARES,\n        [...existing, ...handlers],\n        target.constructor,\n        propertyKey,\n      )\n    } else {\n      // Class-level middleware\n      const existing: MiddlewareHandler[] =\n        Reflect.getMetadata(METADATA.CLASS_MIDDLEWARES, target) || []\n      Reflect.defineMetadata(METADATA.CLASS_MIDDLEWARES, [...existing, ...handlers], target)\n    }\n  }\n}\n\n// ── File Upload Decorator ───────────────────────────────────────────────\n\nexport interface FileUploadConfig {\n  mode: 'single' | 'array' | 'none'\n  fieldName?: string\n  maxCount?: number\n  maxSize?: number\n  allowedMimeTypes?: string[]\n}\n\n/** Configure file upload handling for a controller method */\nexport function FileUpload(config: FileUploadConfig): MethodDecorator {\n  return (target, propertyKey) => {\n    Reflect.defineMetadata(METADATA.FILE_UPLOAD, config, target.constructor, propertyKey)\n  }\n}\n\n// ── Builder Decorator ───────────────────────────────────────────────────\n\n/** Add a static builder() method for fluent construction */\nexport function Builder(target: any): void {\n  Reflect.defineMetadata(METADATA.BUILDER, true, target)\n\n  target.builder = function () {\n    const props: Record<string, any> = {}\n    const proxy: any = new Proxy(\n      {},\n      {\n        get(_, key) {\n          if (key === 'build') {\n            return () => Object.assign(new target(), props)\n          }\n          return (value: any) => {\n            props[key as string] = value\n            return proxy\n          }\n        },\n      },\n    )\n    return proxy\n  }\n}\n"],"mappings":"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","names":["pendingRegistrations","containerRef","flushPending","container","target","scope","has","register","length","Container","_onReady","registerInContainer","Reflect","defineMetadata","METADATA","INJECTABLE","SCOPE","push","Injectable","options","Scope","SINGLETON","Service","Component","Repository","Configuration","CONFIGURATION","Controller","path","CONTROLLER_PATH","Bean","propertyKey","BEAN","BEAN_OPTIONS","PostConstruct","POST_CONSTRUCT","Transactional","_target","_propertyKey","descriptor","original","value","args","Error","txManager","resolve","Symbol","for","tx","begin","result","apply","commit","err","rollback","Autowired","token","existing","getMetadata","AUTOWIRED","Map","set","Inject","parameterIndex","INJECT","Value","envKey","defaultValue","VALUE","createRouteDecorator","method","validation","routes","ROUTES","handlerName","Get","Post","Put","Delete","Patch","Middleware","handlers","METHOD_MIDDLEWARES","CLASS_MIDDLEWARES","FileUpload","config","FILE_UPLOAD","Builder","BUILDER","builder","props","proxy","Proxy","get","_","key","Object","assign"]}