lsh-framework 1.2.0 → 1.3.0

package/dist/lib/api-error-handler.js

@@ -1,185 +0,0 @@
-/**
- * API Error Handler
- * Consolidates error response formatting across all API endpoints
- */
-/**
- * HTTP status codes for common error types
- */
-export const ErrorStatusCodes = {
-    BAD_REQUEST: 400,
-    UNAUTHORIZED: 401,
-    FORBIDDEN: 403,
-    NOT_FOUND: 404,
-    CONFLICT: 409,
-    INTERNAL_SERVER_ERROR: 500,
-    SERVICE_UNAVAILABLE: 503,
-};
-/**
- * Custom API Error class with status code
- */
-export class ApiError extends Error {
-    statusCode;
-    code;
-    details;
-    constructor(message, statusCode = ErrorStatusCodes.INTERNAL_SERVER_ERROR, code, details) {
-        super(message);
-        this.statusCode = statusCode;
-        this.code = code;
-        this.details = details;
-        this.name = 'ApiError';
-    }
-}
-/**
- * Send error response with consistent formatting
- *
- * @param res - Express response object
- * @param error - Error object
- * @param statusCode - HTTP status code (default: 500)
- */
-export function sendError(res, error, statusCode) {
-    const err = error instanceof Error ? error : new Error(String(error));
-    const status = statusCode || (err instanceof ApiError ? err.statusCode : 500);
-    const response = {
-        error: err.message || 'An unexpected error occurred',
-        timestamp: new Date().toISOString(),
-    };
-    if (err instanceof ApiError) {
-        if (err.code)
-            response.code = err.code;
-        if (err.details)
-            response.details = err.details;
-    }
-    // Log error for debugging (in production, use proper logger)
-    if (status >= 500) {
-        console.error('API Error:', err);
-    }
-    res.status(status).json(response);
-}
-/**
- * Send success response with consistent formatting
- *
- * @param res - Express response object
- * @param data - Response data
- * @param statusCode - HTTP status code (default: 200)
- * @param includeTimestamp - Include timestamp in response
- */
-export function sendSuccess(res, data, statusCode = 200, includeTimestamp = false) {
-    if (statusCode === 204) {
-        res.status(204).send();
-        return;
-    }
-    const response = includeTimestamp
-        ? { data, timestamp: new Date().toISOString() }
-        : data;
-    res.status(statusCode).json(response);
-}
-/**
- * Wrapper for async route handlers with automatic error handling
- *
- * Eliminates the need for try-catch blocks in every route handler
- *
- * @param handler - Async route handler function
- * @returns Express middleware function
- *
- * @example
- * ```typescript
- * app.get('/api/jobs', asyncHandler(async (req, res) => {
- *   const jobs = await getJobs();
- *   sendSuccess(res, jobs);
- * }));
- * ```
- */
-export function asyncHandler(handler) {
-    return (req, res, next) => {
-        Promise.resolve(handler(req, res, next)).catch((error) => {
-            sendError(res, error);
-        });
-    };
-}
-/**
- * Execute an operation with automatic success/error handling
- *
- * This is the most powerful wrapper - it handles:
- * - Try-catch
- * - Success response formatting
- * - Error response formatting
- * - Optional webhook triggering
- *
- * @param res - Express response object
- * @param operation - Async operation to execute
- * @param config - Configuration options
- * @param webhookTrigger - Optional webhook trigger function
- *
- * @example
- * ```typescript
- * app.post('/api/jobs', async (req, res) => {
- *   await handleApiOperation(
- *     res,
- *     async () => this.daemon.addJob(req.body),
- *     {
- *       successStatus: 201,
- *       webhookEvent: 'job.created'
- *     },
- *     (event, data) => this.triggerWebhook(event, data)
- *   );
- * });
- * ```
- */
-export async function handleApiOperation(res, operation, config = {}, webhookTrigger) {
-    const { successStatus = 200, includeTimestamp = false, webhookEvent, webhookData, } = config;
-    try {
-        const result = await operation();
-        // Send success response
-        sendSuccess(res, result, successStatus, includeTimestamp);
-        // Trigger webhook if configured
-        if (webhookEvent && webhookTrigger) {
-            const webhookPayload = webhookData ? webhookData(result) : result;
-            webhookTrigger(webhookEvent, webhookPayload);
-        }
-    }
-    catch (error) {
-        const err = error;
-        // Determine appropriate status code
-        let statusCode = 400;
-        if (err instanceof ApiError) {
-            statusCode = err.statusCode;
-        }
-        else if (err.message.includes('not found') || err.message.includes('Not found')) {
-            statusCode = 404;
-        }
-        else if (err.message.includes('permission') || err.message.includes('unauthorized')) {
-            statusCode = 403;
-        }
-        else if (err.message.includes('exists') || err.message.includes('duplicate')) {
-            statusCode = 409;
-        }
-        sendError(res, err, statusCode);
-    }
-}
-/**
- * Create a typed API handler with webhook support
- *
- * Returns a function that can be used to handle API operations with
- * automatic error handling and webhook triggering
- *
- * @param webhookTrigger - Webhook trigger function
- * @returns Handler function
- */
-export function createApiHandler(webhookTrigger) {
-    return async function (res, operation, config = {}) {
-        await handleApiOperation(res, operation, config, webhookTrigger);
-    };
-}
-/**
- * Express error handling middleware
- *
- * Should be added after all routes
- *
- * @example
- * ```typescript
- * app.use(errorMiddleware);
- * ```
- */
-export function errorMiddleware(error, req, res, _next) {
-    sendError(res, error);
-}

package/dist/lib/associative-arrays.js

@@ -1,285 +0,0 @@
-/**
- * Associative Arrays Implementation
- * Provides ZSH-compatible associative array functionality
- */
-export class AssociativeArrayManager {
-    context;
-    constructor() {
-        this.context = {
-            arrays: new Map(),
-            arrayTypes: new Map(),
-        };
-    }
-    /**
-     * Declare an associative array with typeset -A
-     */
-    declareAssociativeArray(name) {
-        this.context.arrays.set(name, {});
-        this.context.arrayTypes.set(name, 'associative');
-    }
-    /**
-     * Declare an indexed array with typeset -a
-     */
-    declareIndexedArray(name) {
-        this.context.arrays.set(name, {});
-        this.context.arrayTypes.set(name, 'indexed');
-    }
-    /**
-     * Set a value in an associative array
-     */
-    setAssociativeValue(arrayName, key, value) {
-        if (!this.context.arrays.has(arrayName)) {
-            this.declareAssociativeArray(arrayName);
-        }
-        const array = this.context.arrays.get(arrayName);
-        array[key] = value;
-    }
-    /**
-     * Set a value in an indexed array
-     */
-    setIndexedValue(arrayName, index, value) {
-        if (!this.context.arrays.has(arrayName)) {
-            this.declareIndexedArray(arrayName);
-        }
-        const array = this.context.arrays.get(arrayName);
-        array[index.toString()] = value;
-    }
-    /**
-     * Get a value from an array
-     */
-    getValue(arrayName, key) {
-        const array = this.context.arrays.get(arrayName);
-        return array ? array[key] : undefined;
-    }
-    /**
-     * Get all keys from an associative array
-     */
-    getKeys(arrayName) {
-        const array = this.context.arrays.get(arrayName);
-        if (!array)
-            return [];
-        const type = this.context.arrayTypes.get(arrayName);
-        if (type === 'indexed') {
-            // For indexed arrays, return sorted numeric keys
-            return Object.keys(array)
-                .map(k => parseInt(k, 10))
-                .filter(k => !isNaN(k))
-                .sort((a, b) => a - b)
-                .map(k => k.toString());
-        }
-        else {
-            // For associative arrays, return all keys
-            return Object.keys(array);
-        }
-    }
-    /**
-     * Get all values from an array
-     */
-    getValues(arrayName) {
-        const array = this.context.arrays.get(arrayName);
-        if (!array)
-            return [];
-        const type = this.context.arrayTypes.get(arrayName);
-        if (type === 'indexed') {
-            // For indexed arrays, return values in order
-            const keys = this.getKeys(arrayName);
-            return keys.map(key => array[key]);
-        }
-        else {
-            // For associative arrays, return all values
-            return Object.values(array);
-        }
-    }
-    /**
-     * Get array length
-     */
-    getLength(arrayName) {
-        const array = this.context.arrays.get(arrayName);
-        return array ? Object.keys(array).length : 0;
-    }
-    /**
-     * Check if an array exists
-     */
-    hasArray(arrayName) {
-        return this.context.arrays.has(arrayName);
-    }
-    /**
-     * Get array type
-     */
-    getArrayType(arrayName) {
-        return this.context.arrayTypes.get(arrayName);
-    }
-    /**
-     * Remove an array
-     */
-    removeArray(arrayName) {
-        const hadArray = this.context.arrays.has(arrayName);
-        this.context.arrays.delete(arrayName);
-        this.context.arrayTypes.delete(arrayName);
-        return hadArray;
-    }
-    /**
-     * Get all array names
-     */
-    getAllArrayNames() {
-        return Array.from(this.context.arrays.keys());
-    }
-    /**
-     * Clear all arrays
-     */
-    clearAllArrays() {
-        this.context.arrays.clear();
-        this.context.arrayTypes.clear();
-    }
-    /**
-     * Get array slice (for indexed arrays)
-     */
-    getSlice(arrayName, start, end) {
-        const array = this.context.arrays.get(arrayName);
-        if (!array)
-            return [];
-        const type = this.context.arrayTypes.get(arrayName);
-        if (type !== 'indexed')
-            return [];
-        const keys = this.getKeys(arrayName);
-        const startIdx = Math.max(0, start - 1); // Convert to 0-based
-        const endIdx = end ? Math.min(keys.length, end) : keys.length;
-        return keys.slice(startIdx, endIdx).map(key => array[key]);
-    }
-    /**
-     * Expand array reference like ${array[key]} or ${array[@]}
-     */
-    expandArrayReference(reference) {
-        // Match patterns like ${array[key]}, ${array[@]}, ${array[*]}
-        const match = reference.match(/^\$\{([^[\]]+)(?:\[([^\]]+)\])?(?:\[@\*\]|\[@\]|\[\*\]|\[@\])?\}$/);
-        if (!match)
-            return [];
-        const arrayName = match[1];
-        const key = match[2];
-        if (!this.hasArray(arrayName))
-            return [];
-        if (key) {
-            // Single element access
-            const value = this.getValue(arrayName, key);
-            return value !== undefined ? [value] : [];
-        }
-        else {
-            // All elements access
-            return this.getValues(arrayName);
-        }
-    }
-    /**
-     * Expand array keys like ${(k)array}
-     */
-    expandArrayKeys(reference) {
-        const match = reference.match(/^\$\{\(k\)([^}]+)\}$/);
-        if (!match)
-            return [];
-        const arrayName = match[1];
-        return this.getKeys(arrayName);
-    }
-    /**
-     * Expand array values like ${(v)array}
-     */
-    expandArrayValues(reference) {
-        const match = reference.match(/^\$\{\(v\)([^}]+)\}$/);
-        if (!match)
-            return [];
-        const arrayName = match[1];
-        return this.getValues(arrayName);
-    }
-    /**
-     * Expand array length like ${#array}
-     */
-    expandArrayLength(reference) {
-        const match = reference.match(/^\$\{#([^}]+)\}$/);
-        if (!match)
-            return '';
-        const arrayName = match[1];
-        return this.getLength(arrayName).toString();
-    }
-    /**
-     * Parse typeset command
-     */
-    parseTypesetCommand(args) {
-        if (args.length === 0) {
-            return { success: false, message: 'typeset: missing arguments' };
-        }
-        for (const arg of args) {
-            if (arg === '-A') {
-                // Declare associative array - next argument should be the name
-                const nameIndex = args.indexOf('-A') + 1;
-                if (nameIndex < args.length) {
-                    const name = args[nameIndex];
-                    this.declareAssociativeArray(name);
-                }
-            }
-            else if (arg === '-a') {
-                // Declare indexed array - next argument should be the name
-                const nameIndex = args.indexOf('-a') + 1;
-                if (nameIndex < args.length) {
-                    const name = args[nameIndex];
-                    this.declareIndexedArray(name);
-                }
-            }
-            else if (arg.includes('=')) {
-                // Assignment: name=value or name[key]=value
-                const [left, right] = arg.split('=', 2);
-                const arrayMatch = left.match(/^([^[\]]+)(?:\[([^\]]+)\])?$/);
-                if (arrayMatch) {
-                    const arrayName = arrayMatch[1];
-                    const key = arrayMatch[2];
-                    if (key) {
-                        // Associative array assignment
-                        this.setAssociativeValue(arrayName, key, right);
-                    }
-                    else {
-                        // Regular variable assignment (not array)
-                        // This would be handled by the regular variable system
-                    }
-                }
-            }
-        }
-        return { success: true, message: '' };
-    }
-    /**
-     * Get array information for display
-     */
-    getArrayInfo(arrayName) {
-        if (!this.hasArray(arrayName))
-            return null;
-        const type = this.getArrayType(arrayName);
-        const length = this.getLength(arrayName);
-        const keys = this.getKeys(arrayName);
-        const values = this.getValues(arrayName);
-        return {
-            type: type || 'unknown',
-            length,
-            keys,
-            values,
-        };
-    }
-    /**
-     * Export array data for serialization
-     */
-    exportArrays() {
-        const arrays = {};
-        const types = {};
-        for (const [name, array] of this.context.arrays) {
-            arrays[name] = { ...array };
-            types[name] = this.context.arrayTypes.get(name) || 'unknown';
-        }
-        return { arrays, types };
-    }
-    /**
-     * Import array data from serialization
-     */
-    importArrays(data) {
-        this.clearAllArrays();
-        for (const [name, array] of Object.entries(data.arrays)) {
-            this.context.arrays.set(name, { ...array });
-            this.context.arrayTypes.set(name, data.types[name]);
-        }
-    }
-}
-export default AssociativeArrayManager;