@stacksjs/ts-cloud-core 0.1.2 → 0.1.6

package/src/cloudformation/builders/monitoring.ts

@@ -1,300 +0,0 @@
-import type { CloudFormationBuilder } from '../builder'
-import { Fn } from '../types'
-
-export interface AlarmConfig {
-  name?: string
-  metric: string
-  threshold: number
-  evaluationPeriods?: number
-  comparisonOperator?: 'GreaterThanThreshold' | 'LessThanThreshold' | 'GreaterThanOrEqualToThreshold' | 'LessThanOrEqualToThreshold'
-  statistic?: 'Average' | 'Sum' | 'Minimum' | 'Maximum' | 'SampleCount'
-  period?: number
-  treatMissingData?: 'breaching' | 'notBreaching' | 'ignore' | 'missing'
-  service?: string
-  namespace?: string
-  dimensions?: Record<string, string>
-}
-
-export interface MonitoringConfig {
-  dashboard?: {
-    name: string
-    widgets?: Array<{
-      type: 'metric' | 'log' | 'text'
-      metrics?: string[] | Array<{ service?: string, metric: string }>
-      logGroup?: string
-      text?: string
-      width?: number
-      height?: number
-    }>
-  }
-  alarms?: AlarmConfig[]
-  logs?: {
-    retention?: number
-    groups?: string[]
-  }
-}
-
-/**
- * Add CloudWatch monitoring resources to CloudFormation template
- */
-export function addMonitoringResources(
-  builder: CloudFormationBuilder,
-  config: MonitoringConfig,
-): void {
-  // SNS Topic for alarms
-  if (config.alarms && config.alarms.length > 0) {
-    builder.addResource('AlarmTopic', 'AWS::SNS::Topic', {
-      TopicName: Fn.sub('${AWS::StackName}-alarms'),
-      DisplayName: 'CloudWatch Alarms',
-      Tags: [
-        { Key: 'Name', Value: Fn.sub('${AWS::StackName}-alarms') },
-      ],
-    })
-
-    // Add alarms
-    config.alarms.forEach((alarm, index) => {
-      addCloudWatchAlarm(builder, alarm, index)
-    })
-  }
-
-  // CloudWatch Dashboard
-  if (config.dashboard) {
-    addCloudWatchDashboard(builder, config.dashboard)
-  }
-
-  // Log Groups
-  if (config.logs?.groups) {
-    config.logs.groups.forEach(group => {
-      addLogGroup(builder, group, config.logs?.retention)
-    })
-  }
-}
-
-/**
- * Add CloudWatch alarm
- */
-function addCloudWatchAlarm(
-  builder: CloudFormationBuilder,
-  config: AlarmConfig,
-  index: number,
-): void {
-  const alarmId = builder.toLogicalId(`alarm-${config.name || config.metric}-${index}`)
-
-  const alarmProperties: Record<string, any> = {
-    AlarmName: config.name || Fn.sub(`\${AWS::StackName}-${config.metric}`),
-    AlarmDescription: `Alarm for ${config.metric}`,
-    MetricName: config.metric,
-    Namespace: config.namespace || getNamespaceForMetric(config.metric, config.service),
-    Statistic: config.statistic || 'Average',
-    Period: config.period || 300,
-    EvaluationPeriods: config.evaluationPeriods || 1,
-    Threshold: config.threshold,
-    ComparisonOperator: config.comparisonOperator || 'GreaterThanThreshold',
-    TreatMissingData: config.treatMissingData || 'notBreaching',
-    AlarmActions: [Fn.ref('AlarmTopic')],
-    OKActions: [Fn.ref('AlarmTopic')],
-  }
-
-  // Dimensions
-  if (config.dimensions) {
-    alarmProperties.Dimensions = Object.entries(config.dimensions).map(([name, value]) => ({
-      Name: name,
-      Value: value,
-    }))
-  }
-  else if (config.service) {
-    // Auto-generate dimensions based on service
-    alarmProperties.Dimensions = generateDimensionsForService(config.service)
-  }
-
-  builder.addResource(alarmId, 'AWS::CloudWatch::Alarm', alarmProperties, {
-    dependsOn: 'AlarmTopic',
-  })
-}
-
-/**
- * Add CloudWatch Dashboard
- */
-function addCloudWatchDashboard(
-  builder: CloudFormationBuilder,
-  config: MonitoringConfig['dashboard'],
-): void {
-  if (!config) return
-
-  const widgets: any[] = []
-  let x = 0
-  let y = 0
-
-  // Build dashboard widgets
-  config.widgets?.forEach(widget => {
-    const width = widget.width || 12
-    const height = widget.height || 6
-
-    if (widget.type === 'metric' && widget.metrics) {
-      const metrics = widget.metrics.map(metric => {
-        if (typeof metric === 'string') {
-          // Simple metric name - infer namespace
-          const namespace = getNamespaceForMetric(metric)
-          return [namespace, metric]
-        }
-        else {
-          // Metric with service specified
-          const namespace = getNamespaceForMetric(metric.metric, metric.service)
-          return [namespace, metric.metric]
-        }
-      })
-
-      widgets.push({
-        type: 'metric',
-        x,
-        y,
-        width,
-        height,
-        properties: {
-          metrics,
-          period: 300,
-          stat: 'Average',
-          region: Fn.ref('AWS::Region'),
-          title: widget.metrics.length > 1
-            ? 'Multiple Metrics'
-            : typeof widget.metrics[0] === 'string'
-              ? widget.metrics[0]
-              : widget.metrics[0].metric,
-        },
-      })
-    }
-    else if (widget.type === 'log' && widget.logGroup) {
-      widgets.push({
-        type: 'log',
-        x,
-        y,
-        width,
-        height,
-        properties: {
-          query: `SOURCE '${widget.logGroup}'\n| fields @timestamp, @message\n| sort @timestamp desc\n| limit 20`,
-          region: Fn.ref('AWS::Region'),
-          title: `Logs: ${widget.logGroup}`,
-        },
-      })
-    }
-    else if (widget.type === 'text' && widget.text) {
-      widgets.push({
-        type: 'text',
-        x,
-        y,
-        width,
-        height,
-        properties: {
-          markdown: widget.text,
-        },
-      })
-    }
-
-    // Update position for next widget
-    x += width
-    if (x >= 24) {
-      x = 0
-      y += height
-    }
-  })
-
-  builder.addResource('CloudWatchDashboard', 'AWS::CloudWatch::Dashboard', {
-    DashboardName: Fn.sub(`\${AWS::StackName}-${config.name}`),
-    DashboardBody: JSON.stringify({ widgets }),
-  })
-
-  // Output
-  builder.addOutputs({
-    DashboardURL: {
-      Description: 'CloudWatch Dashboard URL',
-      Value: Fn.sub(
-        `https://console.aws.amazon.com/cloudwatch/home?region=\${AWS::Region}#dashboards:name=\${CloudWatchDashboard}`,
-      ),
-    },
-  })
-}
-
-/**
- * Add CloudWatch Log Group
- */
-function addLogGroup(
-  builder: CloudFormationBuilder,
-  groupName: string,
-  retention?: number,
-): void {
-  const logicalId = builder.toLogicalId(`${groupName}-log-group`)
-
-  builder.addResource(logicalId, 'AWS::Logs::LogGroup', {
-    LogGroupName: Fn.sub(`/aws/\${AWS::StackName}/${groupName}`),
-    RetentionInDays: retention || 14,
-    Tags: [
-      { Key: 'Name', Value: Fn.sub(`\${AWS::StackName}-${groupName}`) },
-    ],
-  })
-}
-
-/**
- * Get AWS namespace for a metric
- */
-function getNamespaceForMetric(metric: string, service?: string): string {
-  if (service) {
-    const namespaceMap: Record<string, string> = {
-      'ec2': 'AWS/EC2',
-      'ecs': 'AWS/ECS',
-      'lambda': 'AWS/Lambda',
-      'rds': 'AWS/RDS',
-      'dynamodb': 'AWS/DynamoDB',
-      's3': 'AWS/S3',
-      'cloudfront': 'AWS/CloudFront',
-      'alb': 'AWS/ApplicationELB',
-      'nlb': 'AWS/NetworkELB',
-      'apigateway': 'AWS/ApiGateway',
-      'sqs': 'AWS/SQS',
-      'sns': 'AWS/SNS',
-      'kinesis': 'AWS/Kinesis',
-      'elasticache': 'AWS/ElastiCache',
-    }
-    return namespaceMap[service.toLowerCase()] || 'AWS/CloudWatch'
-  }
-
-  // Infer namespace from metric name
-  const metricLower = metric.toLowerCase()
-
-  if (metricLower.includes('cpu') || metricLower.includes('memory') || metricLower.includes('network')) {
-    return 'AWS/EC2'
-  }
-  if (metricLower.includes('lambda') || metricLower.includes('invocation') || metricLower.includes('duration')) {
-    return 'AWS/Lambda'
-  }
-  if (metricLower.includes('request') || metricLower.includes('latency') || metricLower.includes('target')) {
-    return 'AWS/ApplicationELB'
-  }
-  if (metricLower.includes('database') || metricLower.includes('connection')) {
-    return 'AWS/RDS'
-  }
-  if (metricLower.includes('read') || metricLower.includes('write') || metricLower.includes('consumed')) {
-    return 'AWS/DynamoDB'
-  }
-
-  return 'AWS/CloudWatch'
-}
-
-/**
- * Generate dimensions for a service
- */
-function generateDimensionsForService(service: string): any[] {
-  const dimensionMap: Record<string, any[]> = {
-    'ec2': [{ Name: 'InstanceId', Value: Fn.ref('EC2Instance') }],
-    'ecs': [
-      { Name: 'ClusterName', Value: Fn.ref('ECSCluster') },
-      { Name: 'ServiceName', Value: Fn.getAtt('ECSService', 'Name') },
-    ],
-    'lambda': [{ Name: 'FunctionName', Value: Fn.ref('LambdaFunction') }],
-    'rds': [{ Name: 'DBInstanceIdentifier', Value: Fn.ref('Database') }],
-    'dynamodb': [{ Name: 'TableName', Value: Fn.ref('DynamoDBTable') }],
-    'alb': [{ Name: 'LoadBalancer', Value: Fn.getAtt('LoadBalancer', 'LoadBalancerFullName') }],
-    'apigateway': [{ Name: 'ApiName', Value: Fn.ref('HttpApi') }],
-  }
-
-  return dimensionMap[service.toLowerCase()] || []
-}

package/src/cloudformation/builders/network.ts

@@ -1,264 +0,0 @@
-import type { CloudFormationBuilder } from '../builder'
-import { Fn } from '../types'
-
-export interface NetworkConfig {
-  vpc?: {
-    cidr?: string
-    availabilityZones?: number
-    natGateways?: number
-    enableDnsHostnames?: boolean
-    enableDnsSupport?: boolean
-  }
-}
-
-/**
- * Add VPC and networking resources to CloudFormation template
- */
-export function addNetworkResources(
-  builder: CloudFormationBuilder,
-  config: NetworkConfig,
-): void {
-  if (!config.vpc) {
-    return
-  }
-
-  const {
-    cidr = '10.0.0.0/16',
-    availabilityZones = 2,
-    natGateways = 1,
-    enableDnsHostnames = true,
-    enableDnsSupport = true,
-  } = config.vpc
-
-  // VPC
-  builder.addResource('VPC', 'AWS::EC2::VPC', {
-    CidrBlock: cidr,
-    EnableDnsHostnames: enableDnsHostnames,
-    EnableDnsSupport: enableDnsSupport,
-    Tags: [
-      { Key: 'Name', Value: Fn.sub('${AWS::StackName}-vpc') },
-    ],
-  })
-
-  // Internet Gateway
-  builder.addResource('InternetGateway', 'AWS::EC2::InternetGateway', {
-    Tags: [
-      { Key: 'Name', Value: Fn.sub('${AWS::StackName}-igw') },
-    ],
-  })
-
-  builder.addResource('VPCGatewayAttachment', 'AWS::EC2::VPCGatewayAttachment', {
-    VpcId: Fn.ref('VPC'),
-    InternetGatewayId: Fn.ref('InternetGateway'),
-  }, {
-    dependsOn: ['VPC', 'InternetGateway'],
-  })
-
-  // Public subnets (one per AZ)
-  const publicSubnets: string[] = []
-  for (let i = 0; i < availabilityZones; i++) {
-    const subnetId = `PublicSubnet${i + 1}`
-    publicSubnets.push(subnetId)
-
-    builder.addResource(subnetId, 'AWS::EC2::Subnet', {
-      VpcId: Fn.ref('VPC'),
-      CidrBlock: Fn.select(i, Fn.cidr(Fn.getAtt('VPC', 'CidrBlock'), availabilityZones * 2, 8)),
-      AvailabilityZone: Fn.select(i, Fn.getAZs()),
-      MapPublicIpOnLaunch: true,
-      Tags: [
-        { Key: 'Name', Value: Fn.sub(`\${AWS::StackName}-public-${i + 1}`) },
-        { Key: 'Type', Value: 'public' },
-      ],
-    }, {
-      dependsOn: 'VPC',
-    })
-  }
-
-  // Private subnets (one per AZ)
-  const privateSubnets: string[] = []
-  for (let i = 0; i < availabilityZones; i++) {
-    const subnetId = `PrivateSubnet${i + 1}`
-    privateSubnets.push(subnetId)
-
-    builder.addResource(subnetId, 'AWS::EC2::Subnet', {
-      VpcId: Fn.ref('VPC'),
-      CidrBlock: Fn.select(
-        i + availabilityZones,
-        Fn.cidr(Fn.getAtt('VPC', 'CidrBlock'), availabilityZones * 2, 8),
-      ),
-      AvailabilityZone: Fn.select(i, Fn.getAZs()),
-      MapPublicIpOnLaunch: false,
-      Tags: [
-        { Key: 'Name', Value: Fn.sub(`\${AWS::StackName}-private-${i + 1}`) },
-        { Key: 'Type', Value: 'private' },
-      ],
-    }, {
-      dependsOn: 'VPC',
-    })
-  }
-
-  // Elastic IPs for NAT Gateways
-  const eips: string[] = []
-  for (let i = 0; i < natGateways; i++) {
-    const eipId = `NatEIP${i + 1}`
-    eips.push(eipId)
-
-    builder.addResource(eipId, 'AWS::EC2::EIP', {
-      Domain: 'vpc',
-      Tags: [
-        { Key: 'Name', Value: Fn.sub(`\${AWS::StackName}-nat-eip-${i + 1}`) },
-      ],
-    }, {
-      dependsOn: 'VPCGatewayAttachment',
-    })
-  }
-
-  // NAT Gateways
-  const natGatewayIds: string[] = []
-  for (let i = 0; i < natGateways; i++) {
-    const natId = `NatGateway${i + 1}`
-    natGatewayIds.push(natId)
-
-    // Use round-robin to distribute NAT gateways across AZs
-    const subnetIndex = i % availabilityZones
-
-    builder.addResource(natId, 'AWS::EC2::NatGateway', {
-      AllocationId: Fn.getAtt(eips[i], 'AllocationId'),
-      SubnetId: Fn.ref(publicSubnets[subnetIndex]),
-      Tags: [
-        { Key: 'Name', Value: Fn.sub(`\${AWS::StackName}-nat-${i + 1}`) },
-      ],
-    }, {
-      dependsOn: [eips[i], publicSubnets[subnetIndex]],
-    })
-  }
-
-  // Public route table
-  builder.addResource('PublicRouteTable', 'AWS::EC2::RouteTable', {
-    VpcId: Fn.ref('VPC'),
-    Tags: [
-      { Key: 'Name', Value: Fn.sub('${AWS::StackName}-public-rt') },
-    ],
-  }, {
-    dependsOn: 'VPC',
-  })
-
-  builder.addResource('PublicRoute', 'AWS::EC2::Route', {
-    RouteTableId: Fn.ref('PublicRouteTable'),
-    DestinationCidrBlock: '0.0.0.0/0',
-    GatewayId: Fn.ref('InternetGateway'),
-  }, {
-    dependsOn: ['PublicRouteTable', 'VPCGatewayAttachment'],
-  })
-
-  // Associate public subnets with public route table
-  publicSubnets.forEach((subnetId, i) => {
-    builder.addResource(`PublicSubnetRouteTableAssociation${i + 1}`, 'AWS::EC2::SubnetRouteTableAssociation', {
-      SubnetId: Fn.ref(subnetId),
-      RouteTableId: Fn.ref('PublicRouteTable'),
-    }, {
-      dependsOn: [subnetId, 'PublicRouteTable'],
-    })
-  })
-
-  // Private route tables (one per NAT gateway for HA)
-  privateSubnets.forEach((subnetId, i) => {
-    const routeTableId = `PrivateRouteTable${i + 1}`
-    const natIndex = i % natGateways
-
-    builder.addResource(routeTableId, 'AWS::EC2::RouteTable', {
-      VpcId: Fn.ref('VPC'),
-      Tags: [
-        { Key: 'Name', Value: Fn.sub(`\${AWS::StackName}-private-rt-${i + 1}`) },
-      ],
-    }, {
-      dependsOn: 'VPC',
-    })
-
-    builder.addResource(`PrivateRoute${i + 1}`, 'AWS::EC2::Route', {
-      RouteTableId: Fn.ref(routeTableId),
-      DestinationCidrBlock: '0.0.0.0/0',
-      NatGatewayId: Fn.ref(natGatewayIds[natIndex]),
-    }, {
-      dependsOn: [routeTableId, natGatewayIds[natIndex]],
-    })
-
-    builder.addResource(`PrivateSubnetRouteTableAssociation${i + 1}`, 'AWS::EC2::SubnetRouteTableAssociation', {
-      SubnetId: Fn.ref(subnetId),
-      RouteTableId: Fn.ref(routeTableId),
-    }, {
-      dependsOn: [subnetId, routeTableId],
-    })
-  })
-
-  // VPC Endpoints for AWS services (cost optimization)
-  builder.addResource('S3VPCEndpoint', 'AWS::EC2::VPCEndpoint', {
-    VpcId: Fn.ref('VPC'),
-    ServiceName: Fn.sub('com.amazonaws.${AWS::Region}.s3'),
-    VpcEndpointType: 'Gateway',
-    RouteTableIds: [
-      Fn.ref('PublicRouteTable'),
-      ...Array.from({ length: availabilityZones }, (_, i) => Fn.ref(`PrivateRouteTable${i + 1}`)),
-    ],
-  }, {
-    dependsOn: 'VPC',
-  })
-
-  // Network ACL for additional security
-  builder.addResource('NetworkAcl', 'AWS::EC2::NetworkAcl', {
-    VpcId: Fn.ref('VPC'),
-    Tags: [
-      { Key: 'Name', Value: Fn.sub('${AWS::StackName}-nacl') },
-    ],
-  }, {
-    dependsOn: 'VPC',
-  })
-
-  // Allow all inbound traffic (can be customized)
-  builder.addResource('NetworkAclEntryInbound', 'AWS::EC2::NetworkAclEntry', {
-    NetworkAclId: Fn.ref('NetworkAcl'),
-    RuleNumber: 100,
-    Protocol: -1,
-    RuleAction: 'allow',
-    CidrBlock: '0.0.0.0/0',
-  }, {
-    dependsOn: 'NetworkAcl',
-  })
-
-  // Allow all outbound traffic
-  builder.addResource('NetworkAclEntryOutbound', 'AWS::EC2::NetworkAclEntry', {
-    NetworkAclId: Fn.ref('NetworkAcl'),
-    RuleNumber: 100,
-    Protocol: -1,
-    Egress: true,
-    RuleAction: 'allow',
-    CidrBlock: '0.0.0.0/0',
-  }, {
-    dependsOn: 'NetworkAcl',
-  })
-
-  // Outputs
-  builder.addOutputs({
-    VPCId: {
-      Description: 'VPC ID',
-      Value: Fn.ref('VPC'),
-      Export: {
-        Name: Fn.sub('${AWS::StackName}-VPC'),
-      },
-    },
-    PublicSubnets: {
-      Description: 'Public subnet IDs',
-      Value: Fn.join(',', publicSubnets.map(id => Fn.ref(id))),
-      Export: {
-        Name: Fn.sub('${AWS::StackName}-PublicSubnets'),
-      },
-    },
-    PrivateSubnets: {
-      Description: 'Private subnet IDs',
-      Value: Fn.join(',', privateSubnets.map(id => Fn.ref(id))),
-      Export: {
-        Name: Fn.sub('${AWS::StackName}-PrivateSubnets'),
-      },
-    },
-  })
-}

package/src/cloudformation/builders/queue.ts

@@ -1,147 +0,0 @@
-import type { CloudFormationBuilder } from '../builder'
-import { Fn } from '../types'
-
-export interface QueueConfig {
-  [queueName: string]: {
-    fifo?: boolean
-    visibilityTimeout?: number
-    messageRetentionPeriod?: number
-    receiveMessageWaitTime?: number
-    deadLetterQueue?: boolean
-    maxReceiveCount?: number
-    contentBasedDeduplication?: boolean
-  }
-}
-
-/**
- * Add SQS queue resources to CloudFormation template
- */
-export function addQueueResources(
-  builder: CloudFormationBuilder,
-  config: QueueConfig,
-): void {
-  for (const [queueName, queueConfig] of Object.entries(config)) {
-    addQueue(builder, queueName, queueConfig)
-  }
-}
-
-/**
- * Add SQS queue
- */
-function addQueue(
-  builder: CloudFormationBuilder,
-  name: string,
-  config: QueueConfig[string],
-): void {
-  const logicalId = builder.toLogicalId(`${name}-queue`)
-  const isFifo = config.fifo || false
-
-  // Dead Letter Queue (if enabled)
-  let dlqArn: any
-  if (config.deadLetterQueue) {
-    const dlqLogicalId = `${logicalId}DLQ`
-
-    builder.addResource(dlqLogicalId, 'AWS::SQS::Queue', {
-      QueueName: isFifo
-        ? Fn.sub(`\${AWS::StackName}-${name}-dlq.fifo`)
-        : Fn.sub(`\${AWS::StackName}-${name}-dlq`),
-      FifoQueue: isFifo,
-      MessageRetentionPeriod: 1209600, // 14 days max retention for DLQ
-      Tags: [
-        { Key: 'Name', Value: Fn.sub(`\${AWS::StackName}-${name}-dlq`) },
-      ],
-    })
-
-    dlqArn = Fn.getAtt(dlqLogicalId, 'Arn')
-  }
-
-  // Main Queue
-  const queueProperties: Record<string, any> = {
-    QueueName: isFifo
-      ? Fn.sub(`\${AWS::StackName}-${name}.fifo`)
-      : Fn.sub(`\${AWS::StackName}-${name}`),
-    FifoQueue: isFifo,
-    VisibilityTimeout: config.visibilityTimeout || 30,
-    MessageRetentionPeriod: config.messageRetentionPeriod || 345600, // 4 days
-    ReceiveMessageWaitTimeSeconds: config.receiveMessageWaitTime || 0,
-    Tags: [
-      { Key: 'Name', Value: Fn.sub(`\${AWS::StackName}-${name}`) },
-    ],
-  }
-
-  // FIFO-specific settings
-  if (isFifo && config.contentBasedDeduplication) {
-    queueProperties.ContentBasedDeduplication = true
-  }
-
-  // Dead Letter Queue configuration
-  if (config.deadLetterQueue && dlqArn) {
-    queueProperties.RedrivePolicy = {
-      deadLetterTargetArn: dlqArn,
-      maxReceiveCount: config.maxReceiveCount || 3,
-    }
-  }
-
-  builder.addResource(logicalId, 'AWS::SQS::Queue', queueProperties, {
-    dependsOn: config.deadLetterQueue ? `${logicalId}DLQ` : undefined,
-  })
-
-  // Queue Policy (allow common AWS services to send messages)
-  builder.addResource(`${logicalId}Policy`, 'AWS::SQS::QueuePolicy', {
-    Queues: [Fn.ref(logicalId)],
-    PolicyDocument: {
-      Version: '2012-10-17',
-      Statement: [
-        {
-          Effect: 'Allow',
-          Principal: {
-            Service: [
-              'lambda.amazonaws.com',
-              'events.amazonaws.com',
-              'sns.amazonaws.com',
-            ],
-          },
-          Action: 'sqs:SendMessage',
-          Resource: Fn.getAtt(logicalId, 'Arn'),
-          Condition: {
-            ArnEquals: {
-              'aws:SourceArn': Fn.sub('arn:aws:*:${AWS::Region}:${AWS::AccountId}:*'),
-            },
-          },
-        },
-      ],
-    },
-  }, {
-    dependsOn: logicalId,
-  })
-
-  // Outputs
-  builder.addOutputs({
-    [`${logicalId}Url`]: {
-      Description: `${name} queue URL`,
-      Value: Fn.ref(logicalId),
-      Export: {
-        Name: Fn.sub(`\${AWS::StackName}-${name}-queue-url`),
-      },
-    },
-    [`${logicalId}Arn`]: {
-      Description: `${name} queue ARN`,
-      Value: Fn.getAtt(logicalId, 'Arn'),
-      Export: {
-        Name: Fn.sub(`\${AWS::StackName}-${name}-queue-arn`),
-      },
-    },
-  })
-
-  if (config.deadLetterQueue) {
-    builder.addOutputs({
-      [`${logicalId}DLQUrl`]: {
-        Description: `${name} dead letter queue URL`,
-        Value: Fn.ref(`${logicalId}DLQ`),
-        Export: {
-          Name: Fn.sub(`\${AWS::StackName}-${name}-dlq-url`),
-        },
-      },
-    })
-  }
-}