@stacksjs/ts-cloud-aws-types 0.1.1

package/src/appsync.ts

@@ -0,0 +1,246 @@
+/**
+ * AWS AppSync Types
+ * CloudFormation resource types for AWS AppSync (GraphQL)
+ */
+
+import type { Tag } from './common'
+
+export interface GraphQLApi {
+  Type: 'AWS::AppSync::GraphQLApi'
+  Properties: {
+    Name: string
+    AuthenticationType: 'API_KEY' | 'AWS_IAM' | 'AMAZON_COGNITO_USER_POOLS' | 'OPENID_CONNECT' | 'AWS_LAMBDA'
+
+    // Optional authentication providers
+    AdditionalAuthenticationProviders?: Array<{
+      AuthenticationType: 'API_KEY' | 'AWS_IAM' | 'AMAZON_COGNITO_USER_POOLS' | 'OPENID_CONNECT' | 'AWS_LAMBDA'
+      UserPoolConfig?: {
+        UserPoolId: string | { Ref: string }
+        AwsRegion?: string
+        AppIdClientRegex?: string
+      }
+      OpenIDConnectConfig?: {
+        Issuer: string
+        ClientId?: string
+        IatTTL?: number
+        AuthTTL?: number
+      }
+      LambdaAuthorizerConfig?: {
+        AuthorizerUri: string | { Ref: string }
+        AuthorizerResultTtlInSeconds?: number
+        IdentityValidationExpression?: string
+      }
+    }>
+
+    // Cognito User Pool config (if using AMAZON_COGNITO_USER_POOLS)
+    UserPoolConfig?: {
+      UserPoolId: string | { Ref: string }
+      AwsRegion?: string
+      DefaultAction: 'ALLOW' | 'DENY'
+      AppIdClientRegex?: string
+    }
+
+    // OpenID Connect config (if using OPENID_CONNECT)
+    OpenIDConnectConfig?: {
+      Issuer: string
+      ClientId?: string
+      IatTTL?: number
+      AuthTTL?: number
+    }
+
+    // Lambda authorizer config (if using AWS_LAMBDA)
+    LambdaAuthorizerConfig?: {
+      AuthorizerUri: string | { Ref: string }
+      AuthorizerResultTtlInSeconds?: number
+      IdentityValidationExpression?: string
+    }
+
+    // Logging
+    LogConfig?: {
+      CloudWatchLogsRoleArn: string | { Ref: string }
+      FieldLogLevel: 'NONE' | 'ERROR' | 'ALL'
+      ExcludeVerboseContent?: boolean
+    }
+
+    // X-Ray tracing
+    XrayEnabled?: boolean
+
+    Tags?: Tag[]
+  }
+  DeletionPolicy?: 'Delete' | 'Retain'
+  UpdateReplacePolicy?: 'Delete' | 'Retain'
+}
+
+export interface GraphQLSchema {
+  Type: 'AWS::AppSync::GraphQLSchema'
+  Properties: {
+    ApiId: string | { Ref: string }
+    Definition?: string
+    DefinitionS3Location?: string
+  }
+  DependsOn?: string | string[]
+}
+
+export interface DataSource {
+  Type: 'AWS::AppSync::DataSource'
+  Properties: {
+    ApiId: string | { Ref: string }
+    Name: string
+    Type: 'AWS_LAMBDA' | 'AMAZON_DYNAMODB' | 'AMAZON_ELASTICSEARCH' | 'AMAZON_OPENSEARCH_SERVICE' | 'HTTP' | 'RELATIONAL_DATABASE' | 'NONE'
+    ServiceRoleArn?: string | { Ref: string }
+
+    // Lambda config (if Type = AWS_LAMBDA)
+    LambdaConfig?: {
+      LambdaFunctionArn: string | { Ref: string }
+    }
+
+    // DynamoDB config (if Type = AMAZON_DYNAMODB)
+    DynamoDBConfig?: {
+      TableName: string | { Ref: string }
+      AwsRegion: string
+      UseCallerCredentials?: boolean
+      DeltaSyncConfig?: {
+        BaseTableTTL: number
+        DeltaSyncTableName: string | { Ref: string }
+        DeltaSyncTableTTL: number
+      }
+      Versioned?: boolean
+    }
+
+    // OpenSearch config (if Type = AMAZON_OPENSEARCH_SERVICE)
+    OpenSearchServiceConfig?: {
+      AwsRegion: string
+      Endpoint: string | { 'Fn::GetAtt': [string, string] }
+    }
+
+    // HTTP config (if Type = HTTP)
+    HttpConfig?: {
+      Endpoint: string
+      AuthorizationConfig?: {
+        AuthorizationType: 'AWS_IAM'
+        AwsIamConfig?: {
+          SigningRegion?: string
+          SigningServiceName?: string
+        }
+      }
+    }
+
+    // RDS config (if Type = RELATIONAL_DATABASE)
+    RelationalDatabaseConfig?: {
+      RelationalDatabaseSourceType: 'RDS_HTTP_ENDPOINT'
+      RdsHttpEndpointConfig?: {
+        AwsRegion: string
+        DbClusterIdentifier: string | { Ref: string }
+        DatabaseName?: string
+        Schema?: string
+        AwsSecretStoreArn: string | { Ref: string }
+      }
+    }
+
+    Description?: string
+  }
+  DependsOn?: string | string[]
+}
+
+export interface Resolver {
+  Type: 'AWS::AppSync::Resolver'
+  Properties: {
+    ApiId: string | { Ref: string }
+    TypeName: string // e.g., 'Query', 'Mutation', 'Subscription'
+    FieldName: string
+    DataSourceName?: string | { Ref: string }
+
+    // Request/Response mapping templates (VTL)
+    RequestMappingTemplate?: string
+    ResponseMappingTemplate?: string
+
+    // Or use S3 location
+    RequestMappingTemplateS3Location?: string
+    ResponseMappingTemplateS3Location?: string
+
+    // Pipeline resolvers
+    Kind?: 'UNIT' | 'PIPELINE'
+    PipelineConfig?: {
+      Functions?: Array<string | { Ref: string }>
+    }
+
+    // Caching
+    CachingConfig?: {
+      CachingKeys?: string[]
+      Ttl?: number
+    }
+
+    // Sync config (for subscriptions)
+    SyncConfig?: {
+      ConflictDetection: 'VERSION' | 'NONE'
+      ConflictHandler?: 'OPTIMISTIC_CONCURRENCY' | 'LAMBDA' | 'AUTOMERGE'
+      LambdaConflictHandlerConfig?: {
+        LambdaConflictHandlerArn: string | { Ref: string }
+      }
+    }
+
+    // Code (for JavaScript resolvers)
+    Code?: string
+    CodeS3Location?: string
+    Runtime?: {
+      Name: 'APPSYNC_JS'
+      RuntimeVersion: string
+    }
+  }
+  DependsOn?: string | string[]
+}
+
+export interface FunctionConfiguration {
+  Type: 'AWS::AppSync::FunctionConfiguration'
+  Properties: {
+    ApiId: string | { Ref: string }
+    Name: string
+    DataSourceName: string | { Ref: string }
+    FunctionVersion?: string
+
+    // Request/Response mapping templates
+    RequestMappingTemplate?: string
+    ResponseMappingTemplate?: string
+    RequestMappingTemplateS3Location?: string
+    ResponseMappingTemplateS3Location?: string
+
+    // Code (for JavaScript functions)
+    Code?: string
+    CodeS3Location?: string
+    Runtime?: {
+      Name: 'APPSYNC_JS'
+      RuntimeVersion: string
+    }
+
+    Description?: string
+  }
+  DependsOn?: string | string[]
+}
+
+export interface ApiKey {
+  Type: 'AWS::AppSync::ApiKey'
+  Properties: {
+    ApiId: string | { Ref: string }
+    Description?: string
+    Expires?: number // Unix timestamp
+  }
+  DependsOn?: string | string[]
+}
+
+export interface DomainName {
+  Type: 'AWS::AppSync::DomainName'
+  Properties: {
+    DomainName: string
+    CertificateArn: string | { Ref: string }
+    Description?: string
+  }
+}
+
+export interface DomainNameApiAssociation {
+  Type: 'AWS::AppSync::DomainNameApiAssociation'
+  Properties: {
+    DomainName: string | { Ref: string }
+    ApiId: string | { Ref: string }
+  }
+  DependsOn?: string | string[]
+}

package/src/athena.ts

@@ -0,0 +1,102 @@
+/**
+ * AWS Athena Types
+ * CloudFormation resource types for AWS Athena (log analytics, data querying)
+ */
+
+import type { Tag } from './common'
+
+export interface WorkGroup {
+  Type: 'AWS::Athena::WorkGroup'
+  Properties: {
+    Name: string
+    Description?: string
+    State?: 'ENABLED' | 'DISABLED'
+
+    WorkGroupConfiguration?: {
+      // Query result location
+      ResultConfiguration?: {
+        OutputLocation?: string
+        EncryptionConfiguration?: {
+          EncryptionOption: 'SSE_S3' | 'SSE_KMS' | 'CSE_KMS'
+          KmsKey?: string | { Ref: string }
+        }
+        ExpectedBucketOwner?: string
+        AclConfiguration?: {
+          S3AclOption: 'BUCKET_OWNER_FULL_CONTROL'
+        }
+      }
+
+      // Performance settings
+      EnforceWorkGroupConfiguration?: boolean
+      PublishCloudWatchMetricsEnabled?: boolean
+      BytesScannedCutoffPerQuery?: number
+      RequesterPaysEnabled?: boolean
+
+      // Engine version
+      EngineVersion?: {
+        SelectedEngineVersion?: string
+        EffectiveEngineVersion?: string
+      }
+
+      // Execution role (for federated queries)
+      ExecutionRole?: string | { Ref: string }
+
+      // Additional configurations
+      AdditionalConfiguration?: string
+      CustomerContentEncryptionConfiguration?: {
+        KmsKey: string | { Ref: string }
+      }
+    }
+
+    Tags?: Tag[]
+  }
+  DeletionPolicy?: 'Delete' | 'Retain'
+  UpdateReplacePolicy?: 'Delete' | 'Retain'
+}
+
+export interface DataCatalog {
+  Type: 'AWS::Athena::DataCatalog'
+  Properties: {
+    Name: string
+    Type: 'LAMBDA' | 'GLUE' | 'HIVE'
+    Description?: string
+    Parameters?: Record<string, string>
+    Tags?: Tag[]
+  }
+}
+
+export interface NamedQuery {
+  Type: 'AWS::Athena::NamedQuery'
+  Properties: {
+    Name?: string
+    Database: string
+    QueryString: string
+    Description?: string
+    WorkGroup?: string
+  }
+}
+
+export interface PreparedStatement {
+  Type: 'AWS::Athena::PreparedStatement'
+  Properties: {
+    StatementName: string
+    WorkGroup: string
+    QueryStatement: string
+    Description?: string
+  }
+  DependsOn?: string | string[]
+}
+
+export interface CapacityReservation {
+  Type: 'AWS::Athena::CapacityReservation'
+  Properties: {
+    Name: string
+    TargetDpus: number
+    CapacityAssignmentConfiguration?: {
+      CapacityAssignments?: Array<{
+        WorkGroupNames?: string[]
+      }>
+    }
+    Tags?: Tag[]
+  }
+}

package/src/autoscaling.ts

@@ -0,0 +1,201 @@
+/**
+ * AWS Auto Scaling Types
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_AutoScaling.html
+ */
+
+import type { Tag } from './common'
+
+/**
+ * AWS::AutoScaling::AutoScalingGroup
+ */
+export interface AutoScalingGroup {
+  Type: 'AWS::AutoScaling::AutoScalingGroup'
+  Properties: {
+    AutoScalingGroupName?: string
+    MinSize: string | number
+    MaxSize: string | number
+    DesiredCapacity?: string | number
+    DefaultInstanceWarmup?: number
+    HealthCheckType?: 'EC2' | 'ELB'
+    HealthCheckGracePeriod?: number
+    LaunchTemplate?: {
+      LaunchTemplateId?: string | { Ref: string }
+      LaunchTemplateName?: string
+      Version: string | { 'Fn::GetAtt': [string, string] }
+    }
+    LaunchConfigurationName?: string | { Ref: string }
+    AvailabilityZones?: string[] | { 'Fn::GetAZs': string }
+    VPCZoneIdentifier?: string[] | { Ref: string }
+    TargetGroupARNs?: Array<string | { Ref: string }>
+    LoadBalancerNames?: Array<string | { Ref: string }>
+    TerminationPolicies?: Array<'OldestInstance' | 'NewestInstance' | 'OldestLaunchConfiguration' | 'ClosestToNextInstanceHour' | 'Default' | 'OldestLaunchTemplate' | 'AllocationStrategy'>
+    NewInstancesProtectedFromScaleIn?: boolean
+    Tags?: Array<Tag & { PropagateAtLaunch: boolean }>
+    MetricsCollection?: Array<{
+      Granularity: string
+      Metrics?: string[]
+    }>
+    Cooldown?: string | number
+    CapacityRebalance?: boolean
+  }
+  DependsOn?: string | string[]
+  CreationPolicy?: {
+    ResourceSignal?: {
+      Count?: number
+      Timeout?: string
+    }
+    AutoScalingCreationPolicy?: {
+      MinSuccessfulInstancesPercent?: number
+    }
+  }
+  UpdatePolicy?: {
+    AutoScalingReplacingUpdate?: {
+      WillReplace?: boolean
+    }
+    AutoScalingRollingUpdate?: {
+      MaxBatchSize?: number
+      MinInstancesInService?: number
+      MinSuccessfulInstancesPercent?: number
+      PauseTime?: string
+      SuspendProcesses?: string[]
+      WaitOnResourceSignals?: boolean
+    }
+    AutoScalingScheduledAction?: {
+      IgnoreUnmodifiedGroupSizeProperties?: boolean
+    }
+  }
+}
+
+/**
+ * AWS::AutoScaling::LaunchConfiguration
+ */
+export interface AutoScalingLaunchConfiguration {
+  Type: 'AWS::AutoScaling::LaunchConfiguration'
+  Properties: {
+    LaunchConfigurationName?: string
+    ImageId: string
+    InstanceType: string
+    KeyName?: string
+    SecurityGroups?: Array<string | { Ref: string }>
+    UserData?: string | { 'Fn::Base64': any }
+    IamInstanceProfile?: string | { Ref: string } | { 'Fn::GetAtt': [string, string] }
+    BlockDeviceMappings?: Array<{
+      DeviceName: string
+      Ebs?: {
+        DeleteOnTermination?: boolean
+        Encrypted?: boolean
+        Iops?: number
+        SnapshotId?: string
+        Throughput?: number
+        VolumeSize?: number
+        VolumeType?: 'gp2' | 'gp3' | 'io1' | 'io2' | 'sc1' | 'st1' | 'standard'
+      }
+      NoDevice?: boolean
+      VirtualName?: string
+    }>
+    AssociatePublicIpAddress?: boolean
+    EbsOptimized?: boolean
+    InstanceMonitoring?: boolean
+    PlacementTenancy?: 'default' | 'dedicated'
+    SpotPrice?: string
+  }
+}
+
+/**
+ * AWS::AutoScaling::ScalingPolicy
+ */
+export interface AutoScalingScalingPolicy {
+  Type: 'AWS::AutoScaling::ScalingPolicy'
+  Properties: {
+    PolicyName?: string
+    PolicyType?: 'TargetTrackingScaling' | 'StepScaling' | 'SimpleScaling'
+    AutoScalingGroupName: string | { Ref: string }
+    AdjustmentType?: 'ChangeInCapacity' | 'ExactCapacity' | 'PercentChangeInCapacity'
+    ScalingAdjustment?: number
+    Cooldown?: string | number
+    MinAdjustmentMagnitude?: number
+    MetricAggregationType?: 'Minimum' | 'Maximum' | 'Average'
+    EstimatedInstanceWarmup?: number
+    TargetTrackingConfiguration?: {
+      PredefinedMetricSpecification?: {
+        PredefinedMetricType: 'ASGAverageCPUUtilization' | 'ASGAverageNetworkIn' | 'ASGAverageNetworkOut' | 'ALBRequestCountPerTarget'
+        ResourceLabel?: string
+      }
+      CustomizedMetricSpecification?: {
+        MetricName: string
+        Namespace: string
+        Statistic: 'Average' | 'Minimum' | 'Maximum' | 'SampleCount' | 'Sum'
+        Unit?: string
+        Dimensions?: Array<{
+          Name: string
+          Value: string
+        }>
+      }
+      TargetValue: number
+      DisableScaleIn?: boolean
+    }
+    StepAdjustments?: Array<{
+      MetricIntervalLowerBound?: number
+      MetricIntervalUpperBound?: number
+      ScalingAdjustment: number
+    }>
+  }
+}
+
+/**
+ * AWS::AutoScaling::ScheduledAction
+ */
+export interface AutoScalingScheduledAction {
+  Type: 'AWS::AutoScaling::ScheduledAction'
+  Properties: {
+    AutoScalingGroupName: string | { Ref: string }
+    DesiredCapacity?: number
+    MinSize?: number
+    MaxSize?: number
+    Recurrence?: string
+    StartTime?: string
+    EndTime?: string
+    TimeZone?: string
+  }
+}
+
+/**
+ * AWS::AutoScaling::LifecycleHook
+ */
+export interface AutoScalingLifecycleHook {
+  Type: 'AWS::AutoScaling::LifecycleHook'
+  Properties: {
+    LifecycleHookName?: string
+    AutoScalingGroupName: string | { Ref: string }
+    LifecycleTransition: 'autoscaling:EC2_INSTANCE_LAUNCHING' | 'autoscaling:EC2_INSTANCE_TERMINATING'
+    DefaultResult?: 'CONTINUE' | 'ABANDON'
+    HeartbeatTimeout?: number
+    NotificationTargetARN?: string | { Ref: string } | { 'Fn::GetAtt': [string, string] }
+    RoleARN?: string | { 'Fn::GetAtt': [string, string] }
+    NotificationMetadata?: string
+  }
+}
+
+/**
+ * AWS::AutoScaling::WarmPool
+ */
+export interface AutoScalingWarmPool {
+  Type: 'AWS::AutoScaling::WarmPool'
+  Properties: {
+    AutoScalingGroupName: string | { Ref: string }
+    MaxGroupPreparedCapacity?: number
+    MinSize?: number
+    PoolState?: 'Hibernated' | 'Running' | 'Stopped'
+    InstanceReusePolicy?: {
+      ReuseOnScaleIn?: boolean
+    }
+  }
+}
+
+export type AutoScalingResource =
+  | AutoScalingGroup
+  | AutoScalingLaunchConfiguration
+  | AutoScalingScalingPolicy
+  | AutoScalingScheduledAction
+  | AutoScalingLifecycleHook
+  | AutoScalingWarmPool