@revealui/core 0.0.1-pre.4 → 0.2.1

package/dist/utils/field-conversion.js

@@ -0,0 +1,275 @@
+/**
+ * Field Conversion Utilities
+ *
+ * Converts between standard Field types and RevealUIField types.
+ *
+ * NOTE ON TYPE ASSERTIONS:
+ * The type assertions in this file are necessary due to TypeScript's limitation
+ * with narrowing separate variables. Here's why:
+ *
+ * 1. `baseField` is initialized as `RevealUIField` (a union type) or `Field` (a union type)
+ * 2. TypeScript can narrow `field` or `revealUIField` in conditionals/switches
+ * 3. However, TypeScript CANNOT narrow `baseField` because it's a separate variable
+ *    that was explicitly typed, not derived from the narrowed value
+ *
+ * The assertions (`as RevealUITextField`, etc.) are used to tell TypeScript that
+ * after type narrowing checks, we're assigning type-specific properties that exist
+ * on the narrowed type but not on the base union type.
+ *
+ * Alternative approaches considered:
+ * - Returning different object literals per type: Would work but duplicates code
+ * - Using type predicates on baseField: Not possible without runtime checks
+ * - Restructuring to avoid mutations: Would require significant refactoring
+ *
+ * These assertions are safe because they're guarded by runtime type checks
+ * (isTextField, isArrayField, switch on field.type).
+ */
+import { isArrayField, isTextField } from '@revealui/contracts/cms';
+const getFieldLabel = (field) => {
+    if (typeof field.label === 'string' && field.label.length > 0) {
+        return field.label;
+    }
+    if (typeof field.name === 'string' && field.name.length > 0) {
+        return field.name;
+    }
+    return 'Field';
+};
+// Convert from standard field to RevealUI field
+export function convertToRevealUIField(field) {
+    const labelText = getFieldLabel(field);
+    const baseField = {
+        name: field.name || '',
+        type: field.type,
+        label: field.label,
+        required: field.required,
+        revealUI: {
+            searchable: false,
+            permissions: ['read', 'write'],
+            tenantScoped: false,
+            auditLog: false,
+            validation: field.required
+                ? [
+                    {
+                        type: 'required',
+                        message: `${labelText} is required`,
+                    },
+                ]
+                : [],
+        },
+        admin: field.admin,
+        validate: field.validate
+            ? (value, args) => {
+                // Pass through the validation args directly
+                // Field.validate expects (value, args) where args is FieldValidateArgs
+                if (field.validate) {
+                    const result = field.validate(value, args);
+                    if (result === true || typeof result === 'string') {
+                        return result;
+                    }
+                    return true;
+                }
+                return true;
+            }
+            : undefined,
+    };
+    // Add type-specific properties using type guards and switch narrowing
+    // NOTE: Type assertions are necessary here because TypeScript cannot narrow
+    // `baseField` even though we've narrowed `field`. See file-level comment.
+    if (isTextField(field)) {
+        // TypeScript narrows field to TextField here, but baseField remains RevealUIField
+        // Assertion is safe because we've verified field.type === 'text'
+        const textBaseField = baseField;
+        textBaseField.maxLength = field.maxLength;
+        textBaseField.minLength = field.minLength;
+    }
+    else if (isArrayField(field)) {
+        // TypeScript narrows field to ArrayField here, but baseField remains RevealUIField
+        // Assertion is safe because we've verified field.type === 'array'
+        const arrayBaseField = baseField;
+        if (field.fields) {
+            arrayBaseField.fields = field.fields.map((f) => convertToRevealUIField(f));
+        }
+        arrayBaseField.minRows = field.minRows;
+        arrayBaseField.maxRows = field.maxRows;
+    }
+    else {
+        // Use switch for types without type guards
+        switch (field.type) {
+            case 'checkbox': {
+                // TypeScript narrows field in switch statement, but baseField needs assertion
+                // Assertion on field is needed because CheckboxField might not be properly discriminated
+                const checkboxBaseField = baseField;
+                checkboxBaseField.defaultValue = field.defaultValue;
+                break;
+            }
+            case 'richText': {
+                // TypeScript narrows field in switch statement, but baseField needs assertion
+                // Assertion on field is needed because RichTextField might not be properly discriminated
+                const richTextBaseField = baseField;
+                richTextBaseField.editor = field.editor;
+                break;
+            }
+        }
+    }
+    return baseField;
+}
+// Convert from RevealUI field to standard field
+export function convertFromRevealUIField(revealUIField) {
+    const baseField = {
+        name: revealUIField.name || '',
+        type: revealUIField.type,
+        label: revealUIField.label,
+        required: revealUIField.required,
+        admin: revealUIField.admin,
+        validate: revealUIField.validate
+            ? (value, args) => {
+                // Pass through the validation args directly
+                // RevealUIField.validate should accept FieldValidateArgs
+                if (revealUIField.validate) {
+                    const result = revealUIField.validate(value, args);
+                    if (result === true || typeof result === 'string') {
+                        return result;
+                    }
+                    return true;
+                }
+                return true;
+            }
+            : undefined,
+    };
+    // Add type-specific properties using type guards and switch narrowing
+    // NOTE: Type assertions are necessary here because TypeScript cannot narrow
+    // `baseField` even though we've narrowed `revealUIField`. See file-level comment.
+    if (revealUIField.type === 'text') {
+        // TypeScript narrows revealUIField to RevealUITextField, but baseField remains Field
+        // Assertions are safe because we've verified revealUIField.type === 'text'
+        const textBaseField = baseField;
+        const textField = revealUIField;
+        textBaseField.maxLength = textField.maxLength;
+        textBaseField.minLength = textField.minLength;
+    }
+    else if (revealUIField.type === 'array') {
+        // TypeScript narrows revealUIField to RevealUIArrayField, but baseField remains Field
+        // Assertions are safe because we've verified revealUIField.type === 'array'
+        const arrayBaseField = baseField;
+        const arrayField = revealUIField;
+        if (arrayField.fields) {
+            // Convert RevealUIField[] to Field[] - this is safe because RevealUIField extends Field
+            arrayBaseField.fields = arrayField.fields.map((f) => convertFromRevealUIField(f));
+        }
+        arrayBaseField.minRows = arrayField.minRows;
+        arrayBaseField.maxRows = arrayField.maxRows;
+    }
+    else {
+        // Use switch for types without type guards
+        switch (revealUIField.type) {
+            case 'checkbox': {
+                // TypeScript narrows revealUIField in switch statement, but baseField needs assertion
+                // Assertion on revealUIField is needed because RevealUICheckboxField might not be properly discriminated
+                const checkboxBaseField = baseField;
+                checkboxBaseField.defaultValue = revealUIField.defaultValue;
+                break;
+            }
+            case 'richText': {
+                // TypeScript narrows revealUIField in switch statement, but baseField needs assertion
+                // Assertion on revealUIField is needed because RevealUIRichTextField might not be properly discriminated
+                const richTextBaseField = baseField;
+                richTextBaseField.editor = revealUIField.editor;
+                break;
+            }
+        }
+    }
+    return baseField;
+}
+// Enhance a standard field with RevealUI features
+export function enhanceFieldWithRevealUI(field, revealUIOptions) {
+    const revealUIField = convertToRevealUIField(field);
+    if (revealUIOptions) {
+        revealUIField.revealUI = {
+            ...revealUIField.revealUI,
+            ...revealUIOptions,
+        };
+    }
+    return revealUIField;
+}
+// Validate a RevealUI field
+export function validateRevealUIField(field, value, context) {
+    const labelText = getFieldLabel(field);
+    // Run RevealUI-specific validations
+    if (field.revealUI?.validation) {
+        for (const rule of field.revealUI.validation) {
+            // Convert context to RevealUIHookContext for rule validation
+            const hookContext = {
+                revealui: undefined,
+                operation: context.operation,
+                user: context.user,
+                tenant: context.tenant || '',
+            };
+            switch (rule.type) {
+                case 'required':
+                    if (!value) {
+                        return rule.message || `${labelText} is required`;
+                    }
+                    break;
+                case 'min':
+                    {
+                        const minValue = typeof rule.value === 'number' ? rule.value : undefined;
+                        // For string values, check length
+                        if (typeof value === 'string' && minValue !== undefined && value.length < minValue) {
+                            return rule.message || `${labelText} must be at least ${minValue} characters`;
+                        }
+                        // For number values, check value
+                        if (typeof value === 'number' && minValue !== undefined && value < minValue) {
+                            return rule.message || `${labelText} must be at least ${minValue}`;
+                        }
+                    }
+                    break;
+                case 'max':
+                    {
+                        const maxValue = typeof rule.value === 'number' ? rule.value : undefined;
+                        // For string values, check length
+                        if (typeof value === 'string' && maxValue !== undefined && value.length > maxValue) {
+                            return rule.message || `${labelText} must be no more than ${maxValue} characters`;
+                        }
+                        // For number values, check value
+                        if (typeof value === 'number' && maxValue !== undefined && value > maxValue) {
+                            return rule.message || `${labelText} must be no more than ${maxValue}`;
+                        }
+                    }
+                    break;
+                case 'pattern':
+                    if (typeof value === 'string' &&
+                        rule.value instanceof RegExp &&
+                        !rule.value.test(value)) {
+                        return rule.message || `${labelText} format is invalid`;
+                    }
+                    break;
+                case 'custom':
+                    if (rule.validate) {
+                        const result = rule.validate(value, hookContext);
+                        if (result !== true) {
+                            return typeof result === 'string' ? result : `${labelText} is invalid`;
+                        }
+                    }
+                    break;
+            }
+        }
+    }
+    // Run the original field validator if it exists
+    if (field.validate) {
+        // Convert context to FieldValidateArgs format
+        const validateArgs = {
+            value,
+            data: context.data,
+            siblingData: context.siblingData,
+            req: {
+                user: context.user,
+            },
+            operation: context.operation,
+        };
+        const result = field.validate(value, validateArgs);
+        if (result !== true) {
+            return typeof result === 'string' ? result : `${labelText} is invalid`;
+        }
+    }
+    return true;
+}

package/dist/utils/flattenResult.d.ts

@@ -0,0 +1,7 @@
+import type { RevealDocument } from '../types/index.js';
+/**
+ * Flattens SQL result with dotted notation into nested objects
+ * e.g., { 'author.title': 'John', 'author.id': 1 } -> { author: { title: 'John', id: 1 } }
+ */
+export declare function flattenResult(doc: RevealDocument): RevealDocument;
+//# sourceMappingURL=flattenResult.d.ts.map

package/dist/utils/flattenResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flattenResult.d.ts","sourceRoot":"","sources":["../../src/utils/flattenResult.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,cAAc,GAAG,cAAc,CAoBjE"}

package/dist/utils/flattenResult.js

@@ -0,0 +1,23 @@
+/**
+ * Flattens SQL result with dotted notation into nested objects
+ * e.g., { 'author.title': 'John', 'author.id': 1 } -> { author: { title: 'John', id: 1 } }
+ */
+export function flattenResult(doc) {
+    const result = { ...doc };
+    for (const key of Object.keys(doc)) {
+        if (key.includes('.')) {
+            const parts = key.split('.', 2);
+            const parentKey = parts[0];
+            const childKey = parts[1];
+            if (parentKey && childKey) {
+                if (!result[parentKey]) {
+                    result[parentKey] = {};
+                }
+                ;
+                result[parentKey][childKey] = doc[key];
+                Reflect.deleteProperty(result, key);
+            }
+        }
+    }
+    return result;
+}

package/dist/utils/getBlockSelect.d.ts

@@ -0,0 +1,12 @@
+import type { SelectType } from '../types/index.js';
+/**
+ * Gets the select configuration for a specific block
+ */
+export declare const getBlockSelect: ({ block, select, selectMode, }: {
+    block: {
+        slug: string;
+    };
+    select: SelectType;
+    selectMode: "include" | "exclude";
+}) => SelectType | undefined;
+//# sourceMappingURL=getBlockSelect.d.ts.map

package/dist/utils/getBlockSelect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getBlockSelect.d.ts","sourceRoot":"","sources":["../../src/utils/getBlockSelect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAEnD;;GAEG;AACH,eAAO,MAAM,cAAc,GAAI,gCAI5B;IACD,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAA;IACvB,MAAM,EAAE,UAAU,CAAA;IAClB,UAAU,EAAE,SAAS,GAAG,SAAS,CAAA;CAClC,KAAG,UAAU,GAAG,SAShB,CAAA"}

package/dist/utils/getBlockSelect.js

@@ -0,0 +1,12 @@
+/**
+ * Gets the select configuration for a specific block
+ */
+export const getBlockSelect = ({ block, select, selectMode, }) => {
+    if (!select || selectMode === 'exclude')
+        return undefined;
+    const blockSelect = select[block.slug];
+    if (typeof blockSelect === 'object' && blockSelect !== null) {
+        return blockSelect;
+    }
+    return undefined;
+};

package/dist/utils/getSelectMode.d.ts

@@ -0,0 +1,8 @@
+import type { SelectMode, SelectType } from '../types/index.js';
+/**
+ * Determines if a select object is in 'include' or 'exclude' mode
+ * - include: only specified fields are included
+ * - exclude: all fields except specified are included
+ */
+export declare const getSelectMode: (select: SelectType) => SelectMode;
+//# sourceMappingURL=getSelectMode.d.ts.map

package/dist/utils/getSelectMode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSelectMode.d.ts","sourceRoot":"","sources":["../../src/utils/getSelectMode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAE/D;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,UAAU,KAAG,UAgBlD,CAAA"}

package/dist/utils/getSelectMode.js

@@ -0,0 +1,21 @@
+/**
+ * Determines if a select object is in 'include' or 'exclude' mode
+ * - include: only specified fields are included
+ * - exclude: all fields except specified are included
+ */
+export const getSelectMode = (select) => {
+    for (const selectValue of Object.values(select)) {
+        if (selectValue === false) {
+            return 'exclude';
+        }
+        if (typeof selectValue === 'object' && selectValue !== null && !Array.isArray(selectValue)) {
+            // Recursively check nested objects - if any nested object is exclude mode, return exclude
+            const nestedMode = getSelectMode(selectValue);
+            if (nestedMode === 'exclude') {
+                return 'exclude';
+            }
+            // Continue checking other keys even if this nested object is include mode
+        }
+    }
+    return 'include';
+};

package/dist/utils/isValidID.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Validates if an ID is valid based on the ID type
+ */
+export declare const isValidID: (id: unknown, idType?: "number" | "text") => boolean;
+//# sourceMappingURL=isValidID.d.ts.map

package/dist/utils/isValidID.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isValidID.d.ts","sourceRoot":"","sources":["../../src/utils/isValidID.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,SAAS,GAAI,IAAI,OAAO,EAAE,SAAQ,QAAQ,GAAG,MAAe,KAAG,OAW3E,CAAA"}

package/dist/utils/isValidID.js

@@ -0,0 +1,13 @@
+/**
+ * Validates if an ID is valid based on the ID type
+ */
+export const isValidID = (id, idType = 'text') => {
+    if (idType === 'number') {
+        return typeof id === 'number' && !Number.isNaN(id) && Number.isFinite(id);
+    }
+    // For text IDs, allow strings and convert numbers to strings
+    if (typeof id === 'number') {
+        return !Number.isNaN(id) && Number.isFinite(id);
+    }
+    return typeof id === 'string' && id.length > 0;
+};

package/dist/utils/json-parsing.d.ts

@@ -0,0 +1,48 @@
+/**
+ * JSON Parsing Utilities
+ *
+ * Utilities for serializing and deserializing JSON fields in database operations.
+ * Handles the _json column pattern used for storing complex field types.
+ */
+import type { RevealDocument } from '../types/index.js';
+/**
+ * Parse a JSON field value safely
+ *
+ * @param value - Value to parse (may be string or already parsed object)
+ * @returns Parsed value or original value if not JSON
+ */
+export declare function parseJsonField(value: unknown): unknown;
+/**
+ * Deserialize JSON fields from database document
+ *
+ * Handles the _json column pattern:
+ * - PostgreSQL JSONB returns as object
+ * - SQLite TEXT returns as string
+ * - Merges _json fields into document
+ * - Removes _json column from result
+ * - Deserializes other JSON strings (backwards compatibility)
+ *
+ * @param doc - Raw document from database
+ * @param tableName - Table name (for logging)
+ * @returns Deserialized document
+ */
+export declare function deserializeJsonFields(doc: Record<string, unknown>, tableName?: string): RevealDocument;
+/**
+ * Collect JSON fields into an object for the _json column
+ *
+ * @param data - Data object
+ * @param jsonFieldNames - Set of field names that should be stored as JSON
+ * @returns Object containing JSON fields
+ */
+export declare function collectJsonFields(data: Record<string, unknown>, jsonFieldNames: Set<string>): Record<string, unknown>;
+/**
+ * Serialize a value for database storage
+ *
+ * Converts objects and arrays to JSON strings for SQLite compatibility.
+ * Primitives are returned as-is.
+ *
+ * @param value - Value to serialize
+ * @returns Serialized value (string for objects/arrays, otherwise original value)
+ */
+export declare function serializeValueForDatabase(value: unknown): unknown;
+//# sourceMappingURL=json-parsing.d.ts.map

package/dist/utils/json-parsing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-parsing.d.ts","sourceRoot":"","sources":["../../src/utils/json-parsing.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAEvD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAetD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,SAAS,CAAC,EAAE,MAAM,GACjB,cAAc,CA2DhB;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,GAC1B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAUzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CASjE"}

package/dist/utils/json-parsing.js

@@ -0,0 +1,130 @@
+/**
+ * JSON Parsing Utilities
+ *
+ * Utilities for serializing and deserializing JSON fields in database operations.
+ * Handles the _json column pattern used for storing complex field types.
+ */
+import { defaultLogger } from '../instance/logger.js';
+/**
+ * Parse a JSON field value safely
+ *
+ * @param value - Value to parse (may be string or already parsed object)
+ * @returns Parsed value or original value if not JSON
+ */
+export function parseJsonField(value) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (typeof value === 'string' && (value.startsWith('{') || value.startsWith('['))) {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            // Not valid JSON, keep as string
+            return value;
+        }
+    }
+    return value;
+}
+/**
+ * Deserialize JSON fields from database document
+ *
+ * Handles the _json column pattern:
+ * - PostgreSQL JSONB returns as object
+ * - SQLite TEXT returns as string
+ * - Merges _json fields into document
+ * - Removes _json column from result
+ * - Deserializes other JSON strings (backwards compatibility)
+ *
+ * @param doc - Raw document from database
+ * @param tableName - Table name (for logging)
+ * @returns Deserialized document
+ */
+export function deserializeJsonFields(doc, tableName) {
+    // Ensure id field exists (required by RevealDocument type)
+    const rawId = doc.id;
+    const fallbackId = rawId === null || rawId === undefined
+        ? ''
+        : typeof rawId === 'string' ||
+            typeof rawId === 'number' ||
+            typeof rawId === 'boolean' ||
+            typeof rawId === 'bigint'
+            ? String(rawId)
+            : '';
+    const result = {
+        id: typeof rawId === 'string' || typeof rawId === 'number' ? rawId : fallbackId,
+        ...doc,
+    };
+    // Handle _json column: deserialize and merge JSON fields into document
+    if (result._json !== null && result._json !== undefined) {
+        try {
+            // PostgreSQL JSONB returns as object, SQLite TEXT returns as string
+            const jsonFields = typeof result._json === 'string' ? JSON.parse(result._json) : result._json;
+            // Merge JSON fields into document
+            if (jsonFields && typeof jsonFields === 'object') {
+                Object.assign(result, jsonFields);
+            }
+        }
+        catch (error) {
+            // Invalid JSON - log for debugging but continue
+            defaultLogger.warn(`Failed to parse _json in ${tableName || 'unknown'}:`, error);
+        }
+    }
+    // Remove _json from result (internal column)
+    Reflect.deleteProperty(result, '_json');
+    // Deserialize other JSON strings (for backwards compatibility with non-JSON fields)
+    for (const [key, value] of Object.entries(result)) {
+        if (value === null || value === undefined) {
+            result[key] = value;
+            continue;
+        }
+        // Check for JSON string pattern
+        if (typeof value === 'string' && (value.startsWith('{') || value.startsWith('['))) {
+            try {
+                const parsed = JSON.parse(value);
+                result[key] = parsed;
+            }
+            catch {
+                // Not valid JSON, keep as string
+                result[key] = value;
+            }
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Collect JSON fields into an object for the _json column
+ *
+ * @param data - Data object
+ * @param jsonFieldNames - Set of field names that should be stored as JSON
+ * @returns Object containing JSON fields
+ */
+export function collectJsonFields(data, jsonFieldNames) {
+    const jsonData = {};
+    jsonFieldNames.forEach((name) => {
+        if (name in data && data[name] !== undefined) {
+            jsonData[name] = data[name];
+        }
+    });
+    return jsonData;
+}
+/**
+ * Serialize a value for database storage
+ *
+ * Converts objects and arrays to JSON strings for SQLite compatibility.
+ * Primitives are returned as-is.
+ *
+ * @param value - Value to serialize
+ * @returns Serialized value (string for objects/arrays, otherwise original value)
+ */
+export function serializeValueForDatabase(value) {
+    if (value !== null &&
+        value !== undefined &&
+        (typeof value === 'object' || Array.isArray(value))) {
+        return JSON.stringify(value);
+    }
+    return value;
+}

package/dist/utils/jwt-validation.d.ts

@@ -0,0 +1,14 @@
+/**
+ * JWT Validation Utilities
+ *
+ * Utilities for validating JWT tokens from RevealRequest objects.
+ */
+import type { RevealRequest } from '../types/index.js';
+/**
+ * Validate JWT token from request authorization header
+ *
+ * @param req - RevealRequest object
+ * @throws Error if token is invalid or expired
+ */
+export declare function validateJWTFromRequest(req?: RevealRequest): Promise<void>;
+//# sourceMappingURL=jwt-validation.d.ts.map

package/dist/utils/jwt-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwt-validation.d.ts","sourceRoot":"","sources":["../../src/utils/jwt-validation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAGtD;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,GAAG,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CA4B/E"}

package/dist/utils/jwt-validation.js

@@ -0,0 +1,36 @@
+/**
+ * JWT Validation Utilities
+ *
+ * Utilities for validating JWT tokens from RevealRequest objects.
+ */
+import { jwtVerify } from 'jose';
+import { extractAuthHeader } from './request-headers.js';
+/**
+ * Validate JWT token from request authorization header
+ *
+ * @param req - RevealRequest object
+ * @throws Error if token is invalid or expired
+ */
+export async function validateJWTFromRequest(req) {
+    const authHeader = extractAuthHeader(req);
+    if (!authHeader || typeof authHeader !== 'string') {
+        return; // No auth header, skip validation
+    }
+    // Extract token from "JWT <token>" format
+    if (!authHeader.startsWith('JWT ')) {
+        return; // Not a JWT token, skip validation
+    }
+    const token = authHeader.substring(4);
+    const secret = process.env.REVEALUI_SECRET;
+    if (!secret || secret.length < 32) {
+        throw new Error('REVEALUI_SECRET must be set to a secure random value (minimum 32 characters). ' +
+            'Generate one with: openssl rand -base64 32');
+    }
+    try {
+        await jwtVerify(token, new TextEncoder().encode(secret));
+    }
+    catch (_error) {
+        // Token is invalid, expired, or tampered
+        throw new Error('Invalid or expired token');
+    }
+}