@stacksjs/ts-cloud-core 0.1.6 → 0.1.7

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
+}

package/dist/s3/index.d.ts

@@ -0,0 +1,173 @@
+export declare const storageAdvancedManager: StorageAdvancedManager;
+/**
+ * S3 Advanced Features
+ * Object Lock, Transfer Acceleration, Access Points, Glacier, Inventory, Batch Operations, Event Notifications
+ */
+export declare interface LifecyclePolicy {
+  id: string
+  transitions: Array<{ days: number; storageClass: string }>
+  expiration?: number
+}
+export declare interface VersioningConfig {
+  id: string
+  enabled: boolean
+  mfaDelete: boolean
+}
+export declare interface ReplicationRule {
+  id: string
+  sourceRegion: string
+  destRegion: string
+  destBucket: string
+}
+export declare interface IntelligentTieringConfig {
+  id: string
+  archiveDays: number
+  deepArchiveDays: number
+}
+export declare interface ObjectLockConfig {
+  id: string
+  bucketName: string
+  mode: 'COMPLIANCE' | 'GOVERNANCE'
+  retentionDays?: number
+  retentionYears?: number
+  legalHoldEnabled: boolean
+}
+export declare interface TransferAccelerationConfig {
+  id: string
+  bucketName: string
+  enabled: boolean
+  endpoint: string
+}
+export declare interface AccessPoint {
+  id: string
+  name: string
+  bucketName: string
+  vpcId?: string
+  publicAccessBlock: boolean
+  policy?: Record<string, any>
+}
+export declare interface GlacierArchiveConfig {
+  id: string
+  bucketName: string
+  archiveType: 'GLACIER' | 'DEEP_ARCHIVE'
+  transitionDays: number
+  restoreConfig?: {
+    tier: 'Expedited' | 'Standard' | 'Bulk'
+    days: number
+  }
+}
+export declare interface InventoryConfig {
+  id: string
+  sourceBucket: string
+  destinationBucket: string
+  schedule: 'Daily' | 'Weekly'
+  format: 'CSV' | 'ORC' | 'Parquet'
+  includedFields: string[]
+  prefix?: string
+}
+export declare interface BatchOperation {
+  id: string
+  operation: 'Copy' | 'Delete' | 'RestoreObject' | 'Tagging' | 'ACL' | 'ObjectLock'
+  manifestBucket: string
+  manifestKey: string
+  priority: number
+  status: 'pending' | 'in_progress' | 'completed' | 'failed'
+  totalObjects?: number
+  processedObjects?: number
+}
+export declare interface EventNotification {
+  id: string
+  bucketName: string
+  events: Array<'s3:ObjectCreated:*' | 's3:ObjectRemoved:*' | 's3:ObjectRestore:*' | 's3:Replication:*'>
+  destination: {
+    type: 'Lambda' | 'SQS' | 'SNS'
+    arn: string
+  }
+  filter?: {
+    prefix?: string
+    suffix?: string
+  }
+}
+export declare class StorageAdvancedManager {
+  private policies: any;
+  private versioningConfigs: any;
+  private replicationRules: any;
+  private tieringConfigs: any;
+  private objectLocks: any;
+  private transferAcceleration: any;
+  private accessPoints: any;
+  private glacierConfigs: any;
+  private inventories: any;
+  private batchOps: any;
+  private eventNotifications: any;
+  private counter: any;
+  createLifecyclePolicy(transitions: Array<{ days: number; storageClass: string }>, expiration?: number): LifecyclePolicy;
+  enableVersioning(mfaDelete?: any): VersioningConfig;
+  createReplicationRule(sourceRegion: string, destRegion: string, destBucket: string): ReplicationRule;
+  createIntelligentTiering(archiveDays: number, deepArchiveDays: number): IntelligentTieringConfig;
+  enableObjectLock(options: {
+    bucketName: string
+    mode?: 'COMPLIANCE' | 'GOVERNANCE'
+    retentionDays?: number
+    retentionYears?: number
+    legalHoldEnabled?: boolean
+  }): ObjectLockConfig;
+  enableTransferAcceleration(bucketName: string): TransferAccelerationConfig;
+  createAccessPoint(options: {
+    name: string
+    bucketName: string
+    vpcId?: string
+    publicAccessBlock?: boolean
+    policy?: Record<string, any>
+  }): AccessPoint;
+  createGlacierArchive(options: {
+    bucketName: string
+    archiveType: 'GLACIER' | 'DEEP_ARCHIVE'
+    transitionDays: number
+    restoreTier?: 'Expedited' | 'Standard' | 'Bulk'
+    restoreDays?: number
+  }): GlacierArchiveConfig;
+  createInventory(options: {
+    sourceBucket: string
+    destinationBucket: string
+    schedule?: 'Daily' | 'Weekly'
+    format?: 'CSV' | 'ORC' | 'Parquet'
+    includedFields?: string[]
+    prefix?: string
+  }): InventoryConfig;
+  createBatchOperation(options: {
+    operation: 'Copy' | 'Delete' | 'RestoreObject' | 'Tagging' | 'ACL' | 'ObjectLock'
+    manifestBucket: string
+    manifestKey: string
+    priority?: number
+  }): BatchOperation;
+  executeBatchOperation(batchOpId: string): BatchOperation;
+  getBatchOperationStatus(batchOpId: string): BatchOperation | undefined;
+  createLambdaNotification(options: {
+    bucketName: string
+    lambdaArn: string
+    events: Array<'s3:ObjectCreated:*' | 's3:ObjectRemoved:*' | 's3:ObjectRestore:*' | 's3:Replication:*'>
+    prefix?: string
+    suffix?: string
+  }): EventNotification;
+  createSQSNotification(options: {
+    bucketName: string
+    queueArn: string
+    events: Array<'s3:ObjectCreated:*' | 's3:ObjectRemoved:*' | 's3:ObjectRestore:*' | 's3:Replication:*'>
+    prefix?: string
+    suffix?: string
+  }): EventNotification;
+  createSNSNotification(options: {
+    bucketName: string
+    topicArn: string
+    events: Array<'s3:ObjectCreated:*' | 's3:ObjectRemoved:*' | 's3:ObjectRestore:*' | 's3:Replication:*'>
+    prefix?: string
+    suffix?: string
+  }): EventNotification;
+  generateObjectLockCF(config: ObjectLockConfig): any;
+  generateTransferAccelerationCF(config: TransferAccelerationConfig): any;
+  generateAccessPointCF(accessPoint: AccessPoint): any;
+  generateInventoryCF(inventory: InventoryConfig): any;
+  generateEventNotificationCF(notification: EventNotification): any;
+  clear(): void;
+}

package/dist/schema/index.d.ts

@@ -0,0 +1,9 @@
+import schema from './cloud-config.schema.json';
+/**
+ * Validate configuration against JSON schema
+ */
+export declare function validateAgainstSchema(config: any): {
+  valid: boolean
+  errors: string[]
+};
+export { schema as cloudConfigSchema };

package/dist/security/certificate-manager.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Global certificate manager instance
+ */
+export declare const certificateManager: CertificateManager;
+/**
+ * Certificate Lifecycle Management
+ * Automated certificate provisioning, renewal, and monitoring
+ */
+export declare interface Certificate {
+  id: string
+  arn: string
+  domainName: string
+  subjectAlternativeNames?: string[]
+  validationMethod: 'DNS' | 'EMAIL'
+  status: CertificateStatus
+  issuer?: string
+  issuedAt?: Date
+  expiresAt?: Date
+  renewalEligibility?: boolean
+  inUseBy?: string[]
+}
+export declare interface CertificateRenewal {
+  id: string
+  certificateArn: string
+  autoRenew: boolean
+  renewBeforeDays: number
+  lastRenewal?: Date
+  nextRenewal?: Date
+  renewalStatus?: 'success' | 'pending' | 'failed'
+}
+export declare interface CertificateValidation {
+  domainName: string
+  validationMethod: 'DNS' | 'EMAIL'
+  validationStatus: 'PENDING' | 'SUCCESS' | 'FAILED'
+  resourceRecords?: DnsRecord[]
+  validationEmails?: string[]
+}
+export declare interface DnsRecord {
+  name: string
+  type: 'CNAME' | 'A' | 'AAAA' | 'TXT'
+  value: string
+}
+export declare interface CertificateMonitor {
+  id: string
+  name: string
+  certificates: string[]
+  expirationThreshold: number
+  alertEnabled: boolean
+  snsTopicArn?: string
+}
+export declare interface CertificateAlert {
+  id: string
+  certificateArn: string
+  alertType: 'expiring_soon' | 'expired' | 'renewal_failed' | 'validation_failed'
+  severity: 'critical' | 'warning' | 'info'
+  message: string
+  timestamp: Date
+  acknowledged?: boolean
+}
+export type CertificateStatus = | 'PENDING_VALIDATION'
+  | 'ISSUED'
+  | 'INACTIVE'
+  | 'EXPIRED'
+  | 'VALIDATION_TIMED_OUT'
+  | 'REVOKED'
+  | 'FAILED'
+/**
+ * Certificate manager
+ */
+export declare class CertificateManager {
+  private certificates: Map<string, Certificate>;
+  private renewals: Map<string, CertificateRenewal>;
+  private validations: Map<string, CertificateValidation>;
+  private monitors: Map<string, CertificateMonitor>;
+  private alerts: Map<string, CertificateAlert>;
+  private certificateCounter: any;
+  private renewalCounter: any;
+  private validationCounter: any;
+  private monitorCounter: any;
+  private alertCounter: any;
+  requestCertificate(options: {
+    domainName: string
+    subjectAlternativeNames?: string[]
+    validationMethod?: 'DNS' | 'EMAIL'
+  }): Certificate;
+  requestWildcardCertificate(options: {
+    domainName: string
+    includeApex?: boolean
+  }): Certificate;
+  requestMultiDomainCertificate(options: {
+    primaryDomain: string
+    additionalDomains: string[]
+    validationMethod?: 'DNS' | 'EMAIL'
+  }): Certificate;
+  private createValidation(certificate: Certificate): CertificateValidation;
+  validateCertificate(certificateId: string): { success: boolean; message: string };
+  enableAutoRenewal(options: {
+    certificateArn: string
+    renewBeforeDays?: number
+  }): CertificateRenewal;
+  renewCertificate(renewalId: string): Promise<{ success: boolean; message: string }>;
+  createMonitor(monitor: Omit<CertificateMonitor, 'id'>): CertificateMonitor;
+  checkExpiration(): CertificateAlert[];
+  createAlert(alert: Omit<CertificateAlert, 'id' | 'timestamp' | 'acknowledged'>): CertificateAlert;
+  acknowledgeAlert(alertId: string): void;
+  getCertificate(id: string): Certificate | undefined;
+  listCertificates(): Certificate[];
+  getExpiringCertificates(days?: number): Certificate[];
+  getValidation(certificateId: string): CertificateValidation | undefined;
+  getRenewal(id: string): CertificateRenewal | undefined;
+  listRenewals(): CertificateRenewal[];
+  listAlerts(acknowledged?: boolean): CertificateAlert[];
+  generateCertificateCF(certificate: Certificate): any;
+  generateExpirationAlarmCF(options: {
+    alarmName: string
+    certificateArn: string
+    daysBeforeExpiration: number
+    snsTopicArn?: string
+  }): any;
+  clear(): void;
+}

package/dist/security/index.d.ts

@@ -0,0 +1,4 @@
+export * from './secrets-rotation';
+export * from './secrets-manager';
+export * from './certificate-manager';
+export * from './scanning';