@stacksjs/cloud 0.70.23 → 0.70.26

package/dist/compute.d.ts

@@ -1,221 +0,0 @@
-import type { Construct } from 'constructs';
-import type { NestedCloudProps } from '../types';
-
-export declare interface ComputeStackProps extends NestedCloudProps {
-  vpc: ec2.Vpc
-  fileSystem: efs.FileSystem
-  zone: route53.IHostedZone
-  certificate: acm.Certificate
-}
-export declare 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, 
-      cpu: 256, 
-      runtimePlatform: {
-        cpuArchitecture: ecs.CpuArchitecture.ARM64,
-      },
-    })
-
-
-    const container = this.taskDefinition.addContainer('WebServerContainer', {
-      containerName: `${props.appName}-${props.appEnv}-api`,
-      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, 
-        }),
-      }),
-      healthCheck: {
-        command: ['CMD-SHELL', 'curl -f http:
-        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',
-    })
-
-    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)) 
-
-    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,
-    })
-
-    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:
-      description: 'The URL of the deployed application',
-    })
-
-    new Output(scope, 'ApiVanityUrl', {
-      value: `http:
-      description: 'The Vanity URL / DNS name of the load balancer',
-    })
-  }
-}

package/dist/database.d.ts

@@ -1,29 +0,0 @@
-import type { Construct } from 'constructs';
-import type { NestedCloudProps } from '../types';
-
-export declare interface DatabaseStackProps extends NestedCloudProps {
-  vpc: ec2.Vpc
-}
-export declare class DatabaseStack {
-  database: dynamodb.Table
-
-  constructor(scope: Construct, props: DatabaseStackProps) {
-    this.database = new dynamodb.Table(scope, 'Database', {
-      tableName: `${props.slug}-${props.appEnv}-database`,
-      partitionKey: {
-        name: 'id',
-        type: dynamodb.AttributeType.STRING,
-      },
-      sortKey: {
-        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,
-    })
-  }
-}

package/dist/deployment.d.ts

@@ -1,60 +0,0 @@
-import type { Construct } from 'constructs';
-import type { NestedCloudProps } from '../types';
-
-export declare interface DeploymentStackProps extends NestedCloudProps {
-  publicBucket: s3.Bucket
-  docsBucket?: s3.Bucket
-  privateBucket: s3.Bucket
-  mainDistribution: cloudfront.Distribution
-  docsDistribution?: cloudfront.Distribution
-}
-export declare class DeploymentStack {
-  privateSource: string
-  docsSource: string
-  publicSource: string
-
-  constructor(scope: Construct, props: DeploymentStackProps) {
-    this.privateSource = '../../private'
-    this.docsSource = '../docs/dist/'
-    this.publicSource = config.app.docMode === true ? this.docsSource : '../views/web/dist/'
-    const mainBucket = config.app.docMode === true ? props.docsBucket : props.publicBucket
-
-    new s3deploy.BucketDeployment(scope, 'Website', {
-      sources: [
-        s3deploy.Source.asset(this.publicSource, {
-          assetHash: websiteSourceHash(),
-          assetHashType: AssetHashType.CUSTOM,
-        }),
-      ],
-      destinationBucket: mainBucket as s3.Bucket,
-      distribution: props.mainDistribution,
-    })
-
-    if (this.shouldDeployDocs()) {
-      new s3deploy.BucketDeployment(scope, 'Docs', {
-        sources: [
-          s3deploy.Source.asset(this.docsSource, {
-            assetHash: docsSourceHash(),
-            assetHashType: AssetHashType.CUSTOM,
-          }),
-        ],
-        destinationBucket: props.docsBucket as s3.Bucket,
-        distribution: props.docsDistribution,
-      })
-    }
-
-    if (hasFiles(this.privateSource)) {
-      new s3deploy.BucketDeployment(scope, 'PrivateFiles', {
-        sources: [s3deploy.Source.asset(this.privateSource)],
-        destinationBucket: props.privateBucket,
-      })
-    }
-    else {
-      console.error(`The path ${this.privateSource} does not have any files`)
-    }
-  }
-
-  shouldDeployDocs(): boolean {
-    return hasFiles(p.projectPath('docs')) && !config.app.docMode
-  }
-}

package/dist/dns.d.ts

@@ -1,34 +0,0 @@
-import type { Construct } from 'constructs';
-import type { NestedCloudProps } from '../types';
-
-export declare class DnsStack {
-  zone: route53.IHostedZone
-
-  constructor(scope: Construct, props: NestedCloudProps) {
-    this.zone = route53.PublicHostedZone.fromLookup(scope, 'AppUrlHostedZone', {
-      domainName: props.domain,
-    })
-
-    const wwwBucket = new s3.Bucket(scope, 'WwwBucket', {
-      bucketName: `www.${props.domain}`,
-      websiteRedirect: {
-        hostName: props.domain,
-        protocol: s3.RedirectProtocol.HTTPS,
-      },
-      removalPolicy: RemovalPolicy.DESTROY,
-      autoDeleteObjects: true,
-    })
-
-    new route53.ARecord(scope, 'WwwAliasRecord', {
-      recordName: `www.${props.domain}`,
-      zone: this.zone,
-      target: route53.RecordTarget.fromAlias(new targets.BucketWebsiteTarget(wwwBucket)),
-    })
-
-    new route53.ARecord(scope, 'StoreAliasRecord', {
-      recordName: `store.${props.domain}`,
-      zone: this.zone,
-      target: route53.RecordTarget.fromIpAddresses('137.66.37.136'),
-    })
-  }
-}

package/dist/docs.d.ts

@@ -1,34 +0,0 @@
-import type { CfnResource } from 'aws-cdk-lib';
-import type { Construct } from 'constructs';
-import type { NestedCloudProps } from '../types';
-
-export declare interface DocsStackProps extends NestedCloudProps {
-}
-export declare class DocsStack {
-  originRequestFunction: lambda.Function
-
-  constructor(scope: Construct, props: DocsStackProps) {
-    const docsPrefix = 'docs'
-
-    this.originRequestFunction = new lambda.Function(scope, 'OriginRequestFunction', {
-      functionName: `${props.slug}-${props.appEnv}-origin-request-${props.timestamp}`,
-      description: 'The Stacks Origin Request function that prettifies URLs by removing the .html extension',
-      runtime: lambda.Runtime.NODEJS_20_X,
-      handler: 'dist/origin-request.handler',
-      code: lambda.Code.fromAsset(p.cloudPath('dist.zip'), {
-        assetHash: originRequestFunctionHash(),
-        assetHashType: AssetHashType.CUSTOM,
-      }),
-    })
-
-    const cfnOriginRequestFunction = this.originRequestFunction.node.defaultChild as CfnResource
-    cfnOriginRequestFunction.applyRemovalPolicy(RemovalPolicy.RETAIN)
-
-    if (!config.app.docMode && storage.hasFiles(p.projectPath('docs'))) {
-      new Output(scope, 'DocsUrl', {
-        value: `https:
-        description: 'The URL of the deployed documentation',
-      })
-    }
-  }
-}