@forinda/kickjs-core 0.3.0

package/dist/chunk-IHZOCBCK.js

@@ -0,0 +1,75 @@
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/logger.ts
+import pino from "pino";
+var isDev = process.env.NODE_ENV !== "production";
+var rootLogger = pino({
+  level: process.env.LOG_LEVEL || "info",
+  ...isDev ? {
+    transport: {
+      target: "pino-pretty",
+      options: {
+        colorize: true,
+        translateTime: "SYS:HH:MM:ss.l"
+      }
+    }
+  } : {}
+});
+var loggerCache = /* @__PURE__ */ new Map();
+var Logger = class _Logger {
+  static {
+    __name(this, "Logger");
+  }
+  log;
+  constructor(name) {
+    this.log = name ? rootLogger.child({
+      component: name
+    }) : rootLogger;
+  }
+  /** Create or retrieve a cached named logger */
+  static for(name) {
+    let cached = loggerCache.get(name);
+    if (!cached) {
+      cached = new _Logger(name);
+      loggerCache.set(name, cached);
+    }
+    return cached;
+  }
+  /** Create a child logger with a sub-component name */
+  child(name) {
+    return new _Logger(name);
+  }
+  info(msg, ...args) {
+    this.log.info(msg, ...args);
+  }
+  warn(msg, ...args) {
+    this.log.warn(msg, ...args);
+  }
+  error(msgOrObj, msg, ...args) {
+    this.log.error(msgOrObj, msg, ...args);
+  }
+  debug(msg, ...args) {
+    this.log.debug(msg, ...args);
+  }
+  trace(msg, ...args) {
+    this.log.trace(msg, ...args);
+  }
+  fatal(msg, ...args) {
+    this.log.fatal(msg, ...args);
+  }
+};
+function createLogger(name) {
+  return Logger.for(name);
+}
+__name(createLogger, "createLogger");
+var logger = rootLogger;
+
+export {
+  rootLogger,
+  Logger,
+  createLogger,
+  logger
+};
+//# sourceMappingURL=chunk-IHZOCBCK.js.map

package/dist/chunk-IHZOCBCK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/logger.ts"],"sourcesContent":["import pino from 'pino'\n\nconst isDev = process.env.NODE_ENV !== 'production'\n\n/** Root pino logger instance */\nexport const rootLogger = pino({\n  level: process.env.LOG_LEVEL || 'info',\n  ...(isDev\n    ? {\n        transport: {\n          target: 'pino-pretty',\n          options: { colorize: true, translateTime: 'SYS:HH:MM:ss.l' },\n        },\n      }\n    : {}),\n})\n\n/** Cache of named loggers to avoid creating duplicates */\nconst loggerCache = new Map<string, Logger>()\n\n/**\n * Named logger with component context.\n *\n * @example\n * ```ts\n * // Static factory — preferred\n * const log = Logger.for('UserService')\n * log.info('User created')\n * // Output: [UserService] User created\n *\n * // Shorthand function\n * const log = createLogger('OrderService')\n *\n * // Injectable — auto-named from class\n * class MyService {\n *   @Autowired() private logger!: Logger\n *   // or inject a named one:\n *   private log = Logger.for('MyService')\n * }\n * ```\n */\nexport class Logger {\n  private log: pino.Logger\n\n  constructor(name?: string) {\n    this.log = name ? rootLogger.child({ component: name }) : rootLogger\n  }\n\n  /** Create or retrieve a cached named logger */\n  static for(name: string): Logger {\n    let cached = loggerCache.get(name)\n    if (!cached) {\n      cached = new Logger(name)\n      loggerCache.set(name, cached)\n    }\n    return cached\n  }\n\n  /** Create a child logger with a sub-component name */\n  child(name: string): Logger {\n    return new Logger(name)\n  }\n\n  info(msg: string, ...args: any[]) {\n    this.log.info(msg, ...args)\n  }\n\n  warn(msg: string, ...args: any[]) {\n    this.log.warn(msg, ...args)\n  }\n\n  error(msgOrObj: any, msg?: string, ...args: any[]) {\n    this.log.error(msgOrObj, msg, ...args)\n  }\n\n  debug(msg: string, ...args: any[]) {\n    this.log.debug(msg, ...args)\n  }\n\n  trace(msg: string, ...args: any[]) {\n    this.log.trace(msg, ...args)\n  }\n\n  fatal(msg: string, ...args: any[]) {\n    this.log.fatal(msg, ...args)\n  }\n}\n\n/** Shorthand for Logger.for(name) */\nexport function createLogger(name: string): Logger {\n  return Logger.for(name)\n}\n\n/** @deprecated Use rootLogger instead */\nexport const logger = rootLogger\n"],"mappings":";;;;;AAAA,OAAOA,UAAU;AAEjB,IAAMC,QAAQC,QAAQC,IAAIC,aAAa;AAGhC,IAAMC,aAAaC,KAAK;EAC7BC,OAAOL,QAAQC,IAAIK,aAAa;EAChC,GAAIP,QACA;IACEQ,WAAW;MACTC,QAAQ;MACRC,SAAS;QAAEC,UAAU;QAAMC,eAAe;MAAiB;IAC7D;EACF,IACA,CAAC;AACP,CAAA;AAGA,IAAMC,cAAc,oBAAIC,IAAAA;AAuBjB,IAAMC,SAAN,MAAMA,QAAAA;EAzCb,OAyCaA;;;EACHC;EAER,YAAYC,MAAe;AACzB,SAAKD,MAAMC,OAAOb,WAAWc,MAAM;MAAEC,WAAWF;IAAK,CAAA,IAAKb;EAC5D;;EAGA,OAAOgB,IAAIH,MAAsB;AAC/B,QAAII,SAASR,YAAYS,IAAIL,IAAAA;AAC7B,QAAI,CAACI,QAAQ;AACXA,eAAS,IAAIN,QAAOE,IAAAA;AACpBJ,kBAAYU,IAAIN,MAAMI,MAAAA;IACxB;AACA,WAAOA;EACT;;EAGAH,MAAMD,MAAsB;AAC1B,WAAO,IAAIF,QAAOE,IAAAA;EACpB;EAEAO,KAAKC,QAAgBC,MAAa;AAChC,SAAKV,IAAIQ,KAAKC,KAAAA,GAAQC,IAAAA;EACxB;EAEAC,KAAKF,QAAgBC,MAAa;AAChC,SAAKV,IAAIW,KAAKF,KAAAA,GAAQC,IAAAA;EACxB;EAEAE,MAAMC,UAAeJ,QAAiBC,MAAa;AACjD,SAAKV,IAAIY,MAAMC,UAAUJ,KAAAA,GAAQC,IAAAA;EACnC;EAEAI,MAAML,QAAgBC,MAAa;AACjC,SAAKV,IAAIc,MAAML,KAAAA,GAAQC,IAAAA;EACzB;EAEAK,MAAMN,QAAgBC,MAAa;AACjC,SAAKV,IAAIe,MAAMN,KAAAA,GAAQC,IAAAA;EACzB;EAEAM,MAAMP,QAAgBC,MAAa;AACjC,SAAKV,IAAIgB,MAAMP,KAAAA,GAAQC,IAAAA;EACzB;AACF;AAGO,SAASO,aAAahB,MAAY;AACvC,SAAOF,OAAOK,IAAIH,IAAAA;AACpB;AAFgBgB;AAKT,IAAMC,SAAS9B;","names":["pino","isDev","process","env","NODE_ENV","rootLogger","pino","level","LOG_LEVEL","transport","target","options","colorize","translateTime","loggerCache","Map","Logger","log","name","child","component","for","cached","get","set","info","msg","args","warn","error","msgOrObj","debug","trace","fatal","createLogger","logger"]}

package/dist/chunk-PKJSIVAI.js

@@ -0,0 +1,56 @@
+import {
+  __name
+} from "./chunk-7QVYU63E.js";
+
+// src/errors.ts
+var HttpException = class _HttpException extends Error {
+  static {
+    __name(this, "HttpException");
+  }
+  status;
+  details;
+  constructor(status, message, details) {
+    super(message), this.status = status, this.details = details;
+    this.name = "HttpException";
+  }
+  /** Create from a Zod error */
+  static fromZodError(error, message) {
+    const firstIssue = error.issues?.[0];
+    return new _HttpException(422, message || firstIssue?.message || "Validation failed", [
+      ...(error.issues || []).map((issue) => ({
+        field: issue.path?.join(".") || "",
+        message: issue.message,
+        code: issue.code
+      }))
+    ]);
+  }
+  static badRequest(message = "Bad Request") {
+    return new _HttpException(400, message);
+  }
+  static unauthorized(message = "Unauthorized") {
+    return new _HttpException(401, message);
+  }
+  static forbidden(message = "Forbidden") {
+    return new _HttpException(403, message);
+  }
+  static notFound(message = "Not Found") {
+    return new _HttpException(404, message);
+  }
+  static conflict(message = "Conflict") {
+    return new _HttpException(409, message);
+  }
+  static unprocessable(message = "Unprocessable Entity", details) {
+    return new _HttpException(422, message, details);
+  }
+  static tooManyRequests(message = "Too Many Requests") {
+    return new _HttpException(429, message);
+  }
+  static internal(message = "Internal Server Error") {
+    return new _HttpException(500, message);
+  }
+};
+
+export {
+  HttpException
+};
+//# sourceMappingURL=chunk-PKJSIVAI.js.map

package/dist/chunk-PKJSIVAI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts"],"sourcesContent":["/** Validation error detail */\nexport interface ValidationError {\n  field: string\n  message: string\n  code?: string\n}\n\n/**\n * Typed HTTP exception with status code and optional validation details.\n * Provides static factory methods for common HTTP errors.\n */\nexport class HttpException extends Error {\n  constructor(\n    public readonly status: number,\n    message: string,\n    public readonly details?: ValidationError[],\n  ) {\n    super(message)\n    this.name = 'HttpException'\n  }\n\n  /** Create from a Zod error */\n  static fromZodError(error: any, message?: string): HttpException {\n    const firstIssue = error.issues?.[0]\n    return new HttpException(422, message || firstIssue?.message || 'Validation failed', [\n      ...(error.issues || []).map((issue: any) => ({\n        field: issue.path?.join('.') || '',\n        message: issue.message,\n        code: issue.code,\n      })),\n    ])\n  }\n\n  static badRequest(message = 'Bad Request') {\n    return new HttpException(400, message)\n  }\n  static unauthorized(message = 'Unauthorized') {\n    return new HttpException(401, message)\n  }\n  static forbidden(message = 'Forbidden') {\n    return new HttpException(403, message)\n  }\n  static notFound(message = 'Not Found') {\n    return new HttpException(404, message)\n  }\n  static conflict(message = 'Conflict') {\n    return new HttpException(409, message)\n  }\n  static unprocessable(message = 'Unprocessable Entity', details?: ValidationError[]) {\n    return new HttpException(422, message, details)\n  }\n  static tooManyRequests(message = 'Too Many Requests') {\n    return new HttpException(429, message)\n  }\n  static internal(message = 'Internal Server Error') {\n    return new HttpException(500, message)\n  }\n}\n"],"mappings":";;;;;AAWO,IAAMA,gBAAN,MAAMA,uBAAsBC,MAAAA;EAXnC,OAWmCA;;;;;EACjC,YACkBC,QAChBC,SACgBC,SAChB;AACA,UAAMD,OAAAA,GAAAA,KAJUD,SAAAA,QAAAA,KAEAE,UAAAA;AAGhB,SAAKC,OAAO;EACd;;EAGA,OAAOC,aAAaC,OAAYJ,SAAiC;AAC/D,UAAMK,aAAaD,MAAME,SAAS,CAAA;AAClC,WAAO,IAAIT,eAAc,KAAKG,WAAWK,YAAYL,WAAW,qBAAqB;UAC/EI,MAAME,UAAU,CAAA,GAAIC,IAAI,CAACC,WAAgB;QAC3CC,OAAOD,MAAME,MAAMC,KAAK,GAAA,KAAQ;QAChCX,SAASQ,MAAMR;QACfY,MAAMJ,MAAMI;MACd,EAAA;KACD;EACH;EAEA,OAAOC,WAAWb,UAAU,eAAe;AACzC,WAAO,IAAIH,eAAc,KAAKG,OAAAA;EAChC;EACA,OAAOc,aAAad,UAAU,gBAAgB;AAC5C,WAAO,IAAIH,eAAc,KAAKG,OAAAA;EAChC;EACA,OAAOe,UAAUf,UAAU,aAAa;AACtC,WAAO,IAAIH,eAAc,KAAKG,OAAAA;EAChC;EACA,OAAOgB,SAAShB,UAAU,aAAa;AACrC,WAAO,IAAIH,eAAc,KAAKG,OAAAA;EAChC;EACA,OAAOiB,SAASjB,UAAU,YAAY;AACpC,WAAO,IAAIH,eAAc,KAAKG,OAAAA;EAChC;EACA,OAAOkB,cAAclB,UAAU,wBAAwBC,SAA6B;AAClF,WAAO,IAAIJ,eAAc,KAAKG,SAASC,OAAAA;EACzC;EACA,OAAOkB,gBAAgBnB,UAAU,qBAAqB;AACpD,WAAO,IAAIH,eAAc,KAAKG,OAAAA;EAChC;EACA,OAAOoB,SAASpB,UAAU,yBAAyB;AACjD,WAAO,IAAIH,eAAc,KAAKG,OAAAA;EAChC;AACF;","names":["HttpException","Error","status","message","details","name","fromZodError","error","firstIssue","issues","map","issue","field","path","join","code","badRequest","unauthorized","forbidden","notFound","conflict","unprocessable","tooManyRequests","internal"]}

package/dist/chunk-RYMYKGZK.js

@@ -0,0 +1,37 @@
+// src/interfaces.ts
+import "reflect-metadata";
+var Scope = /* @__PURE__ */ (function(Scope2) {
+  Scope2["SINGLETON"] = "singleton";
+  Scope2["TRANSIENT"] = "transient";
+  return Scope2;
+})({});
+var METADATA = {
+  INJECTABLE: /* @__PURE__ */ Symbol("kick:injectable"),
+  SCOPE: /* @__PURE__ */ Symbol("kick:scope"),
+  AUTOWIRED: /* @__PURE__ */ Symbol("kick:autowired"),
+  INJECT: /* @__PURE__ */ Symbol("kick:inject"),
+  CONFIGURATION: /* @__PURE__ */ Symbol("kick:configuration"),
+  BEAN: /* @__PURE__ */ Symbol("kick:bean"),
+  BEAN_OPTIONS: /* @__PURE__ */ Symbol("kick:bean:options"),
+  POST_CONSTRUCT: /* @__PURE__ */ Symbol("kick:post_construct"),
+  TRANSACTIONAL: /* @__PURE__ */ Symbol("kick:transactional"),
+  BUILDER: /* @__PURE__ */ Symbol("kick:builder"),
+  CONTROLLER_PATH: /* @__PURE__ */ Symbol("kick:controller:path"),
+  ROUTES: /* @__PURE__ */ Symbol("kick:routes"),
+  CLASS_MIDDLEWARES: /* @__PURE__ */ Symbol("kick:class:middlewares"),
+  METHOD_MIDDLEWARES: /* @__PURE__ */ Symbol("kick:method:middlewares"),
+  FILE_UPLOAD: /* @__PURE__ */ Symbol("kick:file:upload"),
+  VALUE: /* @__PURE__ */ Symbol("kick:value"),
+  // TypeScript emit metadata keys
+  PARAM_TYPES: "design:paramtypes",
+  PROPERTY_TYPE: "design:type",
+  RETURN_TYPE: "design:returntype"
+};
+var TRANSACTION_MANAGER = /* @__PURE__ */ Symbol("TransactionManager");
+
+export {
+  Scope,
+  METADATA,
+  TRANSACTION_MANAGER
+};
+//# sourceMappingURL=chunk-RYMYKGZK.js.map

package/dist/chunk-RYMYKGZK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/interfaces.ts"],"sourcesContent":["import 'reflect-metadata'\n\n/** Lifecycle scope for DI registrations */\nexport enum Scope {\n  SINGLETON = 'singleton',\n  TRANSIENT = 'transient',\n}\n\n/** Generic constructor type */\nexport type Constructor<T = any> = new (...args: any[]) => T\n\n/** Options for @Service, @Repository, @Component decorators */\nexport interface ServiceOptions {\n  scope?: Scope\n}\n\n/** Options for @Bean decorator */\nexport interface BeanOptions {\n  scope?: Scope\n}\n\n/** Transaction manager interface for @Transactional support */\nexport interface TransactionManager<TTx = unknown> {\n  begin(): Promise<TTx>\n  commit(tx: TTx): Promise<void>\n  rollback(tx: TTx): Promise<void>\n}\n\n/** Fluent builder type */\nexport type BuilderOf<T> = {\n  [K in keyof T as T[K] extends Function ? never : K]-?: (value: T[K]) => BuilderOf<T>\n} & { build(): T }\n\n/** Class with static builder() method */\nexport interface Buildable<T> {\n  builder(): BuilderOf<T>\n}\n\n/** Symbol-based metadata keys for the DI system */\nexport const METADATA = {\n  INJECTABLE: Symbol('kick:injectable'),\n  SCOPE: Symbol('kick:scope'),\n  AUTOWIRED: Symbol('kick:autowired'),\n  INJECT: Symbol('kick:inject'),\n  CONFIGURATION: Symbol('kick:configuration'),\n  BEAN: Symbol('kick:bean'),\n  BEAN_OPTIONS: Symbol('kick:bean:options'),\n  POST_CONSTRUCT: Symbol('kick:post_construct'),\n  TRANSACTIONAL: Symbol('kick:transactional'),\n  BUILDER: Symbol('kick:builder'),\n  CONTROLLER_PATH: Symbol('kick:controller:path'),\n  ROUTES: Symbol('kick:routes'),\n  CLASS_MIDDLEWARES: Symbol('kick:class:middlewares'),\n  METHOD_MIDDLEWARES: Symbol('kick:method:middlewares'),\n  FILE_UPLOAD: Symbol('kick:file:upload'),\n  VALUE: Symbol('kick:value'),\n  // TypeScript emit metadata keys\n  PARAM_TYPES: 'design:paramtypes',\n  PROPERTY_TYPE: 'design:type',\n  RETURN_TYPE: 'design:returntype',\n} as const\n\n/** DI token for transaction manager */\nexport const TRANSACTION_MANAGER = Symbol('TransactionManager')\n"],"mappings":";AAAA,OAAO;AAGA,IAAKA,QAAAA,0BAAAA,QAAAA;;;SAAAA;;AAoCL,IAAMC,WAAW;EACtBC,YAAYC,uBAAO,iBAAA;EACnBC,OAAOD,uBAAO,YAAA;EACdE,WAAWF,uBAAO,gBAAA;EAClBG,QAAQH,uBAAO,aAAA;EACfI,eAAeJ,uBAAO,oBAAA;EACtBK,MAAML,uBAAO,WAAA;EACbM,cAAcN,uBAAO,mBAAA;EACrBO,gBAAgBP,uBAAO,qBAAA;EACvBQ,eAAeR,uBAAO,oBAAA;EACtBS,SAAST,uBAAO,cAAA;EAChBU,iBAAiBV,uBAAO,sBAAA;EACxBW,QAAQX,uBAAO,aAAA;EACfY,mBAAmBZ,uBAAO,wBAAA;EAC1Ba,oBAAoBb,uBAAO,yBAAA;EAC3Bc,aAAad,uBAAO,kBAAA;EACpBe,OAAOf,uBAAO,YAAA;;EAEdgB,aAAa;EACbC,eAAe;EACfC,aAAa;AACf;AAGO,IAAMC,sBAAsBnB,uBAAO,oBAAA;","names":["Scope","METADATA","INJECTABLE","Symbol","SCOPE","AUTOWIRED","INJECT","CONFIGURATION","BEAN","BEAN_OPTIONS","POST_CONSTRUCT","TRANSACTIONAL","BUILDER","CONTROLLER_PATH","ROUTES","CLASS_MIDDLEWARES","METHOD_MIDDLEWARES","FILE_UPLOAD","VALUE","PARAM_TYPES","PROPERTY_TYPE","RETURN_TYPE","TRANSACTION_MANAGER"]}

package/dist/container.d.ts

@@ -0,0 +1,40 @@
+import { Constructor, Scope } from './interfaces.js';
+
+/**
+ * Inversion-of-Control (IoC) container that manages dependency registration,
+ * resolution, and lifecycle. Implements the Singleton pattern so all parts of
+ * the application share a single container instance.
+ *
+ * Supports constructor injection, property injection (@Autowired),
+ * factory-based beans (@Bean), and lifecycle hooks (@PostConstruct).
+ */
+declare class Container {
+    private static instance;
+    private registrations;
+    private resolving;
+    /** Callback set by the decorators module to flush pending registrations */
+    static _onReady: ((container: Container) => void) | null;
+    static getInstance(): Container;
+    /**
+     * Resets the container by replacing the singleton with a fresh instance.
+     * Useful for testing to ensure a clean slate between test runs.
+     */
+    static reset(): void;
+    /** Register a class constructor under the given token */
+    register(token: any, target: Constructor, scope?: Scope): void;
+    /** Register a factory function under the given token */
+    registerFactory(token: any, factory: () => any, scope?: Scope): void;
+    /** Register a pre-constructed singleton instance */
+    registerInstance(token: any, instance: any): void;
+    /** Check if a binding exists for the given token */
+    has(token: any): boolean;
+    /** Resolve a dependency by its token */
+    resolve<T = any>(token: any): T;
+    /** Process all @Configuration classes and invoke their @Bean methods */
+    bootstrap(): void;
+    private createInstance;
+    private injectProperties;
+    private processConfiguration;
+}
+
+export { Container };

package/dist/container.js

@@ -0,0 +1,9 @@
+import {
+  Container
+} from "./chunk-AZH3H6VS.js";
+import "./chunk-RYMYKGZK.js";
+import "./chunk-7QVYU63E.js";
+export {
+  Container
+};
+//# sourceMappingURL=container.js.map

package/dist/container.js.map

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

package/dist/decorators.d.ts

@@ -0,0 +1,65 @@
+import { BeanOptions, ServiceOptions } from './interfaces.js';
+
+/** Mark a class as injectable with lifecycle scope */
+declare function Injectable(options?: ServiceOptions): ClassDecorator;
+/** Mark a class as a service (semantic alias for Injectable) */
+declare function Service(options?: ServiceOptions): ClassDecorator;
+/** Mark a class as a generic managed component */
+declare function Component(options?: ServiceOptions): ClassDecorator;
+/** Mark a class as a repository */
+declare function Repository(options?: ServiceOptions): ClassDecorator;
+/** Mark a class as a configuration provider for @Bean methods */
+declare function Configuration(): ClassDecorator;
+/** Mark a class as an HTTP controller with an optional route prefix */
+declare function Controller(path?: string): ClassDecorator;
+/** Mark a method inside @Configuration as a bean factory */
+declare function Bean(options?: BeanOptions): MethodDecorator;
+/** Mark a method as a lifecycle hook called after instantiation */
+declare function PostConstruct(): MethodDecorator;
+/** Wrap a method in a database transaction with auto commit/rollback */
+declare function Transactional(): MethodDecorator;
+/** Property injection — resolved lazily from the container */
+declare function Autowired(token?: any): PropertyDecorator;
+/** Constructor parameter injection with explicit token */
+declare function Inject(token: any): ParameterDecorator;
+/**
+ * Inject an environment variable value. Evaluated lazily so the env
+ * is available at access time, not at decoration time.
+ *
+ * If no default is provided and the env var is missing, throws at access time
+ * to catch misconfiguration early instead of returning undefined.
+ *
+ * Uses metadata + instance getter to work correctly with `useDefineForClassFields`.
+ */
+declare function Value(envKey: string, defaultValue?: any): PropertyDecorator;
+interface RouteDefinition {
+    method: string;
+    path: string;
+    handlerName: string;
+    validation?: {
+        body?: any;
+        query?: any;
+        params?: any;
+    };
+}
+declare const Get: (path?: string, validation?: RouteDefinition["validation"]) => MethodDecorator;
+declare const Post: (path?: string, validation?: RouteDefinition["validation"]) => MethodDecorator;
+declare const Put: (path?: string, validation?: RouteDefinition["validation"]) => MethodDecorator;
+declare const Delete: (path?: string, validation?: RouteDefinition["validation"]) => MethodDecorator;
+declare const Patch: (path?: string, validation?: RouteDefinition["validation"]) => MethodDecorator;
+type MiddlewareHandler = (ctx: any, next: () => void) => void | Promise<void>;
+/** Attach middleware handlers to a class or method */
+declare function Middleware(...handlers: MiddlewareHandler[]): ClassDecorator & MethodDecorator;
+interface FileUploadConfig {
+    mode: 'single' | 'array' | 'none';
+    fieldName?: string;
+    maxCount?: number;
+    maxSize?: number;
+    allowedMimeTypes?: string[];
+}
+/** Configure file upload handling for a controller method */
+declare function FileUpload(config: FileUploadConfig): MethodDecorator;
+/** Add a static builder() method for fluent construction */
+declare function Builder(target: any): void;
+
+export { Autowired, Bean, Builder, Component, Configuration, Controller, Delete, FileUpload, type FileUploadConfig, Get, Inject, Injectable, Middleware, type MiddlewareHandler, Patch, Post, PostConstruct, Put, Repository, type RouteDefinition, Service, Transactional, Value };

package/dist/decorators.js

@@ -0,0 +1,48 @@
+import {
+  Autowired,
+  Bean,
+  Builder,
+  Component,
+  Configuration,
+  Controller,
+  Delete,
+  FileUpload,
+  Get,
+  Inject,
+  Injectable,
+  Middleware,
+  Patch,
+  Post,
+  PostConstruct,
+  Put,
+  Repository,
+  Service,
+  Transactional,
+  Value
+} from "./chunk-GAO2TPCH.js";
+import "./chunk-AZH3H6VS.js";
+import "./chunk-RYMYKGZK.js";
+import "./chunk-7QVYU63E.js";
+export {
+  Autowired,
+  Bean,
+  Builder,
+  Component,
+  Configuration,
+  Controller,
+  Delete,
+  FileUpload,
+  Get,
+  Inject,
+  Injectable,
+  Middleware,
+  Patch,
+  Post,
+  PostConstruct,
+  Put,
+  Repository,
+  Service,
+  Transactional,
+  Value
+};
+//# sourceMappingURL=decorators.js.map

package/dist/decorators.js.map

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

package/dist/errors.d.ts

@@ -0,0 +1,27 @@
+/** Validation error detail */
+interface ValidationError {
+    field: string;
+    message: string;
+    code?: string;
+}
+/**
+ * Typed HTTP exception with status code and optional validation details.
+ * Provides static factory methods for common HTTP errors.
+ */
+declare class HttpException extends Error {
+    readonly status: number;
+    readonly details?: ValidationError[] | undefined;
+    constructor(status: number, message: string, details?: ValidationError[] | undefined);
+    /** Create from a Zod error */
+    static fromZodError(error: any, message?: string): HttpException;
+    static badRequest(message?: string): HttpException;
+    static unauthorized(message?: string): HttpException;
+    static forbidden(message?: string): HttpException;
+    static notFound(message?: string): HttpException;
+    static conflict(message?: string): HttpException;
+    static unprocessable(message?: string, details?: ValidationError[]): HttpException;
+    static tooManyRequests(message?: string): HttpException;
+    static internal(message?: string): HttpException;
+}
+
+export { HttpException, type ValidationError };

package/dist/errors.js

@@ -0,0 +1,8 @@
+import {
+  HttpException
+} from "./chunk-PKJSIVAI.js";
+import "./chunk-7QVYU63E.js";
+export {
+  HttpException
+};
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

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

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { Container } from './container.js';
+export { BeanOptions, Buildable, BuilderOf, Constructor, METADATA, Scope, ServiceOptions, TRANSACTION_MANAGER, TransactionManager } from './interfaces.js';
+export { Autowired, Bean, Builder, Component, Configuration, Controller, Delete, FileUpload, FileUploadConfig, Get, Inject, Injectable, Middleware, MiddlewareHandler, Patch, Post, PostConstruct, Put, Repository, RouteDefinition, Service, Transactional, Value } from './decorators.js';
+export { AppModule, AppModuleClass, ModuleRoutes } from './app-module.js';
+export { AdapterMiddleware, AppAdapter, AppAdapterClass, MiddlewarePhase } from './adapter.js';
+export { Logger, createLogger, logger, rootLogger } from './logger.js';
+export { HttpException, ValidationError } from './errors.js';
+import 'pino';

package/dist/index.js

@@ -0,0 +1,75 @@
+import {
+  Autowired,
+  Bean,
+  Builder,
+  Component,
+  Configuration,
+  Controller,
+  Delete,
+  FileUpload,
+  Get,
+  Inject,
+  Injectable,
+  Middleware,
+  Patch,
+  Post,
+  PostConstruct,
+  Put,
+  Repository,
+  Service,
+  Transactional,
+  Value
+} from "./chunk-GAO2TPCH.js";
+import {
+  Container
+} from "./chunk-AZH3H6VS.js";
+import {
+  HttpException
+} from "./chunk-PKJSIVAI.js";
+import {
+  METADATA,
+  Scope,
+  TRANSACTION_MANAGER
+} from "./chunk-RYMYKGZK.js";
+import {
+  Logger,
+  createLogger,
+  logger,
+  rootLogger
+} from "./chunk-IHZOCBCK.js";
+import "./chunk-7QVYU63E.js";
+
+// src/index.ts
+import "reflect-metadata";
+export {
+  Autowired,
+  Bean,
+  Builder,
+  Component,
+  Configuration,
+  Container,
+  Controller,
+  Delete,
+  FileUpload,
+  Get,
+  HttpException,
+  Inject,
+  Injectable,
+  Logger,
+  METADATA,
+  Middleware,
+  Patch,
+  Post,
+  PostConstruct,
+  Put,
+  Repository,
+  Scope,
+  Service,
+  TRANSACTION_MANAGER,
+  Transactional,
+  Value,
+  createLogger,
+  logger,
+  rootLogger
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import 'reflect-metadata'\n\n// DI Container\nexport { Container } from './container'\n\n// Interfaces & Constants\nexport {\n  Scope,\n  METADATA,\n  TRANSACTION_MANAGER,\n  type Constructor,\n  type ServiceOptions,\n  type BeanOptions,\n  type TransactionManager,\n  type BuilderOf,\n  type Buildable,\n} from './interfaces'\n\n// Decorators\nexport {\n  Injectable,\n  Service,\n  Component,\n  Repository,\n  Configuration,\n  Controller,\n  Bean,\n  PostConstruct,\n  Transactional,\n  Autowired,\n  Inject,\n  Value,\n  Get,\n  Post,\n  Put,\n  Delete,\n  Patch,\n  Middleware,\n  FileUpload,\n  Builder,\n  type RouteDefinition,\n  type MiddlewareHandler,\n  type FileUploadConfig,\n} from './decorators'\n\n// Module System\nexport { type AppModule, type AppModuleClass, type ModuleRoutes } from './app-module'\n\n// Adapter System\nexport {\n  type AppAdapter,\n  type AppAdapterClass,\n  type AdapterMiddleware,\n  type MiddlewarePhase,\n} from './adapter'\n\n// Logger\nexport { Logger, createLogger, rootLogger, logger } from './logger'\n\n// Errors\nexport { HttpException, type ValidationError } from './errors'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO;","names":[]}

package/dist/interfaces.d.ts

@@ -0,0 +1,57 @@
+/** Lifecycle scope for DI registrations */
+declare enum Scope {
+    SINGLETON = "singleton",
+    TRANSIENT = "transient"
+}
+/** Generic constructor type */
+type Constructor<T = any> = new (...args: any[]) => T;
+/** Options for @Service, @Repository, @Component decorators */
+interface ServiceOptions {
+    scope?: Scope;
+}
+/** Options for @Bean decorator */
+interface BeanOptions {
+    scope?: Scope;
+}
+/** Transaction manager interface for @Transactional support */
+interface TransactionManager<TTx = unknown> {
+    begin(): Promise<TTx>;
+    commit(tx: TTx): Promise<void>;
+    rollback(tx: TTx): Promise<void>;
+}
+/** Fluent builder type */
+type BuilderOf<T> = {
+    [K in keyof T as T[K] extends Function ? never : K]-?: (value: T[K]) => BuilderOf<T>;
+} & {
+    build(): T;
+};
+/** Class with static builder() method */
+interface Buildable<T> {
+    builder(): BuilderOf<T>;
+}
+/** Symbol-based metadata keys for the DI system */
+declare const METADATA: {
+    readonly INJECTABLE: symbol;
+    readonly SCOPE: symbol;
+    readonly AUTOWIRED: symbol;
+    readonly INJECT: symbol;
+    readonly CONFIGURATION: symbol;
+    readonly BEAN: symbol;
+    readonly BEAN_OPTIONS: symbol;
+    readonly POST_CONSTRUCT: symbol;
+    readonly TRANSACTIONAL: symbol;
+    readonly BUILDER: symbol;
+    readonly CONTROLLER_PATH: symbol;
+    readonly ROUTES: symbol;
+    readonly CLASS_MIDDLEWARES: symbol;
+    readonly METHOD_MIDDLEWARES: symbol;
+    readonly FILE_UPLOAD: symbol;
+    readonly VALUE: symbol;
+    readonly PARAM_TYPES: "design:paramtypes";
+    readonly PROPERTY_TYPE: "design:type";
+    readonly RETURN_TYPE: "design:returntype";
+};
+/** DI token for transaction manager */
+declare const TRANSACTION_MANAGER: unique symbol;
+
+export { type BeanOptions, type Buildable, type BuilderOf, type Constructor, METADATA, Scope, type ServiceOptions, TRANSACTION_MANAGER, type TransactionManager };

package/dist/interfaces.js

@@ -0,0 +1,12 @@
+import {
+  METADATA,
+  Scope,
+  TRANSACTION_MANAGER
+} from "./chunk-RYMYKGZK.js";
+import "./chunk-7QVYU63E.js";
+export {
+  METADATA,
+  Scope,
+  TRANSACTION_MANAGER
+};
+//# sourceMappingURL=interfaces.js.map

package/dist/interfaces.js.map

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

package/dist/logger.d.ts

@@ -0,0 +1,45 @@
+import pino from 'pino';
+
+/** Root pino logger instance */
+declare const rootLogger: pino.Logger<never, boolean>;
+/**
+ * Named logger with component context.
+ *
+ * @example
+ * ```ts
+ * // Static factory — preferred
+ * const log = Logger.for('UserService')
+ * log.info('User created')
+ * // Output: [UserService] User created
+ *
+ * // Shorthand function
+ * const log = createLogger('OrderService')
+ *
+ * // Injectable — auto-named from class
+ * class MyService {
+ *   @Autowired() private logger!: Logger
+ *   // or inject a named one:
+ *   private log = Logger.for('MyService')
+ * }
+ * ```
+ */
+declare class Logger {
+    private log;
+    constructor(name?: string);
+    /** Create or retrieve a cached named logger */
+    static for(name: string): Logger;
+    /** Create a child logger with a sub-component name */
+    child(name: string): Logger;
+    info(msg: string, ...args: any[]): void;
+    warn(msg: string, ...args: any[]): void;
+    error(msgOrObj: any, msg?: string, ...args: any[]): void;
+    debug(msg: string, ...args: any[]): void;
+    trace(msg: string, ...args: any[]): void;
+    fatal(msg: string, ...args: any[]): void;
+}
+/** Shorthand for Logger.for(name) */
+declare function createLogger(name: string): Logger;
+/** @deprecated Use rootLogger instead */
+declare const logger: pino.Logger<never, boolean>;
+
+export { Logger, createLogger, logger, rootLogger };

package/dist/logger.js

@@ -0,0 +1,14 @@
+import {
+  Logger,
+  createLogger,
+  logger,
+  rootLogger
+} from "./chunk-IHZOCBCK.js";
+import "./chunk-7QVYU63E.js";
+export {
+  Logger,
+  createLogger,
+  logger,
+  rootLogger
+};
+//# sourceMappingURL=logger.js.map

package/dist/logger.js.map

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