@di-framework/di-framework 2.0.4 → 3.0.0

package/README.md

@@ -6,12 +6,12 @@
 
 A lightweight, type-safe Dependency Injection framework for TypeScript using decorators. This framework automatically manages service instantiation, dependency resolution, and lifecycle management.
 
-
 ## Installation
 
 No external dependencies required! The framework works with SWC and TypeScript's native decorator support.
 
 Just ensure you have:
+
 - TypeScript 5.0+
 - SWC or TypeScript compiler with `experimentalDecorators` and `emitDecoratorMetadata` enabled
 
@@ -22,7 +22,7 @@ The decorators are fully integrated with SWC's native support - no need for `ref
 ### 1. Basic Service
 
 ```typescript
-import { Container } from 'di-framework/decorators';
+import { Container } from '@di-framework/di-framework/decorators';
 
 @Container()
 export class DatabaseService {
@@ -35,7 +35,7 @@ export class DatabaseService {
 ### 2. Service with Dependencies
 
 ```typescript
-import { Container, Component } from 'di-framework/decorators';
+import { Container, Component } from '@di-framework/di-framework/decorators';
 import { DatabaseService } from './services/DatabaseService';
 
 @Container()
@@ -56,7 +56,7 @@ Note: Property injection is used for all dependencies. This works seamlessly wit
 ### 3. Resolve Services
 
 ```typescript
-import { useContainer } from 'di-framework/container';
+import { useContainer } from '@di-framework/di-framework/container';
 import { UserService } from './services/UserService';
 
 const container = useContainer();
@@ -73,11 +73,13 @@ userService.getUser('123');
 Marks a class as injectable and automatically registers it with the DI container.
 
 **Options:**
+
 - `singleton?: boolean` (default: `true`) - Create a new instance each time or reuse the same instance
 - `container?: DIContainer` - Specify a custom container (defaults to global container)
-  - Note: Import as `import { Container as DIContainer } from 'di-framework/container'` to avoid name collision with the `@Container` decorator.
+  - Note: Import as `import { Container as DIContainer } from '@di-framework/di-framework/container'` to avoid name collision with the `@Container` decorator.
 
 **Example:**
+
 ```typescript
 @Container({ singleton: false })
 export class RequestScopedService {
@@ -90,9 +92,11 @@ export class RequestScopedService {
 Marks a constructor parameter or property for dependency injection.
 
 **Parameters:**
+
 - `target` - The class to inject or a string identifier for factory-registered services
 
 **Example - Constructor Parameter:**
+
 ```typescript
 @Container()
 export class OrderService {
@@ -101,6 +105,7 @@ export class OrderService {
 ```
 
 **Example - Property Injection:**
+
 ```typescript
 @Container()
 export class ReportService {
@@ -114,9 +119,11 @@ export class ReportService {
 Marks a method for telemetry tracking. When called, it emits a `telemetry` event on the container. Works with both synchronous and asynchronous methods.
 
 **Options:**
+
 - `logging?: boolean` (default: `false`) - If true, logs the method execution details (status and duration) to the console.
 
 **Example:**
+
 ```typescript
 @Container()
 export class ApiService {
@@ -132,12 +139,15 @@ export class ApiService {
 Marks a method as a listener for telemetry events. The method will be automatically registered to the container's `telemetry` event when the service is instantiated.
 
 **Example:**
+
 ```typescript
 @Container()
 export class MonitoringService {
   @TelemetryListener()
   onTelemetry(event: any) {
-    console.log(`Method ${event.className}.${event.methodName} took ${event.endTime - event.startTime}ms`);
+    console.log(
+      `Method ${event.className}.${event.methodName} took ${event.endTime - event.startTime}ms`,
+    );
   }
 }
 ```
@@ -147,7 +157,7 @@ export class MonitoringService {
 Returns the global DI container instance.
 
 ```typescript
-import { useContainer } from 'di-framework/container';
+import { useContainer } from '@di-framework/di-framework/container';
 
 const container = useContainer();
 ```
@@ -165,10 +175,14 @@ container.register(UserService, { singleton: true });
 Register a service using a factory function.
 
 ```typescript
-container.registerFactory('config', () => ({
-  apiKey: process.env.API_KEY,
-  dbUrl: process.env.DATABASE_URL
-}), { singleton: true });
+container.registerFactory(
+  'config',
+  () => ({
+    apiKey: process.env.API_KEY,
+    dbUrl: process.env.DATABASE_URL,
+  }),
+  { singleton: true },
+);
 ```
 
 ### `container.resolve(serviceClass)`
@@ -205,12 +219,14 @@ console.log(names); // ['DatabaseService', 'UserService', ...]
 Subscribe to DI container lifecycle events (observer pattern).
 
 **Events:**
+
 - `registered` - fired when a class or factory is registered
 - `resolved` - fired whenever a service is resolved (cached or fresh)
 - `constructed` - fired when `construct()` creates a new instance
 - `cleared` - fired when the container is cleared
 
 **Example:**
+
 ```typescript
 const unsubscribe = container.on('resolved', ({ key, fromCache }) => {
   console.log(`Resolved ${typeof key === 'string' ? key : key.name} (fromCache=${fromCache})`);
@@ -224,11 +240,14 @@ 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/decorators';
-import { LoggerService } from 'di-framework/services/LoggerService';
+import { Component } from '@di-framework/di-framework/decorators';
+import { LoggerService } from '@di-framework/di-framework/services/LoggerService';
 
 class Greeter {
-  constructor(@Component(LoggerService) private logger: LoggerService, private greeting: string) {}
+  constructor(
+    @Component(LoggerService) private logger: LoggerService,
+    private greeting: string,
+  ) {}
 }
 
 const greeter = container.construct(Greeter, { 1: 'hello world' });
@@ -252,7 +271,7 @@ export class ApplicationContext {
   constructor(
     @Component(DatabaseService) private db: DatabaseService,
     @Component(LoggerService) private logger: LoggerService,
-    @Component(AuthService) private auth: AuthService
+    @Component(AuthService) private auth: AuthService,
   ) {}
 
   async initialize() {
@@ -314,12 +333,16 @@ db.connect();
 ### Factory Functions
 
 ```typescript
-container.registerFactory('apiClient', () => {
-  return new HttpClient({
-    baseUrl: process.env.API_URL,
-    timeout: 5000
-  });
-}, { singleton: true });
+container.registerFactory(
+  'apiClient',
+  () => {
+    return new HttpClient({
+      baseUrl: process.env.API_URL,
+      timeout: 5000,
+    });
+  },
+  { singleton: true },
+);
 
 // Use in services
 @Container()
@@ -343,9 +366,10 @@ export class UserService {
 ## Comparison with SAMPLE.ts
 
 ### Before (Manual - SAMPLE.ts)
+
 ```typescript
 const createServerContext = (env, ctx) => {
-  if(!instanceState.member) {
+  if (!instanceState.member) {
     const contextInstance = Context.create({
       contactService: ContactService.create({}),
       assetService: AssetService.create({}),
@@ -363,20 +387,22 @@ const createServerContext = (env, ctx) => {
   instanceState.member.setCtx(ctx);
   // ... manual dependency wiring
   instanceState.member.knowledgeService.setAttachmentService(
-    instanceState.member.attachmentService
+    instanceState.member.attachmentService,
   );
   return instanceState.member;
 };
 ```
 
 ### After (DI Framework)
+
 ```typescript
 @Container()
 export class ApplicationContext {
   constructor(
     @Component(ContactService) private contactService: ContactService,
     @Component(AssetService) private assetService: AssetService,
-    @Component(TransactionService) private transactionService: TransactionService,
+    @Component(TransactionService)
+    private transactionService: TransactionService,
     // ... all services automatically injected
     @Component(ChatService) private chatService: ChatService,
   ) {}
@@ -399,6 +425,7 @@ appContext.setCtx(ctx);
 ```
 
 **Benefits:**
+
 - No manual service instantiation
 - No manual dependency wiring
 - Automatic singleton management
@@ -409,6 +436,7 @@ appContext.setCtx(ctx);
 ## Error Handling
 
 ### Circular Dependencies
+
 ```typescript
 // This will be detected and throw an error:
 @Container()
@@ -425,6 +453,7 @@ class ServiceB {
 ```
 
 ### Unregistered Services
+
 ```typescript
 @Container()
 class MyService {
@@ -448,13 +477,15 @@ class MyService {
 
 ```typescript
 // Create a test container
-import { Container as DIContainer } from 'di-framework/container';
+import { Container as DIContainer } from '@di-framework/di-framework/container';
 
 const testContainer = new DIContainer();
 
 // Register mock implementations
 class MockDatabaseService {
-  query() { return { mock: true }; }
+  query() {
+    return { mock: true };
+  }
 }
 
 testContainer.register(MockDatabaseService);

package/dist/container.d.ts

@@ -40,6 +40,9 @@ type ContainerEventPayloads = {
 type Listener<T> = (payload: T) => void;
 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;
@@ -48,6 +51,7 @@ export declare class Container {
     private services;
     private resolutionStack;
     private listeners;
+    private cronJobs;
     /**
      * Register a service class as injectable
      */
@@ -78,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
      */
@@ -93,12 +101,20 @@ export declare class Container {
      * Subscribe to container lifecycle events (observer pattern).
      * Returns an unsubscribe function.
      */
-    on<K extends keyof ContainerEventPayloads>(event: K, listener: Listener<ContainerEventPayloads[K]>): () => void;
+    on<K extends keyof ContainerEventPayloads | (string & {})>(event: K, listener: Listener<K extends keyof ContainerEventPayloads ? ContainerEventPayloads[K] : any>): () => void;
     /**
      * Remove a previously registered listener
      */
-    off<K extends keyof ContainerEventPayloads>(event: K, listener: Listener<ContainerEventPayloads[K]>): void;
-    private emit;
+    off<K extends keyof ContainerEventPayloads | (string & {})>(event: K, listener: Listener<K extends keyof ContainerEventPayloads ? ContainerEventPayloads[K] : any>): void;
+    emit<K extends keyof ContainerEventPayloads | (string & {})>(event: K, payload: K extends keyof ContainerEventPayloads ? ContainerEventPayloads[K] : any): void;
+    /**
+     * 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

@@ -10,6 +10,9 @@ 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
@@ -30,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
      */
@@ -145,9 +208,19 @@ export class Container {
      */
     clear() {
         const count = this.services.size;
+        this.stopCronJobs();
         this.services.clear();
         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
      */
@@ -200,7 +273,148 @@ export class Container {
                 listener(payload);
             }
             catch (err) {
-                console.error(`[Container] listener for '${event}' threw`, err);
+                console.error(`[Container] listener for '${String(event)}' threw`, err);
+            }
+        });
+    }
+    /**
+     * Apply event publishers and subscribers defined via decorators
+     */
+    applyEvents(instance, constructor) {
+        const className = constructor.name;
+        // Handle @Subscriber(event)
+        const subscriberMap = getMetadata(SUBSCRIBER_METADATA_KEY, constructor.prototype) || {};
+        Object.entries(subscriberMap).forEach(([event, methods]) => {
+            methods.forEach((methodName) => {
+                const method = instance[methodName];
+                if (typeof method === 'function') {
+                    this.on(event, (payload) => {
+                        try {
+                            method.call(instance, payload);
+                        }
+                        catch (err) {
+                            console.error(`[Container] Subscriber '${className}.${methodName}' for event '${event}' threw`, err);
+                        }
+                    });
+                }
+            });
+        });
+        // Handle @Publisher(options)
+        const publisherMethods = getMetadata(PUBLISHER_METADATA_KEY, constructor.prototype) || {};
+        Object.entries(publisherMethods).forEach(([methodName, options]) => {
+            const originalMethod = instance[methodName];
+            if (typeof originalMethod === 'function') {
+                const self = this;
+                const phase = options.phase ?? 'after';
+                instance[methodName] = function (...args) {
+                    const startTime = Date.now();
+                    const emit = (result, error) => {
+                        const payload = {
+                            className,
+                            methodName,
+                            args,
+                            startTime,
+                            endTime: Date.now(),
+                            result,
+                            error,
+                        };
+                        if (options.logging) {
+                            const duration = payload.endTime - payload.startTime;
+                            const status = error
+                                ? `ERROR: ${error && error.message ? error.message : String(error)}`
+                                : 'SUCCESS';
+                            console.log(`[Publisher] ${className}.${methodName} -> '${options.event}' - ${status} (${duration}ms)`);
+                        }
+                        self.emit(options.event, payload);
+                    };
+                    try {
+                        if (phase === 'before' || phase === 'both') {
+                            // Emit before invocation (no result yet)
+                            emit(undefined, undefined);
+                        }
+                        const result = originalMethod.apply(this, args);
+                        if (result instanceof Promise) {
+                            return result
+                                .then((val) => {
+                                if (phase === 'after' || phase === 'both') {
+                                    emit(val, undefined);
+                                }
+                                return val;
+                            })
+                                .catch((err) => {
+                                // Always emit on error to allow subscribers to react
+                                emit(undefined, err);
+                                throw err;
+                            });
+                        }
+                        if (phase === 'after' || phase === 'both') {
+                            emit(result, undefined);
+                        }
+                        return result;
+                    }
+                    catch (err) {
+                        emit(undefined, err);
+                        throw err;
+                    }
+                };
+            }
+        });
+    }
+    /**
+     * 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();
             }
         });
     }
@@ -255,11 +469,18 @@ export class Container {
         const instance = new type(...dependencies);
         // Apply Telemetry and TelemetryListener
         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 allInjectProperties = { ...injectProperties, ...protoInjectProperties };
+        const allInjectProperties = {
+            ...injectProperties,
+            ...protoInjectProperties,
+        };
         Object.entries(allInjectProperties).forEach(([propName, targetType]) => {
             if (!propName.startsWith('param_') && targetType) {
                 try {
@@ -345,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

package/dist/decorators.d.ts

@@ -31,6 +31,54 @@ export declare function Telemetry(options?: TelemetryOptions): (target: any, pro
  * The method will be automatically registered to the container's 'telemetry' event.
  */
 export declare function TelemetryListener(): (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => void;
+/**
+ * Options for the @Publisher decorator
+ */
+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';
+    /** Optional console logging for debug purposes. Defaults to false. */
+    logging?: boolean;
+}
+/**
+ * Marks a method to publish a custom event on invocation.
+ * Useful for cross-platform event-driven architectures.
+ *
+ * Example:
+ * @Container()
+ * class UserService {
+ *   @Publisher('user.created')
+ *   createUser(dto: CreateUserDto) { ... }
+ * }
+ */
+export declare function Publisher(optionsOrEvent: string | PublisherOptions): (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => void;
+/**
+ * Marks a method to subscribe to a custom event emitted on the container.
+ * The decorated method will receive the published payload.
+ *
+ * Example:
+ * @Container()
+ * class AuditService {
+ *   @Subscriber('user.created')
+ *   onUserCreated(payload: any) { ... }
+ * }
+ */
+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
  *
@@ -54,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
  *
@@ -82,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,7 +7,7 @@
  * 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 } from './container';
+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';
 /**
@@ -35,6 +35,68 @@ export function TelemetryListener() {
         defineMetadata(TELEMETRY_LISTENER_METADATA_KEY, listeners, target);
     };
 }
+/**
+ * Marks a method to publish a custom event on invocation.
+ * Useful for cross-platform event-driven architectures.
+ *
+ * Example:
+ * @Container()
+ * class UserService {
+ *   @Publisher('user.created')
+ *   createUser(dto: CreateUserDto) { ... }
+ * }
+ */
+export function Publisher(optionsOrEvent) {
+    return function (target, propertyKey, descriptor) {
+        const options = typeof optionsOrEvent === 'string' ? { event: optionsOrEvent } : optionsOrEvent;
+        const methods = getOwnMetadata(PUBLISHER_METADATA_KEY, target) || {};
+        methods[propertyKey] = {
+            event: options.event,
+            phase: options.phase ?? 'after',
+            logging: options.logging ?? false,
+        };
+        defineMetadata(PUBLISHER_METADATA_KEY, methods, target);
+    };
+}
+/**
+ * Marks a method to subscribe to a custom event emitted on the container.
+ * The decorated method will receive the published payload.
+ *
+ * Example:
+ * @Container()
+ * class AuditService {
+ *   @Subscriber('user.created')
+ *   onUserCreated(payload: any) { ... }
+ * }
+ */
+export function Subscriber(event) {
+    return function (target, propertyKey, descriptor) {
+        const map = getOwnMetadata(SUBSCRIBER_METADATA_KEY, target) || {};
+        if (!map[event])
+            map[event] = [];
+        map[event].push(propertyKey);
+        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
  *
@@ -63,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@di-framework/di-framework",
-  "version": "2.0.4",
+  "version": "3.0.0",
   "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",
@@ -19,12 +19,25 @@
   ],
   "exports": {
     ".": {
+      "bun": "./container.ts",
       "import": "./dist/container.js",
       "types": "./dist/container.d.ts"
     },
-    "./container": "./dist/container.js",
-    "./decorators": "./dist/decorators.js",
-    "./types": "./dist/types.js"
+    "./container": {
+      "bun": "./container.ts",
+      "import": "./dist/container.js",
+      "types": "./dist/container.d.ts"
+    },
+    "./decorators": {
+      "bun": "./decorators.ts",
+      "import": "./dist/decorators.js",
+      "types": "./dist/decorators.d.ts"
+    },
+    "./types": {
+      "bun": "./types.ts",
+      "import": "./dist/types.js",
+      "types": "./dist/types.d.ts"
+    }
   },
   "license": "MIT",
   "repository": {