@jaypie/fabric 0.1.0

package/dist/cjs/lambda/index.cjs

@@ -0,0 +1,967 @@
+'use strict';
+
+var aws = require('@jaypie/aws');
+var lambda = require('@jaypie/lambda');
+var errors = require('@jaypie/errors');
+
+/**
+ * Meta-modeling Constants
+ */
+// =============================================================================
+// Constants
+// =============================================================================
+/** Root organizational unit */
+/** Fabric version - used to identify pre-instantiated Services */
+const FABRIC_VERSION = "0.1.0";
+
+/**
+ * Date Type Conversion for @jaypie/fabric
+ *
+ * Adds Date as a supported type in the fabric type system.
+ * Follows the same conversion patterns as String, Number, Boolean.
+ */
+/**
+ * Convert a value to a Date
+ *
+ * Supported inputs:
+ * - Date: returned as-is (validated)
+ * - Number: treated as Unix timestamp (milliseconds)
+ * - String: parsed via Date constructor (ISO 8601, etc.)
+ * - Object with value property: unwrapped and converted
+ *
+ * @throws BadRequestError if value cannot be converted to valid Date
+ */
+function fabricDate(value) {
+    // Already a Date
+    if (value instanceof Date) {
+        if (Number.isNaN(value.getTime())) {
+            throw new errors.BadRequestError("Invalid Date value");
+        }
+        return value;
+    }
+    // Null/undefined
+    if (value === null || value === undefined) {
+        throw new errors.BadRequestError("Cannot convert null or undefined to Date");
+    }
+    // Object with value property (fabric pattern)
+    if (typeof value === "object" && value !== null && "value" in value) {
+        return fabricDate(value.value);
+    }
+    // Number (timestamp in milliseconds)
+    if (typeof value === "number") {
+        if (Number.isNaN(value)) {
+            throw new errors.BadRequestError("Cannot convert NaN to Date");
+        }
+        const date = new Date(value);
+        if (Number.isNaN(date.getTime())) {
+            throw new errors.BadRequestError(`Cannot convert ${value} to Date`);
+        }
+        return date;
+    }
+    // String (ISO 8601 or parseable format)
+    if (typeof value === "string") {
+        // Empty string is invalid
+        if (value.trim() === "") {
+            throw new errors.BadRequestError("Cannot convert empty string to Date");
+        }
+        const date = new Date(value);
+        if (Number.isNaN(date.getTime())) {
+            throw new errors.BadRequestError(`Cannot convert "${value}" to Date`);
+        }
+        return date;
+    }
+    // Boolean cannot be converted to Date
+    if (typeof value === "boolean") {
+        throw new errors.BadRequestError("Cannot convert boolean to Date");
+    }
+    // Arrays - attempt single element extraction
+    if (Array.isArray(value)) {
+        if (value.length === 1) {
+            return fabricDate(value[0]);
+        }
+        throw new errors.BadRequestError(`Cannot convert array with ${value.length} elements to Date`);
+    }
+    throw new errors.BadRequestError(`Cannot convert ${typeof value} to Date`);
+}
+/**
+ * Type guard for Date type in schema definitions
+ */
+function isDateType(type) {
+    return type === Date;
+}
+
+// Fabric functions for @jaypie/fabric
+/**
+ * Try to parse a string as JSON if it looks like JSON
+ * Returns the parsed value or the original string if not JSON
+ */
+function tryParseJson(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+        (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            // Not valid JSON, return original
+            return value;
+        }
+    }
+    return value;
+}
+/**
+ * Unwrap arrays and objects to get to the scalar value
+ * - Single-element arrays unwrap to their element
+ * - Objects with value property unwrap to that value
+ * - Recursively unwraps nested structures
+ */
+function unwrapToScalar(value) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    // Unwrap single-element arrays
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return undefined;
+        }
+        if (value.length === 1) {
+            return unwrapToScalar(value[0]);
+        }
+        throw new errors.BadRequestError("Cannot convert multi-value array to scalar");
+    }
+    // Unwrap objects with value property
+    if (typeof value === "object") {
+        const obj = value;
+        if ("value" in obj) {
+            return unwrapToScalar(obj.value);
+        }
+        throw new errors.BadRequestError("Object must have a value attribute");
+    }
+    return value;
+}
+/**
+ * Prepare a value for scalar conversion by parsing JSON strings and unwrapping
+ */
+function prepareForScalarConversion(value) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    // Try to parse JSON strings
+    if (typeof value === "string") {
+        const parsed = tryParseJson(value);
+        if (parsed !== value) {
+            // Successfully parsed, unwrap the result
+            return unwrapToScalar(parsed);
+        }
+        return value;
+    }
+    // Unwrap arrays and objects
+    if (Array.isArray(value) || typeof value === "object") {
+        return unwrapToScalar(value);
+    }
+    return value;
+}
+/**
+ * Convert a value to a boolean
+ * - Arrays, objects, and JSON strings are unwrapped first
+ * - String "true" becomes true
+ * - String "false" becomes false
+ * - Strings that parse to numbers: positive = true, zero or negative = false
+ * - Numbers: positive = true, zero or negative = false
+ * - Boolean passes through
+ */
+function fabricBoolean(value) {
+    // Prepare value by parsing JSON and unwrapping arrays/objects
+    const prepared = prepareForScalarConversion(value);
+    if (prepared === undefined || prepared === null) {
+        return undefined;
+    }
+    if (typeof prepared === "boolean") {
+        return prepared;
+    }
+    if (typeof prepared === "string") {
+        if (prepared === "") {
+            return undefined;
+        }
+        const lower = prepared.toLowerCase();
+        if (lower === "true") {
+            return true;
+        }
+        if (lower === "false") {
+            return false;
+        }
+        // Try to parse as number
+        const num = parseFloat(prepared);
+        if (isNaN(num)) {
+            throw new errors.BadRequestError(`Cannot convert "${prepared}" to Boolean`);
+        }
+        return num > 0;
+    }
+    if (typeof prepared === "number") {
+        if (isNaN(prepared)) {
+            throw new errors.BadRequestError("Cannot convert NaN to Boolean");
+        }
+        return prepared > 0;
+    }
+    throw new errors.BadRequestError(`Cannot convert ${typeof prepared} to Boolean`);
+}
+/**
+ * Convert a value to a number
+ * - Arrays, objects, and JSON strings are unwrapped first
+ * - String "" becomes undefined
+ * - String "true" becomes 1
+ * - String "false" becomes 0
+ * - Strings that parse to numbers use those values
+ * - Strings that parse to NaN throw BadRequestError
+ * - Boolean true becomes 1, false becomes 0
+ * - Number passes through
+ */
+function fabricNumber(value) {
+    // Prepare value by parsing JSON and unwrapping arrays/objects
+    const prepared = prepareForScalarConversion(value);
+    if (prepared === undefined || prepared === null) {
+        return undefined;
+    }
+    if (typeof prepared === "number") {
+        if (isNaN(prepared)) {
+            throw new errors.BadRequestError("Cannot convert NaN to Number");
+        }
+        return prepared;
+    }
+    if (typeof prepared === "boolean") {
+        return prepared ? 1 : 0;
+    }
+    if (typeof prepared === "string") {
+        if (prepared === "") {
+            return undefined;
+        }
+        const lower = prepared.toLowerCase();
+        if (lower === "true") {
+            return 1;
+        }
+        if (lower === "false") {
+            return 0;
+        }
+        const num = parseFloat(prepared);
+        if (isNaN(num)) {
+            throw new errors.BadRequestError(`Cannot convert "${prepared}" to Number`);
+        }
+        return num;
+    }
+    throw new errors.BadRequestError(`Cannot convert ${typeof prepared} to Number`);
+}
+/**
+ * Convert a value to a string
+ * - Arrays, objects, and JSON strings are unwrapped first
+ * - String "" becomes undefined
+ * - Boolean true becomes "true", false becomes "false"
+ * - Number converts to string representation
+ * - String passes through
+ */
+function fabricString(value) {
+    // Prepare value by parsing JSON and unwrapping arrays/objects
+    const prepared = prepareForScalarConversion(value);
+    if (prepared === undefined || prepared === null) {
+        return undefined;
+    }
+    if (typeof prepared === "string") {
+        if (prepared === "") {
+            return undefined;
+        }
+        return prepared;
+    }
+    if (typeof prepared === "boolean") {
+        return prepared ? "true" : "false";
+    }
+    if (typeof prepared === "number") {
+        if (isNaN(prepared)) {
+            throw new errors.BadRequestError("Cannot convert NaN to String");
+        }
+        return String(prepared);
+    }
+    throw new errors.BadRequestError(`Cannot convert ${typeof prepared} to String`);
+}
+/**
+ * Convert a value to an array
+ * - Non-arrays become arrays containing that value
+ * - Arrays of a single value become that value (unwrapped)
+ * - Multi-value arrays throw BadRequestError
+ * - undefined/null become undefined
+ */
+function fabricArray(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        // Arrays pass through (single-element unwrapping happens when converting FROM array)
+        return value;
+    }
+    // Non-arrays become single-element arrays
+    return [value];
+}
+/**
+ * Convert a value to an object with a value property
+ * - Scalars become { value: scalar }
+ * - Arrays become { value: array }
+ * - Objects with a value attribute pass through
+ * - Objects without a value attribute throw BadRequestError
+ * - undefined/null become undefined
+ */
+function fabricObject(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    // Check if already an object (but not an array)
+    if (typeof value === "object" && !Array.isArray(value)) {
+        const obj = value;
+        if ("value" in obj) {
+            return obj;
+        }
+        throw new errors.BadRequestError("Object must have a value attribute");
+    }
+    // Scalars and arrays become { value: ... }
+    return { value };
+}
+/**
+ * Check if a type is a typed array (e.g., [String], [Number], [], etc.)
+ */
+function isTypedArrayType(type) {
+    return Array.isArray(type);
+}
+/**
+ * Split a string on comma or tab delimiters for typed array conversion.
+ * Only splits if the string contains commas or tabs.
+ * Returns the original value if not a string or no delimiters found.
+ */
+function splitStringForArray(value) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    // Check for comma or tab delimiters
+    if (value.includes(",")) {
+        return value.split(",").map((s) => s.trim());
+    }
+    if (value.includes("\t")) {
+        return value.split("\t").map((s) => s.trim());
+    }
+    return value;
+}
+/**
+ * Try to parse a string as JSON for array context.
+ * Returns parsed value if it's an array, otherwise returns original.
+ */
+function tryParseJsonArray(value) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // Not valid JSON, fall through
+        }
+    }
+    return value;
+}
+/**
+ * Get the element type from a typed array type
+ * Returns undefined for untyped arrays ([])
+ */
+function getArrayElementType(type) {
+    if (type.length === 0) {
+        return undefined; // Untyped array
+    }
+    const elementType = type[0];
+    // Handle constructor types
+    if (elementType === Boolean)
+        return "boolean";
+    if (elementType === Number)
+        return "number";
+    if (elementType === String)
+        return "string";
+    if (elementType === Object)
+        return "object";
+    // Handle string types
+    if (elementType === "boolean")
+        return "boolean";
+    if (elementType === "number")
+        return "number";
+    if (elementType === "string")
+        return "string";
+    if (elementType === "object")
+        return "object";
+    // Handle shorthand types
+    if (elementType === "")
+        return "string"; // "" shorthand for String
+    if (typeof elementType === "object" &&
+        elementType !== null &&
+        Object.keys(elementType).length === 0) {
+        return "object"; // {} shorthand for Object
+    }
+    throw new errors.BadRequestError(`Unknown array element type: ${String(elementType)}`);
+}
+/**
+ * Convert a value to a typed array
+ * - Tries to parse JSON arrays first
+ * - Splits strings on comma/tab if present
+ * - Wraps non-arrays in an array
+ * - Converts each element to the specified element type
+ */
+function fabricTypedArray(value, elementType) {
+    // Try to parse JSON array first
+    let processed = tryParseJsonArray(value);
+    // If still a string, try to split on comma/tab
+    processed = splitStringForArray(processed);
+    // Convert to array (wraps non-arrays)
+    const array = fabricArray(processed);
+    if (array === undefined) {
+        return undefined;
+    }
+    // If no element type specified, return as-is
+    if (elementType === undefined) {
+        return array;
+    }
+    // Convert each element to the element type
+    return array.map((element, index) => {
+        try {
+            switch (elementType) {
+                case "boolean":
+                    return fabricBoolean(element);
+                case "number":
+                    return fabricNumber(element);
+                case "object":
+                    return fabricObject(element);
+                case "string":
+                    return fabricString(element);
+                default:
+                    throw new errors.BadRequestError(`Unknown element type: ${elementType}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof errors.BadRequestError) {
+                throw new errors.BadRequestError(`Cannot convert array element at index ${index}: ${error.message}`);
+            }
+            throw error;
+        }
+    });
+}
+/**
+ * Fabric a value to the specified type
+ */
+function fabric(value, type) {
+    // Check for Date type first
+    if (isDateType(type)) {
+        return fabricDate(value);
+    }
+    // Check for typed array types
+    if (isTypedArrayType(type)) {
+        const elementType = getArrayElementType(type);
+        return fabricTypedArray(value, elementType);
+    }
+    const normalizedType = normalizeType(type);
+    switch (normalizedType) {
+        case "array":
+            return fabricArray(value);
+        case "boolean":
+            return fabricBoolean(value);
+        case "number":
+            return fabricNumber(value);
+        case "object":
+            return fabricObject(value);
+        case "string":
+            return fabricString(value);
+        default:
+            throw new errors.BadRequestError(`Unknown type: ${String(type)}`);
+    }
+}
+/**
+ * Normalize type to string representation
+ */
+function normalizeType(type) {
+    if (type === Array || type === "array") {
+        return "array";
+    }
+    if (type === Boolean || type === "boolean") {
+        return "boolean";
+    }
+    if (type === Number || type === "number") {
+        return "number";
+    }
+    if (type === Object || type === "object") {
+        return "object";
+    }
+    if (type === String || type === "string") {
+        return "string";
+    }
+    throw new errors.BadRequestError(`Unknown type: ${String(type)}`);
+}
+
+// Service for @jaypie/fabric
+/**
+ * Check if a single-element array is a typed array type constructor.
+ */
+function isTypedArrayConstructor(element) {
+    return (element === Boolean ||
+        element === Number ||
+        element === String ||
+        element === Object ||
+        element === "boolean" ||
+        element === "number" ||
+        element === "string" ||
+        element === "object" ||
+        element === "" ||
+        (typeof element === "object" &&
+            element !== null &&
+            !(element instanceof RegExp) &&
+            Object.keys(element).length === 0));
+}
+/**
+ * Check if a type is a validated string type (array of string literals and/or RegExp).
+ * Distinguishes from typed arrays like [String], [Number], etc.
+ */
+function isValidatedStringType(type) {
+    if (!Array.isArray(type)) {
+        return false;
+    }
+    // Empty array is untyped array, not validated string
+    if (type.length === 0) {
+        return false;
+    }
+    // Single-element arrays with type constructors are typed arrays
+    if (type.length === 1 && isTypedArrayConstructor(type[0])) {
+        return false;
+    }
+    // Check that all elements are strings or RegExp
+    return type.every((item) => typeof item === "string" || item instanceof RegExp);
+}
+/**
+ * Check if a type is a validated number type (array of number literals).
+ * Distinguishes from typed arrays like [Number], etc.
+ */
+function isValidatedNumberType(type) {
+    if (!Array.isArray(type)) {
+        return false;
+    }
+    // Empty array is untyped array, not validated number
+    if (type.length === 0) {
+        return false;
+    }
+    // Single-element arrays with type constructors are typed arrays
+    if (type.length === 1 && isTypedArrayConstructor(type[0])) {
+        return false;
+    }
+    // Check that all elements are numbers
+    return type.every((item) => typeof item === "number");
+}
+/**
+ * Parse input string as JSON if it's a string
+ */
+function parseInput(input) {
+    if (input === undefined || input === null) {
+        return {};
+    }
+    if (typeof input === "string") {
+        if (input === "") {
+            return {};
+        }
+        try {
+            const parsed = JSON.parse(input);
+            if (typeof parsed !== "object" ||
+                parsed === null ||
+                Array.isArray(parsed)) {
+                throw new errors.BadRequestError("Input must be an object");
+            }
+            return parsed;
+        }
+        catch (error) {
+            if (error instanceof errors.BadRequestError) {
+                throw error;
+            }
+            throw new errors.BadRequestError("Invalid JSON input");
+        }
+    }
+    if (typeof input === "object" && !Array.isArray(input)) {
+        return input;
+    }
+    throw new errors.BadRequestError("Input must be an object or JSON string");
+}
+/**
+ * Run validation on a value (supports async validators)
+ */
+async function runValidation(value, validate, fieldName) {
+    if (typeof validate === "function") {
+        const result = await validate(value);
+        if (result === false) {
+            throw new errors.BadRequestError(`Validation failed for field "${fieldName}"`);
+        }
+    }
+    else if (validate instanceof RegExp) {
+        if (typeof value !== "string" || !validate.test(value)) {
+            throw new errors.BadRequestError(`Validation failed for field "${fieldName}"`);
+        }
+    }
+    else if (Array.isArray(validate)) {
+        // Check if value matches any item in the array
+        for (const item of validate) {
+            if (item instanceof RegExp) {
+                if (typeof value === "string" && item.test(value)) {
+                    return; // Match found
+                }
+            }
+            else if (typeof item === "function") {
+                try {
+                    const result = await item(value);
+                    if (result !== false) {
+                        return; // Match found
+                    }
+                }
+                catch {
+                    // Continue to next item
+                }
+            }
+            else if (value === item) {
+                return; // Scalar match found
+            }
+        }
+        throw new errors.BadRequestError(`Validation failed for field "${fieldName}"`);
+    }
+}
+/**
+ * Check if a field is required
+ * A field is required unless it has a default OR required is explicitly false
+ */
+function isFieldRequired(definition) {
+    if (definition.required === false) {
+        return false;
+    }
+    if (definition.default !== undefined) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Process a single field through conversion and validation
+ */
+async function processField(fieldName, value, definition) {
+    // Apply default if value is undefined
+    let processedValue = value;
+    if (processedValue === undefined && definition.default !== undefined) {
+        processedValue = definition.default;
+    }
+    // Determine actual type and validation
+    let actualType = definition.type;
+    let validation = definition.validate;
+    // Handle bare RegExp shorthand: /regex/
+    if (definition.type instanceof RegExp) {
+        actualType = String;
+        validation = definition.type; // The RegExp becomes the validation
+    }
+    // Handle validated string shorthand: ["value1", "value2"] or [/regex/]
+    else if (isValidatedStringType(definition.type)) {
+        actualType = String;
+        validation = definition.type; // The array becomes the validation
+    }
+    // Handle validated number shorthand: [1, 2, 3]
+    else if (isValidatedNumberType(definition.type)) {
+        actualType = Number;
+        validation = definition.type; // The array becomes the validation
+    }
+    // Fabric to target type
+    const convertedValue = fabric(processedValue, actualType);
+    // Check if required field is missing
+    if (convertedValue === undefined && isFieldRequired(definition)) {
+        throw new errors.BadRequestError(`Missing required field "${fieldName}"`);
+    }
+    // Run validation if provided
+    if (validation !== undefined && convertedValue !== undefined) {
+        await runValidation(convertedValue, validation, fieldName);
+    }
+    return convertedValue;
+}
+/**
+ * Fabric a service function
+ *
+ * Service builds a function that initiates a "controller" step that:
+ * - Parses the input if it is a string to object
+ * - Fabrics each input field to its type
+ * - Calls the validation function or regular expression or checks the array
+ * - Calls the service function and returns the response
+ *
+ * The returned function has config properties for introspection.
+ */
+function fabricService(config) {
+    const { input: inputDefinitions, service } = config;
+    const handler = async (rawInput, context) => {
+        // Parse input (handles string JSON)
+        const parsedInput = parseInput(rawInput);
+        // If no input definitions, pass through to service or return parsed input
+        if (!inputDefinitions) {
+            if (service) {
+                return service(parsedInput, context);
+            }
+            return parsedInput;
+        }
+        // Process all fields in parallel
+        const entries = Object.entries(inputDefinitions);
+        const processedValues = await Promise.all(entries.map(([fieldName, definition]) => processField(fieldName, parsedInput[fieldName], definition)));
+        // Build processed input object
+        const processedInput = {};
+        entries.forEach(([fieldName], index) => {
+            processedInput[fieldName] = processedValues[index];
+        });
+        // Return processed input if no service, otherwise call service
+        if (service) {
+            return service(processedInput, context);
+        }
+        return processedInput;
+    };
+    // Attach config properties directly to handler for flat access
+    const typedHandler = handler;
+    typedHandler.$fabric = FABRIC_VERSION;
+    if (config.alias !== undefined)
+        typedHandler.alias = config.alias;
+    if (config.description !== undefined)
+        typedHandler.description = config.description;
+    if (config.input !== undefined)
+        typedHandler.input = config.input;
+    if (config.service !== undefined)
+        typedHandler.service = config.service;
+    return typedHandler;
+}
+
+// Resolve inline service definitions to full Service objects
+/**
+ * Type guard to check if a value is a pre-instantiated Service
+ * A Service is a function with the `$fabric` property set by fabricService
+ */
+function isService$1(value) {
+    return typeof value === "function" && "$fabric" in value;
+}
+/**
+ * Resolve a service configuration to a full Service object
+ *
+ * Supports two patterns:
+ * 1. Inline service definition - pass a plain function as `service` along with
+ *    `alias`, `description`, and `input` in the config
+ * 2. Pre-instantiated Service - pass a Service object as `service`
+ *
+ * When a pre-instantiated Service is passed, config fields act as overrides:
+ * - `alias` overrides service.alias
+ * - `description` overrides service.description
+ * - `input` overrides service.input
+ *
+ * The original Service is never mutated - a new Service is created when overrides
+ * are applied.
+ *
+ * @example
+ * ```typescript
+ * // Inline service definition
+ * const service = resolveService({
+ *   alias: "greet",
+ *   description: "Greet a user",
+ *   input: { name: { type: String } },
+ *   service: ({ name }) => `Hello, ${name}!`,
+ * });
+ *
+ * // Pre-instantiated with override
+ * const baseService = fabricService({ alias: "foo", service: (x) => x });
+ * const overridden = resolveService({
+ *   alias: "bar",  // Override alias
+ *   service: baseService,
+ * });
+ * ```
+ */
+function resolveService(config) {
+    const { alias, description, input, service } = config;
+    if (isService$1(service)) {
+        // Service is pre-instantiated - config fields act as overrides
+        // Create new Service with merged properties (config overrides service)
+        return fabricService({
+            alias: alias ?? service.alias,
+            description: description ?? service.description,
+            input: input ?? service.input,
+            service: service.service,
+        });
+    }
+    // Service is an inline function - create Service from config
+    return fabricService({
+        alias,
+        description,
+        input,
+        service,
+    });
+}
+
+// Lambda Service adapter for @jaypie/fabric
+/**
+ * Type guard to check if a value is a pre-instantiated Service
+ * A Service is a function with the `$fabric` property set by fabricService
+ */
+function isService(value) {
+    return typeof value === "function" && "$fabric" in value;
+}
+/**
+ * Type guard to check if a value is a config object (has service property)
+ */
+function isConfig(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "service" in value &&
+        typeof value.service === "function");
+}
+/**
+ * Fabric a Lambda handler that wraps a service
+ *
+ * This function creates a Lambda-compatible handler that:
+ * - Uses getMessages() to extract messages from SQS/SNS events
+ * - Calls the service once for each message
+ * - Returns the single response if one message, or an array of responses if multiple
+ * - Integrates with lambdaHandler for lifecycle management (secrets, setup, teardown, etc.)
+ *
+ * @param serviceOrConfig - The service function or configuration object
+ * @param options - Lambda handler options (secrets, setup, teardown, etc.)
+ * @returns A Lambda handler function
+ *
+ * @example
+ * ```typescript
+ * import { fabricLambda } from "@jaypie/fabric/lambda";
+ * import { myService } from "./services";
+ *
+ * // Direct service style
+ * export const handler = fabricLambda(myService);
+ *
+ * // Config object style
+ * export const handler2 = fabricLambda({
+ *   service: myService,
+ *   secrets: ["ANTHROPIC_API_KEY", "OPENAI_API_KEY"],
+ * });
+ *
+ * // Service with options style
+ * export const handler3 = fabricLambda(myService, {
+ *   secrets: ["ANTHROPIC_API_KEY"],
+ * });
+ * ```
+ */
+function fabricLambda(serviceOrConfig, options = {}) {
+    // Normalize arguments and resolve service
+    let service;
+    let opts;
+    if (isConfig(serviceOrConfig)) {
+        // Config object with service property
+        const { alias, description, input, service: configService, ...configOpts } = serviceOrConfig;
+        // Resolve inline service or apply overrides
+        service = resolveService({
+            alias,
+            description,
+            input,
+            service: configService,
+        });
+        opts = configOpts;
+    }
+    else if (isService(serviceOrConfig)) {
+        // Pre-instantiated Service passed directly
+        service = serviceOrConfig;
+        opts = options;
+    }
+    else {
+        // Plain function passed directly - wrap it
+        service = resolveService({ service: serviceOrConfig });
+        opts = options;
+    }
+    // Use service.alias as the name for logging (can be overridden via options.name)
+    const name = opts.name ?? service.alias;
+    // Create context callbacks that wrap the registration callbacks with error swallowing
+    // Callback failures should never halt service execution
+    const sendMessage = opts.onMessage
+        ? async (message) => {
+            try {
+                await opts.onMessage(message);
+            }
+            catch {
+                // Swallow errors - callback failures should not halt execution
+            }
+        }
+        : undefined;
+    const contextOnError = opts.onError
+        ? async (error) => {
+            try {
+                await opts.onError(error);
+            }
+            catch {
+                // Swallow errors - callback failures should not halt execution
+            }
+        }
+        : undefined;
+    const contextOnFatal = opts.onFatal
+        ? async (error) => {
+            try {
+                await opts.onFatal(error);
+            }
+            catch {
+                // Swallow errors - callback failures should not halt execution
+            }
+        }
+        : undefined;
+    // Create context for the service
+    const context = {
+        onError: contextOnError,
+        onFatal: contextOnFatal,
+        sendMessage,
+    };
+    // Create the inner Lambda handler logic (context param required for lambdaHandler signature)
+    const innerHandler = async (event, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _context) => {
+        // Extract messages from SQS/SNS event wrapper
+        const messages = aws.getMessages(event);
+        // Process each message through the service
+        const results = [];
+        for (const message of messages) {
+            try {
+                const result = await service(message, context);
+                results.push(result);
+            }
+            catch (error) {
+                // Any thrown error is fatal - call onFatal or onError as fallback
+                if (opts.onFatal) {
+                    await opts.onFatal(error);
+                }
+                else if (opts.onError) {
+                    await opts.onError(error);
+                }
+                // Re-throw to let lambdaHandler handle it
+                throw error;
+            }
+        }
+        // Call onComplete if provided
+        const response = results.length === 1 ? results[0] : results;
+        if (opts.onComplete) {
+            try {
+                await opts.onComplete(response);
+            }
+            catch {
+                // Swallow errors - callback failures should not halt execution
+            }
+        }
+        return response;
+    };
+    // Wrap with lambdaHandler for lifecycle management
+    return lambda.lambdaHandler(innerHandler, {
+        chaos: opts.chaos,
+        name,
+        secrets: opts.secrets,
+        setup: opts.setup,
+        teardown: opts.teardown,
+        throw: opts.throw,
+        unavailable: opts.unavailable,
+        validate: opts.validate,
+    });
+}
+
+exports.fabricLambda = fabricLambda;
+//# sourceMappingURL=index.cjs.map