@geekmidas/constructs 0.0.7 → 0.0.10

package/src/endpoints/EndpointFactory.ts

@@ -2,6 +2,7 @@ import type { Logger } from '@geekmidas/logger';
 import { ConsoleLogger } from '@geekmidas/logger/console';
 import type { Service } from '@geekmidas/services';
 import uniqBy from 'lodash.uniqby';
+import type { Authorizer } from './Authorizer';
 import type { AuthorizeFn, SessionFn } from './Endpoint';
 import { EndpointBuilder } from './EndpointBuilder';
 
@@ -17,6 +18,7 @@ export class EndpointFactory<
   TSession = unknown,
   TEventPublisher extends EventPublisher<any> | undefined = undefined,
   TEventPublisherServiceName extends string = string,
+  TAuthorizers extends readonly string[] = readonly string[],
 > {
   // @ts-ignore
   private defaultServices: TServices;
@@ -27,6 +29,8 @@ export class EndpointFactory<
     | undefined;
   private defaultSessionExtractor?: SessionFn<TServices, TLogger, TSession>;
   private defaultLogger: TLogger = DEFAULT_LOGGER;
+  private availableAuthorizers: Authorizer[] = [];
+  private defaultAuthorizerName?: TAuthorizers[number];
 
   constructor({
     basePath,
@@ -36,13 +40,16 @@ export class EndpointFactory<
     // @ts-ignore
     defaultServices = [] as TServices,
     defaultEventPublisher,
+    availableAuthorizers = [],
+    defaultAuthorizerName,
   }: EndpointFactoryOptions<
     TServices,
     TBasePath,
     TLogger,
     TSession,
     TEventPublisher,
-    TEventPublisherServiceName
+    TEventPublisherServiceName,
+    TAuthorizers
   > = {}) {
     // Initialize default services
     this.defaultServices = uniqBy(
@@ -55,6 +62,8 @@ export class EndpointFactory<
     this.defaultLogger = defaultLogger || (DEFAULT_LOGGER as TLogger);
     this.defaultSessionExtractor = defaultSessionExtractor;
     this.defaultEventPublisher = defaultEventPublisher;
+    this.availableAuthorizers = availableAuthorizers;
+    this.defaultAuthorizerName = defaultAuthorizerName;
   }
 
   static joinPaths<TBasePath extends string, P extends string>(
@@ -94,6 +103,41 @@ export class EndpointFactory<
     return result as JoinPaths<TBasePath, P>;
   }
 
+  // Configure available authorizers
+  authorizers<const T extends readonly string[]>(
+    authorizers: T,
+  ): EndpointFactory<
+    TServices,
+    TBasePath,
+    TLogger,
+    TSession,
+    TEventPublisher,
+    TEventPublisherServiceName,
+    T
+  > {
+    const authorizerConfigs = authorizers.map((name) => ({
+      name,
+    }));
+    return new EndpointFactory<
+      TServices,
+      TBasePath,
+      TLogger,
+      TSession,
+      TEventPublisher,
+      TEventPublisherServiceName,
+      T
+    >({
+      defaultServices: this.defaultServices,
+      basePath: this.basePath,
+      defaultAuthorizeFn: this.defaultAuthorizeFn,
+      defaultLogger: this.defaultLogger,
+      defaultSessionExtractor: this.defaultSessionExtractor,
+      defaultEventPublisher: this.defaultEventPublisher,
+      availableAuthorizers: authorizerConfigs,
+      defaultAuthorizerName: this.defaultAuthorizerName,
+    });
+  }
+
   // Create a sub-router with a path prefix
   route<TPath extends string>(
     path: TPath,
@@ -103,7 +147,8 @@ export class EndpointFactory<
     TLogger,
     TSession,
     TEventPublisher,
-    TEventPublisherServiceName
+    TEventPublisherServiceName,
+    TAuthorizers
   > {
     const newBasePath = EndpointFactory.joinPaths(path, this.basePath);
     return new EndpointFactory<
@@ -112,7 +157,8 @@ export class EndpointFactory<
       TLogger,
       TSession,
       TEventPublisher,
-      TEventPublisherServiceName
+      TEventPublisherServiceName,
+      TAuthorizers
     >({
       defaultServices: this.defaultServices,
       basePath: newBasePath,
@@ -120,6 +166,8 @@ export class EndpointFactory<
       defaultLogger: this.defaultLogger,
       defaultSessionExtractor: this.defaultSessionExtractor,
       defaultEventPublisher: this.defaultEventPublisher,
+      availableAuthorizers: this.availableAuthorizers,
+      defaultAuthorizerName: this.defaultAuthorizerName,
     });
   }
 
@@ -132,7 +180,8 @@ export class EndpointFactory<
     TLogger,
     TSession,
     TEventPublisher,
-    TEventPublisherServiceName
+    TEventPublisherServiceName,
+    TAuthorizers
   > {
     return new EndpointFactory<
       TServices,
@@ -140,7 +189,8 @@ export class EndpointFactory<
       TLogger,
       TSession,
       TEventPublisher,
-      TEventPublisherServiceName
+      TEventPublisherServiceName,
+      TAuthorizers
     >({
       defaultServices: this.defaultServices,
       basePath: this.basePath,
@@ -148,6 +198,8 @@ export class EndpointFactory<
       defaultLogger: this.defaultLogger,
       defaultSessionExtractor: this.defaultSessionExtractor,
       defaultEventPublisher: this.defaultEventPublisher,
+      availableAuthorizers: this.availableAuthorizers,
+      defaultAuthorizerName: this.defaultAuthorizerName,
     });
   }
 
@@ -160,7 +212,8 @@ export class EndpointFactory<
     TLogger,
     TSession,
     TEventPublisher,
-    TEventPublisherServiceName
+    TEventPublisherServiceName,
+    TAuthorizers
   > {
     return new EndpointFactory<
       [...S, ...TServices],
@@ -168,7 +221,8 @@ export class EndpointFactory<
       TLogger,
       TSession,
       TEventPublisher,
-      TEventPublisherServiceName
+      TEventPublisherServiceName,
+      TAuthorizers
     >({
       defaultServices: [...services, ...this.defaultServices],
       basePath: this.basePath,
@@ -176,6 +230,8 @@ export class EndpointFactory<
       defaultLogger: this.defaultLogger,
       defaultSessionExtractor: this.defaultSessionExtractor,
       defaultEventPublisher: this.defaultEventPublisher,
+      availableAuthorizers: this.availableAuthorizers,
+      defaultAuthorizerName: this.defaultAuthorizerName,
     });
   }
 
@@ -187,7 +243,8 @@ export class EndpointFactory<
     L,
     TSession,
     TEventPublisher,
-    TEventPublisherServiceName
+    TEventPublisherServiceName,
+    TAuthorizers
   > {
     return new EndpointFactory<
       TServices,
@@ -195,7 +252,8 @@ export class EndpointFactory<
       L,
       TSession,
       TEventPublisher,
-      TEventPublisherServiceName
+      TEventPublisherServiceName,
+      TAuthorizers
     >({
       defaultServices: this.defaultServices,
       basePath: this.basePath,
@@ -208,6 +266,8 @@ export class EndpointFactory<
       defaultSessionExtractor: this
         .defaultSessionExtractor as unknown as SessionFn<TServices, L, TSession>,
       defaultEventPublisher: this.defaultEventPublisher,
+      availableAuthorizers: this.availableAuthorizers,
+      defaultAuthorizerName: this.defaultAuthorizerName,
     });
   }
 
@@ -216,14 +276,23 @@ export class EndpointFactory<
     TServiceName extends string = string,
   >(
     publisher: Service<TServiceName, T>,
-  ): EndpointFactory<TServices, TBasePath, TLogger, TSession, T, TServiceName> {
+  ): EndpointFactory<
+    TServices,
+    TBasePath,
+    TLogger,
+    TSession,
+    T,
+    TServiceName,
+    TAuthorizers
+  > {
     return new EndpointFactory<
       TServices,
       TBasePath,
       TLogger,
       TSession,
       T,
-      TServiceName
+      TServiceName,
+      TAuthorizers
     >({
       defaultServices: this.defaultServices,
       basePath: this.basePath,
@@ -231,6 +300,8 @@ export class EndpointFactory<
       defaultLogger: this.defaultLogger,
       defaultSessionExtractor: this.defaultSessionExtractor,
       defaultEventPublisher: publisher,
+      availableAuthorizers: this.availableAuthorizers,
+      defaultAuthorizerName: this.defaultAuthorizerName,
     });
   }
 
@@ -242,7 +313,8 @@ export class EndpointFactory<
     TLogger,
     T,
     TEventPublisher,
-    TEventPublisherServiceName
+    TEventPublisherServiceName,
+    TAuthorizers
   > {
     return new EndpointFactory<
       TServices,
@@ -250,7 +322,8 @@ export class EndpointFactory<
       TLogger,
       T,
       TEventPublisher,
-      TEventPublisherServiceName
+      TEventPublisherServiceName,
+      TAuthorizers
     >({
       defaultServices: this.defaultServices,
       basePath: this.basePath,
@@ -262,6 +335,8 @@ export class EndpointFactory<
       defaultLogger: this.defaultLogger,
       defaultSessionExtractor: session,
       defaultEventPublisher: this.defaultEventPublisher,
+      availableAuthorizers: this.availableAuthorizers,
+      defaultAuthorizerName: this.defaultAuthorizerName,
     });
   }
 
@@ -276,7 +351,9 @@ export class EndpointFactory<
     TLogger,
     undefined,
     TSession,
-    TEventPublisher
+    TEventPublisher,
+    TEventPublisherServiceName,
+    TAuthorizers
   > {
     const fullPath = EndpointFactory.joinPaths(path, this.basePath);
     const builder = new EndpointBuilder<
@@ -287,7 +364,9 @@ export class EndpointFactory<
       TLogger,
       undefined,
       TSession,
-      TEventPublisher
+      TEventPublisher,
+      TEventPublisherServiceName,
+      TAuthorizers
     >(fullPath, method);
 
     if (this.defaultAuthorizeFn) {
@@ -295,7 +374,8 @@ export class EndpointFactory<
       builder._authorize = this.defaultAuthorizeFn;
     }
     if (this.defaultServices.length) {
-      builder._services = this.defaultServices as TServices;
+      // Create a copy to avoid sharing references between builders
+      builder._services = [...this.defaultServices] as TServices;
     }
 
     if (this.defaultLogger) {
@@ -314,17 +394,13 @@ export class EndpointFactory<
       builder._setPublisher(this.defaultEventPublisher);
     }
 
-    return builder as unknown as EndpointBuilder<
-      JoinPaths<TBasePath, TPath>,
-      TMethod,
-      {},
-      TServices,
-      TLogger,
-      undefined,
-      TSession,
-      TEventPublisher,
-      TEventPublisherServiceName
-    >;
+    // Set available authorizers and default
+    builder._availableAuthorizers = this.availableAuthorizers;
+    if (this.defaultAuthorizerName) {
+      builder._authorizerName = this.defaultAuthorizerName;
+    }
+
+    return builder;
   }
 
   post<TPath extends string>(path: TPath) {
@@ -386,6 +462,7 @@ export interface EndpointFactoryOptions<
   TSession = unknown,
   TEventPublisher extends EventPublisher<any> | undefined = undefined,
   TEventPublisherServiceName extends string = string,
+  TAuthorizers extends readonly string[] = readonly string[],
 > {
   defaultServices?: TServices;
   basePath?: TBasePath;
@@ -394,6 +471,8 @@ export interface EndpointFactoryOptions<
   defaultSessionExtractor?: SessionFn<TServices, TLogger, TSession>;
   defaultEventPublisher?: Service<TEventPublisherServiceName, TEventPublisher>;
   defaultEvents?: MappedEvent<TEventPublisher, undefined>[];
+  availableAuthorizers?: Authorizer[];
+  defaultAuthorizerName?: TAuthorizers[number];
 }
 
 export const e = new EndpointFactory();

package/src/endpoints/HonoEndpointAdaptor.ts

@@ -5,6 +5,8 @@ import { checkRateLimit, getRateLimitHeaders } from '@geekmidas/rate-limit';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import { type Context, Hono } from 'hono';
 import { setCookie } from 'hono/cookie';
+import { logger as honoLogger } from 'hono/logger';
+import { timing } from 'hono/timing';
 import { validator } from 'hono/validator';
 import type { HttpMethod, LowerHttpMethod } from '../types';
 import {
@@ -65,6 +67,8 @@ export class HonoEndpoint<
     >,
   ) {}
 
+  static isDev = process.env.NODE_ENV === 'development';
+
   static async validate<T extends StandardSchemaV1>(
     c: Context<any, string, {}>,
     data: unknown,
@@ -150,6 +154,15 @@ export class HonoEndpoint<
     app: Hono,
     options?: HonoEndpointOptions,
   ): void {
+    // Add timing middleware (always enabled)
+    app.use('*', timing());
+
+    // Add logger middleware in development mode
+
+    if (HonoEndpoint.isDev) {
+      app.use('*', honoLogger());
+    }
+
     // Add docs route if not disabled
     const docsPath =
       options?.docsPath !== false ? options?.docsPath || '/docs' : null;
@@ -353,6 +366,10 @@ export class HonoEndpoint<
             // @ts-ignore
             c.set('__logger', logger);
 
+            if (HonoEndpoint.isDev) {
+              logger.info({ status, body: output }, 'Outgoing response');
+            }
+
             return c.json(output, status);
           } catch (validationError: any) {
             logger.error(validationError, 'Output validation failed');
@@ -361,11 +378,23 @@ export class HonoEndpoint<
               422,
               'Response validation failed',
             );
+            if (HonoEndpoint.isDev) {
+              logger.info(
+                { status: error.statusCode, body: error },
+                'Outgoing response',
+              );
+            }
             return c.json(error, error.statusCode as ContentfulStatusCode);
           }
         } catch (e: any) {
           logger.error(e, 'Error processing endpoint request');
           const error = wrapError(e, 500, 'Internal Server Error');
+          if (HonoEndpoint.isDev) {
+            logger.info(
+              { status: error.statusCode, body: error },
+              'Outgoing response',
+            );
+          }
           return c.json(error, error.statusCode as ContentfulStatusCode);
         }
       },

package/src/endpoints/__tests__/Endpoint.cookies.spec.ts

@@ -117,4 +117,89 @@ describe('Endpoint.createCookies', () => {
     expect(cookieFn('_ga')).toBe('GA1.2.123456789.1234567890');
     expect(cookieFn('authenticated')).toBe('true');
   });
+
+  describe('cookie() - get all cookies', () => {
+    it('should return all cookies as object when called without arguments', () => {
+      const cookieFn = Endpoint.createCookies(
+        'session=abc123; theme=dark; lang=en',
+      );
+
+      const allCookies = cookieFn();
+
+      expect(allCookies).toEqual({
+        session: 'abc123',
+        theme: 'dark',
+        lang: 'en',
+      });
+    });
+
+    it('should return empty object when no cookies exist', () => {
+      const cookieFn = Endpoint.createCookies(undefined);
+
+      const allCookies = cookieFn();
+
+      expect(allCookies).toEqual({});
+    });
+
+    it('should return empty object for empty cookie string', () => {
+      const cookieFn = Endpoint.createCookies('');
+
+      const allCookies = cookieFn();
+
+      expect(allCookies).toEqual({});
+    });
+
+    it('should decode URL-encoded values in all cookies', () => {
+      const cookieFn = Endpoint.createCookies(
+        'user=John%20Doe; email=john%40example.com',
+      );
+
+      const allCookies = cookieFn();
+
+      expect(allCookies).toEqual({
+        user: 'John Doe',
+        email: 'john@example.com',
+      });
+    });
+
+    it('should preserve case in cookie names when getting all', () => {
+      const cookieFn = Endpoint.createCookies('Session=abc; session=xyz; TOKEN=123');
+
+      const allCookies = cookieFn();
+
+      expect(allCookies).toEqual({
+        Session: 'abc',
+        session: 'xyz',
+        TOKEN: '123',
+      });
+    });
+
+    it('should handle cookies with equals sign in values', () => {
+      const cookieFn = Endpoint.createCookies(
+        'data=key=value; token=abc=123=xyz',
+      );
+
+      const allCookies = cookieFn();
+
+      expect(allCookies).toEqual({
+        data: 'key=value',
+        token: 'abc=123=xyz',
+      });
+    });
+
+    it('should work with complex real-world cookie string', () => {
+      const cookieFn = Endpoint.createCookies(
+        'session=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9; user_id=12345; preferences=%7B%22theme%22%3A%22dark%22%7D; authenticated=true',
+      );
+
+      const allCookies = cookieFn();
+
+      expect(allCookies).toEqual({
+        session: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9',
+        user_id: '12345',
+        preferences: '{"theme":"dark"}',
+        authenticated: 'true',
+      });
+    });
+  });
 });

package/src/endpoints/__tests__/Endpoint.headers.spec.ts

@@ -0,0 +1,187 @@
+import { describe, expect, it } from 'vitest';
+import { Endpoint } from '../Endpoint';
+
+describe('Endpoint.createHeaders', () => {
+  it('should get single header value', () => {
+    const headerFn = Endpoint.createHeaders({
+      'Content-Type': 'application/json',
+      Host: 'example.com',
+    });
+
+    expect(headerFn('content-type')).toBe('application/json');
+    expect(headerFn('host')).toBe('example.com');
+  });
+
+  it('should be case-insensitive for header names', () => {
+    const headerFn = Endpoint.createHeaders({
+      'Content-Type': 'application/json',
+    });
+
+    expect(headerFn('content-type')).toBe('application/json');
+    expect(headerFn('Content-Type')).toBe('application/json');
+    expect(headerFn('CONTENT-TYPE')).toBe('application/json');
+    expect(headerFn('CoNtEnT-tYpE')).toBe('application/json');
+  });
+
+  it('should return undefined for non-existent header', () => {
+    const headerFn = Endpoint.createHeaders({
+      'Content-Type': 'application/json',
+    });
+
+    expect(headerFn('Authorization')).toBeUndefined();
+  });
+
+  it('should handle empty headers object', () => {
+    const headerFn = Endpoint.createHeaders({});
+
+    expect(headerFn('Content-Type')).toBeUndefined();
+  });
+
+  it('should handle headers with special characters', () => {
+    const headerFn = Endpoint.createHeaders({
+      'X-Custom-Header': 'value-with-dashes',
+      'X-Request-ID': '12345-67890-abcdef',
+    });
+
+    expect(headerFn('x-custom-header')).toBe('value-with-dashes');
+    expect(headerFn('X-REQUEST-ID')).toBe('12345-67890-abcdef');
+  });
+
+  it('should handle standard HTTP headers', () => {
+    const headerFn = Endpoint.createHeaders({
+      'Content-Type': 'application/json',
+      'Content-Length': '1234',
+      Authorization: 'Bearer token123',
+      'User-Agent': 'Mozilla/5.0',
+      Accept: 'application/json',
+      'Accept-Language': 'en-US,en;q=0.9',
+      'Cache-Control': 'no-cache',
+    });
+
+    expect(headerFn('content-type')).toBe('application/json');
+    expect(headerFn('content-length')).toBe('1234');
+    expect(headerFn('authorization')).toBe('Bearer token123');
+    expect(headerFn('user-agent')).toBe('Mozilla/5.0');
+    expect(headerFn('accept')).toBe('application/json');
+    expect(headerFn('accept-language')).toBe('en-US,en;q=0.9');
+    expect(headerFn('cache-control')).toBe('no-cache');
+  });
+
+  it('should handle forwarded headers', () => {
+    const headerFn = Endpoint.createHeaders({
+      'X-Forwarded-For': '203.0.113.1',
+      'X-Forwarded-Proto': 'https',
+      'X-Real-IP': '203.0.113.1',
+    });
+
+    expect(headerFn('x-forwarded-for')).toBe('203.0.113.1');
+    expect(headerFn('x-forwarded-proto')).toBe('https');
+    expect(headerFn('x-real-ip')).toBe('203.0.113.1');
+  });
+
+  describe('header() - get all headers', () => {
+    it('should return all headers as object when called without arguments', () => {
+      const headerFn = Endpoint.createHeaders({
+        'Content-Type': 'application/json',
+        Host: 'example.com',
+        Authorization: 'Bearer token123',
+      });
+
+      const allHeaders = headerFn();
+
+      expect(allHeaders).toEqual({
+        'content-type': 'application/json',
+        host: 'example.com',
+        authorization: 'Bearer token123',
+      });
+    });
+
+    it('should return empty object when no headers exist', () => {
+      const headerFn = Endpoint.createHeaders({});
+
+      const allHeaders = headerFn();
+
+      expect(allHeaders).toEqual({});
+    });
+
+    it('should normalize all header names to lowercase', () => {
+      const headerFn = Endpoint.createHeaders({
+        'Content-Type': 'application/json',
+        HOST: 'example.com',
+        'X-Custom-Header': 'value',
+      });
+
+      const allHeaders = headerFn();
+
+      expect(allHeaders).toEqual({
+        'content-type': 'application/json',
+        host: 'example.com',
+        'x-custom-header': 'value',
+      });
+    });
+
+    it('should work with standard HTTP headers', () => {
+      const headerFn = Endpoint.createHeaders({
+        'Content-Type': 'application/json',
+        'Content-Length': '1234',
+        Authorization: 'Bearer token123',
+        'User-Agent': 'Mozilla/5.0',
+        Accept: 'application/json',
+      });
+
+      const allHeaders = headerFn();
+
+      expect(allHeaders).toEqual({
+        'content-type': 'application/json',
+        'content-length': '1234',
+        authorization: 'Bearer token123',
+        'user-agent': 'Mozilla/5.0',
+        accept: 'application/json',
+      });
+    });
+
+    it('should work with custom and forwarded headers', () => {
+      const headerFn = Endpoint.createHeaders({
+        'X-Forwarded-For': '203.0.113.1',
+        'X-Forwarded-Proto': 'https',
+        'X-Request-ID': 'req-123',
+        'X-Custom-Header': 'custom-value',
+      });
+
+      const allHeaders = headerFn();
+
+      expect(allHeaders).toEqual({
+        'x-forwarded-for': '203.0.113.1',
+        'x-forwarded-proto': 'https',
+        'x-request-id': 'req-123',
+        'x-custom-header': 'custom-value',
+      });
+    });
+
+    it('should handle complex real-world headers', () => {
+      const headerFn = Endpoint.createHeaders({
+        'Content-Type': 'application/json; charset=utf-8',
+        Host: 'api.example.com',
+        Connection: 'keep-alive',
+        'User-Agent':
+          'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        Accept: '*/*',
+        'Accept-Encoding': 'gzip, deflate, br',
+        'Accept-Language': 'en-US,en;q=0.9',
+        Authorization: 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9',
+        'Cache-Control': 'no-cache',
+        Origin: 'https://example.com',
+        Referer: 'https://example.com/dashboard',
+        'X-Requested-With': 'XMLHttpRequest',
+      });
+
+      const allHeaders = headerFn();
+
+      expect(allHeaders).toHaveProperty('content-type');
+      expect(allHeaders).toHaveProperty('host');
+      expect(allHeaders).toHaveProperty('authorization');
+      expect(allHeaders).toHaveProperty('user-agent');
+      expect(Object.keys(allHeaders).length).toBe(12);
+    });
+  });
+});