@batijs/cli 0.0.259 → 0.0.261

package/dist/boilerplates/@batijs/authjs/files/$package.json.js

@@ -44,7 +44,7 @@ var require_package = __commonJS({
         "@auth/core": "^0.34.2",
         "@batijs/compile": "workspace:*",
         "@types/node": "^18.19.14",
-        "@universal-middleware/core": "^0.2.5",
+        "@universal-middleware/core": "^0.2.6",
         dotenv: "^16.4.5"
       },
       dependencies: {

package/dist/boilerplates/@batijs/authjs/files/server/authjs-handler.ts

@@ -77,7 +77,7 @@ export async function getSession(req: Request, config: Omit<AuthConfig, "raw">):
  * Add Auth.js session to context
  * @link {@see https://authjs.dev/getting-started/session-management/get-session}
  **/
-export const authjsSessionMiddleware = (() => async (request, context) => {
+export const authjsSessionMiddleware: Get<[], UniversalMiddleware> = () => async (request, context) => {
   try {
     return {
       ...context,
@@ -90,7 +90,7 @@ export const authjsSessionMiddleware = (() => async (request, context) => {
       session: null,
     };
   }
-}) satisfies Get<[], UniversalMiddleware>;
+};
 
 /**
  * Auth.js route

package/dist/boilerplates/@batijs/authjs/types/server/authjs-handler.d.ts

@@ -1,5 +1,6 @@
 import { type AuthConfig } from "@auth/core";
 import type { Session } from "@auth/core/types";
+import type { Get, UniversalMiddleware } from "@universal-middleware/core";
 /**
  * Retrieve Auth.js session from Request
  */
@@ -8,9 +9,7 @@ export declare function getSession(req: Request, config: Omit<AuthConfig, "raw">
  * Add Auth.js session to context
  * @link {@see https://authjs.dev/getting-started/session-management/get-session}
  **/
-export declare const authjsSessionMiddleware: () => (request: Request, context: Universal.Context) => Promise<{
-    session: Session | null;
-}>;
+export declare const authjsSessionMiddleware: Get<[], UniversalMiddleware>;
 /**
  * Auth.js route
  * @link {@see https://authjs.dev/getting-started/installation}

package/dist/boilerplates/@batijs/aws/files/$README.md.js

@@ -0,0 +1,109 @@
+// files/$README.md.ts
+import { loadReadme } from "@batijs/core";
+async function getReadme(props) {
+  const content = await loadReadme(props);
+  const todo = `
+## *AWS CDK Deployment*
+
+This is a boilerplate for deploying your Vike app to AWS using the AWS Cloud Development Kit (CDK) including creating a custom domain in Route53.
+
+**Architecture:**
+- S3 Bucket for static client assets (\`/dist/client/assets\`).
+- Lambda function for the backend and SSR.
+- CloudFront distribution for CDN and routing requests \`/assets/*\` to the S3 bucket.
+
+This boilerplate is a starting point for deploying your Vike app to AWS. You can customize the deployment by modifying the \`cdk/lib/vike-stack.ts\` file.
+
+### Prerequisites
+
+Before you get started, make sure to configure your AWS credentials.
+
+**Loading from a file:**
+
+You can keep your AWS credentials in a file. The credentials are found at:
+
+\`~/.aws/credentials\` on Linux, Unix, and macOS;
+\`C:\\Users\\USER_NAME\\.aws\\credentials\` on Windows
+
+If the credentials file does not exist on your machine:
+
+Download the AWS CLI from [here](https://aws.amazon.com/cli/) and configure your AWS credentials using the following command:
+\`aws configure\`
+
+And then use this guide to configure the credentials
+The credentials file should look like:
+
+\`
+[default]
+aws_access_key_id = <YOUR_ACCESS_KEY_ID>
+aws_secret_access_key = <YOUR_SECRET_ACCESS_KEY>
+\`
+
+**Loading from environment variables:**
+
+AWS SDK automatically detects AWS credentials in your environment and uses them for making requests to AWS. The environment variables that you need to set are:
+
+\`AWS_ACCESS_KEY_ID\`
+\`AWS_SECRET_ACCESS_KEY\`
+If you are using temporary credentials, also set:
+
+\`AWS_SESSION_TOKEN\`
+This is often the most convenient way to configure credentials when deploying your AWS CDK app in a CI environment. 
+
+> [!NOTE]
+> You should change the stack name to give your app stack a distinctive name in your AWS environment. You can do so by modifying the \`infrastructure.ts.ts\` file in the \`cdk/bin\` directory.
+
+### Deployment to AWS
+
+If you want to have a look at the synthesized CloudFormation template, you can run \`pnpm cdk synth\` and see the template as YAML on screen or in \`cdk.out/VikeStack.template.json\`.
+
+> [!NOTE]
+> If this is your **first time deploying a CDK app** in this environment you need to **bootstrap**:
+> \`pnpm cdk bootstrap\`. (The default region based on your AWS CLI configuration will be used)
+
+You can deploy your Vike App via the following command:
+\`pnpm deploy:aws\` or \`pnpm cdk deploy\`
+
+The URL to the CloudFront distribution will be displayed in the output of the deployment.
+You can also access the CloudFront distribution domainname in the AWS SSM registry und \`vike/distribution/url\`.
+
+### Stack Configuration
+
+You can configure the stack in the \`cdk/bin/infrastructure.ts\` file:
+| --- | --- | --- |
+| Variable | Examples | Description |
+| \`domainName: "example.com",\` | "example.com" |  |
+| \`subDomain: "www",\` |"www" | |
+| \`certificate: undefined,\` | "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" or a certificatemanager.ICertificate | reuse an existing AWS Certificate |
+| \`hostedZone: undefined,\` | route53.HostedZone.fromLookup(stack, "MyHostedZone", { domainName: "example.com" }) | |
+
+If \`domainName\` is managed by **Route53**, the \`hostedZone\` will be updated with by lookup in Route53 based on the \`domainName\`.
+
+These scenarios are supported:
+A. \`domainName\` exists in Route53, \`subDomain\` is given - the subdomain with the domain are used as alternative domains for the CloudFront Distribution. An new Certificate for the url is created and assigned to the CF-Distribution. An Alias-Record pointing to the CF-Distribution ist created in Route53.
+B. \`domainName\` exists in Route53, \`subDomain\` is given - the subdomain with the domain are used as alternative domains for the CloudFront Distribution. If \`certificate\` contains a valid entry it will be assigned to the CF-Distribution. An Alias-Record pointing to the CF-Distribution ist created in Route53.
+C. \`domainName\` **does not exist** in Route53, \`subDomain\` is given - the subdomain with the domain are used as alternative domains for the CloudFront Distribution. If \`certificate\` contains a valid entry it will be assigned to the CF-Distribution. A manual created CNAME or A-Record should pointing to the CF-Distribution.
+
+#### Custom Domain
+
+If you have a custom domain, you can add it to the stack configuration in the \`cdk/bin/infrastructure.ts\` file:
+
+> [!NOTE]
+> If you deploy your App to a region different than \`us-east-1\` and you have never deployed to this region before, you will need to bootstrap this region too:
+ \`CDK_DEFAULT_REGION=us-east-1 pnpm deploy:cdk bootstrap\`
+
+
+### Destroying the Stack on AWS
+
+To destroy the stack on AWS, run the following command:
+\`pnpm cdk destroy\`
+
+Or delete the CloudFormation stack which starts with "VikeStack-<Your App Name>" created by this project.
+
+`;
+  content.addTodo(todo);
+  return content.finalize();
+}
+export {
+  getReadme as default
+};

package/dist/boilerplates/@batijs/aws/files/$package.json.js

@@ -0,0 +1,138 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "@batijs/aws",
+      private: true,
+      version: "0.0.1",
+      description: "",
+      type: "module",
+      scripts: {
+        "check-types": "tsc --noEmit",
+        build: "bati-compile-boilerplate"
+      },
+      keywords: [],
+      author: "",
+      license: "MIT",
+      devDependencies: {
+        "@batijs/compile": "workspace:*",
+        "@types/node": "^18.19.14",
+        "@types/which": "^3.0.4",
+        "aws-cdk": "^2.154.1",
+        "aws-cdk-lib": "^2.154.1",
+        cdk: "^2.154.1",
+        constructs: "^10.3.0",
+        esbuild: "^0.23.1",
+        "source-map-support": "^0.5.21",
+        tsx: "^4.19.0",
+        typescript: "^5.5.4",
+        vitest: "^2.0.5",
+        which: "^4.0.0"
+      },
+      dependencies: {
+        "@batijs/core": "workspace:*"
+      },
+      files: [
+        "dist/"
+      ],
+      bati: {
+        if: {
+          flag: "aws"
+        }
+      },
+      exports: {
+        "./vitest.config": {
+          types: "./dist/types/vitest.config.d.ts"
+        },
+        "./cdk/lib/vike-stack": {
+          types: "./dist/types/cdk/lib/vike-stack.d.ts"
+        },
+        "./cdk/bin/infrastructure": {
+          types: "./dist/types/cdk/bin/infrastructure.d.ts"
+        },
+        "./tests/aws_handler.spec": {
+          types: "./dist/types/tests/aws_handler.spec.d.ts"
+        }
+      },
+      typesVersions: {
+        "*": {
+          "vitest.config": [
+            "./dist/types/vitest.config.d.ts"
+          ],
+          "cdk/lib/vike-stack": [
+            "./dist/types/cdk/lib/vike-stack.d.ts"
+          ],
+          "cdk/bin/infrastructure": [
+            "./dist/types/cdk/bin/infrastructure.d.ts"
+          ],
+          "tests/aws_handler.spec": [
+            "./dist/types/tests/aws_handler.spec.d.ts"
+          ]
+        }
+      }
+    };
+  }
+});
+
+// files/$package.json.ts
+import { addDependency, loadAsJson, setScripts } from "@batijs/core";
+async function getPackageJson(props) {
+  const packageJson = await loadAsJson(props);
+  setScripts(packageJson, {
+    test: {
+      value: "vitest",
+      precedence: 0
+    },
+    "deploy:cdk": {
+      value: "cdk",
+      precedence: 0
+    },
+    "deploy:aws": {
+      value: "pnpm run build && cdk deploy --all",
+      precedence: 0
+    }
+  });
+  return addDependency(packageJson, await Promise.resolve().then(() => __toESM(require_package(), 1)).then((x) => x.default), {
+    devDependencies: [
+      "cdk",
+      "aws-cdk",
+      "@types/node",
+      "tsx",
+      "typescript",
+      "esbuild",
+      "vitest",
+      "which",
+      "@types/which"
+    ],
+    dependencies: ["aws-cdk-lib", "constructs", "source-map-support"]
+  });
+}
+export {
+  getPackageJson as default
+};

package/dist/boilerplates/@batijs/aws/files/$tsconfig.json.js

@@ -0,0 +1,15 @@
+// files/$tsconfig.json.ts
+import { loadAsJson } from "@batijs/core";
+async function getTsConfig(props) {
+  const tsConfig = await loadAsJson(props);
+  tsConfig.compilerOptions.types = [
+    ...tsConfig.compilerOptions.types ?? [],
+    "@types/node",
+    "vitest/globals",
+    "@types/which"
+  ];
+  return tsConfig;
+}
+export {
+  getTsConfig as default
+};

package/dist/boilerplates/@batijs/aws/files/cdk/$stack-name-suffix.json.js

@@ -0,0 +1,19 @@
+// files/cdk/$stack-name-suffix.json.ts
+async function getDataJson() {
+  const dataJson = {
+    stackNameSuffix: generateRandomPrefix(8)
+  };
+  return dataJson;
+}
+function generateRandomPrefix(length) {
+  if (process.env.NODE_ENV === "test") return "TEST";
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += characters.charAt(Math.floor(Math.random() * characters.length));
+  }
+  return result;
+}
+export {
+  getDataJson as default
+};

package/dist/boilerplates/@batijs/aws/files/cdk/bin/infrastructure.ts

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import "source-map-support/register";
+import * as cdk from "aws-cdk-lib";
+import { VikeStack } from "../lib/vike-stack";
+
+import * as certificatemanager from "aws-cdk-lib/aws-certificatemanager";
+import * as route53 from "aws-cdk-lib/aws-route53";
+
+//# BATI.has("REMOVE-COMMENT") || "remove-comments-only"
+// @ts-ignore file will be generated by the transformer
+import { stackNameSuffix } from "../stack-name-suffix.json";
+
+const env: cdk.Environment = {
+  account: process.env.CDK_DEFAULT_ACCOUNT,
+  region: process.env.CDK_DEFAULT_REGION,
+};
+
+export type CustomStackProps = cdk.StackProps & {
+  domainName?: string;
+  subDomain?: string;
+  certificate?: string | certificatemanager.ICertificate;
+  hostedZone?: route53.IHostedZone;
+};
+
+// Here you can configure the stack:
+const customStackProps: CustomStackProps = {
+  domainName: undefined, // e.g. "example.com"
+  subDomain: undefined, // e.g. "www"
+  certificate: undefined, // e.g. "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" or a certificatemanager.ICertificate
+  hostedZone: undefined, // e.g. route53.HostedZone.fromLookup(stack, "MyHostedZone", { domainName: "example.com" })
+};
+
+const app = new cdk.App();
+
+const usEast1Stack = customStackProps?.domainName
+  ? new cdk.Stack(app, `VikeStack-Cert-${stackNameSuffix}`, {
+      env: {
+        ...env,
+        region: "us-east-1",
+      },
+      crossRegionReferences: true,
+    })
+  : undefined;
+
+customStackProps.hostedZone = usEast1Stack
+  ? customStackProps?.hostedZone
+    ? customStackProps?.hostedZone
+    : customStackProps?.domainName
+      ? route53.HostedZone.fromLookup(usEast1Stack, "MyHostedZone", {
+          domainName: customStackProps.domainName,
+        })
+      : undefined
+  : undefined;
+
+customStackProps.certificate = usEast1Stack ? loadCertificate(usEast1Stack, customStackProps) : undefined;
+
+const mainStack = new VikeStack(app, `VikeStack-${stackNameSuffix}`, {
+  env,
+  crossRegionReferences: true,
+  customStackProps,
+});
+
+if (usEast1Stack) {
+  mainStack.addDependency(usEast1Stack);
+  app.synth();
+}
+function loadCertificate(stack: cdk.Stack, stackConfig: CustomStackProps): certificatemanager.ICertificate | undefined {
+  const { domainName, subDomain, certificate, hostedZone } = stackConfig;
+  if (typeof certificate === "string") {
+    certificatemanager.Certificate.fromCertificateArn(stack, "Certificate", certificate);
+  } else if (certificate) {
+    return certificate;
+  }
+
+  if (!domainName) {
+    return undefined;
+  }
+
+  const siteDomainName = `${(subDomain?.length ?? 0 > 0) ? `${subDomain}.` : ""}${domainName}`;
+  return new certificatemanager.Certificate(stack, "Certificate", {
+    domainName: siteDomainName,
+    //subjectAlternativeNames: props.domainAliases,
+    validation: certificatemanager.CertificateValidation.fromDns(hostedZone),
+  });
+}

package/dist/boilerplates/@batijs/aws/files/cdk/lib/vike-stack.ts

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+import "source-map-support/register";
+import { Construct } from "constructs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import * as cdk from "aws-cdk-lib";
+import * as ssm from "aws-cdk-lib/aws-ssm";
+import * as s3 from "aws-cdk-lib/aws-s3";
+import * as s3deploy from "aws-cdk-lib/aws-s3-deployment";
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import * as logs from "aws-cdk-lib/aws-logs";
+import * as cloudfront from "aws-cdk-lib/aws-cloudfront";
+import * as nodejs from "aws-cdk-lib/aws-lambda-nodejs";
+import * as origin from "aws-cdk-lib/aws-cloudfront-origins";
+import * as api from "aws-cdk-lib/aws-apigatewayv2";
+import { HttpLambdaIntegration } from "aws-cdk-lib/aws-apigatewayv2-integrations";
+import * as route53 from "aws-cdk-lib/aws-route53";
+import * as targets from "aws-cdk-lib/aws-route53-targets";
+import { existsSync } from "node:fs";
+import type { CustomStackProps } from "../bin/infrastructure";
+
+type VikeStackProps = cdk.StackProps & {
+  customStackProps: CustomStackProps;
+};
+
+// Define __dirname for ES module scope
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = join(__filename, "..");
+
+export class VikeStack extends cdk.Stack {
+  readonly distributionUrlParameterName = `/${this.stackName}/distribution/url`;
+
+  constructor(scope: Construct, id: string, props: VikeStackProps) {
+    super(scope, id, props);
+
+    const certificate =
+      props.customStackProps?.certificate && typeof props.customStackProps?.certificate !== "string"
+        ? props.customStackProps?.certificate
+        : undefined;
+
+    const hostedZone = props.customStackProps?.hostedZone;
+    const subDomain = props.customStackProps?.subDomain;
+    const domainName = props.customStackProps?.domainName;
+    const siteDomainName = domainName
+      ? `${(subDomain?.length ?? 0 > 0) ? `${subDomain}.` : ""}${domainName}`
+      : undefined;
+
+    const bucket = new s3.Bucket(this, "StaticAssetsBucket", {
+      /**
+       * The default removal policy is RETAIN, which means that cdk destroy will not attempt to delete
+       * the new bucket, and it will remain in your account until manually deleted. By setting the policy to
+       * DESTROY, cdk destroy will attempt to delete the bucket, but will error if the bucket is not empty.
+       */
+      removalPolicy: cdk.RemovalPolicy.DESTROY, // NOT recommended for production code
+
+      /**
+       * For sample purposes only, if you create an S3 bucket then populate it, stack destruction fails.  This
+       * setting will enable full cleanup of the demo.
+       */
+      autoDeleteObjects: true, // NOT recommended for production code
+    });
+
+    // Create a Lambda function for the backend
+    const banner =
+      "const require = (await import('node:module')).createRequire(import.meta.url);const __filename = (await import('node:url')).fileURLToPath(import.meta.url);const __dirname = (await import('node:path')).dirname(__filename);";
+
+    const fn = new nodejs.NodejsFunction(this, "RequestHandler", {
+      handler: "handler",
+      entry: join(__dirname, "../../entry_aws_lambda.ts"),
+      // fix error: "Cannot find a package lock file ..." when using "bun" javascript package manager and runtime
+      depsLockFilePath: findBunLockFile(),
+      environment: {
+        NODE_ENV: "production",
+      },
+      bundling: {
+        banner,
+        format: nodejs.OutputFormat.ESM,
+        minify: true,
+        target: "esnext",
+        //nodeModules: ["react", "react-dom"],
+        esbuildArgs: {
+          "--tree-shaking": true,
+        },
+      },
+      runtime: lambda.Runtime.NODEJS_20_X,
+      architecture: lambda.Architecture.ARM_64,
+      memorySize: 256,
+      timeout: cdk.Duration.seconds(10),
+      logRetention: logs.RetentionDays.THREE_DAYS,
+      tracing: lambda.Tracing.ACTIVE,
+    });
+
+    const integration = new HttpLambdaIntegration("RequestHandlerIntegration", fn, {
+      payloadFormatVersion: api.PayloadFormatVersion.VERSION_2_0,
+    });
+
+    const httpApi = new api.HttpApi(this, "WebsiteApi", {
+      defaultIntegration: integration,
+    });
+
+    const httpApiUrl = `${httpApi.httpApiId}.execute-api.${cdk.Stack.of(this).region}.${cdk.Stack.of(this).urlSuffix}`;
+
+    // Create a CloudFront distribution with custom behaviors
+    const requestHandlerOrigin = new origin.HttpOrigin(httpApiUrl);
+
+    const requestHandlerBehavior: cloudfront.AddBehaviorOptions = {
+      allowedMethods: cloudfront.AllowedMethods.ALLOW_ALL,
+      viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+      cachePolicy: cloudfront.CachePolicy.CACHING_DISABLED,
+      // https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-managed-origin-request-policies.html
+      originRequestPolicy: cloudfront.OriginRequestPolicy.ALL_VIEWER_EXCEPT_HOST_HEADER,
+      compress: true,
+    };
+
+    const assetOrigin = new origin.S3Origin(bucket);
+    const assetBehaviorOptions = {
+      viewerProtocolPolicy: cloudfront.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+      compress: true,
+    };
+
+    const distribution = new cloudfront.Distribution(this, "CloudFront", {
+      defaultBehavior: {
+        origin: requestHandlerOrigin,
+        ...requestHandlerBehavior,
+      },
+      domainNames: siteDomainName ? [siteDomainName] : undefined,
+      certificate,
+      enableIpv6: true,
+      minimumProtocolVersion: cloudfront.SecurityPolicyProtocol.TLS_V1_2_2021,
+      httpVersion: cloudfront.HttpVersion.HTTP2_AND_3,
+      priceClass: cloudfront.PriceClass.PRICE_CLASS_100,
+    });
+
+    distribution.addBehavior("/assets/*", assetOrigin, assetBehaviorOptions);
+
+    // Deploy static assets to the S3 bucket and invalidate the CloudFront cache
+    new s3deploy.BucketDeployment(this, "DeployStaticAssets", {
+      sources: [s3deploy.Source.asset(join(__dirname, "../../dist/client"))],
+      destinationBucket: bucket,
+      distribution,
+      distributionPaths: ["/*"],
+      prune: true,
+      cacheControl: [
+        s3deploy.CacheControl.maxAge(cdk.Duration.days(365)),
+        s3deploy.CacheControl.sMaxAge(cdk.Duration.days(365)),
+      ],
+    });
+
+    // Create a Route 53 alias record pointing to the CloudFront distribution
+    if (hostedZone) {
+      new route53.ARecord(this, "AliasRecord", {
+        zone: hostedZone,
+        target: route53.RecordTarget.fromAlias(new targets.CloudFrontTarget(distribution)),
+        recordName: subDomain ?? "", // This will create a record for www.example.com
+      });
+    }
+
+    // Store the CloudFront URL in an SSM parameter
+    new ssm.StringParameter(this, "DistributionUrlParameter", {
+      parameterName: this.distributionUrlParameterName,
+      stringValue: siteDomainName ? siteDomainName! : distribution.distributionDomainName,
+      tier: ssm.ParameterTier.STANDARD,
+    });
+
+    // Output the CloudFront URL and API endpoint
+    new cdk.CfnOutput(this, "CloudFrontURL", {
+      value: `https://${siteDomainName ? siteDomainName : distribution.distributionDomainName}`,
+    });
+
+    new cdk.CfnOutput(this, "CloudFrontID", {
+      value: distribution.distributionId,
+    });
+  }
+}
+
+function findBunLockFile() {
+  let bunLockFile = join(__dirname, "../../", "bun.lockb");
+  if (existsSync(bunLockFile)) {
+    return bunLockFile;
+  }
+  bunLockFile = join(__dirname, "../../", "../../", "bun.lockb"); // special case for bat tests
+  if (existsSync(bunLockFile)) {
+    return bunLockFile;
+  }
+  return undefined;
+}

package/dist/boilerplates/@batijs/aws/files/cdk.json

@@ -0,0 +1,72 @@
+{
+  "app": "pnpm tsx cdk/bin/infrastructure.ts",
+  "watch": {
+    "include": [
+      "**"
+    ],
+    "exclude": [
+      "README.md",
+      "cdk*.json",
+      "**/*.d.ts",
+      "**/*.js",
+      "tsconfig.json",
+      "package*.json",
+      "yarn.lock",
+      "node_modules",
+      "test"
+    ]
+  },
+  "context": {
+    "@aws-cdk/core:newStyleStackSynthesis": true,
+    "@aws-cdk/aws-lambda:recognizeLayerVersion": true,
+    "@aws-cdk/core:checkSecretUsage": true,
+    "@aws-cdk/core:target-partitions": [
+      "aws",
+      "aws-cn"
+    ],
+    "@aws-cdk-containers/ecs-service-extensions:enableDefaultLogDriver": true,
+    "@aws-cdk/aws-ec2:uniqueImdsv2TemplateName": true,
+    "@aws-cdk/aws-ecs:arnFormatIncludesClusterName": true,
+    "@aws-cdk/aws-iam:minimizePolicies": true,
+    "@aws-cdk/core:validateSnapshotRemovalPolicy": true,
+    "@aws-cdk/aws-codepipeline:crossAccountKeyAliasStackSafeResourceName": true,
+    "@aws-cdk/aws-s3:createDefaultLoggingPolicy": true,
+    "@aws-cdk/aws-sns-subscriptions:restrictSqsDescryption": true,
+    "@aws-cdk/aws-apigateway:disableCloudWatchRole": true,
+    "@aws-cdk/core:enablePartitionLiterals": true,
+    "@aws-cdk/aws-events:eventsTargetQueueSameAccount": true,
+    "@aws-cdk/aws-ecs:disableExplicitDeploymentControllerForCircuitBreaker": true,
+    "@aws-cdk/aws-iam:importedRoleStackSafeDefaultPolicyName": true,
+    "@aws-cdk/aws-s3:serverAccessLogsUseBucketPolicy": true,
+    "@aws-cdk/aws-route53-patters:useCertificate": true,
+    "@aws-cdk/customresources:installLatestAwsSdkDefault": false,
+    "@aws-cdk/aws-rds:databaseProxyUniqueResourceName": true,
+    "@aws-cdk/aws-codedeploy:removeAlarmsFromDeploymentGroup": true,
+    "@aws-cdk/aws-apigateway:authorizerChangeDeploymentLogicalId": true,
+    "@aws-cdk/aws-ec2:launchTemplateDefaultUserData": true,
+    "@aws-cdk/aws-secretsmanager:useAttachedSecretResourcePolicyForSecretTargetAttachments": true,
+    "@aws-cdk/aws-redshift:columnId": true,
+    "@aws-cdk/aws-stepfunctions-tasks:enableEmrServicePolicyV2": true,
+    "@aws-cdk/aws-ec2:restrictDefaultSecurityGroup": true,
+    "@aws-cdk/aws-apigateway:requestValidatorUniqueId": true,
+    "@aws-cdk/aws-kms:aliasNameRef": true,
+    "@aws-cdk/aws-autoscaling:generateLaunchTemplateInsteadOfLaunchConfig": true,
+    "@aws-cdk/core:includePrefixInUniqueNameGeneration": true,
+    "@aws-cdk/aws-efs:denyAnonymousAccess": true,
+    "@aws-cdk/aws-opensearchservice:enableOpensearchMultiAzWithStandby": true,
+    "@aws-cdk/aws-lambda-nodejs:useLatestRuntimeVersion": true,
+    "@aws-cdk/aws-efs:mountTargetOrderInsensitiveLogicalId": true,
+    "@aws-cdk/aws-rds:auroraClusterChangeScopeOfInstanceParameterGroupWithEachParameters": true,
+    "@aws-cdk/aws-appsync:useArnForSourceApiAssociationIdentifier": true,
+    "@aws-cdk/aws-rds:preventRenderingDeprecatedCredentials": true,
+    "@aws-cdk/aws-codepipeline-actions:useNewDefaultBranchForCodeCommitSource": true,
+    "@aws-cdk/aws-cloudwatch-actions:changeLambdaPermissionLogicalIdForLambdaAction": true,
+    "@aws-cdk/aws-codepipeline:crossAccountKeysDefaultValueToFalse": true,
+    "@aws-cdk/aws-codepipeline:defaultPipelineTypeToV2": true,
+    "@aws-cdk/aws-kms:reduceCrossAccountRegionPolicyScope": true,
+    "@aws-cdk/aws-eks:nodegroupNameAttribute": true,
+    "@aws-cdk/aws-ec2:ebsDefaultGp3Volume": true,
+    "@aws-cdk/aws-ecs:removeDefaultDeploymentAlarm": true,
+    "@aws-cdk/custom-resources:logApiResponseDataPropertyTrueDefault": false
+  }
+}