@geekmidas/constructs 0.0.1 → 0.0.3

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

@@ -0,0 +1,235 @@
+import { describe, expect, it } from 'vitest';
+import { ResponseBuilder, SuccessStatus } from '../Endpoint';
+
+describe('ResponseBuilder', () => {
+  describe('header', () => {
+    it('should set a single header', () => {
+      const builder = new ResponseBuilder();
+      builder.header('X-Custom-Header', 'custom-value');
+
+      const metadata = builder.getMetadata();
+      expect(metadata.headers).toEqual({
+        'X-Custom-Header': 'custom-value',
+      });
+    });
+
+    it('should set multiple headers', () => {
+      const builder = new ResponseBuilder();
+      builder
+        .header('X-Header-1', 'value1')
+        .header('X-Header-2', 'value2')
+        .header('Content-Type', 'application/json');
+
+      const metadata = builder.getMetadata();
+      expect(metadata.headers).toEqual({
+        'X-Header-1': 'value1',
+        'X-Header-2': 'value2',
+        'Content-Type': 'application/json',
+      });
+    });
+
+    it('should allow method chaining', () => {
+      const builder = new ResponseBuilder();
+      const result = builder.header('X-Test', 'value');
+
+      expect(result).toBe(builder);
+    });
+  });
+
+  describe('cookie', () => {
+    it('should set a simple cookie', () => {
+      const builder = new ResponseBuilder();
+      builder.cookie('session', 'abc123');
+
+      const metadata = builder.getMetadata();
+      expect(metadata.cookies?.has('session')).toBe(true);
+      expect(metadata.cookies?.get('session')).toEqual({
+        value: 'abc123',
+        options: undefined,
+      });
+    });
+
+    it('should set cookie with options', () => {
+      const builder = new ResponseBuilder();
+      builder.cookie('session', 'abc123', {
+        httpOnly: true,
+        secure: true,
+        sameSite: 'strict',
+        maxAge: 3600,
+        path: '/',
+      });
+
+      const metadata = builder.getMetadata();
+      const cookie = metadata.cookies?.get('session');
+      expect(cookie).toEqual({
+        value: 'abc123',
+        options: {
+          httpOnly: true,
+          secure: true,
+          sameSite: 'strict',
+          maxAge: 3600,
+          path: '/',
+        },
+      });
+    });
+
+    it('should set multiple cookies', () => {
+      const builder = new ResponseBuilder();
+      builder
+        .cookie('session', 'abc123')
+        .cookie('theme', 'dark')
+        .cookie('lang', 'en');
+
+      const metadata = builder.getMetadata();
+      expect(metadata.cookies?.size).toBe(3);
+      expect(metadata.cookies?.get('session')?.value).toBe('abc123');
+      expect(metadata.cookies?.get('theme')?.value).toBe('dark');
+      expect(metadata.cookies?.get('lang')?.value).toBe('en');
+    });
+
+    it('should allow method chaining', () => {
+      const builder = new ResponseBuilder();
+      const result = builder.cookie('test', 'value');
+
+      expect(result).toBe(builder);
+    });
+  });
+
+  describe('deleteCookie', () => {
+    it('should set cookie with empty value and maxAge 0', () => {
+      const builder = new ResponseBuilder();
+      builder.deleteCookie('session');
+
+      const metadata = builder.getMetadata();
+      const cookie = metadata.cookies?.get('session');
+      expect(cookie?.value).toBe('');
+      expect(cookie?.options?.maxAge).toBe(0);
+      expect(cookie?.options?.expires?.getTime()).toBe(0);
+    });
+
+    it('should preserve domain and path options', () => {
+      const builder = new ResponseBuilder();
+      builder.deleteCookie('session', {
+        domain: '.example.com',
+        path: '/app',
+      });
+
+      const metadata = builder.getMetadata();
+      const cookie = metadata.cookies?.get('session');
+      expect(cookie?.options).toMatchObject({
+        domain: '.example.com',
+        path: '/app',
+        maxAge: 0,
+      });
+    });
+
+    it('should allow method chaining', () => {
+      const builder = new ResponseBuilder();
+      const result = builder.deleteCookie('test');
+
+      expect(result).toBe(builder);
+    });
+  });
+
+  describe('status', () => {
+    it('should set status code', () => {
+      const builder = new ResponseBuilder();
+      builder.status(SuccessStatus.Created);
+
+      const metadata = builder.getMetadata();
+      expect(metadata.status).toBe(201);
+    });
+
+    it('should allow method chaining', () => {
+      const builder = new ResponseBuilder();
+      const result = builder.status(SuccessStatus.OK);
+
+      expect(result).toBe(builder);
+    });
+  });
+
+  describe('send', () => {
+    it('should return data with metadata', () => {
+      const builder = new ResponseBuilder();
+      builder.header('X-Test', 'value').status(SuccessStatus.Created);
+
+      const result = builder.send({ id: '123', name: 'Test' });
+
+      expect(result).toEqual({
+        data: { id: '123', name: 'Test' },
+        metadata: {
+          headers: { 'X-Test': 'value' },
+          cookies: new Map(),
+          status: SuccessStatus.Created,
+        },
+      });
+    });
+
+    it('should work with complex data', () => {
+      const builder = new ResponseBuilder();
+      const complexData = {
+        user: { id: '1', name: 'John' },
+        posts: [{ id: '1', title: 'Post' }],
+      };
+
+      const result = builder.send(complexData);
+
+      expect(result.data).toEqual(complexData);
+      expect(result.metadata).toBeDefined();
+    });
+  });
+
+  describe('fluent API', () => {
+    it('should support full fluent chain', () => {
+      const builder = new ResponseBuilder();
+
+      const result = builder
+        .status(SuccessStatus.Created)
+        .header('Location', '/users/123')
+        .header('X-User-Id', '123')
+        .cookie('session', 'abc123', { httpOnly: true })
+        .cookie('preferences', 'dark-mode')
+        .send({ id: '123', name: 'John' });
+
+      expect(result).toEqual({
+        data: { id: '123', name: 'John' },
+        metadata: {
+          status: 201,
+          headers: {
+            Location: '/users/123',
+            'X-User-Id': '123',
+          },
+          cookies: new Map([
+            ['session', { value: 'abc123', options: { httpOnly: true } }],
+            ['preferences', { value: 'dark-mode', options: undefined }],
+          ]),
+        },
+      });
+    });
+  });
+
+  describe('getMetadata', () => {
+    it('should return current metadata', () => {
+      const builder = new ResponseBuilder();
+      builder.header('X-Test', 'value').cookie('test', 'cookie-value');
+
+      const metadata = builder.getMetadata();
+
+      expect(metadata).toEqual({
+        headers: { 'X-Test': 'value' },
+        cookies: new Map([
+          ['test', { value: 'cookie-value', options: undefined }],
+        ]),
+      });
+    });
+
+    it('should return empty objects for unused features', () => {
+      const builder = new ResponseBuilder();
+      const metadata = builder.getMetadata();
+
+      expect(metadata.headers).toEqual({});
+      expect(metadata.cookies?.size).toBe(0);
+      expect(metadata.status).toBeUndefined();
+    });
+  });
+});

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

@@ -2,6 +2,7 @@ import { UnprocessableEntityError } from '@geekmidas/errors';
 import { ConsoleLogger } from '@geekmidas/logger/console';
 import { describe, expect, it, vi } from 'vitest';
 import { z } from 'zod';
+import { SuccessStatus } from '../Endpoint';
 import { e } from '../EndpointFactory';
 import { TestEndpointAdaptor } from '../TestEndpointAdaptor';
 
@@ -191,6 +192,7 @@ describe('TestEndpointAdaptor', () => {
         logger: expect.any(ConsoleLogger),
         services: mockServices,
         header: expect.any(Function),
+        cookie: expect.any(Function),
       });
     });
 
@@ -232,5 +234,351 @@ describe('TestEndpointAdaptor', () => {
         contentType: 'application/json',
       });
     });
+
+    it('should read cookies from request', async () => {
+      const endpoint = e
+        .get('/cookies')
+        .output(
+          z.object({
+            session: z.string().optional(),
+            theme: z.string().optional(),
+          }),
+        )
+        .handle(async ({ cookie }) => ({
+          session: cookie('session'),
+          theme: cookie('theme'),
+        }));
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+
+      const result = await adapter.request({
+        services: mockServices,
+        headers: {
+          host: 'example.com',
+          cookie: 'session=abc123; theme=dark',
+        },
+      });
+
+      expect(result).toEqual({
+        session: 'abc123',
+        theme: 'dark',
+      });
+    });
+
+    it('should handle missing cookies gracefully', async () => {
+      const endpoint = e
+        .get('/cookies-optional')
+        .output(
+          z.object({
+            session: z.string().optional(),
+          }),
+        )
+        .handle(async ({ cookie }) => ({
+          session: cookie('session') || 'default',
+        }));
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+
+      const result = await adapter.request({
+        services: mockServices,
+        headers: {
+          host: 'example.com',
+        },
+      });
+
+      expect(result).toEqual({
+        session: 'default',
+      });
+    });
+
+    it('should handle URL encoded cookie values', async () => {
+      const endpoint = e
+        .get('/cookies-encoded')
+        .output(z.object({ user: z.string() }))
+        .handle(async ({ cookie }) => ({
+          user: cookie('user') || 'unknown',
+        }));
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+
+      const result = await adapter.request({
+        services: mockServices,
+        headers: {
+          host: 'example.com',
+          cookie: 'user=John%20Doe',
+        },
+      });
+
+      expect(result).toEqual({
+        user: 'John Doe',
+      });
+    });
+
+    it('should use cookies in session extraction', async () => {
+      const endpoint = e
+        .get('/profile')
+        .output(z.object({ userId: z.string() }))
+        .handle(async ({ session }) => ({
+          userId: (session as any).userId,
+        }));
+
+      // Mock getSession that uses cookies
+      endpoint.getSession = vi.fn().mockImplementation(({ cookie }) => {
+        const sessionId = cookie('session');
+        if (sessionId === 'valid-session') {
+          return { userId: 'user-123' };
+        }
+        return null;
+      });
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+
+      const result = await adapter.request({
+        services: mockServices,
+        headers: {
+          host: 'example.com',
+          cookie: 'session=valid-session',
+        },
+      });
+
+      expect(result).toEqual({ userId: 'user-123' });
+      expect(endpoint.getSession).toHaveBeenCalledWith({
+        logger: expect.any(ConsoleLogger),
+        services: mockServices,
+        header: expect.any(Function),
+        cookie: expect.any(Function),
+      });
+    });
+
+    it('should handle multiple cookies with same name (uses last)', async () => {
+      const endpoint = e
+        .get('/duplicate-cookies')
+        .output(z.object({ value: z.string() }))
+        .handle(async ({ cookie }) => ({
+          value: cookie('test') || 'none',
+        }));
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+
+      const result = await adapter.request({
+        services: mockServices,
+        headers: {
+          host: 'example.com',
+          cookie: 'test=first; test=second',
+        },
+      });
+
+      // When duplicates exist, Map uses the last occurrence
+      expect(result).toEqual({
+        value: 'second',
+      });
+    });
+  });
+
+  describe('response handling', () => {
+    it('should set response cookies', 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.request({
+        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({
+        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,
+        },
+      });
+    });
+
+    it('should set custom response headers', 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.request({
+        body: { name: 'John Doe' },
+        services: mockServices,
+        headers: { host: 'example.com' },
+      });
+
+      expect((result as any).data).toEqual({
+        id: 'user-123',
+        name: 'John Doe',
+      });
+      expect((result as any).metadata.headers).toEqual({
+        Location: '/users/user-123',
+        'X-User-Id': 'user-123',
+      });
+    });
+
+    it('should set custom status code', 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.request({
+        body: { name: 'Resource' },
+        services: mockServices,
+        headers: { host: 'example.com' },
+      });
+
+      expect((result as any).metadata.status).toBe(201);
+    });
+
+    it('should delete cookies', 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.request({
+        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('/');
+    });
+
+    it('should combine cookies, headers, and status', 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.request({
+        body: { data: 'test' },
+        services: mockServices,
+        headers: { host: 'example.com' },
+      });
+
+      expect((result as any).data).toEqual({
+        id: '123',
+        result: 'test',
+      });
+      expect((result as any).metadata.status).toBe(201);
+      expect((result as any).metadata.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 },
+      });
+    });
+
+    it('should return simple response without metadata when not using response builder', async () => {
+      const endpoint = e
+        .get('/simple')
+        .output(z.object({ message: z.string() }))
+        .handle(async () => {
+          // Not using response builder, just returning data
+          return { message: 'Hello' };
+        });
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+      const result = await adapter.request({
+        services: mockServices,
+        headers: { host: 'example.com' },
+      });
+
+      // Should return just the data, not wrapped in metadata
+      expect(result).toEqual({ message: 'Hello' });
+      expect(result).not.toHaveProperty('metadata');
+    });
+
+    it('should combine request cookies and response cookies', async () => {
+      const endpoint = e
+        .get('/preferences')
+        .output(z.object({ theme: z.string(), updated: z.boolean() }))
+        .handle(async ({ cookie }, response) => {
+          const currentTheme = cookie('theme') || 'light';
+          const newTheme = currentTheme === 'light' ? 'dark' : 'light';
+
+          return response
+            .cookie('theme', newTheme, { maxAge: 86400 })
+            .send({ theme: newTheme, updated: true });
+        });
+
+      const adapter = new TestEndpointAdaptor(endpoint);
+      const result = await adapter.request({
+        services: mockServices,
+        headers: {
+          host: 'example.com',
+          cookie: 'theme=light',
+        },
+      });
+
+      expect((result as any).data).toEqual({
+        theme: 'dark',
+        updated: true,
+      });
+      expect((result as any).metadata.cookies?.get('theme')?.value).toBe(
+        'dark',
+      );
+    });
   });
 });

package/dist/endpoints/TestEndpointAdaptor.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"TestEndpointAdaptor.cjs","names":["endpoint: Endpoint<\n      TRoute,\n      TMethod,\n      TInput,\n      TOutSchema,\n      TServices,\n      TLogger,\n      TSession,\n      TEventPublisher,\n      TEventPublisherServiceName\n    >","EnvironmentParser","serviceDiscovery: ServiceDiscovery<\n      any,\n      any\n    >","ctx: TestRequestAdaptor<\n      TInput,\n      TServices,\n      TEventPublisher,\n      TEventPublisherServiceName\n    >"],"sources":["../../src/endpoints/TestEndpointAdaptor.ts"],"sourcesContent":["import { EnvironmentParser } from '@geekmidas/envkit';\nimport type { EventPublisher } from '@geekmidas/events';\nimport type { Logger } from '@geekmidas/logger';\nimport type {\n  InferComposableStandardSchema,\n  InferStandardSchema,\n} from '@geekmidas/schema';\nimport {\n  type Service,\n  ServiceDiscovery,\n  type ServiceRecord,\n} from '@geekmidas/services';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport { publishConstructEvents } from '../publisher';\nimport type { HttpMethod } from '../types';\nimport { Endpoint, type EndpointSchemas } from './Endpoint';\n\nexport class TestEndpointAdaptor<\n  TRoute extends string,\n  TMethod extends HttpMethod,\n  TInput extends EndpointSchemas = {},\n  TOutSchema extends StandardSchemaV1 | undefined = undefined,\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TSession = unknown,\n  TEventPublisher extends EventPublisher<any> | undefined = undefined,\n  TEventPublisherServiceName extends string = string,\n> {\n  static getDefaultServiceDiscover<\n    TRoute extends string,\n    TMethod extends HttpMethod,\n    TInput extends EndpointSchemas = {},\n    TOutSchema extends StandardSchemaV1 | undefined = undefined,\n    TServices extends Service[] = [],\n    TLogger extends Logger = Logger,\n    TSession = unknown,\n    TEventPublisher extends EventPublisher<any> | undefined = undefined,\n    TEventPublisherServiceName extends string = string,\n  >(\n    endpoint: Endpoint<\n      TRoute,\n      TMethod,\n      TInput,\n      TOutSchema,\n      TServices,\n      TLogger,\n      TSession,\n      TEventPublisher,\n      TEventPublisherServiceName\n    >,\n  ) {\n    return ServiceDiscovery.getInstance(\n      endpoint.logger,\n      new EnvironmentParser({}),\n    );\n  }\n  constructor(\n    private readonly endpoint: Endpoint<\n      TRoute,\n      TMethod,\n      TInput,\n      TOutSchema,\n      TServices,\n      TLogger,\n      TSession,\n      TEventPublisher,\n      TEventPublisherServiceName\n    >,\n    private serviceDiscovery: ServiceDiscovery<\n      any,\n      any\n    > = TestEndpointAdaptor.getDefaultServiceDiscover(endpoint),\n  ) {}\n\n  async request(\n    ctx: TestRequestAdaptor<\n      TInput,\n      TServices,\n      TEventPublisher,\n      TEventPublisherServiceName\n    >,\n  ): Promise<InferStandardSchema<TOutSchema>> {\n    const body = await this.endpoint.parseInput((ctx as any).body, 'body');\n    const query = await this.endpoint.parseInput((ctx as any).query, 'query');\n    const params = await this.endpoint.parseInput(\n      (ctx as any).params,\n      'params',\n    );\n\n    const header = Endpoint.createHeaders(ctx.headers);\n    const logger = this.endpoint.logger.child({\n      route: this.endpoint.route,\n      host: ctx.headers.host,\n      method: this.endpoint.method,\n    }) as TLogger;\n    const session = await this.endpoint.getSession({\n      logger,\n      services: ctx.services,\n      header,\n    });\n\n    const response = await this.endpoint.handler({\n      body,\n      query,\n      params,\n      session,\n      services: ctx.services,\n      logger,\n      header,\n    } as any);\n\n    const output = await this.endpoint.parseOutput(response);\n    ctx.publisher && (await this.serviceDiscovery.register([ctx.publisher]));\n\n    await publishConstructEvents(this.endpoint, output, this.serviceDiscovery);\n\n    return output;\n  }\n}\n\nexport type TestRequestAdaptor<\n  TInput extends EndpointSchemas = {},\n  TServices extends Service[] = [],\n  TEventPublisher extends EventPublisher<any> | undefined = undefined,\n  TEventPublisherServiceName extends string = string,\n> = {\n  services: ServiceRecord<TServices>;\n  headers: Record<string, string>;\n  publisher?: Service<TEventPublisherServiceName, TEventPublisher>;\n} & InferComposableStandardSchema<TInput>;\n"],"mappings":";;;;;;;;;;;;AAiBA,IAAa,sBAAb,MAAa,oBAUX;CACA,OAAO,0BAWLA,UAWA;AACA,SAAO,sCAAiB,YACtB,SAAS,QACT,IAAIC,qCAAkB,CAAE,GACzB;CACF;CACD,YACmBD,UAWTE,mBAGJ,oBAAoB,0BAA0B,SAAS,EAC3D;EAfiB;EAWT;CAIN;CAEJ,MAAM,QACJC,KAM0C;EAC1C,MAAM,OAAO,MAAM,KAAK,SAAS,WAAY,IAAY,MAAM,OAAO;EACtE,MAAM,QAAQ,MAAM,KAAK,SAAS,WAAY,IAAY,OAAO,QAAQ;EACzE,MAAM,SAAS,MAAM,KAAK,SAAS,WAChC,IAAY,QACb,SACD;EAED,MAAM,SAAS,0BAAS,cAAc,IAAI,QAAQ;EAClD,MAAM,SAAS,KAAK,SAAS,OAAO,MAAM;GACxC,OAAO,KAAK,SAAS;GACrB,MAAM,IAAI,QAAQ;GAClB,QAAQ,KAAK,SAAS;EACvB,EAAC;EACF,MAAM,UAAU,MAAM,KAAK,SAAS,WAAW;GAC7C;GACA,UAAU,IAAI;GACd;EACD,EAAC;EAEF,MAAM,WAAW,MAAM,KAAK,SAAS,QAAQ;GAC3C;GACA;GACA;GACA;GACA,UAAU,IAAI;GACd;GACA;EACD,EAAQ;EAET,MAAM,SAAS,MAAM,KAAK,SAAS,YAAY,SAAS;AACxD,MAAI,aAAc,MAAM,KAAK,iBAAiB,SAAS,CAAC,IAAI,SAAU,EAAC;AAEvE,QAAM,yCAAuB,KAAK,UAAU,QAAQ,KAAK,iBAAiB;AAE1E,SAAO;CACR;AACF"}

package/dist/endpoints/TestEndpointAdaptor.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"TestEndpointAdaptor.mjs","names":["endpoint: Endpoint<\n      TRoute,\n      TMethod,\n      TInput,\n      TOutSchema,\n      TServices,\n      TLogger,\n      TSession,\n      TEventPublisher,\n      TEventPublisherServiceName\n    >","serviceDiscovery: ServiceDiscovery<\n      any,\n      any\n    >","ctx: TestRequestAdaptor<\n      TInput,\n      TServices,\n      TEventPublisher,\n      TEventPublisherServiceName\n    >"],"sources":["../../src/endpoints/TestEndpointAdaptor.ts"],"sourcesContent":["import { EnvironmentParser } from '@geekmidas/envkit';\nimport type { EventPublisher } from '@geekmidas/events';\nimport type { Logger } from '@geekmidas/logger';\nimport type {\n  InferComposableStandardSchema,\n  InferStandardSchema,\n} from '@geekmidas/schema';\nimport {\n  type Service,\n  ServiceDiscovery,\n  type ServiceRecord,\n} from '@geekmidas/services';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport { publishConstructEvents } from '../publisher';\nimport type { HttpMethod } from '../types';\nimport { Endpoint, type EndpointSchemas } from './Endpoint';\n\nexport class TestEndpointAdaptor<\n  TRoute extends string,\n  TMethod extends HttpMethod,\n  TInput extends EndpointSchemas = {},\n  TOutSchema extends StandardSchemaV1 | undefined = undefined,\n  TServices extends Service[] = [],\n  TLogger extends Logger = Logger,\n  TSession = unknown,\n  TEventPublisher extends EventPublisher<any> | undefined = undefined,\n  TEventPublisherServiceName extends string = string,\n> {\n  static getDefaultServiceDiscover<\n    TRoute extends string,\n    TMethod extends HttpMethod,\n    TInput extends EndpointSchemas = {},\n    TOutSchema extends StandardSchemaV1 | undefined = undefined,\n    TServices extends Service[] = [],\n    TLogger extends Logger = Logger,\n    TSession = unknown,\n    TEventPublisher extends EventPublisher<any> | undefined = undefined,\n    TEventPublisherServiceName extends string = string,\n  >(\n    endpoint: Endpoint<\n      TRoute,\n      TMethod,\n      TInput,\n      TOutSchema,\n      TServices,\n      TLogger,\n      TSession,\n      TEventPublisher,\n      TEventPublisherServiceName\n    >,\n  ) {\n    return ServiceDiscovery.getInstance(\n      endpoint.logger,\n      new EnvironmentParser({}),\n    );\n  }\n  constructor(\n    private readonly endpoint: Endpoint<\n      TRoute,\n      TMethod,\n      TInput,\n      TOutSchema,\n      TServices,\n      TLogger,\n      TSession,\n      TEventPublisher,\n      TEventPublisherServiceName\n    >,\n    private serviceDiscovery: ServiceDiscovery<\n      any,\n      any\n    > = TestEndpointAdaptor.getDefaultServiceDiscover(endpoint),\n  ) {}\n\n  async request(\n    ctx: TestRequestAdaptor<\n      TInput,\n      TServices,\n      TEventPublisher,\n      TEventPublisherServiceName\n    >,\n  ): Promise<InferStandardSchema<TOutSchema>> {\n    const body = await this.endpoint.parseInput((ctx as any).body, 'body');\n    const query = await this.endpoint.parseInput((ctx as any).query, 'query');\n    const params = await this.endpoint.parseInput(\n      (ctx as any).params,\n      'params',\n    );\n\n    const header = Endpoint.createHeaders(ctx.headers);\n    const logger = this.endpoint.logger.child({\n      route: this.endpoint.route,\n      host: ctx.headers.host,\n      method: this.endpoint.method,\n    }) as TLogger;\n    const session = await this.endpoint.getSession({\n      logger,\n      services: ctx.services,\n      header,\n    });\n\n    const response = await this.endpoint.handler({\n      body,\n      query,\n      params,\n      session,\n      services: ctx.services,\n      logger,\n      header,\n    } as any);\n\n    const output = await this.endpoint.parseOutput(response);\n    ctx.publisher && (await this.serviceDiscovery.register([ctx.publisher]));\n\n    await publishConstructEvents(this.endpoint, output, this.serviceDiscovery);\n\n    return output;\n  }\n}\n\nexport type TestRequestAdaptor<\n  TInput extends EndpointSchemas = {},\n  TServices extends Service[] = [],\n  TEventPublisher extends EventPublisher<any> | undefined = undefined,\n  TEventPublisherServiceName extends string = string,\n> = {\n  services: ServiceRecord<TServices>;\n  headers: Record<string, string>;\n  publisher?: Service<TEventPublisherServiceName, TEventPublisher>;\n} & InferComposableStandardSchema<TInput>;\n"],"mappings":";;;;;;;;;;;AAiBA,IAAa,sBAAb,MAAa,oBAUX;CACA,OAAO,0BAWLA,UAWA;AACA,SAAO,iBAAiB,YACtB,SAAS,QACT,IAAI,kBAAkB,CAAE,GACzB;CACF;CACD,YACmBA,UAWTC,mBAGJ,oBAAoB,0BAA0B,SAAS,EAC3D;EAfiB;EAWT;CAIN;CAEJ,MAAM,QACJC,KAM0C;EAC1C,MAAM,OAAO,MAAM,KAAK,SAAS,WAAY,IAAY,MAAM,OAAO;EACtE,MAAM,QAAQ,MAAM,KAAK,SAAS,WAAY,IAAY,OAAO,QAAQ;EACzE,MAAM,SAAS,MAAM,KAAK,SAAS,WAChC,IAAY,QACb,SACD;EAED,MAAM,SAAS,SAAS,cAAc,IAAI,QAAQ;EAClD,MAAM,SAAS,KAAK,SAAS,OAAO,MAAM;GACxC,OAAO,KAAK,SAAS;GACrB,MAAM,IAAI,QAAQ;GAClB,QAAQ,KAAK,SAAS;EACvB,EAAC;EACF,MAAM,UAAU,MAAM,KAAK,SAAS,WAAW;GAC7C;GACA,UAAU,IAAI;GACd;EACD,EAAC;EAEF,MAAM,WAAW,MAAM,KAAK,SAAS,QAAQ;GAC3C;GACA;GACA;GACA;GACA,UAAU,IAAI;GACd;GACA;EACD,EAAQ;EAET,MAAM,SAAS,MAAM,KAAK,SAAS,YAAY,SAAS;AACxD,MAAI,aAAc,MAAM,KAAK,iBAAiB,SAAS,CAAC,IAAI,SAAU,EAAC;AAEvE,QAAM,uBAAuB,KAAK,UAAU,QAAQ,KAAK,iBAAiB;AAE1E,SAAO;CACR;AACF"}

package/dist/index-CuGR4L7O.d.mts

@@ -1,9 +0,0 @@
-import { FunctionBuilder } from "./FunctionBuilder-C-PfPN3r.mjs";
-import * as _geekmidas_logger8 from "@geekmidas/logger";
-import * as _geekmidas_schema7 from "@geekmidas/schema";
-
-//#region src/functions/index.d.ts
-declare const f: FunctionBuilder<_geekmidas_schema7.ComposableStandardSchema, undefined, [], _geekmidas_logger8.Logger, undefined, string>;
-//#endregion
-export { f };
-//# sourceMappingURL=index-CuGR4L7O.d.mts.map

package/dist/index-Fg3N3EKD.d.cts

@@ -1,9 +0,0 @@
-import { FunctionBuilder } from "./FunctionBuilder-BS1KgxA_.cjs";
-import * as _geekmidas_logger7 from "@geekmidas/logger";
-import * as _geekmidas_schema6 from "@geekmidas/schema";
-
-//#region src/functions/index.d.ts
-declare const f: FunctionBuilder<_geekmidas_schema6.ComposableStandardSchema, undefined, [], _geekmidas_logger7.Logger, undefined, string>;
-//#endregion
-export { f };
-//# sourceMappingURL=index-Fg3N3EKD.d.cts.map