@jaypie/fabric 0.1.0

package/dist/cjs/data/index.cjs

@@ -0,0 +1,1575 @@
+'use strict';
+
+var errors = require('@jaypie/errors');
+
+// #region Constants
+/**
+ * Default pagination limit for list operations
+ */
+const DEFAULT_LIMIT = 20;
+/**
+ * Maximum pagination limit
+ */
+const MAX_LIMIT = 100;
+// #endregion
+
+/**
+ * Default scope value (APEX)
+ */
+const APEX = "@";
+/**
+ * Extract ID from path parameters
+ */
+function extractId(context) {
+    return context.params.id;
+}
+/**
+ * Extract scope context from HTTP context
+ */
+function extractScopeContext(context) {
+    return {
+        body: context.body,
+        params: context.params,
+        query: context.query,
+    };
+}
+/**
+ * Calculate scope from scope configuration
+ */
+async function calculateScopeFromConfig(scopeConfig, context) {
+    if (scopeConfig === undefined) {
+        return APEX;
+    }
+    if (typeof scopeConfig === "string") {
+        return scopeConfig;
+    }
+    const scopeContext = extractScopeContext(context);
+    return scopeConfig(scopeContext);
+}
+/**
+ * Transform HTTP context to create operation input
+ * Extracts body fields for entity creation
+ */
+function transformCreate(context) {
+    const body = context.body;
+    return { ...body };
+}
+/**
+ * Transform HTTP context to read operation input
+ * Extracts ID from path parameters
+ */
+function transformRead(context) {
+    const id = extractId(context);
+    if (!id) {
+        throw new Error("Missing id parameter");
+    }
+    return { id };
+}
+/**
+ * Transform HTTP context to update operation input
+ * Extracts ID from path and merges with body
+ */
+function transformUpdate(context) {
+    const id = extractId(context);
+    if (!id) {
+        throw new Error("Missing id parameter");
+    }
+    const body = context.body;
+    return { id, ...body };
+}
+/**
+ * Transform HTTP context to delete operation input
+ * Extracts ID from path parameters
+ */
+function transformDelete(context) {
+    const id = extractId(context);
+    if (!id) {
+        throw new Error("Missing id parameter");
+    }
+    return { id };
+}
+/**
+ * Transform HTTP context to archive operation input
+ * Extracts ID from path parameters
+ */
+function transformArchive(context) {
+    const id = extractId(context);
+    if (!id) {
+        throw new Error("Missing id parameter");
+    }
+    return { id };
+}
+/**
+ * Transform HTTP context to list operation input
+ * Extracts pagination options from query string
+ */
+function transformList(context, defaultLimit = DEFAULT_LIMIT, maxLimit = MAX_LIMIT) {
+    const query = context.query;
+    // Parse limit with bounds
+    let limit = defaultLimit;
+    const limitParam = query.get("limit");
+    if (limitParam) {
+        const parsed = parseInt(limitParam, 10);
+        if (!isNaN(parsed) && parsed > 0) {
+            limit = Math.min(parsed, maxLimit);
+        }
+    }
+    // Parse cursor
+    const startKey = query.get("cursor") ?? query.get("startKey") ?? undefined;
+    // Parse sort order
+    const ascending = query.get("ascending") === "true" || query.get("sort") === "asc";
+    // Parse archived/deleted flags
+    const archived = query.get("archived") === "true";
+    const deleted = query.get("deleted") === "true";
+    return {
+        archived,
+        ascending,
+        deleted,
+        limit,
+        startKey,
+    };
+}
+/**
+ * Transform HTTP context to execute operation input
+ * Extracts ID from path and merges with body
+ */
+function transformExecute(context) {
+    const id = extractId(context);
+    if (!id) {
+        throw new Error("Missing id parameter");
+    }
+    const body = context.body;
+    return { id, ...body };
+}
+/**
+ * Pluralize a model alias for route paths
+ * Simple pluralization: adds 's' unless already ends in 's'
+ */
+function pluralize(alias) {
+    if (alias.endsWith("s")) {
+        return alias;
+    }
+    // Handle common irregular plurals
+    if (alias.endsWith("y")) {
+        return alias.slice(0, -1) + "ies";
+    }
+    if (alias.endsWith("x") || alias.endsWith("ch") || alias.endsWith("sh")) {
+        return alias + "es";
+    }
+    return alias + "s";
+}
+/**
+ * Capitalize first letter of string
+ */
+function capitalize(str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Encode pagination cursor for client response
+ */
+function encodeCursor(lastEvaluatedKey) {
+    if (!lastEvaluatedKey) {
+        return undefined;
+    }
+    return Buffer.from(JSON.stringify(lastEvaluatedKey)).toString("base64");
+}
+/**
+ * Decode pagination cursor from client request
+ */
+function decodeCursor(cursor) {
+    if (!cursor) {
+        return undefined;
+    }
+    try {
+        const decoded = Buffer.from(cursor, "base64").toString("utf-8");
+        return JSON.parse(decoded);
+    }
+    catch {
+        return undefined;
+    }
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Extract token from Authorization header
+ * Removes "Bearer " prefix (case insensitive) and strips whitespace
+ *
+ * Examples:
+ * - "Bearer eyJhbGc..." → "eyJhbGc..."
+ * - "bearer eyJhbGc..." → "eyJhbGc..."
+ * - "BEARER eyJhbGc..." → "eyJhbGc..."
+ * - "eyJhbGc..." → "eyJhbGc..."
+ * - "  eyJhbGc...  " → "eyJhbGc..."
+ */
+function extractToken(authHeader) {
+    if (!authHeader) {
+        return "";
+    }
+    let token = authHeader.trim();
+    // Remove "Bearer " prefix (case insensitive)
+    const bearerRegex = /^bearer\s+/i;
+    if (bearerRegex.test(token)) {
+        token = token.replace(bearerRegex, "");
+    }
+    return token.trim();
+}
+/**
+ * Get authorization header from Headers object
+ */
+function getAuthHeader(headers) {
+    return headers.get("authorization");
+}
+/**
+ * Validate authorization and return auth context
+ *
+ * @param headers - Request headers
+ * @param config - Authorization configuration (function or false)
+ * @returns Auth context from the authorization function, or undefined if public
+ * @throws UnauthorizedError if authorization fails
+ */
+async function validateAuthorization(headers, config) {
+    // Public endpoint - no authorization required
+    if (config === false) {
+        return undefined;
+    }
+    const authHeader = getAuthHeader(headers);
+    const token = extractToken(authHeader);
+    // If authorization is required but no token provided
+    if (!token) {
+        throw new errors.UnauthorizedError("Authorization header required");
+    }
+    // Call the authorization function
+    const authFunction = config;
+    return authFunction(token);
+}
+
+/**
+ * Default HTTP transformation function
+ * Merges query parameters with body (body takes precedence)
+ */
+const defaultHttpTransform = ({ body, query, }) => {
+    const queryObject = Object.fromEntries(query.entries());
+    const bodyObject = typeof body === "object" && body !== null ? body : {};
+    return {
+        ...queryObject,
+        ...bodyObject,
+    };
+};
+
+/**
+ * Check if a value is a fabricService (has $fabric property)
+ */
+function isFabricService(value) {
+    return (typeof value === "function" &&
+        "$fabric" in value &&
+        typeof value.$fabric === "string");
+}
+/**
+ * Create an HTTP-aware fabric service
+ *
+ * Extends fabricService with:
+ * - HTTP context transformation (body, headers, method, path, query, params)
+ * - Authorization handling (token extraction from Authorization header)
+ * - CORS configuration (enabled by default)
+ *
+ * Accepts either:
+ * - Inline service definition (with `service` function)
+ * - Pre-built `fabricService` instance (via `service` property)
+ */
+function fabricHttp(config) {
+    const { authorization = false, cors = true, http = defaultHttpTransform, service: serviceConfig, stream = false, ...baseConfig } = config;
+    // Resolve the underlying service
+    let underlyingService;
+    if (isFabricService(serviceConfig)) {
+        // Pre-built fabricService - merge configs
+        underlyingService = serviceConfig;
+        // Merge base config properties from the pre-built service
+        if (baseConfig.alias === undefined &&
+            underlyingService.alias !== undefined) {
+            baseConfig.alias = underlyingService.alias;
+        }
+        if (baseConfig.description === undefined &&
+            underlyingService.description !== undefined) {
+            baseConfig.description = underlyingService.description;
+        }
+        if (baseConfig.input === undefined &&
+            underlyingService.input !== undefined) {
+            baseConfig.input = underlyingService.input;
+        }
+    }
+    else {
+        // Inline service definition or plain function
+        const serviceFunction = serviceConfig;
+        underlyingService = fabricService({
+            ...baseConfig,
+            service: serviceFunction,
+        });
+    }
+    // Create the HTTP handler that processes HTTP context
+    const httpHandler = async (input, context) => {
+        // If context has HTTP info, process authorization
+        // (HTTP context is added by the adapter layer like fabricExpress)
+        if (context?.http && authorization !== false) {
+            const authResult = await validateAuthorization(context.http.headers, authorization);
+            // Add auth result to context
+            context.auth = authResult;
+        }
+        // Call the underlying service
+        return underlyingService(input, context);
+    };
+    // Create the HTTP service with all properties
+    const httpService = httpHandler;
+    // Copy properties from config (which may have been merged with underlying service)
+    httpService.$fabric = underlyingService.$fabric;
+    // Use baseConfig values (which include overrides) or fall back to underlying service
+    const resolvedAlias = baseConfig.alias ?? underlyingService.alias;
+    const resolvedDescription = baseConfig.description ?? underlyingService.description;
+    const resolvedInput = baseConfig.input ?? underlyingService.input;
+    if (resolvedAlias !== undefined) {
+        httpService.alias = resolvedAlias;
+    }
+    if (resolvedDescription !== undefined) {
+        httpService.description = resolvedDescription;
+    }
+    if (resolvedInput !== undefined) {
+        httpService.input = resolvedInput;
+    }
+    if (underlyingService.service !== undefined) {
+        httpService.service = underlyingService.service;
+    }
+    // Add HTTP-specific properties
+    httpService.authorization = authorization;
+    httpService.cors = cors;
+    httpService.http = http;
+    httpService.stream = stream;
+    return httpService;
+}
+
+/**
+ * Create the "archive" service for a FabricData endpoint
+ * POST /{model}/:id/archive - Archive an entity
+ */
+function createArchiveService(modelConfig, operationConfig, globalConfig) {
+    const { alias, name } = modelConfig;
+    return fabricHttp({
+        alias: `archive-${alias}`,
+        description: `Archive a ${name}`,
+        input: {
+            id: { type: String, description: `${name} ID` },
+        },
+        authorization: operationConfig.authorization ?? globalConfig.authorization,
+        cors: globalConfig.cors,
+        http: operationConfig.http ?? transformArchive,
+        service: async (input) => {
+            // Dynamically import DynamoDB utilities
+            const { archiveEntity, getEntity } = await import('@jaypie/dynamodb');
+            const id = input.id;
+            if (!id) {
+                throw new errors.BadRequestError("ID is required");
+            }
+            // Check if entity exists
+            const existing = await getEntity({ id, model: alias });
+            if (!existing) {
+                throw new errors.NotFoundError(`${name} not found`);
+            }
+            // Archive the entity
+            const archived = await archiveEntity({ id, model: alias });
+            if (!archived) {
+                throw new errors.NotFoundError(`${name} not found`);
+            }
+            // Fetch the updated entity to return
+            const updated = await getEntity({ id, model: alias });
+            return updated;
+        },
+    });
+}
+
+/**
+ * Create the "create" service for a FabricData endpoint
+ * POST /{model} - Create a new entity
+ */
+function createCreateService(modelConfig, operationConfig, globalConfig) {
+    const { alias, name } = modelConfig;
+    return fabricHttp({
+        alias: `create-${alias}`,
+        description: `Create a new ${name}`,
+        authorization: operationConfig.authorization ?? globalConfig.authorization,
+        cors: globalConfig.cors,
+        http: operationConfig.http ?? transformCreate,
+        service: async (input, context) => {
+            // Dynamically import DynamoDB utilities
+            const { putEntity } = await import('@jaypie/dynamodb');
+            // Calculate scope
+            const scopeConfig = globalConfig.scope;
+            const httpContext = context?.http;
+            const scope = httpContext
+                ? await calculateScopeFromConfig(scopeConfig, httpContext)
+                : "@";
+            // Validate required fields
+            if (!input || typeof input !== "object") {
+                throw new errors.BadRequestError("Request body is required");
+            }
+            // Apply transform if configured
+            let entityInput = input;
+            if (operationConfig.transform) {
+                entityInput = {
+                    ...entityInput,
+                    ...operationConfig.transform(entityInput, null),
+                };
+            }
+            // Build the entity
+            const now = new Date().toISOString();
+            const entity = {
+                ...entityInput,
+                createdAt: now,
+                id: crypto.randomUUID(),
+                model: alias,
+                name: entityInput.name ?? name,
+                scope,
+                sequence: Date.now(),
+                updatedAt: now,
+            };
+            // Create the entity
+            const created = await putEntity({ entity });
+            return created;
+        },
+    });
+}
+
+/**
+ * Create the "delete" service for a FabricData endpoint
+ * DELETE /{model}/:id - Soft delete an entity
+ */
+function createDeleteService(modelConfig, operationConfig, globalConfig) {
+    const { alias, name } = modelConfig;
+    return fabricHttp({
+        alias: `delete-${alias}`,
+        description: `Delete a ${name}`,
+        input: {
+            id: { type: String, description: `${name} ID` },
+        },
+        authorization: operationConfig.authorization ?? globalConfig.authorization,
+        cors: globalConfig.cors,
+        http: operationConfig.http ?? transformDelete,
+        service: async (input) => {
+            // Dynamically import DynamoDB utilities
+            const { deleteEntity, getEntity } = await import('@jaypie/dynamodb');
+            const id = input.id;
+            if (!id) {
+                throw new errors.BadRequestError("ID is required");
+            }
+            // Check if entity exists
+            const existing = await getEntity({ id, model: alias });
+            if (!existing) {
+                throw new errors.NotFoundError(`${name} not found`);
+            }
+            // Soft delete the entity
+            const deleted = await deleteEntity({ id, model: alias });
+            if (!deleted) {
+                throw new errors.NotFoundError(`${name} not found`);
+            }
+            // Return success (no content)
+            return null;
+        },
+    });
+}
+
+/**
+ * Create an "execute" service for a custom action
+ * POST /{model}/:id/{alias} - Execute a custom action on an entity
+ */
+function createExecuteService(modelConfig, executeConfig, globalConfig) {
+    const { alias: modelAlias, name: modelName } = modelConfig;
+    const { alias: actionAlias, authorization, description, input: inputDefinition, service: actionService, } = executeConfig;
+    return fabricHttp({
+        alias: `${modelAlias}-${actionAlias}`,
+        description: description ?? `${actionAlias} action on ${modelName}`,
+        input: {
+            id: { type: String, description: `${modelName} ID` },
+            ...inputDefinition,
+        },
+        authorization: authorization ?? globalConfig.authorization,
+        cors: globalConfig.cors,
+        http: transformExecute,
+        service: async (input) => {
+            // Dynamically import DynamoDB utilities
+            const { getEntity } = await import('@jaypie/dynamodb');
+            const id = input.id;
+            const { id: _id, ...actionInput } = input;
+            if (!id) {
+                throw new errors.BadRequestError("ID is required");
+            }
+            // Fetch the entity
+            const entity = await getEntity({ id, model: modelAlias });
+            if (!entity) {
+                throw new errors.NotFoundError(`${modelName} not found`);
+            }
+            // Execute the action
+            const result = await actionService(entity, actionInput);
+            return result;
+        },
+    });
+}
+
+/**
+ * Create the "list" service for a FabricData endpoint
+ * GET /{model} - List entities with pagination
+ */
+function createListService(modelConfig, operationConfig, globalConfig) {
+    const { alias, name, pluralAlias } = modelConfig;
+    const defaultLimit = globalConfig.defaultLimit ?? DEFAULT_LIMIT;
+    const maxLimit = globalConfig.maxLimit ?? MAX_LIMIT;
+    // Build the HTTP transform function
+    const httpTransform = operationConfig.http ??
+        ((context) => transformList(context, defaultLimit, maxLimit));
+    return fabricHttp({
+        alias: `list-${pluralAlias}`,
+        description: `List ${name} entities`,
+        input: {
+            archived: {
+                type: Boolean,
+                default: false,
+                required: false,
+                description: "Include archived entities",
+            },
+            ascending: {
+                type: Boolean,
+                default: false,
+                required: false,
+                description: "Sort ascending by sequence",
+            },
+            cursor: {
+                type: String,
+                required: false,
+                description: "Pagination cursor",
+            },
+            deleted: {
+                type: Boolean,
+                default: false,
+                required: false,
+                description: "Include deleted entities",
+            },
+            limit: {
+                type: Number,
+                default: defaultLimit,
+                required: false,
+                description: `Number of items per page (max: ${maxLimit})`,
+            },
+        },
+        authorization: operationConfig.authorization ?? globalConfig.authorization,
+        cors: globalConfig.cors,
+        http: httpTransform,
+        service: async (input, context) => {
+            // Dynamically import DynamoDB utilities
+            const { queryByScope } = await import('@jaypie/dynamodb');
+            // Calculate scope
+            const scopeConfig = globalConfig.scope;
+            const httpContext = context?.http;
+            const scope = httpContext
+                ? await calculateScopeFromConfig(scopeConfig, httpContext)
+                : "@";
+            // Parse input with defaults
+            const archived = input.archived ?? false;
+            const ascending = input.ascending ?? false;
+            const deleted = input.deleted ?? false;
+            const limit = Math.min(input.limit ?? defaultLimit, maxLimit);
+            const startKey = decodeCursor(input.cursor ?? input.startKey);
+            // Query entities
+            const result = await queryByScope({
+                archived,
+                ascending,
+                deleted,
+                limit,
+                model: alias,
+                scope,
+                startKey,
+            });
+            // Build response
+            const response = {
+                items: result.items,
+                nextKey: encodeCursor(result.lastEvaluatedKey),
+            };
+            return response;
+        },
+    });
+}
+
+/**
+ * Create the "read" service for a FabricData endpoint
+ * GET /{model}/:id - Get a single entity by ID
+ */
+function createReadService(modelConfig, operationConfig, globalConfig) {
+    const { alias, name } = modelConfig;
+    return fabricHttp({
+        alias: `read-${alias}`,
+        description: `Get a ${name} by ID`,
+        input: {
+            id: { type: String, description: `${name} ID` },
+        },
+        authorization: operationConfig.authorization ?? globalConfig.authorization,
+        cors: globalConfig.cors,
+        http: operationConfig.http ?? transformRead,
+        service: async (input) => {
+            // Dynamically import DynamoDB utilities
+            const { getEntity } = await import('@jaypie/dynamodb');
+            const id = input.id;
+            if (!id) {
+                throw new errors.BadRequestError("ID is required");
+            }
+            // Fetch the entity
+            const entity = await getEntity({ id, model: alias });
+            if (!entity) {
+                throw new errors.NotFoundError(`${name} not found`);
+            }
+            return entity;
+        },
+    });
+}
+
+/**
+ * Create the "update" service for a FabricData endpoint
+ * POST /{model}/:id - Update an existing entity
+ */
+function createUpdateService(modelConfig, operationConfig, globalConfig) {
+    const { alias, name } = modelConfig;
+    return fabricHttp({
+        alias: `update-${alias}`,
+        description: `Update a ${name}`,
+        input: {
+            id: { type: String, description: `${name} ID` },
+        },
+        authorization: operationConfig.authorization ?? globalConfig.authorization,
+        cors: globalConfig.cors,
+        http: operationConfig.http ?? transformUpdate,
+        service: async (input) => {
+            // Dynamically import DynamoDB utilities
+            const { getEntity, updateEntity } = await import('@jaypie/dynamodb');
+            const id = input.id;
+            const { id: _id, ...updateData } = input;
+            if (!id) {
+                throw new errors.BadRequestError("ID is required");
+            }
+            // Fetch existing entity
+            const existing = await getEntity({ id, model: alias });
+            if (!existing) {
+                throw new errors.NotFoundError(`${name} not found`);
+            }
+            // Apply transform if configured
+            let entityUpdate = updateData;
+            if (operationConfig.transform) {
+                entityUpdate = {
+                    ...entityUpdate,
+                    ...operationConfig.transform(updateData, existing),
+                };
+            }
+            // Build the updated entity
+            const entity = {
+                ...existing,
+                ...entityUpdate,
+                // Preserve immutable fields
+                createdAt: existing.createdAt,
+                id: existing.id,
+                model: existing.model,
+                scope: existing.scope,
+                sequence: existing.sequence,
+            };
+            // Update the entity
+            const updated = await updateEntity({ entity });
+            return updated;
+        },
+    });
+}
+
+/**
+ * Resolve model configuration from string or object
+ */
+function resolveModelConfig(model) {
+    if (typeof model === "string") {
+        return {
+            alias: model,
+            description: undefined,
+            name: capitalize(model),
+            pluralAlias: pluralize(model),
+        };
+    }
+    return {
+        alias: model.alias,
+        description: model.description,
+        name: model.name ?? capitalize(model.alias),
+        pluralAlias: pluralize(model.alias),
+    };
+}
+/**
+ * Resolve operation configuration from boolean or object
+ */
+function resolveOperationConfig(option, defaultEnabled = true) {
+    // Undefined means use defaults (enabled)
+    if (option === undefined) {
+        return { enabled: defaultEnabled };
+    }
+    // Boolean means enabled/disabled with defaults
+    if (typeof option === "boolean") {
+        return { enabled: option };
+    }
+    // Object config
+    return {
+        authorization: option.authorization,
+        enabled: option.enabled !== false,
+        http: option.http,
+        transform: option.transform,
+    };
+}
+/**
+ * Create CRUD HTTP services for a Jaypie model backed by DynamoDB
+ *
+ * Generates standard operations:
+ * - POST /{model} - Create
+ * - GET /{model} - List
+ * - GET /{model}/:id - Read
+ * - POST /{model}/:id - Update
+ * - DELETE /{model}/:id - Delete
+ * - POST /{model}/:id/archive - Archive
+ * - POST /{model}/:id/{action} - Custom execute actions
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const recordServices = FabricData({ model: "record" });
+ *
+ * // With authorization
+ * const recordServices = FabricData({
+ *   model: "record",
+ *   authorization: validateToken,
+ *   operations: {
+ *     read: { authorization: false }, // Public read
+ *     delete: { authorization: requireAdmin },
+ *     archive: false, // Disabled
+ *   },
+ * });
+ *
+ * // Use with FabricHttpServer
+ * const server = new FabricHttpServer({
+ *   services: recordServices.services,
+ *   prefix: "/api",
+ * });
+ * ```
+ */
+function FabricData(config) {
+    const modelConfig = resolveModelConfig(config.model);
+    const { alias, pluralAlias } = modelConfig;
+    const services = [];
+    // Resolve operation configs
+    const operations = config.operations ?? {};
+    // Create operation
+    const createOp = resolveOperationConfig(operations.create);
+    if (createOp.enabled) {
+        services.push(createCreateService(modelConfig, createOp, config));
+    }
+    // List operation
+    const listOp = resolveOperationConfig(operations.list);
+    if (listOp.enabled) {
+        services.push(createListService(modelConfig, listOp, config));
+    }
+    // Read operation
+    const readOp = resolveOperationConfig(operations.read);
+    if (readOp.enabled) {
+        services.push(createReadService(modelConfig, readOp, config));
+    }
+    // Update operation
+    const updateOp = resolveOperationConfig(operations.update);
+    if (updateOp.enabled) {
+        services.push(createUpdateService(modelConfig, updateOp, config));
+    }
+    // Delete operation
+    const deleteOp = resolveOperationConfig(operations.delete);
+    if (deleteOp.enabled) {
+        services.push(createDeleteService(modelConfig, deleteOp, config));
+    }
+    // Archive operation
+    const archiveOp = resolveOperationConfig(operations.archive);
+    if (archiveOp.enabled) {
+        services.push(createArchiveService(modelConfig, archiveOp, config));
+    }
+    // Execute actions
+    if (config.execute) {
+        for (const executeConfig of config.execute) {
+            services.push(createExecuteService(modelConfig, executeConfig, config));
+        }
+    }
+    return {
+        model: alias,
+        prefix: `/${pluralAlias}`,
+        services,
+    };
+}
+/**
+ * Check if a value is a FabricDataResult
+ */
+function isFabricDataResult(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const obj = value;
+    return (typeof obj.model === "string" &&
+        typeof obj.prefix === "string" &&
+        Array.isArray(obj.services));
+}
+
+exports.APEX = APEX;
+exports.DEFAULT_LIMIT = DEFAULT_LIMIT;
+exports.FabricData = FabricData;
+exports.MAX_LIMIT = MAX_LIMIT;
+exports.calculateScopeFromConfig = calculateScopeFromConfig;
+exports.capitalize = capitalize;
+exports.createArchiveService = createArchiveService;
+exports.createCreateService = createCreateService;
+exports.createDeleteService = createDeleteService;
+exports.createExecuteService = createExecuteService;
+exports.createListService = createListService;
+exports.createReadService = createReadService;
+exports.createUpdateService = createUpdateService;
+exports.decodeCursor = decodeCursor;
+exports.encodeCursor = encodeCursor;
+exports.extractId = extractId;
+exports.extractScopeContext = extractScopeContext;
+exports.isFabricDataResult = isFabricDataResult;
+exports.pluralize = pluralize;
+exports.transformArchive = transformArchive;
+exports.transformCreate = transformCreate;
+exports.transformDelete = transformDelete;
+exports.transformExecute = transformExecute;
+exports.transformList = transformList;
+exports.transformRead = transformRead;
+exports.transformUpdate = transformUpdate;
+//# sourceMappingURL=index.cjs.map