@di-framework/di-framework 0.0.0-prerelease.308 → 0.0.0-prerelease.310

package/README.md

@@ -22,12 +22,12 @@ The decorators are fully integrated with SWC's native support - no need for `ref
 ### 1. Basic Service
 
 ```typescript
-import { Container } from "@di-framework/di-framework/decorators";
+import { Container } from '@di-framework/di-framework/decorators';
 
 @Container()
 export class DatabaseService {
   connect(): void {
-    console.log("Connected to database");
+    console.log('Connected to database');
   }
 }
 ```
@@ -35,8 +35,8 @@ export class DatabaseService {
 ### 2. Service with Dependencies
 
 ```typescript
-import { Container, Component } from "@di-framework/di-framework/decorators";
-import { DatabaseService } from "./services/DatabaseService";
+import { Container, Component } from '@di-framework/di-framework/decorators';
+import { DatabaseService } from './services/DatabaseService';
 
 @Container()
 export class UserService {
@@ -56,14 +56,14 @@ Note: Property injection is used for all dependencies. This works seamlessly wit
 ### 3. Resolve Services
 
 ```typescript
-import { useContainer } from "@di-framework/di-framework/container";
-import { UserService } from "./services/UserService";
+import { useContainer } from '@di-framework/di-framework/container';
+import { UserService } from './services/UserService';
 
 const container = useContainer();
 const userService = container.resolve<UserService>(UserService);
 
 // All dependencies are automatically injected!
-userService.getUser("123");
+userService.getUser('123');
 ```
 
 ## API Reference
@@ -157,7 +157,7 @@ export class MonitoringService {
 Returns the global DI container instance.
 
 ```typescript
-import { useContainer } from "@di-framework/di-framework/container";
+import { useContainer } from '@di-framework/di-framework/container';
 
 const container = useContainer();
 ```
@@ -176,7 +176,7 @@ Register a service using a factory function.
 
 ```typescript
 container.registerFactory(
-  "config",
+  'config',
   () => ({
     apiKey: process.env.API_KEY,
     dbUrl: process.env.DATABASE_URL,
@@ -192,7 +192,7 @@ Resolve and get an instance of a service.
 ```typescript
 const userService = container.resolve<UserService>(UserService);
 // or by name
-const config = container.resolve("config");
+const config = container.resolve('config');
 ```
 
 ### `container.has(serviceClass)`
@@ -228,10 +228,8 @@ Subscribe to DI container lifecycle events (observer pattern).
 **Example:**
 
 ```typescript
-const unsubscribe = container.on("resolved", ({ key, fromCache }) => {
-  console.log(
-    `Resolved ${typeof key === "string" ? key : key.name} (fromCache=${fromCache})`,
-  );
+const unsubscribe = container.on('resolved', ({ key, fromCache }) => {
+  console.log(`Resolved ${typeof key === 'string' ? key : key.name} (fromCache=${fromCache})`);
 });
 
 unsubscribe(); // stop listening
@@ -242,8 +240,8 @@ unsubscribe(); // stop listening
 Create a fresh instance without registering it, while still honoring dependency injection. Useful for constructor-pattern scenarios where you need to supply specific primitives/config values.
 
 ```typescript
-import { Component } from "@di-framework/di-framework/decorators";
-import { LoggerService } from "@di-framework/di-framework/services/LoggerService";
+import { Component } from '@di-framework/di-framework/decorators';
+import { LoggerService } from '@di-framework/di-framework/services/LoggerService';
 
 class Greeter {
   constructor(
@@ -252,7 +250,7 @@ class Greeter {
   ) {}
 }
 
-const greeter = container.construct(Greeter, { 1: "hello world" });
+const greeter = container.construct(Greeter, { 1: 'hello world' });
 ```
 
 ### `container.fork(options?)`
@@ -277,7 +275,7 @@ export class ApplicationContext {
   ) {}
 
   async initialize() {
-    this.logger.log("Initializing application...");
+    this.logger.log('Initializing application...');
     await this.db.connect();
     this.auth.setup();
   }
@@ -312,12 +310,12 @@ export class DatabaseService {
 
   setEnv(env: Record<string, any>) {
     // Called to initialize environment-specific config
-    console.log("DB URL:", env.DATABASE_URL);
+    console.log('DB URL:', env.DATABASE_URL);
   }
 
   setCtx(context: any) {
     // Called to set execution context
-    console.log("Context:", context);
+    console.log('Context:', context);
   }
 
   connect() {
@@ -328,7 +326,7 @@ export class DatabaseService {
 // Calling lifecycle methods
 const db = container.resolve(DatabaseService);
 db.setEnv(process.env);
-db.setCtx({ userId: "123" });
+db.setCtx({ userId: '123' });
 db.connect();
 ```
 
@@ -336,7 +334,7 @@ db.connect();
 
 ```typescript
 container.registerFactory(
-  "apiClient",
+  'apiClient',
   () => {
     return new HttpClient({
       baseUrl: process.env.API_URL,
@@ -349,7 +347,7 @@ container.registerFactory(
 // Use in services
 @Container()
 export class UserService {
-  constructor(@Component("apiClient") private api: any) {}
+  constructor(@Component('apiClient') private api: any) {}
 }
 ```
 
@@ -479,7 +477,7 @@ class MyService {
 
 ```typescript
 // Create a test container
-import { Container as DIContainer } from "@di-framework/di-framework/container";
+import { Container as DIContainer } from '@di-framework/di-framework/container';
 
 const testContainer = new DIContainer();
 
@@ -497,7 +495,7 @@ testContainer.register(UserService);
 
 // Test the service with mocked dependencies
 const userService = testContainer.resolve(UserService);
-expect(userService.getUser("1")).toEqual({ mock: true });
+expect(userService.getUser('1')).toEqual({ mock: true });
 ```
 
 ## License

package/dist/container.d.ts

@@ -11,7 +11,7 @@ type ContainerEventPayloads = {
     registered: {
         key: string | Constructor;
         singleton: boolean;
-        kind: "class" | "factory";
+        kind: 'class' | 'factory';
     };
     resolved: {
         key: string | Constructor;
@@ -42,6 +42,7 @@ export declare const TELEMETRY_METADATA_KEY = "di:telemetry";
 export declare const TELEMETRY_LISTENER_METADATA_KEY = "di:telemetry-listener";
 export declare const PUBLISHER_METADATA_KEY = "di:publisher";
 export declare const SUBSCRIBER_METADATA_KEY = "di:subscriber";
+export declare const CRON_METADATA_KEY = "di:cron";
 declare function defineMetadata(key: string | symbol, value: any, target: any): void;
 declare function getMetadata(key: string | symbol, target: any): any;
 declare function hasMetadata(key: string | symbol, target: any): boolean;
@@ -50,6 +51,7 @@ export declare class Container {
     private services;
     private resolutionStack;
     private listeners;
+    private cronJobs;
     /**
      * Register a service class as injectable
      */
@@ -80,6 +82,10 @@ export declare class Container {
      * Clear all registered services
      */
     clear(): void;
+    /**
+     * Stop all active cron jobs
+     */
+    stopCronJobs(): void;
     /**
      * Get all registered service names
      */
@@ -105,6 +111,10 @@ export declare class Container {
      * Apply event publishers and subscribers defined via decorators
      */
     private applyEvents;
+    /**
+     * Apply cron schedules defined via @Cron decorator
+     */
+    private applyCron;
     /**
      * Private method to instantiate a service
      */

package/dist/container.js

@@ -5,13 +5,14 @@
  * Supports singleton pattern and automatic dependency injection via decorators.
  * Works with SWC and TypeScript's native decorator support.
  */
-const INJECTABLE_METADATA_KEY = "di:injectable";
-const INJECT_METADATA_KEY = "di:inject";
-const DESIGN_PARAM_TYPES_KEY = "design:paramtypes";
-export const TELEMETRY_METADATA_KEY = "di:telemetry";
-export const TELEMETRY_LISTENER_METADATA_KEY = "di:telemetry-listener";
-export const PUBLISHER_METADATA_KEY = "di:publisher";
-export const SUBSCRIBER_METADATA_KEY = "di:subscriber";
+const INJECTABLE_METADATA_KEY = 'di:injectable';
+const INJECT_METADATA_KEY = 'di:inject';
+const DESIGN_PARAM_TYPES_KEY = 'design:paramtypes';
+export const TELEMETRY_METADATA_KEY = 'di:telemetry';
+export const TELEMETRY_LISTENER_METADATA_KEY = 'di:telemetry-listener';
+export const PUBLISHER_METADATA_KEY = 'di:publisher';
+export const SUBSCRIBER_METADATA_KEY = 'di:subscriber';
+export const CRON_METADATA_KEY = 'di:cron';
 /**
  * Simple metadata storage that doesn't require reflect-metadata
  * Works with SWC's native decorator support
@@ -32,10 +33,70 @@ function hasMetadata(key, target) {
 function getOwnMetadata(key, target) {
     return getMetadata(key, target);
 }
+// Parse a single cron field into an array of matching values.
+// Supports: * (any), star/N (step), N (exact), N,M (list), N-M (range)
+function parseCronField(field, min, max) {
+    if (field === '*') {
+        const out = [];
+        for (let i = min; i <= max; i++)
+            out.push(i);
+        return out;
+    }
+    if (field.startsWith('*/')) {
+        const step = parseInt(field.slice(2), 10);
+        const out = [];
+        for (let i = min; i <= max; i++) {
+            if (i % step === 0)
+                out.push(i);
+        }
+        return out;
+    }
+    if (field.includes(',')) {
+        return field.split(',').map((s) => parseInt(s.trim(), 10));
+    }
+    if (field.includes('-')) {
+        const [lo = 0, hi = 0] = field.split('-').map((s) => parseInt(s.trim(), 10));
+        const out = [];
+        for (let i = lo; i <= hi; i++)
+            out.push(i);
+        return out;
+    }
+    return [parseInt(field, 10)];
+}
+function parseCronExpression(expr) {
+    const parts = expr.trim().split(/\s+/);
+    if (parts.length !== 5)
+        throw new Error(`Invalid cron expression "${expr}": expected 5 fields (minute hour dayOfMonth month dayOfWeek)`);
+    return {
+        minute: parseCronField(parts[0], 0, 59),
+        hour: parseCronField(parts[1], 0, 23),
+        dayOfMonth: parseCronField(parts[2], 1, 31),
+        month: parseCronField(parts[3], 1, 12),
+        dayOfWeek: parseCronField(parts[4], 0, 6),
+    };
+}
+function getNextCronTime(fields, from) {
+    const next = new Date(from);
+    next.setSeconds(0, 0);
+    next.setMinutes(next.getMinutes() + 1);
+    // Search forward up to ~2 years of minutes
+    for (let i = 0; i < 1_051_920; i++) {
+        if (fields.minute.includes(next.getMinutes()) &&
+            fields.hour.includes(next.getHours()) &&
+            fields.dayOfMonth.includes(next.getDate()) &&
+            fields.month.includes(next.getMonth() + 1) &&
+            fields.dayOfWeek.includes(next.getDay())) {
+            return next;
+        }
+        next.setMinutes(next.getMinutes() + 1);
+    }
+    throw new Error(`No matching cron time found for expression within 2 years`);
+}
 export class Container {
     services = new Map();
     resolutionStack = new Set();
     listeners = new Map();
+    cronJobs = [];
     /**
      * Register a service class as injectable
      */
@@ -49,10 +110,10 @@ export class Container {
             type: serviceClass,
             singleton: options.singleton ?? true,
         });
-        this.emit("registered", {
+        this.emit('registered', {
             key: serviceClass,
             singleton: options.singleton ?? true,
-            kind: "class",
+            kind: 'class',
         });
         return this;
     }
@@ -64,10 +125,10 @@ export class Container {
             type: factory,
             singleton: options.singleton ?? true,
         });
-        this.emit("registered", {
+        this.emit('registered', {
             key: name,
             singleton: options.singleton ?? true,
-            kind: "factory",
+            kind: 'factory',
         });
         return this;
     }
@@ -75,11 +136,11 @@ export class Container {
      * Get or create a service instance
      */
     resolve(serviceClass) {
-        const key = typeof serviceClass === "string" ? serviceClass : serviceClass;
-        const keyStr = typeof serviceClass === "string" ? serviceClass : serviceClass.name;
+        const key = typeof serviceClass === 'string' ? serviceClass : serviceClass;
+        const keyStr = typeof serviceClass === 'string' ? serviceClass : serviceClass.name;
         // Check for circular dependencies
         if (this.resolutionStack.has(key)) {
-            throw new Error(`Circular dependency detected while resolving ${keyStr}. Stack: ${Array.from(this.resolutionStack).join(" -> ")} -> ${keyStr}`);
+            throw new Error(`Circular dependency detected while resolving ${keyStr}. Stack: ${Array.from(this.resolutionStack).join(' -> ')} -> ${keyStr}`);
         }
         const definition = this.services.get(key);
         if (!definition) {
@@ -88,7 +149,7 @@ export class Container {
         const wasCached = definition.singleton && !!definition.instance;
         // Return cached singleton
         if (definition.singleton && definition.instance) {
-            this.emit("resolved", {
+            this.emit('resolved', {
                 key,
                 instance: definition.instance,
                 singleton: true,
@@ -104,7 +165,7 @@ export class Container {
             if (definition.singleton) {
                 definition.instance = instance;
             }
-            this.emit("resolved", {
+            this.emit('resolved', {
                 key,
                 instance,
                 singleton: definition.singleton,
@@ -124,12 +185,12 @@ export class Container {
     construct(serviceClass, overrides = {}) {
         const keyStr = serviceClass.name;
         if (this.resolutionStack.has(serviceClass)) {
-            throw new Error(`Circular dependency detected while constructing ${keyStr}. Stack: ${Array.from(this.resolutionStack).join(" -> ")} -> ${keyStr}`);
+            throw new Error(`Circular dependency detected while constructing ${keyStr}. Stack: ${Array.from(this.resolutionStack).join(' -> ')} -> ${keyStr}`);
         }
         this.resolutionStack.add(serviceClass);
         try {
             const instance = this.instantiate(serviceClass, overrides);
-            this.emit("constructed", { key: serviceClass, instance, overrides });
+            this.emit('constructed', { key: serviceClass, instance, overrides });
             return instance;
         }
         finally {
@@ -147,8 +208,18 @@ export class Container {
      */
     clear() {
         const count = this.services.size;
+        this.stopCronJobs();
         this.services.clear();
-        this.emit("cleared", { count });
+        this.emit('cleared', { count });
+    }
+    /**
+     * Stop all active cron jobs
+     */
+    stopCronJobs() {
+        for (const job of this.cronJobs) {
+            job.stop();
+        }
+        this.cronJobs = [];
     }
     /**
      * Get all registered service names
@@ -156,7 +227,7 @@ export class Container {
     getServiceNames() {
         const names = new Set();
         this.services.forEach((_, key) => {
-            if (typeof key === "string") {
+            if (typeof key === 'string') {
                 names.add(key);
             }
         });
@@ -216,7 +287,7 @@ export class Container {
         Object.entries(subscriberMap).forEach(([event, methods]) => {
             methods.forEach((methodName) => {
                 const method = instance[methodName];
-                if (typeof method === "function") {
+                if (typeof method === 'function') {
                     this.on(event, (payload) => {
                         try {
                             method.call(instance, payload);
@@ -232,9 +303,9 @@ export class Container {
         const publisherMethods = getMetadata(PUBLISHER_METADATA_KEY, constructor.prototype) || {};
         Object.entries(publisherMethods).forEach(([methodName, options]) => {
             const originalMethod = instance[methodName];
-            if (typeof originalMethod === "function") {
+            if (typeof originalMethod === 'function') {
                 const self = this;
-                const phase = options.phase ?? "after";
+                const phase = options.phase ?? 'after';
                 instance[methodName] = function (...args) {
                     const startTime = Date.now();
                     const emit = (result, error) => {
@@ -251,13 +322,13 @@ export class Container {
                             const duration = payload.endTime - payload.startTime;
                             const status = error
                                 ? `ERROR: ${error && error.message ? error.message : String(error)}`
-                                : "SUCCESS";
+                                : 'SUCCESS';
                             console.log(`[Publisher] ${className}.${methodName} -> '${options.event}' - ${status} (${duration}ms)`);
                         }
                         self.emit(options.event, payload);
                     };
                     try {
-                        if (phase === "before" || phase === "both") {
+                        if (phase === 'before' || phase === 'both') {
                             // Emit before invocation (no result yet)
                             emit(undefined, undefined);
                         }
@@ -265,7 +336,7 @@ export class Container {
                         if (result instanceof Promise) {
                             return result
                                 .then((val) => {
-                                if (phase === "after" || phase === "both") {
+                                if (phase === 'after' || phase === 'both') {
                                     emit(val, undefined);
                                 }
                                 return val;
@@ -276,7 +347,7 @@ export class Container {
                                 throw err;
                             });
                         }
-                        if (phase === "after" || phase === "both") {
+                        if (phase === 'after' || phase === 'both') {
                             emit(result, undefined);
                         }
                         return result;
@@ -289,12 +360,70 @@ export class Container {
             }
         });
     }
+    /**
+     * Apply cron schedules defined via @Cron decorator
+     */
+    applyCron(instance, constructor) {
+        const cronMethods = getMetadata(CRON_METADATA_KEY, constructor.prototype) || {};
+        Object.entries(cronMethods).forEach(([methodName, schedule]) => {
+            const method = instance[methodName];
+            if (typeof method !== 'function')
+                return;
+            if (typeof schedule === 'number') {
+                // Simple interval in ms
+                const timer = setInterval(() => {
+                    try {
+                        method.call(instance);
+                    }
+                    catch (err) {
+                        console.error(`[Cron] ${constructor.name}.${methodName} threw`, err);
+                    }
+                }, schedule);
+                this.cronJobs.push({ stop: () => clearInterval(timer) });
+            }
+            else {
+                // Cron expression
+                const fields = parseCronExpression(schedule);
+                let stopped = false;
+                const scheduleNext = () => {
+                    if (stopped)
+                        return;
+                    const now = new Date();
+                    const next = getNextCronTime(fields, now);
+                    const delay = next.getTime() - now.getTime();
+                    const timer = setTimeout(() => {
+                        if (stopped)
+                            return;
+                        try {
+                            method.call(instance);
+                        }
+                        catch (err) {
+                            console.error(`[Cron] ${constructor.name}.${methodName} threw`, err);
+                        }
+                        scheduleNext();
+                    }, delay);
+                    // Update the stop function to clear the latest timer
+                    job.stop = () => {
+                        stopped = true;
+                        clearTimeout(timer);
+                    };
+                };
+                const job = {
+                    stop: () => {
+                        stopped = true;
+                    },
+                };
+                this.cronJobs.push(job);
+                scheduleNext();
+            }
+        });
+    }
     /**
      * Private method to instantiate a service
      */
     instantiate(type, overrides = {}) {
-        if (typeof type !== "function") {
-            throw new Error("Service type must be a constructor or factory function");
+        if (typeof type !== 'function') {
+            throw new Error('Service type must be a constructor or factory function');
         }
         // If it's a factory function (not a class), just call it
         if (!this.isClass(type)) {
@@ -342,17 +471,18 @@ export class Container {
         this.applyTelemetry(instance, type);
         // Apply custom event publishers and subscribers
         this.applyEvents(instance, type);
+        // Apply cron schedules
+        this.applyCron(instance, type);
         // Call @Component() decorators on properties
         // Check both the instance and the constructor prototype for metadata
         const injectProperties = getMetadata(INJECT_METADATA_KEY, type) || {};
-        const protoInjectProperties = getMetadata(INJECT_METADATA_KEY, type.prototype) ||
-            {};
+        const protoInjectProperties = getMetadata(INJECT_METADATA_KEY, type.prototype) || {};
         const allInjectProperties = {
             ...injectProperties,
             ...protoInjectProperties,
         };
         Object.entries(allInjectProperties).forEach(([propName, targetType]) => {
-            if (!propName.startsWith("param_") && targetType) {
+            if (!propName.startsWith('param_') && targetType) {
                 try {
                     instance[propName] = this.resolve(targetType);
                 }
@@ -372,8 +502,8 @@ export class Container {
         const listenerMethods = getMetadata(TELEMETRY_LISTENER_METADATA_KEY, constructor.prototype) || [];
         listenerMethods.forEach((methodName) => {
             const method = instance[methodName];
-            if (typeof method === "function") {
-                this.on("telemetry", (payload) => {
+            if (typeof method === 'function') {
+                this.on('telemetry', (payload) => {
                     try {
                         method.call(instance, payload);
                     }
@@ -387,7 +517,7 @@ export class Container {
         const telemetryMethods = getMetadata(TELEMETRY_METADATA_KEY, constructor.prototype) || {};
         Object.entries(telemetryMethods).forEach(([methodName, options]) => {
             const originalMethod = instance[methodName];
-            if (typeof originalMethod === "function") {
+            if (typeof originalMethod === 'function') {
                 const self = this;
                 instance[methodName] = function (...args) {
                     const startTime = Date.now();
@@ -403,12 +533,10 @@ export class Container {
                         };
                         if (options.logging) {
                             const duration = payload.endTime - payload.startTime;
-                            const status = error
-                                ? `ERROR: ${error.message || error}`
-                                : "SUCCESS";
+                            const status = error ? `ERROR: ${error.message || error}` : 'SUCCESS';
                             console.log(`[Telemetry] ${className}.${methodName} - ${status} (${duration}ms)`);
                         }
-                        self.emit("telemetry", payload);
+                        self.emit('telemetry', payload);
                     };
                     try {
                         const result = originalMethod.apply(this, args);
@@ -438,9 +566,7 @@ export class Container {
      * Check if a function is a class constructor
      */
     isClass(func) {
-        return (typeof func === "function" &&
-            func.prototype &&
-            func.prototype.constructor === func);
+        return typeof func === 'function' && func.prototype && func.prototype.constructor === func;
     }
     /**
      * Extract parameter names from constructor
@@ -452,11 +578,11 @@ export class Container {
             return [];
         const paramsStr = match[1];
         return paramsStr
-            .split(",")
+            .split(',')
             .map((param) => {
             const trimmed = param.trim();
-            const withoutDefault = trimmed.split("=")[0] || "";
-            const withoutType = withoutDefault.split(":")[0] || "";
+            const withoutDefault = trimmed.split('=')[0] || '';
+            const withoutType = withoutDefault.split(':')[0] || '';
             return withoutType.trim();
         })
             .filter((param) => param);

package/dist/decorators.d.ts

@@ -7,7 +7,7 @@
  * Works with SWC and TypeScript's native decorator support.
  * No external dependencies required (no reflect-metadata needed).
  */
-import { Container as DIContainer } from "./container";
+import { Container as DIContainer } from './container';
 /**
  * Options for the @Telemetry decorator
  */
@@ -38,7 +38,7 @@ export interface PublisherOptions {
     /** The custom event name to emit on the container */
     event: string;
     /** When to emit relative to the method invocation. Defaults to 'after'. */
-    phase?: "before" | "after" | "both";
+    phase?: 'before' | 'after' | 'both';
     /** Optional console logging for debug purposes. Defaults to false. */
     logging?: boolean;
 }
@@ -66,6 +66,19 @@ export declare function Publisher(optionsOrEvent: string | PublisherOptions): (t
  * }
  */
 export declare function Subscriber(event: string): (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => void;
+/**
+ * Marks a method to run on a cron schedule.
+ * The schedule starts automatically when the service is resolved.
+ * Jobs are stopped when container.clear() is called.
+ *
+ * @param schedule A cron expression (5 fields: minute hour dayOfMonth month dayOfWeek)
+ *                 or an interval in milliseconds.
+ *
+ * @example
+ * Cron('0 * * * *')   // every hour
+ * Cron(30000)          // every 30 seconds
+ */
+export declare function Cron(schedule: string | number): (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => void;
 /**
  * Marks a class as injectable and registers it with the DI container
  *
@@ -89,6 +102,18 @@ export declare function Container(options?: {
 }): <T extends {
     new (...args: any[]): {};
 }>(constructor: T) => T;
+/**
+ * Eagerly resolves a class once at definition time.
+ *
+ * Useful for startup-only classes (e.g. HTTP controllers) whose constructors
+ * register routes or side effects and should run before handling requests.
+ */
+export declare function Bootstrap(options?: {
+    singleton?: boolean;
+    container?: DIContainer;
+}): <T extends {
+    new (...args: any[]): {};
+}>(constructor: T) => T;
 /**
  * Marks a constructor parameter or property for dependency injection
  *
@@ -117,7 +142,7 @@ export declare function Container(options?: {
  *   constructor(@Component('apiKey') apiKey: string) {}
  * }
  */
-export declare function Component(target: any): (targetClass: Object | any, propertyKey?: string | symbol, parameterIndex?: number) => void;
+export declare function Component(target: any): (targetClass: object | any, propertyKey?: string | symbol, parameterIndex?: number) => void;
 /**
  * Check if a class is marked as injectable
  */

package/dist/decorators.js

@@ -7,9 +7,9 @@
  * Works with SWC and TypeScript's native decorator support.
  * No external dependencies required (no reflect-metadata needed).
  */
-import { useContainer, Container as DIContainer, defineMetadata, getOwnMetadata, getMetadata, TELEMETRY_METADATA_KEY, TELEMETRY_LISTENER_METADATA_KEY, PUBLISHER_METADATA_KEY, SUBSCRIBER_METADATA_KEY, } from "./container";
-const INJECTABLE_METADATA_KEY = "di:injectable";
-const INJECT_METADATA_KEY = "di:inject";
+import { useContainer, Container as DIContainer, defineMetadata, getOwnMetadata, getMetadata, TELEMETRY_METADATA_KEY, TELEMETRY_LISTENER_METADATA_KEY, PUBLISHER_METADATA_KEY, SUBSCRIBER_METADATA_KEY, CRON_METADATA_KEY, } from './container';
+const INJECTABLE_METADATA_KEY = 'di:injectable';
+const INJECT_METADATA_KEY = 'di:inject';
 /**
  * Marks a method for telemetry tracking.
  * When called, it will emit a 'telemetry' event on the container.
@@ -48,13 +48,11 @@ export function TelemetryListener() {
  */
 export function Publisher(optionsOrEvent) {
     return function (target, propertyKey, descriptor) {
-        const options = typeof optionsOrEvent === "string"
-            ? { event: optionsOrEvent }
-            : optionsOrEvent;
+        const options = typeof optionsOrEvent === 'string' ? { event: optionsOrEvent } : optionsOrEvent;
         const methods = getOwnMetadata(PUBLISHER_METADATA_KEY, target) || {};
         methods[propertyKey] = {
             event: options.event,
-            phase: options.phase ?? "after",
+            phase: options.phase ?? 'after',
             logging: options.logging ?? false,
         };
         defineMetadata(PUBLISHER_METADATA_KEY, methods, target);
@@ -80,6 +78,25 @@ export function Subscriber(event) {
         defineMetadata(SUBSCRIBER_METADATA_KEY, map, target);
     };
 }
+/**
+ * Marks a method to run on a cron schedule.
+ * The schedule starts automatically when the service is resolved.
+ * Jobs are stopped when container.clear() is called.
+ *
+ * @param schedule A cron expression (5 fields: minute hour dayOfMonth month dayOfWeek)
+ *                 or an interval in milliseconds.
+ *
+ * @example
+ * Cron('0 * * * *')   // every hour
+ * Cron(30000)          // every 30 seconds
+ */
+export function Cron(schedule) {
+    return function (target, propertyKey, descriptor) {
+        const methods = getOwnMetadata(CRON_METADATA_KEY, target) || {};
+        methods[propertyKey] = schedule;
+        defineMetadata(CRON_METADATA_KEY, methods, target);
+    };
+}
 /**
  * Marks a class as injectable and registers it with the DI container
  *
@@ -108,6 +125,25 @@ export function Container(options = {}) {
         return constructor;
     };
 }
+/**
+ * Eagerly resolves a class once at definition time.
+ *
+ * Useful for startup-only classes (e.g. HTTP controllers) whose constructors
+ * register routes or side effects and should run before handling requests.
+ */
+export function Bootstrap(options = {}) {
+    return function (constructor) {
+        const container = options.container ?? useContainer();
+        // Allow bootstrap to be used with or without @Container().
+        if (!container.has(constructor)) {
+            const singleton = options.singleton ?? true;
+            defineMetadata(INJECTABLE_METADATA_KEY, true, constructor);
+            container.register(constructor, { singleton });
+        }
+        container.resolve(constructor);
+        return constructor;
+    };
+}
 /**
  * Marks a constructor parameter or property for dependency injection
  *

package/dist/types.js

@@ -9,7 +9,7 @@
 export class DIError extends Error {
     constructor(message) {
         super(message);
-        this.name = "DIError";
+        this.name = 'DIError';
     }
 }
 /**
@@ -18,7 +18,7 @@ export class DIError extends Error {
 export class CircularDependencyError extends DIError {
     constructor(message) {
         super(message);
-        this.name = "CircularDependencyError";
+        this.name = 'CircularDependencyError';
     }
 }
 /**
@@ -27,7 +27,7 @@ export class CircularDependencyError extends DIError {
 export class ServiceNotFoundError extends DIError {
     constructor(serviceName) {
         super(`Service '${serviceName}' is not registered in the DI container`);
-        this.name = "ServiceNotFoundError";
+        this.name = 'ServiceNotFoundError';
     }
 }
 /**
@@ -76,21 +76,21 @@ export var ServiceUtils;
      * Check if an object is a service class
      */
     function isServiceClass(obj) {
-        return typeof obj === "function" && obj.prototype;
+        return typeof obj === 'function' && obj.prototype;
     }
     ServiceUtils.isServiceClass = isServiceClass;
     /**
      * Check if an object is a factory function
      */
     function isFactory(obj) {
-        return typeof obj === "function" && !isServiceClass(obj);
+        return typeof obj === 'function' && !isServiceClass(obj);
     }
     ServiceUtils.isFactory = isFactory;
     /**
      * Get the service name
      */
     function getServiceName(service) {
-        if (typeof service === "string") {
+        if (typeof service === 'string') {
             return service;
         }
         return service.name;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@di-framework/di-framework",
-  "version": "0.0.0-prerelease.308",
+  "version": "0.0.0-prerelease.310",
   "description": "Lightweight, zero-dependency TypeScript Dependency Injection framework using decorators. Works seamlessly with SWC and TypeScript's native decorator support.",
   "main": "./dist/container.js",
   "types": "./dist/container.d.ts",