@geekmidas/services 0.1.0 → 0.2.0

package/src/context.ts

@@ -0,0 +1,91 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { Logger } from '@geekmidas/logger';
+import type { ServiceContext } from './types';
+
+/**
+ * Internal storage for request context data.
+ * Not exported - services use ServiceContext interface.
+ */
+export interface RequestContextData {
+	logger: Logger;
+	requestId: string;
+	startTime: number;
+}
+
+/**
+ * Internal AsyncLocalStorage instance for request context.
+ * Not exported - use runWithRequestContext() to establish context
+ * and serviceContext to access it.
+ */
+const requestContextStorage = new AsyncLocalStorage<RequestContextData>();
+
+/**
+ * ServiceContext implementation.
+ * Singleton that reads from AsyncLocalStorage.
+ * Methods throw if called outside a request context (catches bugs early).
+ */
+export const serviceContext: ServiceContext = {
+	getLogger() {
+		const store = requestContextStorage.getStore();
+		if (!store) {
+			throw new Error(
+				'ServiceContext.getLogger() called outside request context. ' +
+					'Ensure code runs within runWithRequestContext().',
+			);
+		}
+		return store.logger;
+	},
+
+	getRequestId() {
+		const store = requestContextStorage.getStore();
+		if (!store) {
+			throw new Error(
+				'ServiceContext.getRequestId() called outside request context. ' +
+					'Ensure code runs within runWithRequestContext().',
+			);
+		}
+		return store.requestId;
+	},
+
+	getRequestStartTime() {
+		const store = requestContextStorage.getStore();
+		if (!store) {
+			throw new Error(
+				'ServiceContext.getRequestStartTime() called outside request context. ' +
+					'Ensure code runs within runWithRequestContext().',
+			);
+		}
+		return store.startTime;
+	},
+
+	hasContext() {
+		return requestContextStorage.getStore() !== undefined;
+	},
+};
+
+/**
+ * Run a function with request context.
+ * Used by endpoint/function/subscriber adaptors.
+ *
+ * @param data - Request context data (logger, requestId, startTime)
+ * @param fn - Function to run with context
+ * @returns Result of the function
+ *
+ * @example
+ * ```typescript
+ * const result = await runWithRequestContext(
+ *   { logger, requestId, startTime: Date.now() },
+ *   async () => {
+ *     // Inside here, serviceContext.getLogger() returns `logger`
+ *     // serviceContext.getRequestId() returns `requestId`
+ *     return await handleRequest();
+ *   }
+ * );
+ * ```
+ */
+export function runWithRequestContext<T>(
+	data: RequestContextData,
+	fn: () => T | Promise<T>,
+): T | Promise<T> {
+	return requestContextStorage.run(data, fn);
+}

package/src/index.ts

@@ -1,295 +1,15 @@
-import type { EnvironmentParser } from '@geekmidas/envkit';
-import type { Logger } from '@geekmidas/logger';
-
-/**
- * Service interface for the new simplified service pattern.
- * Services are objects with a serviceName and register method.
- *
- * @template TName - The literal string type for the service name
- * @template TInstance - The type of the service instance that will be registered
- *
- * @example
- * ```typescript
- * class DatabaseService implements Service<'database', Database> {
- *   serviceName = 'database' as const;
- *
- *   async register(envParser: EnvironmentParser<{}>): Promise<Database> {
- *     const config = envParser.create((get) => ({
- *       url: get('DATABASE_URL').string()
- *     })).parse();
- *
- *     return new Database(config.url);
- *   }
- * }
- * ```
- */
-export interface Service<TName extends string = string, TInstance = unknown> {
-  /**
-   * Unique name for the service, used for lookup via services.get()
-   */
-  serviceName: TName;
-  /**
-   * Register method that returns the actual service instance.
-   * Called once on first access, then cached.
-   */
-  register(envParser: EnvironmentParser<{}>): TInstance | Promise<TInstance>;
-}
-
-/**
- * Service discovery container that manages service registration and retrieval.
- * Implements a singleton pattern with lazy initialization of services.
- *
- * @template TServices - Record type mapping service names to their instance types
- * @template TLogger - Logger type for internal logging
- *
- * @example
- * ```typescript
- * // Define service types
- * interface MyServices {
- *   database: Database;
- *   cache: CacheService;
- *   auth: AuthService;
- * }
- *
- * // Get service discovery instance
- * const discovery = ServiceDiscovery.getInstance<MyServices>(logger, envParser);
- *
- * // Register services
- * await discovery.register([
- *   new DatabaseService(),
- *   new CacheService(),
- *   new AuthService()
- * ]);
- *
- * // Retrieve services
- * const db = await discovery.get('database');
- * const { cache, auth } = await discovery.getMany(['cache', 'auth']);
- * ```
- */
-export class ServiceDiscovery<
-  TServices extends Record<string, unknown> = {},
-  TLogger extends Logger = Logger,
-> {
-  /** Singleton instance of ServiceDiscovery */
-  private static _instance: ServiceDiscovery<any, any>;
-  /** Map of registered service definitions */
-  private services = new Map<string, Service>();
-  /** Map of instantiated service instances */
-  private instances = new Map<keyof TServices, TServices[keyof TServices]>();
-
-  /**
-   * Gets the singleton instance of ServiceDiscovery.
-   * Creates a new instance if one doesn't exist.
-   *
-   * @template T - Record type mapping service names to their instance types
-   * @template TLogger - Logger type for internal logging
-   * @param logger - Logger instance for service logging
-   * @param envParser - Environment parser for service configuration
-   * @returns The ServiceDiscovery singleton instance
-   *
-   * @example
-   * ```typescript
-   * const services = ServiceDiscovery.getInstance<MyServices>(logger, envParser);
-   * ```
-   */
-  static getInstance<
-    T extends Record<any, unknown> = any,
-    TLogger extends Logger = Logger,
-  >(logger: TLogger, envParser: EnvironmentParser<{}>): ServiceDiscovery<T> {
-    if (!ServiceDiscovery._instance) {
-      ServiceDiscovery._instance = new ServiceDiscovery<T, TLogger>(
-        logger,
-        envParser,
-      );
-    }
-    return ServiceDiscovery._instance as ServiceDiscovery<T>;
-  }
-
-  /**
-   * Resets the singleton instance. Use only for testing purposes.
-   * This clears all cached services and allows a fresh instance to be created.
-   *
-   * @example
-   * ```typescript
-   * // In test teardown
-   * afterEach(() => {
-   *   ServiceDiscovery.reset();
-   * });
-   * ```
-   */
-  static reset(): void {
-    ServiceDiscovery._instance = undefined as any;
-  }
-
-  /**
-   * Private constructor to enforce singleton pattern.
-   *
-   * @param logger - Logger instance for service logging
-   * @param envParser - Environment parser for service configuration
-   * @private
-   */
-  private constructor(
-    readonly logger: TLogger,
-    readonly envParser: EnvironmentParser<{}>,
-  ) {}
-
-  /**
-   * Register multiple services with the service discovery.
-   * Services are instantiated lazily on first access.
-   * Already instantiated services are returned from cache.
-   *
-   * @template T - Array type of services to register
-   * @param services - Array of services to register
-   * @returns Promise resolving to a record of service names to instances
-   *
-   * @example
-   * ```typescript
-   * const services = await discovery.register([
-   *   new DatabaseService(),
-   *   new CacheService(),
-   *   new AuthService()
-   * ]);
-   *
-   * // services = {
-   * //   database: Database instance,
-   * //   cache: CacheService instance,
-   * //   auth: AuthService instance
-   * // }
-   * ```
-   */
-  async register<T extends Service[]>(services: T): Promise<ServiceRecord<T>> {
-    const registeredServices = {} as ServiceRecord<T>;
-    for (const service of services) {
-      const name = service.serviceName as T[number]['serviceName'];
-      if (this.instances.has(name)) {
-        (registeredServices as any)[name] = this.instances.get(
-          name,
-        ) as TServices[keyof TServices];
-        continue;
-      }
-
-      const instance = await service.register(this.envParser);
-
-      this.instances.set(name, instance as TServices[keyof TServices]);
-      (registeredServices as any)[name] =
-        instance as TServices[keyof TServices];
-    }
-
-    return registeredServices;
-  }
-
-  /**
-   * Get a service from the service discovery.
-   * Services are instantiated on first access if not already cached.
-   *
-   * @template K - The service name key
-   * @param name - The name of the service to get
-   * @returns Promise resolving to the service instance
-   * @throws {Error} If the service is not registered
-   *
-   * @example
-   * ```typescript
-   * const database = await discovery.get('database');
-   * const users = await database.query('SELECT * FROM users');
-   * ```
-   */
-  get<K extends keyof TServices & string>(name: K): Promise<TServices[K]> {
-    const service = this.services.get(name);
-
-    if (!service) {
-      throw new Error(`Service '${name}' not found in service discovery`);
-    }
-
-    return service.register(this.envParser) as Promise<TServices[K]>;
-  }
-  /**
-   * Get multiple services from the service discovery.
-   * Useful for retrieving multiple dependencies at once.
-   *
-   * @template K - Array of service name keys
-   * @param names - Array of service names to retrieve
-   * @returns Promise resolving to an object containing the service instances
-   *
-   * @example
-   * ```typescript
-   * const { database, cache, auth } = await discovery.getMany([
-   *   'database',
-   *   'cache',
-   *   'auth'
-   * ]);
-   * ```
-   */
-  async getMany<K extends (keyof TServices & string)[]>(
-    names: [...K],
-  ): Promise<{ [P in K[number]]: TServices[P] }> {
-    const result = {} as { [P in K[number]]: TServices[P] };
-
-    for (const name of names) {
-      result[name] = await this.get(name);
-    }
-
-    return result;
-  }
-
-  /**
-   * Check if a service exists in the service discovery.
-   * Can check by service name or service instance.
-   *
-   * @param service - The service name or service instance to check
-   * @returns True if the service exists, false otherwise
-   *
-   * @example
-   * ```typescript
-   * if (discovery.has('database')) {
-   *   const db = await discovery.get('database');
-   * }
-   *
-   * // Or check with service instance
-   * const dbService = new DatabaseService();
-   * if (!discovery.has(dbService)) {
-   *   await discovery.register([dbService]);
-   * }
-   * ```
-   */
-  has(service: string | Service): boolean {
-    if (typeof service === 'string') {
-      return this.services.has(service);
-    }
-
-    return this.services.has(service.serviceName);
-  }
-}
-
-/**
- * Utility type to extract service names from an array of services.
- *
- * @template T - Array of Service types
- *
- * @example
- * ```typescript
- * type Names = ExtractServiceNames<[DatabaseService, CacheService]>;
- * // type Names = 'database' | 'cache'
- * ```
- */
-export type ExtractServiceNames<T extends Service[]> = T[number]['serviceName'];
-
-/**
- * Utility type to create a record type from an array of services.
- * Maps service names to their registered instance types.
- *
- * @template T - Array of Service types
- *
- * @example
- * ```typescript
- * type MyServiceRecord = ServiceRecord<[DatabaseService, CacheService]>;
- * // type MyServiceRecord = {
- * //   database: Database;
- * //   cache: CacheService;
- * // }
- * ```
- */
-export type ServiceRecord<T extends Service[]> = {
-  [K in T[number] as K['serviceName']]: K extends Service
-    ? Awaited<ReturnType<K['register']>>
-    : never;
-};
+// Re-export types
+
+// Re-export context utilities
+export {
+	type RequestContextData,
+	runWithRequestContext,
+	serviceContext,
+} from './context';
+// Re-export ServiceDiscovery and utility types
+export {
+	type ExtractServiceNames,
+	ServiceDiscovery,
+	type ServiceRecord,
+} from './ServiceDiscovery';
+export type { Service, ServiceContext, ServiceRegisterOptions } from './types';

package/src/types.ts

@@ -0,0 +1,85 @@
+import type { EnvironmentParser } from '@geekmidas/envkit';
+import type { Logger } from '@geekmidas/logger';
+
+/**
+ * Request context available to services.
+ * Methods are guaranteed to return values when called within a request context.
+ * Throws if called outside a request context (catches bugs early).
+ */
+export interface ServiceContext {
+	/**
+	 * Get the current request's logger.
+	 * @throws Error if called outside a request context
+	 */
+	getLogger(): Logger;
+
+	/**
+	 * Get the current request ID.
+	 * @throws Error if called outside a request context
+	 */
+	getRequestId(): string;
+
+	/**
+	 * Get the current request's start time (from Date.now()).
+	 * Useful for calculating request duration.
+	 * @throws Error if called outside a request context
+	 */
+	getRequestStartTime(): number;
+
+	/**
+	 * Check if currently running inside a request context.
+	 * Use this to guard calls if you need to handle both cases.
+	 */
+	hasContext(): boolean;
+}
+
+/**
+ * Options passed to service register method.
+ */
+export interface ServiceRegisterOptions {
+	/** Environment parser for configuration */
+	envParser: EnvironmentParser<{}>;
+	/** Request context for logging and tracing */
+	context: ServiceContext;
+}
+
+/**
+ * Service interface for the simplified service pattern.
+ * Services are objects with a serviceName and register method.
+ *
+ * @template TName - The literal string type for the service name
+ * @template TInstance - The type of the service instance that will be registered
+ *
+ * @example
+ * ```typescript
+ * const databaseService = {
+ *   serviceName: 'database' as const,
+ *   register({ envParser, context }: ServiceRegisterOptions) {
+ *     const config = envParser.create((get) => ({
+ *       url: get('DATABASE_URL').string()
+ *     })).parse();
+ *
+ *     return {
+ *       async query(sql: string) {
+ *         const logger = context.getLogger();
+ *         logger.debug({ sql }, 'Executing query');
+ *         // ... execute query
+ *       }
+ *     };
+ *   }
+ * } satisfies Service<'database', DatabaseInstance>;
+ * ```
+ */
+export interface Service<TName extends string = string, TInstance = unknown> {
+	/**
+	 * Unique name for the service, used for lookup via services.get()
+	 */
+	serviceName: TName;
+	/**
+	 * Register method that returns the actual service instance.
+	 * Called once on first access, then cached.
+	 *
+	 * @param options - Registration options including envParser and context
+	 */
+	register(options: ServiceRegisterOptions): TInstance | Promise<TInstance>;
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": true
+  },
+  "include": ["src/**/*"]
+}

package/dist/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","names":["logger: TLogger","envParser: EnvironmentParser<{}>","services: T","name: K","names: [...K]","service: string | Service"],"sources":["../src/index.ts"],"sourcesContent":["import type { EnvironmentParser } from '@geekmidas/envkit';\nimport type { Logger } from '@geekmidas/logger';\n\n/**\n * Service interface for the new simplified service pattern.\n * Services are objects with a serviceName and register method.\n *\n * @template TName - The literal string type for the service name\n * @template TInstance - The type of the service instance that will be registered\n *\n * @example\n * ```typescript\n * class DatabaseService implements Service<'database', Database> {\n *   serviceName = 'database' as const;\n *\n *   async register(envParser: EnvironmentParser<{}>): Promise<Database> {\n *     const config = envParser.create((get) => ({\n *       url: get('DATABASE_URL').string()\n *     })).parse();\n *\n *     return new Database(config.url);\n *   }\n * }\n * ```\n */\nexport interface Service<TName extends string = string, TInstance = unknown> {\n  /**\n   * Unique name for the service, used for lookup via services.get()\n   */\n  serviceName: TName;\n  /**\n   * Register method that returns the actual service instance.\n   * Called once on first access, then cached.\n   */\n  register(envParser: EnvironmentParser<{}>): TInstance | Promise<TInstance>;\n}\n\n/**\n * Service discovery container that manages service registration and retrieval.\n * Implements a singleton pattern with lazy initialization of services.\n *\n * @template TServices - Record type mapping service names to their instance types\n * @template TLogger - Logger type for internal logging\n *\n * @example\n * ```typescript\n * // Define service types\n * interface MyServices {\n *   database: Database;\n *   cache: CacheService;\n *   auth: AuthService;\n * }\n *\n * // Get service discovery instance\n * const discovery = ServiceDiscovery.getInstance<MyServices>(logger, envParser);\n *\n * // Register services\n * await discovery.register([\n *   new DatabaseService(),\n *   new CacheService(),\n *   new AuthService()\n * ]);\n *\n * // Retrieve services\n * const db = await discovery.get('database');\n * const { cache, auth } = await discovery.getMany(['cache', 'auth']);\n * ```\n */\nexport class ServiceDiscovery<\n  TServices extends Record<string, unknown> = {},\n  TLogger extends Logger = Logger,\n> {\n  /** Singleton instance of ServiceDiscovery */\n  private static _instance: ServiceDiscovery<any, any>;\n  /** Map of registered service definitions */\n  private services = new Map<string, Service>();\n  /** Map of instantiated service instances */\n  private instances = new Map<keyof TServices, TServices[keyof TServices]>();\n\n  /**\n   * Gets the singleton instance of ServiceDiscovery.\n   * Creates a new instance if one doesn't exist.\n   *\n   * @template T - Record type mapping service names to their instance types\n   * @template TLogger - Logger type for internal logging\n   * @param logger - Logger instance for service logging\n   * @param envParser - Environment parser for service configuration\n   * @returns The ServiceDiscovery singleton instance\n   *\n   * @example\n   * ```typescript\n   * const services = ServiceDiscovery.getInstance<MyServices>(logger, envParser);\n   * ```\n   */\n  static getInstance<\n    T extends Record<any, unknown> = any,\n    TLogger extends Logger = Logger,\n  >(logger: TLogger, envParser: EnvironmentParser<{}>): ServiceDiscovery<T> {\n    if (!ServiceDiscovery._instance) {\n      ServiceDiscovery._instance = new ServiceDiscovery<T, TLogger>(\n        logger,\n        envParser,\n      );\n    }\n    return ServiceDiscovery._instance as ServiceDiscovery<T>;\n  }\n\n  /**\n   * Resets the singleton instance. Use only for testing purposes.\n   * This clears all cached services and allows a fresh instance to be created.\n   *\n   * @example\n   * ```typescript\n   * // In test teardown\n   * afterEach(() => {\n   *   ServiceDiscovery.reset();\n   * });\n   * ```\n   */\n  static reset(): void {\n    ServiceDiscovery._instance = undefined as any;\n  }\n\n  /**\n   * Private constructor to enforce singleton pattern.\n   *\n   * @param logger - Logger instance for service logging\n   * @param envParser - Environment parser for service configuration\n   * @private\n   */\n  private constructor(\n    readonly logger: TLogger,\n    readonly envParser: EnvironmentParser<{}>,\n  ) {}\n\n  /**\n   * Register multiple services with the service discovery.\n   * Services are instantiated lazily on first access.\n   * Already instantiated services are returned from cache.\n   *\n   * @template T - Array type of services to register\n   * @param services - Array of services to register\n   * @returns Promise resolving to a record of service names to instances\n   *\n   * @example\n   * ```typescript\n   * const services = await discovery.register([\n   *   new DatabaseService(),\n   *   new CacheService(),\n   *   new AuthService()\n   * ]);\n   *\n   * // services = {\n   * //   database: Database instance,\n   * //   cache: CacheService instance,\n   * //   auth: AuthService instance\n   * // }\n   * ```\n   */\n  async register<T extends Service[]>(services: T): Promise<ServiceRecord<T>> {\n    const registeredServices = {} as ServiceRecord<T>;\n    for (const service of services) {\n      const name = service.serviceName as T[number]['serviceName'];\n      if (this.instances.has(name)) {\n        (registeredServices as any)[name] = this.instances.get(\n          name,\n        ) as TServices[keyof TServices];\n        continue;\n      }\n\n      const instance = await service.register(this.envParser);\n\n      this.instances.set(name, instance as TServices[keyof TServices]);\n      (registeredServices as any)[name] =\n        instance as TServices[keyof TServices];\n    }\n\n    return registeredServices;\n  }\n\n  /**\n   * Get a service from the service discovery.\n   * Services are instantiated on first access if not already cached.\n   *\n   * @template K - The service name key\n   * @param name - The name of the service to get\n   * @returns Promise resolving to the service instance\n   * @throws {Error} If the service is not registered\n   *\n   * @example\n   * ```typescript\n   * const database = await discovery.get('database');\n   * const users = await database.query('SELECT * FROM users');\n   * ```\n   */\n  get<K extends keyof TServices & string>(name: K): Promise<TServices[K]> {\n    const service = this.services.get(name);\n\n    if (!service) {\n      throw new Error(`Service '${name}' not found in service discovery`);\n    }\n\n    return service.register(this.envParser) as Promise<TServices[K]>;\n  }\n  /**\n   * Get multiple services from the service discovery.\n   * Useful for retrieving multiple dependencies at once.\n   *\n   * @template K - Array of service name keys\n   * @param names - Array of service names to retrieve\n   * @returns Promise resolving to an object containing the service instances\n   *\n   * @example\n   * ```typescript\n   * const { database, cache, auth } = await discovery.getMany([\n   *   'database',\n   *   'cache',\n   *   'auth'\n   * ]);\n   * ```\n   */\n  async getMany<K extends (keyof TServices & string)[]>(\n    names: [...K],\n  ): Promise<{ [P in K[number]]: TServices[P] }> {\n    const result = {} as { [P in K[number]]: TServices[P] };\n\n    for (const name of names) {\n      result[name] = await this.get(name);\n    }\n\n    return result;\n  }\n\n  /**\n   * Check if a service exists in the service discovery.\n   * Can check by service name or service instance.\n   *\n   * @param service - The service name or service instance to check\n   * @returns True if the service exists, false otherwise\n   *\n   * @example\n   * ```typescript\n   * if (discovery.has('database')) {\n   *   const db = await discovery.get('database');\n   * }\n   *\n   * // Or check with service instance\n   * const dbService = new DatabaseService();\n   * if (!discovery.has(dbService)) {\n   *   await discovery.register([dbService]);\n   * }\n   * ```\n   */\n  has(service: string | Service): boolean {\n    if (typeof service === 'string') {\n      return this.services.has(service);\n    }\n\n    return this.services.has(service.serviceName);\n  }\n}\n\n/**\n * Utility type to extract service names from an array of services.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type Names = ExtractServiceNames<[DatabaseService, CacheService]>;\n * // type Names = 'database' | 'cache'\n * ```\n */\nexport type ExtractServiceNames<T extends Service[]> = T[number]['serviceName'];\n\n/**\n * Utility type to create a record type from an array of services.\n * Maps service names to their registered instance types.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type MyServiceRecord = ServiceRecord<[DatabaseService, CacheService]>;\n * // type MyServiceRecord = {\n * //   database: Database;\n * //   cache: CacheService;\n * // }\n * ```\n */\nexport type ServiceRecord<T extends Service[]> = {\n  [K in T[number] as K['serviceName']]: K extends Service\n    ? Awaited<ReturnType<K['register']>>\n    : never;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,IAAa,mBAAb,MAAa,iBAGX;;CAEA,OAAe;;CAEf,AAAQ,2BAAW,IAAI;;CAEvB,AAAQ,4BAAY,IAAI;;;;;;;;;;;;;;;;CAiBxB,OAAO,YAGLA,QAAiBC,WAAuD;AACxE,OAAK,iBAAiB,UACpB,kBAAiB,YAAY,IAAI,iBAC/B,QACA;AAGJ,SAAO,iBAAiB;CACzB;;;;;;;;;;;;;CAcD,OAAO,QAAc;AACnB,mBAAiB;CAClB;;;;;;;;CASD,AAAQ,YACGD,QACAC,WACT;EAFS;EACA;CACP;;;;;;;;;;;;;;;;;;;;;;;;;CA0BJ,MAAM,SAA8BC,UAAwC;EAC1E,MAAM,qBAAqB,CAAE;AAC7B,OAAK,MAAM,WAAW,UAAU;GAC9B,MAAM,OAAO,QAAQ;AACrB,OAAI,KAAK,UAAU,IAAI,KAAK,EAAE;AAC5B,IAAC,mBAA2B,QAAQ,KAAK,UAAU,IACjD,KACD;AACD;GACD;GAED,MAAM,WAAW,MAAM,QAAQ,SAAS,KAAK,UAAU;AAEvD,QAAK,UAAU,IAAI,MAAM,SAAuC;AAChE,GAAC,mBAA2B,QAC1B;EACH;AAED,SAAO;CACR;;;;;;;;;;;;;;;;CAiBD,IAAwCC,MAAgC;EACtE,MAAM,UAAU,KAAK,SAAS,IAAI,KAAK;AAEvC,OAAK,QACH,OAAM,IAAI,OAAO,WAAW,KAAK;AAGnC,SAAO,QAAQ,SAAS,KAAK,UAAU;CACxC;;;;;;;;;;;;;;;;;;CAkBD,MAAM,QACJC,OAC6C;EAC7C,MAAM,SAAS,CAAE;AAEjB,OAAK,MAAM,QAAQ,MACjB,QAAO,QAAQ,MAAM,KAAK,IAAI,KAAK;AAGrC,SAAO;CACR;;;;;;;;;;;;;;;;;;;;;CAsBD,IAAIC,SAAoC;AACtC,aAAW,YAAY,SACrB,QAAO,KAAK,SAAS,IAAI,QAAQ;AAGnC,SAAO,KAAK,SAAS,IAAI,QAAQ,YAAY;CAC9C;AACF"}

package/dist/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","names":["logger: TLogger","envParser: EnvironmentParser<{}>","services: T","name: K","names: [...K]","service: string | Service"],"sources":["../src/index.ts"],"sourcesContent":["import type { EnvironmentParser } from '@geekmidas/envkit';\nimport type { Logger } from '@geekmidas/logger';\n\n/**\n * Service interface for the new simplified service pattern.\n * Services are objects with a serviceName and register method.\n *\n * @template TName - The literal string type for the service name\n * @template TInstance - The type of the service instance that will be registered\n *\n * @example\n * ```typescript\n * class DatabaseService implements Service<'database', Database> {\n *   serviceName = 'database' as const;\n *\n *   async register(envParser: EnvironmentParser<{}>): Promise<Database> {\n *     const config = envParser.create((get) => ({\n *       url: get('DATABASE_URL').string()\n *     })).parse();\n *\n *     return new Database(config.url);\n *   }\n * }\n * ```\n */\nexport interface Service<TName extends string = string, TInstance = unknown> {\n  /**\n   * Unique name for the service, used for lookup via services.get()\n   */\n  serviceName: TName;\n  /**\n   * Register method that returns the actual service instance.\n   * Called once on first access, then cached.\n   */\n  register(envParser: EnvironmentParser<{}>): TInstance | Promise<TInstance>;\n}\n\n/**\n * Service discovery container that manages service registration and retrieval.\n * Implements a singleton pattern with lazy initialization of services.\n *\n * @template TServices - Record type mapping service names to their instance types\n * @template TLogger - Logger type for internal logging\n *\n * @example\n * ```typescript\n * // Define service types\n * interface MyServices {\n *   database: Database;\n *   cache: CacheService;\n *   auth: AuthService;\n * }\n *\n * // Get service discovery instance\n * const discovery = ServiceDiscovery.getInstance<MyServices>(logger, envParser);\n *\n * // Register services\n * await discovery.register([\n *   new DatabaseService(),\n *   new CacheService(),\n *   new AuthService()\n * ]);\n *\n * // Retrieve services\n * const db = await discovery.get('database');\n * const { cache, auth } = await discovery.getMany(['cache', 'auth']);\n * ```\n */\nexport class ServiceDiscovery<\n  TServices extends Record<string, unknown> = {},\n  TLogger extends Logger = Logger,\n> {\n  /** Singleton instance of ServiceDiscovery */\n  private static _instance: ServiceDiscovery<any, any>;\n  /** Map of registered service definitions */\n  private services = new Map<string, Service>();\n  /** Map of instantiated service instances */\n  private instances = new Map<keyof TServices, TServices[keyof TServices]>();\n\n  /**\n   * Gets the singleton instance of ServiceDiscovery.\n   * Creates a new instance if one doesn't exist.\n   *\n   * @template T - Record type mapping service names to their instance types\n   * @template TLogger - Logger type for internal logging\n   * @param logger - Logger instance for service logging\n   * @param envParser - Environment parser for service configuration\n   * @returns The ServiceDiscovery singleton instance\n   *\n   * @example\n   * ```typescript\n   * const services = ServiceDiscovery.getInstance<MyServices>(logger, envParser);\n   * ```\n   */\n  static getInstance<\n    T extends Record<any, unknown> = any,\n    TLogger extends Logger = Logger,\n  >(logger: TLogger, envParser: EnvironmentParser<{}>): ServiceDiscovery<T> {\n    if (!ServiceDiscovery._instance) {\n      ServiceDiscovery._instance = new ServiceDiscovery<T, TLogger>(\n        logger,\n        envParser,\n      );\n    }\n    return ServiceDiscovery._instance as ServiceDiscovery<T>;\n  }\n\n  /**\n   * Resets the singleton instance. Use only for testing purposes.\n   * This clears all cached services and allows a fresh instance to be created.\n   *\n   * @example\n   * ```typescript\n   * // In test teardown\n   * afterEach(() => {\n   *   ServiceDiscovery.reset();\n   * });\n   * ```\n   */\n  static reset(): void {\n    ServiceDiscovery._instance = undefined as any;\n  }\n\n  /**\n   * Private constructor to enforce singleton pattern.\n   *\n   * @param logger - Logger instance for service logging\n   * @param envParser - Environment parser for service configuration\n   * @private\n   */\n  private constructor(\n    readonly logger: TLogger,\n    readonly envParser: EnvironmentParser<{}>,\n  ) {}\n\n  /**\n   * Register multiple services with the service discovery.\n   * Services are instantiated lazily on first access.\n   * Already instantiated services are returned from cache.\n   *\n   * @template T - Array type of services to register\n   * @param services - Array of services to register\n   * @returns Promise resolving to a record of service names to instances\n   *\n   * @example\n   * ```typescript\n   * const services = await discovery.register([\n   *   new DatabaseService(),\n   *   new CacheService(),\n   *   new AuthService()\n   * ]);\n   *\n   * // services = {\n   * //   database: Database instance,\n   * //   cache: CacheService instance,\n   * //   auth: AuthService instance\n   * // }\n   * ```\n   */\n  async register<T extends Service[]>(services: T): Promise<ServiceRecord<T>> {\n    const registeredServices = {} as ServiceRecord<T>;\n    for (const service of services) {\n      const name = service.serviceName as T[number]['serviceName'];\n      if (this.instances.has(name)) {\n        (registeredServices as any)[name] = this.instances.get(\n          name,\n        ) as TServices[keyof TServices];\n        continue;\n      }\n\n      const instance = await service.register(this.envParser);\n\n      this.instances.set(name, instance as TServices[keyof TServices]);\n      (registeredServices as any)[name] =\n        instance as TServices[keyof TServices];\n    }\n\n    return registeredServices;\n  }\n\n  /**\n   * Get a service from the service discovery.\n   * Services are instantiated on first access if not already cached.\n   *\n   * @template K - The service name key\n   * @param name - The name of the service to get\n   * @returns Promise resolving to the service instance\n   * @throws {Error} If the service is not registered\n   *\n   * @example\n   * ```typescript\n   * const database = await discovery.get('database');\n   * const users = await database.query('SELECT * FROM users');\n   * ```\n   */\n  get<K extends keyof TServices & string>(name: K): Promise<TServices[K]> {\n    const service = this.services.get(name);\n\n    if (!service) {\n      throw new Error(`Service '${name}' not found in service discovery`);\n    }\n\n    return service.register(this.envParser) as Promise<TServices[K]>;\n  }\n  /**\n   * Get multiple services from the service discovery.\n   * Useful for retrieving multiple dependencies at once.\n   *\n   * @template K - Array of service name keys\n   * @param names - Array of service names to retrieve\n   * @returns Promise resolving to an object containing the service instances\n   *\n   * @example\n   * ```typescript\n   * const { database, cache, auth } = await discovery.getMany([\n   *   'database',\n   *   'cache',\n   *   'auth'\n   * ]);\n   * ```\n   */\n  async getMany<K extends (keyof TServices & string)[]>(\n    names: [...K],\n  ): Promise<{ [P in K[number]]: TServices[P] }> {\n    const result = {} as { [P in K[number]]: TServices[P] };\n\n    for (const name of names) {\n      result[name] = await this.get(name);\n    }\n\n    return result;\n  }\n\n  /**\n   * Check if a service exists in the service discovery.\n   * Can check by service name or service instance.\n   *\n   * @param service - The service name or service instance to check\n   * @returns True if the service exists, false otherwise\n   *\n   * @example\n   * ```typescript\n   * if (discovery.has('database')) {\n   *   const db = await discovery.get('database');\n   * }\n   *\n   * // Or check with service instance\n   * const dbService = new DatabaseService();\n   * if (!discovery.has(dbService)) {\n   *   await discovery.register([dbService]);\n   * }\n   * ```\n   */\n  has(service: string | Service): boolean {\n    if (typeof service === 'string') {\n      return this.services.has(service);\n    }\n\n    return this.services.has(service.serviceName);\n  }\n}\n\n/**\n * Utility type to extract service names from an array of services.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type Names = ExtractServiceNames<[DatabaseService, CacheService]>;\n * // type Names = 'database' | 'cache'\n * ```\n */\nexport type ExtractServiceNames<T extends Service[]> = T[number]['serviceName'];\n\n/**\n * Utility type to create a record type from an array of services.\n * Maps service names to their registered instance types.\n *\n * @template T - Array of Service types\n *\n * @example\n * ```typescript\n * type MyServiceRecord = ServiceRecord<[DatabaseService, CacheService]>;\n * // type MyServiceRecord = {\n * //   database: Database;\n * //   cache: CacheService;\n * // }\n * ```\n */\nexport type ServiceRecord<T extends Service[]> = {\n  [K in T[number] as K['serviceName']]: K extends Service\n    ? Awaited<ReturnType<K['register']>>\n    : never;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,IAAa,mBAAb,MAAa,iBAGX;;CAEA,OAAe;;CAEf,AAAQ,2BAAW,IAAI;;CAEvB,AAAQ,4BAAY,IAAI;;;;;;;;;;;;;;;;CAiBxB,OAAO,YAGLA,QAAiBC,WAAuD;AACxE,OAAK,iBAAiB,UACpB,kBAAiB,YAAY,IAAI,iBAC/B,QACA;AAGJ,SAAO,iBAAiB;CACzB;;;;;;;;;;;;;CAcD,OAAO,QAAc;AACnB,mBAAiB;CAClB;;;;;;;;CASD,AAAQ,YACGD,QACAC,WACT;EAFS;EACA;CACP;;;;;;;;;;;;;;;;;;;;;;;;;CA0BJ,MAAM,SAA8BC,UAAwC;EAC1E,MAAM,qBAAqB,CAAE;AAC7B,OAAK,MAAM,WAAW,UAAU;GAC9B,MAAM,OAAO,QAAQ;AACrB,OAAI,KAAK,UAAU,IAAI,KAAK,EAAE;AAC5B,IAAC,mBAA2B,QAAQ,KAAK,UAAU,IACjD,KACD;AACD;GACD;GAED,MAAM,WAAW,MAAM,QAAQ,SAAS,KAAK,UAAU;AAEvD,QAAK,UAAU,IAAI,MAAM,SAAuC;AAChE,GAAC,mBAA2B,QAC1B;EACH;AAED,SAAO;CACR;;;;;;;;;;;;;;;;CAiBD,IAAwCC,MAAgC;EACtE,MAAM,UAAU,KAAK,SAAS,IAAI,KAAK;AAEvC,OAAK,QACH,OAAM,IAAI,OAAO,WAAW,KAAK;AAGnC,SAAO,QAAQ,SAAS,KAAK,UAAU;CACxC;;;;;;;;;;;;;;;;;;CAkBD,MAAM,QACJC,OAC6C;EAC7C,MAAM,SAAS,CAAE;AAEjB,OAAK,MAAM,QAAQ,MACjB,QAAO,QAAQ,MAAM,KAAK,IAAI,KAAK;AAGrC,SAAO;CACR;;;;;;;;;;;;;;;;;;;;;CAsBD,IAAIC,SAAoC;AACtC,aAAW,YAAY,SACrB,QAAO,KAAK,SAAS,IAAI,QAAQ;AAGnC,SAAO,KAAK,SAAS,IAAI,QAAQ,YAAY;CAC9C;AACF"}