@fedify/cli 2.0.0-pr.479.1919 → 2.0.0

package/src/init/templates/defaults/federation.ts.tpl

@@ -1,23 +0,0 @@
-import { createFederation, Person } from "@fedify/fedify";
-import { getLogger } from "@logtape/logtape";
-/* imports */
-
-const logger = getLogger(/* logger */);
-
-const federation = createFederation({
-  kv: /* kv */,
-  queue: /* queue */,
-});
-
-federation.setActorDispatcher(
-  "/users/{identifier}",
-  async (ctx, identifier) => {
-    return new Person({
-      id: ctx.getActorUri(identifier),
-      preferredUsername: identifier,
-      name: identifier,
-    });
-  },
-);
-
-export default federation;

package/src/init/templates/defaults/logging.ts.tpl

@@ -1,23 +0,0 @@
-import { configure, getConsoleSink } from "@logtape/logtape";
-import { AsyncLocalStorage } from "node:async_hooks";
-
-await configure({
-  contextLocalStorage: new AsyncLocalStorage(),
-  sinks: {
-    console: getConsoleSink(),
-  },
-  filters: {},
-  loggers: [
-    {
-      category: /* project name */,
-      lowestLevel: "debug",
-      sinks: ["console"],
-    },
-    { category: "fedify", lowestLevel: "info", sinks: ["console"] },
-    {
-      category: ["logtape", "meta"],
-      lowestLevel: "warning",
-      sinks: ["console"],
-    },
-  ],
-});

package/src/init/templates/express/app.ts.tpl

@@ -1,16 +0,0 @@
-import { integrateFederation } from "@fedify/express";
-import { getLogger } from "@logtape/logtape";
-import express from "express";
-import federation from "./federation.ts";
-
-const logger = getLogger("/* logger */");
-
-export const app = express();
-
-app.set("trust proxy", true);
-
-app.use(integrateFederation(federation, () => undefined));
-
-app.get("/", (_, res) => res.send("Hello, Fedify!"));
-
-export default app;

package/src/init/templates/express/index.ts.tpl

@@ -1,6 +0,0 @@
-import app from "./app.ts";
-import "./logging.ts";
-
-app.listen(8000, () => {
-  console.log("Server started at http://localhost:8000");
-});

package/src/init/templates/hono/app.tsx.tpl

@@ -1,14 +0,0 @@
-// @ts-nocheck this file is just a template
-import { Hono } from "/* hono */";
-import { federation } from "@fedify/hono";
-import { getLogger } from "@logtape/logtape";
-import fedi from "./federation.ts";
-
-const logger = getLogger("/* logger */");
-
-const app = new Hono();
-app.use(federation(fedi, () => undefined));
-
-app.get("/", (c) => c.text("Hello, Fedify!"));
-
-export default app;

package/src/init/templates/hono/index/bun.ts.tpl

@@ -1,10 +0,0 @@
-import { behindProxy } from "x-forwarded-fetch";
-import app from "./app.tsx";
-import "./logging.ts";
-
-const server = Bun.serve({
-  port: 8000,
-  fetch: behindProxy(app.fetch.bind(app)),
-});
-
-console.log("Server started at", server.url.href);

package/src/init/templates/hono/index/deno.ts.tpl

@@ -1,13 +0,0 @@
-import { behindProxy } from "@hongminhee/x-forwarded-fetch";
-import "@std/dotenv/load";
-import app from "./app.tsx";
-import "./logging.ts";
-
-Deno.serve(
-  {
-    port: 8000,
-    onListen: ({ port, hostname }) =>
-      console.log("Server started at http://" + hostname + ":" + port),
-  },
-  behindProxy(app.fetch.bind(app)),
-);

package/src/init/templates/hono/index/node.ts.tpl

@@ -1,14 +0,0 @@
-// @ts-nocheck this file is just a template
-import { serve } from "@hono/node-server";
-import { behindProxy } from "x-forwarded-fetch";
-import app from "./app.tsx";
-import "./logging.ts";
-
-serve(
-  {
-    port: 8000,
-    fetch: behindProxy(app.fetch.bind(app)),
-  },
-  (info) =>
-    console.log("Server started at http://" + info.address + ":" + info.port),
-);

package/src/init/templates/next/middleware.ts.tpl

@@ -1,45 +0,0 @@
-import { fedifyWith } from "@fedify/next";
-import federation from "./federation";
-
-export default fedifyWith(federation)(
-/*
-  function (request: Request) {
-    // If you need to handle other requests besides federation
-    // requests in middleware, you can do it here.
-    // If you handle only federation requests in middleware,
-    // you don't need this function.
-    return NextResponse.next();
-  },
-*/
-)
-
-// This config needs because middleware process only requests with the
-// "Accept" header matching the federation accept regex.
-// More details: https://nextjs.org/docs/app/api-reference/file-conventions/middleware#config-object-optional
-export const config = {
-  runtime: "nodejs",
-  matcher: [
-    {
-      source: "/:path*",
-      has: [
-        {
-          type: "header",
-          key: "Accept",
-          value: ".*application\\/((jrd|activity|ld)\\+json|xrd\\+xml).*",
-        },
-      ],
-    },
-    {
-      source: "/:path*",
-      has: [
-        {
-          type: "header",
-          key: "content-type",
-          value: ".*application\\/((jrd|activity|ld)\\+json|xrd\\+xml).*",
-        },
-      ],
-    },
-    { source: "/.well-known/nodeinfo" },
-    { source: "/.well-known/x-nodeinfo2" },
-  ],
-};

package/src/init/templates/nitro/.env.test.tpl

@@ -1 +0,0 @@
-HOST=127.0.0.1

package/src/init/templates/nitro/nitro.config.ts.tpl

@@ -1,14 +0,0 @@
-import { defineNitroConfig } from "nitropack/config"
-
-// https://nitro.build/config
-export default defineNitroConfig({
-  errorHandler: "~/error",
-  esbuild: {
-    options: {
-      target: "esnext",
-    },
-  },
-  compatibilityDate: "latest",
-  srcDir: "server",
-  imports: false
-});

package/src/init/templates/nitro/server/error.ts.tpl

@@ -1,3 +0,0 @@
-import { onError } from "@fedify/h3";
-
-export default onError;

package/src/init/templates/nitro/server/middleware/federation.ts.tpl

@@ -1,8 +0,0 @@
-
-import { integrateFederation } from "@fedify/h3";
-import federation from "../federation"
-
-export default integrateFederation(
-  federation,
-  (event, request) => undefined,
-);

package/src/init/test/action.ts

@@ -1,28 +0,0 @@
-import { pipe, tap, when } from "@fxts/core";
-import { set } from "../../utils.ts";
-import type { TestInitCommand } from "../command.ts";
-import { fillEmptyOptions } from "./fill.ts";
-import 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(isDryRun, runTests(true))),
-    tap(when(isHydRun, runTests(false))),
-    tap(logTestDir),
-  );
-
-const isDryRun = <T extends { dryRun: boolean }>({ dryRun }: T) => dryRun;
-const isHydRun = <T extends { hydRun: boolean }>({ hydRun }: T) => hydRun;
-
-export default runTestInit;

package/src/init/test/create.ts

@@ -1,137 +0,0 @@
-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

@@ -1,67 +0,0 @@
-import { isEmpty, omit, 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: T,
-): DefineAllOptions<T> =>
-  pipe(
-    options,
-    (options) => ("noHydRun" in options
-      ? ({ ...omit(["noHydRun"], options), hydRun: !options.noHydRun })
-      : ({ ...options, hydRun: true })),
-    (options) => ("noDryRun" in options
-      ? ({ ...omit(["noDryRun"], options), dryRun: !options.noDryRun })
-      : ({ ...options, dryRun: true })),
-  ) as DefineAllOptions<T>;

package/src/init/test/lookup.ts

@@ -1,254 +0,0 @@
-import { isEmpty } from "@fxts/core/index.js";
-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 runServerAndLookupUser(
-  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 (isEmpty(hasBanned)) {
-    return dirs;
-  }
-  const bannedLabels = hasBanned.map((wf) => webFrameworks[wf]["label"]);
-  printErrorMessage`\n${
-    values(bannedLabels)
-  } is not supported in lookup test 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")} and 
-      ${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,
-      /https?:\/\/localhost:(\d+)/i,
-      /https?:\/\/0\.0\.0\.0:(\d+)/i,
-      /https?:\/\/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`,
-        ),
-      );
-    });
-  });
-}