@fedify/cli 1.8.12 → 2.0.0-dev.1761

package/src/init/json/pm.json

@@ -0,0 +1,47 @@
+{
+  "deno": {
+    "label": "deno",
+    "checkCommand": [
+      "deno",
+      "--version"
+    ],
+    "outputPattern": "^deno\\s+\\d+\\.\\d+\\.\\d+\\b",
+    "installUrl": "https://docs.deno.com/runtime/getting_started/installation"
+  },
+  "bun": {
+    "label": "bun",
+    "checkCommand": [
+      "bun",
+      "--version"
+    ],
+    "outputPattern": "^\\d+\\.\\d+\\.\\d+$",
+    "installUrl": "https://bun.sh/docs/installation"
+  },
+  "npm": {
+    "label": "npm",
+    "checkCommand": [
+      "npm",
+      "--version"
+    ],
+    "outputPattern": "^\\d+\\.\\d+\\.\\d+$",
+    "installUrl": "https://docs.npmjs.com/downloading-and-installing-node-js-and-npm"
+  },
+  "yarn": {
+    "label": "Yarn",
+    "checkCommand": [
+      "yarn",
+      "--version"
+    ],
+    "outputPattern": "^\\d+\\.\\d+\\.\\d+$",
+    "installUrl": "https://classic.yarnpkg.com/en/docs/install/#windows-stable"
+  },
+  "pnpm": {
+    "label": "pnpm",
+    "checkCommand": [
+      "pnpm",
+      "--version"
+    ],
+    "outputPattern": "^\\d+\\.\\d+\\.\\d+$",
+    "installUrl": "https://pnpm.io/installation"
+  }
+}

package/src/init/json/rt.json

@@ -0,0 +1,42 @@
+{
+  "deno": {
+    "label": "Deno",
+    "checkCommand": [
+      "deno",
+      "--version"
+    ],
+    "outputPattern": "^deno\\s+\\d+\\.\\d+\\.\\d+\\b"
+  },
+  "bun": {
+    "label": "Bun",
+    "checkCommand": [
+      "bun",
+      "--version"
+    ],
+    "outputPattern": "^\\d+\\.\\d+\\.\\d+$"
+  },
+  "pnpm": {
+    "label": "Node.js",
+    "checkCommand": [
+      "node",
+      "--version"
+    ],
+    "outputPattern": "^v\\d+\\.\\d+\\.\\d+$"
+  },
+  "yarn": {
+    "label": "Node.js",
+    "checkCommand": [
+      "node",
+      "--version"
+    ],
+    "outputPattern": "^v\\d+\\.\\d+\\.\\d+$"
+  },
+  "npm": {
+    "label": "Node.js",
+    "checkCommand": [
+      "node",
+      "--version"
+    ],
+    "outputPattern": "^v\\d+\\.\\d+\\.\\d+$"
+  }
+}

package/src/init/json/vscode-settings-for-deno.json

@@ -0,0 +1,43 @@
+{
+  "deno.enable": true,
+  "deno.unstable": true,
+  "editor.detectIndentation": false,
+  "editor.indentSize": 2,
+  "editor.insertSpaces": true,
+  "[javascript]": {
+    "editor.defaultFormatter": "denoland.vscode-deno",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.sortImports": "always"
+    }
+  },
+  "[javascriptreact]": {
+    "editor.defaultFormatter": "denoland.vscode-deno",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.sortImports": "always"
+    }
+  },
+  "[json]": {
+    "editor.defaultFormatter": "vscode.json-language-features",
+    "editor.formatOnSave": true
+  },
+  "[jsonc]": {
+    "editor.defaultFormatter": "vscode.json-language-features",
+    "editor.formatOnSave": true
+  },
+  "[typescript]": {
+    "editor.defaultFormatter": "denoland.vscode-deno",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.sortImports": "always"
+    }
+  },
+  "[typescriptreact]": {
+    "editor.defaultFormatter": "denoland.vscode-deno",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.sortImports": "always"
+    }
+  }
+}

package/src/init/json/vscode-settings.json

@@ -0,0 +1,41 @@
+{
+  "editor.detectIndentation": false,
+  "editor.indentSize": 2,
+  "editor.insertSpaces": true,
+  "[javascript]": {
+    "editor.defaultFormatter": "biomejs.biome",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.organizeImports.biome": "always"
+    }
+  },
+  "[javascriptreact]": {
+    "editor.defaultFormatter": "biomejs.biome",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.organizeImports.biome": "always"
+    }
+  },
+  "[json]": {
+    "editor.defaultFormatter": "biomejs.biome",
+    "editor.formatOnSave": true
+  },
+  "[jsonc]": {
+    "editor.defaultFormatter": "biomejs.biome",
+    "editor.formatOnSave": true
+  },
+  "[typescript]": {
+    "editor.defaultFormatter": "biomejs.biome",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.organizeImports.biome": "always"
+    }
+  },
+  "[typescriptreact]": {
+    "editor.defaultFormatter": "biomejs.biome",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.organizeImports.biome": "always"
+    }
+  }
+}

package/src/init/lib.ts

@@ -0,0 +1,220 @@
+import {
+  entries,
+  evolve,
+  fromEntries,
+  isObject,
+  map,
+  negate,
+  pipe,
+  throwIf,
+  when,
+} from "@fxts/core";
+import { getLogger } from "@logtape/logtape";
+import { dirname, join as joinPath } from "node:path";
+import { toMerged } from "es-toolkit";
+import { readFileSync } from "node:fs";
+import { mkdir, readdir, writeFile } from "node:fs/promises";
+import process from "node:process";
+import metadata from "../../deno.json" with { type: "json" };
+import { colors, isNotFoundError, runSubCommand } from "../utils.ts";
+import kv from "./json/kv.json" with { type: "json" };
+import mq from "./json/mq.json" with { type: "json" };
+import pm from "./json/pm.json" with { type: "json" };
+import rt from "./json/rt.json" with { type: "json" };
+import type {
+  KvStores,
+  MessageQueues,
+  PackageManager,
+  PackageManagers,
+  Runtimes,
+} from "./types.ts";
+import webFrameworks from "./webframeworks.ts";
+
+export const PACKAGE_VERSION = metadata.version;
+export const logger = getLogger(["fedify", "cli", "init"]);
+
+const addFedifyDeps = <T extends object>(json: T): T =>
+  Object.fromEntries(
+    Object.entries(json).map(([key, value]) => [
+      key,
+      toMerged(value, {
+        dependencies: {
+          [`@fedify/${key}`]: PACKAGE_VERSION,
+        },
+      }),
+    ]),
+  ) as T;
+export const kvStores = addFedifyDeps(kv as KvStores);
+export const messageQueues = addFedifyDeps(mq as MessageQueues);
+const toRegExp = (str: string): RegExp => new RegExp(str);
+const convertPattern = <K extends string, T extends { outputPattern: string }>(
+  obj: Record<K, T>,
+): Record<K, Omit<T, "outputPattern"> & { outputPattern: RegExp }> =>
+  pipe(
+    obj,
+    entries as (obj: Record<K, T>) => Generator<[K, T]>,
+    map(([key, value]: [K, T]) =>
+      [key, evolve({ outputPattern: toRegExp })(value)] as const
+    ),
+    fromEntries,
+  ) as Record<K, Omit<T, "outputPattern"> & { outputPattern: RegExp }>;
+const packageManagers = convertPattern(pm) as PackageManagers;
+const runtimes = convertPattern(rt) as Runtimes;
+
+export const getLabel = (name: string) =>
+  pipe(
+    name,
+    whenHasLabel(webFrameworks),
+    whenHasLabel(packageManagers),
+    whenHasLabel(messageQueues),
+    whenHasLabel(kvStores),
+    whenHasLabel(runtimes),
+  );
+const whenHasLabel = <T extends Record<string, { label: string }>>(desc: T) =>
+  when((name: string) => name in desc, (name) => desc[name as keyof T].label);
+
+export const getInstallUrl = (pm: PackageManager) =>
+  packageManagers[pm].installUrl;
+
+export async function isPackageManagerAvailable(
+  pm: PackageManager,
+): Promise<boolean> {
+  if (await isCommandAvailable(packageManagers[pm])) return true;
+  if (process.platform !== "win32") return false;
+  const cmd: [string, ...string[]] = [
+    packageManagers[pm].checkCommand[0] + ".cmd",
+    ...packageManagers[pm].checkCommand.slice(1),
+  ];
+  if (
+    await isCommandAvailable({
+      ...packageManagers[pm],
+      checkCommand: cmd,
+    })
+  ) return true;
+  return false;
+}
+
+export const readTemplate: (templatePath: string) => string = (
+  templatePath,
+) =>
+  readFileSync(
+    joinPath(
+      import.meta.dirname!,
+      "templates",
+      ...(templatePath + ".tpl").split("/"),
+    ),
+    "utf8",
+  );
+
+export const getInstruction: (
+  packageManager: PackageManager,
+) => string = (pm) => `
+To start the server, run the following command:
+
+  ${getDevCommand(pm)}
+
+Then, try look up an actor from your server:
+
+  ${
+  colors.bold(colors.green(
+    "fedify lookup http://localhost:8000/users/john",
+  ))
+}
+
+`;
+
+const getDevCommand = (pm: PackageManager) =>
+  colors.bold(
+    colors.green(
+      pm === "deno"
+        ? "deno task dev"
+        : pm === "bun"
+        ? "bun dev"
+        : `${pm} run dev`,
+    ),
+  );
+
+async function isCommandAvailable(
+  { checkCommand, outputPattern }: {
+    checkCommand: [string, ...string[]];
+    outputPattern: RegExp;
+  },
+): Promise<boolean> {
+  try {
+    const { stdout } = await runSubCommand(checkCommand, {
+      stdio: [null, "pipe", null],
+    });
+    logger.debug(
+      "The stdout of the command {command} is: {stdout}",
+      { command: checkCommand, stdout },
+    );
+    return outputPattern.exec(stdout.trim()) ? true : false;
+  } catch (error) {
+    if (isNotFoundError(error)) return false;
+    logger.debug(
+      "The command {command} failed with the error: {error}",
+      { command: checkCommand, error },
+    );
+    throw error;
+  }
+}
+
+export async function createFile(path: string, content: string): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, content);
+}
+
+const isNotExistsError = (e: unknown) =>
+  isObject(e) && "code" in e && e.code === "ENOENT";
+
+export const throwUnlessNotExists = throwIf(negate(isNotExistsError));
+
+export const isDirectoryEmpty = async (
+  path: string,
+): Promise<boolean> => {
+  try {
+    const files = await readdir(path);
+    return files.length === 0;
+  } catch (e) {
+    throwUnlessNotExists(e);
+    return true;
+  }
+};
+
+export const getNextInitCommand = (
+  pm: PackageManager,
+): string[] => [
+  ...createNextAppCommand(pm),
+  ".",
+  "--ts",
+  "--app",
+  "--biome",
+  "--skip-install",
+];
+
+const createNextAppCommand = (pm: PackageManager): string[] =>
+  pm === "deno"
+    ? ["deno", "run", "-A", "npm:create-next-app@latest"]
+    : pm === "bun"
+    ? ["bun", "create", "next-app"]
+    : pm === "npm"
+    ? ["npx", "create-next-app"]
+    : [pm, "dlx", "create-next-app"];
+
+export const getNitroInitCommand = (
+  pm: PackageManager,
+): string[] => [
+  ...createNitroAppCommand(pm),
+  pm === "deno" ? "npm:giget@latest" : "giget@latest",
+  "nitro",
+  ".",
+];
+
+const createNitroAppCommand = (pm: PackageManager): string[] =>
+  pm === "deno"
+    ? ["deno", "run", "-A"]
+    : pm === "bun"
+    ? ["bunx"]
+    : pm === "npm"
+    ? ["npx"]
+    : [pm, "dlx"];

package/src/init/mod.ts

@@ -0,0 +1,2 @@
+export { default as runInit } from "./action/mod.ts";
+export { initCommand } from "./command.ts";

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,45 @@
+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/nitro.config.ts.tpl

@@ -0,0 +1,5 @@
+// https://nitro.unjs.io/config
+export default defineNitroConfig({
+  srcDir: "server",
+  errorHandler: "~/error"
+});

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

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

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

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

package/src/init/types.ts

@@ -0,0 +1,88 @@
+import type { RequiredNotNull } from "../utils.ts";
+import type { InitCommand } from "./command.ts";
+import type {
+  KV_STORE,
+  MESSAGE_QUEUE,
+  PACKAGE_MANAGER,
+  WEB_FRAMEWORK,
+} from "./const.ts";
+
+export type PackageManager = typeof PACKAGE_MANAGER[number];
+export type WebFramework = typeof WEB_FRAMEWORK[number];
+export type MessageQueue = typeof MESSAGE_QUEUE[number];
+export type KvStore = typeof KV_STORE[number];
+
+export type MessageQueues = Record<MessageQueue, MessageQueueDescription>;
+export type KvStores = Record<KvStore, KvStoreDescription>;
+export type WebFrameworks = Record<WebFramework, WebFrameworkDescription>;
+export type PackageManagers = Record<PackageManager, PackageManagerDescription>;
+export type Runtimes = Record<PackageManager, RuntimeDescription>;
+
+export interface RuntimeDescription {
+  label: string;
+  checkCommand: [string, ...string[]];
+  outputPattern: RegExp;
+}
+
+export interface PackageManagerDescription {
+  label: string;
+  checkCommand: [string, ...string[]];
+  outputPattern: RegExp;
+  installUrl: string;
+}
+
+export interface WebFrameworkInitializer {
+  command?: string[];
+  dependencies?: object;
+  devDependencies?: object;
+  federationFile: string;
+  loggingFile: string;
+  files?: Record<string, string>;
+  compilerOptions?: Record<string, string | boolean | number | string[] | null>;
+  tasks?: Record<string, string>;
+  instruction: string;
+}
+
+export interface WebFrameworkDescription {
+  label: string;
+  packageManagers: readonly PackageManager[];
+  init(
+    projectName: string,
+    pm: PackageManager,
+  ): WebFrameworkInitializer;
+}
+
+export interface MessageQueueDescription {
+  label: string;
+  packageManagers: readonly PackageManager[];
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  imports: Record<string, Record<string, string>>;
+  object: string;
+  denoUnstable?: string[];
+  env?: Record<string, string>;
+}
+
+export interface KvStoreDescription {
+  label: string;
+  packageManagers: readonly PackageManager[];
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  imports: Record<string, Record<string, string>>;
+  object: string;
+  denoUnstable?: string[];
+  env?: Record<string, string>;
+}
+
+export type InitCommandOptions = RequiredNotNull<InitCommand>;
+
+export interface InitCommandData extends InitCommandOptions {
+  readonly projectName: string;
+  readonly initializer: WebFrameworkInitializer;
+  readonly kv: KvStoreDescription;
+  readonly mq: MessageQueueDescription;
+  readonly env: Record<string, string>;
+}
+
+export type InitCommandIo = (data: InitCommandData) => void;
+export type InitCommandAsyncIo = (data: InitCommandData) => Promise<void>;