@stacksjs/ts-cloud-core 0.1.2 → 0.1.6

package/src/queue/management.ts

@@ -1,428 +0,0 @@
-/**
- * SQS Queue Management
- * Retention policies, delay queues, and queue operations
- */
-
-export interface QueueManagement {
-  id: string
-  queueUrl: string
-  queueName: string
-  messageRetentionPeriod: number // seconds (60 - 1209600)
-  delaySeconds: number // 0-900
-  maximumMessageSize: number // bytes
-  receiveMessageWaitTime: number // seconds (long polling)
-  purgeInProgress: boolean
-}
-
-export interface RetentionPolicy {
-  id: string
-  queueId: string
-  retentionPeriod: number // seconds
-  autoCleanup: boolean
-  cleanupSchedule?: string
-  archiveExpiredMessages: boolean
-  archiveS3Bucket?: string
-}
-
-export interface DelayQueue {
-  id: string
-  queueUrl: string
-  defaultDelay: number // seconds
-  perMessageDelay: boolean
-  maxDelay: number
-}
-
-export interface PurgeOperation {
-  id: string
-  queueUrl: string
-  status: 'pending' | 'in_progress' | 'completed' | 'failed'
-  messagesPurged?: number
-  startedAt?: Date
-  completedAt?: Date
-}
-
-export interface QueueMetrics {
-  id: string
-  queueUrl: string
-  timestamp: Date
-  approximateNumberOfMessages: number
-  approximateNumberOfMessagesNotVisible: number
-  approximateNumberOfMessagesDelayed: number
-  oldestMessageAge?: number
-}
-
-/**
- * Queue management manager
- */
-export class QueueManagementManager {
-  private queues: Map<string, QueueManagement> = new Map()
-  private retentionPolicies: Map<string, RetentionPolicy> = new Map()
-  private delayQueues: Map<string, DelayQueue> = new Map()
-  private purgeOperations: Map<string, PurgeOperation> = new Map()
-  private metrics: Map<string, QueueMetrics[]> = new Map()
-  private queueCounter = 0
-  private retentionCounter = 0
-  private delayCounter = 0
-  private purgeCounter = 0
-  private metricsCounter = 0
-
-  /**
-   * Create queue
-   */
-  createQueue(queue: Omit<QueueManagement, 'id' | 'purgeInProgress'>): QueueManagement {
-    const id = `queue-${Date.now()}-${this.queueCounter++}`
-
-    const queueManagement: QueueManagement = {
-      id,
-      purgeInProgress: false,
-      ...queue,
-    }
-
-    this.queues.set(id, queueManagement)
-
-    return queueManagement
-  }
-
-  /**
-   * Create standard queue
-   */
-  createStandardQueue(options: {
-    queueName: string
-    messageRetentionDays?: number
-  }): QueueManagement {
-    return this.createQueue({
-      queueUrl: `https://sqs.us-east-1.amazonaws.com/123456789012/${options.queueName}`,
-      queueName: options.queueName,
-      messageRetentionPeriod: (options.messageRetentionDays || 4) * 24 * 60 * 60,
-      delaySeconds: 0,
-      maximumMessageSize: 256 * 1024, // 256 KB
-      receiveMessageWaitTime: 0,
-    })
-  }
-
-  /**
-   * Create long polling queue
-   */
-  createLongPollingQueue(options: {
-    queueName: string
-    waitTimeSeconds?: number
-  }): QueueManagement {
-    return this.createQueue({
-      queueUrl: `https://sqs.us-east-1.amazonaws.com/123456789012/${options.queueName}`,
-      queueName: options.queueName,
-      messageRetentionPeriod: 345600, // 4 days
-      delaySeconds: 0,
-      maximumMessageSize: 256 * 1024,
-      receiveMessageWaitTime: options.waitTimeSeconds || 20,
-    })
-  }
-
-  /**
-   * Create retention policy
-   */
-  createRetentionPolicy(policy: Omit<RetentionPolicy, 'id'>): RetentionPolicy {
-    const id = `retention-${Date.now()}-${this.retentionCounter++}`
-
-    const retentionPolicy: RetentionPolicy = {
-      id,
-      ...policy,
-    }
-
-    this.retentionPolicies.set(id, retentionPolicy)
-
-    // Update queue retention
-    const queue = this.queues.get(policy.queueId)
-    if (queue) {
-      queue.messageRetentionPeriod = policy.retentionPeriod
-    }
-
-    return retentionPolicy
-  }
-
-  /**
-   * Create short retention policy
-   */
-  createShortRetentionPolicy(options: {
-    queueId: string
-    retentionHours: number
-  }): RetentionPolicy {
-    return this.createRetentionPolicy({
-      queueId: options.queueId,
-      retentionPeriod: options.retentionHours * 60 * 60,
-      autoCleanup: true,
-      archiveExpiredMessages: false,
-    })
-  }
-
-  /**
-   * Create archival retention policy
-   */
-  createArchivalRetentionPolicy(options: {
-    queueId: string
-    retentionDays: number
-    s3Bucket: string
-  }): RetentionPolicy {
-    return this.createRetentionPolicy({
-      queueId: options.queueId,
-      retentionPeriod: options.retentionDays * 24 * 60 * 60,
-      autoCleanup: true,
-      cleanupSchedule: 'cron(0 0 * * ? *)', // Daily at midnight
-      archiveExpiredMessages: true,
-      archiveS3Bucket: options.s3Bucket,
-    })
-  }
-
-  /**
-   * Create delay queue
-   */
-  createDelayQueue(delay: Omit<DelayQueue, 'id'>): DelayQueue {
-    const id = `delay-${Date.now()}-${this.delayCounter++}`
-
-    const delayQueue: DelayQueue = {
-      id,
-      ...delay,
-    }
-
-    this.delayQueues.set(id, delayQueue)
-
-    // Update queue delay
-    const queue = Array.from(this.queues.values()).find(q => q.queueUrl === delay.queueUrl)
-    if (queue) {
-      queue.delaySeconds = delay.defaultDelay
-    }
-
-    return delayQueue
-  }
-
-  /**
-   * Create scheduled delay queue
-   */
-  createScheduledDelayQueue(options: {
-    queueUrl: string
-    delayMinutes: number
-  }): DelayQueue {
-    return this.createDelayQueue({
-      queueUrl: options.queueUrl,
-      defaultDelay: options.delayMinutes * 60,
-      perMessageDelay: false,
-      maxDelay: 900, // 15 minutes max
-    })
-  }
-
-  /**
-   * Purge queue
-   */
-  async purgeQueue(queueId: string): Promise<PurgeOperation> {
-    const queue = this.queues.get(queueId)
-
-    if (!queue) {
-      throw new Error(`Queue not found: ${queueId}`)
-    }
-
-    if (queue.purgeInProgress) {
-      throw new Error('Purge already in progress for this queue')
-    }
-
-    const id = `purge-${Date.now()}-${this.purgeCounter++}`
-
-    const purgeOp: PurgeOperation = {
-      id,
-      queueUrl: queue.queueUrl,
-      status: 'in_progress',
-      startedAt: new Date(),
-    }
-
-    this.purgeOperations.set(id, purgeOp)
-    queue.purgeInProgress = true
-
-    // Simulate purge operation
-    setTimeout(() => {
-      purgeOp.status = 'completed'
-      purgeOp.completedAt = new Date()
-      purgeOp.messagesPurged = Math.floor(Math.random() * 1000)
-      queue.purgeInProgress = false
-    }, 100)
-
-    return purgeOp
-  }
-
-  /**
-   * Collect queue metrics
-   */
-  collectQueueMetrics(queueUrl: string): QueueMetrics {
-    const id = `metrics-${Date.now()}-${this.metricsCounter++}`
-
-    const metrics: QueueMetrics = {
-      id,
-      queueUrl,
-      timestamp: new Date(),
-      approximateNumberOfMessages: Math.floor(Math.random() * 1000),
-      approximateNumberOfMessagesNotVisible: Math.floor(Math.random() * 100),
-      approximateNumberOfMessagesDelayed: Math.floor(Math.random() * 50),
-      oldestMessageAge: Math.floor(Math.random() * 86400),
-    }
-
-    const queueMetrics = this.metrics.get(queueUrl) || []
-    queueMetrics.push(metrics)
-    this.metrics.set(queueUrl, queueMetrics)
-
-    return metrics
-  }
-
-  /**
-   * Get queue health
-   */
-  getQueueHealth(queueUrl: string): {
-    status: 'healthy' | 'warning' | 'critical'
-    issues: string[]
-    recommendations: string[]
-  } {
-    const metricsHistory = this.metrics.get(queueUrl) || []
-
-    if (metricsHistory.length === 0) {
-      return {
-        status: 'healthy',
-        issues: [],
-        recommendations: [],
-      }
-    }
-
-    const latest = metricsHistory[metricsHistory.length - 1]
-    const issues: string[] = []
-    const recommendations: string[] = []
-    let status: 'healthy' | 'warning' | 'critical' = 'healthy'
-
-    // Check message backlog
-    if (latest.approximateNumberOfMessages > 10000) {
-      status = 'critical'
-      issues.push('Large message backlog detected')
-      recommendations.push('Increase consumer capacity')
-    } else if (latest.approximateNumberOfMessages > 1000) {
-      status = 'warning'
-      issues.push('Growing message backlog')
-      recommendations.push('Monitor consumer performance')
-    }
-
-    // Check message age
-    if (latest.oldestMessageAge && latest.oldestMessageAge > 3600) {
-      if (status !== 'critical') status = 'warning'
-      issues.push('Old messages in queue')
-      recommendations.push('Review message processing')
-    }
-
-    // Check delayed messages
-    if (latest.approximateNumberOfMessagesDelayed > 100) {
-      if (status !== 'critical') status = 'warning'
-      issues.push('High number of delayed messages')
-    }
-
-    return {
-      status,
-      issues,
-      recommendations,
-    }
-  }
-
-  /**
-   * Get queue
-   */
-  getQueue(id: string): QueueManagement | undefined {
-    return this.queues.get(id)
-  }
-
-  /**
-   * List queues
-   */
-  listQueues(): QueueManagement[] {
-    return Array.from(this.queues.values())
-  }
-
-  /**
-   * Get retention policy
-   */
-  getRetentionPolicy(id: string): RetentionPolicy | undefined {
-    return this.retentionPolicies.get(id)
-  }
-
-  /**
-   * List retention policies
-   */
-  listRetentionPolicies(): RetentionPolicy[] {
-    return Array.from(this.retentionPolicies.values())
-  }
-
-  /**
-   * Get purge operations
-   */
-  getPurgeOperations(queueUrl?: string): PurgeOperation[] {
-    let operations = Array.from(this.purgeOperations.values())
-
-    if (queueUrl) {
-      operations = operations.filter(op => op.queueUrl === queueUrl)
-    }
-
-    return operations
-  }
-
-  /**
-   * Generate CloudFormation for queue
-   */
-  generateQueueCF(queue: QueueManagement): any {
-    return {
-      Type: 'AWS::SQS::Queue',
-      Properties: {
-        QueueName: queue.queueName,
-        MessageRetentionPeriod: queue.messageRetentionPeriod,
-        DelaySeconds: queue.delaySeconds,
-        MaximumMessageSize: queue.maximumMessageSize,
-        ReceiveMessageWaitTimeSeconds: queue.receiveMessageWaitTime,
-      },
-    }
-  }
-
-  /**
-   * Generate CloudFormation for EventBridge rule for cleanup
-   */
-  generateCleanupRuleCF(policy: RetentionPolicy): any {
-    return {
-      Type: 'AWS::Events::Rule',
-      Properties: {
-        Name: `${policy.id}-cleanup`,
-        Description: 'Automated queue cleanup',
-        ScheduleExpression: policy.cleanupSchedule || 'cron(0 0 * * ? *)',
-        State: 'ENABLED',
-        Targets: [
-          {
-            Arn: 'arn:aws:lambda:us-east-1:123456789012:function:queue-cleanup',
-            Id: policy.id,
-            Input: JSON.stringify({
-              queueId: policy.queueId,
-              archiveBucket: policy.archiveS3Bucket,
-            }),
-          },
-        ],
-      },
-    }
-  }
-
-  /**
-   * Clear all data
-   */
-  clear(): void {
-    this.queues.clear()
-    this.retentionPolicies.clear()
-    this.delayQueues.clear()
-    this.purgeOperations.clear()
-    this.metrics.clear()
-    this.queueCounter = 0
-    this.retentionCounter = 0
-    this.delayCounter = 0
-    this.purgeCounter = 0
-    this.metricsCounter = 0
-  }
-}
-
-/**
- * Global queue management manager instance
- */
-export const queueManagementManager: QueueManagementManager = new QueueManagementManager()