@ykdz/template 0.0.22 → 0.0.23

package/node_modules/@ykdz/template-builtin-source/package.json

@@ -65,7 +65,6 @@
   "dependencies": {
     "@ykdz/template-core": "workspace:*",
     "@ykdz/template-shared": "workspace:*",
-    "typescript": "catalog:",
     "valibot": "catalog:"
   },
   "devDependencies": {
@@ -73,6 +72,7 @@
     "@playwright/test": "catalog:",
     "@tailwindcss/vite": "catalog:",
     "@types/node": "catalog:",
+    "@typescript/native": "catalog:",
     "@vikejs/hono": "catalog:",
     "@vitejs/plugin-vue": "catalog:",
     "drizzle-kit": "catalog:",

package/node_modules/@ykdz/template-builtin-source/templates/preset-source.json

@@ -223,6 +223,7 @@
         "oxfmt",
         "oxlint",
         "oxlint-tsgolint",
+        "srvx",
         "tailwindcss",
         "telefunc",
         "typescript",
@@ -263,6 +264,9 @@
                   "web/pages/index/+Page.telefunc.ts",
                   "web/pages/tailwind.css",
                   "web/playwright.config.ts",
+                  "web/scripts/check-standalone-deployment.ts",
+                  "web/scripts/container-entrypoint.sh",
+                  "web/scripts/prepare-database.sh",
                   "web/scripts/run-playwright.ts",
                   "web/turbo.json",
                   "web/server/api.ts",
@@ -311,6 +315,9 @@
           "vike-app/web/Dockerfile",
           "vike-app/web/Dockerfile.dockerignore",
           "vike-app/web/playwright.config.ts",
+          "vike-app/web/scripts/check-standalone-deployment.ts",
+          "vike-app/web/scripts/container-entrypoint.sh",
+          "vike-app/web/scripts/prepare-database.sh",
           "vike-app/web/vite.config.ts",
           "vike-app/web/turbo.json",
           "vike-app/web/vitest.config.ts"

package/node_modules/@ykdz/template-builtin-source/templates/vike-app/.github/workflows/check.yml

@@ -15,14 +15,8 @@ jobs:
         with:
           node-version-file: package.json
       - run: corepack enable
+      - uses: docker/setup-buildx-action@v3
       - run: pnpm install
       - run: pnpm --filter ./apps/web exec playwright install --with-deps chromium
       - run: pnpm run check
-
-  docker-image:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v7
-      - uses: docker/setup-buildx-action@v3
-      - run: docker buildx build --load --file apps/web/Dockerfile --target runtime --tag vike-app:check .
-      - run: docker buildx build --load --file apps/web/Dockerfile --target database-preparation --tag vike-app-db-prepare:check .
+      - run: pnpm run check:deployment

package/node_modules/@ykdz/template-builtin-source/templates/vike-app/web/Dockerfile

@@ -1,7 +1,10 @@
 # syntax=docker/dockerfile:1.7
 
+ARG DEPLOYMENT_BUILD_ID="local"
+
 FROM node:{{NODE_VERSION}}-bookworm-slim AS base
 ARG PACKAGE_MANAGER_PIN="{{PACKAGE_MANAGER_PIN}}"
+ENV COREPACK_HOME="/corepack"
 ENV PNPM_HOME="/pnpm"
 ENV PATH="$PNPM_HOME:$PATH"
 WORKDIR /repo
@@ -25,6 +28,21 @@ COPY --from=pruner /repo/out/json/ ./
 RUN pnpm install --offline --frozen-lockfile
 COPY --from=pruner /repo/out/full/ ./
 RUN pnpm --filter ./apps/web run build:run
+RUN pnpm --filter ./apps/web deploy --prod --legacy /runtime-deploy \
+  && rm -rf /runtime-deploy/node_modules/@*/db \
+  && find /runtime-deploy/node_modules/.pnpm -mindepth 1 -maxdepth 1 -type d -name '*@file+packages+db' -exec rm -rf '{}' +
+
+FROM node:{{NODE_VERSION}}-bookworm-slim AS application-runtime
+ENV NODE_ENV="production"
+WORKDIR /app
+RUN groupadd --system --gid 1001 nodejs \
+  && useradd --system --uid 1001 --gid nodejs --home-dir /app --shell /usr/sbin/nologin app \
+  && install -d -o app -g nodejs /app /data
+COPY --from=build --chown=app:nodejs /runtime-deploy/node_modules ./node_modules
+COPY --from=build --chown=app:nodejs /repo/apps/web/dist ./dist
+COPY --chmod=755 --from=build /repo/apps/web/scripts/container-entrypoint.sh /usr/local/bin/container-entrypoint
+ENV DATABASE_FILE="/data/app.sqlite"
+USER app
 
 FROM base AS database-preparation
 ENV NODE_ENV="production"
@@ -32,16 +50,34 @@ COPY --from=pruner /repo/out/json/pnpm-lock.yaml ./pnpm-lock.yaml
 COPY --from=pruner /repo/out/json/pnpm-workspace.yaml ./pnpm-workspace.yaml
 RUN pnpm fetch
 COPY --from=pruner /repo/out/json/ ./
-RUN pnpm install --offline --frozen-lockfile
+RUN pnpm install --offline --frozen-lockfile --prod=false
 COPY --from=pruner /repo/out/full/ ./
-CMD ["pnpm", "--dir", "packages/db", "run", "db:prepare:deploy"]
-
-FROM node:{{NODE_VERSION}}-bookworm-slim AS runtime
-ENV NODE_ENV="production"
-WORKDIR /app
 RUN groupadd --system --gid 1001 nodejs \
-  && useradd --system --uid 1001 --gid nodejs --home-dir /app --shell /usr/sbin/nologin app
-COPY --from=build --chown=app:nodejs /repo/apps/web/dist ./dist
+  && useradd --system --uid 1001 --gid nodejs --home-dir /app --shell /usr/sbin/nologin app \
+  && install -d -o app -g nodejs /app /data
+COPY --chmod=755 --from=pruner /repo/out/full/apps/web/scripts/container-entrypoint.sh /usr/local/bin/container-entrypoint
+COPY --chmod=755 --from=pruner /repo/out/full/apps/web/scripts/prepare-database.sh /usr/local/bin/prepare-database
+ENV DATABASE_FILE="/data/app.sqlite"
 USER app
+
+# Final deployment target: standalone
+# One-container deployments prepare the database before startup.
+FROM database-preparation AS standalone
+ARG DEPLOYMENT_BUILD_ID
+LABEL org.opencontainers.image.version="$DEPLOYMENT_BUILD_ID"
+WORKDIR /app
+COPY --from=application-runtime --chown=app:nodejs /app/node_modules ./node_modules
+COPY --from=application-runtime --chown=app:nodejs /app/dist ./dist
+EXPOSE 3000
+ENTRYPOINT ["/usr/local/bin/container-entrypoint"]
+CMD ["prepare-and-start"]
+
+# Final deployment target: runtime
+# Start-only image for databases prepared by a matching standalone image.
+FROM application-runtime AS runtime
+ARG DEPLOYMENT_BUILD_ID
+LABEL org.opencontainers.image.version="$DEPLOYMENT_BUILD_ID"
+ENV CONTAINER_CAPABILITY="start-only"
 EXPOSE 3000
-CMD ["node", "dist/server/index.mjs"]
+ENTRYPOINT ["/usr/local/bin/container-entrypoint"]
+CMD ["start-only"]

package/node_modules/@ykdz/template-builtin-source/templates/vike-app/web/pages/index/+Page.telefunc.ts

@@ -1,6 +1,5 @@
-import { getContext } from "telefunc";
-
 // @template-anchor db-package-import
+import { getContext } from "telefunc";
 
 export type Todo = Awaited<ReturnType<typeof onLoadTodos>>[number];
 

package/node_modules/@ykdz/template-builtin-source/templates/vike-app/web/playwright.config.ts

@@ -1,5 +1,31 @@
 import { defineConfig, devices } from "@playwright/test";
 
+const externalBaseUrlName = "PLAYWRIGHT_EXTERNAL_BASE_URL";
+
+function externalBaseUrl(): string | undefined {
+  if (!Object.hasOwn(process.env, externalBaseUrlName)) {
+    return undefined;
+  }
+
+  const value = process.env[externalBaseUrlName]?.trim();
+  if (!value) {
+    throw new Error(`${externalBaseUrlName} must be a non-empty HTTP(S) URL`);
+  }
+
+  let url: URL;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`${externalBaseUrlName} must be a valid HTTP(S) URL`);
+  }
+
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`${externalBaseUrlName} must use HTTP or HTTPS`);
+  }
+
+  return url.toString();
+}
+
 function requiredPort(name: string): number {
   return Number(requiredEnv(name));
 }
@@ -14,9 +40,14 @@ function requiredEnv(name: string): string {
   return value;
 }
 
-const previewPort = requiredPort("PLAYWRIGHT_WEB_PORT");
-const previewUrl = `http://127.0.0.1:${previewPort}`;
-const databaseFile = requiredEnv("DATABASE_FILE");
+const externalServiceUrl = externalBaseUrl();
+const previewPort = externalServiceUrl
+  ? undefined
+  : requiredPort("PLAYWRIGHT_WEB_PORT");
+const previewUrl = externalServiceUrl ?? `http://127.0.0.1:${previewPort}`;
+const databaseFile = externalServiceUrl
+  ? undefined
+  : requiredEnv("DATABASE_FILE");
 
 function shellValue(value: string): string {
   return `'${value.replaceAll("'", "'\\''")}'`;
@@ -27,13 +58,18 @@ export default defineConfig({
   timeout: 60_000,
   use: {
     baseURL: previewUrl,
-    trace: "on-first-retry",
-  },
-  webServer: {
-    command: `DATABASE_FILE=${shellValue(databaseFile)} pnpm --dir ../../packages/db run db:prepare:test && PORT=${previewPort} node dist/server/index.mjs`,
-    reuseExistingServer: !process.env.CI,
-    url: previewUrl,
+    trace: "retain-on-failure",
   },
+  ...(externalServiceUrl
+    ? {}
+    : {
+        webServer: {
+          command: `DATABASE_FILE=${shellValue(databaseFile!)} pnpm --dir ../../packages/db run db:prepare:test && PORT=${previewPort} node dist/server/index.mjs`,
+          reuseExistingServer: !process.env.CI,
+          timeout: 60_000,
+          url: previewUrl,
+        },
+      }),
   projects: [
     {
       name: "chromium",

package/node_modules/@ykdz/template-builtin-source/templates/vike-app/web/scripts/check-standalone-deployment.ts

@@ -0,0 +1,449 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+
+const webRoot = path.resolve(import.meta.dirname, "..");
+const repositoryRoot = path.resolve(webRoot, "../..");
+const uniqueId = `${process.pid}-${Date.now()}`;
+const standaloneImage = `vike-deployment-check-standalone:${uniqueId}`;
+const runtimeImage = `vike-deployment-check-runtime:${uniqueId}`;
+const containers = {
+  standalone: `vike-deployment-check-standalone-${uniqueId}`,
+  preparation: `vike-deployment-check-preparation-${uniqueId}`,
+  runtime: `vike-deployment-check-runtime-${uniqueId}`,
+  unprepared: `vike-deployment-check-unprepared-${uniqueId}`,
+} as const;
+const volumes = {
+  standalone: `vike-deployment-check-standalone-${uniqueId}`,
+  prepared: `vike-deployment-check-prepared-${uniqueId}`,
+  unprepared: `vike-deployment-check-unprepared-${uniqueId}`,
+} as const;
+const abortController = new AbortController();
+const forwardedSignals = ["SIGINT", "SIGTERM"] as const;
+const signalHandlers = new Map<NodeJS.Signals, () => void>();
+const defaultReadinessTimeoutMs = 60_000;
+
+interface CommandResult {
+  readonly stderr: string;
+  readonly stdout: string;
+}
+
+interface CommandOptions {
+  readonly cwd?: string;
+  readonly env?: NodeJS.ProcessEnv;
+  readonly signal?: AbortSignal;
+  readonly timeout: number;
+}
+
+type DeploymentMode =
+  | "standalone"
+  | "external-preparation"
+  | "runtime"
+  | "fresh-runtime";
+
+async function deploymentPhase<T>(
+  mode: DeploymentMode,
+  phase: string,
+  operation: () => Promise<T>,
+): Promise<T> {
+  try {
+    return await operation();
+  } catch (error: unknown) {
+    throw new Error(`Deployment mode ${mode} failed during ${phase}.`, {
+      cause: error,
+    });
+  }
+}
+
+function commandDisplay(command: string, args: readonly string[]): string {
+  return [command, ...args].map((part) => JSON.stringify(part)).join(" ");
+}
+
+function runCommand(
+  command: string,
+  args: readonly string[],
+  options: CommandOptions,
+): Promise<CommandResult> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      signal: options.signal,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stderr = "";
+    let stdout = "";
+    let timedOut = false;
+    let settled = false;
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk: string) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk: string) => {
+      stderr += chunk;
+    });
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, options.timeout);
+    const finish = (error?: Error): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      if (error === undefined) {
+        resolve({ stderr, stdout });
+      } else {
+        reject(Object.assign(error, { stderr, stdout }));
+      }
+    };
+    child.once("error", (error) => finish(error));
+    child.once("close", (code, signal) => {
+      if (code === 0 && !timedOut) {
+        finish();
+        return;
+      }
+      finish(
+        Object.assign(
+          new Error(
+            `${commandDisplay(command, args)} ${
+              timedOut
+                ? `timed out after ${options.timeout}ms`
+                : `exited with code ${String(code)}${signal === null ? "" : ` from ${signal}`}`
+            }\nstdout:\n${stdout}\nstderr:\n${stderr}`,
+          ),
+          { code, signal },
+        ),
+      );
+    });
+  });
+}
+
+function readinessTimeoutMs(): number {
+  const configured = process.env.STANDALONE_DEPLOYMENT_READINESS_TIMEOUT_MS;
+  if (configured === undefined) {
+    return defaultReadinessTimeoutMs;
+  }
+
+  const timeout = Number(configured);
+  if (!Number.isSafeInteger(timeout) || timeout <= 0) {
+    throw new Error(
+      "STANDALONE_DEPLOYMENT_READINESS_TIMEOUT_MS must be a positive integer",
+    );
+  }
+  return timeout;
+}
+
+async function dockerWithTimeout(
+  timeout: number,
+  ...args: string[]
+): Promise<string> {
+  const { stdout } = await runCommand("docker", args, {
+    cwd: repositoryRoot,
+    signal: abortController.signal,
+    timeout,
+  });
+  return stdout.trim();
+}
+
+async function docker(...args: string[]): Promise<string> {
+  return dockerWithTimeout(600_000, ...args);
+}
+
+async function cleanup(): Promise<void> {
+  const cleanupCommands = [
+    ...Object.values(containers).map((name) => ["rm", "--force", name]),
+    ...Object.values(volumes).map((name) => ["volume", "rm", "--force", name]),
+    ["image", "rm", "--force", runtimeImage],
+    ["image", "rm", "--force", standaloneImage],
+  ];
+
+  for (const args of cleanupCommands) {
+    try {
+      await runCommand("docker", args, {
+        cwd: repositoryRoot,
+        timeout: 30_000,
+      });
+    } catch {
+      // A resource may not have been created yet.
+    }
+  }
+}
+
+async function containerLogs(container: string): Promise<string> {
+  try {
+    const { stderr, stdout } = await runCommand("docker", ["logs", container], {
+      cwd: repositoryRoot,
+      signal: AbortSignal.timeout(10_000),
+      timeout: 10_000,
+    });
+    return [stdout.trim(), stderr.trim()].filter(Boolean).join("\n");
+  } catch (error) {
+    return `Container logs unavailable: ${String(error)}`;
+  }
+}
+
+async function deploymentLogs(): Promise<string> {
+  const logs = await Promise.all(
+    Object.entries(containers).map(
+      async ([phase, container]) =>
+        `${phase} container logs:\n${await containerLogs(container)}`,
+    ),
+  );
+  return logs.join("\n");
+}
+
+async function publishedBaseUrl(container: string): Promise<string> {
+  const portOutput = await dockerWithTimeout(
+    10_000,
+    "port",
+    container,
+    "3000/tcp",
+  );
+  const match = /:(\d+)$/u.exec(portOutput.split("\n")[0] ?? "");
+  if (!match?.[1]) {
+    throw new Error(
+      `Could not determine the published web port: ${portOutput}`,
+    );
+  }
+  return `http://127.0.0.1:${match[1]}`;
+}
+
+async function waitForReady(
+  phase: "Standalone" | "Runtime",
+  container: string,
+  baseUrl: string,
+): Promise<void> {
+  const timeout = readinessTimeoutMs();
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(baseUrl, {
+        signal: AbortSignal.timeout(2_000),
+      });
+      if (response.ok) {
+        return;
+      }
+    } catch {
+      // The container may still be starting the server.
+    }
+
+    const running = await dockerWithTimeout(
+      5_000,
+      "inspect",
+      "--format={{.State.Running}}",
+      container,
+    );
+    if (running !== "true") {
+      throw new Error(
+        `${phase} container exited before readiness.\n${await containerLogs(container)}`,
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+
+  throw new Error(
+    `${phase} container was not ready within ${timeout}ms.\n${await containerLogs(container)}`,
+  );
+}
+
+async function assertProcessIdentity(
+  phase: "Standalone" | "Runtime",
+  container: string,
+): Promise<void> {
+  await docker(
+    "exec",
+    container,
+    "node",
+    "--input-type=module",
+    "--eval",
+    `import { statSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
+const expectedIdentity = 1001;
+if (process.getuid() !== expectedIdentity || process.getgid() !== expectedIdentity) {
+  throw new Error(\`${phase} process identity must be 1001:1001, received \${process.getuid()}:\${process.getgid()}\`);
+}
+const databaseStat = statSync(process.env.DATABASE_FILE);
+if (databaseStat.uid !== expectedIdentity || databaseStat.gid !== expectedIdentity) {
+  throw new Error(\`Database ownership must be 1001:1001, received \${databaseStat.uid}:\${databaseStat.gid}\`);
+}`,
+  );
+}
+
+async function assertEmptyDatabase(container: string): Promise<void> {
+  await docker(
+    "exec",
+    container,
+    "node",
+    "--input-type=module",
+    "--eval",
+    `import { DatabaseSync } from "node:sqlite";
+const db = new DatabaseSync(process.env.DATABASE_FILE);
+const row = db.prepare("select count(*) as count from todos").get();
+if (row.count !== 0) throw new Error(\`Fresh deployment must contain zero TODOs, received \${row.count}\`);`,
+  );
+}
+
+async function runPlaywright(baseUrl: string): Promise<void> {
+  await runCommand("pnpm", ["--dir", "apps/web", "run", "test:e2e:run"], {
+    cwd: repositoryRoot,
+    env: {
+      ...process.env,
+      PLAYWRIGHT_EXTERNAL_BASE_URL: baseUrl,
+    },
+    signal: abortController.signal,
+    timeout: 120_000,
+  });
+}
+
+async function runStartedDeployment(
+  mode: "standalone" | "runtime",
+  readinessLabel: "Standalone" | "Runtime",
+  container: string,
+  volume: string,
+  image: string,
+): Promise<void> {
+  await deploymentPhase(mode, "start", async () =>
+    docker(
+      "run",
+      "--detach",
+      "--name",
+      container,
+      "--publish",
+      "127.0.0.1::3000",
+      "--volume",
+      `${volume}:/data`,
+      image,
+    ),
+  );
+  const baseUrl = await deploymentPhase(mode, "start", async () =>
+    publishedBaseUrl(container),
+  );
+  await deploymentPhase(mode, "readiness", async () =>
+    waitForReady(readinessLabel, container, baseUrl),
+  );
+  await deploymentPhase(mode, "identity", async () =>
+    assertProcessIdentity(readinessLabel, container),
+  );
+  await deploymentPhase(mode, "empty-database", async () =>
+    assertEmptyDatabase(container),
+  );
+  await deploymentPhase(mode, "playwright", async () => runPlaywright(baseUrl));
+}
+
+async function assertUnpreparedRuntimeFails(): Promise<void> {
+  try {
+    await dockerWithTimeout(
+      30_000,
+      "run",
+      "--name",
+      containers.unprepared,
+      "--volume",
+      `${volumes.unprepared}:/data`,
+      runtimeImage,
+    );
+  } catch (error) {
+    const failure = error as {
+      code?: unknown;
+      stderr?: string;
+      stdout?: string;
+    };
+    const output = `${failure.stdout ?? ""}\n${failure.stderr ?? ""}`;
+    if (typeof failure.code === "number" && failure.code !== 0) {
+      if (!output.includes("Database is not ready")) {
+        throw new Error(
+          `Unprepared runtime did not report database readiness failure.\n${output}\n${await containerLogs(containers.unprepared)}`,
+          { cause: error },
+        );
+      }
+      return;
+    }
+    throw error;
+  }
+
+  throw new Error("Unprepared runtime started successfully");
+}
+
+for (const signal of forwardedSignals) {
+  const handler = (): void => {
+    abortController.abort(new Error(`Received ${signal}`));
+  };
+  signalHandlers.set(signal, handler);
+  process.once(signal, handler);
+}
+
+try {
+  await deploymentPhase("standalone", "build", async () =>
+    docker(
+      "build",
+      "--file",
+      "apps/web/Dockerfile",
+      "--target",
+      "standalone",
+      "--build-arg",
+      `DEPLOYMENT_BUILD_ID=${uniqueId}`,
+      "--tag",
+      standaloneImage,
+      ".",
+    ),
+  );
+  await deploymentPhase("runtime", "build", async () =>
+    docker(
+      "build",
+      "--file",
+      "apps/web/Dockerfile",
+      "--target",
+      "runtime",
+      "--build-arg",
+      `DEPLOYMENT_BUILD_ID=${uniqueId}`,
+      "--tag",
+      runtimeImage,
+      ".",
+    ),
+  );
+  for (const volume of Object.values(volumes)) {
+    await docker("volume", "create", volume);
+  }
+
+  await runStartedDeployment(
+    "standalone",
+    "Standalone",
+    containers.standalone,
+    volumes.standalone,
+    standaloneImage,
+  );
+
+  await deploymentPhase("external-preparation", "prepare", async () =>
+    docker(
+      "run",
+      "--name",
+      containers.preparation,
+      "--volume",
+      `${volumes.prepared}:/data`,
+      standaloneImage,
+      "prepare-only",
+    ),
+  );
+  await runStartedDeployment(
+    "runtime",
+    "Runtime",
+    containers.runtime,
+    volumes.prepared,
+    runtimeImage,
+  );
+
+  await deploymentPhase("fresh-runtime", "rejection", async () =>
+    assertUnpreparedRuntimeFails(),
+  );
+} catch (error) {
+  console.error(error);
+  console.error(await deploymentLogs());
+  process.exitCode = 1;
+} finally {
+  for (const signal of forwardedSignals) {
+    const handler = signalHandlers.get(signal);
+    if (handler) {
+      process.removeListener(signal, handler);
+    }
+  }
+  await cleanup();
+}