lsh-framework 3.2.5 → 3.5.1

package/dist/lib/supabase-utils.js

@@ -1,396 +0,0 @@
-/**
- * LSH Supabase Utilities
- *
- * Provides utility functions for common Supabase database operations.
- * Reduces code duplication and ensures consistent error handling across services.
- *
- * Key Features:
- * - Standardized error handling for Supabase queries
- * - Type-safe query builders with soft-delete support
- * - Consistent pagination and filtering patterns
- * - Integration with LSHError for structured error reporting
- *
- * @example
- * ```typescript
- * import { executeQuery, executeSingleQuery, buildFilteredQuery } from './supabase-utils.js';
- *
- * // Single record fetch with error handling
- * const org = await executeSingleQuery(
- *   supabase.from('organizations').select('*').eq('id', id),
- *   'Organization',
- *   { notFoundError: true }
- * );
- *
- * // Multiple records with soft-delete filter
- * const members = await executeQuery(
- *   buildFilteredQuery(supabase.from('members').select('*'), { softDelete: true })
- * );
- * ```
- *
- * @module supabase-utils
- */
-import { LSHError, ErrorCodes, extractErrorMessage } from './lsh-error.js';
-// ============================================================================
-// QUERY EXECUTION
-// ============================================================================
-/**
- * Execute a Supabase query and handle errors consistently.
- *
- * @example
- * ```typescript
- * const members = await executeQuery(
- *   supabase.from('organization_members').select('*').eq('org_id', orgId),
- *   { context: 'Organization members' }
- * );
- * ```
- */
-export async function executeQuery(query, options = {}) {
-    const { context = 'Query', throwOnError = true } = options;
-    try {
-        const { data, error } = await query;
-        if (error) {
-            if (throwOnError) {
-                throw new LSHError(ErrorCodes.DB_QUERY_FAILED, `${context} failed: ${error.message}`, { code: error.code, details: error.details, hint: error.hint });
-            }
-            return [];
-        }
-        return data || [];
-    }
-    catch (err) {
-        if (err instanceof LSHError) {
-            throw err;
-        }
-        if (throwOnError) {
-            throw new LSHError(ErrorCodes.DB_QUERY_FAILED, `${context} failed: ${extractErrorMessage(err)}`, { originalError: extractErrorMessage(err) });
-        }
-        return [];
-    }
-}
-/**
- * Execute a Supabase query expecting a single result.
- *
- * @example
- * ```typescript
- * const org = await executeSingleQuery(
- *   supabase.from('organizations').select('*').eq('id', id).single(),
- *   { context: 'Organization', notFoundError: true }
- * );
- * ```
- */
-export async function executeSingleQuery(query, options = {}) {
-    const { context = 'Record', throwOnError = true, notFoundError = false } = options;
-    try {
-        const { data, error } = await query;
-        if (error) {
-            // Handle "no rows" error specifically
-            if (error.code === 'PGRST116') {
-                if (notFoundError) {
-                    throw new LSHError(ErrorCodes.RESOURCE_NOT_FOUND, `${context} not found`, { code: error.code });
-                }
-                return null;
-            }
-            if (throwOnError) {
-                throw new LSHError(ErrorCodes.DB_QUERY_FAILED, `${context} query failed: ${error.message}`, { code: error.code, details: error.details, hint: error.hint });
-            }
-            return null;
-        }
-        return data;
-    }
-    catch (err) {
-        if (err instanceof LSHError) {
-            throw err;
-        }
-        if (throwOnError) {
-            throw new LSHError(ErrorCodes.DB_QUERY_FAILED, `${context} query failed: ${extractErrorMessage(err)}`, { originalError: extractErrorMessage(err) });
-        }
-        return null;
-    }
-}
-/**
- * Execute a Supabase insert operation.
- *
- * @example
- * ```typescript
- * const newOrg = await executeInsert(
- *   supabase.from('organizations').insert({ name: 'Acme' }).select().single(),
- *   { context: 'Organization creation' }
- * );
- * ```
- */
-export async function executeInsert(query, options = {}) {
-    const { context = 'Insert', throwOnError = true } = options;
-    try {
-        const { data, error } = await query;
-        if (error) {
-            // Handle unique constraint violations
-            if (error.code === '23505') {
-                throw new LSHError(ErrorCodes.RESOURCE_ALREADY_EXISTS, `${context} failed: Record already exists`, { code: error.code, details: error.details });
-            }
-            if (throwOnError) {
-                throw new LSHError(ErrorCodes.DB_QUERY_FAILED, `${context} failed: ${error.message}`, { code: error.code, details: error.details, hint: error.hint });
-            }
-            throw new Error(`${context} failed: ${error.message}`);
-        }
-        if (!data) {
-            throw new LSHError(ErrorCodes.DB_QUERY_FAILED, `${context} failed: No data returned`, { context });
-        }
-        return data;
-    }
-    catch (err) {
-        if (err instanceof LSHError) {
-            throw err;
-        }
-        throw new LSHError(ErrorCodes.DB_QUERY_FAILED, `${context} failed: ${extractErrorMessage(err)}`, { originalError: extractErrorMessage(err) });
-    }
-}
-/**
- * Execute a Supabase update operation.
- *
- * @example
- * ```typescript
- * const updated = await executeUpdate(
- *   supabase.from('organizations').update({ name: 'New Name' }).eq('id', id).select().single(),
- *   { context: 'Organization update' }
- * );
- * ```
- */
-export async function executeUpdate(query, options = {}) {
-    const { context = 'Update', throwOnError = true, notFoundError = false } = options;
-    try {
-        const { data, error } = await query;
-        if (error) {
-            if (error.code === 'PGRST116' && notFoundError) {
-                throw new LSHError(ErrorCodes.RESOURCE_NOT_FOUND, `${context} failed: Record not found`, { code: error.code });
-            }
-            if (throwOnError) {
-                throw new LSHError(ErrorCodes.DB_QUERY_FAILED, `${context} failed: ${error.message}`, { code: error.code, details: error.details, hint: error.hint });
-            }
-            return null;
-        }
-        return data;
-    }
-    catch (err) {
-        if (err instanceof LSHError) {
-            throw err;
-        }
-        if (throwOnError) {
-            throw new LSHError(ErrorCodes.DB_QUERY_FAILED, `${context} failed: ${extractErrorMessage(err)}`, { originalError: extractErrorMessage(err) });
-        }
-        return null;
-    }
-}
-/**
- * Execute a Supabase delete operation (or soft delete).
- */
-export async function executeDelete(query, options = {}) {
-    const { context = 'Delete', throwOnError = true } = options;
-    try {
-        const { error } = await query;
-        if (error) {
-            if (throwOnError) {
-                throw new LSHError(ErrorCodes.DB_QUERY_FAILED, `${context} failed: ${error.message}`, { code: error.code, details: error.details });
-            }
-            return false;
-        }
-        return true;
-    }
-    catch (err) {
-        if (err instanceof LSHError) {
-            throw err;
-        }
-        if (throwOnError) {
-            throw new LSHError(ErrorCodes.DB_QUERY_FAILED, `${context} failed: ${extractErrorMessage(err)}`, { originalError: extractErrorMessage(err) });
-        }
-        return false;
-    }
-}
-// ============================================================================
-// QUERY BUILDERS
-// ============================================================================
-/**
- * Apply common filters to a Supabase query.
- *
- * @example
- * ```typescript
- * const query = applyFilters(
- *   supabase.from('secrets').select('*'),
- *   { softDelete: true, teamId: 'team_123', limit: 50 }
- * );
- * ```
- */
-export function applyFilters(query, filters) {
-    let result = query;
-    // Soft delete filter
-    if (filters.softDelete !== false) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        result = result.is('deleted_at', null);
-    }
-    // Organization filter
-    if (filters.organizationId) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        result = result.eq('organization_id', filters.organizationId);
-    }
-    // Team filter
-    if (filters.teamId) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        result = result.eq('team_id', filters.teamId);
-    }
-    // User filter
-    if (filters.userId) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        result = result.eq('user_id', filters.userId);
-    }
-    // Ordering
-    if (filters.orderBy) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        result = result.order(filters.orderBy, {
-            ascending: filters.orderDirection !== 'desc',
-        });
-    }
-    // Pagination
-    if (filters.limit !== undefined) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        result = result.limit(filters.limit);
-    }
-    if (filters.offset !== undefined) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        result = result.range(filters.offset, filters.offset + (filters.limit || 50) - 1);
-    }
-    return result;
-}
-// ============================================================================
-// EXISTENCE CHECKS
-// ============================================================================
-/**
- * Check if a record exists by ID.
- */
-export async function recordExists(fromQuery, id, idColumn = 'id') {
-    try {
-        const { data } = await fromQuery.select(idColumn).eq(idColumn, id).single();
-        return data !== null;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Check if a record exists by a unique field.
- */
-export async function recordExistsByField(fromQuery, field, value) {
-    try {
-        const { data } = await fromQuery.select(field).eq(field, value).single();
-        return data !== null;
-    }
-    catch {
-        return false;
-    }
-}
-// ============================================================================
-// SOFT DELETE UTILITIES
-// ============================================================================
-/**
- * Perform a soft delete on a record.
- */
-export async function softDelete(fromQuery, id, options = {}) {
-    const { context = 'Soft delete', throwOnError = true } = options;
-    try {
-        const { error } = await fromQuery
-            .update({ deleted_at: new Date().toISOString() })
-            .eq('id', id);
-        if (error) {
-            if (throwOnError) {
-                throw new LSHError(ErrorCodes.DB_QUERY_FAILED, `${context} failed: ${error.message}`, { code: error.code, id });
-            }
-            return false;
-        }
-        return true;
-    }
-    catch (err) {
-        if (err instanceof LSHError) {
-            throw err;
-        }
-        if (throwOnError) {
-            throw new LSHError(ErrorCodes.DB_QUERY_FAILED, `${context} failed: ${extractErrorMessage(err)}`, { id, originalError: extractErrorMessage(err) });
-        }
-        return false;
-    }
-}
-/**
- * Restore a soft-deleted record.
- */
-export async function restoreSoftDeleted(fromQuery, id, options = {}) {
-    const { context = 'Restore', throwOnError = true } = options;
-    try {
-        const { error } = await fromQuery.update({ deleted_at: null }).eq('id', id);
-        if (error) {
-            if (throwOnError) {
-                throw new LSHError(ErrorCodes.DB_QUERY_FAILED, `${context} failed: ${error.message}`, { code: error.code, id });
-            }
-            return false;
-        }
-        return true;
-    }
-    catch (err) {
-        if (err instanceof LSHError) {
-            throw err;
-        }
-        if (throwOnError) {
-            throw new LSHError(ErrorCodes.DB_QUERY_FAILED, `${context} failed: ${extractErrorMessage(err)}`, { id, originalError: extractErrorMessage(err) });
-        }
-        return false;
-    }
-}
-// ============================================================================
-// ERROR CODE MAPPING
-// ============================================================================
-/**
- * Map Postgres error codes to LSH error codes.
- */
-export function mapPostgresErrorCode(pgCode) {
-    const codeMap = {
-        '23505': 'RESOURCE_ALREADY_EXISTS', // unique_violation
-        '23503': 'DB_CONSTRAINT_VIOLATION', // foreign_key_violation
-        '23502': 'VALIDATION_REQUIRED_FIELD', // not_null_violation
-        '23514': 'VALIDATION_OUT_OF_RANGE', // check_violation
-        '42P01': 'DB_QUERY_FAILED', // undefined_table
-        '42703': 'DB_QUERY_FAILED', // undefined_column
-        'PGRST116': 'RESOURCE_NOT_FOUND', // no rows found
-        'PGRST301': 'DB_QUERY_FAILED', // JWT expired
-        'PGRST302': 'AUTH_INVALID_TOKEN', // JWT invalid
-        '08006': 'DB_CONNECTION_FAILED', // connection failure
-        '08001': 'DB_CONNECTION_FAILED', // unable to connect
-        '57014': 'DB_TIMEOUT', // query_canceled (timeout)
-    };
-    return codeMap[pgCode] || 'DB_QUERY_FAILED';
-}
-/**
- * Create an LSHError from a Supabase error.
- */
-export function createDbError(pgError, context) {
-    const code = pgError.code ? mapPostgresErrorCode(pgError.code) : 'DB_QUERY_FAILED';
-    const message = context
-        ? `${context}: ${pgError.message}`
-        : pgError.message;
-    return new LSHError(ErrorCodes[code], message, {
-        pgCode: pgError.code,
-        details: pgError.details,
-        hint: pgError.hint,
-    });
-}
-// ============================================================================
-// EXPORTS
-// ============================================================================
-export default {
-    executeQuery,
-    executeSingleQuery,
-    executeInsert,
-    executeUpdate,
-    executeDelete,
-    applyFilters,
-    recordExists,
-    recordExistsByField,
-    softDelete,
-    restoreSoftDeleted,
-    mapPostgresErrorCode,
-    createDbError,
-};

package/dist/services/cron/cron-registrar.js

@@ -1,240 +0,0 @@
-/**
- * Cron Command Registrar
- * Registers all cron-related CLI commands using BaseCommandRegistrar
- */
-import { BaseCommandRegistrar } from '../../lib/base-command-registrar.js';
-export class CronCommandRegistrar extends BaseCommandRegistrar {
-    constructor() {
-        super('CronService');
-    }
-    async register(program) {
-        const cronCmd = this.createCommand(program, 'cron', 'Cron job management with database integration');
-        this.registerTemplateCommands(cronCmd);
-        this.registerJobManagementCommands(cronCmd);
-        this.registerReportingCommands(cronCmd);
-    }
-    registerTemplateCommands(cronCmd) {
-        // List templates
-        this.addSubcommand(cronCmd, {
-            name: 'templates',
-            description: 'List available job templates',
-            action: async () => {
-                await this.withCronManager(async (manager) => {
-                    const templates = manager.listTemplates();
-                    this.logInfo('Available Job Templates:');
-                    templates.forEach(template => {
-                        this.logInfo(`\n  ${template.id}: ${template.name}`);
-                        this.logInfo(`    Description: ${template.description}`);
-                        this.logInfo(`    Command: ${template.command}`);
-                        this.logInfo(`    Schedule: ${template.schedule}`);
-                        this.logInfo(`    Category: ${template.category}`);
-                        this.logInfo(`    Tags: ${template.tags.join(', ')}`);
-                    });
-                }, { requireRunning: false });
-            }
-        });
-        // Create job from template
-        this.addSubcommand(cronCmd, {
-            name: 'create-from-template',
-            description: 'Create a job from a template',
-            arguments: [{ name: 'templateId', required: true }],
-            options: [
-                { flags: '-n, --name <name>', description: 'Custom job name' },
-                { flags: '-c, --command <command>', description: 'Custom command' },
-                { flags: '-s, --schedule <schedule>', description: 'Custom cron schedule' },
-                { flags: '-w, --working-dir <dir>', description: 'Working directory' },
-                { flags: '-e, --env <env>', description: 'Environment variables (JSON)' },
-                { flags: '-t, --tags <tags>', description: 'Comma-separated tags' },
-                { flags: '-p, --priority <priority>', description: 'Priority (0-10)', defaultValue: '5' }
-            ],
-            action: async (templateId, options) => {
-                const opts = options;
-                const result = await this.withCronManager(async (manager) => {
-                    const customizations = {};
-                    if (opts.name)
-                        customizations.name = opts.name;
-                    if (opts.command)
-                        customizations.command = opts.command;
-                    if (opts.schedule)
-                        customizations.schedule = { cron: opts.schedule };
-                    if (opts.workingDir)
-                        customizations.workingDirectory = opts.workingDir;
-                    if (opts.env)
-                        customizations.environment = this.parseJSON(opts.env, 'environment variables');
-                    if (opts.tags)
-                        customizations.tags = this.parseTags(opts.tags);
-                    if (opts.priority)
-                        customizations.priority = parseInt(opts.priority);
-                    return await manager.createJobFromTemplate(templateId, customizations);
-                });
-                this.logSuccess('Job created from template:');
-                this.logInfo(`  Template: ${templateId}`);
-                this.logInfo(`  Job ID: ${result.id}`);
-                this.logInfo(`  Name: ${result.name}`);
-                this.logInfo(`  Command: ${result.command}`);
-                this.logInfo(`  Schedule: ${result.schedule?.cron || 'N/A'}`);
-            }
-        });
-    }
-    registerJobManagementCommands(cronCmd) {
-        // List jobs
-        this.addSubcommand(cronCmd, {
-            name: 'list',
-            description: 'List all cron jobs',
-            options: [
-                { flags: '-f, --filter <filter>', description: 'Filter by status' }
-            ],
-            action: async (options) => {
-                const opts = options;
-                const jobs = await this.withCronManager(async (manager) => {
-                    return await manager.listJobs(opts.filter ? { status: opts.filter } : undefined);
-                });
-                this.logInfo(`Cron Jobs (${jobs.length} total):`);
-                jobs.forEach(job => {
-                    const schedule = job.schedule?.cron || `${job.schedule?.interval}ms interval`;
-                    this.logInfo(`\n  ${job.id}: ${job.name}`);
-                    this.logInfo(`    Command: ${job.command}`);
-                    this.logInfo(`    Schedule: ${schedule}`);
-                    this.logInfo(`    Status: ${job.status}`);
-                    this.logInfo(`    Priority: ${job.priority}`);
-                    this.logInfo(`    Tags: ${job.tags?.join(', ') || 'None'}`);
-                });
-            }
-        });
-        // Get job info
-        this.addSubcommand(cronCmd, {
-            name: 'info',
-            description: 'Get job information',
-            arguments: [{ name: 'jobId', required: true }],
-            action: async (jobId) => {
-                const job = await this.withCronManager(async (manager) => {
-                    return await manager.getJob(jobId);
-                });
-                if (!job) {
-                    throw new Error(`Job ${jobId} not found`);
-                }
-                this.logInfo(`Job Information: ${jobId}`);
-                this.logInfo(`  Name: ${job.name}`);
-                this.logInfo(`  Command: ${job.command}`);
-                this.logInfo(`  Status: ${job.status}`);
-                this.logInfo(`  Priority: ${job.priority}`);
-                this.logInfo(`  Working Directory: ${job.cwd}`);
-                this.logInfo(`  User: ${job.user}`);
-                this.logInfo(`  Tags: ${job.tags?.join(', ') || 'None'}`);
-                if (job.schedule) {
-                    const schedule = job.schedule.cron || `${job.schedule.interval}ms interval`;
-                    this.logInfo(`  Schedule: ${schedule}`);
-                }
-            }
-        });
-        // Start job
-        this.addSubcommand(cronCmd, {
-            name: 'start',
-            description: 'Start a job',
-            arguments: [{ name: 'jobId', required: true }],
-            action: async (jobId) => {
-                await this.withCronManager(async (manager) => {
-                    await manager.startJob(jobId);
-                });
-                this.logSuccess(`Job ${jobId} started`);
-            }
-        });
-        // Stop job
-        this.addSubcommand(cronCmd, {
-            name: 'stop',
-            description: 'Stop a job',
-            arguments: [{ name: 'jobId', required: true }],
-            options: [
-                { flags: '-s, --signal <signal>', description: 'Signal to send', defaultValue: 'SIGTERM' }
-            ],
-            action: async (jobId, options) => {
-                const opts = options;
-                await this.withCronManager(async (manager) => {
-                    await manager.stopJob(jobId, opts.signal);
-                });
-                this.logSuccess(`Job ${jobId} stopped with signal ${opts.signal}`);
-            }
-        });
-        // Remove job
-        this.addSubcommand(cronCmd, {
-            name: 'remove',
-            description: 'Remove a job',
-            arguments: [{ name: 'jobId', required: true }],
-            options: [
-                { flags: '-f, --force', description: 'Force removal', defaultValue: false }
-            ],
-            action: async (jobId, options) => {
-                const opts = options;
-                await this.withCronManager(async (manager) => {
-                    await manager.removeJob(jobId, opts.force);
-                });
-                this.logSuccess(`Job ${jobId} removed`);
-            }
-        });
-    }
-    registerReportingCommands(cronCmd) {
-        // Get job report
-        this.addSubcommand(cronCmd, {
-            name: 'report',
-            description: 'Get detailed job execution report',
-            arguments: [{ name: 'jobId', required: true }],
-            action: async (jobId) => {
-                const report = await this.withCronManager(async (manager) => {
-                    return await manager.getJobReport(jobId);
-                });
-                this.displayJobReport(report);
-            }
-        });
-        // Get all job reports
-        this.addSubcommand(cronCmd, {
-            name: 'reports',
-            description: 'Get reports for all jobs',
-            action: async () => {
-                const reports = await this.withCronManager(async (manager) => {
-                    return await manager.getAllJobReports();
-                });
-                this.logInfo('All Job Reports:');
-                reports.forEach(report => {
-                    this.logInfo(`\n  ${report.jobId}:`);
-                    this.logInfo(`    Executions: ${report.executions}`);
-                    this.logInfo(`    Success Rate: ${report.successRate.toFixed(1)}%`);
-                    this.logInfo(`    Last Execution: ${report.lastExecution?.toISOString() || 'Never'}`);
-                });
-            }
-        });
-        // Generate comprehensive report
-        this.addSubcommand(cronCmd, {
-            name: 'comprehensive-report',
-            description: 'Generate comprehensive job report',
-            action: async () => {
-                const report = await this.withCronManager(async (manager) => {
-                    return await manager.generateComprehensiveReport();
-                });
-                this.logInfo(report);
-            }
-        });
-        // Export job data
-        this.addSubcommand(cronCmd, {
-            name: 'export',
-            description: 'Export job data',
-            options: [
-                { flags: '-f, --format <format>', description: 'Export format (json or csv)', defaultValue: 'json' },
-                { flags: '-o, --output <file>', description: 'Output file path' }
-            ],
-            action: async (options) => {
-                const opts = options;
-                const data = await this.withCronManager(async (manager) => {
-                    return await manager.exportJobData(opts.format);
-                });
-                if (opts.output) {
-                    const fs = await import('fs');
-                    fs.writeFileSync(opts.output, data);
-                    this.logSuccess(`Data exported to ${opts.output}`);
-                }
-                else {
-                    this.logInfo(data);
-                }
-            }
-        });
-    }
-}

package/dist/services/cron/cron.js

@@ -1,9 +0,0 @@
-/**
- * Cron Service - CLI command registration
- * Uses CronCommandRegistrar for clean, maintainable command setup
- */
-import { CronCommandRegistrar } from './cron-registrar.js';
-export async function init_cron(program) {
-    const registrar = new CronCommandRegistrar();
-    await registrar.register(program);
-}