@revealui/core 0.0.1-pre.3 → 0.2.0

package/dist/error-handling/retry.js

@@ -0,0 +1,450 @@
+/**
+ * Retry Logic for API Calls
+ *
+ * Implements exponential backoff and retry strategies
+ */
+import { logger } from '../observability/logger.js';
+const DEFAULT_CONFIG = {
+    maxRetries: 3,
+    baseDelay: 1000,
+    maxDelay: 30000,
+    exponentialBackoff: true,
+    jitter: true,
+    retryableErrors: (error) => {
+        // Check for explicit non-retryable status codes (4xx client errors)
+        if ('statusCode' in error) {
+            const statusCode = error.statusCode;
+            // Don't retry 4xx errors except 408 (timeout) and 429 (rate limit)
+            if (statusCode !== undefined && statusCode >= 400 && statusCode < 500) {
+                return statusCode === 408 || statusCode === 429;
+            }
+        }
+        // Retry all other errors by default (network errors, 5xx, generic errors)
+        return true;
+    },
+    onRetry: () => { },
+};
+/**
+ * Retry a function with exponential backoff
+ */
+export async function retry(fn, config = {}, options = {}) {
+    const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+    let lastError;
+    for (let attempt = 0; attempt <= mergedConfig.maxRetries; attempt++) {
+        try {
+            // Check if aborted
+            if (options.signal?.aborted) {
+                throw new Error('Request aborted');
+            }
+            return await fn();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            // Don't retry if it's the last attempt
+            if (attempt === mergedConfig.maxRetries) {
+                throw lastError;
+            }
+            // Don't retry if error is not retryable
+            if (!mergedConfig.retryableErrors(lastError)) {
+                throw lastError;
+            }
+            // Call retry callback
+            mergedConfig.onRetry(lastError, attempt + 1);
+            // Calculate delay
+            const delay = calculateDelay(attempt, mergedConfig.baseDelay, mergedConfig.maxDelay, mergedConfig.exponentialBackoff, mergedConfig.jitter);
+            // Wait before retrying
+            await sleep(delay, options.signal);
+        }
+    }
+    throw lastError;
+}
+/**
+ * Calculate retry delay with exponential backoff
+ */
+export function calculateDelay(attempt, baseDelay, maxDelay, exponentialBackoff, jitter) {
+    let delay = baseDelay;
+    if (exponentialBackoff) {
+        // Exponential backoff: 2^attempt * baseDelay
+        delay = Math.min(baseDelay * 2 ** attempt, maxDelay);
+    }
+    if (jitter) {
+        // Add random jitter (±25%)
+        const jitterAmount = delay * 0.25;
+        delay = delay + (Math.random() * jitterAmount * 2 - jitterAmount);
+    }
+    return Math.floor(delay);
+}
+/**
+ * Sleep with abort support
+ */
+export function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(new Error('Request aborted'));
+            return;
+        }
+        const timeout = setTimeout(resolve, ms);
+        if (signal) {
+            signal.addEventListener('abort', () => {
+                clearTimeout(timeout);
+                reject(new Error('Request aborted'));
+            });
+        }
+    });
+}
+/**
+ * Retry wrapper for fetch
+ */
+export async function fetchWithRetry(url, init, config) {
+    const abortController = new AbortController();
+    const signal = init?.signal || abortController.signal;
+    return retry(async () => {
+        const response = await fetch(url, {
+            ...init,
+            signal,
+        });
+        // Throw on error status
+        if (!response.ok) {
+            const error = new Error(`HTTP ${response.status}: ${response.statusText}`);
+            error.statusCode = response.status;
+            error.response = response;
+            throw error;
+        }
+        return response;
+    }, {
+        ...config,
+        retryableErrors: (error) => {
+            // Check custom retryable errors first
+            if (config?.retryableErrors && !config.retryableErrors(error)) {
+                return false;
+            }
+            // Don't retry 4xx errors (except 408, 429)
+            if ('statusCode' in error) {
+                const statusCode = error.statusCode;
+                if (statusCode !== undefined && statusCode >= 400 && statusCode < 500) {
+                    return statusCode === 408 || statusCode === 429;
+                }
+            }
+            return true;
+        },
+    }, { signal });
+}
+/**
+ * Retry wrapper class
+ */
+export class RetryableOperation {
+    fn;
+    config;
+    abortController;
+    attempts = 0;
+    lastError;
+    constructor(fn, config = {}) {
+        this.fn = fn;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.abortController = new AbortController();
+    }
+    /**
+     * Execute with retry
+     */
+    async execute() {
+        return retry(this.fn, this.config, { signal: this.abortController.signal });
+    }
+    /**
+     * Abort operation
+     */
+    abort() {
+        this.abortController.abort();
+    }
+    /**
+     * Get retry statistics
+     */
+    getStats() {
+        return {
+            attempts: this.attempts,
+            lastError: this.lastError,
+        };
+    }
+}
+/**
+ * Retry decorator
+ */
+export function Retryable(config) {
+    return (_target, _propertyKey, descriptor) => {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            return retry(() => originalMethod.apply(this, args), config);
+        };
+        return descriptor;
+    };
+}
+/**
+ * Create retry middleware for API client
+ */
+export function createRetryMiddleware(config = {}) {
+    return async (_request, next) => {
+        return retry(next, config);
+    };
+}
+/**
+ * Batch retry - retry multiple operations
+ */
+export async function retryBatch(operations, config = {}) {
+    return Promise.all(operations.map(async (op) => {
+        try {
+            return await retry(op, config);
+        }
+        catch (error) {
+            return error instanceof Error ? error : new Error(String(error));
+        }
+    }));
+}
+/**
+ * Retry with fallback
+ */
+export async function retryWithFallback(primary, fallback, config = {}) {
+    try {
+        return await retry(primary, config);
+    }
+    catch (error) {
+        logger.warn('Primary operation failed, trying fallback', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return fallback();
+    }
+}
+/**
+ * Conditional retry - only retry if condition is met
+ */
+export async function retryIf(fn, condition, config = {}) {
+    return retry(fn, {
+        ...config,
+        retryableErrors: (error) => {
+            // Check original retryable condition first
+            const originalCheck = config.retryableErrors?.(error) ?? DEFAULT_CONFIG.retryableErrors(error);
+            if (!originalCheck)
+                return false;
+            // Then check custom condition
+            return condition(error, 0);
+        },
+    });
+}
+/**
+ * Retry until condition is met
+ */
+export async function retryUntil(fn, predicate, config = {}, maxAttempts = 10) {
+    let attempts = 0;
+    while (attempts < maxAttempts) {
+        try {
+            const result = await fn();
+            if (predicate(result)) {
+                return result;
+            }
+            // Result doesn't match predicate, treat as retryable error
+            attempts++;
+            if (attempts >= maxAttempts) {
+                throw new Error('Max attempts reached without matching predicate');
+            }
+            const delay = calculateDelay(attempts - 1, config.baseDelay || DEFAULT_CONFIG.baseDelay, config.maxDelay || DEFAULT_CONFIG.maxDelay, config.exponentialBackoff ?? DEFAULT_CONFIG.exponentialBackoff, config.jitter ?? DEFAULT_CONFIG.jitter);
+            await sleep(delay);
+        }
+        catch (error) {
+            attempts++;
+            if (attempts >= maxAttempts) {
+                throw error;
+            }
+            const delay = calculateDelay(attempts - 1, config.baseDelay || DEFAULT_CONFIG.baseDelay, config.maxDelay || DEFAULT_CONFIG.maxDelay, config.exponentialBackoff ?? DEFAULT_CONFIG.exponentialBackoff, config.jitter ?? DEFAULT_CONFIG.jitter);
+            await sleep(delay);
+        }
+    }
+    throw new Error('Max attempts reached');
+}
+/**
+ * Exponential backoff iterator
+ */
+export class ExponentialBackoff {
+    baseDelay;
+    maxDelay;
+    maxAttempts;
+    jitter;
+    constructor(baseDelay = 1000, maxDelay = 30000, maxAttempts = 10, jitter = true) {
+        this.baseDelay = baseDelay;
+        this.maxDelay = maxDelay;
+        this.maxAttempts = maxAttempts;
+        this.jitter = jitter;
+    }
+    async *[Symbol.asyncIterator]() {
+        for (let attempt = 0; attempt < this.maxAttempts; attempt++) {
+            const delay = calculateDelay(attempt, this.baseDelay, this.maxDelay, true, this.jitter);
+            yield delay;
+            await sleep(delay);
+        }
+    }
+}
+/**
+ * Retry policy builder
+ */
+export class RetryPolicyBuilder {
+    config = {};
+    /**
+     * Set max retries
+     */
+    maxRetries(count) {
+        this.config.maxRetries = count;
+        return this;
+    }
+    /**
+     * Set base delay
+     */
+    baseDelay(ms) {
+        this.config.baseDelay = ms;
+        return this;
+    }
+    /**
+     * Set max delay
+     */
+    maxDelay(ms) {
+        this.config.maxDelay = ms;
+        return this;
+    }
+    /**
+     * Enable/disable exponential backoff
+     */
+    exponentialBackoff(enabled = true) {
+        this.config.exponentialBackoff = enabled;
+        return this;
+    }
+    /**
+     * Enable/disable jitter
+     */
+    jitter(enabled = true) {
+        this.config.jitter = enabled;
+        return this;
+    }
+    /**
+     * Set custom retryable errors function
+     */
+    retryOn(fn) {
+        this.config.retryableErrors = fn;
+        return this;
+    }
+    /**
+     * Set retry callback
+     */
+    onRetry(fn) {
+        this.config.onRetry = fn;
+        return this;
+    }
+    /**
+     * Build retry config
+     */
+    build() {
+        return this.config;
+    }
+    /**
+     * Execute function with built policy
+     */
+    async execute(fn) {
+        return retry(fn, this.build());
+    }
+}
+/**
+ * Common retry policies
+ */
+export const RetryPolicies = {
+    /**
+     * Default policy - 3 retries with exponential backoff
+     */
+    default: () => ({
+        maxRetries: 3,
+        baseDelay: 1000,
+        maxDelay: 30000,
+        exponentialBackoff: true,
+        jitter: true,
+    }),
+    /**
+     * Aggressive policy - more retries, faster backoff
+     */
+    aggressive: () => ({
+        maxRetries: 5,
+        baseDelay: 500,
+        maxDelay: 10000,
+        exponentialBackoff: true,
+        jitter: true,
+    }),
+    /**
+     * Conservative policy - fewer retries, longer backoff
+     */
+    conservative: () => ({
+        maxRetries: 2,
+        baseDelay: 2000,
+        maxDelay: 60000,
+        exponentialBackoff: true,
+        jitter: true,
+    }),
+    /**
+     * Linear backoff policy
+     */
+    linear: () => ({
+        maxRetries: 3,
+        baseDelay: 1000,
+        maxDelay: 10000,
+        exponentialBackoff: false,
+        jitter: false,
+    }),
+    /**
+     * Immediate retry policy - no delay
+     */
+    immediate: () => ({
+        maxRetries: 3,
+        baseDelay: 0,
+        maxDelay: 0,
+        exponentialBackoff: false,
+        jitter: false,
+    }),
+    /**
+     * Network error only policy
+     */
+    networkOnly: () => ({
+        maxRetries: 3,
+        baseDelay: 1000,
+        maxDelay: 30000,
+        exponentialBackoff: true,
+        jitter: true,
+        retryableErrors: (error) => error.name === 'NetworkError',
+    }),
+    /**
+     * Idempotent operations policy (safe to retry)
+     */
+    idempotent: () => ({
+        maxRetries: 5,
+        baseDelay: 1000,
+        maxDelay: 30000,
+        exponentialBackoff: true,
+        jitter: true,
+    }),
+};
+/**
+ * Global retry configuration
+ */
+class GlobalRetryConfig {
+    config = RetryPolicies.default();
+    /**
+     * Set global retry config
+     */
+    setConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Get global retry config
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * Reset to default config
+     */
+    reset() {
+        this.config = RetryPolicies.default();
+    }
+}
+export const globalRetryConfig = new GlobalRetryConfig();

package/dist/errors/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * RevealUI CMS Errors
+ * @module @revealui/core/errors
+ */
+export declare class RevealUIError extends Error {
+    constructor(message: string);
+}
+export declare class MissingEditorProp extends RevealUIError {
+    constructor(fieldName?: string);
+}
+export declare class ValidationError extends RevealUIError {
+    constructor(message: string);
+}
+export declare class ConfigurationError extends RevealUIError {
+    constructor(message: string);
+}
+export declare class AccessDeniedError extends RevealUIError {
+    constructor(message?: string);
+}
+export declare class NotFoundError extends RevealUIError {
+    constructor(resource?: string);
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/errors/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,iBAAkB,SAAQ,aAAa;gBACtC,SAAS,CAAC,EAAE,MAAM;CAI/B;AAED,qBAAa,eAAgB,SAAQ,aAAa;gBACpC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,kBAAmB,SAAQ,aAAa;gBACvC,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,iBAAkB,SAAQ,aAAa;gBACtC,OAAO,SAAkB;CAItC;AAED,qBAAa,aAAc,SAAQ,aAAa;gBAClC,QAAQ,CAAC,EAAE,MAAM;CAI9B"}

package/dist/errors/index.js

@@ -0,0 +1,40 @@
+/**
+ * RevealUI CMS Errors
+ * @module @revealui/core/errors
+ */
+export class RevealUIError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RevealUIError';
+    }
+}
+export class MissingEditorProp extends RevealUIError {
+    constructor(fieldName) {
+        super(`Missing editor prop${fieldName ? ` for field: ${fieldName}` : ''}`);
+        this.name = 'MissingEditorProp';
+    }
+}
+export class ValidationError extends RevealUIError {
+    constructor(message) {
+        super(message);
+        this.name = 'ValidationError';
+    }
+}
+export class ConfigurationError extends RevealUIError {
+    constructor(message) {
+        super(message);
+        this.name = 'ConfigurationError';
+    }
+}
+export class AccessDeniedError extends RevealUIError {
+    constructor(message = 'Access denied') {
+        super(message);
+        this.name = 'AccessDeniedError';
+    }
+}
+export class NotFoundError extends RevealUIError {
+    constructor(resource) {
+        super(`${resource || 'Resource'} not found`);
+        this.name = 'NotFoundError';
+    }
+}

package/dist/factories/builders.d.ts

@@ -0,0 +1,50 @@
+import type { RevealConfig, RevealUIAccessRule, RevealUIBlock, RevealUICollectionConfig, RevealUIField, RevealUIInstance } from '../types/index.js';
+/**
+ * Factory Functions
+ *
+ * Helper functions for creating RevealUI configuration objects.
+ */
+/**
+ * Creates a RevealUI instance (wrapper around createRevealUIInstance for backward compatibility)
+ */
+export declare function createRevealUI(config: RevealConfig): Promise<RevealUIInstance>;
+/**
+ * Creates a collection configuration with defaults
+ */
+export declare function createRevealUICollection(options: {
+    slug: string;
+    fields: RevealUIField[];
+    revealUI?: RevealUICollectionConfig['revealUI'];
+    access?: RevealUICollectionConfig['access'];
+}): RevealUICollectionConfig;
+/**
+ * Creates a field configuration with defaults
+ */
+export declare function createRevealUIField(options: {
+    name: string;
+    type: RevealUIField['type'];
+    label?: string;
+    required?: boolean;
+    revealUI?: RevealUIField['revealUI'];
+    admin?: RevealUIField['admin'];
+    validate?: RevealUIField['validate'];
+}): RevealUIField;
+/**
+ * Creates a block configuration with defaults
+ */
+export declare function createRevealUIBlock(options: {
+    slug: string;
+    fields: RevealUIField[];
+    revealUI?: RevealUIBlock['revealUI'];
+    labels?: RevealUIBlock['labels'];
+}): RevealUIBlock;
+/**
+ * Creates an access rule configuration
+ */
+export declare function createRevealUIAccessRule(options: {
+    tenant?: string;
+    user?: string;
+    permissions?: RevealUIAccessRule['permissions'];
+    condition?: RevealUIAccessRule['condition'];
+}): RevealUIAccessRule;
+//# sourceMappingURL=builders.d.ts.map

package/dist/factories/builders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builders.d.ts","sourceRoot":"","sources":["../../src/factories/builders.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EACZ,kBAAkB,EAClB,aAAa,EACb,wBAAwB,EACxB,aAAa,EACb,gBAAgB,EACjB,MAAM,mBAAmB,CAAA;AAE1B;;;;GAIG;AAEH;;GAEG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAEpF;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE;IAChD,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB,QAAQ,CAAC,EAAE,wBAAwB,CAAC,UAAU,CAAC,CAAA;IAC/C,MAAM,CAAC,EAAE,wBAAwB,CAAC,QAAQ,CAAC,CAAA;CAC5C,GAAG,wBAAwB,CAY3B;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE;IAC3C,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,QAAQ,CAAC,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;IACpC,KAAK,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;IAC9B,QAAQ,CAAC,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;CACrC,GAAG,aAAa,CAiBhB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE;IAC3C,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB,QAAQ,CAAC,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;IACpC,MAAM,CAAC,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;CACjC,GAAG,aAAa,CAahB;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE;IAChD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,kBAAkB,CAAC,aAAa,CAAC,CAAA;IAC/C,SAAS,CAAC,EAAE,kBAAkB,CAAC,WAAW,CAAC,CAAA;CAC5C,GAAG,kBAAkB,CAOrB"}

package/dist/factories/builders.js

@@ -0,0 +1,77 @@
+import { createRevealUIInstance } from '../instance/RevealUIInstance.js';
+/**
+ * Factory Functions
+ *
+ * Helper functions for creating RevealUI configuration objects.
+ */
+/**
+ * Creates a RevealUI instance (wrapper around createRevealUIInstance for backward compatibility)
+ */
+export async function createRevealUI(config) {
+    return createRevealUIInstance(config);
+}
+/**
+ * Creates a collection configuration with defaults
+ */
+export function createRevealUICollection(options) {
+    return {
+        slug: options.slug,
+        fields: options.fields,
+        revealUI: {
+            tenantScoped: false,
+            auditLog: false,
+            permissions: ['read', 'update'],
+            ...(options.revealUI || {}),
+        },
+        access: options.access,
+    };
+}
+/**
+ * Creates a field configuration with defaults
+ */
+export function createRevealUIField(options) {
+    return {
+        name: options.name,
+        type: options.type,
+        label: options.label,
+        required: options.required,
+        revealUI: {
+            searchable: false,
+            permissions: ['read', 'update'],
+            tenantScoped: false,
+            auditLog: false,
+            validation: [],
+            ...options.revealUI,
+        },
+        admin: options.admin,
+        validate: options.validate,
+    };
+}
+/**
+ * Creates a block configuration with defaults
+ */
+export function createRevealUIBlock(options) {
+    return {
+        slug: options.slug,
+        fields: options.fields,
+        revealUI: {
+            category: 'content',
+            icon: 'block',
+            permissions: ['read', 'update'],
+            tenantScoped: false,
+            ...options.revealUI,
+        },
+        labels: options.labels,
+    };
+}
+/**
+ * Creates an access rule configuration
+ */
+export function createRevealUIAccessRule(options) {
+    return {
+        tenant: options.tenant,
+        user: options.user,
+        permissions: options.permissions,
+        condition: options.condition,
+    };
+}

package/dist/factories/index.d.ts

@@ -0,0 +1,2 @@
+export { createRevealUI, createRevealUIAccessRule, createRevealUIBlock, createRevealUICollection, createRevealUIField, } from './builders.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/factories/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/factories/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,wBAAwB,EACxB,mBAAmB,EACnB,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,eAAe,CAAA"}

package/dist/factories/index.js

@@ -0,0 +1 @@
+export { createRevealUI, createRevealUIAccessRule, createRevealUIBlock, createRevealUICollection, createRevealUIField, } from './builders.js';