@geekmidas/services 0.0.1 → 0.1.0

package/dist/index.cjs

@@ -58,6 +58,21 @@ var ServiceDiscovery = class ServiceDiscovery {
 		return ServiceDiscovery._instance;
 	}
 	/**
+	* 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() {
+		ServiceDiscovery._instance = void 0;
+	}
+	/**
 	* Private constructor to enforce singleton pattern.
 	*
 	* @param logger - Logger instance for service logging

package/dist/index.cjs.map

@@ -1 +1 @@
-{"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   * 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;;;;;;;;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"}
+{"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.d.cts

@@ -92,6 +92,19 @@ declare class ServiceDiscovery<TServices extends Record<string, unknown> = {}, T
    * ```
    */
   static getInstance<T extends Record<any, unknown> = any, TLogger extends Logger = Logger>(logger: TLogger, envParser: EnvironmentParser<{}>): 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;
   /**
    * Private constructor to enforce singleton pattern.
    *

package/dist/index.d.mts

@@ -92,6 +92,19 @@ declare class ServiceDiscovery<TServices extends Record<string, unknown> = {}, T
    * ```
    */
   static getInstance<T extends Record<any, unknown> = any, TLogger extends Logger = Logger>(logger: TLogger, envParser: EnvironmentParser<{}>): 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;
   /**
    * Private constructor to enforce singleton pattern.
    *

package/dist/index.mjs

@@ -57,6 +57,21 @@ var ServiceDiscovery = class ServiceDiscovery {
 		return ServiceDiscovery._instance;
 	}
 	/**
+	* 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() {
+		ServiceDiscovery._instance = void 0;
+	}
+	/**
 	* Private constructor to enforce singleton pattern.
 	*
 	* @param logger - Logger instance for service logging

package/dist/index.mjs.map

@@ -1 +1 @@
-{"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   * 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;;;;;;;;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"}
+{"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/services",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "private": false,
   "type": "module",
   "exports": {
@@ -12,17 +12,28 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/geekmidas/toolbox.git"
+    "url": "https://github.com/geekmidas/toolbox"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "dependencies": {
-    "@geekmidas/logger": "0.0.1"
-  },
+  "dependencies": {},
   "peerDependencies": {
-    "@geekmidas/envkit": "0.0.7"
+    "@geekmidas/envkit": "^0.2.0",
+    "@geekmidas/logger": "^0.3.0"
+  },
+  "peerDependenciesMeta": {
+    "@geekmidas/envkit": {
+      "optional": true
+    },
+    "@geekmidas/logger": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@geekmidas/envkit": "^0.2.0",
+    "@geekmidas/logger": "^0.3.0"
   },
   "scripts": {
     "ts": "tsc --noEmit --skipLibCheck src/**/*.ts"

package/src/index.ts

@@ -105,6 +105,22 @@ export class ServiceDiscovery<
     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.
    *