@stacksjs/cloud 0.65.0 → 0.67.0

package/src/cloud/ai.ts

@@ -1,24 +0,0 @@
-import type { Construct } from 'constructs'
-import type { NestedCloudProps } from '../types'
-import { config } from '@stacksjs/config'
-import { aws_iam as iam } from 'aws-cdk-lib'
-
-export interface AiStackProps extends NestedCloudProps {}
-
-export class AiStack {
-  // eslint-disable-next-line unused-imports/no-unused-vars
-  constructor(scope: Construct, props: AiStackProps) {
-    const bedrockAccessPolicy = new iam.PolicyStatement({
-      effect: iam.Effect.ALLOW,
-      actions: ['bedrock:InvokeModel', 'bedrock:InvokeModelWithResponseStream'],
-      resources: config.ai.models?.map((model: string) => `arn:aws:bedrock:us-east-1::foundation-model/${model}`),
-    })
-
-    const bedrockAccessRole = new iam.Role(scope, 'BedrockAccessRole', {
-      assumedBy: new iam.ServicePrincipal('ecs-tasks.amazonaws.com'),
-      managedPolicies: [iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AmazonECSTaskExecutionRolePolicy')],
-    })
-
-    bedrockAccessRole.addToPolicy(bedrockAccessPolicy)
-  }
-}

package/src/cloud/cdn.ts

@@ -1,290 +0,0 @@
-import type { aws_certificatemanager as acm, aws_s3 as s3, aws_wafv2 as wafv2 } from 'aws-cdk-lib'
-import type { ApplicationLoadBalancer } from 'aws-cdk-lib/aws-elasticloadbalancingv2'
-import type { Construct } from 'constructs'
-import type { NestedCloudProps } from '../types'
-import { config } from '@stacksjs/config'
-import {
-  aws_cloudfront as cloudfront,
-  Duration,
-  aws_lambda as lambda,
-  aws_cloudfront_origins as origins,
-  CfnOutput as Output,
-  aws_route53 as route53,
-  aws_route53_targets as targets,
-} from 'aws-cdk-lib'
-
-export interface CdnStackProps extends NestedCloudProps {
-  certificate: acm.Certificate
-  logBucket: s3.Bucket
-  publicBucket: s3.Bucket
-  docsBucket?: s3.Bucket
-  firewall: wafv2.CfnWebACL
-  originRequestFunction: lambda.Function
-  zone: route53.IHostedZone
-  webServer?: lambda.Function
-  webServerUrl?: lambda.FunctionUrl
-  lb?: ApplicationLoadBalancer
-}
-
-export class CdnStack {
-  mainDistribution: cloudfront.Distribution
-  docsDistribution: cloudfront.Distribution | undefined
-  cdnCachePolicy: cloudfront.CachePolicy
-  mainVanityUrl!: string
-  docsVanityUrl: string | undefined
-  realtimeLogConfig!: cloudfront.RealtimeLogConfig
-  props: CdnStackProps
-
-  constructor(scope: Construct, props: CdnStackProps) {
-    this.props = props
-
-    this.cdnCachePolicy = new cloudfront.CachePolicy(scope, 'CdnCachePolicy', {
-      comment: 'Stacks CDN Cache Policy',
-      cachePolicyName: `${props.slug}-${props.appEnv}-cdn-cache-policy`,
-      minTtl: config.cloud.cdn?.minTtl ? Duration.seconds(config.cloud.cdn.minTtl) : undefined,
-      defaultTtl: config.cloud.cdn?.defaultTtl ? Duration.seconds(config.cloud.cdn.defaultTtl) : undefined,
-      maxTtl: config.cloud.cdn?.maxTtl ? Duration.seconds(config.cloud.cdn.maxTtl) : undefined,
-      cookieBehavior: this.getCookieBehavior(config.cloud.cdn?.cookieBehavior),
-    })
-
-    const originAccessControl = new cloudfront.S3OriginAccessControl(scope, 'WebOAC', {
-      originAccessControlName: `${props.slug}-${props.appEnv}-web-oac-${props.timestamp}`,
-      description: 'Access from CloudFront to the frontend bucket.',
-      signing: cloudfront.Signing.SIGV4_NO_OVERRIDE,
-    })
-
-    if (config.app.docMode) {
-      // In doc mode, create only one distribution for docs
-      this.mainDistribution = this.createDistribution(
-        scope,
-        props,
-        props.docsBucket as s3.Bucket,
-        this.createDocsOriginRequestFunction(scope),
-        props.domain,
-        'MainCdn',
-        originAccessControl,
-      )
-    }
-    else {
-      // Not in doc mode, create two distributions
-      this.mainDistribution = this.createDistribution(
-        scope,
-        props,
-        props.publicBucket,
-        props.originRequestFunction,
-        props.domain,
-        'MainCdn',
-        originAccessControl,
-      )
-
-      if (props.docsBucket) {
-        this.docsDistribution = this.createDistribution(
-          scope,
-          props,
-          props.docsBucket,
-          this.createDocsOriginRequestFunction(scope),
-          `docs.${props.domain}`,
-          'DocsCdn',
-          originAccessControl,
-        )
-      }
-    }
-
-    // Create Route53 records
-    this.createRoute53Records(scope, props)
-
-    // Create outputs
-    this.createOutputs(scope, props)
-  }
-
-  createDistribution(
-    scope: Construct,
-    props: CdnStackProps,
-    sourceBucket: s3.Bucket,
-    originRequestFunction: lambda.Function,
-    domainName: string,
-    id: string,
-    originAccessControl: cloudfront.S3OriginAccessControl,
-  ): cloudfront.Distribution {
-    return new cloudfront.Distribution(scope, id, {
-      domainNames: [domainName],
-      defaultRootObject: 'index.html',
-      comment: `CDN for ${domainName}`,
-      certificate: props.certificate,
-      enableLogging: true,
-      logBucket: props.logBucket,
-      httpVersion: cloudfront.HttpVersion.HTTP2_AND_3,
-      priceClass: cloudfront.PriceClass.PRICE_CLASS_ALL,
-      enabled: true,
-      minimumProtocolVersion: cloudfront.SecurityPolicyProtocol.TLS_V1_2_2021,
-      webAclId: props.firewall.attrArn,
-      enableIpv6: true,
-      defaultBehavior: {
-        origin: new origins.S3StaticWebsiteOrigin(sourceBucket, {
-          originPath: '/',
-          originAccessControlId: originAccessControl.originAccessControlId,
-        }),
-        edgeLambdas: [
-          {
-            eventType: cloudfront.LambdaEdgeEventType.ORIGIN_REQUEST,
-            functionVersion: originRequestFunction.currentVersion,
-          },
-        ],
-        compress: config.cloud.cdn?.compress,
-        allowedMethods: this.allowedMethods(),
-        cachedMethods: this.cachedMethods(),
-        viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
-        cachePolicy: this.cdnCachePolicy,
-      },
-      errorResponses: [
-        {
-          httpStatus: 404,
-          responsePagePath: '/index.html',
-          responseHttpStatus: 200,
-          ttl: Duration.millis(0),
-        },
-        {
-          httpStatus: 403,
-          responsePagePath: '/index.html',
-          responseHttpStatus: 200,
-          ttl: Duration.millis(0),
-        },
-      ],
-    })
-  }
-
-  createRoute53Records(scope: Construct, props: CdnStackProps): void {
-    new route53.ARecord(scope, 'MainAliasRecord', {
-      recordName: props.domain,
-      zone: props.zone,
-      target: route53.RecordTarget.fromAlias(new targets.CloudFrontTarget(this.mainDistribution)),
-    })
-
-    if (this.docsDistribution) {
-      new route53.ARecord(scope, 'DocsAliasRecord', {
-        recordName: `docs.${props.domain}`,
-        zone: props.zone,
-        target: route53.RecordTarget.fromAlias(new targets.CloudFrontTarget(this.docsDistribution)),
-      })
-    }
-  }
-
-  createOutputs(scope: Construct, props: CdnStackProps): void {
-    new Output(scope, 'MainDistributionId', {
-      value: this.mainDistribution.distributionId,
-    })
-
-    new Output(scope, 'MainUrl', {
-      value: `https://${props.domain}`,
-      description: 'The URL of the deployed main application',
-    })
-
-    this.mainVanityUrl = `https://${this.mainDistribution.domainName}`
-    new Output(scope, 'MainVanityUrl', {
-      value: this.mainVanityUrl,
-      description: 'The vanity URL of the deployed main application',
-    })
-
-    if (this.docsDistribution) {
-      new Output(scope, 'DocsDistributionId', {
-        value: this.docsDistribution.distributionId,
-      })
-
-      this.docsVanityUrl = `https://${this.docsDistribution.domainName}`
-      new Output(scope, 'DocsAppVanityUrl', {
-        value: this.docsVanityUrl,
-        description: 'The vanity URL of the deployed docs application',
-      })
-    }
-  }
-
-  createDocsOriginRequestFunction(scope: Construct): lambda.Function {
-    const docsOriginRequestFunction = new lambda.Function(scope, 'DocsOriginRequestFunction', {
-      functionName: `${this.props.slug}-${this.props.appEnv}-docs-origin-request-function-${this.props.timestamp}`,
-      description: 'Custom origin request function for the docs',
-      runtime: lambda.Runtime.NODEJS_20_X,
-      handler: 'index.handler',
-      code: lambda.Code.fromInline(`
-        const config = {
-          suffix: '.html',
-        }
-
-        const regexSuffixless = /\\/[^/.]+$/
-        const regexTrailingSlash = /.+\\/$/
-
-        exports.handler = (event, context, callback) => {
-          const request = event.Records[0].cf.request;
-          const uri = request.uri;
-
-          // Append index.html to root URI
-          if (uri === '/') {
-            request.uri = '/index.html';
-            callback(null, request);
-            return;
-          }
-
-          // Append .html to suffixless URI
-          if (uri.match(regexSuffixless)) {
-            request.uri = uri + '.html';
-            callback(null, request);
-            return;
-          }
-
-          // Remove trailing slash and append .html to origin request
-          if (uri.match(regexTrailingSlash)) {
-            request.uri = uri.slice(0, -1) + '.html';
-            callback(null, request);
-            return;
-          }
-
-          callback(null, request);
-        };
-      `),
-    })
-
-    new lambda.CfnPermission(scope, 'DocsOriginRequestFunctionPermission', {
-      action: 'lambda:InvokeFunction',
-      principal: 'edgelambda.amazonaws.com',
-      functionName: docsOriginRequestFunction.functionName,
-    })
-
-    return docsOriginRequestFunction
-  }
-
-  getCookieBehavior(cookieBehavior: string | undefined): cloudfront.CacheCookieBehavior | undefined {
-    switch (cookieBehavior) {
-      case 'none':
-        return cloudfront.CacheCookieBehavior.none()
-      case 'all':
-        return cloudfront.CacheCookieBehavior.all()
-      case 'allowList':
-        return cloudfront.CacheCookieBehavior.allowList(...(config.cloud.cdn?.allowList.cookies || []))
-      default:
-        return undefined
-    }
-  }
-
-  allowedMethods(): cloudfront.AllowedMethods {
-    switch (config.cloud.cdn?.allowedMethods) {
-      case 'ALL':
-        return cloudfront.AllowedMethods.ALLOW_ALL
-      case 'GET_HEAD':
-        return cloudfront.AllowedMethods.ALLOW_GET_HEAD
-      case 'GET_HEAD_OPTIONS':
-        return cloudfront.AllowedMethods.ALLOW_GET_HEAD_OPTIONS
-      default:
-        return cloudfront.AllowedMethods.ALLOW_ALL
-    }
-  }
-
-  cachedMethods(): cloudfront.CachedMethods {
-    switch (config.cloud.cdn?.cachedMethods) {
-      case 'GET_HEAD':
-        return cloudfront.CachedMethods.CACHE_GET_HEAD
-      case 'GET_HEAD_OPTIONS':
-        return cloudfront.CachedMethods.CACHE_GET_HEAD_OPTIONS
-      default:
-        return cloudfront.CachedMethods.CACHE_GET_HEAD
-    }
-  }
-}

package/src/cloud/cli.ts

@@ -1,14 +0,0 @@
-import type { Construct } from 'constructs'
-import type { NestedCloudProps } from '../types'
-import { CfnOutput as Output } from 'aws-cdk-lib'
-
-export interface CliStackProps extends NestedCloudProps {}
-
-export class CliStack {
-  constructor(scope: Construct, props: CliStackProps) {
-    new Output(scope, 'CliSetupUrl', {
-      value: `https://api.${props.domain}/install`,
-      description: 'URL to trigger the CLI setup function',
-    })
-  }
-}

package/src/cloud/compute.ts

@@ -1,245 +0,0 @@
-import type { aws_certificatemanager as acm, aws_efs as efs } from 'aws-cdk-lib'
-import type { Construct } from 'constructs'
-import type { EnvKey } from '../../../../env'
-import type { NestedCloudProps } from '../types'
-import { env } from '@stacksjs/env'
-import { path as p } from '@stacksjs/path'
-import {
-  Duration,
-  aws_ec2 as ec2,
-  aws_ecs as ecs,
-  CfnOutput as Output,
-  RemovalPolicy,
-  aws_route53 as route53,
-  aws_route53_targets as route53Targets,
-  aws_secretsmanager as secretsmanager,
-} from 'aws-cdk-lib'
-import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2'
-import { LogGroup } from 'aws-cdk-lib/aws-logs'
-
-export interface ComputeStackProps extends NestedCloudProps {
-  vpc: ec2.Vpc
-  fileSystem: efs.FileSystem
-  zone: route53.IHostedZone
-  certificate: acm.Certificate
-}
-
-export class ComputeStack {
-  lb: elbv2.ApplicationLoadBalancer
-  cluster: ecs.Cluster
-  taskDefinition: ecs.FargateTaskDefinition
-
-  constructor(scope: Construct, props: ComputeStackProps) {
-    const vpc = props.vpc
-    const fileSystem = props.fileSystem
-
-    if (!fileSystem)
-      throw new Error('The file system is missing. Please make sure it was created properly.')
-
-    this.cluster = new ecs.Cluster(scope, 'StacksCluster', {
-      clusterName: `${props.slug}-${props.appEnv}-web-server-cluster`,
-      vpc,
-    })
-
-    this.taskDefinition = new ecs.FargateTaskDefinition(scope, 'TaskDefinition', {
-      family: `${props.appName}-${props.appEnv}-api`,
-      memoryLimitMiB: 512, // Match your Lambda memory size
-      cpu: 256, // Choose an appropriate value
-      runtimePlatform: {
-        cpuArchitecture: ecs.CpuArchitecture.ARM64,
-      },
-    })
-
-    // const assetImage = new ecr_assets.DockerImageAsset(scope, 'DockerImageAsset', {
-    //   directory: p.frameworkCloudPath(),
-    // })
-
-    const container = this.taskDefinition.addContainer('WebServerContainer', {
-      containerName: `${props.appName}-${props.appEnv}-api`,
-      // image: ecs.ContainerImage.fromDockerImageAsset(assetImage),
-      image: ecs.ContainerImage.fromAsset(p.frameworkPath('server')),
-      logging: new ecs.AwsLogDriver({
-        streamPrefix: `${props.appName}-${props.appEnv}-web-server-logs`,
-        logGroup: new LogGroup(scope, 'StacksApiLogs', {
-          logGroupName: '/aws/ecs/stacks-api',
-          removalPolicy: RemovalPolicy.DESTROY, // Automatically remove logs on stack deletion
-        }),
-      }),
-      healthCheck: {
-        command: ['CMD-SHELL', 'curl -f http://localhost:3000/health || exit 1'], // requires curl inside the container which isn't available in the base image. I wonder if there is a better way
-        interval: Duration.seconds(10),
-        timeout: Duration.seconds(5),
-        retries: 3,
-        startPeriod: Duration.seconds(10),
-      },
-    })
-
-    container.addPortMappings({
-      containerPort: 3000,
-      hostPort: 3000,
-    })
-
-    const serviceSecurityGroup = new ec2.SecurityGroup(scope, 'ServiceSecurityGroup', {
-      securityGroupName: `${props.appName}-${props.appEnv}-api-service-sg`,
-      vpc,
-      description: 'Stacks Security Group for API Service',
-    })
-
-    const publicLoadBalancerSG = new ec2.SecurityGroup(scope, 'PublicLoadBalancerSG', {
-      securityGroupName: `${props.appName}-${props.appEnv}-public-load-balancer-sg`,
-      vpc,
-      description: 'Access to the public facing load balancer',
-    })
-
-    // Assuming serviceSecurityGroup and publicLoadBalancerSG are already defined
-    serviceSecurityGroup.addIngressRule(publicLoadBalancerSG, ec2.Port.allTraffic(), 'Ingress from the public ALB')
-
-    this.lb = new elbv2.ApplicationLoadBalancer(scope, 'ApplicationLoadBalancer', {
-      http2Enabled: true,
-      loadBalancerName: `${props.appName}-${props.appEnv}-alb`,
-      vpc,
-      vpcSubnets: {
-        subnets: vpc.selectSubnets({
-          subnetType: ec2.SubnetType.PUBLIC,
-          onePerAz: true,
-        }).subnets,
-      },
-      internetFacing: true,
-      idleTimeout: Duration.seconds(30),
-      securityGroup: publicLoadBalancerSG,
-    })
-
-    new route53.ARecord(scope, 'ApiDomainAliasRecord', {
-      zone: props.zone,
-      recordName: 'api',
-      target: route53.RecordTarget.fromAlias(new route53Targets.LoadBalancerTarget(this.lb)),
-    })
-
-    const serviceTargetGroup = new elbv2.ApplicationTargetGroup(scope, 'ServiceTargetGroup', {
-      targetGroupName: `${props.appName}-${props.appEnv}-api-tg`,
-      vpc,
-      targetType: elbv2.TargetType.IP,
-      protocol: elbv2.ApplicationProtocol.HTTP,
-      port: 3000,
-      healthCheck: {
-        interval: Duration.seconds(6),
-        path: '/health',
-        protocol: elbv2.Protocol.HTTP,
-        timeout: Duration.seconds(5),
-        healthyThresholdCount: 2,
-        unhealthyThresholdCount: 10,
-      },
-    })
-
-    const service = new ecs.FargateService(scope, 'StacksApiService', {
-      serviceName: `${props.appName}-${props.appEnv}-api-service`,
-      cluster: this.cluster,
-      taskDefinition: this.taskDefinition,
-      desiredCount: 1,
-      assignPublicIp: true,
-      maxHealthyPercent: 200,
-      vpcSubnets: vpc.selectSubnets({
-        subnetType: ec2.SubnetType.PUBLIC,
-        onePerAz: true,
-      }),
-      minHealthyPercent: 75,
-      securityGroups: [serviceSecurityGroup],
-    })
-
-    service.attachToApplicationTargetGroup(serviceTargetGroup)
-    publicLoadBalancerSG.addIngressRule(ec2.Peer.anyIpv4(), ec2.Port.allTraffic())
-
-    this.lb.addListener('HttpsListener', {
-      port: 443,
-      certificates: [props.certificate],
-      defaultAction: elbv2.ListenerAction.forward([serviceTargetGroup]),
-    })
-
-    this.lb.addListener('HttpListener', {
-      port: 80,
-      defaultAction: elbv2.ListenerAction.forward([serviceTargetGroup]),
-    })
-
-    props.fileSystem.connections.allowFromAnyIpv4(ec2.Port.tcp(2049)) // port 2049 (NFS) for EFS
-
-    const volumeName = `${props.slug}-${props.appEnv}-efs`
-    this.taskDefinition.addVolume({
-      name: volumeName,
-      efsVolumeConfiguration: {
-        fileSystemId: props.fileSystem.fileSystemId,
-      },
-    })
-
-    container.addMountPoints({
-      sourceVolume: volumeName,
-      containerPath: '/mnt/efs',
-      readOnly: false,
-    })
-
-    // Setup AutoScaling policy
-    // TODO: make this configurable in cloud.compute
-    const scaling = service.autoScaleTaskCount({ maxCapacity: 2 })
-
-    scaling.scaleOnCpuUtilization('CpuScaling', {
-      targetUtilizationPercent: 50,
-      scaleInCooldown: Duration.seconds(60),
-      scaleOutCooldown: Duration.seconds(60),
-    })
-
-    scaling.scaleOnMemoryUtilization('MemoryScaling', {
-      targetUtilizationPercent: 60,
-      scaleInCooldown: Duration.seconds(60),
-      scaleOutCooldown: Duration.seconds(60),
-    })
-
-    const keysToRemove = [
-      '_HANDLER',
-      '_X_AMZN_TRACE_ID',
-      'AWS_REGION',
-      'AWS_EXECUTION_ENV',
-      'AWS_LAMBDA_FUNCTION_NAME',
-      'AWS_LAMBDA_FUNCTION_MEMORY_SIZE',
-      'AWS_LAMBDA_FUNCTION_VERSION',
-      'AWS_LAMBDA_INITIALIZATION_TYPE',
-      'AWS_LAMBDA_LOG_GROUP_NAME',
-      'AWS_LAMBDA_LOG_STREAM_NAME',
-      'AWS_ACCESS_KEY',
-      'AWS_ACCESS_KEY_ID',
-      'AWS_SECRET_ACCESS_KEY',
-      'AWS_SESSION_TOKEN',
-      'AWS_LAMBDA_RUNTIME_API',
-      'LAMBDA_TASK_ROOT',
-      'LAMBDA_RUNTIME_DIR',
-      '_',
-    ]
-    keysToRemove.forEach(key => delete env[key as EnvKey])
-
-    const secrets = new secretsmanager.Secret(scope, 'StacksSecrets', {
-      secretName: `${props.slug}-${props.appEnv}-secrets`,
-      description: 'Secrets for the Stacks application',
-      generateSecretString: {
-        secretStringTemplate: JSON.stringify(env),
-        generateStringKey: Object.keys(env).join(',').length.toString(),
-      },
-    })
-
-    if (service.taskDefinition.executionRole) {
-      secrets.grantRead(service.taskDefinition.executionRole)
-      container.addEnvironment('SECRETS_ARN', secrets.secretArn)
-    }
-    else {
-      throw new Error('Service task execution role is undefined.')
-    }
-
-    const apiPrefix = 'api'
-    new Output(scope, 'ApiUrl', {
-      value: `https://${apiPrefix}.${props.domain}/`,
-      description: 'The URL of the deployed application',
-    })
-
-    new Output(scope, 'ApiVanityUrl', {
-      value: `http://${this.lb.loadBalancerDnsName}`,
-      description: 'The Vanity URL / DNS name of the load balancer',
-    })
-  }
-}

package/src/cloud/dashboard.ts

@@ -1,85 +0,0 @@
-// // TODO: finish this cloudwatch dashboard
-// // import type { aws_lambda as lambda } from 'aws-cdk-lib'
-// import { Aws, CfnOutput as Output, aws_cloudwatch as cloudwatch } from 'aws-cdk-lib'
-// import type { Construct } from 'constructs'
-// import type { NestedCloudProps } from '../types'
-//
-// export interface DashboardStackProps extends NestedCloudProps {
-//   dashboardName?: string
-// }
-//
-// export class DashboardStack {
-//   // lambdaFunction: lambda.Function
-//   dashboard: cloudwatch.Dashboard
-//
-//   constructor(scope: Construct, props: DashboardStackProps) {
-//     const dashboardName = props.dashboardName || 'StacksDashboard'
-//
-//     // Create Sample Lambda Function which will create metrics
-//     // this.lambdaFunction = new Function(this, 'SampleLambda', {
-//     //   handler: 'lambda-handler.handler',
-//     //   runtime: Runtime.PYTHON_3_7,
-//     //   code: new AssetCode(`./lambda`),
-//     //   memorySize: 512,
-//     //   timeout: Duration.seconds(10),
-//     // })
-//
-//     // Create CloudWatch Dashboard
-//     this.dashboard = new cloudwatch.Dashboard(scope, 'SampleLambdaDashboard', {
-//       dashboardName,
-//     })
-//
-//     // Create Title for Dashboard
-//     this.dashboard.addWidgets(new cloudwatch.TextWidget({
-//       markdown: `# Dashboard: `,
-//       // markdown: `# Dashboard: ${this.lambdaFunction.functionName}`,
-//       height: 1,
-//       width: 24,
-//     }))
-//
-//     // Create CloudWatch Dashboard Widgets: Errors, Invocations, Duration, Throttles
-//     this.dashboard.addWidgets(new cloudwatch.GraphWidget({
-//       title: 'Invocations',
-//       left: [this.lambdaFunction.metricInvocations()],
-//       width: 24,
-//     }))
-//
-//     this.dashboard.addWidgets(new cloudwatch.GraphWidget({
-//       title: 'Errors',
-//       left: [this.lambdaFunction.metricErrors()],
-//       width: 24,
-//     }))
-//
-//     this.dashboard.addWidgets(new cloudwatch.GraphWidget({
-//       title: 'Duration',
-//       left: [this.lambdaFunction.metricDuration()],
-//       width: 24,
-//     }))
-//
-//     this.dashboard.addWidgets(new cloudwatch.GraphWidget({
-//       title: 'Throttles',
-//       left: [this.lambdaFunction.metricThrottles()],
-//       width: 24,
-//     }))
-//
-//     // Create Widget to show last 20 Log Entries
-//     this.dashboard.addWidgets(new cloudwatch.LogQueryWidget({
-//       logGroupNames: [this.lambdaFunction.logGroup.logGroupName],
-//       queryLines: [
-//         'fields @timestamp, @message',
-//         'sort @timestamp desc',
-//         'limit 20',
-//       ],
-//       width: 24,
-//     }))
-//
-//     // Generate Output
-//     const cloudwatchDashboardURL = `https://${Aws.REGION}.console.aws.amazon.com/cloudwatch/home?region=${Aws.REGION}#dashboards:name=${dashboardName}`
-//
-//     new Output(scope, 'DashboardOutput', {
-//       value: cloudwatchDashboardURL,
-//       description: 'The CloudWatch Dashboard URL',
-//       exportName: 'StacksDashboardURL',
-//     })
-//   }
-// }

package/src/cloud/database.ts

@@ -1,34 +0,0 @@
-import type { aws_ec2 as ec2 } from 'aws-cdk-lib'
-import type { Construct } from 'constructs'
-import type { NestedCloudProps } from '../types'
-import { aws_dynamodb as dynamodb, RemovalPolicy } from 'aws-cdk-lib'
-
-export interface DatabaseStackProps extends NestedCloudProps {
-  vpc: ec2.Vpc
-}
-
-export class DatabaseStack {
-  database: dynamodb.Table
-
-  constructor(scope: Construct, props: DatabaseStackProps) {
-    this.database = new dynamodb.Table(scope, 'Database', {
-      tableName: `${props.slug}-${props.appEnv}-database`,
-      partitionKey: {
-        // wip
-        name: 'id',
-        type: dynamodb.AttributeType.STRING,
-      },
-      sortKey: {
-        // wip
-        name: 'sort',
-        type: dynamodb.AttributeType.STRING,
-      },
-      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
-      readCapacity: 5,
-      writeCapacity: 5,
-      pointInTimeRecovery: true,
-      removalPolicy: RemovalPolicy.DESTROY,
-      encryption: dynamodb.TableEncryption.AWS_MANAGED,
-    })
-  }
-}