@ts-cloud/core 0.2.2 → 0.2.4

package/dist/queue/batch-processing.d.ts

@@ -0,0 +1,138 @@
+/**
+ * SQS Batch Processing
+ * Batch operations, parallel processing, and throughput optimization
+ */
+export interface BatchConfig {
+    id: string;
+    queueUrl: string;
+    batchSize: number;
+    maxWaitTime: number;
+    parallelProcessors: number;
+    retryAttempts: number;
+    visibilityTimeout: number;
+}
+export interface BatchJob {
+    id: string;
+    configId: string;
+    messages: BatchMessage[];
+    status: 'pending' | 'processing' | 'completed' | 'failed';
+    startedAt?: Date;
+    completedAt?: Date;
+    processedCount: number;
+    failedCount: number;
+}
+export interface BatchMessage {
+    id: string;
+    messageId: string;
+    body: string;
+    receiptHandle: string;
+    attributes: Record<string, any>;
+    status: 'pending' | 'processing' | 'success' | 'failed';
+    processingTime?: number;
+    error?: string;
+}
+export interface ProcessorMetrics {
+    id: string;
+    configId: string;
+    timestamp: Date;
+    messagesProcessed: number;
+    averageProcessingTime: number;
+    throughput: number;
+    errorRate: number;
+}
+/**
+ * Batch processing manager
+ */
+export declare class BatchProcessingManager {
+    private configs;
+    private jobs;
+    private metrics;
+    private configCounter;
+    private jobCounter;
+    private metricsCounter;
+    /**
+     * Create batch config
+     */
+    createBatchConfig(config: Omit<BatchConfig, 'id'>): BatchConfig;
+    /**
+     * Create high-throughput batch config
+     */
+    createHighThroughputConfig(options: {
+        queueUrl: string;
+    }): BatchConfig;
+    /**
+     * Create low-latency batch config
+     */
+    createLowLatencyConfig(options: {
+        queueUrl: string;
+    }): BatchConfig;
+    /**
+     * Create batch job
+     */
+    createBatchJob(options: {
+        configId: string;
+        messageCount: number;
+    }): BatchJob;
+    /**
+     * Process batch job
+     */
+    processBatchJob(jobId: string): Promise<BatchJob>;
+    /**
+     * Process single batch
+     */
+    private processBatch;
+    /**
+     * Process single message
+     */
+    private processMessage;
+    /**
+     * Chunk array into batches
+     */
+    private chunkArray;
+    /**
+     * Collect processor metrics
+     */
+    private collectProcessorMetrics;
+    /**
+     * Get batch statistics
+     */
+    getBatchStatistics(configId: string): {
+        totalJobsProcessed: number;
+        totalMessagesProcessed: number;
+        averageThroughput: number;
+        averageErrorRate: number;
+        averageProcessingTime: number;
+    };
+    /**
+     * Optimize batch config
+     */
+    optimizeBatchConfig(configId: string): BatchConfig;
+    /**
+     * Get config
+     */
+    getConfig(id: string): BatchConfig | undefined;
+    /**
+     * List configs
+     */
+    listConfigs(): BatchConfig[];
+    /**
+     * Get job
+     */
+    getJob(id: string): BatchJob | undefined;
+    /**
+     * List jobs
+     */
+    listJobs(configId?: string): BatchJob[];
+    /**
+     * Generate CloudFormation for Lambda batch processor
+     */
+    generateBatchProcessorCF(config: BatchConfig): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global batch processing manager instance
+ */
+export declare const batchProcessingManager: BatchProcessingManager;

package/dist/queue/dlq-monitoring.d.ts

@@ -0,0 +1,143 @@
+/**
+ * SQS Dead Letter Queue Monitoring
+ * DLQ monitoring, alerts, and automated reprocessing
+ */
+export interface DLQMonitor {
+    id: string;
+    name: string;
+    queueUrl: string;
+    sourceQueues: string[];
+    maxReceiveCount: number;
+    alarmThreshold: number;
+    autoReprocess: boolean;
+    reprocessStrategy: 'immediate' | 'scheduled' | 'manual';
+    notificationTopicArn?: string;
+}
+export interface DLQMetrics {
+    id: string;
+    queueUrl: string;
+    timestamp: Date;
+    approximateNumberOfMessages: number;
+    approximateAgeOfOldestMessage: number;
+    messagesReceived: number;
+    messagesDeleted: number;
+    messagesReprocessed: number;
+}
+export interface DLQAlert {
+    id: string;
+    monitorId: string;
+    alertType: 'threshold_exceeded' | 'old_message' | 'high_receive_count';
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    message: string;
+    timestamp: Date;
+    acknowledged: boolean;
+}
+export interface ReprocessJob {
+    id: string;
+    queueUrl: string;
+    messageId: string;
+    attempts: number;
+    status: 'pending' | 'processing' | 'success' | 'failed';
+    startedAt?: Date;
+    completedAt?: Date;
+    error?: string;
+}
+/**
+ * DLQ monitoring manager
+ */
+export declare class DLQMonitoringManager {
+    private monitors;
+    private metrics;
+    private alerts;
+    private reprocessJobs;
+    private monitorCounter;
+    private metricsCounter;
+    private alertCounter;
+    private jobCounter;
+    /**
+     * Create DLQ monitor
+     */
+    createDLQMonitor(monitor: Omit<DLQMonitor, 'id'>): DLQMonitor;
+    /**
+     * Create automated DLQ monitor
+     */
+    createAutomatedMonitor(options: {
+        name: string;
+        queueUrl: string;
+        sourceQueues: string[];
+        notificationTopicArn: string;
+    }): DLQMonitor;
+    /**
+     * Collect DLQ metrics
+     */
+    collectMetrics(queueUrl: string): DLQMetrics;
+    /**
+     * Check for alerts
+     */
+    private checkForAlerts;
+    /**
+     * Create alert
+     */
+    private createAlert;
+    /**
+     * Acknowledge alert
+     */
+    acknowledgeAlert(alertId: string): DLQAlert;
+    /**
+     * Create reprocess job
+     */
+    createReprocessJob(options: {
+        queueUrl: string;
+        messageId: string;
+    }): ReprocessJob;
+    /**
+     * Execute reprocess job
+     */
+    executeReprocessJob(jobId: string): Promise<ReprocessJob>;
+    /**
+     * Batch reprocess DLQ messages
+     */
+    batchReprocess(options: {
+        queueUrl: string;
+        maxMessages: number;
+    }): Promise<ReprocessJob[]>;
+    /**
+     * Get DLQ statistics
+     */
+    getDLQStatistics(queueUrl: string, hours?: number): {
+        totalMessages: number;
+        avgAge: number;
+        messagesReceived: number;
+        messagesDeleted: number;
+        messagesReprocessed: number;
+        successRate: number;
+    };
+    /**
+     * Get monitor
+     */
+    getMonitor(id: string): DLQMonitor | undefined;
+    /**
+     * List monitors
+     */
+    listMonitors(): DLQMonitor[];
+    /**
+     * Get alerts
+     */
+    getAlerts(monitorId?: string, acknowledged?: boolean): DLQAlert[];
+    /**
+     * Get reprocess jobs
+     */
+    getReprocessJobs(queueUrl?: string): ReprocessJob[];
+    /**
+     * Generate CloudFormation for DLQ alarm
+     */
+    generateDLQAlarmCF(monitor: DLQMonitor): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global DLQ monitoring manager instance
+ */
+export declare const dlqMonitoringManager: DLQMonitoringManager;

package/dist/queue/fifo.d.ts

@@ -0,0 +1,131 @@
+/**
+ * SQS FIFO Queue Management
+ * First-In-First-Out queues with message ordering and deduplication
+ */
+export interface FIFOQueue {
+    id: string;
+    name: string;
+    queueUrl: string;
+    contentBasedDeduplication: boolean;
+    deduplicationScope: 'queue' | 'messageGroup';
+    fifoThroughputLimit: 'perQueue' | 'perMessageGroupId';
+    messageRetentionPeriod: number;
+    visibilityTimeout: number;
+    receiveMessageWaitTime: number;
+    deadLetterTargetArn?: string;
+    maxReceiveCount?: number;
+}
+export interface MessageGroup {
+    id: string;
+    messageGroupId: string;
+    queueId: string;
+    messagesInFlight: number;
+    lastMessageTimestamp?: Date;
+}
+export interface DeduplicationConfig {
+    id: string;
+    queueId: string;
+    deduplicationInterval: number;
+    contentBasedDeduplication: boolean;
+    deduplicationHashes: Map<string, Date>;
+}
+export interface FIFOMessage {
+    id: string;
+    messageId: string;
+    messageGroupId: string;
+    messageDeduplicationId?: string;
+    body: string;
+    attributes: Record<string, any>;
+    sentTimestamp: Date;
+    sequenceNumber: string;
+}
+/**
+ * FIFO queue manager
+ */
+export declare class FIFOQueueManager {
+    private queues;
+    private messageGroups;
+    private deduplicationConfigs;
+    private messages;
+    private queueCounter;
+    private groupCounter;
+    private deduplicationCounter;
+    private messageCounter;
+    private sequenceCounter;
+    /**
+     * Create FIFO queue
+     */
+    createFIFOQueue(queue: Omit<FIFOQueue, 'id' | 'queueUrl'>): FIFOQueue;
+    /**
+     * Create high-throughput FIFO queue
+     */
+    createHighThroughputFIFO(options: {
+        name: string;
+        contentBasedDeduplication?: boolean;
+    }): FIFOQueue;
+    /**
+     * Create standard FIFO queue
+     */
+    createStandardFIFO(options: {
+        name: string;
+        contentBasedDeduplication?: boolean;
+    }): FIFOQueue;
+    /**
+     * Create deduplication config
+     */
+    private createDeduplicationConfig;
+    /**
+     * Send message to FIFO queue
+     */
+    sendMessage(options: {
+        queueId: string;
+        messageGroupId: string;
+        messageBody: string;
+        messageDeduplicationId?: string;
+        messageAttributes?: Record<string, any>;
+    }): FIFOMessage | null;
+    /**
+     * Check if message is duplicate
+     */
+    private isDuplicate;
+    /**
+     * Generate message hash
+     */
+    private generateHash;
+    /**
+     * Generate sequence number
+     */
+    private generateSequenceNumber;
+    /**
+     * Update message group
+     */
+    private updateMessageGroup;
+    /**
+     * Get message groups for queue
+     */
+    getMessageGroups(queueId: string): MessageGroup[];
+    /**
+     * Get queue
+     */
+    getQueue(id: string): FIFOQueue | undefined;
+    /**
+     * List queues
+     */
+    listQueues(): FIFOQueue[];
+    /**
+     * Get messages
+     */
+    getMessages(queueId: string, messageGroupId?: string): FIFOMessage[];
+    /**
+     * Generate CloudFormation for FIFO queue
+     */
+    generateFIFOQueueCF(queue: FIFOQueue): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global FIFO queue manager instance
+ */
+export declare const fifoQueueManager: FIFOQueueManager;

package/dist/queue/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Queue Advanced Features
+ * FIFO queues, DLQ monitoring, batch processing, and queue management
+ */
+export * from './fifo';
+export * from './dlq-monitoring';
+export * from './batch-processing';
+export * from './management';

package/dist/queue/management.d.ts

@@ -0,0 +1,162 @@
+/**
+ * SQS Queue Management
+ * Retention policies, delay queues, and queue operations
+ */
+export interface QueueManagement {
+    id: string;
+    queueUrl: string;
+    queueName: string;
+    messageRetentionPeriod: number;
+    delaySeconds: number;
+    maximumMessageSize: number;
+    receiveMessageWaitTime: number;
+    purgeInProgress: boolean;
+}
+export interface RetentionPolicy {
+    id: string;
+    queueId: string;
+    retentionPeriod: number;
+    autoCleanup: boolean;
+    cleanupSchedule?: string;
+    archiveExpiredMessages: boolean;
+    archiveS3Bucket?: string;
+}
+export interface DelayQueue {
+    id: string;
+    queueUrl: string;
+    defaultDelay: number;
+    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 declare class QueueManagementManager {
+    private queues;
+    private retentionPolicies;
+    private delayQueues;
+    private purgeOperations;
+    private metrics;
+    private queueCounter;
+    private retentionCounter;
+    private delayCounter;
+    private purgeCounter;
+    private metricsCounter;
+    /**
+     * Create queue
+     */
+    createQueue(queue: Omit<QueueManagement, 'id' | 'purgeInProgress'>): QueueManagement;
+    /**
+     * Create standard queue
+     */
+    createStandardQueue(options: {
+        queueName: string;
+        messageRetentionDays?: number;
+    }): QueueManagement;
+    /**
+     * Create long polling queue
+     */
+    createLongPollingQueue(options: {
+        queueName: string;
+        waitTimeSeconds?: number;
+    }): QueueManagement;
+    /**
+     * Create retention policy
+     */
+    createRetentionPolicy(policy: Omit<RetentionPolicy, 'id'>): RetentionPolicy;
+    /**
+     * Create short retention policy
+     */
+    createShortRetentionPolicy(options: {
+        queueId: string;
+        retentionHours: number;
+    }): RetentionPolicy;
+    /**
+     * Create archival retention policy
+     */
+    createArchivalRetentionPolicy(options: {
+        queueId: string;
+        retentionDays: number;
+        s3Bucket: string;
+    }): RetentionPolicy;
+    /**
+     * Create delay queue
+     */
+    createDelayQueue(delay: Omit<DelayQueue, 'id'>): DelayQueue;
+    /**
+     * Create scheduled delay queue
+     */
+    createScheduledDelayQueue(options: {
+        queueUrl: string;
+        delayMinutes: number;
+    }): DelayQueue;
+    /**
+     * Purge queue
+     */
+    purgeQueue(queueId: string): Promise<PurgeOperation>;
+    /**
+     * Collect queue metrics
+     */
+    collectQueueMetrics(queueUrl: string): QueueMetrics;
+    /**
+     * Get queue health
+     */
+    getQueueHealth(queueUrl: string): {
+        status: 'healthy' | 'warning' | 'critical';
+        issues: string[];
+        recommendations: string[];
+    };
+    /**
+     * Get queue
+     */
+    getQueue(id: string): QueueManagement | undefined;
+    /**
+     * List queues
+     */
+    listQueues(): QueueManagement[];
+    /**
+     * Get retention policy
+     */
+    getRetentionPolicy(id: string): RetentionPolicy | undefined;
+    /**
+     * List retention policies
+     */
+    listRetentionPolicies(): RetentionPolicy[];
+    /**
+     * Get purge operations
+     */
+    getPurgeOperations(queueUrl?: string): PurgeOperation[];
+    /**
+     * Generate CloudFormation for queue
+     */
+    generateQueueCF(queue: QueueManagement): any;
+    /**
+     * Generate CloudFormation for EventBridge rule for cleanup
+     */
+    generateCleanupRuleCF(policy: RetentionPolicy): any;
+    /**
+     * Clear all data
+     */
+    clear(): void;
+}
+/**
+ * Global queue management manager instance
+ */
+export declare const queueManagementManager: QueueManagementManager;

package/dist/queue/queue.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/resource-mgmt/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Resource Management - Tagging strategies, cost allocation, resource groups
+ */
+export interface TaggingStrategy {
+    id: string;
+    tags: Record<string, string>;
+    resources: string[];
+}
+export interface CostAllocation {
+    id: string;
+    tagKey: string;
+    allocations: Array<{
+        tagValue: string;
+        cost: number;
+    }>;
+}
+export interface ResourceGroup {
+    id: string;
+    name: string;
+    query: {
+        resourceTypeFilters: string[];
+        tagFilters: Array<{
+            key: string;
+            values: string[];
+        }>;
+    };
+}
+export declare class ResourceManagementManager {
+    private strategies;
+    private allocations;
+    private groups;
+    private counter;
+    createTaggingStrategy(tags: Record<string, string>, resources: string[]): TaggingStrategy;
+    createCostAllocation(tagKey: string, allocations: Array<{
+        tagValue: string;
+        cost: number;
+    }>): CostAllocation;
+    createResourceGroup(name: string, resourceTypeFilters: string[], tagFilters: Array<{
+        key: string;
+        values: string[];
+    }>): ResourceGroup;
+    clear(): void;
+}
+export declare const resourceManagementManager: ResourceManagementManager;

package/dist/resource-naming.d.ts

@@ -0,0 +1,26 @@
+import type { EnvironmentType } from './types';
+export interface NamingOptions {
+    slug: string;
+    environment: EnvironmentType;
+    timestamp?: string;
+    resourceType: string;
+    suffix?: string;
+}
+/**
+ * Generate a consistent resource name following the naming convention:
+ * {slug}-{environment}-{resourceType}-{timestamp}
+ */
+export declare function generateResourceName(options: NamingOptions): string;
+/**
+ * Generate a logical ID for CloudFormation resources
+ * Converts to PascalCase and removes hyphens
+ */
+export declare function generateLogicalId(name: string): string;
+/**
+ * Get current timestamp for resource naming
+ */
+export declare function getTimestamp(): string;
+/**
+ * Sanitize a name to be CloudFormation-compatible
+ */
+export declare function sanitizeName(name: string): string;