@stacksjs/cloud 0.67.0 → 0.68.1

package/dist/ai.d.ts

@@ -0,0 +1,20 @@
+import type { Construct } from 'constructs';
+import type { NestedCloudProps } from '../types';
+
+export declare interface AiStackProps extends NestedCloudProps {}
+export declare class AiStack {
+  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/dist/cdn.d.ts

@@ -0,0 +1,271 @@
+import type { ApplicationLoadBalancer } from 'aws-cdk-lib/aws-elasticloadbalancingv2';
+import type { Construct } from 'constructs';
+import type { NestedCloudProps } from '../types';
+
+export declare 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 declare 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) {
+      this.mainDistribution = this.createDistribution(
+        scope,
+        props,
+        props.docsBucket as s3.Bucket,
+        this.createDocsOriginRequestFunction(scope),
+        props.domain,
+        'MainCdn',
+        originAccessControl,
+      )
+    }
+    else {
+      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,
+        )
+      }
+    }
+
+    this.createRoute53Records(scope, props)
+
+    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:
+      description: 'The URL of the deployed main application',
+    })
+
+    this.mainVanityUrl = `https:
+    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:
+      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;
+
+          if (uri === '/') {
+            request.uri = '/index.html';
+            callback(null, request);
+            return;
+          }
+
+          if (uri.match(regexSuffixless)) {
+            request.uri = uri + '.html';
+            callback(null, request);
+            return;
+          }
+
+          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/dist/cli.d.ts

@@ -0,0 +1,12 @@
+import type { Construct } from 'constructs';
+import type { NestedCloudProps } from '../types';
+
+export declare interface CliStackProps extends NestedCloudProps {}
+export declare class CliStack {
+  constructor(scope: Construct, props: CliStackProps) {
+    new Output(scope, 'CliSetupUrl', {
+      value: `https:
+      description: 'URL to trigger the CLI setup function',
+    })
+  }
+}

package/dist/compute.d.ts

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

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

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

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

@@ -0,0 +1,34 @@
+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',
+      })
+    }
+  }
+}