@fedify/cli 1.8.11 → 2.0.0-dev.1757

package/src/init/action/templates.ts

@@ -0,0 +1,95 @@
+import { entries, join, map, pipe } from "@fxts/core";
+import { toMerged } from "es-toolkit";
+import { replace } from "../../utils.ts";
+import { readTemplate } from "../lib.ts";
+import type { InitCommandData, PackageManager } from "../types.ts";
+
+/**
+ * Loads the federation configuration file content from template.
+ * Reads the default federation template and replaces placeholders with actual configuration values.
+ *
+ * @param param0 - Configuration object containing imports, project name, KV store, message queue, and package manager
+ * @returns The complete federation configuration file content as a string
+ */
+export const loadFederation = (
+  {
+    imports,
+    projectName,
+    kv,
+    mq,
+    packageManager,
+  }: InitCommandData & { imports: string },
+) =>
+  pipe(
+    "defaults/federation.ts",
+    readTemplate,
+    replace(/\/\* imports \*\//, imports),
+    replace(/\/\* logger \*\//, JSON.stringify(projectName)),
+    replace(/\/\* kv \*\//, convertEnv(kv.object, packageManager)),
+    replace(/\/\* queue \*\//, convertEnv(mq.object, packageManager)),
+  );
+
+/**
+ * Loads the logging configuration file content from template.
+ * Reads the default logging template and replaces the project name placeholder.
+ *
+ * @param param0 - Destructured object containing the project name
+ * @returns The complete logging configuration file content as a string
+ */
+export const loadLogging = ({ projectName }: InitCommandData) =>
+  pipe(
+    "defaults/logging.ts",
+    readTemplate,
+    replace(/\/\* project name \*\//, JSON.stringify(projectName)),
+  );
+
+/**
+ * Generates import statements for KV store and message queue dependencies.
+ * Merges imports from both KV and MQ configurations and creates proper ES module import syntax.
+ *
+ * @param param0 - Destructured object containing kv and mq configurations
+ * @returns A multi-line string containing all necessary import statements
+ */
+export const getImports = ({ kv, mq }: InitCommandData) =>
+  pipe(
+    toMerged(kv.imports, mq.imports),
+    entries,
+    map(([module, { "default": defaultImport = "", ...imports }]) => //
+    [module, defaultImport, getAlias(imports)]),
+    map(([module, defaultImport, namedImports]) =>
+      `import ${
+        [defaultImport, namedImports.length > 0 ? `{ ${namedImports} }` : ""]
+          .filter((x) => x.length > 0)
+          .join(", ")
+      } from ${JSON.stringify(module)};`
+    ),
+    join("\n"),
+  );
+
+/**
+ * Converts import mappings to named import string with aliases.
+ * Creates proper ES module named import syntax, using aliases when the import name differs from the local name.
+ *
+ * @param imports - A record mapping import names to their local aliases
+ * @returns A comma-separated string of named imports with aliases where needed
+ */
+export const getAlias = (imports: Record<string, string>) =>
+  pipe(
+    imports,
+    entries,
+    map(([name, alias]) => name === alias ? name : `${name} as ${alias}`),
+    join(", "),
+  );
+
+/**
+ * Converts Node.js environment variable access to Deno-compatible syntax when needed.
+ * Transforms `process.env.VAR_NAME` to `Deno.env.get("VAR_NAME")` for Deno projects.
+ *
+ * @param obj - The object string containing potential environment variable references
+ * @param pm - The package manager (runtime) being used
+ * @returns The converted object string with appropriate environment variable access syntax
+ */
+export const convertEnv = (obj: string, pm: PackageManager) =>
+  pm === "deno" && /process\.env\.(\w+)/.test(obj)
+    ? obj.replaceAll(/process\.env\.(\w+)/, (_, g1) => `Deno.env.get("${g1}")`)
+    : obj;

package/src/init/action/utils.ts

@@ -0,0 +1,64 @@
+import { join as joinPath } from "node:path";
+import type { InitCommandData } from "../types.ts";
+
+export const isDry = ({ dryRun }: InitCommandData) => dryRun;
+
+export const hasCommand = (data: InitCommandData) => !!data.initializer.command;
+
+export const isDeno = (
+  { packageManager }: InitCommandData,
+) => packageManager === "deno";
+
+export const joinDir =
+  (dir: string) => ([filename, content]: readonly [string, string | object]) =>
+    [joinPath(dir, ...filename.split("/")), content] as [
+      string,
+      string | object,
+    ];
+
+/**
+ * Stringify an object into a valid `.env` file format.
+ * From `@std/dotenv/stringify`.
+ *
+ * @example Usage
+ * ```ts
+ * import { stringifyEnvs } from "./utils.ts";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const object = { GREETING: "hello world" };
+ * assertEquals(stringifyEnvs(object), "GREETING='hello world'");
+ * ```
+ *
+ * @param object object to be stringified
+ * @returns string of object
+ */
+export function stringifyEnvs(object: Record<string, string>): string {
+  const lines: string[] = [];
+  for (const [key, value] of Object.entries(object)) {
+    let quote;
+
+    let escapedValue = value ?? "";
+    if (key.startsWith("#")) {
+      // deno-lint-ignore no-console
+      console.warn(
+        `key starts with a '#' indicates a comment and is ignored: '${key}'`,
+      );
+      continue;
+    } else if (escapedValue.includes("\n") || escapedValue.includes("'")) {
+      // escape inner new lines
+      escapedValue = escapedValue.replaceAll("\n", "\\n");
+      quote = `"`;
+    } else if (escapedValue.match(/\W/)) {
+      quote = "'";
+    }
+
+    if (quote) {
+      // escape inner quotes
+      escapedValue = escapedValue.replaceAll(quote, `\\${quote}`);
+      escapedValue = `${quote}${escapedValue}${quote}`;
+    }
+    const line = `${key}=${escapedValue}`;
+    lines.push(line);
+  }
+  return lines.join("\n");
+}

package/src/init/ask/dir.ts

@@ -0,0 +1,98 @@
+import { identity, pipe, when } from "@fxts/core";
+import { input } from "@inquirer/prompts";
+import { message } from "@optique/core/message";
+import { printError } from "@optique/run";
+import toggle from "inquirer-toggle";
+import { getCwd, getOsType, runSubCommand } from "../../utils.ts";
+import { isDirectoryEmpty, logger } from "../lib.ts";
+
+/**
+ * Fills in the project directory by prompting the user if not provided.
+ * If the directory is not empty, asks the user whether to use it anyway.
+ * If the user agrees, offers to move existing contents to trash.
+ * Else, recursively prompts for a new directory until a valid one is provided.
+ *
+ * @param options - Initialization options possibly containing a directory
+ * @returns A promise resolving to options with a guaranteed directory
+ */
+const fillDir: <T extends { dir?: string }>(
+  options: T,
+) => Promise<T & { dir: string }> = async (options) => {
+  const dir = options.dir ?? await askDir(getCwd());
+  return await askIfNonEmpty(dir)
+    ? { ...options, dir }
+    : await fillDir(options);
+};
+
+export default fillDir;
+
+const askDir = (cwd: string) =>
+  input({ message: "Project directory:", default: cwd });
+
+const askIfNonEmpty = async (dir: string) => {
+  if (await isDirectoryEmpty(dir)) return true;
+  if (await askNonEmpty(dir)) return await moveDirToTrash(dir);
+  return false;
+};
+
+const askNonEmpty = (dir: string) =>
+  toggle.default({
+    message: `Directory "${dir}" is not empty.
+Do you want to use it anyway?`,
+    default: false,
+  });
+
+const moveDirToTrash = (dir: string) =>
+  pipe(dir, askMoveToTrash, when(identity, moveToTrash(dir)));
+
+const askMoveToTrash = (dir: string) =>
+  toggle.default({
+    message: `Do you want to move the contents of "${dir}" to the trash?
+If you choose "No", you should choose another directory.`,
+    default: false,
+  });
+
+const moveToTrash = (dir: string) => () =>
+  pipe(
+    getOsType(),
+    getTrashCommand,
+    (fn) => fn(dir),
+    (cmd) => runSubCommand(cmd, { stdio: "ignore" }),
+    () => true,
+  ).catch((e) => {
+    logger.error(e);
+    printError(message`Failed to move ${dir} to trash.
+Please move it manually.`);
+    return false;
+  });
+
+const getTrashCommand = (os: NodeJS.Platform) =>
+  trashCommands[os as keyof typeof trashCommands] ?? trashCommands.linux;
+
+const trashCommands: Record<
+  Extract<NodeJS.Platform, "darwin" | "win32" | "linux">,
+  (dir: string) => string[]
+> = {
+  // mac
+  darwin: (dir: string) => ["trash", dir],
+  // windows
+  win32: (dir: string) => [
+    "powershell",
+    "-Command",
+    getPowershellTrashCommand(dir),
+  ],
+  // other unix
+  linux: (dir: string) => ["rm", "-rf", dir],
+};
+
+const getPowershellTrashCommand = (dir: string) =>
+  [
+    "Add-Type",
+    "-AssemblyName",
+    "Microsoft.VisualBasic;",
+    "[Microsoft.VisualBasic.FileIO.FileSystem]::DeleteDirectory('",
+    dir,
+    "',",
+    "'OnlyErrorDialogs',",
+    "'SendToRecycleBin')",
+  ].join(" ");

package/src/init/ask/kv.ts

@@ -0,0 +1,39 @@
+import { select } from "@inquirer/prompts";
+import { KV_STORE } from "../const.ts";
+import { kvStores } from "../lib.ts";
+import type { KvStore, PackageManager } from "../types.ts";
+
+/**
+ * Fills in the key-value store by prompting the user if not provided.
+ * Ensures the selected KV store is compatible with the chosen package manager.
+ *
+ * @param options - Initialization options possibly containing a kvStore and packageManager
+ * @returns A promise resolving to options with a guaranteed kvStore
+ */
+const fillKvStore: //
+  <T extends { kvStore?: KvStore; packageManager: PackageManager }>(
+    options: T,
+  ) => Promise<T & { kvStore: KvStore }> = async (options) => //
+  ({
+    ...options,
+    kvStore: options.kvStore ?? await askKvStore(options.packageManager),
+  });
+
+export default fillKvStore;
+
+const askKvStore = (pm: PackageManager) =>
+  select<KvStore>({
+    message: "Choose the key-value store to use",
+    choices: KV_STORE.map(choiceKvStore(pm)),
+  });
+
+const choiceKvStore = (pm: PackageManager) => (value: KvStore) => ({
+  name: isKvSupportsPm(value, pm)
+    ? value
+    : `${value} (not supported with ${pm})`,
+  value,
+  disabled: !isKvSupportsPm(value, pm),
+});
+
+const isKvSupportsPm = (kv: KvStore, pm: PackageManager) =>
+  kvStores[kv].packageManagers.includes(pm);

package/src/init/ask/mod.ts

@@ -0,0 +1,23 @@
+import { pipe } from "@fxts/core";
+import type { RequiredNotNull } from "../../utils.ts";
+import type { InitCommand } from "../command.ts";
+import fillDir from "./dir.ts";
+import fillKvStore from "./kv.ts";
+import fillMessageQueue from "./mq.ts";
+import fillPackageManager from "./pm.ts";
+import fillWebFramework from "./wf.ts";
+
+const askOptions: (
+  options: InitCommand,
+) => Promise<RequiredNotNull<InitCommand>> = //
+  (options) =>
+    pipe(
+      options,
+      fillDir,
+      fillWebFramework,
+      fillPackageManager,
+      fillMessageQueue,
+      fillKvStore,
+    );
+
+export default askOptions;

package/src/init/ask/mq.ts

@@ -0,0 +1,37 @@
+import { select } from "@inquirer/prompts";
+import { MESSAGE_QUEUE } from "../const.ts";
+import { messageQueues } from "../lib.ts";
+import type { MessageQueue, PackageManager } from "../types.ts";
+
+/**
+ * Fills in the message queue by prompting the user if not provided.
+ * Ensures the selected message queue is compatible with the chosen package manager.
+ *
+ * @param options - Initialization options possibly containing a messageQueue and packageManager
+ * @returns A promise resolving to options with a guaranteed messageQueue
+ */
+const fillMessageQueue: //
+  <T extends { messageQueue?: MessageQueue; packageManager: PackageManager }> //
+  (options: T) => Promise<T & { messageQueue: MessageQueue }> = //
+  async (options) => ({
+    ...options,
+    messageQueue: options.messageQueue ??
+      await askMessageQueue(options.packageManager),
+  });
+
+export default fillMessageQueue;
+
+const askMessageQueue = (pm: PackageManager) =>
+  select<MessageQueue>({
+    message: "Choose the message queue to use",
+    choices: MESSAGE_QUEUE.map(choiceMessageQueue(pm)),
+  });
+const choiceMessageQueue = (pm: PackageManager) => (value: MessageQueue) => ({
+  name: isMqSupportsPm(value, pm)
+    ? value
+    : `${value} (not supported with ${pm})`,
+  value,
+  disabled: !isMqSupportsPm(value, pm),
+});
+const isMqSupportsPm = (mq: MessageQueue, pm: PackageManager) =>
+  messageQueues[mq].packageManagers.includes(pm);

package/src/init/ask/pm.ts

@@ -0,0 +1,58 @@
+import { select } from "@inquirer/prompts";
+import { message } from "@optique/core/message";
+import { print } from "@optique/run";
+import { PACKAGE_MANAGER } from "../const.ts";
+import { getInstallUrl, getLabel, isPackageManagerAvailable } from "../lib.ts";
+import type { PackageManager, WebFramework } from "../types.ts";
+import webFrameworks from "../webframeworks.ts";
+
+/**
+ * Fills in the package manager by prompting the user if not provided.
+ * Ensures the selected package manager is compatible with the chosen web framework.
+ * If the selected package manager is not installed, informs the user and prompts again.
+ *
+ * @param options - Initialization options possibly containing a packageManager and webFramework
+ * @returns A promise resolving to options with a guaranteed packageManager
+ */
+const fillPackageManager: //
+  <T extends { packageManager?: PackageManager; webFramework: WebFramework }> //
+  (options: T) => //
+  Promise<Omit<T, "packageManager"> & { packageManager: PackageManager }> = //
+  async ({ packageManager, ...options }) => {
+    const pm = packageManager ?? await askPackageManager(options.webFramework);
+    if (await isPackageManagerAvailable(pm)) {
+      return ({ ...options, packageManager: pm });
+    }
+    noticeInstallUrl(pm);
+    return await fillPackageManager(options) as //
+    typeof options & { packageManager: PackageManager };
+  };
+
+export default fillPackageManager;
+
+const askPackageManager = (wf: WebFramework) =>
+  select<PackageManager>({
+    message: "Choose the package manager to use",
+    choices: PACKAGE_MANAGER.map(choicePackageManager(wf)),
+  });
+
+const choicePackageManager = (wf: WebFramework) => (value: PackageManager) => ({
+  name: isWfSupportsPm(wf, value)
+    ? value
+    : `${value} (not supported with ${webFrameworks[wf].label})`,
+  value,
+  disabled: !isWfSupportsPm(wf, value),
+});
+
+const isWfSupportsPm = (
+  wf: WebFramework,
+  pm: PackageManager,
+) => webFrameworks[wf].packageManagers.includes(pm);
+
+const noticeInstallUrl = (pm: PackageManager) => {
+  const label = getLabel(pm);
+  const url = getInstallUrl(pm);
+  print(message`  Package manager ${label} is not installed.`);
+  print(message`  You can install it from following link: ${url}`);
+  print(message`  or choose another package manager:`);
+};

package/src/init/ask/wf.ts

@@ -0,0 +1,27 @@
+import { select } from "@inquirer/prompts";
+import { WEB_FRAMEWORK } from "../const.ts";
+import type { WebFramework } from "../types.ts";
+import webFrameworks from "../webframeworks.ts";
+
+/**
+ * Fills in the web framework by prompting the user if not provided.
+ *
+ * @param options - Initialization options possibly containing a webFramework
+ * @returns A promise resolving to options with a guaranteed webFramework
+ */
+const fillWebFramework: //
+  <T extends { webFramework?: WebFramework }>(options: T) => //
+  Promise<T & { webFramework: WebFramework }> = async (options) => //
+  ({
+    ...options,
+    webFramework: options.webFramework ?? await askWebFramework(),
+  });
+
+export default fillWebFramework;
+
+const askWebFramework = () =>
+  select<WebFramework>({
+    message: "Choose the web framework to use",
+    choices: WEB_FRAMEWORK.map((value) => //
+    ({ name: webFrameworks[value].label, value })),
+  });

package/src/init/command.ts

@@ -0,0 +1,64 @@
+import {
+  argument,
+  choice,
+  command,
+  constant,
+  type InferValue,
+  message,
+  object,
+  option,
+  optional,
+} from "@optique/core";
+import { path } from "@optique/run";
+import {
+  KV_STORE,
+  MESSAGE_QUEUE,
+  PACKAGE_MANAGER,
+  WEB_FRAMEWORK,
+} from "./const.ts";
+
+const joinSep = (str: readonly string[]) => str.join(" | ");
+const webFramework = optional(option(
+  "-w",
+  "--web-framework",
+  choice(WEB_FRAMEWORK, {
+    metavar: `WEB_FRAMEWORK: ${joinSep(WEB_FRAMEWORK)}`,
+  }),
+));
+const packageManager = optional(option(
+  "-p",
+  "--package-manager",
+  choice(PACKAGE_MANAGER, {
+    metavar: `PACKAGE_MANAGER: ${joinSep(PACKAGE_MANAGER)}`,
+  }),
+));
+const kvStore = optional(option(
+  "-k",
+  "--kv-store",
+  choice(KV_STORE, { metavar: `KV_STORE: ${joinSep(KV_STORE)}` }),
+));
+const messageQueue = optional(option(
+  "-m",
+  "--message-queue",
+  choice(MESSAGE_QUEUE, {
+    metavar: `MESSAGE_QUEUE: ${joinSep(MESSAGE_QUEUE)}`,
+  }),
+));
+
+export const initCommand = command(
+  "init",
+  object({
+    command: constant("init"),
+    dir: optional(argument(path({ metavar: "DIRECTORY" }))),
+    webFramework,
+    packageManager,
+    kvStore,
+    messageQueue,
+    dryRun: option("-d", "--dry-run"),
+  }),
+  {
+    description: message`Initialize a new Fedify project directory.`,
+  },
+);
+
+export type InitCommand = InferValue<typeof initCommand>;

package/src/init/const.ts

@@ -0,0 +1,4 @@
+export const PACKAGE_MANAGER = ["deno", "pnpm", "bun", "yarn", "npm"] as const;
+export const WEB_FRAMEWORK = ["hono", "nitro", "next", "express"] as const;
+export const MESSAGE_QUEUE = ["denokv", "redis", "postgres", "amqp"] as const;
+export const KV_STORE = ["denokv", "redis", "postgres"] as const;

package/src/init/json/biome.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.8.3/schema.json",
+  "organizeImports": {
+    "enabled": true
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  }
+}

package/src/init/json/kv.json

@@ -0,0 +1,39 @@
+{
+  "redis": {
+    "label": "Redis",
+    "packageManagers": ["deno", "bun", "npm", "yarn", "pnpm"],
+    "dependencies": {
+      "npm:ioredis": "^5.4.1"
+    },
+    "imports": {
+      "@fedify/redis": { "RedisKvStore": "RedisKvStore" },
+      "ioredis": { "Redis": "Redis" }
+    },
+    "object": "new RedisKvStore(new Redis(process.env.REDIS_URL))",
+    "env": {
+      "REDIS_URL": "redis://localhost:6379"
+    }
+  },
+  "postgres": {
+    "label": "PostgreSQL",
+    "packageManagers": ["deno", "bun", "npm", "yarn", "pnpm"],
+    "dependencies": {
+      "npm:postgres": "^3.4.5"
+    },
+    "imports": {
+      "@fedify/postgres": { "PostgresKvStore": "PostgresKvStore" },
+      "postgres": { "default": "postgres" }
+    },
+    "object": "new PostgresKvStore(postgres(process.env.DATABASE_URL))",
+    "env": {
+      "DATABASE_URL": "postgres://postgres@localhost:5432/postgres"
+    }
+  },
+  "denokv": {
+    "label": "Deno KV",
+    "packageManagers": ["deno"],
+    "imports": { "@fedify/denokv": { "DenoKvStore": "DenoKvStore" } },
+    "object": "new DenoKvStore(await Deno.openKv())",
+    "denoUnstable": ["kv"]
+  }
+}

package/src/init/json/mq.json

@@ -0,0 +1,95 @@
+{
+  "redis": {
+    "label": "Redis",
+    "packageManagers": [
+      "deno",
+      "bun",
+      "npm",
+      "yarn",
+      "pnpm"
+    ],
+    "dependencies": {
+      "npm:ioredis": "^5.4.1"
+    },
+    "imports": {
+      "@fedify/redis": {
+        "RedisMessageQueue": "RedisMessageQueue"
+      },
+      "ioredis": {
+        "Redis": "Redis"
+      }
+    },
+    "object": "new RedisMessageQueue(() => new Redis(process.env.REDIS_URL))",
+    "env": {
+      "REDIS_URL": "redis://localhost:6379"
+    }
+  },
+  "postgres": {
+    "label": "PostgreSQL",
+    "packageManagers": [
+      "deno",
+      "bun",
+      "npm",
+      "yarn",
+      "pnpm"
+    ],
+    "dependencies": {
+      "npm:postgres": "^3.4.5"
+    },
+    "imports": {
+      "@fedify/postgres": {
+        "PostgresMessageQueue": "PostgresMessageQueue"
+      },
+      "postgres": {
+        "default": "postgres"
+      }
+    },
+    "object": "new PostgresMessageQueue(postgres(process.env.DATABASE_URL))",
+    "env": {
+      "DATABASE_URL": "postgres://postgres@localhost:5432/postgres"
+    }
+  },
+  "amqp": {
+    "label": "AMQP (e.g., RabbitMQ)",
+    "packageManagers": [
+      "deno",
+      "bun",
+      "npm",
+      "yarn",
+      "pnpm"
+    ],
+    "dependencies": {
+      "npm:amqplib": "^0.10.4"
+    },
+    "devDependencies": {
+      "npm:@types/amqplib": "^0.10.5"
+    },
+    "imports": {
+      "@fedify/amqp": {
+        "AmqpMessageQueue": "AmqpMessageQueue"
+      },
+      "amqplib": {
+        "connect": "connect"
+      }
+    },
+    "object": "new AmqpMessageQueue(await connect(process.env.AMQP_URL))",
+    "env": {
+      "AMQP_URL": "amqp://localhost"
+    }
+  },
+  "denokv": {
+    "label": "Deno KV",
+    "packageManagers": [
+      "deno"
+    ],
+    "imports": {
+      "@fedify/denokv": {
+        "DenoKvMessageQueue": "DenoKvMessageQueue"
+      }
+    },
+    "object": "new DenoKvMessageQueue(await Deno.openKv())",
+    "denoUnstable": [
+      "kv"
+    ]
+  }
+}