@stacksjs/ts-cloud-core 0.1.3 → 0.1.7

package/dist/deployment/canary.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Global canary manager instance
+ */
+export declare const canaryManager: CanaryManager;
+/**
+ * Canary Deployment Strategy
+ * Gradual rollout with automatic rollback based on metrics
+ */
+export declare interface CanaryDeployment {
+  id: string
+  name: string
+  baselineVersion: DeploymentVersion
+  canaryVersion: DeploymentVersion
+  stages: CanaryStage[]
+  currentStage: number
+  status: 'pending' | 'in_progress' | 'completed' | 'rolled_back' | 'failed'
+  metrics?: CanaryMetrics
+  autoPromote?: boolean
+  autoRollback?: boolean
+}
+export declare interface DeploymentVersion {
+  version: string
+  targetGroupArn?: string
+  taskDefinitionArn?: string
+  functionVersionArn?: string
+  weight: number
+}
+export declare interface CanaryStage {
+  name: string
+  trafficPercentage: number
+  durationMinutes: number
+  alarmThresholds?: AlarmThresholds
+}
+export declare interface AlarmThresholds {
+  errorRate?: number
+  latencyP99?: number
+  latencyP95?: number
+  httpErrorRate?: number
+  customMetrics?: CustomMetric[]
+}
+export declare interface CustomMetric {
+  name: string
+  namespace: string
+  threshold: number
+  comparisonOperator: 'GreaterThanThreshold' | 'LessThanThreshold' | 'GreaterThanOrEqualToThreshold' | 'LessThanOrEqualToThreshold'
+}
+export declare interface CanaryMetrics {
+  baselineErrorRate: number
+  canaryErrorRate: number
+  baselineLatencyP99: number
+  canaryLatencyP99: number
+  baselineRequestCount: number
+  canaryRequestCount: number
+}
+export declare interface CanaryResult {
+  success: boolean
+  deploymentId: string
+  startTime: Date
+  endTime?: Date
+  completedStages: number
+  rolledBack: boolean
+  reason?: string
+  metricsAtCompletion?: CanaryMetrics
+}
+/**
+ * Canary deployment manager
+ */
+export declare class CanaryManager {
+  private deployments: Map<string, CanaryDeployment>;
+  private deploymentHistory: Map<string, CanaryResult[]>;
+  private deploymentCounter: any;
+  private resultCounter: any;
+  static readonly Strategies: any;
+  createDeployment(deployment: Omit<CanaryDeployment, 'id'>): CanaryDeployment;
+  createLambdaCanaryDeployment(options: {
+    name: string
+    baselineVersionArn: string
+    canaryVersionArn: string
+    strategy?: keyof typeof CanaryManager.Strategies
+    autoPromote?: boolean
+    errorRateThreshold?: number
+    latencyThreshold?: number
+  }): CanaryDeployment;
+  createECSCanaryDeployment(options: {
+    name: string
+    baselineTaskDefinitionArn: string
+    canaryTaskDefinitionArn: string
+    baselineTargetGroupArn: string
+    canaryTargetGroupArn: string
+    strategy?: keyof typeof CanaryManager.Strategies
+  }): CanaryDeployment;
+  executeDeployment(deploymentId: string, dryRun?: boolean): Promise<CanaryResult>;
+  private monitorStage(deployment: CanaryDeployment, stage: CanaryStage, dryRun: boolean): Promise<boolean>;
+  rollback(deploymentId: string, dryRun?: boolean): Promise<void>;
+  promoteCanary(deploymentId: string): void;
+  private recordDeployment(deploymentId: string, result: CanaryResult): void;
+  getDeployment(id: string): CanaryDeployment | undefined;
+  listDeployments(): CanaryDeployment[];
+  getDeploymentHistory(deploymentId: string): CanaryResult[];
+  generateLambdaAliasCF(deployment: CanaryDeployment, aliasName: string): any;
+  generateALBListenerRuleCF(deployment: CanaryDeployment): any;
+  clear(): void;
+}

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

@@ -1,28 +1,10 @@
-/**
- * Advanced Deployment Strategies
- * Blue/green, canary, and A/B testing implementations
- */
-
-// Blue/Green Deployments
-export {
-  BlueGreenManager,
-  blueGreenManager,
-} from './blue-green'
-
 export type {
   BlueGreenDeployment,
   Environment,
   RoutingConfig,
   HealthCheckConfig,
   DeploymentResult,
-} from './blue-green'
-
-// Canary Deployments
-export {
-  CanaryManager,
-  canaryManager,
-} from './canary'
-
+} from './blue-green';
 export type {
   CanaryDeployment,
   DeploymentVersion,
@@ -31,14 +13,7 @@ export type {
   CustomMetric,
   CanaryMetrics,
   CanaryResult,
-} from './canary'
-
-// A/B Testing
-export {
-  ABTestManager,
-  abTestManager,
-} from './ab-testing'
-
+} from './canary';
 export type {
   ABTest,
   ABVariant,
@@ -46,16 +21,25 @@ export type {
   ABMetrics,
   VariantMetrics,
   ABTestResult,
-} from './ab-testing'
-
-// Progressive Deployments
-export {
-  ProgressiveDeploymentManager,
-  progressiveDeploymentManager,
-} from './progressive'
-
+} from './ab-testing';
 export type {
   ProgressiveRollout,
   FeatureFlag,
   DeploymentGate,
-} from './progressive'
+} from './progressive';
+export {
+  BlueGreenManager,
+  blueGreenManager,
+} from './blue-green';
+export {
+  CanaryManager,
+  canaryManager,
+} from './canary';
+export {
+  ABTestManager,
+  abTestManager,
+} from './ab-testing';
+export {
+  ProgressiveDeploymentManager,
+  progressiveDeploymentManager,
+} from './progressive';

package/dist/deployment/progressive.d.ts

@@ -0,0 +1,34 @@
+export declare const progressiveDeploymentManager: ProgressiveDeploymentManager;
+/**
+ * Progressive Rollouts, Feature Flags, and Deployment Gates
+ */
+export declare interface ProgressiveRollout {
+  id: string
+  name: string
+  stages: Array<{ percentage: number; durationMinutes: number }>
+  currentStage: number
+}
+export declare interface FeatureFlag {
+  id: string
+  name: string
+  enabled: boolean
+  rolloutPercentage: number
+  targetingRules: Array<{ attribute: string; operator: string; value: any }>
+}
+export declare interface DeploymentGate {
+  id: string
+  name: string
+  type: 'manual' | 'automated'
+  approvers?: string[]
+  conditions?: Array<{ metric: string; threshold: number }>
+}
+export declare class ProgressiveDeploymentManager {
+  private rollouts: any;
+  private flags: any;
+  private gates: any;
+  private counter: any;
+  createProgressiveRollout(name: string, stages: Array<{ percentage: number; durationMinutes: number }>): ProgressiveRollout;
+  createFeatureFlag(name: string, rolloutPercentage?: any): FeatureFlag;
+  createDeploymentGate(name: string, type: 'manual' | 'automated', approvers?: string[], conditions?: Array<{ metric: string; threshold: number }>): DeploymentGate;
+  clear(): void;
+}

package/dist/dns/dnssec.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Global DNSSEC manager instance
+ */
+export declare const dnssecManager: DNSSECManager;
+/**
+ * DNSSEC Configuration
+ * DNS Security Extensions for Route53
+ */
+export declare interface DNSSECConfig {
+  id: string
+  hostedZoneId: string
+  status: 'SIGNING' | 'SIGNED' | 'NOT_SIGNING' | 'DELETING' | 'ACTION_NEEDED'
+  signingStatus?: string
+  statusMessage?: string
+}
+export declare interface KSK {
+  id: string
+  name: string
+  hostedZoneId: string
+  status: 'ACTIVE' | 'INACTIVE' | 'DELETING' | 'ACTION_NEEDED'
+  keyManagementServiceArn: string
+  dnskeyRecord?: string
+  dsRecord?: string
+  digestAlgorithm: number
+  digestValue?: string
+  flag: number
+  keyTag?: number
+  publicKey?: string
+}
+export declare interface DNSSECValidation {
+  id: string
+  domain: string
+  validationStatus: 'VALID' | 'INVALID' | 'INSECURE' | 'BOGUS'
+  dnskeyPresent: boolean
+  rrsigPresent: boolean
+  validSignature: boolean
+  errors: string[]
+}
+/**
+ * DNSSEC manager
+ */
+export declare class DNSSECManager {
+  private configs: Map<string, DNSSECConfig>;
+  private ksks: Map<string, KSK>;
+  private validations: Map<string, DNSSECValidation>;
+  private configCounter: any;
+  private kskCounter: any;
+  private validationCounter: any;
+  enableDNSSEC(options: {
+    hostedZoneId: string
+    kmsKeyArn?: string
+  }): DNSSECConfig;
+  disableDNSSEC(configId: string): DNSSECConfig;
+  createKSK(options: {
+    name: string
+    hostedZoneId: string
+    kmsKeyArn: string
+  }): KSK;
+  deactivateKSK(kskId: string): KSK;
+  validateDNSSEC(options: {
+    domain: string
+    checkDNSKEY?: boolean
+    checkRRSIG?: boolean
+  }): DNSSECValidation;
+  getDNSSECConfig(id: string): DNSSECConfig | undefined;
+  listDNSSECConfigs(): DNSSECConfig[];
+  getKSK(id: string): KSK | undefined;
+  listKSKs(hostedZoneId?: string): KSK[];
+  getDSRecord(kskId: string): string;
+  private generatePublicKey(): string;
+  private generateDigest(dnskeyRecord: string): string;
+  generateDNSSECCF(config: DNSSECConfig): any;
+  generateKSKCF(ksk: KSK): any;
+  clear(): void;
+}

package/dist/dns/index.d.ts

@@ -0,0 +1,3 @@
+export * from './routing';
+export * from './dnssec';
+export * from './resolver';

package/dist/dns/resolver.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Global Route53 Resolver manager instance
+ */
+export declare const route53ResolverManager: Route53ResolverManager;
+/**
+ * Route53 Resolver
+ * DNS firewall, resolver rules, and endpoints
+ */
+export declare interface ResolverEndpoint {
+  id: string
+  name: string
+  direction: 'INBOUND' | 'OUTBOUND'
+  ipAddresses: ResolverIP[]
+  securityGroupIds: string[]
+  status: 'CREATING' | 'OPERATIONAL' | 'UPDATING' | 'DELETING' | 'ACTION_NEEDED'
+}
+export declare interface ResolverIP {
+  subnetId: string
+  ip?: string
+  ipv6?: string
+}
+export declare interface ResolverRule {
+  id: string
+  name: string
+  ruleType: 'FORWARD' | 'SYSTEM' | 'RECURSIVE'
+  domainName: string
+  targetIps?: TargetIP[]
+  resolverEndpointId?: string
+  status: 'COMPLETE' | 'CREATING' | 'UPDATING' | 'DELETING' | 'FAILED'
+}
+export declare interface TargetIP {
+  ip: string
+  port?: number
+}
+export declare interface DNSFirewall {
+  id: string
+  name: string
+  firewallRuleGroupAssociations: FirewallRuleGroupAssociation[]
+}
+export declare interface FirewallRuleGroupAssociation {
+  id: string
+  vpcId: string
+  firewallRuleGroupId: string
+  priority: number
+  mutationProtection: 'ENABLED' | 'DISABLED'
+  status: 'COMPLETE' | 'CREATING' | 'UPDATING' | 'DELETING'
+}
+export declare interface FirewallRuleGroup {
+  id: string
+  name: string
+  rules: FirewallRule[]
+  shareStatus: 'NOT_SHARED' | 'SHARED_WITH_ME' | 'SHARED_BY_ME'
+}
+export declare interface FirewallRule {
+  id: string
+  name: string
+  priority: number
+  action: 'ALLOW' | 'BLOCK' | 'ALERT'
+  blockResponse?: 'NODATA' | 'NXDOMAIN' | 'OVERRIDE'
+  blockOverrideDomain?: string
+  blockOverrideTTL?: number
+  firewallDomainListId: string
+}
+export declare interface FirewallDomainList {
+  id: string
+  name: string
+  domains: string[]
+  status: 'COMPLETE' | 'CREATING' | 'UPDATING' | 'DELETING'
+}
+/**
+ * Route53 Resolver manager
+ */
+export declare class Route53ResolverManager {
+  private endpoints: Map<string, ResolverEndpoint>;
+  private rules: Map<string, ResolverRule>;
+  private firewalls: Map<string, DNSFirewall>;
+  private ruleGroups: Map<string, FirewallRuleGroup>;
+  private domainLists: Map<string, FirewallDomainList>;
+  private endpointCounter: any;
+  private ruleCounter: any;
+  private firewallCounter: any;
+  private ruleGroupCounter: any;
+  private domainListCounter: any;
+  createResolverEndpoint(endpoint: Omit<ResolverEndpoint, 'id' | 'status'>): ResolverEndpoint;
+  createInboundEndpoint(options: {
+    name: string
+    subnetIds: string[]
+    securityGroupIds: string[]
+  }): ResolverEndpoint;
+  createOutboundEndpoint(options: {
+    name: string
+    subnetIds: string[]
+    securityGroupIds: string[]
+  }): ResolverEndpoint;
+  createResolverRule(rule: Omit<ResolverRule, 'id' | 'status'>): ResolverRule;
+  createForwardRule(options: {
+    name: string
+    domainName: string
+    targetIps: TargetIP[]
+    resolverEndpointId: string
+  }): ResolverRule;
+  createSystemRule(options: {
+    name: string
+    domainName: string
+  }): ResolverRule;
+  createFirewallDomainList(options: {
+    name: string
+    domains: string[]
+  }): FirewallDomainList;
+  createFirewallRuleGroup(options: {
+    name: string
+    rules: Omit<FirewallRule, 'id'>[]
+  }): FirewallRuleGroup;
+  createBlockRule(options: {
+    name: string
+    priority: number
+    domainListId: string
+    blockResponse?: 'NODATA' | 'NXDOMAIN' | 'OVERRIDE'
+    blockOverrideDomain?: string
+  }): FirewallRuleGroup;
+  createAllowRule(options: {
+    name: string
+    priority: number
+    domainListId: string
+  }): FirewallRuleGroup;
+  createDNSFirewall(options: {
+    name: string
+    vpcId: string
+    ruleGroupAssociations: Array<{
+      firewallRuleGroupId: string
+      priority: number
+      mutationProtection?: 'ENABLED' | 'DISABLED'
+    }>
+  }): DNSFirewall;
+  createMalwareProtectionFirewall(options: {
+    name: string
+    vpcId: string
+    maliciousDomains: string[]
+  }): DNSFirewall;
+  getEndpoint(id: string): ResolverEndpoint | undefined;
+  listEndpoints(direction?: 'INBOUND' | 'OUTBOUND'): ResolverEndpoint[];
+  getRule(id: string): ResolverRule | undefined;
+  listRules(): ResolverRule[];
+  getFirewall(id: string): DNSFirewall | undefined;
+  listFirewalls(): DNSFirewall[];
+  generateResolverEndpointCF(endpoint: ResolverEndpoint): any;
+  generateResolverRuleCF(rule: ResolverRule): any;
+  generateFirewallRuleGroupCF(ruleGroup: FirewallRuleGroup): any;
+  clear(): void;
+}

package/dist/dns/routing.d.ts

@@ -0,0 +1,217 @@
+/**
+ * Global Route53 routing manager instance
+ */
+export declare const route53RoutingManager: Route53RoutingManager;
+/**
+ * Route53 Advanced Routing
+ * Health-based, geolocation, weighted, failover, and latency-based routing
+ */
+export declare interface RoutingPolicy {
+  id: string
+  name: string
+  type: 'simple' | 'weighted' | 'latency' | 'failover' | 'geolocation' | 'geoproximity' | 'multivalue'
+  recordSetId?: string
+}
+export declare interface WeightedRoutingPolicy extends RoutingPolicy {
+  type: 'weighted'
+  weight: number
+  setIdentifier: string
+  healthCheckId?: string
+}
+export declare interface LatencyRoutingPolicy extends RoutingPolicy {
+  type: 'latency'
+  region: string
+  setIdentifier: string
+  healthCheckId?: string
+}
+export declare interface FailoverRoutingPolicy extends RoutingPolicy {
+  type: 'failover'
+  failoverType: 'PRIMARY' | 'SECONDARY'
+  setIdentifier: string
+  healthCheckId: string
+}
+export declare interface GeolocationRoutingPolicy extends RoutingPolicy {
+  type: 'geolocation'
+  continent?: string
+  country?: string
+  subdivision?: string
+  setIdentifier: string
+  healthCheckId?: string
+}
+export declare interface GeoproximityRoutingPolicy extends RoutingPolicy {
+  type: 'geoproximity'
+  coordinates?: {
+    latitude: number
+    longitude: number
+  }
+  awsRegion?: string
+  bias?: number
+  setIdentifier: string
+  healthCheckId?: string
+}
+export declare interface HealthCheck {
+  id: string
+  name: string
+  type: 'http' | 'https' | 'tcp' | 'calculated' | 'cloudwatch_metric'
+  resourcePath?: string
+  fullyQualifiedDomainName?: string
+  ipAddress?: string
+  port?: number
+  requestInterval: number
+  failureThreshold: number
+  healthCheckStatus: 'Healthy' | 'Unhealthy' | 'Unknown'
+  measureLatency?: boolean
+  enableSNI?: boolean
+}
+export declare interface CalculatedHealthCheck extends HealthCheck {
+  type: 'calculated'
+  childHealthChecks: string[]
+  healthThreshold: number
+}
+export declare interface TrafficPolicy {
+  id: string
+  name: string
+  version: number
+  document: TrafficPolicyDocument
+}
+export declare interface TrafficPolicyDocument {
+  recordType: 'A' | 'AAAA' | 'CNAME'
+  startRule: string
+  endpoints: Record<string, TrafficPolicyEndpoint>
+  rules: Record<string, TrafficPolicyRule>
+}
+export declare interface TrafficPolicyEndpoint {
+  type: 'value' | 'cloudfront' | 'elastic_load_balancer' | 's3_website'
+  value?: string
+  region?: string
+}
+export declare interface TrafficPolicyRule {
+  ruleType: 'failover' | 'geoproximity' | 'latency' | 'weighted' | 'multivalue'
+  primary?: string
+  secondary?: string
+  locations?: Array<{
+    endpointReference: string
+    region?: string
+    latitude?: number
+    longitude?: number
+    bias?: number
+  }>
+  items?: Array<{
+    endpointReference: string
+    weight?: number
+  }>
+}
+/**
+ * Route53 routing policy manager
+ */
+export declare class Route53RoutingManager {
+  private policies: Map<string, RoutingPolicy>;
+  private healthChecks: Map<string, HealthCheck>;
+  private trafficPolicies: Map<string, TrafficPolicy>;
+  private policyCounter: any;
+  private healthCheckCounter: any;
+  private trafficPolicyCounter: any;
+  createWeightedPolicy(options: {
+    name: string
+    weight: number
+    setIdentifier: string
+    healthCheckId?: string
+  }): WeightedRoutingPolicy;
+  createLatencyPolicy(options: {
+    name: string
+    region: string
+    setIdentifier: string
+    healthCheckId?: string
+  }): LatencyRoutingPolicy;
+  createFailoverPolicy(options: {
+    name: string
+    failoverType: 'PRIMARY' | 'SECONDARY'
+    setIdentifier: string
+    healthCheckId: string
+  }): FailoverRoutingPolicy;
+  createGeolocationPolicy(options: {
+    name: string
+    continent?: string
+    country?: string
+    subdivision?: string
+    setIdentifier: string
+    healthCheckId?: string
+  }): GeolocationRoutingPolicy;
+  createGeoproximityPolicy(options: {
+    name: string
+    coordinates?: {
+      latitude: number
+      longitude: number
+    }
+    awsRegion?: string
+    bias?: number
+    setIdentifier: string
+    healthCheckId?: string
+  }): GeoproximityRoutingPolicy;
+  createHTTPHealthCheck(options: {
+    name: string
+    resourcePath: string
+    fullyQualifiedDomainName?: string
+    ipAddress?: string
+    port?: number
+    requestInterval?: number
+    failureThreshold?: number
+    enableSNI?: boolean
+  }): HealthCheck;
+  createTCPHealthCheck(options: {
+    name: string
+    ipAddress: string
+    port: number
+    requestInterval?: number
+    failureThreshold?: number
+  }): HealthCheck;
+  createCalculatedHealthCheck(options: {
+    name: string
+    childHealthChecks: string[]
+    healthThreshold: number
+  }): CalculatedHealthCheck;
+  createTrafficPolicy(policy: Omit<TrafficPolicy, 'id' | 'version'>): TrafficPolicy;
+  createFailoverTrafficPolicy(options: {
+    name: string
+    primaryEndpoint: string
+    secondaryEndpoint: string
+    recordType?: 'A' | 'AAAA' | 'CNAME'
+  }): TrafficPolicy;
+  createGeoproximityTrafficPolicy(options: {
+    name: string
+    locations: Array<{
+      endpoint: string
+      region?: string
+      latitude?: number
+      longitude?: number
+      bias?: number
+    }>
+  }): TrafficPolicy;
+  getPolicy(id: string): RoutingPolicy | undefined;
+  listPolicies(): RoutingPolicy[];
+  getHealthCheck(id: string): HealthCheck | undefined;
+  listHealthChecks(): HealthCheck[];
+  getHealthCheckStatus(id: string): 'Healthy' | 'Unhealthy' | 'Unknown';
+  generateHealthCheckCF(healthCheck: HealthCheck): any;
+  generateWeightedRecordSetCF(options: {
+    hostedZoneId: string
+    name: string
+    type: 'A' | 'AAAA' | 'CNAME'
+    ttl: number
+    resourceRecords: string[]
+    weight: number
+    setIdentifier: string
+    healthCheckId?: string
+  }): any;
+  generateFailoverRecordSetCF(options: {
+    hostedZoneId: string
+    name: string
+    type: 'A' | 'AAAA' | 'CNAME'
+    ttl: number
+    resourceRecords: string[]
+    failover: 'PRIMARY' | 'SECONDARY'
+    setIdentifier: string
+    healthCheckId?: string
+  }): any;
+  clear(): void;
+}