@stacksjs/ts-cloud-core 0.1.1

package/src/multi-region/cross-region.ts

@@ -0,0 +1,410 @@
+/**
+ * Cross-Region Resource Management
+ * Handles references and dependencies between regions
+ */
+
+export interface CrossRegionReference {
+  sourceRegion: string
+  targetRegion: string
+  resourceType: string
+  resourceId: string
+  value: string
+}
+
+export interface CrossRegionExport {
+  region: string
+  exportName: string
+  value: string
+  description?: string
+}
+
+/**
+ * Cross-region reference manager
+ */
+export class CrossRegionReferenceManager {
+  private references: CrossRegionReference[] = []
+  private exports: Map<string, CrossRegionExport[]> = new Map()
+
+  /**
+   * Register a cross-region export
+   */
+  addExport(export_: CrossRegionExport): void {
+    const key = `${export_.region}:${export_.exportName}`
+
+    if (!this.exports.has(export_.region)) {
+      this.exports.set(export_.region, [])
+    }
+
+    this.exports.get(export_.region)!.push(export_)
+  }
+
+  /**
+   * Get export value from another region
+   */
+  getExport(region: string, exportName: string): string | undefined {
+    const regionExports = this.exports.get(region)
+
+    if (!regionExports) return undefined
+
+    const export_ = regionExports.find(e => e.exportName === exportName)
+    return export_?.value
+  }
+
+  /**
+   * Create cross-region reference
+   */
+  createReference(
+    sourceRegion: string,
+    targetRegion: string,
+    resourceType: string,
+    resourceId: string,
+  ): string {
+    // In real implementation, this would:
+    // 1. Store reference in SSM Parameter Store or Systems Manager
+    // 2. Enable cross-region access
+    // 3. Return parameter name
+
+    const parameterName = `/cross-region/${sourceRegion}/${resourceType}/${resourceId}`
+
+    this.references.push({
+      sourceRegion,
+      targetRegion,
+      resourceType,
+      resourceId,
+      value: parameterName,
+    })
+
+    return parameterName
+  }
+
+  /**
+   * Resolve cross-region reference
+   */
+  async resolveReference(
+    targetRegion: string,
+    parameterName: string,
+  ): Promise<string> {
+    // In real implementation, this would:
+    // 1. Fetch parameter from SSM Parameter Store
+    // 2. Handle cross-region access
+    // 3. Return actual value
+
+    const reference = this.references.find(
+      ref => ref.targetRegion === targetRegion && ref.value === parameterName,
+    )
+
+    if (!reference) {
+      throw new Error(`Reference not found: ${parameterName}`)
+    }
+
+    // Placeholder: return the parameter name
+    return `arn:aws:resource:${reference.sourceRegion}:123456789012:${reference.resourceType}/${reference.resourceId}`
+  }
+
+  /**
+   * Get all references for a region
+   */
+  getReferencesForRegion(region: string): CrossRegionReference[] {
+    return this.references.filter(
+      ref => ref.sourceRegion === region || ref.targetRegion === region,
+    )
+  }
+
+  /**
+   * Clear all references
+   */
+  clear(): void {
+    this.references = []
+    this.exports.clear()
+  }
+}
+
+/**
+ * Global resources that exist in one region but are accessible globally
+ */
+export interface GlobalResource {
+  type: 'cloudfront' | 'route53' | 'waf' | 'iam' | 's3-website'
+  id: string
+  region: string
+  arn: string
+  endpoint?: string
+}
+
+/**
+ * Global resource manager
+ */
+export class GlobalResourceManager {
+  private resources: Map<string, GlobalResource> = new Map()
+
+  /**
+   * Register a global resource
+   */
+  register(resource: GlobalResource): void {
+    this.resources.set(resource.id, resource)
+  }
+
+  /**
+   * Get global resource
+   */
+  get(id: string): GlobalResource | undefined {
+    return this.resources.get(id)
+  }
+
+  /**
+   * Get global resources by type
+   */
+  getByType(type: GlobalResource['type']): GlobalResource[] {
+    return Array.from(this.resources.values()).filter(r => r.type === type)
+  }
+
+  /**
+   * Get CloudFront distributions
+   */
+  getCloudFrontDistributions(): GlobalResource[] {
+    return this.getByType('cloudfront')
+  }
+
+  /**
+   * Get Route53 hosted zones
+   */
+  getRoute53HostedZones(): GlobalResource[] {
+    return this.getByType('route53')
+  }
+
+  /**
+   * Get WAF web ACLs
+   */
+  getWAFWebACLs(): GlobalResource[] {
+    return this.getByType('waf')
+  }
+
+  /**
+   * Remove global resource
+   */
+  remove(id: string): void {
+    this.resources.delete(id)
+  }
+
+  /**
+   * Clear all global resources
+   */
+  clear(): void {
+    this.resources.clear()
+  }
+}
+
+/**
+ * Region pairing for replication and failover
+ */
+export interface RegionPair {
+  primary: string
+  secondary: string
+  replicationConfig?: {
+    s3: boolean
+    dynamodb: boolean
+    rds: boolean
+  }
+  failoverConfig?: {
+    automatic: boolean
+    healthCheckInterval: number
+    failoverThreshold: number
+  }
+}
+
+/**
+ * Region pair manager
+ */
+export class RegionPairManager {
+  private pairs: RegionPair[] = []
+
+  /**
+   * Add region pair
+   */
+  addPair(pair: RegionPair): void {
+    this.pairs.push(pair)
+  }
+
+  /**
+   * Get paired region
+   */
+  getPairedRegion(region: string): string | undefined {
+    const pair = this.pairs.find(p => p.primary === region || p.secondary === region)
+
+    if (!pair) return undefined
+
+    return pair.primary === region ? pair.secondary : pair.primary
+  }
+
+  /**
+   * Get all pairs
+   */
+  getAllPairs(): RegionPair[] {
+    return [...this.pairs]
+  }
+
+  /**
+   * Get pairs with replication enabled
+   */
+  getReplicatedPairs(): RegionPair[] {
+    return this.pairs.filter(p => p.replicationConfig)
+  }
+
+  /**
+   * Get pairs with failover enabled
+   */
+  getFailoverPairs(): RegionPair[] {
+    return this.pairs.filter(p => p.failoverConfig?.automatic)
+  }
+
+  /**
+   * Check if regions are paired
+   */
+  arePaired(region1: string, region2: string): boolean {
+    return this.pairs.some(
+      p =>
+        (p.primary === region1 && p.secondary === region2)
+        || (p.primary === region2 && p.secondary === region1),
+    )
+  }
+
+  /**
+   * Clear all pairs
+   */
+  clear(): void {
+    this.pairs = []
+  }
+}
+
+/**
+ * Cross-region stack dependencies
+ */
+export interface StackDependency {
+  dependentStack: string
+  dependentRegion: string
+  dependsOnStack: string
+  dependsOnRegion: string
+  outputKey: string
+}
+
+/**
+ * Stack dependency manager
+ */
+export class StackDependencyManager {
+  private dependencies: StackDependency[] = []
+
+  /**
+   * Add stack dependency
+   */
+  addDependency(dependency: StackDependency): void {
+    this.dependencies.push(dependency)
+  }
+
+  /**
+   * Get dependencies for a stack
+   */
+  getDependencies(stackName: string, region: string): StackDependency[] {
+    return this.dependencies.filter(
+      d => d.dependentStack === stackName && d.dependentRegion === region,
+    )
+  }
+
+  /**
+   * Get dependents of a stack
+   */
+  getDependents(stackName: string, region: string): StackDependency[] {
+    return this.dependencies.filter(
+      d => d.dependsOnStack === stackName && d.dependsOnRegion === region,
+    )
+  }
+
+  /**
+   * Check if stack has dependencies
+   */
+  hasDependencies(stackName: string, region: string): boolean {
+    return this.getDependencies(stackName, region).length > 0
+  }
+
+  /**
+   * Get deployment order
+   */
+  getDeploymentOrder(stacks: Array<{ name: string; region: string }>): Array<{ name: string; region: string }> {
+    const visited: Set<string> = new Set()
+    const order: Array<{ name: string; region: string }> = []
+
+    const visit = (stack: { name: string; region: string }) => {
+      const key = `${stack.name}:${stack.region}`
+
+      if (visited.has(key)) return
+
+      visited.add(key)
+
+      // Visit dependencies first
+      const deps = this.getDependencies(stack.name, stack.region)
+      for (const dep of deps) {
+        visit({
+          name: dep.dependsOnStack,
+          region: dep.dependsOnRegion,
+        })
+      }
+
+      order.push(stack)
+    }
+
+    for (const stack of stacks) {
+      visit(stack)
+    }
+
+    return order
+  }
+
+  /**
+   * Detect circular dependencies
+   */
+  detectCircularDependencies(): boolean {
+    const visited: Set<string> = new Set()
+    const recursionStack: Set<string> = new Set()
+
+    const hasCycle = (stack: string, region: string): boolean => {
+      const key = `${stack}:${region}`
+
+      if (recursionStack.has(key)) return true
+      if (visited.has(key)) return false
+
+      visited.add(key)
+      recursionStack.add(key)
+
+      const deps = this.getDependencies(stack, region)
+      for (const dep of deps) {
+        if (hasCycle(dep.dependsOnStack, dep.dependsOnRegion)) {
+          return true
+        }
+      }
+
+      recursionStack.delete(key)
+      return false
+    }
+
+    for (const dep of this.dependencies) {
+      if (hasCycle(dep.dependentStack, dep.dependentRegion)) {
+        return true
+      }
+    }
+
+    return false
+  }
+
+  /**
+   * Clear all dependencies
+   */
+  clear(): void {
+    this.dependencies = []
+  }
+}
+
+/**
+ * Global instances
+ */
+export const crossRegionReferenceManager: CrossRegionReferenceManager = new CrossRegionReferenceManager()
+export const globalResourceManager: GlobalResourceManager = new GlobalResourceManager()
+export const regionPairManager: RegionPairManager = new RegionPairManager()
+export const stackDependencyManager: StackDependencyManager = new StackDependencyManager()

package/src/multi-region/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Multi-Region Deployment
+ * Deploy and manage infrastructure across multiple AWS regions
+ */
+
+export * from './manager'
+export * from './cross-region'
+export * from './regions'