lsh-framework 3.2.5 → 3.5.1

package/dist/lib/optimized-job-scheduler.js

@@ -1,356 +0,0 @@
-/**
- * Optimized Job Scheduler
- *
- * A priority queue-based job scheduler that efficiently manages scheduled jobs.
- * Instead of linearly scanning all jobs every 2 seconds, this scheduler uses
- * a min-heap to only check jobs that are actually due.
- *
- * Performance Improvements:
- * - O(log n) job insertion/removal vs O(n) linear scan
- * - O(1) to check if any jobs are due
- * - Only processes jobs that are actually due
- * - Smart sleep intervals based on next job time
- *
- * @see Issue #108: PERFORMANCE: Optimize daemon job scheduling algorithm
- */
-import { MinHeap } from './min-heap.js';
-import { createLogger } from './logger.js';
-import { EventEmitter } from 'events';
-const DEFAULT_CONFIG = {
-    minCheckInterval: 100,
-    maxCheckInterval: 60000,
-    dueBuffer: 50,
-    debug: false,
-};
-export class OptimizedJobScheduler extends EventEmitter {
-    heap;
-    jobMap = new Map();
-    config;
-    logger = createLogger('OptimizedJobScheduler');
-    checkTimer;
-    isRunning = false;
-    lastRunTimes = new Map();
-    // Metrics tracking
-    metrics = {
-        totalJobs: 0,
-        dueJobs: 0,
-        nextCheckTime: 0,
-        averageCheckTime: 0,
-        memoryUsage: 0,
-        totalChecks: 0,
-        totalExecuted: 0,
-    };
-    checkTimings = [];
-    MAX_TIMING_SAMPLES = 100;
-    constructor(config = {}) {
-        super();
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        this.heap = new MinHeap(entry => entry.nextRun, entry => entry.jobId);
-    }
-    /**
-     * Start the scheduler
-     */
-    start() {
-        if (this.isRunning) {
-            return;
-        }
-        this.isRunning = true;
-        this.logger.info('Optimized job scheduler started');
-        this.scheduleNextCheck();
-    }
-    /**
-     * Stop the scheduler
-     */
-    stop() {
-        this.isRunning = false;
-        if (this.checkTimer) {
-            clearTimeout(this.checkTimer);
-            this.checkTimer = undefined;
-        }
-        this.logger.info('Optimized job scheduler stopped');
-    }
-    /**
-     * Add a job to the scheduler
-     * @param job The job specification
-     */
-    addJob(job) {
-        if (!job.schedule) {
-            return; // Only scheduled jobs go in the heap
-        }
-        const nextRun = this.calculateNextRun(job);
-        if (nextRun === null) {
-            return; // No valid schedule
-        }
-        const entry = {
-            jobId: job.id,
-            jobName: job.name,
-            nextRun,
-            job,
-        };
-        // Remove existing entry if present
-        if (this.jobMap.has(job.id)) {
-            this.heap.removeById(job.id);
-        }
-        this.heap.push(entry);
-        this.jobMap.set(job.id, entry);
-        this.metrics.totalJobs = this.jobMap.size;
-        if (this.config.debug) {
-            this.logger.debug(`Added job ${job.id} (${job.name}), next run: ${new Date(nextRun).toISOString()}`);
-        }
-        // Reschedule check if this job is due sooner than the current next check
-        if (this.isRunning && nextRun < this.metrics.nextCheckTime) {
-            this.scheduleNextCheck();
-        }
-    }
-    /**
-     * Remove a job from the scheduler
-     * @param jobId The job ID to remove
-     * @returns true if removed, false if not found
-     */
-    removeJob(jobId) {
-        const removed = this.heap.removeById(jobId);
-        const existed = this.jobMap.delete(jobId);
-        this.lastRunTimes.delete(jobId);
-        this.metrics.totalJobs = this.jobMap.size;
-        return existed || removed !== undefined;
-    }
-    /**
-     * Update a job in the scheduler
-     * @param job Updated job specification
-     */
-    updateJob(job) {
-        this.removeJob(job.id);
-        this.addJob(job);
-    }
-    /**
-     * Get jobs that are currently due
-     * @returns Array of jobs ready to execute
-     */
-    getDueJobs() {
-        const startTime = Date.now();
-        const now = startTime + this.config.dueBuffer;
-        const dueJobs = [];
-        // Pop all jobs that are due
-        while (!this.heap.isEmpty() && this.heap.peek().nextRun <= now) {
-            const entry = this.heap.pop();
-            const job = entry.job;
-            // Check if we haven't run this job in the current minute (for cron jobs)
-            if (job.schedule?.cron) {
-                const currentMinute = Math.floor(now / 60000);
-                const lastRun = this.lastRunTimes.get(job.id);
-                if (lastRun === currentMinute) {
-                    // Already ran this minute, reschedule for next run (force recalculate)
-                    const nextRun = this.calculateNextRun(job, new Date(now + 60000), true);
-                    if (nextRun !== null) {
-                        entry.nextRun = nextRun;
-                        this.heap.push(entry);
-                    }
-                    continue;
-                }
-                this.lastRunTimes.set(job.id, currentMinute);
-            }
-            dueJobs.push(job);
-            // Reschedule for next run if it's a recurring job (force recalculate)
-            const nextRun = this.calculateNextRun(job, new Date(now), true);
-            if (nextRun !== null) {
-                entry.nextRun = nextRun;
-                entry.job = job; // Keep updated job reference
-                this.heap.push(entry);
-                this.jobMap.set(job.id, entry);
-            }
-            else {
-                this.jobMap.delete(job.id);
-            }
-        }
-        // Update metrics
-        const checkTime = Date.now() - startTime;
-        this.recordCheckTiming(checkTime);
-        this.metrics.dueJobs = dueJobs.length;
-        this.metrics.totalExecuted += dueJobs.length;
-        return dueJobs;
-    }
-    /**
-     * Check and execute due jobs
-     * Emits 'jobDue' event for each job that should be executed
-     */
-    checkScheduledJobs() {
-        this.metrics.totalChecks++;
-        const dueJobs = this.getDueJobs();
-        for (const job of dueJobs) {
-            this.emit('jobDue', job);
-        }
-        // Schedule next check
-        if (this.isRunning) {
-            this.scheduleNextCheck();
-        }
-        return dueJobs;
-    }
-    /**
-     * Get scheduler metrics
-     */
-    getMetrics() {
-        return {
-            ...this.metrics,
-            totalJobs: this.jobMap.size,
-            memoryUsage: this.estimateMemoryUsage(),
-        };
-    }
-    /**
-     * Calculate the next run time for a job
-     * @param job The job specification
-     * @param fromDate Optional date to calculate from (used for rescheduling after due)
-     * @param forceRecalculate If true, ignore existing nextRun and calculate fresh
-     */
-    calculateNextRun(job, fromDate, forceRecalculate = false) {
-        const now = fromDate || new Date();
-        if (job.schedule?.cron) {
-            return this.getNextCronRun(job.schedule.cron, now);
-        }
-        if (job.schedule?.interval) {
-            // When adding a new job, use the provided nextRun (even if in the past - job is due)
-            if (job.schedule.nextRun && !forceRecalculate) {
-                const nextRunTime = job.schedule.nextRun instanceof Date
-                    ? job.schedule.nextRun.getTime()
-                    : new Date(job.schedule.nextRun).getTime();
-                return nextRunTime;
-            }
-            // Calculate next interval run (used when rescheduling after execution)
-            return now.getTime() + job.schedule.interval;
-        }
-        return null;
-    }
-    /**
-     * Calculate next cron run time
-     */
-    getNextCronRun(cronExpr, from) {
-        try {
-            const [minute, hour, day, month, weekday] = cronExpr.split(' ');
-            const now = new Date(from);
-            // Try to find next matching time within the next 32 days
-            // (covers monthly cron expressions like "0 0 1 * *")
-            for (let i = 0; i < 32 * 24 * 60; i++) {
-                const checkTime = new Date(now.getTime() + i * 60000);
-                if (this.matchesCronField(minute, checkTime.getMinutes(), 0, 59) &&
-                    this.matchesCronField(hour, checkTime.getHours(), 0, 23) &&
-                    this.matchesCronField(day, checkTime.getDate(), 1, 31) &&
-                    this.matchesCronField(month, checkTime.getMonth() + 1, 1, 12) &&
-                    this.matchesCronField(weekday, checkTime.getDay(), 0, 6)) {
-                    // Round to start of minute
-                    checkTime.setSeconds(0, 0);
-                    // Only return if it's in the future
-                    if (checkTime.getTime() > from.getTime()) {
-                        return checkTime.getTime();
-                    }
-                }
-            }
-            return null;
-        }
-        catch (_error) {
-            this.logger.error(`Invalid cron expression: ${cronExpr}`);
-            return null;
-        }
-    }
-    /**
-     * Match a single cron field against a value
-     */
-    matchesCronField(field, value, _min, _max) {
-        // Handle wildcard
-        if (field === '*') {
-            return true;
-        }
-        // Handle specific number
-        if (/^\d+$/.test(field)) {
-            return parseInt(field, 10) === value;
-        }
-        // Handle intervals (*/5)
-        if (field.startsWith('*/')) {
-            const interval = parseInt(field.substring(2), 10);
-            return value % interval === 0;
-        }
-        // Handle ranges (1-5)
-        if (field.includes('-') && !field.includes(',')) {
-            const [start, end] = field.split('-').map(x => parseInt(x, 10));
-            return value >= start && value <= end;
-        }
-        // Handle lists (1,3,5)
-        if (field.includes(',')) {
-            const values = field.split(',').map(x => parseInt(x.trim(), 10));
-            return values.includes(value);
-        }
-        // Handle step values (1-10/2)
-        if (field.includes('/')) {
-            const [range, step] = field.split('/');
-            const stepNum = parseInt(step, 10);
-            if (range === '*') {
-                return value % stepNum === 0;
-            }
-            if (range.includes('-')) {
-                const [start, end] = range.split('-').map(x => parseInt(x, 10));
-                if (value < start || value > end)
-                    return false;
-                return (value - start) % stepNum === 0;
-            }
-        }
-        return false;
-    }
-    /**
-     * Schedule the next check based on when jobs are due
-     */
-    scheduleNextCheck() {
-        if (this.checkTimer) {
-            clearTimeout(this.checkTimer);
-        }
-        if (!this.isRunning) {
-            return;
-        }
-        let delay;
-        if (this.heap.isEmpty()) {
-            // No jobs, wait for max interval
-            delay = this.config.maxCheckInterval;
-        }
-        else {
-            const nextJob = this.heap.peek();
-            const timeUntilDue = nextJob.nextRun - Date.now();
-            // Clamp delay between min and max
-            delay = Math.max(this.config.minCheckInterval, Math.min(this.config.maxCheckInterval, timeUntilDue));
-        }
-        this.metrics.nextCheckTime = Date.now() + delay;
-        this.checkTimer = setTimeout(() => {
-            this.checkScheduledJobs();
-        }, delay);
-    }
-    /**
-     * Record check timing for metrics
-     */
-    recordCheckTiming(timing) {
-        this.checkTimings.push(timing);
-        if (this.checkTimings.length > this.MAX_TIMING_SAMPLES) {
-            this.checkTimings.shift();
-        }
-        this.metrics.averageCheckTime =
-            this.checkTimings.reduce((sum, t) => sum + t, 0) / this.checkTimings.length;
-    }
-    /**
-     * Estimate memory usage
-     */
-    estimateMemoryUsage() {
-        // Rough estimate: ~500 bytes per entry
-        return this.jobMap.size * 500;
-    }
-    /**
-     * Get time until next job is due
-     */
-    getTimeUntilNextJob() {
-        if (this.heap.isEmpty()) {
-            return null;
-        }
-        return Math.max(0, this.heap.peek().nextRun - Date.now());
-    }
-    /**
-     * Get all scheduled jobs (for debugging/status)
-     */
-    getAllJobs() {
-        return Array.from(this.jobMap.values());
-    }
-}
-export default OptimizedJobScheduler;

package/dist/lib/saas-audit.js

@@ -1,215 +0,0 @@
-/**
- * LSH SaaS Audit Logging Service
- * Comprehensive audit trail for all actions
- */
-import { getSupabaseClient } from './supabase-client.js';
-/**
- * Audit Logger Service
- */
-export class AuditLogger {
-    supabase = getSupabaseClient();
-    /**
-     * Log an audit event
-     */
-    async log(input) {
-        try {
-            const { error } = await this.supabase.from('audit_logs').insert({
-                organization_id: input.organizationId,
-                team_id: input.teamId || null,
-                user_id: input.userId || null,
-                user_email: input.userEmail || null,
-                action: input.action,
-                resource_type: input.resourceType,
-                resource_id: input.resourceId || null,
-                ip_address: input.ipAddress || null,
-                user_agent: input.userAgent || null,
-                metadata: input.metadata || {},
-                old_value: input.oldValue || null,
-                new_value: input.newValue || null,
-                timestamp: new Date().toISOString(),
-            });
-            if (error) {
-                console.error('Failed to write audit log:', error);
-                // Don't throw - audit logging should not break the main operation
-            }
-        }
-        catch (error) {
-            console.error('Audit logging error:', error);
-            // Don't throw - audit logging should not break the main operation
-        }
-    }
-    /**
-     * Get audit logs for organization
-     */
-    async getOrganizationLogs(organizationId, options = {}) {
-        let query = this.supabase
-            .from('audit_logs')
-            .select('*', { count: 'exact' })
-            .eq('organization_id', organizationId);
-        if (options.startDate) {
-            query = query.gte('timestamp', options.startDate.toISOString());
-        }
-        if (options.endDate) {
-            query = query.lte('timestamp', options.endDate.toISOString());
-        }
-        if (options.action) {
-            query = query.eq('action', options.action);
-        }
-        if (options.userId) {
-            query = query.eq('user_id', options.userId);
-        }
-        if (options.teamId) {
-            query = query.eq('team_id', options.teamId);
-        }
-        query = query.order('timestamp', { ascending: false });
-        if (options.limit) {
-            query = query.limit(options.limit);
-        }
-        if (options.offset) {
-            query = query.range(options.offset, options.offset + (options.limit || 50) - 1);
-        }
-        const { data, count, error } = await query;
-        if (error) {
-            throw new Error(`Failed to get audit logs: ${error.message}`);
-        }
-        return {
-            logs: (data || []).map(this.mapDbLogToLog),
-            total: count || 0,
-        };
-    }
-    /**
-     * Get audit logs for a specific resource
-     */
-    async getResourceLogs(organizationId, resourceType, resourceId, limit = 50) {
-        const { data, error } = await this.supabase
-            .from('audit_logs')
-            .select('*')
-            .eq('organization_id', organizationId)
-            .eq('resource_type', resourceType)
-            .eq('resource_id', resourceId)
-            .order('timestamp', { ascending: false })
-            .limit(limit);
-        if (error) {
-            throw new Error(`Failed to get resource logs: ${error.message}`);
-        }
-        return (data || []).map(this.mapDbLogToLog);
-    }
-    /**
-     * Get audit logs for a team
-     */
-    async getTeamLogs(teamId, options = {}) {
-        let query = this.supabase
-            .from('audit_logs')
-            .select('*', { count: 'exact' })
-            .eq('team_id', teamId);
-        if (options.startDate) {
-            query = query.gte('timestamp', options.startDate.toISOString());
-        }
-        if (options.endDate) {
-            query = query.lte('timestamp', options.endDate.toISOString());
-        }
-        query = query.order('timestamp', { ascending: false });
-        if (options.limit) {
-            query = query.limit(options.limit);
-        }
-        if (options.offset) {
-            query = query.range(options.offset, options.offset + (options.limit || 50) - 1);
-        }
-        const { data, count, error } = await query;
-        if (error) {
-            throw new Error(`Failed to get team logs: ${error.message}`);
-        }
-        return {
-            logs: (data || []).map(this.mapDbLogToLog),
-            total: count || 0,
-        };
-    }
-    /**
-     * Get audit logs for a user
-     */
-    async getUserLogs(userId, options = {}) {
-        let query = this.supabase
-            .from('audit_logs')
-            .select('*', { count: 'exact' })
-            .eq('user_id', userId);
-        if (options.startDate) {
-            query = query.gte('timestamp', options.startDate.toISOString());
-        }
-        if (options.endDate) {
-            query = query.lte('timestamp', options.endDate.toISOString());
-        }
-        query = query.order('timestamp', { ascending: false });
-        if (options.limit) {
-            query = query.limit(options.limit);
-        }
-        if (options.offset) {
-            query = query.range(options.offset, options.offset + (options.limit || 50) - 1);
-        }
-        const { data, count, error } = await query;
-        if (error) {
-            throw new Error(`Failed to get user logs: ${error.message}`);
-        }
-        return {
-            logs: (data || []).map(this.mapDbLogToLog),
-            total: count || 0,
-        };
-    }
-    /**
-     * Delete old audit logs (for retention policy)
-     */
-    async deleteOldLogs(organizationId, retentionDays) {
-        const cutoffDate = new Date();
-        cutoffDate.setDate(cutoffDate.getDate() - retentionDays);
-        const { count, error } = await this.supabase
-            .from('audit_logs')
-            .delete({ count: 'exact' })
-            .eq('organization_id', organizationId)
-            .lt('timestamp', cutoffDate.toISOString());
-        if (error) {
-            throw new Error(`Failed to delete old logs: ${error.message}`);
-        }
-        return count || 0;
-    }
-    /**
-     * Map database log to AuditLog type
-     */
-    mapDbLogToLog(dbLog) {
-        return {
-            id: dbLog.id,
-            organizationId: dbLog.organization_id,
-            teamId: dbLog.team_id,
-            userId: dbLog.user_id,
-            userEmail: dbLog.user_email,
-            action: dbLog.action,
-            resourceType: dbLog.resource_type,
-            resourceId: dbLog.resource_id,
-            ipAddress: dbLog.ip_address,
-            userAgent: dbLog.user_agent,
-            metadata: dbLog.metadata || {},
-            oldValue: dbLog.old_value,
-            newValue: dbLog.new_value,
-            timestamp: new Date(dbLog.timestamp),
-        };
-    }
-}
-/**
- * Singleton instance
- */
-export const auditLogger = new AuditLogger();
-/**
- * Helper function to extract IP from request
- */
-export function getIpFromRequest(req) {
-    const forwarded = req.headers['x-forwarded-for'];
-    const forwardedIp = typeof forwarded === 'string' ? forwarded.split(',')[0].trim() : undefined;
-    const realIp = req.headers['x-real-ip'];
-    return (forwardedIp ||
-        (typeof realIp === 'string' ? realIp : undefined) ||
-        req.socket?.remoteAddress);
-}
-/**
- * Helper function to extract user agent from request
- */
-export function getUserAgentFromRequest(req) {
-    return req.headers['user-agent'];
-}