@di-framework/di-framework 2.0.4

package/dist/types.d.ts

@@ -0,0 +1,242 @@
+/**
+ * Type Definitions and Utilities for the DI Framework
+ *
+ * Provides interfaces and utility types for building services
+ */
+/**
+ * Represents a service class constructor
+ */
+export type ServiceClass<T> = new (...args: any[]) => T;
+/**
+ * Represents a factory function that creates a service
+ */
+export type ServiceFactory<T> = () => T;
+/**
+ * Service registration options
+ */
+export interface InjectionOptions {
+    /**
+     * Whether this service should be a singleton (default: true)
+     * Singleton: same instance returned for each resolution
+     * Transient: new instance created for each resolution
+     */
+    singleton?: boolean;
+}
+/**
+ * Service with lifecycle methods
+ */
+export interface ILifecycleService {
+    /**
+     * Called after the service is created
+     */
+    onInit?(): void;
+    /**
+     * Called before the service is destroyed
+     */
+    onDestroy?(): void;
+    /**
+     * Called to set environment variables
+     */
+    setEnv?(env: Record<string, any>): void;
+    /**
+     * Called to set execution context
+     */
+    setCtx?(context: any): void;
+}
+/**
+ * Error thrown when DI resolution fails
+ */
+export declare class DIError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when circular dependency is detected
+ */
+export declare class CircularDependencyError extends DIError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when service is not registered
+ */
+export declare class ServiceNotFoundError extends DIError {
+    constructor(serviceName: string);
+}
+/**
+ * Type-safe service class identity
+ *
+ * Use this to ensure type safety when working with service classes
+ *
+ * @example
+ * type UserServiceId = ServiceId<UserService>;
+ * const serviceId: UserServiceId = UserService;
+ */
+export type ServiceId<T> = ServiceClass<T>;
+/**
+ * Utility type to extract the constructor parameters of a service
+ *
+ * @example
+ * type UserServiceDeps = ConstructorParameters<typeof UserService>;
+ */
+export type ServiceDependencies<T> = T extends ServiceClass<infer U> ? ConstructorParameters<ServiceClass<U>> : never;
+/**
+ * Utility type to make all properties of a service optional
+ *
+ * @example
+ * @Container()
+ * class MyService implements PartialService<MyService> {
+ *   optionalDependency?: SomeService;
+ * }
+ */
+export type PartialService<T> = Partial<T>;
+/**
+ * Utility to create a service instance with mocked dependencies
+ *
+ * @example
+ * const mockUserService = new MockService<UserService>({
+ *   database: mockDb,
+ *   logger: mockLogger
+ * });
+ */
+export type MockServiceOptions<T> = {
+    [K in keyof T]?: T[K];
+};
+/**
+ * Represents a resolvable service in the container
+ */
+export type Resolvable = ServiceClass<any> | string;
+/**
+ * Configuration for the DI container
+ */
+export interface ContainerConfig {
+    /**
+     * Whether to throw on unregistered services (default: true)
+     */
+    throwOnUnregistered?: boolean;
+    /**
+     * Whether to detect circular dependencies (default: true)
+     */
+    detectCircularDependencies?: boolean;
+    /**
+     * Maximum recursion depth for dependency resolution (default: 100)
+     */
+    maxResolutionDepth?: number;
+}
+/**
+ * Service metadata stored in the container
+ */
+export interface ServiceMetadata<T = any> {
+    type: ServiceClass<T> | ServiceFactory<T>;
+    singleton: boolean;
+    instance?: T;
+    dependencies?: string[];
+    createdAt?: Date;
+}
+/**
+ * Result of resolving a service
+ */
+export interface ResolutionResult<T = any> {
+    service: T;
+    serviceClass: ServiceClass<T>;
+    isSingleton: boolean;
+    resolutionTimeMs: number;
+}
+/**
+ * Information about a registered service
+ */
+export interface ServiceInfo {
+    name: string;
+    isSingleton: boolean;
+    dependencies: string[];
+    hasInstance: boolean;
+}
+/**
+ * Generic service base class with lifecycle support
+ *
+ * @example
+ * @Container()
+ * export class MyService extends BaseService {
+ *   onInit() {
+ *     console.log('Service initialized');
+ *   }
+ * }
+ */
+export declare abstract class BaseService implements ILifecycleService {
+    protected logger: ILogger;
+    onInit?(): void;
+    onDestroy?(): void;
+    setEnv?(env: Record<string, any>): void;
+    setCtx?(context: any): void;
+    protected log(message: string): void;
+    protected error(message: string): void;
+}
+/**
+ * Logger interface for services
+ */
+export interface ILogger {
+    log(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+    debug(message: string): void;
+}
+/**
+ * Console-based logger implementation
+ */
+export declare class ConsoleLogger implements ILogger {
+    log(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+    debug(message: string): void;
+}
+/**
+ * Utility functions for working with services
+ */
+export declare namespace ServiceUtils {
+    /**
+     * Check if an object is a service class
+     */
+    function isServiceClass(obj: any): obj is ServiceClass<any>;
+    /**
+     * Check if an object is a factory function
+     */
+    function isFactory(obj: any): obj is ServiceFactory<any>;
+    /**
+     * Get the service name
+     */
+    function getServiceName(service: Resolvable): string;
+    /**
+     * Create a mock service for testing
+     */
+    function createMockService<T>(overrides?: Partial<T>): Partial<T>;
+}
+/**
+ * Decorator factory for creating custom decorators
+ *
+ * @example
+ * export function Cached(ttl: number = 60000) {
+ *   return function (
+ *     target: any,
+ *     propertyKey: string,
+ *     descriptor: PropertyDescriptor
+ *   ) {
+ *     const originalMethod = descriptor.value;
+ *     const cache = new Map<string, { data: any; time: number }>();
+ *
+ *     descriptor.value = function (...args: any[]) {
+ *       const key = JSON.stringify(args);
+ *       const cached = cache.get(key);
+ *       const now = Date.now();
+ *
+ *       if (cached && now - cached.time < ttl) {
+ *         return cached.data;
+ *       }
+ *
+ *       const result = originalMethod.apply(this, args);
+ *       cache.set(key, { data: result, time: now });
+ *       return result;
+ *     };
+ *
+ *     return descriptor;
+ *   };
+ * }
+ */
+export declare function createDecorator<T extends (...args: any[]) => any>(decorator: T): T;

package/dist/types.js

@@ -0,0 +1,140 @@
+/**
+ * Type Definitions and Utilities for the DI Framework
+ *
+ * Provides interfaces and utility types for building services
+ */
+/**
+ * Error thrown when DI resolution fails
+ */
+export class DIError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DIError';
+    }
+}
+/**
+ * Error thrown when circular dependency is detected
+ */
+export class CircularDependencyError extends DIError {
+    constructor(message) {
+        super(message);
+        this.name = 'CircularDependencyError';
+    }
+}
+/**
+ * Error thrown when service is not registered
+ */
+export class ServiceNotFoundError extends DIError {
+    constructor(serviceName) {
+        super(`Service '${serviceName}' is not registered in the DI container`);
+        this.name = 'ServiceNotFoundError';
+    }
+}
+/**
+ * Generic service base class with lifecycle support
+ *
+ * @example
+ * @Container()
+ * export class MyService extends BaseService {
+ *   onInit() {
+ *     console.log('Service initialized');
+ *   }
+ * }
+ */
+export class BaseService {
+    logger = new ConsoleLogger();
+    log(message) {
+        this.logger.log(message);
+    }
+    error(message) {
+        this.logger.error(message);
+    }
+}
+/**
+ * Console-based logger implementation
+ */
+export class ConsoleLogger {
+    log(message) {
+        console.log(`[LOG] ${message}`);
+    }
+    error(message) {
+        console.error(`[ERROR] ${message}`);
+    }
+    warn(message) {
+        console.warn(`[WARN] ${message}`);
+    }
+    debug(message) {
+        console.debug(`[DEBUG] ${message}`);
+    }
+}
+/**
+ * Utility functions for working with services
+ */
+export var ServiceUtils;
+(function (ServiceUtils) {
+    /**
+     * Check if an object is a service class
+     */
+    function isServiceClass(obj) {
+        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);
+    }
+    ServiceUtils.isFactory = isFactory;
+    /**
+     * Get the service name
+     */
+    function getServiceName(service) {
+        if (typeof service === 'string') {
+            return service;
+        }
+        return service.name;
+    }
+    ServiceUtils.getServiceName = getServiceName;
+    /**
+     * Create a mock service for testing
+     */
+    function createMockService(overrides = {}) {
+        return overrides;
+    }
+    ServiceUtils.createMockService = createMockService;
+})(ServiceUtils || (ServiceUtils = {}));
+/**
+ * Decorator factory for creating custom decorators
+ *
+ * @example
+ * export function Cached(ttl: number = 60000) {
+ *   return function (
+ *     target: any,
+ *     propertyKey: string,
+ *     descriptor: PropertyDescriptor
+ *   ) {
+ *     const originalMethod = descriptor.value;
+ *     const cache = new Map<string, { data: any; time: number }>();
+ *
+ *     descriptor.value = function (...args: any[]) {
+ *       const key = JSON.stringify(args);
+ *       const cached = cache.get(key);
+ *       const now = Date.now();
+ *
+ *       if (cached && now - cached.time < ttl) {
+ *         return cached.data;
+ *       }
+ *
+ *       const result = originalMethod.apply(this, args);
+ *       cache.set(key, { data: result, time: now });
+ *       return result;
+ *     };
+ *
+ *     return descriptor;
+ *   };
+ * }
+ */
+export function createDecorator(decorator) {
+    return decorator;
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@di-framework/di-framework",
+  "version": "2.0.4",
+  "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",
+  "module": "./dist/container.js",
+  "author": "github.com/geoffsee",
+  "type": "module",
+  "keywords": [
+    "dependency-injection",
+    "di",
+    "ioc",
+    "inversion-of-control",
+    "decorators",
+    "typescript",
+    "swc",
+    "framework"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/container.js",
+      "types": "./dist/container.d.ts"
+    },
+    "./container": "./dist/container.js",
+    "./decorators": "./dist/decorators.js",
+    "./types": "./dist/types.js"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/geoffsee/di-framework"
+  },
+  "bugs": {
+    "url": "https://github.com/geoffsee/di-framework/issues"
+  },
+  "homepage": "https://github.com/geoffsee/di-framework#readme",
+  "scripts": {
+    "test": "bun test"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "devDependencies": {},
+  "files": [
+    "dist",
+    "README.md",
+    "MIGRATION_GUIDE.md"
+  ]
+}