@ykdz/template 0.0.33 → 0.0.36

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

@@ -1,6 +1,18 @@
+import { execFileSync } from "node:child_process";
+import { rmSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { createServer } from "node:net";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
 import { defineConfig, devices } from "@playwright/test";
 
 const externalBaseUrlName = "PLAYWRIGHT_EXTERNAL_BASE_URL";
+const externalReadinessTimeoutMs = 30_000;
+const webRoot = path.dirname(fileURLToPath(import.meta.url));
+const migrationsRoot = path.resolve(webRoot, "../../packages/db-migrations");
+const databaseFile = path.join(webRoot, "node_modules/.tmp/e2e.sqlite");
+const stateFile = path.join(webRoot, "node_modules/.tmp/playwright-port");
 
 function externalBaseUrl(): string | undefined {
   if (!Object.hasOwn(process.env, externalBaseUrlName)) {
@@ -26,31 +38,98 @@ function externalBaseUrl(): string | undefined {
   return url.toString();
 }
 
-function requiredPort(name: string): number {
-  return Number(requiredEnv(name));
+async function availablePort(): Promise<string> {
+  return await new Promise((resolve, reject) => {
+    const server = createServer();
+
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+
+      if (typeof address !== "object" || address === null) {
+        server.close(() => {
+          reject(new Error("Could not allocate a Playwright web port"));
+        });
+        return;
+      }
+
+      const port = String(address.port);
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+
+        resolve(port);
+      });
+    });
+  });
 }
 
-function requiredEnv(name: string): string {
-  const value = process.env[name];
+async function awaitExternalService(baseUrl: string): Promise<void> {
+  const deadline = Date.now() + externalReadinessTimeoutMs;
 
-  if (!value) {
-    throw new Error(`${name} must be set by scripts/run-playwright.ts`);
+  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));
   }
 
-  return value;
+  throw new Error(
+    `External Playwright service at ${baseUrl} was not ready within ${externalReadinessTimeoutMs}ms`,
+  );
+}
+
+async function sharedPort(envName: string): Promise<{
+  readonly port: string;
+  readonly prepared: boolean;
+}> {
+  const envPort = process.env[envName];
+  if (envPort !== undefined) {
+    return { port: envPort, prepared: false };
+  }
+  try {
+    return { port: await readFile(stateFile, "utf8"), prepared: false };
+  } catch {
+    const port = await availablePort();
+    await mkdir(path.dirname(stateFile), { recursive: true });
+    await writeFile(stateFile, port, "utf8");
+    return { port, prepared: true };
+  }
+}
+
+function prepareLocalDatabase(): void {
+  rmSync(databaseFile, { force: true });
+  execFileSync("pnpm", ["run", "db:push"], {
+    cwd: migrationsRoot,
+    env: { ...process.env, DATABASE_FILE: databaseFile },
+    stdio: "inherit",
+  });
 }
 
 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("'", "'\\''")}'`;
+let previewUrl: string;
+
+if (externalServiceUrl === undefined) {
+  const { port, prepared } = await sharedPort("PLAYWRIGHT_WEB_PORT");
+  previewUrl = `http://127.0.0.1:${port}`;
+  process.env.DATABASE_FILE = databaseFile;
+  process.env.PORT = port;
+  if (prepared) {
+    prepareLocalDatabase();
+  }
+} else {
+  previewUrl = externalServiceUrl;
+  await awaitExternalService(externalServiceUrl);
 }
 
 export default defineConfig({
@@ -61,16 +140,17 @@ export default defineConfig({
     trace: "retain-on-failure",
   },
   reporter: [["list"], ["html"]],
-  ...(externalServiceUrl
-    ? {}
-    : {
+  globalTeardown: "./test/playwright-teardown.ts",
+  ...(externalServiceUrl === undefined
+    ? {
         webServer: {
-          command: `DATABASE_FILE=${shellValue(databaseFile!)} pnpm --dir ../../packages/db-migrations run db:prepare:test && PORT=${previewPort} node dist/server/index.mjs`,
+          command: "node dist/server/index.mjs",
           reuseExistingServer: !process.env.CI,
           timeout: 60_000,
           url: previewUrl,
         },
-      }),
+      }
+    : {}),
   projects: [
     {
       name: "chromium",

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

@@ -0,0 +1,12 @@
+import { rmSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const webRoot = path.dirname(fileURLToPath(import.meta.url));
+
+export default function teardown(): void {
+  rmSync(path.join(webRoot, "node_modules/.tmp/e2e.sqlite"), { force: true });
+  rmSync(path.join(webRoot, "node_modules/.tmp/playwright-port"), {
+    force: true,
+  });
+}

package/node_modules/@ykdz/template-builtin-presets/templates/vike-app/web/vite.config.ts

@@ -1,12 +1,50 @@
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
 import tailwindcss from "@tailwindcss/vite";
 import vue from "@vitejs/plugin-vue";
 import telefunc from "telefunc/vite";
 import vike from "vike/plugin";
 import { defineConfig, type PluginOption } from "vite";
 
+const webRoot = path.dirname(fileURLToPath(import.meta.url));
+const migrationsRoot = path.resolve(webRoot, "../../packages/db-migrations");
+const databaseRoot = path.resolve(webRoot, "../../packages/db");
+const databaseFile = path.join(webRoot, "data/app.sqlite");
+
 // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- telefunc/vite currently types its plugin factory as any.
 const telefuncPlugin = telefunc() as PluginOption;
 
+async function prepareDatabase(): Promise<void> {
+  const env = { ...process.env, DATABASE_FILE: databaseFile };
+  process.env.DATABASE_FILE = databaseFile;
+  execFileSync("pnpm", ["run", "db:push"], {
+    cwd: migrationsRoot,
+    env,
+    stdio: "inherit",
+  });
+  execFileSync("pnpm", ["run", "db:seed:example"], {
+    cwd: databaseRoot,
+    env,
+    stdio: "inherit",
+  });
+}
+
+function databasePreparationPlugin(): PluginOption {
+  return {
+    name: "database-preparation",
+    configureServer: () => prepareDatabase(),
+    configurePreviewServer: () => prepareDatabase(),
+  };
+}
+
 export default defineConfig({
-  plugins: [vike(), telefuncPlugin, vue(), tailwindcss()],
+  plugins: [
+    vike(),
+    telefuncPlugin,
+    vue(),
+    tailwindcss(),
+    databasePreparationPlugin(),
+  ],
 });

package/node_modules/@ykdz/template-builtin-presets/templates/vue-app/playwright.config.ts

@@ -1,16 +1,57 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { createServer } from "node:net";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
 import { defineConfig, devices } from "@playwright/test";
 
-function requiredPort(name: string): number {
-  const value = process.env[name];
+const webRoot = path.dirname(fileURLToPath(import.meta.url));
+const stateFile = path.join(webRoot, "node_modules/.tmp/playwright-port");
 
-  if (!value) {
-    throw new Error(`${name} must be set by scripts/run-playwright.ts`);
-  }
+async function availablePort(): Promise<string> {
+  return await new Promise((resolve, reject) => {
+    const server = createServer();
+
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+
+      if (typeof address !== "object" || address === null) {
+        server.close(() => {
+          reject(new Error("Could not allocate a Playwright web port"));
+        });
+        return;
+      }
+
+      const port = String(address.port);
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
 
-  return Number(value);
+        resolve(port);
+      });
+    });
+  });
+}
+
+async function sharedPort(envName: string): Promise<string> {
+  const envPort = process.env[envName];
+  if (envPort !== undefined) {
+    return envPort;
+  }
+  try {
+    return await readFile(stateFile, "utf8");
+  } catch {
+    const port = await availablePort();
+    await mkdir(path.dirname(stateFile), { recursive: true });
+    await writeFile(stateFile, port, "utf8");
+    return port;
+  }
 }
 
-const previewPort = requiredPort("PLAYWRIGHT_WEB_PORT");
+const previewPort = await sharedPort("PLAYWRIGHT_WEB_PORT");
 const previewUrl = `http://127.0.0.1:${previewPort}`;
 
 export default defineConfig({

package/node_modules/@ykdz/template-builtin-presets/templates/vue-hono-app/web/playwright.config.ts

@@ -1,17 +1,68 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { createServer } from "node:net";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
 import { defineConfig, devices } from "@playwright/test";
 
-function requiredPort(name: string): number {
-  const value = process.env[name];
+const webRoot = path.dirname(fileURLToPath(import.meta.url));
+const stateFile = path.join(webRoot, "node_modules/.tmp/playwright-ports");
 
-  if (!value) {
-    throw new Error(`${name} must be set by scripts/run-playwright.ts`);
-  }
+async function availablePort(): Promise<string> {
+  return await new Promise((resolve, reject) => {
+    const server = createServer();
+
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+
+      if (typeof address !== "object" || address === null) {
+        server.close(() => {
+          reject(new Error("Could not allocate a Playwright web port"));
+        });
+        return;
+      }
+
+      const port = String(address.port);
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
 
-  return Number(value);
+        resolve(port);
+      });
+    });
+  });
+}
+
+async function sharedPorts(): Promise<{
+  readonly api: string;
+  readonly web: string;
+}> {
+  const envApi = process.env.PLAYWRIGHT_API_PORT;
+  const envWeb = process.env.PLAYWRIGHT_WEB_PORT;
+  if (envApi !== undefined && envWeb !== undefined) {
+    return { api: envApi, web: envWeb };
+  }
+  try {
+    const parsed = JSON.parse(await readFile(stateFile, "utf8")) as {
+      readonly api: string;
+      readonly web: string;
+    };
+    return parsed;
+  } catch {
+    const ports = {
+      api: envApi ?? (await availablePort()),
+      web: envWeb ?? (await availablePort()),
+    };
+    await mkdir(path.dirname(stateFile), { recursive: true });
+    await writeFile(stateFile, JSON.stringify(ports), "utf8");
+    return ports;
+  }
 }
 
-const apiPort = requiredPort("PLAYWRIGHT_API_PORT");
-const webPort = requiredPort("PLAYWRIGHT_WEB_PORT");
+const { api: apiPort, web: webPort } = await sharedPorts();
 const apiBaseUrl = `http://127.0.0.1:${apiPort}`;
 const apiHealthUrl = `${apiBaseUrl}/api/health`;
 const webBaseUrl = `http://127.0.0.1:${webPort}`;

package/node_modules/@ykdz/template-core/dist/module-graph.d.ts

@@ -11,70 +11,39 @@ export type PlaywrightBrowserAssetsEnvironmentNeed = {
     readonly kind: "playwright-browser-assets";
     readonly browser: "chromium";
     readonly owner: ComponentOwner;
-    readonly nextStep: {
-        readonly id: string;
-        readonly label: string;
-        readonly command: string;
-        readonly args: readonly string[];
-        readonly display: string;
-        readonly machineVerifiable: boolean;
-    };
 };
 export type ShellCheckEnvironmentNeed = {
     readonly kind: "shellcheck-command";
     readonly owner: ComponentOwner;
-    readonly nextStep: {
-        readonly id: "install-shellcheck";
-        readonly label: "Install ShellCheck";
-        readonly command: "sudo";
-        readonly args: readonly string[];
-        readonly display: "sudo apt-get update && sudo apt-get install -y shellcheck";
-        readonly machineVerifiable: false;
-    };
 };
 /** Rust task leaves require the maintained toolchain in local and CI plans. */
 export type RustToolchainEnvironmentNeed = {
     readonly kind: "rust-toolchain";
     readonly owner: ComponentOwner;
     readonly toolchain: "stable";
-    readonly nextStep: {
-        readonly id: "install-rust-toolchain";
-        readonly label: "Install Rust toolchain";
-        readonly command: "rustup";
-        readonly args: readonly string[];
-        readonly display: "rustup toolchain install stable --component rustfmt --component clippy";
-        readonly machineVerifiable: boolean;
-    };
 };
 /**
  * Docker is needed only by the focused deployment mode. It is deliberately
- * outside ordinary Check Environment Needs, whose preparation and next steps
- * apply to every generated-check scenario.
+ * outside ordinary Check Environment Needs, which apply to every
+ * generated-check scenario.
  */
 export type DockerEngineEnvironmentNeed = {
     readonly kind: "docker-engine";
-    readonly preparation: {
-        readonly id: "verify-docker-engine";
-        readonly label: "Verify Docker engine";
-        readonly command: "docker";
-        readonly args: readonly ["version", "--format", "{{.Server.Version}}"];
-        readonly display: "docker version --format {{.Server.Version}}";
-        readonly machineVerifiable: true;
-    };
 };
 export type CheckEnvironmentNeed = PlaywrightBrowserAssetsEnvironmentNeed | ShellCheckEnvironmentNeed | RustToolchainEnvironmentNeed;
 export type DeploymentEnvironmentNeed = DockerEngineEnvironmentNeed;
-/**
- * The durable form of a Check Environment Need. It deliberately retains only
- * the explicit preparation fact, never a task name or package execution list.
- */
-export type CheckEnvironmentNeedFact = Pick<PlaywrightBrowserAssetsEnvironmentNeed, "kind" | "browser" | "owner"> | Pick<ShellCheckEnvironmentNeed, "kind" | "owner"> | Pick<RustToolchainEnvironmentNeed, "kind" | "owner" | "toolchain">;
-/** Deployment preparation is likewise durable without selecting an executing package. */
-export type DeploymentEnvironmentNeedFact = Pick<DockerEngineEnvironmentNeed, "kind">;
-export declare function checkEnvironmentNeedFact(need: CheckEnvironmentNeed): CheckEnvironmentNeedFact;
-export declare function checkEnvironmentNeedFromFact(fact: CheckEnvironmentNeedFact): CheckEnvironmentNeed;
-export declare function deploymentEnvironmentNeedFact(need: DeploymentEnvironmentNeed): DeploymentEnvironmentNeedFact;
-export declare function deploymentEnvironmentNeedFromFact(fact: DeploymentEnvironmentNeedFact): DeploymentEnvironmentNeed;
+export type EnvironmentNeedsMetadata = {
+    readonly schemaVersion: 1;
+    readonly check: readonly CheckEnvironmentNeed[];
+    readonly deployment: readonly DeploymentEnvironmentNeed[];
+};
+/** Validates, deduplicates, and canonically orders durable Environment Needs. */
+export declare function normalizeEnvironmentNeeds(options: {
+    readonly check: readonly CheckEnvironmentNeed[];
+    readonly deployment: readonly DeploymentEnvironmentNeed[];
+}): EnvironmentNeedsMetadata;
+/** Strict codec for Local Template Metadata consumed by Package Addition. */
+export declare function parseEnvironmentNeedsMetadata(value: unknown): EnvironmentNeedsMetadata;
 export declare function rustToolchainEnvironmentNeed(owner: ComponentOwner): RustToolchainEnvironmentNeed;
 export declare function dockerEngineEnvironmentNeed(): DockerEngineEnvironmentNeed;
 export declare const qualityTaskVocabulary: readonly ["boundaries", "format:check", "lint", "typecheck", "build", "test", "test:e2e"];
@@ -83,18 +52,11 @@ export declare function renderTurboRunCommand(taskNames: readonly string[], args
     readonly continueAfterFailure?: boolean;
     readonly taskPrefix?: boolean;
 }): string;
-export declare function renderRootCheckCommand(): string;
+export declare function renderRootCheckCommand(additionalTasks?: readonly string[]): string;
 export declare function renderDeploymentCheckCommand(): string;
 export declare function renderFixCommand(): string;
-export declare function renderPlaywrightBrowserInstallCommand(need: CheckEnvironmentNeed, options?: {
-    readonly withDeps?: boolean;
-}): string;
-export declare function playwrightBrowserAssetsNextStepDescriptor(owner: ComponentOwner): Pick<CheckEnvironmentNeed["nextStep"], "id" | "label">;
 export declare function playwrightBrowserAssetsEnvironmentNeed(options: {
     readonly browser: "chromium";
     readonly owner: ComponentOwner;
-    readonly id?: string;
-    readonly label?: string;
-    readonly machineVerifiable?: boolean;
 }): PlaywrightBrowserAssetsEnvironmentNeed;
 export declare function shellCheckEnvironmentNeed(owner: ComponentOwner): ShellCheckEnvironmentNeed;