@ykdz/template 0.0.41 → 0.1.0-experimental.0

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

@@ -1,553 +0,0 @@
-import { spawn } from "node:child_process";
-import { readFile } from "node:fs/promises";
-const repositoryRoot = process.cwd();
-const applicationPackageName = "{{APPLICATION_PACKAGE_NAME}}";
-const uniqueId = `${process.pid}-${Date.now()}`;
-const standaloneImage = `vike-deployment-check-standalone:${uniqueId}`;
-const runtimeImage = `vike-deployment-check-runtime:${uniqueId}`;
-const network = `vike-deployment-check-${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]),
-    ["network", "rm", network],
-    ["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 dockerHostGatewayAddress(): Promise<string | undefined> {
-  try {
-    const routes = await readFile("/proc/net/route", "utf8");
-    for (const line of routes.split("\n").slice(1)) {
-      const [, destination, gateway] = line.trim().split(/\s+/u);
-      if (
-        destination !== "00000000" ||
-        gateway === undefined ||
-        gateway === "00000000"
-      ) {
-        continue;
-      }
-      const octets = gateway.match(/../gu)?.reverse();
-      if (octets === undefined) return undefined;
-      return octets
-        .map((octet) => String(Number.parseInt(octet, 16)))
-        .join(".");
-    }
-  } catch {
-    // /proc/net/route is Linux-specific. Local Docker-on-host runs still use
-    // the loopback candidate below.
-  }
-  return undefined;
-}
-
-async function publishedBaseUrls(
-  container: string,
-): Promise<readonly 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}`,
-    );
-  }
-  const gateway = await dockerHostGatewayAddress();
-  return [
-    `http://127.0.0.1:${match[1]}`,
-    gateway === undefined ? undefined : `http://${gateway}:${match[1]}`,
-  ].filter((candidate): candidate is string => candidate !== undefined);
-}
-
-async function waitForReady(
-  phase: "Standalone" | "Runtime",
-  container: string,
-  baseUrls: readonly string[],
-): Promise<string> {
-  const timeout = readinessTimeoutMs();
-  const deadline = Date.now() + timeout;
-  while (Date.now() < deadline) {
-    for (const baseUrl of baseUrls) {
-      try {
-        const response = await fetch(baseUrl, {
-          signal: AbortSignal.timeout(2_000),
-        });
-        if (response.ok) {
-          return baseUrl;
-        }
-      } catch {
-        // The container may still be starting the server, or this candidate may
-        // not be reachable from the current Docker execution topology.
-      }
-    }
-
-    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 at ${baseUrls.join(", ")} 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",
-    ["--filter", applicationPackageName, "run", "test:e2e"],
-    {
-      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,
-      "--network",
-      network,
-      "--publish",
-      "0.0.0.0::3000",
-      "--volume",
-      `${volume}:/data`,
-      image,
-    ),
-  );
-  const baseUrls = await deploymentPhase(mode, "start", async () =>
-    publishedBaseUrls(container),
-  );
-  const baseUrl = await deploymentPhase(mode, "readiness", async () =>
-    waitForReady(readinessLabel, container, baseUrls),
-  );
-  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> {
-  await dockerWithTimeout(
-    30_000,
-    "run",
-    "--detach",
-    "--name",
-    containers.unprepared,
-    "--network",
-    network,
-    "--publish",
-    "0.0.0.0::3000",
-    "--volume",
-    `${volumes.unprepared}:/data`,
-    runtimeImage,
-  );
-  const baseUrls = await publishedBaseUrls(containers.unprepared);
-  const deadline = Date.now() + 30_000;
-
-  while (Date.now() < deadline) {
-    const statePromise = dockerWithTimeout(
-      5_000,
-      "inspect",
-      "--format={{.State.Status}}:{{.State.ExitCode}}",
-      containers.unprepared,
-    ).then(
-      (state) => ({ state }),
-      (error: unknown) => ({ error }),
-    );
-    const probes = await Promise.all(
-      baseUrls.map((baseUrl) =>
-        fetch(baseUrl, {
-          signal: AbortSignal.timeout(500),
-        }).then(
-          (response) => ({ baseUrl, response }),
-          () => ({ baseUrl, response: undefined }),
-        ),
-      ),
-    );
-
-    const servedProbe = probes.find((probe) => probe.response !== undefined);
-    if (servedProbe?.response !== undefined) {
-      throw new Error(
-        `Unprepared runtime served HTTP ${servedProbe.response.status} at ${servedProbe.baseUrl} before exiting.`,
-      );
-    }
-
-    const stateResult = await statePromise;
-    if ("error" in stateResult) {
-      throw stateResult.error;
-    }
-    const match =
-      /^(created|running|paused|restarting|removing|exited|dead):(\d+)$/u.exec(
-        stateResult.state,
-      );
-    if (match?.[1] === "exited") {
-      const exitCode = Number(match[2]);
-      const logs = await containerLogs(containers.unprepared);
-      if (exitCode === 0) {
-        throw new Error(
-          `Unprepared runtime exited successfully instead of rejecting startup.\n${logs}`,
-        );
-      }
-      if (!logs.includes("DATABASE_NOT_READY")) {
-        throw new Error(
-          `Unprepared runtime did not report database readiness failure.\n${logs}`,
-        );
-      }
-      return;
-    }
-    if (match === null || match[1] === "dead") {
-      throw new Error(
-        `Unprepared runtime entered unexpected state ${stateResult.state}.`,
-      );
-    }
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-
-  throw new Error("Unprepared runtime did not exit within 30000ms");
-}
-
-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",
-      "Dockerfile",
-      "--target",
-      "standalone",
-      "--build-arg",
-      `DEPLOYMENT_BUILD_ID=${uniqueId}`,
-      "--tag",
-      standaloneImage,
-      ".",
-    ),
-  );
-  await deploymentPhase("runtime", "build", async () =>
-    docker(
-      "build",
-      "--file",
-      "Dockerfile",
-      "--target",
-      "runtime",
-      "--build-arg",
-      `DEPLOYMENT_BUILD_ID=${uniqueId}`,
-      "--tag",
-      runtimeImage,
-      ".",
-    ),
-  );
-  for (const volume of Object.values(volumes)) {
-    await docker("volume", "create", volume);
-  }
-  await docker("network", "create", network);
-
-  await runStartedDeployment(
-    "standalone",
-    "Standalone",
-    containers.standalone,
-    volumes.standalone,
-    standaloneImage,
-  );
-
-  await deploymentPhase("external-preparation", "prepare", async () =>
-    docker(
-      "run",
-      "--name",
-      containers.preparation,
-      "--network",
-      network,
-      "--volume",
-      `${volumes.prepared}:/data`,
-      standaloneImage,
-      "prepare-only",
-    ),
-  );
-  await deploymentPhase("external-preparation", "exit", async () => {
-    const state = await dockerWithTimeout(
-      10_000,
-      "inspect",
-      "--format={{.State.Status}}:{{.State.ExitCode}}",
-      containers.preparation,
-    );
-    if (state !== "exited:0") {
-      throw new Error(
-        `Preparation-only container must exit successfully, received ${state}.\n${await containerLogs(containers.preparation)}`,
-      );
-    }
-  });
-  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-presets/templates/vike-app/web/server/app.ts

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

package/node_modules/@ykdz/template-builtin-presets/templates/vike-app/web/test/e2e/app.spec.ts

@@ -1,18 +0,0 @@
-import { expect, test } from "@playwright/test";
-
-test("renders the Vike home page", async ({ page }) => {
-  const todoTitle = `编写生成项目端到端测试 ${Date.now()}`;
-
-  // Vike can retain background browser requests after its interactive page is
-  // ready; the visible UI assertions below are the actual readiness contract.
-  await page.goto("/", { waitUntil: "domcontentloaded" });
-  await expect(
-    page.getByRole("heading", { name: "全栈 Vike 应用" }),
-  ).toBeVisible();
-  await page.getByRole("button", { name: "计数：0" }).click();
-  await expect(page.getByRole("button", { name: "计数：1" })).toBeVisible();
-
-  await page.getByPlaceholder("添加一条数据库待办").fill(todoTitle);
-  await page.getByRole("button", { name: "添加" }).click();
-  await expect(page.getByText(todoTitle)).toBeVisible();
-});

package/node_modules/@ykdz/template-builtin-presets/templates/vike-app/web/tsconfig.app.json

@@ -1,26 +0,0 @@
-{
-  "extends": [
-    "@vue/tsconfig/tsconfig.dom.json",
-    "{{TYPESCRIPT_CONFIG_PACKAGE}}/base.json"
-  ],
-  "compilerOptions": {
-    "composite": true,
-    "exactOptionalPropertyTypes": false,
-    "module": "esnext",
-    "moduleResolution": "bundler",
-    "rewriteRelativeImportExtensions": false,
-    "skipLibCheck": true,
-    "target": "es2024",
-    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
-    "types": ["node"]
-  },
-  "include": [
-    "+server.ts",
-    "assets/**/*.svg",
-    "components/**/*.vue",
-    "pages/**/*.ts",
-    "pages/**/*.vue",
-    "server/**/*.ts",
-    "types/**/*.d.ts"
-  ]
-}

package/node_modules/@ykdz/template-builtin-presets/templates/vike-app/web/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "files": [],
-  "references": [
-    { "path": "./tsconfig.app.json" },
-    { "path": "./tsconfig.test.json" },
-    { "path": "./tsconfig.node.json" }
-  ]
-}

package/node_modules/@ykdz/template-builtin-presets/templates/vike-app/web/tsconfig.node.json

@@ -1,21 +0,0 @@
-{
-  "extends": "{{TYPESCRIPT_CONFIG_PACKAGE}}/base.json",
-  "compilerOptions": {
-    "composite": true,
-    "erasableSyntaxOnly": true,
-    "lib": ["ESNext", "DOM", "DOM.Iterable"],
-    "module": "esnext",
-    "moduleResolution": "bundler",
-    "rewriteRelativeImportExtensions": true,
-    "skipLibCheck": true,
-    "target": "es2024",
-    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
-    "types": ["node"]
-  },
-  "include": [
-    "playwright.config.ts",
-    "scripts/**/*.ts",
-    "vite.config.ts",
-    "vitest.config.ts"
-  ]
-}

package/node_modules/@ykdz/template-builtin-presets/templates/vike-app/web/tsconfig.test.json

@@ -1,9 +0,0 @@
-{
-  "extends": "./tsconfig.app.json",
-  "compilerOptions": {
-    "lib": ["ESNext", "DOM", "DOM.Iterable"],
-    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.test.tsbuildinfo",
-    "types": ["node", "vitest/globals"]
-  },
-  "include": ["test/**/*.ts", "vitest.config.ts"]
-}

package/node_modules/@ykdz/template-builtin-presets/templates/vike-app/web/turbo.json

@@ -1,9 +0,0 @@
-{
-  "extends": ["//"],
-  "tags": ["app"],
-  "tasks": {
-    "build": {
-      "outputs": ["dist/**"]
-    }
-  }
-}

package/node_modules/@ykdz/template-builtin-presets/templates/vike-app/web/types/global.d.ts

@@ -1,9 +0,0 @@
-// @template-anchor db-package-import
-
-declare global {
-  namespace Telefunc {
-    interface Context {
-      db: Database;
-    }
-  }
-}