autotel-aws 0.2.0

package/dist/step-functions.d.ts

@@ -0,0 +1,423 @@
+import { TraceContext } from 'autotel';
+import { SpanContext } from '@opentelemetry/api';
+
+/**
+ * Step Functions instrumentation
+ *
+ * Provides semantic helpers for tracing AWS Step Functions operations
+ * with context propagation for distributed tracing across state machines.
+ *
+ * @example Start workflow with trace context
+ * ```typescript
+ * import { StepFunctionsExecutor, injectTraceContext } from 'autotel-aws/step-functions';
+ * import { SFNClient } from '@aws-sdk/client-sfn';
+ *
+ * const sfn = new SFNClient({});
+ * const executor = new StepFunctionsExecutor(sfn, {
+ *   stateMachineArn: 'arn:aws:states:us-east-1:123456789:stateMachine:OrderProcessor'
+ * });
+ *
+ * // Start execution with automatic trace context injection
+ * const result = await executor.startExecution({
+ *   input: { orderId: '123', items: [...] },
+ *   name: 'order-123-execution'
+ * });
+ * ```
+ *
+ * @example Extract context in Lambda invoked by Step Functions
+ * ```typescript
+ * import { extractStepFunctionsContext } from 'autotel-aws/step-functions';
+ * import { wrapHandler } from 'autotel-aws/lambda';
+ *
+ * export const handler = wrapHandler(async (event) => {
+ *   // Extract trace context from Step Functions input
+ *   const parentContext = extractStepFunctionsContext(event);
+ *
+ *   // Process the order (without the trace context fields)
+ *   const { orderId, items } = event;
+ *   await processOrder(orderId, items);
+ *
+ *   return { status: 'completed' };
+ * });
+ * ```
+ *
+ * @example Activity worker with context propagation
+ * ```typescript
+ * import { StepFunctionsActivityWorker } from 'autotel-aws/step-functions';
+ *
+ * const worker = new StepFunctionsActivityWorker(sfn, {
+ *   activityArn: 'arn:aws:states:us-east-1:123456789:activity:ProcessPayment'
+ * });
+ *
+ * // Worker extracts trace context and creates child spans
+ * await worker.poll(async (input, taskToken, ctx) => {
+ *   ctx.setAttribute('payment.amount', input.amount);
+ *   const result = await processPayment(input);
+ *   return result;
+ * });
+ * ```
+ */
+
+/**
+ * Step Functions operation configuration
+ */
+interface TraceStepFunctionConfig {
+    /**
+     * State machine ARN
+     * Sets `aws.stepfunctions.state_machine_arn` attribute.
+     */
+    stateMachineArn: string;
+    /**
+     * Operation type
+     * Used to generate the span name: `stepfunctions.{operation}`
+     * @default 'execute'
+     */
+    operation?: 'StartExecution' | 'DescribeExecution' | 'StopExecution' | 'ListExecutions' | 'SendTaskSuccess' | 'SendTaskFailure' | 'execute';
+}
+/**
+ * Configuration for StepFunctionsExecutor
+ */
+interface StepFunctionsExecutorConfig {
+    /**
+     * State machine ARN
+     */
+    stateMachineArn: string;
+    /**
+     * Inject W3C Trace Context into execution input
+     * @default true
+     */
+    injectTraceContext?: boolean;
+    /**
+     * Optional service name for tracing
+     */
+    service?: string;
+}
+/**
+ * Execution input with optional trace context
+ */
+interface ExecutionInput<T = Record<string, unknown>> {
+    /**
+     * The input data for the execution
+     */
+    input: T;
+    /**
+     * Optional execution name (must be unique within 90 days)
+     */
+    name?: string;
+    /**
+     * Optional trace ID for idempotency
+     */
+    traceHeader?: string;
+}
+/**
+ * Configuration for StepFunctionsActivityWorker
+ */
+interface StepFunctionsActivityWorkerConfig {
+    /**
+     * Activity ARN
+     */
+    activityArn: string;
+    /**
+     * Worker name for identification
+     */
+    workerName?: string;
+    /**
+     * Extract trace context from activity input
+     * @default true
+     */
+    extractTraceContext?: boolean;
+    /**
+     * Optional service name for tracing
+     */
+    service?: string;
+}
+/**
+ * Trace context fields injected into Step Functions input
+ */
+interface TraceContextFields {
+    _traceContext?: {
+        traceparent: string;
+        tracestate?: string;
+        baggage?: string;
+    };
+}
+/**
+ * Inject W3C Trace Context into Step Functions execution input
+ *
+ * Adds `_traceContext` field with traceparent, tracestate, and baggage.
+ * This enables distributed tracing across Step Functions executions
+ * and Lambda functions invoked by the state machine.
+ *
+ * @param input - The original execution input
+ * @returns Input with trace context injected
+ *
+ * @example
+ * ```typescript
+ * const input = { orderId: '123', items: [...] };
+ * const inputWithContext = injectTraceContext(input);
+ * // { orderId: '123', items: [...], _traceContext: { traceparent: '...' } }
+ *
+ * await sfn.send(new StartExecutionCommand({
+ *   stateMachineArn: 'arn:...',
+ *   input: JSON.stringify(inputWithContext)
+ * }));
+ * ```
+ */
+declare function injectTraceContext<T extends Record<string, unknown>>(input: T): T & TraceContextFields;
+/**
+ * Extract W3C Trace Context from Step Functions input
+ *
+ * Extracts the `_traceContext` field added by injectTraceContext.
+ * Returns the SpanContext if present, or undefined.
+ *
+ * @param input - Step Functions input (event in Lambda handler)
+ * @returns SpanContext if trace context was found, undefined otherwise
+ *
+ * @example
+ * ```typescript
+ * // In a Lambda invoked by Step Functions
+ * export const handler = async (event) => {
+ *   const parentContext = extractStepFunctionsContext(event);
+ *   // Use parentContext to link traces...
+ *
+ *   // Access data without trace context
+ *   const { orderId, items } = stripTraceContext(event);
+ * };
+ * ```
+ */
+declare function extractStepFunctionsContext(input: unknown): SpanContext | undefined;
+/**
+ * Strip trace context fields from Step Functions input
+ *
+ * Returns the input without `_traceContext` field for cleaner processing.
+ *
+ * @param input - Step Functions input with optional trace context
+ * @returns Input without trace context fields
+ *
+ * @example
+ * ```typescript
+ * const event = { orderId: '123', _traceContext: { ... } };
+ * const cleanInput = stripTraceContext(event);
+ * // { orderId: '123' }
+ * ```
+ */
+declare function stripTraceContext<T extends Record<string, unknown>>(input: T): Omit<T, '_traceContext'>;
+/**
+ * Trace Step Functions operations
+ *
+ * Creates a traced function that automatically sets Step Functions attributes.
+ *
+ * @param config - Step Functions operation configuration
+ * @returns A higher-order function that wraps your Step Functions operation with tracing
+ *
+ * @remarks
+ * Semantic attributes set automatically:
+ * - `aws.stepfunctions.state_machine_arn` - State machine ARN
+ *
+ * Additional attributes you should set in your handler:
+ * - `aws.stepfunctions.execution_arn` - Execution ARN
+ * - `aws.stepfunctions.execution_name` - Execution name
+ *
+ * @example
+ * ```typescript
+ * export const startWorkflow = traceStepFunction({
+ *   stateMachineArn: 'arn:aws:states:us-east-1:123456789:stateMachine:OrderProcessor',
+ *   operation: 'StartExecution'
+ * })(ctx => async (input: object, executionName?: string) => {
+ *   const result = await sfn.send(new StartExecutionCommand({
+ *     stateMachineArn: 'arn:aws:states:...',
+ *     input: JSON.stringify(injectTraceContext(input)),
+ *     name: executionName
+ *   }));
+ *
+ *   ctx.setAttribute('aws.stepfunctions.execution_arn', result.executionArn ?? '');
+ *   return result;
+ * });
+ * ```
+ */
+declare function traceStepFunction(config: TraceStepFunctionConfig): <TArgs extends unknown[], TReturn>(fn: (ctx: TraceContext) => (...args: TArgs) => Promise<TReturn>) => (...args: TArgs) => Promise<TReturn>;
+/**
+ * Step Functions Executor with automatic trace context injection
+ *
+ * Wraps an SFN client to automatically:
+ * - Create spans for all operations
+ * - Inject W3C Trace Context into execution input
+ * - Set proper semantic attributes
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { StepFunctionsExecutor } from 'autotel-aws/step-functions';
+ * import { SFNClient } from '@aws-sdk/client-sfn';
+ *
+ * const sfn = new SFNClient({ region: 'us-east-1' });
+ * const executor = new StepFunctionsExecutor(sfn, {
+ *   stateMachineArn: 'arn:aws:states:us-east-1:123456789:stateMachine:OrderProcessor'
+ * });
+ *
+ * // Start execution with automatic trace context
+ * const result = await executor.startExecution({
+ *   input: { orderId: '123', items: ['item1', 'item2'] },
+ *   name: 'order-123-execution'
+ * });
+ *
+ * console.log('Execution ARN:', result.executionArn);
+ * ```
+ *
+ * @example Express workflow (sync execution)
+ * ```typescript
+ * // Express workflows return synchronously
+ * const result = await executor.startSyncExecution({
+ *   input: { orderId: '123' }
+ * });
+ *
+ * if (result.status === 'SUCCEEDED') {
+ *   const output = JSON.parse(result.output || '{}');
+ *   console.log('Workflow output:', output);
+ * }
+ * ```
+ */
+declare class StepFunctionsExecutor<TClient extends {
+    send: (command: any) => Promise<any>;
+} = any> {
+    private client;
+    private config;
+    private stateMachineName;
+    constructor(client: TClient, config: StepFunctionsExecutorConfig);
+    /**
+     * Start a new execution of the state machine
+     *
+     * @param execution - Execution input and optional name
+     * @returns Promise with execution ARN and start date
+     */
+    startExecution<T extends Record<string, unknown>>(execution: ExecutionInput<T>): Promise<{
+        executionArn?: string;
+        startDate?: Date;
+    }>;
+    /**
+     * Start a synchronous execution (Express workflows only)
+     *
+     * @param execution - Execution input and optional name
+     * @returns Promise with execution result including output
+     */
+    startSyncExecution<T extends Record<string, unknown>>(execution: ExecutionInput<T>): Promise<{
+        executionArn?: string;
+        status?: 'SUCCEEDED' | 'FAILED' | 'TIMED_OUT';
+        output?: string;
+        error?: string;
+        cause?: string;
+        billingDetails?: {
+            billedMemoryUsedInMB?: number;
+            billedDurationInMilliseconds?: number;
+        };
+    }>;
+    /**
+     * Describe an execution
+     *
+     * @param executionArn - ARN of the execution to describe
+     * @returns Promise with execution details
+     */
+    describeExecution(executionArn: string): Promise<{
+        executionArn?: string;
+        stateMachineArn?: string;
+        name?: string;
+        status?: string;
+        startDate?: Date;
+        stopDate?: Date;
+        input?: string;
+        output?: string;
+        error?: string;
+        cause?: string;
+    }>;
+    /**
+     * Stop an execution
+     *
+     * @param executionArn - ARN of the execution to stop
+     * @param options - Optional error and cause for the stop
+     * @returns Promise with stop date
+     */
+    stopExecution(executionArn: string, options?: {
+        error?: string;
+        cause?: string;
+    }): Promise<{
+        stopDate?: Date;
+    }>;
+}
+/**
+ * Step Functions Activity Worker with trace context extraction
+ *
+ * Polls for activity tasks and processes them with automatic tracing.
+ * Extracts trace context from task input for distributed tracing.
+ *
+ * @example Basic activity worker
+ * ```typescript
+ * import { StepFunctionsActivityWorker } from 'autotel-aws/step-functions';
+ * import { SFNClient } from '@aws-sdk/client-sfn';
+ *
+ * const sfn = new SFNClient({ region: 'us-east-1' });
+ * const worker = new StepFunctionsActivityWorker(sfn, {
+ *   activityArn: 'arn:aws:states:us-east-1:123456789:activity:ProcessPayment',
+ *   workerName: 'payment-worker-1'
+ * });
+ *
+ * // Process tasks with automatic tracing
+ * await worker.poll(async (input, taskToken, ctx) => {
+ *   ctx.setAttribute('payment.amount', input.amount);
+ *   ctx.setAttribute('payment.currency', input.currency);
+ *
+ *   const result = await processPayment(input);
+ *
+ *   ctx.setAttribute('payment.status', result.status);
+ *   return result;
+ * });
+ * ```
+ *
+ * @example Continuous polling with error handling
+ * ```typescript
+ * async function runWorker() {
+ *   while (true) {
+ *     try {
+ *       await worker.poll(async (input, taskToken, ctx) => {
+ *         return await processTask(input);
+ *       });
+ *     } catch (error) {
+ *       console.error('Worker error:', error);
+ *       // Brief pause before retrying
+ *       await new Promise(resolve => setTimeout(resolve, 1000));
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare class StepFunctionsActivityWorker<TClient extends {
+    send: (command: any) => Promise<any>;
+} = any> {
+    private client;
+    private config;
+    private activityName;
+    constructor(client: TClient, config: StepFunctionsActivityWorkerConfig);
+    /**
+     * Poll for an activity task and process it
+     *
+     * @param processor - Function to process the task input
+     * @returns Promise that resolves when the task is processed
+     */
+    poll<TInput extends Record<string, unknown>, TOutput>(processor: (input: TInput, taskToken: string, ctx: TraceContext) => Promise<TOutput>): Promise<void>;
+    /**
+     * Send a task heartbeat
+     *
+     * For long-running activities, send heartbeats to prevent timeout.
+     *
+     * @param taskToken - The task token from GetActivityTask
+     */
+    sendHeartbeat(taskToken: string): Promise<void>;
+    /**
+     * Send task failure
+     *
+     * @param taskToken - The task token from GetActivityTask
+     * @param error - Error code
+     * @param cause - Error cause description
+     */
+    sendFailure(taskToken: string, error: string, cause?: string): Promise<void>;
+}
+
+export { type ExecutionInput, StepFunctionsActivityWorker, type StepFunctionsActivityWorkerConfig, StepFunctionsExecutor, type StepFunctionsExecutorConfig, type TraceStepFunctionConfig, extractStepFunctionsContext, injectTraceContext, stripTraceContext, traceStepFunction };

package/dist/step-functions.js

@@ -0,0 +1,6 @@
+export { StepFunctionsActivityWorker, StepFunctionsExecutor, extractStepFunctionsContext, injectTraceContext, stripTraceContext, traceStepFunction } from './chunk-DF5PT3JK.js';
+import './chunk-YG56NRIO.js';
+import './chunk-I4CKQ4RD.js';
+import './chunk-DGUM43GV.js';
+//# sourceMappingURL=step-functions.js.map
+//# sourceMappingURL=step-functions.js.map

package/dist/step-functions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"step-functions.js"}

package/dist/testing.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+require('./chunk-JEQ2X3Z6.cjs');
+
+// src/testing/lambda-harness.ts
+function createMockLambdaContext(overrides) {
+  return {
+    awsRequestId: "test-request-id",
+    functionName: "test-function",
+    functionVersion: "$LATEST",
+    invokedFunctionArn: "arn:aws:lambda:us-east-1:123456789012:function:test-function",
+    memoryLimitInMB: "128",
+    getRemainingTimeInMillis: () => 3e4,
+    ...overrides
+  };
+}
+function createLambdaTestHarness() {
+  return {
+    /**
+     * Invoke a Lambda handler with test event and context
+     */
+    async invoke(handler, event, context) {
+      const mockContext = createMockLambdaContext(context);
+      return handler(event, mockContext);
+    }
+  };
+}
+
+// src/testing/localstack.ts
+function createLocalStackHelpers() {
+  return {
+    /**
+     * Get LocalStack endpoint URL
+     * @param _service - Service name (currently unused, all services use same endpoint)
+     */
+    getEndpoint(_service) {
+      const host = process.env.LOCALSTACK_HOST || "localhost";
+      const port = process.env.LOCALSTACK_PORT || "4566";
+      return `http://${host}:${port}`;
+    },
+    /**
+     * Check if LocalStack is available
+     */
+    async isAvailable() {
+      try {
+        const response = await fetch(
+          `${this.getEndpoint("health")}/_localstack/health`,
+          { method: "GET" }
+        );
+        return response.ok;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+
+exports.createLambdaTestHarness = createLambdaTestHarness;
+exports.createLocalStackHelpers = createLocalStackHelpers;
+//# sourceMappingURL=testing.cjs.map
+//# sourceMappingURL=testing.cjs.map

package/dist/testing.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/testing/lambda-harness.ts","../src/testing/localstack.ts"],"names":[],"mappings":";;;;;AAUO,SAAS,wBAAwB,SAAA,EAAmD;AACzF,EAAA,OAAO;AAAA,IACL,YAAA,EAAc,iBAAA;AAAA,IACd,YAAA,EAAc,eAAA;AAAA,IACd,eAAA,EAAiB,SAAA;AAAA,IACjB,kBAAA,EAAoB,8DAAA;AAAA,IACpB,eAAA,EAAiB,KAAA;AAAA,IACjB,0BAA0B,MAAM,GAAA;AAAA,IAChC,GAAG;AAAA,GACL;AACF;AAKO,SAAS,uBAAA,GAA0B;AACxC,EAAA,OAAO;AAAA;AAAA;AAAA;AAAA,IAIL,MAAM,MAAA,CACJ,OAAA,EACA,KAAA,EACA,OAAA,EACkB;AAClB,MAAA,MAAM,WAAA,GAAc,wBAAwB,OAAO,CAAA;AACnD,MAAA,OAAO,OAAA,CAAQ,OAAO,WAAW,CAAA;AAAA,IACnC;AAAA,GACF;AACF;;;AC9BO,SAAS,uBAAA,GAA0B;AACxC,EAAA,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA,IAKL,YAAY,QAAA,EAA0B;AACpC,MAAA,MAAM,IAAA,GAAO,OAAA,CAAQ,GAAA,CAAI,eAAA,IAAmB,WAAA;AAC5C,MAAA,MAAM,IAAA,GAAO,OAAA,CAAQ,GAAA,CAAI,eAAA,IAAmB,MAAA;AAC5C,MAAA,OAAO,CAAA,OAAA,EAAU,IAAI,CAAA,CAAA,EAAI,IAAI,CAAA,CAAA;AAAA,IAC/B,CAAA;AAAA;AAAA;AAAA;AAAA,IAKA,MAAM,WAAA,GAAgC;AACpC,MAAA,IAAI;AACF,QAAA,MAAM,WAAW,MAAM,KAAA;AAAA,UACrB,CAAA,EAAG,IAAA,CAAK,WAAA,CAAY,QAAQ,CAAC,CAAA,mBAAA,CAAA;AAAA,UAC7B,EAAE,QAAQ,KAAA;AAAM,SAClB;AACA,QAAA,OAAO,QAAA,CAAS,EAAA;AAAA,MAClB,CAAA,CAAA,MAAQ;AACN,QAAA,OAAO,KAAA;AAAA,MACT;AAAA,IACF;AAAA,GACF;AACF","file":"testing.cjs","sourcesContent":["/**\n * Lambda test harness utilities\n */\n\nimport type { LambdaHandler } from '../lambda/types';\nimport type { LambdaContext } from '../types';\n\n/**\n * Mock Lambda context for testing\n */\nexport function createMockLambdaContext(overrides?: Partial<LambdaContext>): LambdaContext {\n  return {\n    awsRequestId: 'test-request-id',\n    functionName: 'test-function',\n    functionVersion: '$LATEST',\n    invokedFunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:test-function',\n    memoryLimitInMB: '128',\n    getRemainingTimeInMillis: () => 30_000,\n    ...overrides,\n  };\n}\n\n/**\n * Lambda test harness\n */\nexport function createLambdaTestHarness() {\n  return {\n    /**\n     * Invoke a Lambda handler with test event and context\n     */\n    async invoke<TEvent, TResult>(\n      handler: LambdaHandler<TEvent, TResult>,\n      event: TEvent,\n      context?: Partial<LambdaContext>\n    ): Promise<TResult> {\n      const mockContext = createMockLambdaContext(context);\n      return handler(event, mockContext);\n    },\n  };\n}\n","/**\n * LocalStack integration helpers\n *\n * LocalStack is a cloud service emulator for local AWS development and testing.\n */\n\n/**\n * Create LocalStack helpers for testing\n */\nexport function createLocalStackHelpers() {\n  return {\n    /**\n     * Get LocalStack endpoint URL\n     * @param _service - Service name (currently unused, all services use same endpoint)\n     */\n    getEndpoint(_service: string): string {\n      const host = process.env.LOCALSTACK_HOST || 'localhost';\n      const port = process.env.LOCALSTACK_PORT || '4566';\n      return `http://${host}:${port}`;\n    },\n\n    /**\n     * Check if LocalStack is available\n     */\n    async isAvailable(): Promise<boolean> {\n      try {\n        const response = await fetch(\n          `${this.getEndpoint('health')}/_localstack/health`,\n          { method: 'GET' }\n        );\n        return response.ok;\n      } catch {\n        return false;\n      }\n    },\n  };\n}\n"]}

package/dist/testing.d.cts

@@ -0,0 +1,39 @@
+import { L as LambdaHandler } from './types-kTFVdSqO.cjs';
+import { a as LambdaContext } from './types-3_ak5jhy.cjs';
+import '@opentelemetry/api';
+
+/**
+ * Lambda test harness utilities
+ */
+
+/**
+ * Lambda test harness
+ */
+declare function createLambdaTestHarness(): {
+    /**
+     * Invoke a Lambda handler with test event and context
+     */
+    invoke<TEvent, TResult>(handler: LambdaHandler<TEvent, TResult>, event: TEvent, context?: Partial<LambdaContext>): Promise<TResult>;
+};
+
+/**
+ * LocalStack integration helpers
+ *
+ * LocalStack is a cloud service emulator for local AWS development and testing.
+ */
+/**
+ * Create LocalStack helpers for testing
+ */
+declare function createLocalStackHelpers(): {
+    /**
+     * Get LocalStack endpoint URL
+     * @param _service - Service name (currently unused, all services use same endpoint)
+     */
+    getEndpoint(_service: string): string;
+    /**
+     * Check if LocalStack is available
+     */
+    isAvailable(): Promise<boolean>;
+};
+
+export { createLambdaTestHarness, createLocalStackHelpers };

package/dist/testing.d.ts

@@ -0,0 +1,39 @@
+import { L as LambdaHandler } from './types-UiBv_I_M.js';
+import { a as LambdaContext } from './types-3_ak5jhy.js';
+import '@opentelemetry/api';
+
+/**
+ * Lambda test harness utilities
+ */
+
+/**
+ * Lambda test harness
+ */
+declare function createLambdaTestHarness(): {
+    /**
+     * Invoke a Lambda handler with test event and context
+     */
+    invoke<TEvent, TResult>(handler: LambdaHandler<TEvent, TResult>, event: TEvent, context?: Partial<LambdaContext>): Promise<TResult>;
+};
+
+/**
+ * LocalStack integration helpers
+ *
+ * LocalStack is a cloud service emulator for local AWS development and testing.
+ */
+/**
+ * Create LocalStack helpers for testing
+ */
+declare function createLocalStackHelpers(): {
+    /**
+     * Get LocalStack endpoint URL
+     * @param _service - Service name (currently unused, all services use same endpoint)
+     */
+    getEndpoint(_service: string): string;
+    /**
+     * Check if LocalStack is available
+     */
+    isAvailable(): Promise<boolean>;
+};
+
+export { createLambdaTestHarness, createLocalStackHelpers };

package/dist/testing.js

@@ -0,0 +1,58 @@
+import './chunk-DGUM43GV.js';
+
+// src/testing/lambda-harness.ts
+function createMockLambdaContext(overrides) {
+  return {
+    awsRequestId: "test-request-id",
+    functionName: "test-function",
+    functionVersion: "$LATEST",
+    invokedFunctionArn: "arn:aws:lambda:us-east-1:123456789012:function:test-function",
+    memoryLimitInMB: "128",
+    getRemainingTimeInMillis: () => 3e4,
+    ...overrides
+  };
+}
+function createLambdaTestHarness() {
+  return {
+    /**
+     * Invoke a Lambda handler with test event and context
+     */
+    async invoke(handler, event, context) {
+      const mockContext = createMockLambdaContext(context);
+      return handler(event, mockContext);
+    }
+  };
+}
+
+// src/testing/localstack.ts
+function createLocalStackHelpers() {
+  return {
+    /**
+     * Get LocalStack endpoint URL
+     * @param _service - Service name (currently unused, all services use same endpoint)
+     */
+    getEndpoint(_service) {
+      const host = process.env.LOCALSTACK_HOST || "localhost";
+      const port = process.env.LOCALSTACK_PORT || "4566";
+      return `http://${host}:${port}`;
+    },
+    /**
+     * Check if LocalStack is available
+     */
+    async isAvailable() {
+      try {
+        const response = await fetch(
+          `${this.getEndpoint("health")}/_localstack/health`,
+          { method: "GET" }
+        );
+        return response.ok;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+
+export { createLambdaTestHarness, createLocalStackHelpers };
+//# sourceMappingURL=testing.js.map
+//# sourceMappingURL=testing.js.map

package/dist/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/testing/lambda-harness.ts","../src/testing/localstack.ts"],"names":[],"mappings":";;;AAUO,SAAS,wBAAwB,SAAA,EAAmD;AACzF,EAAA,OAAO;AAAA,IACL,YAAA,EAAc,iBAAA;AAAA,IACd,YAAA,EAAc,eAAA;AAAA,IACd,eAAA,EAAiB,SAAA;AAAA,IACjB,kBAAA,EAAoB,8DAAA;AAAA,IACpB,eAAA,EAAiB,KAAA;AAAA,IACjB,0BAA0B,MAAM,GAAA;AAAA,IAChC,GAAG;AAAA,GACL;AACF;AAKO,SAAS,uBAAA,GAA0B;AACxC,EAAA,OAAO;AAAA;AAAA;AAAA;AAAA,IAIL,MAAM,MAAA,CACJ,OAAA,EACA,KAAA,EACA,OAAA,EACkB;AAClB,MAAA,MAAM,WAAA,GAAc,wBAAwB,OAAO,CAAA;AACnD,MAAA,OAAO,OAAA,CAAQ,OAAO,WAAW,CAAA;AAAA,IACnC;AAAA,GACF;AACF;;;AC9BO,SAAS,uBAAA,GAA0B;AACxC,EAAA,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA,IAKL,YAAY,QAAA,EAA0B;AACpC,MAAA,MAAM,IAAA,GAAO,OAAA,CAAQ,GAAA,CAAI,eAAA,IAAmB,WAAA;AAC5C,MAAA,MAAM,IAAA,GAAO,OAAA,CAAQ,GAAA,CAAI,eAAA,IAAmB,MAAA;AAC5C,MAAA,OAAO,CAAA,OAAA,EAAU,IAAI,CAAA,CAAA,EAAI,IAAI,CAAA,CAAA;AAAA,IAC/B,CAAA;AAAA;AAAA;AAAA;AAAA,IAKA,MAAM,WAAA,GAAgC;AACpC,MAAA,IAAI;AACF,QAAA,MAAM,WAAW,MAAM,KAAA;AAAA,UACrB,CAAA,EAAG,IAAA,CAAK,WAAA,CAAY,QAAQ,CAAC,CAAA,mBAAA,CAAA;AAAA,UAC7B,EAAE,QAAQ,KAAA;AAAM,SAClB;AACA,QAAA,OAAO,QAAA,CAAS,EAAA;AAAA,MAClB,CAAA,CAAA,MAAQ;AACN,QAAA,OAAO,KAAA;AAAA,MACT;AAAA,IACF;AAAA,GACF;AACF","file":"testing.js","sourcesContent":["/**\n * Lambda test harness utilities\n */\n\nimport type { LambdaHandler } from '../lambda/types';\nimport type { LambdaContext } from '../types';\n\n/**\n * Mock Lambda context for testing\n */\nexport function createMockLambdaContext(overrides?: Partial<LambdaContext>): LambdaContext {\n  return {\n    awsRequestId: 'test-request-id',\n    functionName: 'test-function',\n    functionVersion: '$LATEST',\n    invokedFunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:test-function',\n    memoryLimitInMB: '128',\n    getRemainingTimeInMillis: () => 30_000,\n    ...overrides,\n  };\n}\n\n/**\n * Lambda test harness\n */\nexport function createLambdaTestHarness() {\n  return {\n    /**\n     * Invoke a Lambda handler with test event and context\n     */\n    async invoke<TEvent, TResult>(\n      handler: LambdaHandler<TEvent, TResult>,\n      event: TEvent,\n      context?: Partial<LambdaContext>\n    ): Promise<TResult> {\n      const mockContext = createMockLambdaContext(context);\n      return handler(event, mockContext);\n    },\n  };\n}\n","/**\n * LocalStack integration helpers\n *\n * LocalStack is a cloud service emulator for local AWS development and testing.\n */\n\n/**\n * Create LocalStack helpers for testing\n */\nexport function createLocalStackHelpers() {\n  return {\n    /**\n     * Get LocalStack endpoint URL\n     * @param _service - Service name (currently unused, all services use same endpoint)\n     */\n    getEndpoint(_service: string): string {\n      const host = process.env.LOCALSTACK_HOST || 'localhost';\n      const port = process.env.LOCALSTACK_PORT || '4566';\n      return `http://${host}:${port}`;\n    },\n\n    /**\n     * Check if LocalStack is available\n     */\n    async isAvailable(): Promise<boolean> {\n      try {\n        const response = await fetch(\n          `${this.getEndpoint('health')}/_localstack/health`,\n          { method: 'GET' }\n        );\n        return response.ok;\n      } catch {\n        return false;\n      }\n    },\n  };\n}\n"]}