@geekmidas/constructs 0.0.7 → 0.0.9

package/dist/subscribers/index.d.mts

@@ -1,10 +1,10 @@
-import "../Construct-DdyYENBD.mjs";
-import { Subscriber } from "../Subscriber-BxH6n8zQ.mjs";
-import { SubscriberBuilder } from "../SubscriberBuilder-BpSDPzBz.mjs";
-import * as _geekmidas_logger5 from "@geekmidas/logger";
+import "../Construct-zhmcmIdY.mjs";
+import { Subscriber } from "../Subscriber-g3IWM1_d.mjs";
+import { SubscriberBuilder } from "../SubscriberBuilder-YjQ7qIpQ.mjs";
+import * as _geekmidas_logger4 from "@geekmidas/logger";
 
 //#region src/subscribers/index.d.ts
-declare const s: SubscriberBuilder<[], _geekmidas_logger5.Logger, undefined, undefined, string, []>;
+declare const s: SubscriberBuilder<[], _geekmidas_logger4.Logger, undefined, undefined, string, []>;
 //#endregion
 export { Subscriber, SubscriberBuilder, s };
 //# sourceMappingURL=index.d.mts.map

package/dist/subscribers/index.mjs

@@ -1,6 +1,6 @@
-import "../Construct-BbKCIPQm.mjs";
-import { Subscriber } from "../Subscriber-DkCDcTUL.mjs";
-import { SubscriberBuilder } from "../SubscriberBuilder-Bn9Hyi28.mjs";
+import "../Construct-B-O9OBS1.mjs";
+import { Subscriber } from "../Subscriber-bJSqvjdK.mjs";
+import { SubscriberBuilder } from "../SubscriberBuilder-CyCyjT6L.mjs";
 
 //#region src/subscribers/index.ts
 const s = new SubscriberBuilder();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/constructs",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "private": false,
   "type": "module",
   "exports": {
@@ -66,13 +66,13 @@
     "lodash.compact": "~3.0.1",
     "openapi-types": "~12.1.3",
     "fast-glob": "~3.3.3",
-    "@geekmidas/logger": "0.0.1",
-    "@geekmidas/events": "0.0.2",
     "@geekmidas/schema": "0.0.2",
     "@geekmidas/services": "0.0.1",
+    "@geekmidas/logger": "0.0.1",
+    "@geekmidas/events": "0.0.2",
+    "@geekmidas/rate-limit": "0.1.0",
     "@geekmidas/cache": "0.0.7",
-    "@geekmidas/errors": "0.0.1",
-    "@geekmidas/rate-limit": "0.1.0"
+    "@geekmidas/errors": "0.0.1"
   },
   "devDependencies": {
     "@types/lodash.pick": "~4.4.9",

package/src/Construct.ts

@@ -20,6 +20,8 @@ export abstract class Construct<
 
     public readonly publisherService?: Service<TServiceName, T>,
     public outputSchema?: OutSchema,
+    public readonly timeout?: number,
+    public readonly memorySize?: number,
   ) {}
 
   /**

package/src/crons/Cron.ts

@@ -42,6 +42,7 @@ export class Cron<
     logger?: TLogger,
     publisherService?: Service<TEventPublisherServiceName, TEventPublisher>,
     events: any[] = [],
+    memorySize?: number,
   ) {
     super(
       fn,
@@ -53,6 +54,7 @@ export class Cron<
       logger,
       publisherService,
       events,
+      memorySize,
     );
   }
 

package/src/crons/CronBuilder.ts

@@ -28,10 +28,16 @@ export class CronBuilder<
   TEventPublisherServiceName
 > {
   private _schedule?: ScheduleExpression;
+
   constructor() {
     super(ConstructType.Cron);
   }
 
+  memorySize(memorySize: number): this {
+    this._memorySize = memorySize;
+    return this;
+  }
+
   schedule(
     _expression: ScheduleExpression,
   ): CronBuilder<
@@ -175,6 +181,7 @@ export class CronBuilder<
       this._logger,
       this._publisher,
       this._events,
+      this._memorySize,
     );
 
     // Reset builder state after creating the cron to prevent pollution
@@ -186,6 +193,7 @@ export class CronBuilder<
     this.inputSchema = undefined;
     this.outputSchema = undefined;
     this._timeout = undefined;
+    this._memorySize = undefined;
 
     return cron;
   }

package/src/crons/__tests__/CronBuilder.state-isolation.spec.ts

@@ -0,0 +1,227 @@
+import { describe, expect, it } from 'vitest';
+import { ConsoleLogger } from '@geekmidas/logger/console';
+import { CronBuilder } from '../CronBuilder';
+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('CronBuilder - State Isolation', () => {
+  describe('singleton instance state reset', () => {
+    it('should reset services after handle() is called', () => {
+      const c = new CronBuilder();
+
+      // First cron with ServiceA and ServiceB
+      const cron1 = c
+        .schedule('rate(5 minutes)')
+        .services([ServiceA, ServiceB])
+        .handle(async () => ({}));
+
+      // Second cron should not have any services from first
+      const cron2 = c.schedule('rate(10 minutes)').handle(async () => ({}));
+
+      expect(cron1.services.map((s) => s.serviceName)).toEqual(['a', 'b']);
+      expect(cron2.services.map((s) => s.serviceName)).toEqual([]);
+    });
+
+    it('should reset logger after handle() is called', () => {
+      const c = new CronBuilder();
+      const customLogger = new ConsoleLogger({ app: 'custom' });
+
+      // First cron with custom logger
+      const cron1 = c
+        .schedule('rate(5 minutes)')
+        .logger(customLogger)
+        .handle(async () => ({}));
+
+      // Second cron should have default logger (not the custom one)
+      const cron2 = c.schedule('rate(10 minutes)').handle(async () => ({}));
+
+      expect(cron1.logger).toBe(customLogger);
+      expect(cron2.logger).not.toBe(customLogger);
+      expect(cron2.logger).toBeInstanceOf(ConsoleLogger);
+    });
+
+    it('should reset schedule after handle() is called', () => {
+      const c = new CronBuilder();
+
+      // First cron with schedule
+      const cron1 = c.schedule('rate(5 minutes)').handle(async () => ({}));
+
+      // Second cron should not have schedule from first
+      const cron2 = c.schedule('rate(10 minutes)').handle(async () => ({}));
+
+      expect(cron1.schedule).toBe('rate(5 minutes)');
+      expect(cron2.schedule).toBe('rate(10 minutes)');
+
+      // Check internal state is reset
+      expect((c as any)._schedule).toBeUndefined();
+    });
+
+    it('should reset events after handle() is called', () => {
+      const c = new CronBuilder();
+
+      // Create first cron (events array should be empty initially)
+      const cron1 = c.schedule('rate(5 minutes)').handle(async () => ({}));
+
+      // Verify state was reset
+      expect((c as any)._events).toEqual([]);
+      expect((c as any)._services).toEqual([]);
+      expect((c as any)._schedule).toBeUndefined();
+    });
+
+    it('should reset input/output schemas after handle() is called', () => {
+      const c = new CronBuilder();
+      const inputSchema: any = { '~standard': { validate: () => ({}) } };
+      const outputSchema: any = { '~standard': { validate: () => ({}) } };
+
+      // First cron with schemas
+      const cron1 = c
+        .schedule('rate(5 minutes)')
+        .input(inputSchema)
+        .output(outputSchema)
+        .handle(async () => ({}));
+
+      // Second cron should not have schemas
+      const cron2 = c.schedule('rate(10 minutes)').handle(async () => ({}));
+
+      expect(cron1.input).toBe(inputSchema);
+      expect(cron1.outputSchema).toBe(outputSchema);
+      expect(cron2.input).toBeUndefined();
+      expect(cron2.outputSchema).toBeUndefined();
+    });
+
+    it('should reset timeout after handle() is called', () => {
+      const c = new CronBuilder();
+
+      // First cron with custom timeout
+      const cron1 = c
+        .schedule('rate(5 minutes)')
+        .timeout(5000)
+        .handle(async () => ({}));
+
+      // Second cron should have default timeout (30000)
+      const cron2 = c.schedule('rate(10 minutes)').handle(async () => ({}));
+
+      expect(cron1.timeout).toBe(5000);
+      expect(cron2.timeout).toBe(30000); // Default timeout
+    });
+  });
+
+  describe('method chaining before handle()', () => {
+    it('should accumulate services when chaining', () => {
+      const c = new CronBuilder();
+
+      const cron = c
+        .schedule('rate(5 minutes)')
+        .services([ServiceA])
+        .services([ServiceB])
+        .handle(async () => ({}));
+
+      expect(cron.services.map((s) => s.serviceName)).toEqual(['a', 'b']);
+    });
+
+    it('should not share references between different builder chains', () => {
+      const c = new CronBuilder();
+
+      // Start two separate chains
+      const builder1 = c.schedule('rate(5 minutes)').services([ServiceA]);
+      const builder2 = c.schedule('rate(10 minutes)').services([ServiceB]);
+
+      // They should be the same instance (singleton)
+      expect(builder1).toBe(builder2);
+      expect(builder1).toBe(c);
+
+      // But after handle, state is reset
+      const cron1 = builder1.handle(async () => ({}));
+
+      // Now builder2 should have reset state
+      expect((builder2 as any)._services).toEqual([]);
+
+      // Add services again
+      const cron2 = builder2
+        .schedule('rate(15 minutes)')
+        .services([ServiceB])
+        .handle(async () => ({}));
+
+      expect(cron1.services.map((s) => s.serviceName)).toEqual(['a', 'b']);
+      expect(cron2.services.map((s) => s.serviceName)).toEqual(['b']);
+    });
+  });
+
+  describe('sequential cron creation', () => {
+    it('should create independent crons sequentially', () => {
+      const c = new CronBuilder();
+
+      const cron1 = c
+        .schedule('rate(5 minutes)')
+        .services([ServiceA, ServiceB])
+        .handle(async () => ({ result: 1 }));
+
+      const cron2 = c
+        .schedule('rate(10 minutes)')
+        .services([ServiceA])
+        .handle(async () => ({ result: 2 }));
+
+      const cron3 = c
+        .schedule('rate(15 minutes)')
+        .handle(async () => ({ result: 3 }));
+
+      expect(cron1.services.map((s) => s.serviceName)).toEqual(['a', 'b']);
+      expect(cron1.schedule).toBe('rate(5 minutes)');
+
+      expect(cron2.services.map((s) => s.serviceName)).toEqual(['a']);
+      expect(cron2.schedule).toBe('rate(10 minutes)');
+
+      expect(cron3.services.map((s) => s.serviceName)).toEqual([]);
+      expect(cron3.schedule).toBe('rate(15 minutes)');
+    });
+  });
+
+  describe('publisher isolation', () => {
+    it('should reset publisher after handle() is called', () => {
+      const c = new CronBuilder();
+      const mockPublisher: any = {
+        serviceName: 'publisher',
+        async register() {
+          return { publish: () => {} };
+        },
+      };
+
+      const cron1 = c
+        .schedule('rate(5 minutes)')
+        .publisher(mockPublisher)
+        .handle(async () => ({}));
+
+      const cron2 = c.schedule('rate(10 minutes)').handle(async () => ({}));
+
+      expect((cron1 as any).publisherService).toBe(mockPublisher);
+      expect((cron2 as any).publisherService).toBeUndefined();
+    });
+  });
+
+  describe('cron expression types', () => {
+    it('should handle different schedule expression formats', () => {
+      const c = new CronBuilder();
+
+      const cron1 = c.schedule('rate(5 minutes)').handle(async () => ({}));
+      const cron2 = c.schedule('cron(0 12 * * ? *)').handle(async () => ({}));
+      const cron3 = c.schedule('rate(1 hour)').handle(async () => ({}));
+
+      expect(cron1.schedule).toBe('rate(5 minutes)');
+      expect(cron2.schedule).toBe('cron(0 12 * * ? *)');
+      expect(cron3.schedule).toBe('rate(1 hour)');
+    });
+  });
+});

package/src/endpoints/Authorizer.ts

@@ -0,0 +1,34 @@
+/**
+ * Represents an authorizer configuration for endpoints
+ */
+export interface Authorizer {
+  /**
+   * Unique identifier for the authorizer
+   */
+  name: string;
+  /**
+   * Type of authorizer (e.g., 'iam', 'jwt', 'custom')
+   */
+  type?: string;
+  /**
+   * Description of what this authorizer does
+   */
+  description?: string;
+  /**
+   * Additional metadata specific to the authorizer type
+   */
+  metadata?: Record<string, any>;
+}
+
+/**
+ * Helper to create an authorizer configuration
+ */
+export function createAuthorizer(
+  name: string,
+  options?: Omit<Authorizer, 'name'>,
+): Authorizer {
+  return {
+    name,
+    ...options,
+  };
+}

package/src/endpoints/Endpoint.ts

@@ -5,6 +5,7 @@ import set from 'lodash.set';
 import type { OpenAPIV3_1 } from 'openapi-types';
 
 import type { Service, ServiceRecord } from '@geekmidas/services';
+import type { Authorizer } from './Authorizer';
 import { ConstructType } from '../Construct';
 import { Function, type FunctionHandler } from '../functions';
 
@@ -93,6 +94,8 @@ export class Endpoint<
   public authorize: AuthorizeFn<TServices, TLogger, TSession> = () => true;
   /** Optional rate limiting configuration */
   public rateLimit?: RateLimitConfig;
+  /** Optional authorizer for this endpoint */
+  public authorizer?: Authorizer;
   /** The endpoint handler function */
   private endpointFn!: EndpointHandler<
     TInput,
@@ -174,12 +177,13 @@ export class Endpoint<
    * Creates a case-insensitive header lookup function from a headers object.
    *
    * @param headers - Object containing header key-value pairs
-   * @returns Function to retrieve header values by case-insensitive key
+   * @returns Function to retrieve header values by case-insensitive key, or all headers
    *
    * @example
    * ```typescript
    * const headerFn = Endpoint.createHeaders({ 'Content-Type': 'application/json' });
    * headerFn('content-type'); // Returns 'application/json'
+   * headerFn(); // Returns { 'content-type': 'application/json' }
    * ```
    */
   static createHeaders(headers: Record<string, string>): HeaderFn {
@@ -189,22 +193,30 @@ export class Endpoint<
       headerMap.set(key, v);
     }
 
-    return function get(key: string): string | undefined {
+    function get(): Record<string, string>;
+    function get(key: string): string | undefined;
+    function get(key?: string): string | undefined | Record<string, string> {
+      if (key === undefined) {
+        // Return all headers as plain object
+        return Object.fromEntries(headerMap.entries());
+      }
       return headerMap.get(key.toLowerCase());
-    };
+    }
+
+    return get;
   }
 
   /**
    * Parses cookie string and creates a cookie lookup function.
    *
    * @param cookieHeader - The Cookie header value
-   * @returns Function to retrieve cookie values by name
+   * @returns Function to retrieve cookie values by name, or all cookies
    *
    * @example
    * ```typescript
    * const cookieFn = Endpoint.createCookies('session=abc123; theme=dark');
    * cookieFn('session'); // Returns 'abc123'
-   * cookieFn('theme'); // Returns 'dark'
+   * cookieFn(); // Returns { session: 'abc123', theme: 'dark' }
    * ```
    */
   static createCookies(cookieHeader: string | undefined): CookieFn {
@@ -222,9 +234,17 @@ export class Endpoint<
       }
     }
 
-    return function get(name: string): string | undefined {
+    function get(): Record<string, string>;
+    function get(name: string): string | undefined;
+    function get(name?: string): string | undefined | Record<string, string> {
+      if (name === undefined) {
+        // Return all cookies as plain object
+        return Object.fromEntries(cookieMap.entries());
+      }
       return cookieMap.get(name);
-    };
+    }
+
+    return get;
   }
 
   /**
@@ -499,6 +519,7 @@ export class Endpoint<
    * @param options.getSession - Session extraction function
    * @param options.authorize - Authorization check function
    * @param options.status - Success HTTP status code (default: 200)
+   * @param options.authorizer - Optional authorizer configuration
    */
   constructor({
     fn,
@@ -511,12 +532,14 @@ export class Endpoint<
     output: outputSchema,
     services,
     timeout,
+    memorySize,
     getSession,
     authorize,
     rateLimit,
     status = SuccessStatus.OK,
     publisherService,
     events,
+    authorizer,
   }: EndpointOptions<
     TRoute,
     TMethod,
@@ -539,6 +562,7 @@ export class Endpoint<
       logger,
       publisherService,
       events,
+      memorySize,
     );
 
     this.route = route;
@@ -559,6 +583,10 @@ export class Endpoint<
     if (rateLimit) {
       this.rateLimit = rateLimit;
     }
+
+    if (authorizer) {
+      this.authorizer = authorizer;
+    }
   }
 }
 
@@ -625,6 +653,8 @@ export interface EndpointOptions<
   tags?: string[];
   /** Optional execution timeout in milliseconds */
   timeout: number | undefined;
+  /** Optional memory size in MB for serverless deployments */
+  memorySize: number | undefined;
   /** Input validation schemas */
   input: TInput | undefined;
   /** Output validation schema */
@@ -645,6 +675,8 @@ export interface EndpointOptions<
   publisherService?: Service<TEventPublisherServiceName, TEventPublisher>;
 
   events?: MappedEvent<TEventPublisher, OutSchema>[];
+  /** Optional authorizer configuration */
+  authorizer?: Authorizer;
 }
 
 /**
@@ -780,24 +812,45 @@ export type EndpointHeaders = Map<string, string>;
 
 /**
  * Function type for retrieving HTTP header values.
+ * Supports two calling patterns:
+ * - `header(key)` - Get a single header value (case-insensitive)
+ * - `header()` - Get all headers as a plain object
  *
- * @param key - The header name (case-insensitive)
- * @returns The header value or undefined if not found
+ * @example
+ * ```typescript
+ * // Get single header
+ * const contentType = header('content-type');
+ *
+ * // Get all headers
+ * const allHeaders = header();
+ * // { 'content-type': 'application/json', 'host': 'example.com', ... }
+ * ```
  */
-export type HeaderFn = SingleHeaderFn;
+export interface HeaderFn {
+  (): Record<string, string>;
+  (key: string): string | undefined;
+}
 
 /**
  * Function type for retrieving cookie values.
- *
- * @param name - The cookie name
- * @returns The cookie value or undefined if not found
+ * Supports two calling patterns:
+ * - `cookie(name)` - Get a single cookie value
+ * - `cookie()` - Get all cookies as a plain object
  *
  * @example
  * ```typescript
+ * // Get single cookie
  * const sessionId = cookie('session');
+ *
+ * // Get all cookies
+ * const allCookies = cookie();
+ * // { session: 'abc123', theme: 'dark', ... }
  * ```
  */
-export type CookieFn = (name: string) => string | undefined;
+export interface CookieFn {
+  (): Record<string, string>;
+  (name: string): string | undefined;
+}
 
 /**
  * Cookie options matching standard Set-Cookie attributes