@stacksjs/ts-cloud-core 0.1.3 → 0.1.7

package/{src/preview/index.ts → dist/preview/index.d.ts}

@@ -1,32 +1,9 @@
-/**
- * Preview Environments
- * Ephemeral environments for PR/branch previews
- */
-
-export {
-  PreviewEnvironmentManager,
-  previewManager,
-} from './manager'
-
 export type {
   PreviewEnvironment,
   PreviewEnvironmentOptions,
   PreviewCleanupOptions,
-} from './manager'
-
-export {
-  generatePreviewWorkflow,
-  generateCleanupWorkflow,
-  generateCostReportWorkflow,
-} from './github'
-
-export type { GitHubWorkflowOptions } from './github'
-
-export {
-  PreviewNotificationService,
-  previewNotifications,
-} from './notifications'
-
+} from './manager';
+export type { GitHubWorkflowOptions } from './github';
 export type {
   NotificationChannel,
   SlackConfig,
@@ -34,4 +11,17 @@ export type {
   EmailConfig,
   WebhookConfig,
   NotificationEvent,
-} from './notifications'
+} from './notifications';
+export {
+  PreviewEnvironmentManager,
+  previewManager,
+} from './manager';
+export {
+  generatePreviewWorkflow,
+  generateCleanupWorkflow,
+  generateCostReportWorkflow,
+} from './github';
+export {
+  PreviewNotificationService,
+  previewNotifications,
+} from './notifications';

package/dist/preview/manager.d.ts

@@ -0,0 +1,58 @@
+import type { CloudConfig } from '@stacksjs/ts-cloud-types';
+/**
+ * Global preview environment manager instance
+ */
+export declare const previewManager: PreviewEnvironmentManager;
+export declare interface PreviewEnvironment {
+  id: string
+  name: string
+  branch: string
+  pr?: number
+  commitSha: string
+  createdAt: Date
+  expiresAt: Date
+  url?: string
+  status: 'creating' | 'active' | 'failed' | 'destroying' | 'destroyed'
+  stackName: string
+  region: string
+  resources: string[]
+  cost?: number
+}
+export declare interface PreviewEnvironmentOptions {
+  branch: string
+  pr?: number
+  commitSha: string
+  ttl?: number
+  baseConfig: CloudConfig
+  region?: string
+}
+export declare interface PreviewCleanupOptions {
+  maxAge?: number
+  keepCount?: number
+  dryRun?: boolean
+}
+/**
+ * Preview Environment Manager
+ */
+export declare class PreviewEnvironmentManager {
+  private environments: Map<string, PreviewEnvironment>;
+  createPreviewEnvironment(options: PreviewEnvironmentOptions): Promise<PreviewEnvironment>;
+  destroyPreviewEnvironment(id: string): Promise<void>;
+  getPreviewEnvironment(id: string): PreviewEnvironment | undefined;
+  getPreviewEnvironmentByBranch(branch: string): PreviewEnvironment | undefined;
+  getPreviewEnvironmentByPR(pr: number): PreviewEnvironment | undefined;
+  listPreviewEnvironments(): PreviewEnvironment[];
+  listActivePreviewEnvironments(): PreviewEnvironment[];
+  cleanupExpiredEnvironments(options?: PreviewCleanupOptions): Promise<{
+    destroyed: string[]
+    failed: string[]
+  }>;
+  updatePreviewEnvironment(id: string, commitSha: string): Promise<PreviewEnvironment>;
+  getPreviewEnvironmentsCost(): Promise<{
+    total: number
+    byEnvironment: Record<string, number>
+  }>;
+  private generatePreviewId(branch: string, pr?: number, commitSha?: string): string;
+  private generatePreviewName(branch: string, pr?: number): string;
+  private createPreviewConfig(baseConfig: CloudConfig, name: string): CloudConfig;
+}

package/dist/preview/notifications.d.ts

@@ -0,0 +1,55 @@
+import type { PreviewEnvironment } from './manager';
+/**
+ * Global notification service instance
+ */
+export declare const previewNotifications: PreviewNotificationService;
+export declare interface NotificationChannel {
+  type: 'slack' | 'discord' | 'email' | 'webhook'
+  config: SlackConfig | DiscordConfig | EmailConfig | WebhookConfig
+}
+export declare interface SlackConfig {
+  webhookUrl: string
+  channel?: string
+  username?: string
+  iconEmoji?: string
+}
+export declare interface DiscordConfig {
+  webhookUrl: string
+  username?: string
+  avatarUrl?: string
+}
+export declare interface EmailConfig {
+  from: string
+  to: string[]
+  smtpHost: string
+  smtpPort: number
+  smtpUser?: string
+  smtpPassword?: string
+}
+export declare interface WebhookConfig {
+  url: string
+  method?: 'POST' | 'GET'
+  headers?: Record<string, string>
+}
+export declare interface NotificationEvent {
+  type: 'created' | 'updated' | 'destroyed' | 'failed' | 'expired'
+  environment: PreviewEnvironment
+  timestamp: Date
+  metadata?: Record<string, any>
+}
+/**
+ * Preview environment notification service
+ */
+export declare class PreviewNotificationService {
+  private channels: NotificationChannel[];
+  addChannel(channel: NotificationChannel): void;
+  removeChannel(type: NotificationChannel['type']): void;
+  notify(event: NotificationEvent): Promise<void>;
+  private sendToChannel(channel: NotificationChannel, event: NotificationEvent): Promise<void>;
+  private sendToSlack(config: SlackConfig, event: NotificationEvent): Promise<void>;
+  private formatSlackMessage(event: NotificationEvent, config: SlackConfig): any;
+  private sendToDiscord(config: DiscordConfig, event: NotificationEvent): Promise<void>;
+  private formatDiscordMessage(event: NotificationEvent, config: DiscordConfig): any;
+  private sendToEmail(config: EmailConfig, event: NotificationEvent): Promise<void>;
+  private sendToWebhook(config: WebhookConfig, event: NotificationEvent): Promise<void>;
+}

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

@@ -0,0 +1,87 @@
+/**
+ * Global batch processing manager instance
+ */
+export declare const batchProcessingManager: BatchProcessingManager;
+/**
+ * SQS Batch Processing
+ * Batch operations, parallel processing, and throughput optimization
+ */
+export declare interface BatchConfig {
+  id: string
+  queueUrl: string
+  batchSize: number
+  maxWaitTime: number
+  parallelProcessors: number
+  retryAttempts: number
+  visibilityTimeout: number
+}
+export declare interface BatchJob {
+  id: string
+  configId: string
+  messages: BatchMessage[]
+  status: 'pending' | 'processing' | 'completed' | 'failed'
+  startedAt?: Date
+  completedAt?: Date
+  processedCount: number
+  failedCount: number
+}
+export declare interface BatchMessage {
+  id: string
+  messageId: string
+  body: string
+  receiptHandle: string
+  attributes: Record<string, any>
+  status: 'pending' | 'processing' | 'success' | 'failed'
+  processingTime?: number
+  error?: string
+}
+export declare 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: Map<string, BatchConfig>;
+  private jobs: Map<string, BatchJob>;
+  private metrics: Map<string, ProcessorMetrics[]>;
+  private configCounter: any;
+  private jobCounter: any;
+  private metricsCounter: any;
+  createBatchConfig(config: Omit<BatchConfig, 'id'>): BatchConfig;
+  createHighThroughputConfig(options: {
+    queueUrl: string
+  }): BatchConfig;
+  createLowLatencyConfig(options: {
+    queueUrl: string
+  }): BatchConfig;
+  createBatchJob(options: {
+    configId: string
+    messageCount: number
+  }): BatchJob;
+  processBatchJob(jobId: string): Promise<BatchJob>;
+  private processBatch(messages: BatchMessage[], config: BatchConfig): Promise<void>;
+  private processMessage(message: BatchMessage, config: BatchConfig): Promise<void>;
+  private chunkArray<T>(array: T[], chunkSize: number): T[][];
+  private collectProcessorMetrics(configId: string, job: BatchJob): void;
+  getBatchStatistics(configId: string): {
+    totalJobsProcessed: number
+    totalMessagesProcessed: number
+    averageThroughput: number
+    averageErrorRate: number
+    averageProcessingTime: number
+  };
+  optimizeBatchConfig(configId: string): BatchConfig;
+  getConfig(id: string): BatchConfig | undefined;
+  listConfigs(): BatchConfig[];
+  getJob(id: string): BatchJob | undefined;
+  listJobs(configId?: string): BatchJob[];
+  generateBatchProcessorCF(config: BatchConfig): any;
+  clear(): void;
+}

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

@@ -0,0 +1,95 @@
+/**
+ * Global DLQ monitoring manager instance
+ */
+export declare const dlqMonitoringManager: DLQMonitoringManager;
+/**
+ * SQS Dead Letter Queue Monitoring
+ * DLQ monitoring, alerts, and automated reprocessing
+ */
+export declare interface DLQMonitor {
+  id: string
+  name: string
+  queueUrl: string
+  sourceQueues: string[]
+  maxReceiveCount: number
+  alarmThreshold: number
+  autoReprocess: boolean
+  reprocessStrategy: 'immediate' | 'scheduled' | 'manual'
+  notificationTopicArn?: string
+}
+export declare interface DLQMetrics {
+  id: string
+  queueUrl: string
+  timestamp: Date
+  approximateNumberOfMessages: number
+  approximateAgeOfOldestMessage: number
+  messagesReceived: number
+  messagesDeleted: number
+  messagesReprocessed: number
+}
+export declare 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 declare 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: Map<string, DLQMonitor>;
+  private metrics: Map<string, DLQMetrics[]>;
+  private alerts: Map<string, DLQAlert>;
+  private reprocessJobs: Map<string, ReprocessJob>;
+  private monitorCounter: any;
+  private metricsCounter: any;
+  private alertCounter: any;
+  private jobCounter: any;
+  createDLQMonitor(monitor: Omit<DLQMonitor, 'id'>): DLQMonitor;
+  createAutomatedMonitor(options: {
+    name: string
+    queueUrl: string
+    sourceQueues: string[]
+    notificationTopicArn: string
+  }): DLQMonitor;
+  collectMetrics(queueUrl: string): DLQMetrics;
+  private checkForAlerts(queueUrl: string, metrics: DLQMetrics): void;
+  private createAlert(alert: Omit<DLQAlert, 'id' | 'timestamp' | 'acknowledged'>): DLQAlert;
+  acknowledgeAlert(alertId: string): DLQAlert;
+  createReprocessJob(options: {
+    queueUrl: string
+    messageId: string
+  }): ReprocessJob;
+  executeReprocessJob(jobId: string): Promise<ReprocessJob>;
+  batchReprocess(options: {
+    queueUrl: string
+    maxMessages: number
+  }): Promise<ReprocessJob[]>;
+  getDLQStatistics(queueUrl: string, hours?: number): {
+    totalMessages: number
+    avgAge: number
+    messagesReceived: number
+    messagesDeleted: number
+    messagesReprocessed: number
+    successRate: number
+  };
+  getMonitor(id: string): DLQMonitor | undefined;
+  listMonitors(): DLQMonitor[];
+  getAlerts(monitorId?: string, acknowledged?: boolean): DLQAlert[];
+  getReprocessJobs(queueUrl?: string): ReprocessJob[];
+  generateDLQAlarmCF(monitor: DLQMonitor): any;
+  clear(): void;
+}

package/dist/queue/fifo.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Global FIFO queue manager instance
+ */
+export declare const fifoQueueManager: FIFOQueueManager;
+/**
+ * SQS FIFO Queue Management
+ * First-In-First-Out queues with message ordering and deduplication
+ */
+export declare 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 declare interface MessageGroup {
+  id: string
+  messageGroupId: string
+  queueId: string
+  messagesInFlight: number
+  lastMessageTimestamp?: Date
+}
+export declare interface DeduplicationConfig {
+  id: string
+  queueId: string
+  deduplicationInterval: number
+  contentBasedDeduplication: boolean
+  deduplicationHashes: Map<string, Date>
+}
+export declare 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: Map<string, FIFOQueue>;
+  private messageGroups: Map<string, MessageGroup>;
+  private deduplicationConfigs: Map<string, DeduplicationConfig>;
+  private messages: Map<string, FIFOMessage>;
+  private queueCounter: any;
+  private groupCounter: any;
+  private deduplicationCounter: any;
+  private messageCounter: any;
+  private sequenceCounter: any;
+  createFIFOQueue(queue: Omit<FIFOQueue, 'id' | 'queueUrl'>): FIFOQueue;
+  createHighThroughputFIFO(options: {
+    name: string
+    contentBasedDeduplication?: boolean
+  }): FIFOQueue;
+  createStandardFIFO(options: {
+    name: string
+    contentBasedDeduplication?: boolean
+  }): FIFOQueue;
+  private createDeduplicationConfig(config: {
+    queueId: string
+    contentBasedDeduplication: boolean
+    deduplicationInterval: number
+  }): DeduplicationConfig;
+  sendMessage(options: {
+    queueId: string
+    messageGroupId: string
+    messageBody: string
+    messageDeduplicationId?: string
+    messageAttributes?: Record<string, any>
+  }): FIFOMessage | null;
+  private isDuplicate(config: DeduplicationConfig, deduplicationId: string): boolean;
+  private generateHash(content: string): string;
+  private generateSequenceNumber(): string;
+  private updateMessageGroup(queueId: string, messageGroupId: string): void;
+  getMessageGroups(queueId: string): MessageGroup[];
+  getQueue(id: string): FIFOQueue | undefined;
+  listQueues(): FIFOQueue[];
+  getMessages(queueId: string, messageGroupId?: string): FIFOMessage[];
+  generateFIFOQueueCF(queue: FIFOQueue): any;
+  clear(): void;
+}

package/dist/queue/index.d.ts

@@ -0,0 +1,4 @@
+export * from './fifo';
+export * from './dlq-monitoring';
+export * from './batch-processing';
+export * from './management';

package/dist/queue/management.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Global queue management manager instance
+ */
+export declare const queueManagementManager: QueueManagementManager;
+/**
+ * SQS Queue Management
+ * Retention policies, delay queues, and queue operations
+ */
+export declare interface QueueManagement {
+  id: string
+  queueUrl: string
+  queueName: string
+  messageRetentionPeriod: number
+  delaySeconds: number
+  maximumMessageSize: number
+  receiveMessageWaitTime: number
+  purgeInProgress: boolean
+}
+export declare interface RetentionPolicy {
+  id: string
+  queueId: string
+  retentionPeriod: number
+  autoCleanup: boolean
+  cleanupSchedule?: string
+  archiveExpiredMessages: boolean
+  archiveS3Bucket?: string
+}
+export declare interface DelayQueue {
+  id: string
+  queueUrl: string
+  defaultDelay: number
+  perMessageDelay: boolean
+  maxDelay: number
+}
+export declare interface PurgeOperation {
+  id: string
+  queueUrl: string
+  status: 'pending' | 'in_progress' | 'completed' | 'failed'
+  messagesPurged?: number
+  startedAt?: Date
+  completedAt?: Date
+}
+export declare 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: Map<string, QueueManagement>;
+  private retentionPolicies: Map<string, RetentionPolicy>;
+  private delayQueues: Map<string, DelayQueue>;
+  private purgeOperations: Map<string, PurgeOperation>;
+  private metrics: Map<string, QueueMetrics[]>;
+  private queueCounter: any;
+  private retentionCounter: any;
+  private delayCounter: any;
+  private purgeCounter: any;
+  private metricsCounter: any;
+  createQueue(queue: Omit<QueueManagement, 'id' | 'purgeInProgress'>): QueueManagement;
+  createStandardQueue(options: {
+    queueName: string
+    messageRetentionDays?: number
+  }): QueueManagement;
+  createLongPollingQueue(options: {
+    queueName: string
+    waitTimeSeconds?: number
+  }): QueueManagement;
+  createRetentionPolicy(policy: Omit<RetentionPolicy, 'id'>): RetentionPolicy;
+  createShortRetentionPolicy(options: {
+    queueId: string
+    retentionHours: number
+  }): RetentionPolicy;
+  createArchivalRetentionPolicy(options: {
+    queueId: string
+    retentionDays: number
+    s3Bucket: string
+  }): RetentionPolicy;
+  createDelayQueue(delay: Omit<DelayQueue, 'id'>): DelayQueue;
+  createScheduledDelayQueue(options: {
+    queueUrl: string
+    delayMinutes: number
+  }): DelayQueue;
+  purgeQueue(queueId: string): Promise<PurgeOperation>;
+  collectQueueMetrics(queueUrl: string): QueueMetrics;
+  getQueueHealth(queueUrl: string): {
+    status: 'healthy' | 'warning' | 'critical'
+    issues: string[]
+    recommendations: string[]
+  };
+  getQueue(id: string): QueueManagement | undefined;
+  listQueues(): QueueManagement[];
+  getRetentionPolicy(id: string): RetentionPolicy | undefined;
+  listRetentionPolicies(): RetentionPolicy[];
+  getPurgeOperations(queueUrl?: string): PurgeOperation[];
+  generateQueueCF(queue: QueueManagement): any;
+  generateCleanupRuleCF(policy: RetentionPolicy): any;
+  clear(): void;
+}

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

@@ -0,0 +1,29 @@
+export declare const resourceManagementManager: ResourceManagementManager;
+/**
+ * Resource Management - Tagging strategies, cost allocation, resource groups
+ */
+export declare interface TaggingStrategy {
+  id: string
+  tags: Record<string, string>
+  resources: string[]
+}
+export declare interface CostAllocation {
+  id: string
+  tagKey: string
+  allocations: Array<{ tagValue: string; cost: number }>
+}
+export declare interface ResourceGroup {
+  id: string
+  name: string
+  query: { resourceTypeFilters: string[]; tagFilters: Array<{ key: string; values: string[] }> }
+}
+export declare class ResourceManagementManager {
+  private strategies: any;
+  private allocations: any;
+  private groups: any;
+  private counter: any;
+  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;
+}

package/dist/resource-naming.d.ts

@@ -0,0 +1,26 @@
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+/**
+ * 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;
+export declare interface NamingOptions {
+  slug: string
+  environment: EnvironmentType
+  timestamp?: string
+  resourceType: string
+  suffix?: string
+}