@ykdz/template 0.0.21 → 0.0.23

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();
+}

package/node_modules/@ykdz/template-builtin-source/templates/vike-app/web/scripts/container-entrypoint.sh

@@ -0,0 +1,52 @@
+#!/bin/sh
+set -eu
+
+database_file=${DATABASE_FILE:-/data/app.sqlite}
+container_capability=${CONTAINER_CAPABILITY:-prepare-and-start}
+prepare_database_command=${PREPARE_DATABASE_COMMAND:-/usr/local/bin/prepare-database}
+case "$database_file" in
+  /*) ;;
+  *)
+    echo "DATABASE_FILE must be an absolute path: $database_file" >&2
+    exit 64
+    ;;
+esac
+
+prepare_database() {
+  "$prepare_database_command" "$database_file"
+}
+
+if [ "$container_capability" = "start-only" ]; then
+  case "${1:-}" in
+    start-only)
+      exec node /app/dist/server/index.mjs
+      ;;
+    prepare-only | prepare-and-start)
+      echo "Container capability 'start-only' does not support '${1}'." >&2
+      exit 64
+      ;;
+    *)
+      echo "Unsupported container command '${1:-}'. Expected start-only." >&2
+      exit 64
+      ;;
+  esac
+fi
+
+if [ "$container_capability" != "prepare-and-start" ]; then
+  echo "Unsupported CONTAINER_CAPABILITY '$container_capability'." >&2
+  exit 64
+fi
+
+case "${1:-}" in
+  prepare-only)
+    prepare_database
+    ;;
+  prepare-and-start)
+    prepare_database
+    exec node /app/dist/server/index.mjs
+    ;;
+  *)
+    echo "Unsupported container command '${1:-}'. Expected prepare-only or prepare-and-start." >&2
+    exit 64
+    ;;
+esac

package/node_modules/@ykdz/template-builtin-source/templates/vike-app/web/scripts/prepare-database.sh

@@ -0,0 +1,6 @@
+#!/bin/sh
+set -eu
+
+database_file=$1
+mkdir -p "$(dirname "$database_file")"
+DATABASE_FILE="$database_file" pnpm --dir /repo/packages/db run db:prepare:deploy

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

@@ -1,5 +1,38 @@
 import { spawn } from "node:child_process";
+import { mkdir, rm } from "node:fs/promises";
 import { createServer } from "node:net";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const databaseFile = fileURLToPath(
+  new URL("../node_modules/.tmp/e2e.sqlite", import.meta.url),
+);
+const externalBaseUrlName = "PLAYWRIGHT_EXTERNAL_BASE_URL";
+const externalReadinessTimeoutMs = 30_000;
+
+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();
+}
 
 async function availablePort(): Promise<string> {
   return await new Promise((resolve, reject) => {
@@ -29,34 +62,90 @@ async function availablePort(): Promise<string> {
   });
 }
 
-async function playwrightEnv(): Promise<NodeJS.ProcessEnv> {
+async function awaitExternalService(baseUrl: string): Promise<void> {
+  const deadline = Date.now() + externalReadinessTimeoutMs;
+
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(baseUrl, {
+        signal: AbortSignal.timeout(2_000),
+      });
+      if (response.ok) {
+        return;
+      }
+    } catch {
+      // The externally managed service may still be starting.
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+
+  throw new Error(
+    `External Playwright service at ${baseUrl} was not ready within ${externalReadinessTimeoutMs}ms`,
+  );
+}
+
+async function localPlaywrightEnv(): Promise<NodeJS.ProcessEnv> {
   return {
     ...process.env,
+    DATABASE_FILE: process.env.DATABASE_FILE ?? databaseFile,
     PLAYWRIGHT_WEB_PORT:
       process.env.PLAYWRIGHT_WEB_PORT ?? (await availablePort()),
   };
 }
 
-const env = await playwrightEnv();
+const externalServiceUrl = externalBaseUrl();
+const env = externalServiceUrl
+  ? { ...process.env }
+  : await localPlaywrightEnv();
+const localDatabaseFile = externalServiceUrl ? undefined : env.DATABASE_FILE;
 delete env.NO_COLOR;
 
+if (externalServiceUrl) {
+  await awaitExternalService(externalServiceUrl);
+} else {
+  await mkdir(path.dirname(localDatabaseFile!), { recursive: true });
+  await rm(localDatabaseFile!, { force: true });
+}
+
 const command = process.platform === "win32" ? "playwright.cmd" : "playwright";
 const child = spawn(command, ["test", ...process.argv.slice(2)], {
   env,
   stdio: "inherit",
 });
 
-child.once("error", (error: Error) => {
-  console.error(error);
-  process.exitCode = 1;
-});
+const forwardedSignals = ["SIGINT", "SIGTERM"] as const;
+const forwardSignal = (signal: NodeJS.Signals): void => {
+  child.kill(signal);
+};
+for (const signal of forwardedSignals) {
+  process.once(signal, forwardSignal);
+}
 
-child.once("exit", (code: number | null, signal: NodeJS.Signals | null) => {
-  if (signal) {
-    console.error(`Playwright exited with signal ${signal}`);
+try {
+  const result = await new Promise<{
+    code: number | null;
+    signal: NodeJS.Signals | null;
+  }>((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code, signal) => resolve({ code, signal }));
+  });
+
+  if (result.signal) {
+    console.error(`Playwright exited with signal ${result.signal}`);
     process.exitCode = 1;
-    return;
+  } else {
+    process.exitCode = result.code ?? 1;
+  }
+} catch (error) {
+  console.error(error);
+  process.exitCode = 1;
+} finally {
+  for (const signal of forwardedSignals) {
+    process.removeListener(signal, forwardSignal);
   }
 
-  process.exitCode = code ?? 1;
-});
+  if (localDatabaseFile) {
+    await rm(localDatabaseFile, { force: true });
+  }
+}

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

@@ -1,25 +1,36 @@
+// @template-anchor db-package-import
 import vike from "@vikejs/hono";
 import { Hono } from "hono";
 import { Telefunc } from "telefunc/node";
 
-// @template-anchor db-package-import
 import { api } from "#/server/api";
 
 const telefunc = new Telefunc();
 
-export const app = new Hono();
+export function createApp() {
+  try {
+    assertDatabaseReady(createDatabase());
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+
+  const app = new Hono();
+
+  app.route("/api", api);
 
-app.route("/api", api);
+  app.all("/_telefunc", async (c) => {
+    const response = await telefunc.serve({
+      request: c.req.raw,
+      context: {
+        db: createDatabase(),
+      },
+    });
 
-app.all("/_telefunc", async (c) => {
-  const response = await telefunc.serve({
-    request: c.req.raw,
-    context: {
-      db: createDatabase(),
-    },
+    return response ?? c.notFound();
   });
 
-  return response ?? c.notFound();
-});
+  vike(app);
 
-vike(app);
+  return app;
+}