@geekmidas/services 0.0.1

package/README.md

@@ -0,0 +1,510 @@
+# @geekmidas/services
+
+Service discovery and dependency injection system for TypeScript applications with full type safety and automatic lifecycle management.
+
+## Features
+
+- **Type-Safe Services**: Full TypeScript support with generic type inference
+- **Lazy Initialization**: Services are initialized only when needed
+- **Singleton Pattern**: Services are cached and reused across requests
+- **Dependency Injection**: Automatic service resolution and injection
+- **Environment Integration**: Seamless integration with @geekmidas/envkit
+- **Service Discovery**: Centralized service registry and discovery
+- **Error Handling**: Graceful error handling during service initialization
+
+## Installation
+
+```bash
+pnpm add @geekmidas/services
+```
+
+## Quick Start
+
+### Define a Service
+
+```typescript
+import type { Service } from '@geekmidas/services';
+import type { EnvironmentParser } from '@geekmidas/envkit';
+import { Kysely } from 'kysely';
+
+// Define your database service
+const databaseService = {
+  serviceName: 'database' as const,
+  async register(envParser: EnvironmentParser<{}>) {
+    const config = envParser.create((get) => ({
+      url: get('DATABASE_URL').string(),
+      ssl: get('DATABASE_SSL').string().transform(Boolean).default('false')
+    })).parse();
+
+    const db = new Kysely({ /* config */ });
+    await db.connection().execute('SELECT 1'); // Health check
+
+    return db;
+  }
+} satisfies Service<'database', Kysely<Database>>;
+
+export { databaseService };
+```
+
+### Use Services in Constructs
+
+```typescript
+import { e } from '@geekmidas/constructs/endpoints';
+import { databaseService } from './services/database';
+import { z } from 'zod';
+
+export const getUser = e
+  .get('/users/:id')
+  .params(z.object({ id: z.string() }))
+  .services([databaseService])
+  .handle(async ({ params, services }) => {
+    // services.database is fully typed as Kysely<Database>
+    const user = await services.database
+      .selectFrom('users')
+      .where('id', '=', params.id)
+      .selectAll()
+      .executeTakeFirstOrThrow();
+
+    return user;
+  });
+```
+
+## Service Discovery
+
+The ServiceDiscovery class manages service lifecycle and dependency injection:
+
+```typescript
+import { ServiceDiscovery } from '@geekmidas/services';
+import { ConsoleLogger } from '@geekmidas/logger/console';
+import { EnvironmentParser } from '@geekmidas/envkit';
+
+const logger = new ConsoleLogger();
+const envParser = new EnvironmentParser(process.env).create(() => ({})).parse();
+
+const serviceDiscovery = ServiceDiscovery.getInstance(logger, envParser);
+
+// Services are lazily initialized
+const database = await serviceDiscovery.discover(databaseService);
+```
+
+## Creating Services
+
+### Database Service
+
+```typescript
+import type { Service } from '@geekmidas/services';
+import { Kysely, PostgresDialect } from 'kysely';
+import { Pool } from 'pg';
+
+const databaseService = {
+  serviceName: 'database' as const,
+  async register(envParser: EnvironmentParser<{}>) {
+    const config = envParser.create((get) => ({
+      host: get('DB_HOST').string(),
+      port: get('DB_PORT').string().transform(Number).default('5432'),
+      database: get('DB_NAME').string(),
+      user: get('DB_USER').string(),
+      password: get('DB_PASSWORD').string(),
+      ssl: get('DB_SSL').string().transform(Boolean).default('false')
+    })).parse();
+
+    const db = new Kysely<Database>({
+      dialect: new PostgresDialect({
+        pool: new Pool({
+          host: config.host,
+          port: config.port,
+          database: config.database,
+          user: config.user,
+          password: config.password,
+          ssl: config.ssl
+        })
+      })
+    });
+
+    return db;
+  }
+} satisfies Service<'database', Kysely<Database>>;
+```
+
+### Redis/Cache Service
+
+```typescript
+import type { Service } from '@geekmidas/services';
+import { UpstashCache } from '@geekmidas/cache/upstash';
+
+const cacheService = {
+  serviceName: 'cache' as const,
+  async register(envParser: EnvironmentParser<{}>) {
+    const config = envParser.create((get) => ({
+      url: get('UPSTASH_REDIS_URL').string().url(),
+      token: get('UPSTASH_REDIS_TOKEN').string()
+    })).parse();
+
+    return new UpstashCache({
+      url: config.url,
+      token: config.token
+    });
+  }
+} satisfies Service<'cache', UpstashCache<any>>;
+```
+
+### Email Service
+
+```typescript
+import type { Service } from '@geekmidas/services';
+import { createEmailClient } from '@geekmidas/emailkit';
+import * as templates from './email-templates';
+
+const emailService = {
+  serviceName: 'email' as const,
+  async register(envParser: EnvironmentParser<{}>) {
+    const config = envParser.create((get) => ({
+      host: get('SMTP_HOST').string(),
+      port: get('SMTP_PORT').string().transform(Number),
+      user: get('SMTP_USER').string(),
+      pass: get('SMTP_PASS').string(),
+      from: get('EMAIL_FROM').string().email()
+    })).parse();
+
+    return createEmailClient({
+      smtp: {
+        host: config.host,
+        port: config.port,
+        auth: {
+          user: config.user,
+          pass: config.pass
+        }
+      },
+      templates,
+      defaults: { from: config.from }
+    });
+  }
+} satisfies Service<'email', ReturnType<typeof createEmailClient>>;
+```
+
+### Event Publisher Service
+
+```typescript
+import type { Service } from '@geekmidas/services';
+import type { EventPublisher, PublishableMessage } from '@geekmidas/events';
+
+type UserEvents =
+  | PublishableMessage<'user.created', { userId: string }>
+  | PublishableMessage<'user.updated', { userId: string }>;
+
+const userEventPublisher = {
+  serviceName: 'userEventPublisher' as const,
+  async register(envParser: EnvironmentParser<{}>) {
+    const config = envParser.create((get) => ({
+      publisherUrl: get('EVENT_PUBLISHER_URL').string()
+    })).parse();
+
+    const { Publisher } = await import('@geekmidas/events');
+    return Publisher.fromConnectionString<UserEvents>(config.publisherUrl);
+  }
+} satisfies Service<'userEventPublisher', EventPublisher<UserEvents>>;
+```
+
+## Multiple Services
+
+Inject multiple services into a construct:
+
+```typescript
+import { e } from '@geekmidas/constructs/endpoints';
+import { databaseService } from './services/database';
+import { cacheService } from './services/cache';
+import { emailService } from './services/email';
+import { z } from 'zod';
+
+export const createUser = e
+  .post('/users')
+  .body(z.object({
+    name: z.string(),
+    email: z.string().email()
+  }))
+  .services([databaseService, cacheService, emailService])
+  .handle(async ({ body, services }) => {
+    // Check cache first
+    const cached = await services.cache.get(`user:${body.email}`);
+    if (cached) {
+      return cached;
+    }
+
+    // Create user in database
+    const user = await services.database
+      .insertInto('users')
+      .values(body)
+      .returningAll()
+      .executeTakeFirstOrThrow();
+
+    // Send welcome email
+    await services.email.sendTemplate('welcome', {
+      to: user.email,
+      props: { name: user.name }
+    });
+
+    // Cache result
+    await services.cache.set(`user:${user.email}`, user, 3600);
+
+    return user;
+  });
+```
+
+## Service Lifecycle
+
+### Lazy Initialization
+
+Services are only initialized when first requested:
+
+```typescript
+const serviceDiscovery = ServiceDiscovery.getInstance(logger, envParser);
+
+// Not initialized yet
+const service1 = databaseService;
+
+// Initialized here
+const db = await serviceDiscovery.discover(databaseService);
+
+// Reuses same instance (singleton)
+const db2 = await serviceDiscovery.discover(databaseService);
+assert(db === db2); // true
+```
+
+### Singleton Pattern
+
+ServiceDiscovery ensures each service is a singleton:
+
+```typescript
+// First call initializes the service
+const db1 = await serviceDiscovery.discover(databaseService);
+
+// Subsequent calls return cached instance
+const db2 = await serviceDiscovery.discover(databaseService);
+const db3 = await serviceDiscovery.discover(databaseService);
+
+// All references point to same instance
+console.log(db1 === db2 && db2 === db3); // true
+```
+
+## Error Handling
+
+Handle service initialization errors gracefully:
+
+```typescript
+const databaseService = {
+  serviceName: 'database' as const,
+  async register(envParser: EnvironmentParser<{}>) {
+    try {
+      const config = envParser.create((get) => ({
+        url: get('DATABASE_URL').string()
+      })).parse();
+
+      const db = new Kysely({ /* config */ });
+
+      // Test connection
+      await db.connection().execute('SELECT 1');
+
+      return db;
+    } catch (error) {
+      throw new Error(`Failed to initialize database: ${error.message}`);
+    }
+  }
+} satisfies Service<'database', Kysely<Database>>;
+```
+
+## Testing
+
+Mock services in tests:
+
+```typescript
+import { ServiceDiscovery } from '@geekmidas/services';
+import { vi } from 'vitest';
+
+// Create mock database
+const mockDb = {
+  selectFrom: vi.fn(() => ({
+    where: vi.fn(() => ({
+      selectAll: vi.fn(() => ({
+        executeTakeFirstOrThrow: vi.fn().mockResolvedValue({
+          id: '1',
+          name: 'Test User'
+        })
+      }))
+    }))
+  }))
+};
+
+// Create mock service
+const mockDatabaseService = {
+  serviceName: 'database' as const,
+  async register() {
+    return mockDb;
+  }
+} satisfies Service<'database', typeof mockDb>;
+
+// Use in tests
+const serviceDiscovery = ServiceDiscovery.getInstance(logger, envParser);
+const db = await serviceDiscovery.discover(mockDatabaseService);
+
+// Test your code
+```
+
+## Service Patterns
+
+### Repository Pattern
+
+```typescript
+import type { Service } from '@geekmidas/services';
+
+class UserRepository {
+  constructor(private db: Kysely<Database>) {}
+
+  async findById(id: string) {
+    return this.db
+      .selectFrom('users')
+      .where('id', '=', id)
+      .selectAll()
+      .executeTakeFirst();
+  }
+
+  async create(data: NewUser) {
+    return this.db
+      .insertInto('users')
+      .values(data)
+      .returningAll()
+      .executeTakeFirstOrThrow();
+  }
+}
+
+const userRepositoryService = {
+  serviceName: 'userRepository' as const,
+  async register(envParser: EnvironmentParser<{}>) {
+    const db = await databaseService.register(envParser);
+    return new UserRepository(db);
+  }
+} satisfies Service<'userRepository', UserRepository>;
+```
+
+### Service Composition
+
+```typescript
+import type { Service } from '@geekmidas/services';
+
+class UserService {
+  constructor(
+    private repository: UserRepository,
+    private email: EmailClient,
+    private cache: Cache
+  ) {}
+
+  async createUser(data: NewUser) {
+    const user = await this.repository.create(data);
+    await this.email.sendTemplate('welcome', {
+      to: user.email,
+      props: { name: user.name }
+    });
+    await this.cache.set(`user:${user.id}`, user, 3600);
+    return user;
+  }
+}
+
+const userServiceService = {
+  serviceName: 'userService' as const,
+  async register(envParser: EnvironmentParser<{}>) {
+    const repository = await userRepositoryService.register(envParser);
+    const email = await emailService.register(envParser);
+    const cache = await cacheService.register(envParser);
+
+    return new UserService(repository, email, cache);
+  }
+} satisfies Service<'userService', UserService>;
+```
+
+## TypeScript Types
+
+```typescript
+import type { Service } from '@geekmidas/services';
+
+// Service interface
+interface Service<TName extends string = string, TInstance = unknown> {
+  serviceName: TName;
+  register(envParser: EnvironmentParser<{}>): Promise<TInstance> | TInstance;
+}
+
+// Infer service name
+type ServiceName<T> = T extends Service<infer N, any> ? N : never;
+
+// Infer service instance type
+type ServiceInstance<T> = T extends Service<any, infer I> ? I : never;
+```
+
+## Best Practices
+
+### 1. Use `satisfies` for Type Safety
+
+```typescript
+// ✅ Use satisfies to ensure correct implementation
+const service = {
+  serviceName: 'myService' as const,
+  async register(envParser) {
+    return new MyService();
+  }
+} satisfies Service<'myService', MyService>;
+
+// ❌ Don't use type annotation (loses type inference)
+const service: Service = {
+  serviceName: 'myService',
+  async register(envParser) {
+    return new MyService();
+  }
+};
+```
+
+### 2. Use `as const` for Service Names
+
+```typescript
+// ✅ Literal type for better type inference
+serviceName: 'database' as const
+
+// ❌ String type loses specificity
+serviceName: 'database'
+```
+
+### 3. Validate Configuration
+
+```typescript
+async register(envParser: EnvironmentParser<{}>) {
+  const config = envParser.create((get) => ({
+    url: get('DATABASE_URL').string().url(), // Validates URL format
+    port: get('PORT').string().transform(Number).default('5432'),
+    ssl: get('SSL').string().transform(Boolean).default('false')
+  })).parse();
+
+  return new Database(config);
+}
+```
+
+### 4. Test Connections
+
+```typescript
+async register(envParser: EnvironmentParser<{}>) {
+  const db = new Database(config);
+
+  // Test connection during initialization
+  await db.connection().execute('SELECT 1');
+
+  return db;
+}
+```
+
+## Related Packages
+
+- [@geekmidas/constructs](../constructs) - Uses services for dependency injection
+- [@geekmidas/envkit](../envkit) - Environment configuration for services
+- [@geekmidas/logger](../logger) - Logging within services
+- [@geekmidas/cache](../cache) - Cache services
+- [@geekmidas/events](../events) - Event publisher services
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,179 @@
+
+//#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
+exports.ServiceDiscovery = ServiceDiscovery;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

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