@fedify/cli 1.8.12 → 2.0.0-dev.1757

package/src/init/webframeworks.ts

@@ -0,0 +1,151 @@
+import { pipe } from "@fxts/core";
+import { replace } from "../utils.ts";
+import { PACKAGE_MANAGER } from "./const.ts";
+import {
+  getInstruction,
+  getNextInitCommand,
+  getNitroInitCommand,
+  PACKAGE_VERSION,
+  readTemplate,
+} from "./lib.ts";
+import type { WebFrameworks } from "./types.ts";
+
+const webFrameworks: WebFrameworks = {
+  hono: {
+    label: "Hono",
+    packageManagers: PACKAGE_MANAGER,
+    init: (projectName, pm) => ({
+      dependencies: pm === "deno"
+        ? {
+          "@std/dotenv": "^0.225.2",
+          "@hono/hono": "^4.5.0",
+          "@hongminhee/x-forwarded-fetch": "^0.2.0",
+        }
+        : pm === "bun"
+        ? { hono: "^4.5.0", "x-forwarded-fetch": "^0.2.0" }
+        : {
+          "@dotenvx/dotenvx": "^1.14.1",
+          hono: "^4.5.0",
+          "@hono/node-server": "^1.12.0",
+          tsx: "^4.17.0",
+          "x-forwarded-fetch": "^0.2.0",
+        },
+      devDependencies: pm === "bun" ? { "@types/bun": "^1.1.6" } : {},
+      federationFile: "src/federation.ts",
+      loggingFile: "src/logging.ts",
+      files: {
+        "src/app.tsx": pipe(
+          "hono/app.tsx",
+          readTemplate,
+          replace(
+            /\/\* hono \*\//,
+            pm === "deno" ? "@hono/hono" : "hono",
+          ),
+        )
+          .replace(/\/\* logger \*\//, projectName),
+        "src/index.ts": readTemplate(`hono/index/${pm}.ts`),
+      },
+      compilerOptions: pm === "deno" ? undefined : {
+        "lib": ["ESNext", "DOM"],
+        "target": "ESNext",
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "allowImportingTsExtensions": true,
+        "verbatimModuleSyntax": true,
+        "noEmit": true,
+        "strict": true,
+        "jsx": "react-jsx",
+        "jsxImportSource": "hono/jsx",
+      },
+      tasks: {
+        "dev": pm === "deno"
+          ? "deno run -A --watch ./src/index.ts"
+          : pm === "bun"
+          ? "bun run --hot ./src/index.ts"
+          : "dotenvx run -- tsx watch ./src/index.ts",
+        "prod": pm === "deno"
+          ? "deno run -A ./src/index.ts"
+          : pm === "bun"
+          ? "bun run ./src/index.ts"
+          : "dotenvx run -- node --import tsx ./src/index.ts",
+      },
+      instruction: getInstruction(pm),
+    }),
+  },
+  express: {
+    label: "Express",
+    packageManagers: ["bun", "npm", "yarn", "pnpm"] as const,
+    init: (projectName, pm) => ({
+      dependencies: {
+        express: "^4.19.2",
+        "@fedify/express": PACKAGE_VERSION,
+        ...(pm !== "deno" && pm !== "bun"
+          ? { "@dotenvx/dotenvx": "^1.14.1", tsx: "^4.17.0" }
+          : {}),
+      },
+      devDependencies: {
+        "@types/express": "^4.17.21",
+        ...(pm === "bun" ? { "@types/bun": "^1.1.6" } : {}),
+      },
+      federationFile: "src/federation.ts",
+      loggingFile: "src/logging.ts",
+      files: {
+        "src/app.ts": readTemplate("express/app.ts")
+          .replace(/\/\* logger \*\//, projectName),
+        "src/index.ts": readTemplate("express/index.ts"),
+      },
+      compilerOptions: pm === "deno" ? undefined : {
+        "lib": ["ESNext", "DOM"],
+        "target": "ESNext",
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "allowImportingTsExtensions": true,
+        "verbatimModuleSyntax": true,
+        "noEmit": true,
+        "strict": true,
+      },
+      tasks: {
+        "dev": pm === "bun"
+          ? "bun run --hot ./src/index.ts"
+          : "dotenvx run -- tsx watch ./src/index.ts",
+        "prod": pm === "bun"
+          ? "bun run ./src/index.ts"
+          : "dotenvx run -- node --import tsx ./src/index.ts",
+      },
+      instruction: getInstruction(pm),
+    }),
+  },
+  nitro: {
+    label: "Nitro",
+    packageManagers: PACKAGE_MANAGER,
+    init: (_, pm) => ({
+      command: getNitroInitCommand(pm),
+      dependencies: { "@fedify/h3": PACKAGE_VERSION },
+      federationFile: "server/federation.ts",
+      loggingFile: "server/logging.ts",
+      files: {
+        "server/middleware/federation.ts": readTemplate(
+          "nitro/server/middleware/federation.ts",
+        ),
+        "server/error.ts": readTemplate("nitro/server/error.ts"),
+        "nitro.config.ts": readTemplate("nitro/nitro.config.ts"),
+      },
+      instruction: getInstruction(pm),
+    }),
+  },
+  next: {
+    label: "Next.js",
+    packageManagers: PACKAGE_MANAGER,
+    init: (_, pm) => ({
+      label: "Next.js",
+      command: getNextInitCommand(pm),
+      dependencies: { "@fedify/next": PACKAGE_VERSION },
+      devDependencies: { "@types/node": "^20.11.2" },
+      federationFile: "federation/index.ts",
+      loggingFile: "logging.ts",
+      files: { "middleware.ts": readTemplate("next/middleware.ts") },
+      instruction: getInstruction(pm),
+    }),
+  },
+} as const;
+export default webFrameworks;

package/src/kv.bun.ts

@@ -0,0 +1,12 @@
+import type { KvStore } from "@fedify/fedify/federation";
+import { SqliteKvStore } from "@fedify/sqlite";
+import { Database } from "bun:sqlite";
+import { join } from "node:path";
+import type { DatabaseSync } from "node:sqlite";
+import { getCacheDir } from "./cache.ts";
+
+export async function getKvStore(): Promise<KvStore> {
+  const path = join(await getCacheDir(), "sqlite");
+  const sqlite = new Database(path);
+  return new SqliteKvStore(sqlite as unknown as DatabaseSync);
+}

package/src/kv.node.ts

@@ -0,0 +1,11 @@
+import type { KvStore } from "@fedify/fedify/federation";
+import { SqliteKvStore } from "@fedify/sqlite";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { getCacheDir } from "./cache.ts";
+
+export async function getKvStore(): Promise<KvStore> {
+  const path = join(await getCacheDir(), "sqlite");
+  const sqlite = new DatabaseSync(path);
+  return new SqliteKvStore(sqlite);
+}

package/src/log.ts

@@ -0,0 +1,64 @@
+import { getFileSink } from "@logtape/file";
+import {
+  configure,
+  getConsoleSink,
+  type LogRecord,
+  type Sink,
+} from "@logtape/logtape";
+import { dirname } from "node:path";
+import process from "node:process";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { mkdir } from "node:fs/promises";
+
+export interface RecordingSink extends Sink {
+  startRecording(): void;
+  stopRecording(): void;
+  getRecords(): LogRecord[];
+}
+
+export function getRecordingSink(): RecordingSink {
+  let records: LogRecord[] = [];
+  let recording = false;
+  const sink: RecordingSink = (record: LogRecord) => {
+    if (recording) records.push(record);
+  };
+  sink.startRecording = () => {
+    records = [];
+    recording = true;
+  };
+  sink.stopRecording = () => {
+    recording = false;
+  };
+  sink.getRecords = () => [...records];
+  return sink;
+}
+
+export const recordingSink = getRecordingSink();
+
+export const logFile = process.env["FEDIFY_LOG_FILE"];
+if (logFile != null) {
+  await mkdir(dirname(logFile), { recursive: true });
+}
+
+await configure({
+  sinks: {
+    console: getConsoleSink(),
+    recording: recordingSink,
+    file: logFile == null ? () => undefined : getFileSink(logFile),
+  },
+  filters: {},
+  loggers: [
+    {
+      category: "fedify",
+      lowestLevel: "debug",
+      sinks: ["recording", "file"],
+    },
+    {
+      category: ["logtape", "meta"],
+      lowestLevel: "warning",
+      sinks: ["console", "file"],
+    },
+  ],
+  contextLocalStorage: new AsyncLocalStorage(),
+  reset: true,
+});

package/src/lookup.test.ts

@@ -0,0 +1,182 @@
+import { Activity, Note } from "@fedify/fedify";
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdir, readFile, rm } from "node:fs/promises";
+import { getContextLoader } from "./docloader.ts";
+import {
+  clearTimeoutSignal,
+  createTimeoutSignal,
+  TimeoutError,
+  writeObjectToStream,
+} from "./lookup.ts";
+
+test("writeObjectToStream - writes Note object with default options", async () => {
+  const testDir = "./test_output_note";
+  const testFile = `${testDir}/note.txt`;
+
+  await mkdir(testDir, { recursive: true });
+
+  const note = new Note({
+    id: new URL("https://example.com/notes/1"),
+    content: "Hello, fediverse!",
+  });
+
+  const contextLoader = await getContextLoader({});
+  await writeObjectToStream(note, testFile, undefined, contextLoader);
+  await new Promise((resolve) => setTimeout(resolve, 100));
+
+  const content = await readFile(testFile, { encoding: "utf8" });
+
+  assert.ok(content);
+  assert.match(content, /Hello, fediverse!/);
+  assert.match(content, /id/);
+
+  await rm(testDir, { recursive: true });
+});
+
+test("writeObjectToStream - writes Activity object in raw JSON-LD format", async () => {
+  const testDir = "./test_output_activity";
+  const testFile = `${testDir}/raw.json`;
+
+  await mkdir(testDir, { recursive: true });
+
+  const activity = new Activity({
+    id: new URL("https://example.com/activities/1"),
+  });
+
+  const contextLoader = await getContextLoader({});
+  await writeObjectToStream(activity, testFile, "raw", contextLoader);
+  await new Promise((resolve) => setTimeout(resolve, 100));
+
+  // Verify file exists and contains JSON-LD
+  const content = await readFile(testFile);
+
+  assert.ok(content);
+  assert.ok(content.includes("@context"));
+  assert.ok(content.includes("id"));
+
+  await rm(testDir, { recursive: true });
+});
+
+test("writeObjectToStream - writes object in compact JSON-LD format", async () => {
+  const testDir = "./test_output_compact";
+  const testFile = `${testDir}/compact.json`;
+
+  await mkdir(testDir, { recursive: true });
+
+  const note = new Note({
+    id: new URL("https://example.com/notes/1"),
+    content: "Test note",
+  });
+
+  const contextLoader = await getContextLoader({});
+  await writeObjectToStream(note, testFile, "compact", contextLoader);
+  await new Promise((resolve) => setTimeout(resolve, 100));
+
+  // Verify file exists and contains compacted JSON-LD
+  const content = await readFile(testFile);
+  assert.ok(content);
+  assert.ok(content.includes("Test note"));
+
+  await rm(testDir, { recursive: true });
+});
+
+test("writeObjectToStream - writes object in expanded JSON-LD format", async () => {
+  const testDir = "./test_output_expand";
+  const testFile = `${testDir}/expand.json`;
+
+  await mkdir(testDir, { recursive: true });
+
+  const note = new Note({
+    id: new URL("https://example.com/notes/1"),
+    content: "Test note for expansion",
+  });
+
+  const contextLoader = await getContextLoader({});
+  await writeObjectToStream(note, testFile, "expand", contextLoader);
+  await new Promise((resolve) => setTimeout(resolve, 100));
+
+  const content = await readFile(testFile);
+  assert.ok(content);
+  assert.ok(content.includes("Test note for expansion"));
+
+  await rm(testDir, { recursive: true });
+});
+
+test("writeObjectToStream - writes to stdout when no output file specified", async () => {
+  const note = new Note({
+    id: new URL("https://example.com/notes/1"),
+    content: "Test stdout note",
+  });
+
+  const contextLoader = await getContextLoader({});
+
+  await writeObjectToStream(note, undefined, undefined, contextLoader);
+});
+
+test("writeObjectToStream - handles empty content properly", async () => {
+  const testDir = "./test_output_empty";
+  const testFile = `${testDir}/empty.txt`;
+
+  await mkdir(testDir, { recursive: true });
+
+  const note = new Note({
+    id: new URL("https://example.com/notes/1"),
+  });
+
+  const contextLoader = await getContextLoader({});
+
+  await writeObjectToStream(note, testFile, undefined, contextLoader);
+  await new Promise((resolve) => setTimeout(resolve, 100));
+
+  const content = await readFile(testFile);
+  assert.ok(content);
+  assert.ok(content.includes("Note"));
+
+  await rm(testDir, { recursive: true });
+});
+
+test("createTimeoutSignal - returns undefined when no timeout specified", () => {
+  const signal = createTimeoutSignal();
+  assert.strictEqual(signal, undefined);
+});
+
+test("createTimeoutSignal - returns undefined when timeout is null", () => {
+  const signal = createTimeoutSignal(undefined);
+  assert.strictEqual(signal, undefined);
+});
+
+test("createTimeoutSignal - creates AbortSignal that aborts after timeout", async () => {
+  const signal = createTimeoutSignal(0.1);
+  assert.ok(signal);
+  assert.ok(!signal.aborted);
+
+  await new Promise((resolve) => setTimeout(resolve, 150));
+
+  assert.ok(signal.aborted);
+  assert.ok(signal.reason instanceof TimeoutError);
+  assert.equal(
+    (signal.reason as TimeoutError).message,
+    "Request timed out after 0.1 seconds",
+  );
+});
+
+test("createTimeoutSignal - signal is not aborted before timeout", () => {
+  const signal = createTimeoutSignal(1); // 1 second timeout
+  assert.ok(signal);
+  assert.ok(!signal.aborted);
+
+  clearTimeoutSignal(signal);
+});
+
+test("clearTimeoutSignal - cleans up timer properly", async () => {
+  const signal = createTimeoutSignal(0.05); // 50ms timeout
+  assert.ok(signal);
+  assert.ok(!signal.aborted);
+
+  clearTimeoutSignal(signal);
+
+  await new Promise((resolve) => setTimeout(resolve, 100));
+
+  assert.ok(!signal.aborted);
+});