feat: docker-compose support

.github/workflows/reusable.run-tests.yml

@@ -86,35 +86,53 @@ jobs:
         # does not interpret backslashes in Windows paths as escape sequences.
         run: bun "$GITHUB_WORKSPACE/bati-cli/dist/index.js" --knip ${{ inputs.flags }} "$RUNNER_TEMP/${{ inputs.destination }}"
 
+      # Every matrix keeps the generated app pristine and hosts all e2e
+      # artefacts in a sibling `<destination>.e2e/` workspace. TEST_DIR is
+      # where Link tests-utils, Link tests files, Prepare Bati tests, lint
+      # and test all run.
+      - name: Resolve test working dir
+        shell: bash
+        run: |
+          mkdir -p "$RUNNER_TEMP/${{ inputs.destination }}.e2e"
+          echo "TEST_DIR=$RUNNER_TEMP/${{ inputs.destination }}.e2e" >> "$GITHUB_ENV"
+
       - name: Link tests-utils
         shell: bash
         run: cp -s "$GITHUB_WORKSPACE/bati-tests-utils/"* .
-        working-directory: ${{ runner.temp }}/${{ inputs.destination }}
+        working-directory: ${{ env.TEST_DIR }}
 
       - name: Link tests files
         shell: bash
         run: cp -s "$GITHUB_WORKSPACE/bati-tests-files/"* .
-        working-directory: ${{ runner.temp }}/${{ inputs.destination }}
+        working-directory: ${{ env.TEST_DIR }}
 
       - name: Prepare Bati tests
         shell: bash
         run:
           bun "$GITHUB_WORKSPACE/bati-tests/prepare.js" --test-files='${{ inputs.test-files }}' ${{
           inputs.flags }}
-        working-directory: ${{ runner.temp }}/${{ inputs.destination }}
+        working-directory: ${{ env.TEST_DIR }}
 
-      - name: Install dependencies
+      - name: Install dependencies (app)
         shell: bash
         run: bun install
         working-directory: ${{ runner.temp }}/${{ inputs.destination }}
 
+      - name: Install dependencies (e2e workspace)
+        shell: bash
+        run: bun install
+        working-directory: ${{ env.TEST_DIR }}
+
       - name: Generate types
         if: contains(inputs.flags, '--cloudflare')
         shell: bash
         run: bun run generate-types
         working-directory: ${{ runner.temp }}/${{ inputs.destination }}
 
+      # For dokploy the build happens inside `docker compose up --build` during
+      # the test step; a separate local build would duplicate the work.
       - name: Run build
+        if: "!contains(inputs.flags, '--dokploy')"
         shell: bash
         run: bun run build
         working-directory: ${{ runner.temp }}/${{ inputs.destination }}
@@ -123,32 +141,35 @@ jobs:
         shell: bash
         # Bun hangs on Windows
         run: ${{ runner.os == 'Windows' && 'npm run test' || 'bun run test' }}
-        working-directory: ${{ runner.temp }}/${{ inputs.destination }}
+        working-directory: ${{ env.TEST_DIR }}
 
+      # Lint / typecheck / knip scripts live on the .e2e/ workspace and proxy
+      # to the sibling app via `cd ../<app>`. They run for every matrix that
+      # selected the corresponding flag — including --dokploy.
       - name: Run lint:eslint
         if: contains(inputs.flags, '--eslint')
         shell: bash
         run: bun run lint:eslint
-        working-directory: ${{ runner.temp }}/${{ inputs.destination }}
+        working-directory: ${{ env.TEST_DIR }}
 
       - name: Run lint:biome
         if: contains(inputs.flags, '--biome')
         shell: bash
         run: bun run lint:biome
-        working-directory: ${{ runner.temp }}/${{ inputs.destination }}
+        working-directory: ${{ env.TEST_DIR }}
 
       - name: Run lint:oxlint
         if: contains(inputs.flags, '--oxlint')
         shell: bash
         run: bun run lint:oxlint
-        working-directory: ${{ runner.temp }}/${{ inputs.destination }}
+        working-directory: ${{ env.TEST_DIR }}
 
       - name: Run typecheck
         shell: bash
         run: bun run typecheck
-        working-directory: ${{ runner.temp }}/${{ inputs.destination }}
+        working-directory: ${{ env.TEST_DIR }}
 
       - name: Run knip
         shell: bash
         run: bun run knip
-        working-directory: ${{ runner.temp }}/${{ inputs.destination }}
+        working-directory: ${{ env.TEST_DIR }}

boilerplates/aws/files/$package.json.ts

@@ -3,29 +3,33 @@ import { loadPackageJson, type TransformerProps } from "@batijs/core";
 export default async function getPackageJson(props: TransformerProps): Promise<unknown> {
   const packageJson = await loadPackageJson(props, await import("../package.json").then((x) => x.default));
 
-  return packageJson
-    .setScript("test", {
-      value: "vitest",
-      precedence: 0,
-    })
-    .setScript("deploy:cdk-deploy-all", {
-      value: "cdk deploy --all",
-      precedence: 0,
-    })
-    .setScript("deploy:aws", {
-      value: "run-s build deploy:cdk-deploy-all",
-      precedence: 0,
-    })
-    .setScript("cdk:app", {
-      value: "tsx cdk/bin/infrastructure.ts",
-      precedence: 0,
-    })
-    .setScript("cdk", {
-      value: "cdk",
-      precedence: 0,
-    })
-    .addDependencies(["aws-cdk-lib", "constructs", "source-map-support"])
-    .addDevDependencies(["cdk", "aws-cdk", "@types/node", "@types/which", "typescript", "esbuild", "vitest", "which"])
-    .addDevDependencies(["npm-run-all2"], ["deploy:aws"])
-    .addDevDependencies(["tsx"], ["cdk:app"]);
+  return (
+    packageJson
+      .setScript("test", {
+        value: "vitest",
+        precedence: 0,
+      })
+      .setScript("deploy:cdk-deploy-all", {
+        value: "cdk deploy --all",
+        precedence: 0,
+      })
+      .setScript("deploy:aws", {
+        value: "run-s build deploy:cdk-deploy-all",
+        precedence: 0,
+      })
+      .setScript("cdk:app", {
+        value: "tsx cdk/bin/infrastructure.ts",
+        precedence: 0,
+      })
+      .setScript("cdk", {
+        value: "cdk",
+        precedence: 0,
+      })
+      // CDK (infra-as-code) and source-map-support are only loaded by the `cdk/` deploy
+      // scripts — never by the app at runtime, and CDK esbuild-bundles the lambda anyway.
+      .addDevDependencies(["aws-cdk-lib", "constructs", "source-map-support"])
+      .addDevDependencies(["cdk", "aws-cdk", "@types/node", "@types/which", "typescript", "esbuild", "vitest", "which"])
+      .addDevDependencies(["npm-run-all2"], ["deploy:aws"])
+      .addDevDependencies(["tsx"], ["cdk:app"])
+  );
 }

boilerplates/docker-compose/bati.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "@batijs/core/config";
+
+export default defineConfig({
+  if(meta) {
+    return meta.BATI.has("dokploy");
+  },
+  enforce: "post",
+});

boilerplates/docker-compose/files/$.dockerignore.ts

@@ -0,0 +1,20 @@
+import type { TransformerProps } from "@batijs/core";
+
+export default async function getDockerignore(props: TransformerProps): Promise<string> {
+  const lines = ["node_modules", ".git", "dist", ".env", ".env.*", "!.env.example", "*.log", ".DS_Store"];
+
+  // The e2e plumbing lives in the sibling `<app>.e2e/` workspace and must never reach
+  // the image — but only the test suite ever scaffolds those files. A normal user has
+  // none of them, so excluding them outside of tests would just be dead, confusing noise.
+  if (props.meta.BATI_TEST) {
+    lines.push(
+      "# e2e plumbing (lives in the sibling `<app>.e2e/` workspace, never the image)",
+      "batijs-tests-utils-*.tgz",
+      "bati.config.json",
+      "vitest.config.ts",
+      "*.spec.ts",
+    );
+  }
+
+  return `${lines.join("\n")}\n`;
+}

boilerplates/docker-compose/files/$Dockerfile.ts

@@ -0,0 +1,100 @@
+import { dockerfile, dockerPackageManager, packageManager, type TransformerProps } from "@batijs/core";
+
+export default async function getDockerfile(props: TransformerProps): Promise<string> {
+  const { meta } = props;
+  let pm = packageManager();
+
+  // better-sqlite3 has no Bun prebuild yet (oven-sh/bun#4290) — build it with node.
+  const deps = Object.keys({ ...props.packageJson.dependencies, ...props.packageJson.devDependencies });
+  if (pm.name === "bun" && deps.includes("better-sqlite3")) {
+    pm = { name: "npm", run: "npm run", exec: "npx" };
+  }
+
+  const nodeCli = pm.name === "bun" ? "bun" : "node";
+  const run = pm.run;
+  // e2e apps carry no per-app lockfile (only a workspace one Docker can't see), so
+  // they install loosely; real users install against their committed lockfile.
+  const config = dockerPackageManager(pm.name, { frozenLockfile: !meta.BATI_TEST });
+
+  // Commands run at container startup, before the server, when a database needs
+  // migrating — plus the source files each migration script must find in the runner.
+  const startupMigrations: string[] = [];
+  const migrationCopies: { sources: string[]; dest: string; from: string }[] = [];
+  if (meta.BATI.has("sqlite")) {
+    startupMigrations.push(`${run} sqlite:migrate`);
+    migrationCopies.push({ sources: ["/app/database/sqlite"], dest: "./database/sqlite", from: "builder" });
+  }
+  if (meta.BATI.has("drizzle")) {
+    startupMigrations.push(`${run} drizzle:migrate`);
+    migrationCopies.push({ sources: ["/app/database/migrations"], dest: "./database/migrations", from: "deps-dev" });
+    migrationCopies.push({ sources: ["/app/drizzle.config.ts"], dest: "./drizzle.config.ts", from: "builder" });
+  }
+  if (meta.BATI.has("kysely")) {
+    startupMigrations.push(`${nodeCli} ./dist/server/migrate.mjs`);
+    migrationCopies.push({
+      sources: ["/app/database/kysely/migrations"],
+      dest: "./dist/server/migrations",
+      from: "builder",
+    });
+  }
+
+  // Run migrations before the server when present; otherwise launch it directly.
+  const startCmd =
+    startupMigrations.length > 0
+      ? ["sh", "-c", [...startupMigrations, `${nodeCli} ./dist/server/index.mjs`].join(" && ")]
+      : [nodeCli, "./dist/server/index.mjs"];
+
+  // Files that participate in dependency installation.
+  const installSources = ["package.json", ...config.lockfiles];
+
+  const df = dockerfile()
+    // ── deps-dev: all dependencies (devDeps + deps) for build & migrations ───
+    .from(config.image, { as: "deps-dev", comment: "install all dependencies (devDeps + deps) for build & migrations" })
+    .workdir("/app")
+    .when(config.corepack, (b) => b.run("corepack enable"))
+    .copy(["."], ".")
+    .run(config.install)
+    .when(meta.BATI.has("drizzle"), (b) =>
+      b.env({ DATABASE_URL: "/app/database/sqlite.db" }).run(`${run} drizzle:generate`),
+    )
+
+    // ── deps-prod: production dependencies only ──────────────────────────────
+    .from(config.image, { as: "deps-prod", comment: "install production-only dependencies for the runtime image" })
+    .workdir("/app")
+    .when(config.corepack, (b) => b.run("corepack enable"))
+    .copy(installSources, "./")
+    .run(config.installProd)
+
+    // ── builder: build the application using deps-dev ────────────────────────
+    .from(config.image, { as: "builder", comment: "build the application" })
+    .workdir("/app")
+    .when(config.corepack, (b) => b.run("corepack enable"))
+    .copy(["/app/node_modules"], "./node_modules", { from: "deps-dev" })
+    .copy(["."], ".")
+    .run(`${run} build`)
+
+    // ── runner: production runtime image ─────────────────────────────────────
+    .from(config.image, { as: "runner", comment: "production runtime image" })
+    .workdir("/app")
+    .env({ NODE_ENV: "production", PORT: "3000" })
+    // Runtime env mirrors docker-compose.yml: every var compose injects gets a default
+    // here so the image runs on its own. Secrets stay empty — compose overrides them.
+    .when(!meta.BATI.hasD1 && meta.BATI.hasDatabase, (b) =>
+      b.env({ DATABASE_URL: "/app/database/sqlite.db" }, { comment: "non-D1 database" }),
+    )
+    .when(meta.BATI.has("auth0"), (b) =>
+      b.env({ AUTH0_CLIENT_ID: "", AUTH0_CLIENT_SECRET: "", AUTH0_ISSUER_BASE_URL: "" }, { comment: "auth0" }),
+    )
+    .when(meta.BATI.has("sentry"), (b) => b.env({ SENTRY_DSN: "" }, { comment: "sentry" }))
+    .when(config.corepack, (b) => b.run("corepack enable"))
+    .copy(installSources, "./")
+    .copy(["/app/node_modules"], "./node_modules", { from: "deps-prod" })
+    .copy(["/app/dist"], "./dist", { from: "builder" })
+    .pipe((b) => {
+      for (const { sources, dest, from } of migrationCopies) b.copy(sources, dest, { from });
+    })
+    .expose(3000)
+    .cmd(startCmd);
+
+  return `${df.build()}\n`;
+}

boilerplates/docker-compose/files/docker-compose.yml

@@ -0,0 +1,28 @@
+services:
+  app:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    ports:
+      - "${PORT:-3000}:3000"
+    environment:
+      - NODE_ENV=production
+      - PORT=3000
+      # !BATI.hasD1 && BATI.hasDatabase
+      - DATABASE_URL=${DATABASE_URL:-/app/data/db.sqlite}
+      # BATI.has("auth0")
+      - AUTH0_CLIENT_ID=${AUTH0_CLIENT_ID}
+      # BATI.has("auth0")
+      - AUTH0_CLIENT_SECRET=${AUTH0_CLIENT_SECRET}
+      # BATI.has("auth0")
+      - AUTH0_ISSUER_BASE_URL=${AUTH0_ISSUER_BASE_URL}
+      # BATI.has("sentry")
+      - SENTRY_DSN=${SENTRY_DSN}
+    # BATI.hasDatabase
+    volumes:
+      - sqlite_data:/app/data
+    restart: unless-stopped
+
+# BATI.hasDatabase
+volumes:
+  sqlite_data:

boilerplates/docker-compose/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@batijs/docker-compose",
+  "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:*",
+    "@batijs/core": "workspace:",
+    "@types/node": "^20.19.37"
+  },
+  "nx": {
+    "tags": [
+      "type:boilerplate"
+    ]
+  },
+  "files": [
+    "dist/"
+  ]
+}

boilerplates/docker-compose/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": ["../tsconfig.base.json"]
+}

boilerplates/dokploy/bati.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from "@batijs/core/config";
+
+export default defineConfig({
+  if(meta) {
+    return meta.BATI.has("dokploy");
+  },
+  nextSteps(_meta, _packageManager, { bold }) {
+    return [
+      {
+        type: "text",
+        step: `${bold("dokploy")}: Check ${bold("TODO.md")} for remaining steps.`,
+      },
+    ];
+  },
+  enforce: "post",
+});

boilerplates/dokploy/files/$TODO.md.ts

@@ -0,0 +1,29 @@
+import { loadMarkdown, type TransformerProps } from "@batijs/core";
+
+export default async function getTodo(props: TransformerProps): Promise<unknown> {
+  const content = await loadMarkdown(props);
+
+  //language=Markdown
+  const todo = `
+## Dokploy
+
+1. **Push your repository** to a Git provider (GitHub, GitLab, Bitbucket, etc.)
+
+2. **Install Dokploy** on your VPS if you haven't already:
+   \`\`\`sh
+   curl -sSL https://dokploy.com/install.sh | sudo sh
+   \`\`\`
+
+3. **Open Dokploy** at \`http://<your-server-ip>:3000\` and complete the initial setup.
+
+4. **Create a new application** in the Dokploy dashboard and connect it to your repository.
+
+5. **Deploy** — Dokploy will use the \`docker-compose.yml\` at the root of your repository to build and start your application.
+
+See also: https://docs.dokploy.com
+`;
+
+  content.addMarkdownFeature(todo, "dokploy");
+
+  return content;
+}