@stacksjs/ts-cloud-core 0.1.1

package/src/cloudformation/builders/monitoring.ts

@@ -0,0 +1,300 @@
+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

@@ -0,0 +1,264 @@
+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

@@ -0,0 +1,147 @@
+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`),
+        },
+      },
+    })
+  }
+}