@fedify/cli 2.0.0-pr.474.1879 → 2.0.0-pr.479.1900

package/src/init/test/action.ts

@@ -0,0 +1,25 @@
+import { pipe, tap, when } from "@fxts/core";
+import { set } from "../../utils.ts";
+import type { TestInitCommand } from "../command.ts";
+import { fillEmptyOptions } from "./fill.ts";
+import { isDryRun, isHydRun, runTests } from "./run.ts";
+import {
+  emptyTestDir,
+  genRunId,
+  genTestDirPrefix,
+  logTestDir,
+} from "./utils.ts";
+
+const runTestInit = (options: TestInitCommand) =>
+  pipe(
+    options,
+    set("runId", genRunId),
+    set("testDirPrefix", genTestDirPrefix),
+    tap(emptyTestDir),
+    fillEmptyOptions,
+    tap(when(isHydRun, runTests(false))),
+    tap(when(isDryRun, runTests(true))),
+    tap(logTestDir),
+  );
+
+export default runTestInit;

package/src/init/test/create.ts

@@ -0,0 +1,137 @@
+import { filter, isEmpty, pipe, toArray } from "@fxts/core";
+import { values } from "@optique/core";
+import { appendFile, mkdir } from "node:fs/promises";
+import { join, sep } from "node:path";
+import process from "node:process";
+import {
+  CommandError,
+  type GeneratedType,
+  printErrorMessage,
+  printMessage,
+  product,
+  runSubCommand,
+} from "../../utils.ts";
+import packageManagers from "../json/pm.json" with { type: "json" };
+import { kvStores, messageQueues } from "../lib.ts";
+import type {
+  KvStore,
+  MessageQueue,
+  PackageManager,
+  WebFramework,
+} from "../types.ts";
+import webFrameworks from "../webframeworks.ts";
+import type { InitTestData, MultipleOption } from "./types.ts";
+
+const BANNED_PMS: PackageManager[] = ["bun", "yarn"];
+
+const createTestApp = (testDirPrefix: string, dry: boolean) =>
+async (
+  options: GeneratedType<ReturnType<typeof generateTestCases>>,
+): Promise<string> => {
+  const testDir = join(testDirPrefix, ...options);
+  const vals = values(testDir.split(sep).slice(-4));
+  try {
+    const result = await runSubCommand(
+      toArray(genInitCommand(testDir, dry, options)),
+      {
+        cwd: join(import.meta.dirname!, "../../.."),
+        stdio: ["ignore", "pipe", "pipe"],
+      },
+    );
+
+    await saveOutputs(testDir, result);
+    printMessage`  Pass: ${vals}`;
+    return testDir;
+  } catch (error) {
+    if (error instanceof CommandError) {
+      await saveOutputs(testDir, {
+        stdout: error.stdout,
+        stderr: error.stderr,
+      });
+    } else {
+      const errorMessage = error instanceof Error
+        ? error.message
+        : String(error);
+      await saveOutputs(testDir, { stdout: "", stderr: errorMessage });
+    }
+    printMessage`  Fail: ${vals}`;
+    return "";
+  }
+};
+
+export default createTestApp;
+
+function* genInitCommand(
+  testDir: string,
+  dry: boolean,
+  [webFramework, packageManager, kvStore, messageQueue]: //
+    GeneratedType<ReturnType<typeof generateTestCases>>,
+) {
+  yield "deno";
+  yield "run";
+  yield "-A";
+  yield "src/mod.ts";
+  yield "init";
+  yield testDir;
+  yield "-w";
+  yield webFramework;
+  yield "-p";
+  yield packageManager;
+  yield "-k";
+  yield kvStore;
+  yield "-m";
+  yield messageQueue;
+  yield "--test-mode";
+  if (dry) yield "-d";
+}
+
+export const generateTestCases = <T extends Pick<InitTestData, MultipleOption>>(
+  { webFramework, packageManager, kvStore, messageQueue }: T,
+) => {
+  const pms = filterPackageManager(packageManager);
+  exitIfCasesEmpty([webFramework, pms, kvStore, messageQueue]);
+
+  return product(webFramework, pms, kvStore, messageQueue);
+};
+
+const filterPackageManager = (pm: PackageManager[]) =>
+  pipe(
+    pm,
+    filter(
+      (pm) =>
+        BANNED_PMS.includes(pm)
+          ? printErrorMessage`${packageManagers[pm]["label"]} is not \
+supported in test mode yet because ${packageManagers[pm]["label"]} don't \
+support local file dependencies properly.`
+          : true,
+    ),
+    toArray,
+  );
+
+const exitIfCasesEmpty = (cases: string[][]): never | void => {
+  if (cases.some(isEmpty)) {
+    printErrorMessage`No test cases to run. Exiting.`;
+    process.exit(1);
+  }
+};
+
+const saveOutputs = async (
+  dirPath: string,
+  { stdout, stderr }: { stdout: string; stderr: string },
+): Promise<void> => {
+  await mkdir(dirPath, { recursive: true });
+  if (stdout) await appendFile(join(dirPath, "out.txt"), stdout + "\n", "utf8");
+  if (stderr) await appendFile(join(dirPath, "err.txt"), stderr + "\n", "utf8");
+};
+
+export function filterOptions(
+  options: GeneratedType<ReturnType<typeof generateTestCases>>,
+): boolean {
+  const [wf, pm, kv, mq] = options as //
+  [WebFramework, PackageManager, KvStore, MessageQueue];
+  return [
+    webFrameworks[wf].packageManagers,
+    kvStores[kv].packageManagers,
+    messageQueues[mq].packageManagers,
+  ].every((pms) => pms.includes(pm));
+}

package/src/init/test/fill.ts

@@ -0,0 +1,61 @@
+import { isEmpty, pipe } from "@fxts/core";
+import type { TestInitCommand } from "../command.ts";
+import {
+  KV_STORE,
+  MESSAGE_QUEUE,
+  PACKAGE_MANAGER,
+  WEB_FRAMEWORK,
+} from "../const.ts";
+import type {
+  DefineAllOptions,
+  DefineOption,
+  MultipleOption,
+} from "./types.ts";
+
+export const fillEmptyOptions = <T extends TestInitCommand>(
+  options: T,
+): DefineAllOptions<T> =>
+  pipe(
+    options,
+    fillWebFramework,
+    fillPackageManager,
+    fillKVStore,
+    fillMessageQueue,
+    fillRunMode,
+  ) as DefineAllOptions<T>;
+
+const fillOption = <
+  K extends MultipleOption,
+  AllValues = TestInitCommand[K] extends readonly (infer U)[] ? (U & string)[]
+    : never,
+>(
+  key: K,
+  allValues: AllValues,
+) =>
+<T extends TestInitCommand>(
+  options: T,
+): T extends Awaited<DefineOption<T, infer J>> | DefineOption<T, infer J>
+  ? DefineOption<T, J | K>
+  : DefineOption<T, K> =>
+  ({
+    ...options,
+    [key]: (isEmpty(options[key])
+      ? allValues
+      : (options[key].filter((i) =>
+        (allValues as readonly unknown[]).includes(i)
+      ) as T[K])),
+  }) as T extends Awaited<DefineOption<T, infer J>> | DefineOption<T, infer J>
+    ? DefineOption<T, J | K>
+    : DefineOption<T, K>;
+
+const fillWebFramework = fillOption("webFramework", WEB_FRAMEWORK);
+const fillPackageManager = fillOption("packageManager", PACKAGE_MANAGER);
+const fillKVStore = fillOption("kvStore", KV_STORE);
+const fillMessageQueue = fillOption("messageQueue", MESSAGE_QUEUE);
+
+const fillRunMode = <T extends TestInitCommand>(
+  options: DefineAllOptions<T>,
+): DefineAllOptions<T> => ({
+  ...options,
+  ...(options.hydRun || options.dryRun ? {} : { hydRun: true, dryRun: true }),
+});

package/src/init/test/lookup.ts

@@ -0,0 +1,253 @@
+import { values } from "@optique/core";
+import type { ChildProcessByStdio } from "node:child_process";
+import { spawn } from "node:child_process";
+import { createWriteStream } from "node:fs";
+import { join, sep } from "node:path";
+import process from "node:process";
+import type Stream from "node:stream";
+import { printErrorMessage, printMessage, runSubCommand } from "../../utils.ts";
+import { getDevCommand } from "../lib.ts";
+import type {
+  KvStore,
+  MessageQueue,
+  PackageManager,
+  WebFramework,
+} from "../types.ts";
+import webFrameworks from "../webframeworks.ts";
+
+const HANDLE = "john";
+const STARTUP_TIMEOUT = 30000; // 30 seconds
+const CWD = process.cwd();
+const BANNED_WFS: WebFramework[] = ["next"];
+
+/**
+ * Run servers for all generated apps and test them with the lookup command.
+ *
+ * @param dirs - Array of paths to generated app directories
+ */
+export default async function runServerAndReadUser(
+  dirs: string[],
+): Promise<void> {
+  const valid = dirs.filter(Boolean);
+  if (valid.length === 0) {
+    printErrorMessage`\nNo directories to lookup test.`;
+    return;
+  }
+  const filtered = filterWebFrameworks(valid);
+
+  printMessage`\nLookup Test start for ${String(filtered.length)} app(s)!`;
+
+  const results = await Array.fromAsync(filtered, testApp);
+
+  const successCount = results.filter(Boolean).length;
+  const failCount = results.length - successCount;
+
+  printMessage`Lookup Test Results:
+  Total: ${String(results.length)}
+  Passed: ${String(successCount)}
+  Failed: ${String(failCount)}\n\n`;
+}
+
+function filterWebFrameworks(
+  dirs: string[],
+): string[] {
+  const wfs = new Set<WebFramework>(
+    dirs.map((dir) => dir.split(sep).slice(-4, -3)[0] as WebFramework),
+  );
+  const hasBanned = BANNED_WFS.filter((wf) => wfs.has(wf));
+  if (!hasBanned) {
+    return dirs;
+  }
+  const bannedLabels = hasBanned.map((wf) => webFrameworks[wf]["label"]);
+  printErrorMessage`\n${
+    values(bannedLabels)
+  } is not supported in test mode yet.`;
+  return dirs.filter((dir) =>
+    !BANNED_WFS.includes(dir.split(sep).slice(-4, -3)[0] as WebFramework)
+  );
+}
+
+/**
+ * Run the dev server and test with lookup command.
+ */
+async function testApp(dir: string): Promise<boolean> {
+  const [wf, pm, kv, mq] = dir.split(sep).slice(-4) as //
+  [WebFramework, PackageManager, KvStore, MessageQueue];
+
+  printMessage`  Testing ${values([wf, pm, kv, mq])}...`;
+
+  const result = await serverClosure(
+    dir,
+    getDevCommand(pm),
+    sendLookup,
+  );
+
+  printMessage`    Lookup ${result ? "successful" : "failed"} for ${
+    values([wf, pm, kv, mq])
+  }!`;
+  if (!result) {
+    printMessage`    Check out these files for more details:
+      ${join(dir, "out.txt")}
+      ${join(dir, "err.txt")}\n`;
+  }
+  printMessage`\n`;
+
+  return result;
+}
+
+const sendLookup = async (port: number) => {
+  const serverUrl = `http://localhost:${port}`;
+  const lookupTarget = `${serverUrl}/users/${HANDLE}`;
+  // Wait for server to be ready
+  printMessage`    Waiting for server to start at ${serverUrl}...`;
+
+  const isReady = await waitForServer(serverUrl, STARTUP_TIMEOUT);
+
+  if (!isReady) {
+    printErrorMessage`Server did not start within \
+${String(STARTUP_TIMEOUT)}ms`;
+    return false;
+  }
+
+  printMessage`    Server is ready. Running lookup command...`;
+
+  // Run lookup command from original directory
+  try {
+    await runSubCommand(
+      ["deno", "task", "cli", "lookup", lookupTarget],
+      { cwd: CWD },
+    );
+
+    return true;
+  } catch (error) {
+    if (error instanceof Error) {
+      printErrorMessage`${error.message}`;
+    }
+  }
+  return false;
+};
+
+/**
+ * Wait for the server to be ready by checking if it responds to requests.
+ */
+async function waitForServer(url: string, timeout: number): Promise<boolean> {
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < timeout) {
+    try {
+      const response = await fetch(url, { signal: AbortSignal.timeout(1000) });
+      if (response.ok) {
+        return true;
+      }
+    } catch {
+      // Server not ready yet, continue waiting
+    }
+
+    // Wait 500ms before next attempt
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+
+  return false;
+}
+
+async function serverClosure<T>(
+  dir: string,
+  cmd: string,
+  callback: (port: number) => Promise<T>,
+): Promise<Awaited<T>> {
+  // Start the dev server using Node.js spawn
+  const devCommand = cmd.split(" ");
+  const serverProcess = spawn(devCommand[0], devCommand.slice(1), {
+    cwd: dir,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true, // Create a new process group
+  });
+
+  // Append stdout and stderr to files
+  const stdout = createWriteStream(join(dir, "out.txt"), { flags: "a" });
+  const stderr = createWriteStream(join(dir, "err.txt"), { flags: "a" });
+
+  serverProcess.stdout?.pipe(stdout);
+  serverProcess.stderr?.pipe(stderr);
+
+  try {
+    const port = await determinePort(serverProcess);
+    return await callback(port);
+  } finally {
+    try {
+      process.kill(-serverProcess.pid!, "SIGKILL");
+    } catch {
+      serverProcess.kill("SIGKILL");
+
+      // Close file streams
+      stdout.end();
+      stderr.end();
+    }
+  }
+}
+
+function determinePort(
+  server: ChildProcessByStdio<null, Stream.Readable, Stream.Readable>,
+): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(
+        new Error("Timeout: Could not determine port from server output"),
+      );
+    }, STARTUP_TIMEOUT);
+
+    let stdoutData = "";
+    let stderrData = "";
+
+    // Common patterns for port detection
+    const portPatterns = [
+      /listening on.*:(\d+)/i,
+      /server.*:(\d+)/i,
+      /port\s*:?\s*(\d+)/i,
+      /localhost:(\d+)/i,
+      /0\.0\.0\.0:(\d+)/i,
+      /127\.0\.0\.1:(\d+)/i,
+      /https?:\/\/[^:]+:(\d+)/i,
+    ];
+
+    const checkForPort = (data: string) => {
+      for (const pattern of portPatterns) {
+        const match = data.match(pattern);
+        if (match && match[1]) {
+          const port = Number.parseInt(match[1], 10);
+          if (port > 0 && port < 65536) {
+            clearTimeout(timeout);
+            return port;
+          }
+        }
+      }
+      return null;
+    };
+
+    server.stdout.on("data", (chunk) => {
+      stdoutData += chunk.toString();
+      const port = checkForPort(stdoutData);
+      if (port) resolve(port);
+    });
+
+    server.stderr.on("data", (chunk) => {
+      stderrData += chunk.toString();
+      const port = checkForPort(stderrData);
+      if (port) resolve(port);
+    });
+
+    server.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+
+    server.on("exit", (code) => {
+      clearTimeout(timeout);
+      reject(
+        new Error(
+          `Server exited with code ${code} before port could be determined`,
+        ),
+      );
+    });
+  });
+}

package/src/init/test/run.ts

@@ -0,0 +1,42 @@
+import { filter, map, pipe, tap } from "@fxts/core";
+import { optionNames } from "@optique/core";
+import { join } from "node:path";
+import { printMessage } from "../../utils.ts";
+import createTestApp, { filterOptions, generateTestCases } from "./create.ts";
+import runServerAndReadUser from "./lookup.ts";
+import type { InitTestData } from "./types.ts";
+
+export const isDryRun = <T extends { dryRun: boolean }>({ dryRun }: T) =>
+  dryRun;
+export const isHydRun = <T extends { hydRun: boolean }>({ hydRun }: T) =>
+  hydRun;
+
+export const runTests =
+  (dry: boolean) =>
+  <T extends InitTestData>({ testDirPrefix, dryRun, hydRun, ...options }: T) =>
+    pipe(
+      options,
+      printStartMessage,
+      generateTestCases,
+      filter(filterOptions),
+      map(createTestApp(join(testDirPrefix, getMid(dryRun, hydRun, dry)), dry)),
+      Array.fromAsync<string>,
+      runServerAndReadUser,
+    );
+
+const printStartMessage: <T>(t: T) => T = tap(
+  () =>
+    printMessage`\n
+Init Test start!
+Options: ${
+      optionNames([
+        "Web Framework",
+        "Package Manager",
+        "KV Store",
+        "Message Queue",
+      ])
+    }`,
+);
+
+const getMid = (dryRun: boolean, hydRun: boolean, dry: boolean) =>
+  dryRun === hydRun ? dry ? "dry" : "hyd" : "";

package/src/init/test/types.ts

@@ -0,0 +1,34 @@
+import type { TestInitCommand } from "../command.ts";
+
+export interface InitTestData extends AllDefinedTestInitCommand {
+  runId: string;
+  testDirPrefix: string;
+}
+
+export interface AllDefinedTestInitCommand extends TestInitCommand {
+  webFramework: (TestInitCommand["webFramework"][number] & string)[];
+  packageManager: (TestInitCommand["packageManager"][number] & string)[];
+  kvStore: (TestInitCommand["kvStore"][number] & string)[];
+  messageQueue: (TestInitCommand["messageQueue"][number] & string)[];
+}
+
+export type MultipleOption =
+  | "webFramework"
+  | "packageManager"
+  | "kvStore"
+  | "messageQueue";
+
+export type DefineOption<T extends TestInitCommand, K extends MultipleOption> =
+  & Omit<T, K>
+  & {
+    [Key in MultipleOption]: Key extends K ? AllDefinedTestInitCommand[Key]
+      : T[Key];
+  };
+
+export type DefineAllOptions<T extends TestInitCommand> =
+  & Omit<T, MultipleOption>
+  & {
+    [K in MultipleOption]: TestInitCommand[K] extends readonly unknown[]
+      ? AllDefinedTestInitCommand[K]
+      : never;
+  };

package/src/init/test/utils.ts

@@ -0,0 +1,21 @@
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { printMessage } from "../../utils.ts";
+
+export const genRunId = () =>
+  `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+
+export const genTestDirPrefix = <T extends { runId: string }>({ runId }: T) =>
+  join(tmpdir(), "fedify-init", runId);
+
+export const emptyTestDir = <
+  T extends { testDirPrefix: string },
+>({ testDirPrefix }: T) =>
+  Deno.remove(testDirPrefix, { recursive: true }).catch(() => {});
+
+export const logTestDir = <
+  T extends { runId: string; testDirPrefix: string },
+>({ runId, testDirPrefix }: T) =>
+  printMessage`Test run completed.
+Run ID: ${runId}
+Path: ${testDirPrefix}`;

package/src/init/types.ts

@@ -1,3 +1,4 @@
+import type { Message } from "@optique/core";
 import type { RequiredNotNull } from "../utils.ts";
 import type { InitCommand } from "./command.ts";
 import type {
@@ -40,15 +41,15 @@ export interface WebFrameworkInitializer {
   files?: Record<string, string>;
   compilerOptions?: Record<string, string | boolean | number | string[] | null>;
   tasks?: Record<string, string>;
-  instruction: string;
+  instruction: Message;
 }
 
 export interface WebFrameworkDescription {
   label: string;
   packageManagers: readonly PackageManager[];
+  defaultPort: number;
   init(
-    projectName: string,
-    pm: PackageManager,
+    data: InitCommandOptions & { projectName: string },
   ): WebFrameworkInitializer;
 }