@batijs/cli 0.0.260 → 0.0.261

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
+  }
+}

package/dist/boilerplates/@batijs/aws/files/tests/aws_handler.spec.ts

@@ -0,0 +1,116 @@
+import { beforeAll, describe, expect, it } from "vitest";
+
+import { execSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import path from "node:path";
+import * as which from "which";
+
+const bunExists = which.sync("bun", { nothrow: true }) !== null;
+const npmCli = bunExists ? "bun" : "pnpm";
+
+console.log("RUN TESTS ***");
+
+describe("AWSHandler", () => {
+  beforeAll(
+    async () => {
+      if (existsSync(path.join(process.cwd(), "cdk.out"))) {
+        rmSync(path.join(process.cwd(), "cdk.out"), { recursive: true });
+      }
+      /*
+       * `--build "${npmCli} run build"` is required to build the project before synth
+       */
+      const synthCommand = `${npmCli} run cdk --json --build "${npmCli} run build" synth`;
+      execSync(synthCommand, {
+        encoding: "utf8",
+        maxBuffer: 50 * 1024 * 1024,
+        env: {
+          BUN_LOCKFILE: "../../bun.lockb", // This is to make sure that the correct lockfile is used in a bun project
+          PATH: process.env.PATH,
+        },
+      });
+    },
+    2 * 60 * 1000,
+  );
+
+  it("should request a page from the AWS handler", async () => {
+    const cdkOutPath = path.join(process.cwd(), "cdk.out");
+    const templateFilePath = readdirSync(cdkOutPath).find(
+      (file) => file.startsWith("VikeStack-") && file.endsWith(".template.json"),
+    );
+    const templateFullPath = path.join(cdkOutPath, templateFilePath!);
+    expect(existsSync(templateFullPath)).toBe(true);
+    const cloudfrontTemplateJson = readFileSync(templateFullPath, "utf8");
+    const requestHandlerFolder = extractRequestHandlerPath(
+      JSON.parse(cloudfrontTemplateJson),
+      "/RequestHandler/Resource",
+    );
+    const requestHandlerPath = path.join(process.cwd(), "cdk.out", requestHandlerFolder!, "index.mjs");
+    expect(existsSync(requestHandlerPath)).toBe(true);
+
+    const { handler } = await import(requestHandlerPath);
+    const event = {
+      version: "2.0",
+      routeKey: "$default",
+      rawPath: "/",
+      rawQueryString: "",
+      headers: {
+        accept: "*/*",
+        "content-length": "0",
+        host: "example.com",
+        "user-agent": "PostmanRuntime/7.26.8",
+        "x-amzn-trace-id": "Root=1-5f84c7a9-0e5b1e1e1e1e1e1e1e1e1e1e",
+        "x-forwarded-for": "127.0.0.1",
+        "x-forwarded-port": "443",
+        "x-forwarded-proto": "https",
+      },
+      requestContext: {
+        accountId: "123456789012",
+        apiId: "api-id",
+        domainName: "example.com",
+        domainPrefix: "example",
+        http: {
+          method: "GET",
+          path: "/",
+          protocol: "HTTP/1.1",
+          sourceIp: "127.0.0.1",
+          userAgent: "PostmanRuntime/7.26.8",
+        },
+        requestId: "id",
+        routeKey: "$default",
+        stage: "$default",
+        time: "12/Mar/2021:19:03:58 +0000",
+        timeEpoch: 1615578238000,
+      },
+      isBase64Encoded: false,
+    };
+    const response = await handler(event, {});
+    expect(response.statusCode).toBe(200);
+    const body = response.isBase64Encoded ? Buffer.from(response.body, "base64").toString("utf8") : response.body;
+    expect(body).toContain("My Vike App");
+  });
+});
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type JsonData = Record<string, any>;
+
+function extractRequestHandlerPath(jsonData: JsonData, targetCdkPath: string): string | null {
+  let assetPath: string | null = null;
+
+  function traverse(obj: JsonData) {
+    if (typeof obj !== "object" || obj === null) return;
+
+    if (obj?.["aws:cdk:path"]?.endsWith(targetCdkPath)) {
+      assetPath = obj?.["aws:asset:path"];
+      return;
+    }
+
+    for (const key in obj) {
+      if (obj?.[key]) {
+        traverse(obj[key]);
+      }
+    }
+  }
+
+  traverse(jsonData);
+  return assetPath;
+}

package/dist/boilerplates/@batijs/aws/files/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["tests/**/*.spec.ts"], // Adjust the pattern as needed
+    watch: false,
+  },
+});

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

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import "source-map-support/register";
+import * as cdk from "aws-cdk-lib";
+import * as certificatemanager from "aws-cdk-lib/aws-certificatemanager";
+import * as route53 from "aws-cdk-lib/aws-route53";
+export type CustomStackProps = cdk.StackProps & {
+    domainName?: string;
+    subDomain?: string;
+    certificate?: string | certificatemanager.ICertificate;
+    hostedZone?: route53.IHostedZone;
+};

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

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import "source-map-support/register";
+import { Construct } from "constructs";
+import * as cdk from "aws-cdk-lib";
+import type { CustomStackProps } from "../bin/infrastructure";
+type VikeStackProps = cdk.StackProps & {
+    customStackProps: CustomStackProps;
+};
+export declare class VikeStack extends cdk.Stack {
+    readonly distributionUrlParameterName: string;
+    constructor(scope: Construct, id: string, props: VikeStackProps);
+}
+export {};

package/dist/boilerplates/@batijs/aws/types/tests/aws_handler.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/boilerplates/@batijs/aws/types/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

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

@@ -58,6 +58,10 @@ var require_package = __commonJS({
         "@hattip/core": "^0.0.47",
         "@hattip/router": "^0.0.47",
         "@hattip/vite": "^0.0.47",
+        "@hattip/adapter-aws-lambda": "^0.0.47",
+        "@hattip/static": "^0.0.47",
+        "@hattip/walk": "^0.0.47",
+        "@types/aws-lambda": "^8.10.143",
         "@trpc/server": "^10.45.2",
         "@types/node": "^18.19.14",
         "@universal-middleware/hattip": "^0.2.4",
@@ -82,12 +86,18 @@ var require_package = __commonJS({
       exports: {
         "./hattip-entry": {
           types: "./dist/types/hattip-entry.d.ts"
+        },
+        "./entry_aws_lambda": {
+          types: "./dist/types/entry_aws_lambda.d.ts"
         }
       },
       typesVersions: {
         "*": {
           "hattip-entry": [
             "./dist/types/hattip-entry.d.ts"
+          ],
+          entry_aws_lambda: [
+            "./dist/types/entry_aws_lambda.d.ts"
           ]
         }
       }
@@ -136,7 +146,8 @@ async function getPackageJson(props) {
       "vite",
       "vike",
       "@universal-middleware/hattip",
-      ...props.meta.BATI.has("vercel") ? ["@hattip/adapter-vercel-edge"] : []
+      ...props.meta.BATI.has("vercel") ? ["@hattip/adapter-vercel-edge"] : [],
+      ...props.meta.BATI.has("aws") ? ["@types/aws-lambda", "@hattip/adapter-aws-lambda", "@hattip/static", "@hattip/walk"] : []
     ]
   });
 }

package/dist/boilerplates/@batijs/hattip/files/entry_aws_lambda.ts

@@ -0,0 +1,37 @@
+/*{ @if (it.BATI.has("aws")) }*/
+/*
+entry_aws_lambda.ts
+
+This file is the entry point for AWS Lambda
+
+Notes:
+* The file name must not have any special characters or dots except for the extension. https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#API_CreateFunction_RequestSyntax
+
+*/
+
+import { existsSync } from "node:fs";
+import awsLambdaAdapter from "@hattip/adapter-aws-lambda";
+import { walk } from "@hattip/walk";
+import type { FileInfo } from "@hattip/walk";
+import { createStaticMiddleware } from "@hattip/static";
+import { createFileReader } from "@hattip/static/fs";
+import hattipHandler from "@batijs/hattip/hattip-entry";
+import type { Handler, APIGatewayProxyResultV2, APIGatewayProxyEventV2 } from "aws-lambda";
+
+const root = new URL("./dist/client", import.meta.url);
+const staticRootExists = existsSync(root);
+const files = staticRootExists ? walk(root) : new Map<string, FileInfo>();
+const staticMiddleware = staticRootExists
+  ? createStaticMiddleware(files, createFileReader(root), {
+      urlRoot: "/",
+    })
+  : undefined;
+
+const awsHandler = awsLambdaAdapter((ctx) => {
+  if (hattipHandler === undefined) throw new Error("hattipHandler is undefined");
+  if (staticMiddleware === undefined) return hattipHandler(ctx);
+  return staticMiddleware(ctx) || hattipHandler(ctx);
+});
+
+export const handler: Handler<APIGatewayProxyEventV2, APIGatewayProxyResultV2> = awsHandler;
+/*{ /if }*/

package/dist/boilerplates/@batijs/hattip/types/entry_aws_lambda.d.ts

@@ -0,0 +1,2 @@
+import type { Handler, APIGatewayProxyResultV2, APIGatewayProxyEventV2 } from "aws-lambda";
+export declare const handler: Handler<APIGatewayProxyEventV2, APIGatewayProxyResultV2>;

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

@@ -55,6 +55,7 @@ var require_package = __commonJS({
         "@cloudflare/workers-types": "^4.20240821.1",
         "@hono/node-server": "^1.12.2",
         "@hono/vite-dev-server": "^0.15.1",
+        "@types/aws-lambda": "^8.10.145",
         "@trpc/server": "^10.45.2",
         "@types/node": "^18.19.14",
         "@universal-middleware/hono": "^0.2.5",
@@ -81,6 +82,9 @@ var require_package = __commonJS({
         "./hono-entry": {
           types: "./dist/types/hono-entry.d.ts"
         },
+        "./entry_aws_lambda": {
+          types: "./dist/types/entry_aws_lambda.d.ts"
+        },
         "./hono-entry.node": {
           types: "./dist/types/hono-entry.node.d.ts"
         }
@@ -90,6 +94,9 @@ var require_package = __commonJS({
           "hono-entry": [
             "./dist/types/hono-entry.d.ts"
           ],
+          entry_aws_lambda: [
+            "./dist/types/entry_aws_lambda.d.ts"
+          ],
           "hono-entry.node": [
             "./dist/types/hono-entry.node.d.ts"
           ]
@@ -120,7 +127,7 @@ async function getPackageJson(props) {
     }
   });
   return addDependency(packageJson, await Promise.resolve().then(() => __toESM(require_package(), 1)).then((x) => x.default), {
-    devDependencies: ["@hono/vite-dev-server", "@types/node"],
+    devDependencies: ["@hono/vite-dev-server", "@types/node", "@types/aws-lambda"],
     dependencies: [
       "@hono/node-server",
       "@universal-middleware/hono",

package/dist/boilerplates/@batijs/hono/files/entry_aws_lambda.ts

@@ -0,0 +1,37 @@
+/*{ @if (it.BATI.has("aws")) }*/
+/*
+entry_aws_lambda.ts
+
+This file is the entry point for AWS Lambda
+
+Notes:
+* The file name must not have any special characters or dots except for the extension. https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunction.html#API_CreateFunction_RequestSyntax
+
+*/
+
+import { Hono } from "hono";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { handle } from "hono/aws-lambda";
+import type { LambdaEvent, LambdaContext } from "hono/aws-lambda";
+import app from "@batijs/hono/hono-entry"; // file is provided by hono
+import type { Handler, APIGatewayProxyResult } from "aws-lambda";
+
+type Bindings = {
+  event: LambdaEvent;
+  lambdaContext: LambdaContext;
+};
+
+const lambdaApp = new Hono<{ Bindings: Bindings }>();
+
+lambdaApp.use(
+  "/*",
+  serveStatic({
+    root: `./dist/client/`,
+  }),
+);
+
+lambdaApp.route("/", app!);
+const awsHandler = handle(lambdaApp);
+
+export const handler: Handler<LambdaEvent, APIGatewayProxyResult> = awsHandler;
+/*{ /if }*/

package/dist/boilerplates/@batijs/hono/types/entry_aws_lambda.d.ts

@@ -0,0 +1,3 @@
+import type { LambdaEvent } from "hono/aws-lambda";
+import type { Handler, APIGatewayProxyResult } from "aws-lambda";
+export declare const handler: Handler<LambdaEvent, APIGatewayProxyResult>;

package/dist/boilerplates/boilerplates.json

@@ -26,6 +26,17 @@
       "files"
     ]
   },
+  {
+    "config": {
+      "if": {
+        "flag": "aws"
+      }
+    },
+    "folder": "@batijs/aws",
+    "subfolders": [
+      "files"
+    ]
+  },
   {
     "config": {
       "if": {

package/dist/index.js

@@ -1677,7 +1677,7 @@ var createDefaultQueryTester = function(query, options) {
 // package.json
 var package_default = {
   name: "@batijs/cli",
-  version: "0.0.260",
+  version: "0.0.261",
   type: "module",
   scripts: {
     "check-types": "tsc --noEmit",
@@ -1760,6 +1760,10 @@ Choose one of them, or simply remove selected Server`
   [RulesMessage.ERROR_LUCIA_R_COMPAT_DATABASE]: error(
     `${inverse(bold("Lucia"))} requires a ${inverse(bold("Database"))}, and is only compatible with ${inverse(bold("SQLite"))} or ${inverse(bold("Drizzle"))}`
   ),
+  [RulesMessage.ERROR_AWS_R_COMPAT_SERVER]: error(
+    `${inverse(bold("AWS"))} is only compatible with ${inverse(bold("Hono"))} or ${inverse(bold("HatTip"))}.
+Choose one of them, or simply remove selected Server`
+  ),
   [RulesMessage.INFO_DRIZZLE_STACKBLITZ]: null
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@batijs/cli",
-  "version": "0.0.260",
+  "version": "0.0.261",
   "type": "module",
   "keywords": [],
   "description": "Next-gen scaffolder. Get started with fully-functional apps, and choose any tool you want",
@@ -20,12 +20,12 @@
     "typescript": "^5.5.4",
     "unplugin-purge-polyfills": "^0.0.5",
     "vite": "^5.4.2",
-    "@batijs/build": "0.0.260",
-    "@batijs/compile": "0.0.260"
+    "@batijs/compile": "0.0.261",
+    "@batijs/build": "0.0.261"
   },
   "dependencies": {
-    "@batijs/features": "0.0.260",
-    "@batijs/core": "0.0.260"
+    "@batijs/core": "0.0.261",
+    "@batijs/features": "0.0.261"
   },
   "bin": "./dist/index.js",
   "exports": {