@revealui/core 0.0.1-pre.4 → 0.2.0

package/dist/api/compression.js

@@ -0,0 +1,233 @@
+/**
+ * API Response Compression Middleware
+ *
+ * Implements gzip and brotli compression for API responses
+ */
+import { NextResponse } from 'next/server';
+import { logger } from '../observability/logger.js';
+const DEFAULT_OPTIONS = {
+    threshold: 1024, // 1KB minimum
+    level: 6, // Balanced compression
+    preferBrotli: true,
+    excludeTypes: [
+        'image/png',
+        'image/jpeg',
+        'image/gif',
+        'image/webp',
+        'video/mp4',
+        'application/zip',
+        'application/gzip',
+        'application/pdf',
+    ],
+};
+/**
+ * Check if response should be compressed
+ */
+function shouldCompress(response, options) {
+    const contentType = response.headers.get('content-type') || '';
+    const contentLength = parseInt(response.headers.get('content-length') || '0', 10);
+    // Check if already compressed
+    if (response.headers.get('content-encoding')) {
+        return false;
+    }
+    // Check content type exclusions
+    if (options.excludeTypes?.some((type) => contentType.includes(type))) {
+        return false;
+    }
+    // Check size threshold
+    if (contentLength > 0 && contentLength < (options.threshold || 0)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Get best compression encoding from Accept-Encoding header
+ */
+function getBestEncoding(request, preferBrotli) {
+    const acceptEncoding = request.headers.get('accept-encoding') || '';
+    const supportsBrotli = acceptEncoding.includes('br');
+    const supportsGzip = acceptEncoding.includes('gzip');
+    if (preferBrotli && supportsBrotli) {
+        return 'br';
+    }
+    if (supportsGzip) {
+        return 'gzip';
+    }
+    if (supportsBrotli) {
+        return 'br';
+    }
+    return null;
+}
+/**
+ * Compress response body
+ */
+async function compressBody(body, encoding, _level) {
+    const textEncoder = new TextEncoder();
+    const data = typeof body === 'string' ? textEncoder.encode(body) : body;
+    if (encoding === 'gzip') {
+        // Use CompressionStream API (available in modern environments)
+        const stream = new Response(data).body?.pipeThrough(new CompressionStream('gzip'));
+        const compressed = await new Response(stream).arrayBuffer();
+        return new Uint8Array(compressed);
+    }
+    if (encoding === 'br') {
+        // Brotli compression
+        // Note: CompressionStream('deflate-raw') is available, but not 'br' in all environments
+        // Fallback to gzip if brotli not available
+        try {
+            const stream = new Response(data).body?.pipeThrough(new CompressionStream('deflate'));
+            const compressed = await new Response(stream).arrayBuffer();
+            return new Uint8Array(compressed);
+        }
+        catch {
+            // Fallback to gzip
+            const stream = new Response(data).body?.pipeThrough(new CompressionStream('gzip'));
+            const compressed = await new Response(stream).arrayBuffer();
+            return new Uint8Array(compressed);
+        }
+    }
+    return data;
+}
+/**
+ * Compress API response
+ */
+export async function compressResponse(request, response, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    // Check if should compress
+    if (!shouldCompress(response, opts)) {
+        return response;
+    }
+    // Get best encoding
+    const encoding = getBestEncoding(request, opts.preferBrotli ?? true);
+    if (!encoding) {
+        return response;
+    }
+    try {
+        // Get response body
+        const body = await response.text();
+        // Compress body
+        const compressed = await compressBody(body, encoding, opts.level || 6);
+        // Create new response with compressed body
+        const newResponse = new NextResponse(compressed, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+        });
+        // Set compression headers
+        newResponse.headers.set('content-encoding', encoding);
+        newResponse.headers.set('content-length', compressed.length.toString());
+        newResponse.headers.delete('content-length'); // Let runtime set it
+        newResponse.headers.set('vary', 'Accept-Encoding');
+        return newResponse;
+    }
+    catch (error) {
+        logger.error('Compression error', error instanceof Error ? error : new Error(String(error)));
+        return response;
+    }
+}
+/**
+ * Create compression middleware
+ */
+export function createCompressionMiddleware(options = {}) {
+    return async (request, next) => {
+        const response = await next();
+        return compressResponse(request, response, options);
+    };
+}
+/**
+ * Calculate compression ratio
+ */
+export function getCompressionRatio(originalSize, compressedSize) {
+    return ((originalSize - compressedSize) / originalSize) * 100;
+}
+export function getCompressionStats(originalBody, compressedBody, encoding) {
+    const originalSize = typeof originalBody === 'string' ? new Blob([originalBody]).size : originalBody.length;
+    const compressedSize = compressedBody.length;
+    const compressionRatio = getCompressionRatio(originalSize, compressedSize);
+    const savings = originalSize - compressedSize;
+    return {
+        originalSize,
+        compressedSize,
+        compressionRatio,
+        encoding,
+        savings,
+    };
+}
+/**
+ * Preset compression configurations
+ */
+export const COMPRESSION_PRESETS = {
+    // Fast compression, lower ratio
+    fast: {
+        threshold: 512,
+        level: 3,
+        preferBrotli: false,
+    },
+    // Balanced compression
+    balanced: {
+        threshold: 1024,
+        level: 6,
+        preferBrotli: true,
+    },
+    // Maximum compression, slower
+    max: {
+        threshold: 512,
+        level: 9,
+        preferBrotli: true,
+    },
+    // For static assets
+    static: {
+        threshold: 1024,
+        level: 9,
+        preferBrotli: true,
+    },
+    // For API responses
+    api: {
+        threshold: 512,
+        level: 6,
+        preferBrotli: true,
+        excludeTypes: [
+            'image/png',
+            'image/jpeg',
+            'image/gif',
+            'image/webp',
+            'video/mp4',
+            'application/zip',
+            'application/gzip',
+            'application/pdf',
+        ],
+    },
+};
+/**
+ * Compress JSON response
+ */
+export async function compressJSON(data, encoding = 'gzip', level = 6) {
+    const json = JSON.stringify(data);
+    return compressBody(json, encoding, level);
+}
+/**
+ * Decompress response
+ */
+export async function decompressBody(body, encoding) {
+    if (encoding === 'gzip') {
+        const stream = new Response(body).body?.pipeThrough(new DecompressionStream('gzip'));
+        const decompressed = await new Response(stream).arrayBuffer();
+        return new Uint8Array(decompressed);
+    }
+    if (encoding === 'br' || encoding === 'deflate') {
+        const stream = new Response(body).body?.pipeThrough(new DecompressionStream('deflate'));
+        const decompressed = await new Response(stream).arrayBuffer();
+        return new Uint8Array(decompressed);
+    }
+    return body;
+}
+/**
+ * Check if compression is supported
+ */
+export function isCompressionSupported(request) {
+    const acceptEncoding = request.headers.get('accept-encoding') || '';
+    return {
+        gzip: acceptEncoding.includes('gzip'),
+        brotli: acceptEncoding.includes('br'),
+    };
+}

package/dist/api/payload-optimization.d.ts

@@ -0,0 +1,138 @@
+/**
+ * API Payload Optimization
+ *
+ * Reduces payload size through field selection, pagination, and data transformation
+ */
+interface PaginationOptions {
+    page?: number;
+    limit?: number;
+    cursor?: string;
+    defaultLimit?: number;
+    maxLimit?: number;
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    pagination: {
+        page?: number;
+        limit: number;
+        total?: number;
+        hasMore: boolean;
+        nextCursor?: string | null;
+        prevCursor?: string | null;
+    };
+}
+interface FieldSelectionOptions {
+    include?: string[];
+    exclude?: string[];
+    defaultFields?: string[];
+}
+/**
+ * Paginate array of items
+ */
+export declare function paginateArray<T>(items: T[], options?: PaginationOptions): PaginatedResponse<T>;
+/**
+ * Create cursor for cursor-based pagination
+ */
+export declare function createCursor(item: Record<string, unknown>, field?: string): string;
+/**
+ * Parse cursor
+ */
+export declare function parseCursor(cursor: string): {
+    field: string;
+    value: unknown;
+} | null;
+/**
+ * Select fields from object
+ */
+export declare function selectFields<T extends Record<string, unknown>>(obj: T, options: FieldSelectionOptions): Partial<T>;
+/**
+ * Select fields from array of objects
+ */
+export declare function selectFieldsFromArray<T extends Record<string, unknown>>(items: T[], options: FieldSelectionOptions): Partial<T>[];
+/**
+ * Remove null and undefined values
+ */
+export declare function removeEmpty<T extends Record<string, unknown>>(obj: T): Partial<T>;
+/**
+ * Flatten nested object
+ */
+export declare function flattenObject(obj: Record<string, unknown>, prefix?: string): Record<string, unknown>;
+/**
+ * Minimize JSON response size
+ */
+export declare function minimizeJSON(data: unknown): string;
+/**
+ * Format JSON response (for development)
+ */
+export declare function formatJSON(data: unknown): string;
+/**
+ * Remove sensitive fields
+ */
+export declare function sanitizeResponse<T extends Record<string, unknown>>(obj: T, sensitiveFields?: string[]): Partial<T>;
+/**
+ * Transform timestamps to ISO strings
+ */
+export declare function transformDates<T extends Record<string, unknown>>(obj: T): T;
+/**
+ * Calculate payload size in bytes
+ */
+export declare function getPayloadSize(data: unknown): number;
+/**
+ * Get payload size in human-readable format
+ */
+export declare function formatPayloadSize(bytes: number): string;
+/**
+ * Optimize payload by removing unnecessary data
+ */
+export interface OptimizationResult<T> {
+    data: T;
+    originalSize: number;
+    optimizedSize: number;
+    savings: number;
+    savingsPercent: number;
+}
+export declare function optimizePayload<T>(data: T, options?: FieldSelectionOptions & {
+    removeEmpty?: boolean;
+    transformDates?: boolean;
+    sanitize?: boolean;
+}): OptimizationResult<T>;
+/**
+ * Create API response with optimized payload
+ */
+export declare function createOptimizedResponse<T>(data: T, options?: {
+    pagination?: PaginationOptions;
+    fields?: FieldSelectionOptions;
+    optimize?: boolean;
+    compress?: boolean;
+}): {
+    data: unknown;
+    meta?: {
+        pagination?: PaginatedResponse<T>['pagination'];
+        size?: {
+            original: string;
+            optimized: string;
+            savings: string;
+        };
+    };
+};
+/**
+ * Parse field selection from query params
+ */
+export declare function parseFieldsFromQuery(query: string): FieldSelectionOptions;
+/**
+ * Parse pagination from query params
+ */
+export declare function parsePaginationFromQuery(query: string): PaginationOptions;
+/**
+ * Batch responses to reduce round trips
+ */
+export declare function batchResponses<T>(responses: Array<{
+    key: string;
+    data: T;
+}>): Record<string, T>;
+/**
+ * Create partial response (for large objects)
+ */
+export declare function createPartialResponse<T extends Record<string, unknown>>(obj: T, maxDepth?: number, currentDepth?: number): Partial<T> | string;
+export {};
+//# sourceMappingURL=payload-optimization.d.ts.map

package/dist/api/payload-optimization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload-optimization.d.ts","sourceRoot":"","sources":["../../src/api/payload-optimization.ts"],"names":[],"mappings":"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"}

package/dist/api/payload-optimization.js

@@ -0,0 +1,320 @@
+/**
+ * API Payload Optimization
+ *
+ * Reduces payload size through field selection, pagination, and data transformation
+ */
+/**
+ * Paginate array of items
+ */
+export function paginateArray(items, options = {}) {
+    const { page = 1, limit = options.defaultLimit || 20, maxLimit = 100 } = options;
+    // Enforce max limit
+    const effectiveLimit = Math.min(limit, maxLimit);
+    // Calculate offset
+    const offset = (page - 1) * effectiveLimit;
+    // Slice data
+    const data = items.slice(offset, offset + effectiveLimit);
+    return {
+        data,
+        pagination: {
+            page,
+            limit: effectiveLimit,
+            total: items.length,
+            hasMore: offset + effectiveLimit < items.length,
+        },
+    };
+}
+/**
+ * Create cursor for cursor-based pagination
+ */
+export function createCursor(item, field = 'id') {
+    const value = item[field];
+    return Buffer.from(JSON.stringify({ field, value })).toString('base64');
+}
+/**
+ * Parse cursor
+ */
+export function parseCursor(cursor) {
+    try {
+        const decoded = Buffer.from(cursor, 'base64').toString('utf-8');
+        return JSON.parse(decoded);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Select fields from object
+ */
+export function selectFields(obj, options) {
+    const { include, exclude, defaultFields } = options;
+    // If include is specified, only include those fields
+    if (include && include.length > 0) {
+        const result = {};
+        for (const field of include) {
+            if (field in obj) {
+                result[field] = obj[field];
+            }
+        }
+        return result;
+    }
+    // If exclude is specified, exclude those fields
+    if (exclude && exclude.length > 0) {
+        const result = { ...obj };
+        for (const field of exclude) {
+            delete result[field];
+        }
+        return result;
+    }
+    // Use default fields
+    if (defaultFields && defaultFields.length > 0) {
+        const result = {};
+        for (const field of defaultFields) {
+            if (field in obj) {
+                result[field] = obj[field];
+            }
+        }
+        return result;
+    }
+    // Return all fields
+    return obj;
+}
+/**
+ * Select fields from array of objects
+ */
+export function selectFieldsFromArray(items, options) {
+    return items.map((item) => selectFields(item, options));
+}
+/**
+ * Remove null and undefined values
+ */
+export function removeEmpty(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value !== null && value !== undefined) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Flatten nested object
+ */
+export function flattenObject(obj, prefix = '') {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const newKey = prefix ? `${prefix}.${key}` : key;
+        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+            Object.assign(result, flattenObject(value, newKey));
+        }
+        else {
+            result[newKey] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Minimize JSON response size
+ */
+export function minimizeJSON(data) {
+    return JSON.stringify(data, null, 0);
+}
+/**
+ * Format JSON response (for development)
+ */
+export function formatJSON(data) {
+    return JSON.stringify(data, null, 2);
+}
+/**
+ * Remove sensitive fields
+ */
+export function sanitizeResponse(obj, sensitiveFields = ['password', 'secret', 'token', 'apiKey']) {
+    return selectFields(obj, { exclude: sensitiveFields });
+}
+/**
+ * Transform timestamps to ISO strings
+ */
+export function transformDates(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (value instanceof Date) {
+            result[key] = value.toISOString();
+        }
+        else if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+            result[key] = transformDates(value);
+        }
+        else if (Array.isArray(value)) {
+            result[key] = value.map((item) => typeof item === 'object' && item !== null
+                ? transformDates(item)
+                : item);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Calculate payload size in bytes
+ */
+export function getPayloadSize(data) {
+    const json = JSON.stringify(data);
+    return new Blob([json]).size;
+}
+/**
+ * Get payload size in human-readable format
+ */
+export function formatPayloadSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(2)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+export function optimizePayload(data, options = {}) {
+    const originalSize = getPayloadSize(data);
+    let optimized = data;
+    // Select fields
+    if (Array.isArray(data)) {
+        optimized = selectFieldsFromArray(data, options);
+    }
+    else if (typeof data === 'object' && data !== null) {
+        optimized = selectFields(data, options);
+    }
+    // Remove empty values
+    if (options.removeEmpty) {
+        if (Array.isArray(optimized)) {
+            optimized = optimized.map((item) => removeEmpty(item));
+        }
+        else if (optimized !== null && typeof optimized === 'object') {
+            optimized = removeEmpty(optimized);
+        }
+    }
+    // Transform dates
+    if (options.transformDates) {
+        if (Array.isArray(optimized)) {
+            optimized = optimized.map((item) => transformDates(item));
+        }
+        else if (optimized !== null && typeof optimized === 'object') {
+            optimized = transformDates(optimized);
+        }
+    }
+    // Sanitize
+    if (options.sanitize) {
+        if (Array.isArray(optimized)) {
+            optimized = optimized.map((item) => sanitizeResponse(item));
+        }
+        else if (optimized !== null && typeof optimized === 'object') {
+            optimized = sanitizeResponse(optimized);
+        }
+    }
+    const optimizedSize = getPayloadSize(optimized);
+    const savings = originalSize - optimizedSize;
+    const savingsPercent = (savings / originalSize) * 100;
+    return {
+        data: optimized,
+        originalSize,
+        optimizedSize,
+        savings,
+        savingsPercent,
+    };
+}
+/**
+ * Create API response with optimized payload
+ */
+export function createOptimizedResponse(data, options = {}) {
+    let result = data;
+    // Paginate if array
+    if (Array.isArray(data) && options.pagination) {
+        const paginated = paginateArray(data, options.pagination);
+        result = {
+            data: paginated.data,
+            meta: {
+                pagination: paginated.pagination,
+            },
+        };
+    }
+    // Optimize payload
+    if (options.optimize) {
+        const optimized = optimizePayload(result, options.fields || {});
+        const resultWithMeta = result;
+        return {
+            data: optimized.data,
+            meta: {
+                ...(resultWithMeta.meta && typeof resultWithMeta.meta === 'object'
+                    ? resultWithMeta.meta
+                    : {}),
+                size: {
+                    original: formatPayloadSize(optimized.originalSize),
+                    optimized: formatPayloadSize(optimized.optimizedSize),
+                    savings: `${optimized.savingsPercent.toFixed(1)}%`,
+                },
+            },
+        };
+    }
+    return { data: result };
+}
+/**
+ * Parse field selection from query params
+ */
+export function parseFieldsFromQuery(query) {
+    const params = new URLSearchParams(query);
+    const include = params.get('fields')?.split(',').filter(Boolean);
+    const exclude = params.get('exclude')?.split(',').filter(Boolean);
+    return {
+        include,
+        exclude,
+    };
+}
+/**
+ * Parse pagination from query params
+ */
+export function parsePaginationFromQuery(query) {
+    const params = new URLSearchParams(query);
+    const page = parseInt(params.get('page') || '1', 10);
+    const limit = parseInt(params.get('limit') || '20', 10);
+    const cursor = params.get('cursor') || undefined;
+    return {
+        page,
+        limit,
+        cursor,
+    };
+}
+/**
+ * Batch responses to reduce round trips
+ */
+export function batchResponses(responses) {
+    const result = {};
+    for (const { key, data } of responses) {
+        result[key] = data;
+    }
+    return result;
+}
+/**
+ * Create partial response (for large objects)
+ */
+export function createPartialResponse(obj, maxDepth = 2, currentDepth = 0) {
+    if (currentDepth >= maxDepth) {
+        return '[truncated]';
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (Array.isArray(value)) {
+            result[key] = value
+                .slice(0, 10)
+                .map((item) => typeof item === 'object' && item !== null
+                ? createPartialResponse(item, maxDepth, currentDepth + 1)
+                : item);
+            if (value.length > 10) {
+                result[`${key}_count`] = value.length;
+            }
+        }
+        else if (value !== null && typeof value === 'object') {
+            result[key] = createPartialResponse(value, maxDepth, currentDepth + 1);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}