@geekmidas/constructs 0.0.6 → 0.0.9

package/src/endpoints/__tests__/TestEndpointAdaptor.spec.ts

@@ -393,28 +393,19 @@ describe('TestEndpointAdaptor', () => {
         });
 
       const adapter = new TestEndpointAdaptor(endpoint);
-      const result = await adapter.request({
+      const result = await adapter.fullRequest({
         body: { email: 'test@example.com', password: 'pass123' },
         services: mockServices,
         headers: { host: 'example.com' },
       });
 
-      expect(result).toHaveProperty('data');
-      expect(result).toHaveProperty('metadata');
-      expect((result as any).data).toEqual({
+      expect(result.body).toEqual({
         id: 'user-1',
         email: 'test@example.com',
       });
-      expect((result as any).metadata.cookies?.has('session')).toBe(true);
-      expect((result as any).metadata.cookies?.get('session')).toEqual({
-        value: 'abc123',
-        options: {
-          httpOnly: true,
-          secure: true,
-          sameSite: 'strict',
-          maxAge: 3600,
-        },
-      });
+      expect(result.headers['set-cookie']).toEqual([
+        'session=abc123; Max-Age=3600; HttpOnly; Secure; SameSite=strict',
+      ]);
     });
 
     it('should set custom response headers', async () => {
@@ -431,17 +422,17 @@ describe('TestEndpointAdaptor', () => {
         });
 
       const adapter = new TestEndpointAdaptor(endpoint);
-      const result = await adapter.request({
+      const result = await adapter.fullRequest({
         body: { name: 'John Doe' },
         services: mockServices,
         headers: { host: 'example.com' },
       });
 
-      expect((result as any).data).toEqual({
+      expect(result.body).toEqual({
         id: 'user-123',
         name: 'John Doe',
       });
-      expect((result as any).metadata.headers).toEqual({
+      expect(result.headers).toEqual({
         Location: '/users/user-123',
         'X-User-Id': 'user-123',
       });
@@ -457,13 +448,13 @@ describe('TestEndpointAdaptor', () => {
         });
 
       const adapter = new TestEndpointAdaptor(endpoint);
-      const result = await adapter.request({
+      const result = await adapter.fullRequest({
         body: { name: 'Resource' },
         services: mockServices,
         headers: { host: 'example.com' },
       });
 
-      expect((result as any).metadata.status).toBe(201);
+      expect(result.status).toBe(201);
     });
 
     it('should delete cookies', async () => {
@@ -477,16 +468,17 @@ describe('TestEndpointAdaptor', () => {
         });
 
       const adapter = new TestEndpointAdaptor(endpoint);
-      const result = await adapter.request({
+      const result = await adapter.fullRequest({
         services: mockServices,
         headers: { host: 'example.com' },
       });
 
-      expect((result as any).data.success).toBe(true);
-      const sessionCookie = (result as any).metadata.cookies?.get('session');
-      expect(sessionCookie?.value).toBe('');
-      expect(sessionCookie?.options?.maxAge).toBe(0);
-      expect(sessionCookie?.options?.path).toBe('/');
+      expect(result.body.success).toBe(true);
+      const setCookieHeader = result.headers['set-cookie'] as string[];
+      expect(setCookieHeader).toHaveLength(1);
+      expect(setCookieHeader[0]).toContain('session=');
+      expect(setCookieHeader[0]).toContain('Max-Age=0');
+      expect(setCookieHeader[0]).toContain('Path=/');
     });
 
     it('should combine cookies, headers, and status', async () => {
@@ -505,28 +497,21 @@ describe('TestEndpointAdaptor', () => {
         });
 
       const adapter = new TestEndpointAdaptor(endpoint);
-      const result = await adapter.request({
+      const result = await adapter.fullRequest({
         body: { data: 'test' },
         services: mockServices,
         headers: { host: 'example.com' },
       });
 
-      expect((result as any).data).toEqual({
+      expect(result.body).toEqual({
         id: '123',
         result: 'test',
       });
-      expect((result as any).metadata.status).toBe(201);
-      expect((result as any).metadata.headers).toEqual({
+      expect(result.status).toBe(201);
+      expect(result.headers).toEqual({
         Location: '/complete/123',
         'X-Request-Id': 'req-456',
-      });
-      expect((result as any).metadata.cookies?.size).toBe(2);
-      expect((result as any).metadata.cookies?.get('tracking')?.value).toBe(
-        'track-789',
-      );
-      expect((result as any).metadata.cookies?.get('preference')).toEqual({
-        value: 'dark',
-        options: { maxAge: 86400 },
+        'set-cookie': ['tracking=track-789', 'preference=dark; Max-Age=86400'],
       });
     });
 
@@ -564,7 +549,7 @@ describe('TestEndpointAdaptor', () => {
         });
 
       const adapter = new TestEndpointAdaptor(endpoint);
-      const result = await adapter.request({
+      const result = await adapter.fullRequest({
         services: mockServices,
         headers: {
           host: 'example.com',
@@ -572,13 +557,295 @@ describe('TestEndpointAdaptor', () => {
         },
       });
 
-      expect((result as any).data).toEqual({
+      expect(result.body).toEqual({
         theme: 'dark',
         updated: true,
       });
-      expect((result as any).metadata.cookies?.get('theme')?.value).toBe(
-        'dark',
-      );
+      expect(result.headers['set-cookie']).toEqual([
+        'theme=dark; Max-Age=86400',
+      ]);
+    });
+  });
+
+  describe('fullRequest', () => {
+    it('should return full HTTP response with body, status, and headers', async () => {
+      const endpoint = e
+        .get('/test')
+        .output(z.object({ message: z.string() }))
+        .handle(() => ({ message: 'Hello World' }));
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+
+      const result = await adapter.fullRequest({
+        services: mockServices,
+        headers: { host: 'example.com' },
+      });
+
+      expect(result).toEqual({
+        body: { message: 'Hello World' },
+        status: 200,
+        headers: {},
+      });
+    });
+
+    it('should return custom status code in HTTP response', async () => {
+      const endpoint = e
+        .post('/resources')
+        .body(z.object({ name: z.string() }))
+        .output(z.object({ id: z.string() }))
+        .handle(async (ctx, response) => {
+          return response.status(SuccessStatus.Created).send({ id: '123' });
+        });
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+      const result = await adapter.fullRequest({
+        body: { name: 'Resource' },
+        services: mockServices,
+        headers: { host: 'example.com' },
+      });
+
+      expect(result.status).toBe(201);
+      expect(result.body).toEqual({ id: '123' });
+    });
+
+    it('should include custom headers in HTTP response', async () => {
+      const endpoint = e
+        .post('/users')
+        .body(z.object({ name: z.string() }))
+        .output(z.object({ id: z.string(), name: z.string() }))
+        .handle(async ({ body }, response) => {
+          const user = { id: 'user-123', name: body.name };
+          return response
+            .header('Location', `/users/${user.id}`)
+            .header('X-User-Id', user.id)
+            .send(user);
+        });
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+      const result = await adapter.fullRequest({
+        body: { name: 'John Doe' },
+        services: mockServices,
+        headers: { host: 'example.com' },
+      });
+
+      expect(result.body).toEqual({
+        id: 'user-123',
+        name: 'John Doe',
+      });
+      expect(result.headers).toEqual({
+        Location: '/users/user-123',
+        'X-User-Id': 'user-123',
+      });
+    });
+
+    it('should convert cookies to Set-Cookie headers', async () => {
+      const endpoint = e
+        .post('/auth/login')
+        .body(z.object({ email: z.string(), password: z.string() }))
+        .output(z.object({ id: z.string(), email: z.string() }))
+        .handle(async ({ body }, response) => {
+          return response
+            .cookie('session', 'abc123', {
+              httpOnly: true,
+              secure: true,
+              sameSite: 'strict',
+              maxAge: 3600,
+            })
+            .send({ id: 'user-1', email: body.email });
+        });
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+      const result = await adapter.fullRequest({
+        body: { email: 'test@example.com', password: 'pass123' },
+        services: mockServices,
+        headers: { host: 'example.com' },
+      });
+
+      expect(result.body).toEqual({
+        id: 'user-1',
+        email: 'test@example.com',
+      });
+      expect(result.headers['set-cookie']).toEqual([
+        'session=abc123; Max-Age=3600; HttpOnly; Secure; SameSite=strict',
+      ]);
+    });
+
+    it('should handle multiple cookies as array of Set-Cookie headers', async () => {
+      const endpoint = e
+        .post('/complete')
+        .body(z.object({ data: z.string() }))
+        .output(z.object({ id: z.string(), result: z.string() }))
+        .handle(async ({ body }, response) => {
+          return response
+            .cookie('tracking', 'track-789')
+            .cookie('preference', 'dark', { maxAge: 86400, path: '/' })
+            .send({ id: '123', result: body.data });
+        });
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+      const result = await adapter.fullRequest({
+        body: { data: 'test' },
+        services: mockServices,
+        headers: { host: 'example.com' },
+      });
+
+      expect(result.headers['set-cookie']).toEqual([
+        'tracking=track-789',
+        'preference=dark; Max-Age=86400; Path=/',
+      ]);
+    });
+
+    it('should serialize all cookie options correctly', async () => {
+      const expires = new Date('2025-12-31T23:59:59Z');
+      const endpoint = e
+        .get('/cookies-full')
+        .output(z.object({ success: z.boolean() }))
+        .handle(async (ctx, response) => {
+          return response
+            .cookie('full-cookie', 'value123', {
+              domain: 'example.com',
+              path: '/api',
+              expires: expires,
+              maxAge: 7200,
+              httpOnly: true,
+              secure: true,
+              sameSite: 'lax',
+            })
+            .send({ success: true });
+        });
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+      const result = await adapter.fullRequest({
+        services: mockServices,
+        headers: { host: 'example.com' },
+      });
+
+      expect(result.headers['set-cookie']).toEqual([
+        `full-cookie=value123; Max-Age=7200; Expires=${expires.toUTCString()}; Domain=example.com; Path=/api; HttpOnly; Secure; SameSite=lax`,
+      ]);
+    });
+
+    it('should handle cookie deletion in Set-Cookie header', async () => {
+      const endpoint = e
+        .post('/auth/logout')
+        .output(z.object({ success: z.boolean() }))
+        .handle(async (ctx, response) => {
+          return response
+            .deleteCookie('session', { path: '/' })
+            .send({ success: true });
+        });
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+      const result = await adapter.fullRequest({
+        services: mockServices,
+        headers: { host: 'example.com' },
+      });
+
+      expect(result.body.success).toBe(true);
+      const setCookieHeader = result.headers['set-cookie'] as string[];
+      expect(setCookieHeader).toHaveLength(1);
+      expect(setCookieHeader[0]).toContain('session=');
+      expect(setCookieHeader[0]).toContain('Max-Age=0');
+      expect(setCookieHeader[0]).toContain('Path=/');
+      expect(setCookieHeader[0]).toContain('Expires=');
+    });
+
+    it('should combine headers and cookies in HTTP response', async () => {
+      const endpoint = e
+        .post('/complete')
+        .body(z.object({ data: z.string() }))
+        .output(z.object({ id: z.string(), result: z.string() }))
+        .handle(async ({ body }, response) => {
+          return response
+            .status(SuccessStatus.Created)
+            .header('Location', '/complete/123')
+            .header('X-Request-Id', 'req-456')
+            .cookie('tracking', 'track-789')
+            .cookie('preference', 'dark', { maxAge: 86400 })
+            .send({ id: '123', result: body.data });
+        });
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+      const result = await adapter.fullRequest({
+        body: { data: 'test' },
+        services: mockServices,
+        headers: { host: 'example.com' },
+      });
+
+      expect(result).toEqual({
+        body: { id: '123', result: 'test' },
+        status: 201,
+        headers: {
+          Location: '/complete/123',
+          'X-Request-Id': 'req-456',
+          'set-cookie': [
+            'tracking=track-789',
+            'preference=dark; Max-Age=86400',
+          ],
+        },
+      });
+    });
+
+    it('should handle empty response metadata', async () => {
+      const endpoint = e
+        .get('/simple')
+        .output(z.object({ message: z.string() }))
+        .handle(async () => ({ message: 'Hello' }));
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+      const result = await adapter.fullRequest({
+        services: mockServices,
+        headers: { host: 'example.com' },
+      });
+
+      expect(result).toEqual({
+        body: { message: 'Hello' },
+        status: 200,
+        headers: {},
+      });
+    });
+  });
+
+  describe('request method delegation', () => {
+    it('should return only body from fullRequest', async () => {
+      const endpoint = e
+        .post('/users')
+        .body(z.object({ name: z.string() }))
+        .output(z.object({ id: z.string(), name: z.string() }))
+        .handle(async ({ body }, response) => {
+          return response
+            .status(SuccessStatus.Created)
+            .header('Location', '/users/123')
+            .cookie('session', 'abc')
+            .send({ id: '123', name: body.name });
+        });
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+
+      // Call request (should only return body)
+      const simpleResult = await adapter.request({
+        body: { name: 'John' },
+        services: mockServices,
+        headers: { host: 'example.com' },
+      });
+
+      // Call fullRequest (should return full HTTP response)
+      const fullResult = await adapter.fullRequest({
+        body: { name: 'John' },
+        services: mockServices,
+        headers: { host: 'example.com' },
+      });
+
+      // request should only return the body
+      expect(simpleResult).toEqual({ id: '123', name: 'John' });
+      expect(simpleResult).not.toHaveProperty('status');
+      expect(simpleResult).not.toHaveProperty('headers');
+
+      // fullRequest should return complete HTTP response
+      expect(fullResult.body).toEqual({ id: '123', name: 'John' });
+      expect(fullResult.status).toBe(201);
+      expect(fullResult.headers).toHaveProperty('Location');
+      expect(fullResult.headers).toHaveProperty('set-cookie');
     });
   });
 });

package/src/functions/Function.ts

@@ -125,7 +125,7 @@ export class Function<
 
   constructor(
     protected readonly fn: Fn,
-    readonly timeout = 30000, // Default timeout of 30 seconds
+    timeout = 30000, // Default timeout of 30 seconds
     type: ConstructType = ConstructType.Function,
     public input?: TInput,
     outputSchema?: OutSchema,
@@ -133,8 +133,18 @@ export class Function<
     logger: TLogger = DEFAULT_LOGGER,
     publisherService?: Service<TEventPublisherServiceName, TEventPublisher>,
     events: MappedEvent<TEventPublisher, OutSchema>[] = [],
+    memorySize?: number,
   ) {
-    super(type, logger, services, events, publisherService, outputSchema);
+    super(
+      type,
+      logger,
+      services,
+      events,
+      publisherService,
+      outputSchema,
+      timeout,
+      memorySize,
+    );
   }
 }
 

package/src/functions/FunctionBuilder.ts

@@ -27,6 +27,8 @@ export class FunctionBuilder<
   TEventPublisher,
   TEventPublisherServiceName
 > {
+  protected _memorySize?: number;
+
   constructor(public type = ConstructType.Function) {
     super(type);
   }
@@ -36,6 +38,11 @@ export class FunctionBuilder<
     return this;
   }
 
+  memorySize(memorySize: number): this {
+    this._memorySize = memorySize;
+    return this;
+  }
+
   output<T extends StandardSchemaV1>(
     schema: T,
   ): FunctionBuilder<
@@ -166,6 +173,7 @@ export class FunctionBuilder<
       this._logger,
       this._publisher,
       this._events,
+      this._memorySize,
     );
 
     // Reset builder state after creating the function to prevent pollution
@@ -176,6 +184,7 @@ export class FunctionBuilder<
     this.inputSchema = undefined;
     this.outputSchema = undefined;
     this._timeout = undefined;
+    this._memorySize = undefined;
 
     return func;
   }

package/src/functions/__tests__/FunctionBuilder.state-isolation.spec.ts

@@ -0,0 +1,160 @@
+import { describe, expect, it } from 'vitest';
+import { ConsoleLogger } from '@geekmidas/logger/console';
+import { FunctionBuilder } from '../FunctionBuilder';
+import type { Service } from '@geekmidas/services';
+
+const ServiceA = {
+  serviceName: 'a' as const,
+  async register() {
+    return { test: () => 'a' };
+  },
+} satisfies Service<'a', any>;
+
+const ServiceB = {
+  serviceName: 'b' as const,
+  async register() {
+    return { test: () => 'b' };
+  },
+} satisfies Service<'b', any>;
+
+describe('FunctionBuilder - State Isolation', () => {
+  describe('singleton instance state reset', () => {
+    it('should reset services after handle() is called', () => {
+      const f = new FunctionBuilder();
+
+      // First function with ServiceA and ServiceB
+      const fn1 = f.services([ServiceA, ServiceB]).handle(async () => ({}));
+
+      // Second function should not have any services from first
+      const fn2 = f.handle(async () => ({}));
+
+      expect(fn1.services.map((s) => s.serviceName)).toEqual(['a', 'b']);
+      expect(fn2.services.map((s) => s.serviceName)).toEqual([]);
+    });
+
+    it('should reset logger after handle() is called', () => {
+      const f = new FunctionBuilder();
+      const customLogger = new ConsoleLogger({ app: 'custom' });
+
+      // First function with custom logger
+      const fn1 = f.logger(customLogger).handle(async () => ({}));
+
+      // Second function should have default logger (not the custom one)
+      const fn2 = f.handle(async () => ({}));
+
+      expect(fn1.logger).toBe(customLogger);
+      expect(fn2.logger).not.toBe(customLogger);
+      expect(fn2.logger).toBeInstanceOf(ConsoleLogger);
+    });
+
+    it('should reset events after handle() is called', () => {
+      const f = new FunctionBuilder();
+
+      // Create first function (events array should be empty initially)
+      const fn1 = f.handle(async () => ({}));
+
+      // Verify state was reset
+      expect((f as any)._events).toEqual([]);
+      expect((f as any)._services).toEqual([]);
+    });
+
+    it('should reset input/output schemas after handle() is called', () => {
+      const f = new FunctionBuilder();
+      const inputSchema: any = { '~standard': { validate: () => ({}) } };
+      const outputSchema: any = { '~standard': { validate: () => ({}) } };
+
+      // First function with schemas
+      const fn1 = f.input(inputSchema).output(outputSchema).handle(async () => ({}));
+
+      // Second function should not have schemas
+      const fn2 = f.handle(async () => ({}));
+
+      expect(fn1.input).toBe(inputSchema);
+      expect(fn1.outputSchema).toBe(outputSchema);
+      expect(fn2.input).toBeUndefined();
+      expect(fn2.outputSchema).toBeUndefined();
+    });
+
+    it('should reset timeout after handle() is called', () => {
+      const f = new FunctionBuilder();
+
+      // First function with custom timeout
+      const fn1 = f.timeout(5000).handle(async () => ({}));
+
+      // Second function should have default timeout (30000)
+      const fn2 = f.handle(async () => ({}));
+
+      expect(fn1.timeout).toBe(5000);
+      expect(fn2.timeout).toBe(30000); // Default timeout
+    });
+  });
+
+  describe('method chaining before handle()', () => {
+    it('should accumulate services when chaining', () => {
+      const f = new FunctionBuilder();
+
+      const fn = f
+        .services([ServiceA])
+        .services([ServiceB])
+        .handle(async () => ({}));
+
+      expect(fn.services.map((s) => s.serviceName)).toEqual(['a', 'b']);
+    });
+
+    it('should not share references between different builder chains', () => {
+      const f = new FunctionBuilder();
+
+      // Start two separate chains
+      const builder1 = f.services([ServiceA]);
+      const builder2 = f.services([ServiceB]);
+
+      // They should be the same instance (singleton)
+      expect(builder1).toBe(builder2);
+      expect(builder1).toBe(f);
+
+      // But after handle, state is reset
+      const fn1 = builder1.handle(async () => ({}));
+
+      // Now builder2 should have reset state
+      expect((builder2 as any)._services).toEqual([]);
+
+      // Add services again
+      const fn2 = builder2.services([ServiceB]).handle(async () => ({}));
+
+      expect(fn1.services.map((s) => s.serviceName)).toEqual(['a', 'b']);
+      expect(fn2.services.map((s) => s.serviceName)).toEqual(['b']);
+    });
+  });
+
+  describe('sequential function creation', () => {
+    it('should create independent functions sequentially', () => {
+      const f = new FunctionBuilder();
+
+      const fn1 = f.services([ServiceA, ServiceB]).handle(async () => ({ result: 1 }));
+      const fn2 = f.services([ServiceA]).handle(async () => ({ result: 2 }));
+      const fn3 = f.handle(async () => ({ result: 3 }));
+
+      expect(fn1.services.map((s) => s.serviceName)).toEqual(['a', 'b']);
+      expect(fn2.services.map((s) => s.serviceName)).toEqual(['a']);
+      expect(fn3.services.map((s) => s.serviceName)).toEqual([]);
+    });
+  });
+
+  describe('publisher isolation', () => {
+    it('should reset publisher after handle() is called', () => {
+      const f = new FunctionBuilder();
+      const mockPublisher: any = {
+        serviceName: 'publisher',
+        async register() {
+          return { publish: () => {} };
+        },
+      };
+
+      const fn1 = f.publisher(mockPublisher).handle(async () => ({}));
+      const fn2 = f.handle(async () => ({}));
+
+      expect((fn1 as any).publisherService).toBe(mockPublisher);
+      expect((fn2 as any).publisherService).toBeUndefined();
+    });
+  });
+});

package/dist/Construct-BSEs6uwW.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Construct-BSEs6uwW.cjs","names":["type: ConstructType","logger: TLogger","services: TServices","events: MappedEvent<T, any>[]","publisherService?: Service<TServiceName, T>","outputSchema?: OutSchema","EnvironmentParser","services: Service[]","v: string"],"sources":["../src/Construct.ts"],"sourcesContent":["import { EnvironmentParser } from '@geekmidas/envkit';\nimport type { EventPublisher, MappedEvent } from '@geekmidas/events';\nimport type { Logger } from '@geekmidas/logger';\nimport type { Service } from '@geekmidas/services';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport compact from 'lodash.compact';\n\nexport abstract class Construct<\n  TLogger extends Logger = Logger,\n  TServiceName extends string = string,\n  T extends EventPublisher<any> | undefined = undefined,\n  OutSchema extends StandardSchemaV1 | undefined = undefined,\n  TServices extends Service[] = [],\n> {\n  constructor(\n    public readonly type: ConstructType,\n    public readonly logger: TLogger,\n    public readonly services: TServices,\n    public readonly events: MappedEvent<T, any>[] = [],\n\n    public readonly publisherService?: Service<TServiceName, T>,\n    public outputSchema?: OutSchema,\n  ) {}\n\n  /**\n   * Returns an array of environment variable names required by this construct's services.\n   * This is determined by running a \"sniffer\" EnvironmentParser through each service's\n   * register method to track which environment variables are accessed.\n   *\n   * @returns Promise that resolves to array of environment variable names, sorted alphabetically\n   *\n   * @example\n   * ```typescript\n   * const endpoint = e\n   *   .services([databaseService, authService])\n   *   .get('/users')\n   *   .handle(async () => []);\n   *\n   * const envVars = await endpoint.getEnvironment(); // ['AUTH_SECRET', 'DATABASE_URL']\n   * ```\n   */\n  async getEnvironment(): Promise<string[]> {\n    const envVars = new Set<string>();\n    const sniffer = new EnvironmentParser({});\n    const services: Service[] = compact([\n      ...this.services,\n      this.publisherService,\n    ]);\n\n    try {\n      // Run each service's register method with the sniffer to track env var access\n      for (const service of services) {\n        try {\n          const config = service.register(sniffer);\n\n          // Await if it's a Promise (async services)\n          const resolvedConfig =\n            config && typeof config === 'object' && 'then' in config\n              ? await Promise.resolve(config)\n              : config;\n\n          // If register returns a ConfigParser, collect its env vars\n          if (\n            resolvedConfig &&\n            typeof resolvedConfig === 'object' &&\n            'getEnvironmentVariables' in resolvedConfig &&\n            typeof resolvedConfig.getEnvironmentVariables === 'function'\n          ) {\n            const vars = resolvedConfig.getEnvironmentVariables();\n            if (Array.isArray(vars)) {\n              vars.forEach((v: string) => envVars.add(v));\n            }\n          }\n        } catch (serviceError) {\n          // Service registration failed (e.g., missing env vars during .parse())\n          // But env vars were already tracked during .create(), so we continue\n          continue;\n        }\n      }\n\n      return Array.from(envVars).sort();\n    } catch (error) {\n      console.error(\n        'Error determining environment variables for construct:',\n        error,\n      );\n\n      return [];\n    }\n  }\n}\n\nexport enum ConstructType {\n  Cron = 'dev.geekmidas.function.cron',\n  Endpoint = 'dev.geekmidas.function.endpoint',\n  Function = 'dev.geekmidas.function.function',\n  Subscriber = 'dev.geekmidas.function.subscriber',\n}\n"],"mappings":";;;;;AAOA,IAAsB,YAAtB,MAME;CACA,YACkBA,MACAC,QACAC,UACAC,SAAgC,CAAE,GAElCC,kBACTC,cACP;EAPgB;EACA;EACA;EACA;EAEA;EACT;CACL;;;;;;;;;;;;;;;;;;CAmBJ,MAAM,iBAAoC;EACxC,MAAM,0BAAU,IAAI;EACpB,MAAM,UAAU,IAAIC,qCAAkB,CAAE;EACxC,MAAMC,WAAsB,4BAAQ,CAClC,GAAG,KAAK,UACR,KAAK,gBACN,EAAC;AAEF,MAAI;AAEF,QAAK,MAAM,WAAW,SACpB,KAAI;IACF,MAAM,SAAS,QAAQ,SAAS,QAAQ;IAGxC,MAAM,iBACJ,iBAAiB,WAAW,YAAY,UAAU,SAC9C,MAAM,QAAQ,QAAQ,OAAO,GAC7B;AAGN,QACE,yBACO,mBAAmB,YAC1B,6BAA6B,yBACtB,eAAe,4BAA4B,YAClD;KACA,MAAM,OAAO,eAAe,yBAAyB;AACrD,SAAI,MAAM,QAAQ,KAAK,CACrB,MAAK,QAAQ,CAACC,MAAc,QAAQ,IAAI,EAAE,CAAC;IAE9C;GACF,SAAQ,cAAc;AAGrB;GACD;AAGH,UAAO,MAAM,KAAK,QAAQ,CAAC,MAAM;EAClC,SAAQ,OAAO;AACd,WAAQ,MACN,0DACA,MACD;AAED,UAAO,CAAE;EACV;CACF;AACF;AAED,IAAY,0DAAL;AACL;AACA;AACA;AACA;;AACD"}

package/dist/Construct-BbKCIPQm.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"Construct-BbKCIPQm.mjs","names":["type: ConstructType","logger: TLogger","services: TServices","events: MappedEvent<T, any>[]","publisherService?: Service<TServiceName, T>","outputSchema?: OutSchema","services: Service[]","v: string"],"sources":["../src/Construct.ts"],"sourcesContent":["import { EnvironmentParser } from '@geekmidas/envkit';\nimport type { EventPublisher, MappedEvent } from '@geekmidas/events';\nimport type { Logger } from '@geekmidas/logger';\nimport type { Service } from '@geekmidas/services';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport compact from 'lodash.compact';\n\nexport abstract class Construct<\n  TLogger extends Logger = Logger,\n  TServiceName extends string = string,\n  T extends EventPublisher<any> | undefined = undefined,\n  OutSchema extends StandardSchemaV1 | undefined = undefined,\n  TServices extends Service[] = [],\n> {\n  constructor(\n    public readonly type: ConstructType,\n    public readonly logger: TLogger,\n    public readonly services: TServices,\n    public readonly events: MappedEvent<T, any>[] = [],\n\n    public readonly publisherService?: Service<TServiceName, T>,\n    public outputSchema?: OutSchema,\n  ) {}\n\n  /**\n   * Returns an array of environment variable names required by this construct's services.\n   * This is determined by running a \"sniffer\" EnvironmentParser through each service's\n   * register method to track which environment variables are accessed.\n   *\n   * @returns Promise that resolves to array of environment variable names, sorted alphabetically\n   *\n   * @example\n   * ```typescript\n   * const endpoint = e\n   *   .services([databaseService, authService])\n   *   .get('/users')\n   *   .handle(async () => []);\n   *\n   * const envVars = await endpoint.getEnvironment(); // ['AUTH_SECRET', 'DATABASE_URL']\n   * ```\n   */\n  async getEnvironment(): Promise<string[]> {\n    const envVars = new Set<string>();\n    const sniffer = new EnvironmentParser({});\n    const services: Service[] = compact([\n      ...this.services,\n      this.publisherService,\n    ]);\n\n    try {\n      // Run each service's register method with the sniffer to track env var access\n      for (const service of services) {\n        try {\n          const config = service.register(sniffer);\n\n          // Await if it's a Promise (async services)\n          const resolvedConfig =\n            config && typeof config === 'object' && 'then' in config\n              ? await Promise.resolve(config)\n              : config;\n\n          // If register returns a ConfigParser, collect its env vars\n          if (\n            resolvedConfig &&\n            typeof resolvedConfig === 'object' &&\n            'getEnvironmentVariables' in resolvedConfig &&\n            typeof resolvedConfig.getEnvironmentVariables === 'function'\n          ) {\n            const vars = resolvedConfig.getEnvironmentVariables();\n            if (Array.isArray(vars)) {\n              vars.forEach((v: string) => envVars.add(v));\n            }\n          }\n        } catch (serviceError) {\n          // Service registration failed (e.g., missing env vars during .parse())\n          // But env vars were already tracked during .create(), so we continue\n          continue;\n        }\n      }\n\n      return Array.from(envVars).sort();\n    } catch (error) {\n      console.error(\n        'Error determining environment variables for construct:',\n        error,\n      );\n\n      return [];\n    }\n  }\n}\n\nexport enum ConstructType {\n  Cron = 'dev.geekmidas.function.cron',\n  Endpoint = 'dev.geekmidas.function.endpoint',\n  Function = 'dev.geekmidas.function.function',\n  Subscriber = 'dev.geekmidas.function.subscriber',\n}\n"],"mappings":";;;;AAOA,IAAsB,YAAtB,MAME;CACA,YACkBA,MACAC,QACAC,UACAC,SAAgC,CAAE,GAElCC,kBACTC,cACP;EAPgB;EACA;EACA;EACA;EAEA;EACT;CACL;;;;;;;;;;;;;;;;;;CAmBJ,MAAM,iBAAoC;EACxC,MAAM,0BAAU,IAAI;EACpB,MAAM,UAAU,IAAI,kBAAkB,CAAE;EACxC,MAAMC,WAAsB,QAAQ,CAClC,GAAG,KAAK,UACR,KAAK,gBACN,EAAC;AAEF,MAAI;AAEF,QAAK,MAAM,WAAW,SACpB,KAAI;IACF,MAAM,SAAS,QAAQ,SAAS,QAAQ;IAGxC,MAAM,iBACJ,iBAAiB,WAAW,YAAY,UAAU,SAC9C,MAAM,QAAQ,QAAQ,OAAO,GAC7B;AAGN,QACE,yBACO,mBAAmB,YAC1B,6BAA6B,yBACtB,eAAe,4BAA4B,YAClD;KACA,MAAM,OAAO,eAAe,yBAAyB;AACrD,SAAI,MAAM,QAAQ,KAAK,CACrB,MAAK,QAAQ,CAACC,MAAc,QAAQ,IAAI,EAAE,CAAC;IAE9C;GACF,SAAQ,cAAc;AAGrB;GACD;AAGH,UAAO,MAAM,KAAK,QAAQ,CAAC,MAAM;EAClC,SAAQ,OAAO;AACd,WAAQ,MACN,0DACA,MACD;AAED,UAAO,CAAE;EACV;CACF;AACF;AAED,IAAY,0DAAL;AACL;AACA;AACA;AACA;;AACD"}