@geekmidas/constructs 0.0.7 → 0.0.10

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { Construct, ConstructType } from "./Construct-BbKCIPQm.mjs";
+import { Construct, ConstructType } from "./Construct-C3hsQBy4.mjs";
 
 export { Construct, ConstructType };

package/dist/publisher.d.cts

@@ -1,4 +1,4 @@
-import { Construct } from "./Construct-Bm-PSO2V.cjs";
+import { Construct } from "./Construct-ci5u8Xnu.cjs";
 import { EventPublisher, MappedEvent } from "@geekmidas/events";
 import { Logger } from "@geekmidas/logger";
 import { Service, ServiceDiscovery } from "@geekmidas/services";

package/dist/publisher.d.mts

@@ -1,4 +1,4 @@
-import { Construct } from "./Construct-DdyYENBD.mjs";
+import { Construct } from "./Construct-zhmcmIdY.mjs";
 import { Service, ServiceDiscovery } from "@geekmidas/services";
 import { EventPublisher, MappedEvent } from "@geekmidas/events";
 import { Logger } from "@geekmidas/logger";

package/dist/subscribers/AWSLambdaSubscriberAdaptor.d.cts

@@ -1,4 +1,4 @@
-import "../Construct-Bm-PSO2V.cjs";
-import "../Subscriber-BoFm12i_.cjs";
-import { AWSLambdaHandler, AWSLambdaSubscriber } from "../AWSLambdaSubscriberAdaptor-QKVxR6qh.cjs";
+import "../Construct-ci5u8Xnu.cjs";
+import "../Subscriber-Cy28j8MS.cjs";
+import { AWSLambdaHandler, AWSLambdaSubscriber } from "../AWSLambdaSubscriberAdaptor-J_pSz6pu.cjs";
 export { AWSLambdaHandler, AWSLambdaSubscriber };

package/dist/subscribers/AWSLambdaSubscriberAdaptor.d.mts

@@ -1,4 +1,4 @@
-import "../Construct-DdyYENBD.mjs";
-import "../Subscriber-BxH6n8zQ.mjs";
-import { AWSLambdaHandler, AWSLambdaSubscriber } from "../AWSLambdaSubscriberAdaptor-C6JYIZxn.mjs";
+import "../Construct-zhmcmIdY.mjs";
+import "../Subscriber-g3IWM1_d.mjs";
+import { AWSLambdaHandler, AWSLambdaSubscriber } from "../AWSLambdaSubscriberAdaptor-D6kjKjSf.mjs";
 export { AWSLambdaHandler, AWSLambdaSubscriber };

package/dist/subscribers/Subscriber.cjs

@@ -1,4 +1,4 @@
-require('../Construct-BSEs6uwW.cjs');
-const require_Subscriber = require('../Subscriber-CSt7EOlT.cjs');
+require('../Construct-VEI7M3fs.cjs');
+const require_Subscriber = require('../Subscriber-BL30GpWp.cjs');
 
 exports.Subscriber = require_Subscriber.Subscriber;

package/dist/subscribers/Subscriber.d.cts

@@ -1,3 +1,3 @@
-import "../Construct-Bm-PSO2V.cjs";
-import { Subscriber, SubscriberContext, SubscriberHandler } from "../Subscriber-BoFm12i_.cjs";
+import "../Construct-ci5u8Xnu.cjs";
+import { Subscriber, SubscriberContext, SubscriberHandler } from "../Subscriber-Cy28j8MS.cjs";
 export { Subscriber, SubscriberContext, SubscriberHandler };

package/dist/subscribers/Subscriber.d.mts

@@ -1,3 +1,3 @@
-import "../Construct-DdyYENBD.mjs";
-import { Subscriber, SubscriberContext, SubscriberHandler } from "../Subscriber-BxH6n8zQ.mjs";
+import "../Construct-zhmcmIdY.mjs";
+import { Subscriber, SubscriberContext, SubscriberHandler } from "../Subscriber-g3IWM1_d.mjs";
 export { Subscriber, SubscriberContext, SubscriberHandler };

package/dist/subscribers/Subscriber.mjs

@@ -1,4 +1,4 @@
-import "../Construct-BbKCIPQm.mjs";
-import { Subscriber } from "../Subscriber-DkCDcTUL.mjs";
+import "../Construct-C3hsQBy4.mjs";
+import { Subscriber } from "../Subscriber-CTczVFsF.mjs";
 
 export { Subscriber };

package/dist/subscribers/SubscriberBuilder.cjs

@@ -1,5 +1,5 @@
-require('../Construct-BSEs6uwW.cjs');
-require('../Subscriber-CSt7EOlT.cjs');
-const require_SubscriberBuilder = require('../SubscriberBuilder-RsiOmnwq.cjs');
+require('../Construct-VEI7M3fs.cjs');
+require('../Subscriber-BL30GpWp.cjs');
+const require_SubscriberBuilder = require('../SubscriberBuilder-D1hojYLa.cjs');
 
 exports.SubscriberBuilder = require_SubscriberBuilder.SubscriberBuilder;

package/dist/subscribers/SubscriberBuilder.d.cts

@@ -1,4 +1,4 @@
-import "../Construct-Bm-PSO2V.cjs";
-import "../Subscriber-BoFm12i_.cjs";
-import { SubscriberBuilder } from "../SubscriberBuilder-DgljKtYu.cjs";
+import "../Construct-ci5u8Xnu.cjs";
+import "../Subscriber-Cy28j8MS.cjs";
+import { SubscriberBuilder } from "../SubscriberBuilder-BzK8kc2a.cjs";
 export { SubscriberBuilder };

package/dist/subscribers/SubscriberBuilder.d.mts

@@ -1,4 +1,4 @@
-import "../Construct-DdyYENBD.mjs";
-import "../Subscriber-BxH6n8zQ.mjs";
-import { SubscriberBuilder } from "../SubscriberBuilder-BpSDPzBz.mjs";
+import "../Construct-zhmcmIdY.mjs";
+import "../Subscriber-g3IWM1_d.mjs";
+import { SubscriberBuilder } from "../SubscriberBuilder-YjQ7qIpQ.mjs";
 export { SubscriberBuilder };

package/dist/subscribers/SubscriberBuilder.mjs

@@ -1,5 +1,5 @@
-import "../Construct-BbKCIPQm.mjs";
-import "../Subscriber-DkCDcTUL.mjs";
-import { SubscriberBuilder } from "../SubscriberBuilder-Bn9Hyi28.mjs";
+import "../Construct-C3hsQBy4.mjs";
+import "../Subscriber-CTczVFsF.mjs";
+import { SubscriberBuilder } from "../SubscriberBuilder-CekL3BoP.mjs";
 
 export { SubscriberBuilder };

package/dist/subscribers/index.cjs

@@ -1,6 +1,6 @@
-require('../Construct-BSEs6uwW.cjs');
-const require_Subscriber = require('../Subscriber-CSt7EOlT.cjs');
-const require_SubscriberBuilder = require('../SubscriberBuilder-RsiOmnwq.cjs');
+require('../Construct-VEI7M3fs.cjs');
+const require_Subscriber = require('../Subscriber-BL30GpWp.cjs');
+const require_SubscriberBuilder = require('../SubscriberBuilder-D1hojYLa.cjs');
 
 //#region src/subscribers/index.ts
 const s = new require_SubscriberBuilder.SubscriberBuilder();

package/dist/subscribers/index.d.cts

@@ -1,10 +1,10 @@
-import "../Construct-Bm-PSO2V.cjs";
-import { Subscriber } from "../Subscriber-BoFm12i_.cjs";
-import { SubscriberBuilder } from "../SubscriberBuilder-DgljKtYu.cjs";
-import * as _geekmidas_logger8 from "@geekmidas/logger";
+import "../Construct-ci5u8Xnu.cjs";
+import { Subscriber } from "../Subscriber-Cy28j8MS.cjs";
+import { SubscriberBuilder } from "../SubscriberBuilder-BzK8kc2a.cjs";
+import * as _geekmidas_logger0 from "@geekmidas/logger";
 
 //#region src/subscribers/index.d.ts
-declare const s: SubscriberBuilder<[], _geekmidas_logger8.Logger, undefined, undefined, string, []>;
+declare const s: SubscriberBuilder<[], _geekmidas_logger0.Logger, undefined, undefined, string, []>;
 //#endregion
 export { Subscriber, SubscriberBuilder, s };
 //# sourceMappingURL=index.d.cts.map

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_logger1 from "@geekmidas/logger";
 
 //#region src/subscribers/index.d.ts
-declare const s: SubscriberBuilder<[], _geekmidas_logger5.Logger, undefined, undefined, string, []>;
+declare const s: SubscriberBuilder<[], _geekmidas_logger1.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-C3hsQBy4.mjs";
+import { Subscriber } from "../Subscriber-CTczVFsF.mjs";
+import { SubscriberBuilder } from "../SubscriberBuilder-CekL3BoP.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.10",
   "private": false,
   "type": "module",
   "exports": {
@@ -66,12 +66,12 @@
     "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/cache": "0.0.7",
+    "@geekmidas/logger": "0.0.1",
     "@geekmidas/errors": "0.0.1",
+    "@geekmidas/cache": "0.0.7",
+    "@geekmidas/events": "0.0.2",
     "@geekmidas/rate-limit": "0.1.0"
   },
   "devDependencies": {
@@ -81,13 +81,13 @@
     "@types/lodash.uniqby": "~4.7.9",
     "@types/lodash.compact": "~3.0.9",
     "zod": "~4.1.12",
-    "@geekmidas/testkit": "0.0.16"
+    "@geekmidas/testkit": "0.0.17"
   },
   "peerDependencies": {
     "@middy/core": ">=6.3.1",
     "@types/aws-lambda": ">=8.10.92",
     "hono": ">=4.8.2",
-    "@geekmidas/envkit": "~0.0.7"
+    "@geekmidas/envkit": "~0.0.8"
   },
   "scripts": {
     "ts": "tsc --noEmit --skipLibCheck src/**/*.ts"

package/src/Construct.ts

@@ -1,4 +1,4 @@
-import { EnvironmentParser } from '@geekmidas/envkit';
+import { SnifferEnvironmentParser } from '@geekmidas/envkit/sniffer';
 import type { EventPublisher, MappedEvent } from '@geekmidas/events';
 import type { Logger } from '@geekmidas/logger';
 import type { Service } from '@geekmidas/services';
@@ -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,
   ) {}
 
   /**
@@ -40,8 +42,7 @@ export abstract class Construct<
    * ```
    */
   async getEnvironment(): Promise<string[]> {
-    const envVars = new Set<string>();
-    const sniffer = new EnvironmentParser({});
+    const sniffer = new SnifferEnvironmentParser();
     const services: Service[] = compact([
       ...this.services,
       this.publisherService,
@@ -51,34 +52,20 @@ export abstract class Construct<
       // Run each service's register method with the sniffer to track env var access
       for (const service of services) {
         try {
-          const config = service.register(sniffer);
+          const result = service.register(sniffer as any);
 
           // Await if it's a Promise (async services)
-          const resolvedConfig =
-            config && typeof config === 'object' && 'then' in config
-              ? await Promise.resolve(config)
-              : config;
-
-          // If register returns a ConfigParser, collect its env vars
-          if (
-            resolvedConfig &&
-            typeof resolvedConfig === 'object' &&
-            'getEnvironmentVariables' in resolvedConfig &&
-            typeof resolvedConfig.getEnvironmentVariables === 'function'
-          ) {
-            const vars = resolvedConfig.getEnvironmentVariables();
-            if (Array.isArray(vars)) {
-              vars.forEach((v: string) => envVars.add(v));
-            }
+          if (result && typeof result === 'object' && 'then' in result) {
+            await Promise.resolve(result);
           }
-        } catch (serviceError) {
-          // Service registration failed (e.g., missing env vars during .parse())
-          // But env vars were already tracked during .create(), so we continue
+        } catch {
+          // Service registration may fail but env vars are still tracked
           continue;
         }
       }
 
-      return Array.from(envVars).sort();
+      // Get tracked env vars directly from the sniffer
+      return sniffer.getEnvironmentVariables();
     } catch (error) {
       console.error(
         'Error determining environment variables for construct:',

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,
+  };
+}