@geekmidas/services 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,214 @@
+import { EnvironmentParser } from "@geekmidas/envkit";
+import { Logger } from "@geekmidas/logger";
+
+//#region src/index.d.ts
+
+/**
+ * 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);
+ *   }
+ * }
+ * ```
+ */
+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']);
+ * ```
+ */
+declare class ServiceDiscovery<TServices extends Record<string, unknown> = {}, TLogger extends Logger = Logger> {
+  readonly logger: TLogger;
+  readonly envParser: EnvironmentParser<{}>;
+  /** Singleton instance of ServiceDiscovery */
+  private static _instance;
+  /** Map of registered service definitions */
+  private services;
+  /** Map of instantiated service instances */
+  private instances;
+  /**
+   * 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>;
+  /**
+   * Private constructor to enforce singleton pattern.
+   *
+   * @param logger - Logger instance for service logging
+   * @param envParser - Environment parser for service configuration
+   * @private
+   */
+  private constructor();
+  /**
+   * 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
+   * // }
+   * ```
+   */
+  register<T extends Service[]>(services: T): Promise<ServiceRecord<T>>;
+  /**
+   * 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]>;
+  /**
+   * 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'
+   * ]);
+   * ```
+   */
+  getMany<K extends (keyof TServices & string)[]>(names: [...K]): Promise<{ [P in K[number]]: TServices[P] }>;
+  /**
+   * 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;
+}
+/**
+ * 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'
+ * ```
+ */
+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;
+ * // }
+ * ```
+ */
+type ServiceRecord<T extends Service[]> = { [K in T[number] as K['serviceName']]: K extends Service ? Awaited<ReturnType<K['register']>> : never };
+//#endregion
+export { ExtractServiceNames, Service, ServiceDiscovery, ServiceRecord };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.mts

@@ -0,0 +1,214 @@
+import { EnvironmentParser } from "@geekmidas/envkit";
+import { Logger } from "@geekmidas/logger";
+
+//#region src/index.d.ts
+
+/**
+ * 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);
+ *   }
+ * }
+ * ```
+ */
+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']);
+ * ```
+ */
+declare class ServiceDiscovery<TServices extends Record<string, unknown> = {}, TLogger extends Logger = Logger> {
+  readonly logger: TLogger;
+  readonly envParser: EnvironmentParser<{}>;
+  /** Singleton instance of ServiceDiscovery */
+  private static _instance;
+  /** Map of registered service definitions */
+  private services;
+  /** Map of instantiated service instances */
+  private instances;
+  /**
+   * 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>;
+  /**
+   * Private constructor to enforce singleton pattern.
+   *
+   * @param logger - Logger instance for service logging
+   * @param envParser - Environment parser for service configuration
+   * @private
+   */
+  private constructor();
+  /**
+   * 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
+   * // }
+   * ```
+   */
+  register<T extends Service[]>(services: T): Promise<ServiceRecord<T>>;
+  /**
+   * 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]>;
+  /**
+   * 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'
+   * ]);
+   * ```
+   */
+  getMany<K extends (keyof TServices & string)[]>(names: [...K]): Promise<{ [P in K[number]]: TServices[P] }>;
+  /**
+   * 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;
+}
+/**
+ * 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'
+ * ```
+ */
+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;
+ * // }
+ * ```
+ */
+type ServiceRecord<T extends Service[]> = { [K in T[number] as K['serviceName']]: K extends Service ? Awaited<ReturnType<K['register']>> : never };
+//#endregion
+export { ExtractServiceNames, Service, ServiceDiscovery, ServiceRecord };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,178 @@
+//#region src/index.ts
+/**
+* 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']);
+* ```
+*/
+var ServiceDiscovery = class ServiceDiscovery {
+	/** Singleton instance of ServiceDiscovery */
+	static _instance;
+	/** Map of registered service definitions */
+	services = /* @__PURE__ */ new Map();
+	/** Map of instantiated service instances */
+	instances = /* @__PURE__ */ new Map();
+	/**
+	* 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(logger, envParser) {
+		if (!ServiceDiscovery._instance) ServiceDiscovery._instance = new ServiceDiscovery(logger, envParser);
+		return ServiceDiscovery._instance;
+	}
+	/**
+	* Private constructor to enforce singleton pattern.
+	*
+	* @param logger - Logger instance for service logging
+	* @param envParser - Environment parser for service configuration
+	* @private
+	*/
+	constructor(logger, envParser) {
+		this.logger = logger;
+		this.envParser = envParser;
+	}
+	/**
+	* 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(services) {
+		const registeredServices = {};
+		for (const service of services) {
+			const name = service.serviceName;
+			if (this.instances.has(name)) {
+				registeredServices[name] = this.instances.get(name);
+				continue;
+			}
+			const instance = await service.register(this.envParser);
+			this.instances.set(name, instance);
+			registeredServices[name] = instance;
+		}
+		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(name) {
+		const service = this.services.get(name);
+		if (!service) throw new Error(`Service '${name}' not found in service discovery`);
+		return service.register(this.envParser);
+	}
+	/**
+	* 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(names) {
+		const result = {};
+		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) {
+		if (typeof service === "string") return this.services.has(service);
+		return this.services.has(service.serviceName);
+	}
+};
+
+//#endregion
+export { ServiceDiscovery };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +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"}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@geekmidas/services",
+  "version": "0.0.1",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/geekmidas/toolbox.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "dependencies": {
+    "@geekmidas/logger": "0.0.1"
+  },
+  "peerDependencies": {
+    "@geekmidas/envkit": "0.0.7"
+  },
+  "scripts": {
+    "ts": "tsc --noEmit --skipLibCheck src/**/*.ts"
+  }
+}