@fedify/cli 2.0.0-pr.479.1922 → 2.0.0

package/src/init/action/set.ts

@@ -1,65 +0,0 @@
-import { pipe } from "@fxts/core";
-import { existsSync } from "node:fs";
-import { realpath } from "node:fs/promises";
-import { basename, normalize } from "node:path";
-import { merge, set } from "../../utils.ts";
-import { kvStores, messageQueues } from "../lib.ts";
-import type {
-  InitCommandData,
-  InitCommandOptions,
-  KvStore,
-  KvStoreDescription,
-  MessageQueue,
-  MessageQueueDescription,
-} from "../types.ts";
-import webFrameworks from "../webframeworks.ts";
-
-/**
- * Set all necessary data for initializing the project.
- * This function orchestrates the setting of project name, initializer,
- * key-value store, message queue, and environment variables by calling
- * individual setter functions for each piece of data.
- *
- * @param data - The initial command options provided by the user
- * @returns A promise resolving to a complete InitCommandData object
- */
-const setData = (data: InitCommandOptions): Promise<InitCommandData> =>
-  pipe(
-    data,
-    setProjectName,
-    setInitializer,
-    setKv,
-    setMq,
-    setEnv,
-  );
-
-export default setData;
-
-const setProjectName = set(
-  "projectName",
-  async <
-    T extends { dir: string },
-  >({ dir }: T) =>
-    basename(existsSync(dir) ? await realpath(dir) : normalize(dir)),
-);
-
-const setInitializer = set("initializer", <
-  T extends InitCommandOptions & { projectName: string },
->(data: T) => webFrameworks[data.webFramework].init(data));
-
-const setKv = set("kv", <
-  T extends { kvStore: KvStore },
->({ kvStore }: T) => kvStores[kvStore]);
-
-const setMq = set(
-  "mq",
-  <
-    T extends { messageQueue: MessageQueue },
-  >({ messageQueue }: T) => messageQueues[messageQueue],
-);
-const setEnv = set(
-  "env",
-  <
-    T extends { kv: KvStoreDescription; mq: MessageQueueDescription },
-  >({ kv, mq }: T) => merge(kv.env)(mq.env),
-);

package/src/init/action/templates.ts

@@ -1,96 +0,0 @@
-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(", "),
-  );
-
-const ENV_REG_EXP = /process\.env\.(\w+)/g;
-/**
- * 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" && ENV_REG_EXP.test(obj)
-    ? obj.replaceAll(ENV_REG_EXP, (_, g1) => `Deno.env.get("${g1}")`)
-    : obj;

package/src/init/action/utils.ts

@@ -1,64 +0,0 @@
-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 }: Pick<InitCommandData, "packageManager">,
-) => 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

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

@@ -1,82 +0,0 @@
-import { pipe, tap, throwError, unless, when } from "@fxts/core/index.js";
-import { select } from "@inquirer/prompts";
-import { printErrorMessage } from "../../utils.ts";
-import { KV_STORE } from "../const.ts";
-import { isTest, 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;
-      testMode: boolean;
-    },
-  >(options: T) => Promise<KvDefined<T>> //
- = (options) =>
-  pipe(
-    options,
-    when(isKvStoreEmpty, askKvStore) as <
-      T extends { kvStore?: KvStore; packageManager: PackageManager },
-    >(options: T) => KvDefined<T>,
-    unless(
-      isKvSupportsPm,
-      (opt: KvDefined<typeof options>) =>
-        pipe(
-          opt,
-          when(isTest, throwError(unmatchedWhileTesting)),
-          tap(noticeUnmatched),
-          fillKvStore,
-        ),
-    ),
-  ) as Promise<KvDefined<typeof options>>;
-
-export default fillKvStore;
-
-type KvDefined<T> = Omit<T, "kvStore"> & { kvStore: KvStore };
-
-const isKvStoreEmpty = <T extends { kvStore?: KvStore }>(
-  options: T,
-): options is T & { kvStore: undefined } => !options.kvStore;
-
-const askKvStore = async <
-  T extends { packageManager: PackageManager },
->(data: T): Promise<Omit<T, "kvStore"> & { kvStore: KvStore }> => ({
-  ...data,
-  kvStore: await select<KvStore>({
-    message: "Choose the key-value store to use",
-    choices: KV_STORE.map(choiceKvStore(data.packageManager)),
-  }),
-});
-
-const unmatchedWhileTesting = <
-  T extends { kvStore: KvStore; packageManager: PackageManager },
->({ kvStore: kv, packageManager: pm }: T) =>
-  new Error(
-    `Key-value store '${kv}' is not compatible with package manager '${pm}'`,
-  );
-
-const noticeUnmatched = <
-  T extends { kvStore: KvStore; packageManager: PackageManager },
->({ kvStore: kv, packageManager: pm }: T) =>
-  printErrorMessage`Error: Key-value store '${kv}' is not compatible with package manager '${pm}'`;
-
-const choiceKvStore = (pm: PackageManager) => (kv: KvStore) => ({
-  name: isKvSupportsPm({ kvStore: kv, packageManager: pm })
-    ? kv
-    : `${kv} (not supported with ${pm})`,
-  value: kv,
-  disabled: !isKvSupportsPm({ kvStore: kv, packageManager: pm }),
-});
-
-const isKvSupportsPm = <
-  T extends { kvStore: KvStore; packageManager: PackageManager },
->({ kvStore, packageManager }: T) =>
-  kvStores[kvStore].packageManagers.includes(packageManager);

package/src/init/ask/mod.ts

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

@@ -1,86 +0,0 @@
-import { pipe, tap, throwError, unless, when } from "@fxts/core/index.js";
-import { select } from "@inquirer/prompts";
-import { printErrorMessage } from "../../utils.ts";
-import { MESSAGE_QUEUE } from "../const.ts";
-import { isTest, 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;
-      testMode: boolean;
-    },
-  >(options: T) => Promise<MqDefined<T>> //
- = (options) =>
-  pipe(
-    options,
-    when(isMessageQueueEmpty, askMessageQueue) as <
-      T extends { messageQueue?: MessageQueue; packageManager: PackageManager },
-    >(options: T) => MqDefined<T>,
-    unless(
-      isMqSupportsPm,
-      (opt: MqDefined<typeof options>) =>
-        pipe(
-          opt,
-          when(isTest, throwError(unmatchedWhileTesting)),
-          tap(noticeUnmatched),
-          fillMessageQueue,
-        ),
-    ),
-  ) as Promise<MqDefined<typeof options>>;
-
-export default fillMessageQueue;
-
-type MqDefined<T> = Omit<T, "messageQueue"> & { messageQueue: MessageQueue };
-
-const isMessageQueueEmpty = <T extends { messageQueue?: MessageQueue }>(
-  options: T,
-): options is T & { messageQueue: undefined } => !options.messageQueue;
-
-const askMessageQueue = async <
-  T extends { packageManager: PackageManager },
->(
-  data: T,
-): Promise<Omit<T, "messageQueue"> & { messageQueue: MessageQueue }> => ({
-  ...data,
-  messageQueue: await select<MessageQueue>({
-    message: "Choose the message queue to use",
-    choices: MESSAGE_QUEUE.map(choiceMessageQueue(data.packageManager)),
-  }),
-});
-
-const unmatchedWhileTesting = <
-  T extends { messageQueue: MessageQueue; packageManager: PackageManager },
->({ messageQueue: mq, packageManager: pm }: T) =>
-  new Error(
-    `Message queue '${mq}' is not compatible with package manager '${pm}'`,
-  );
-
-const noticeUnmatched = <
-  T extends { messageQueue: MessageQueue; packageManager: PackageManager },
->({ messageQueue: mq, packageManager: pm }: T) => {
-  printErrorMessage`Error: Message queue '${mq}' is not compatible with package manager '${pm}'`;
-};
-
-const choiceMessageQueue =
-  (packageManager: PackageManager) => (messageQueue: MessageQueue) => ({
-    name: isMqSupportsPm({ messageQueue, packageManager })
-      ? messageQueue
-      : `${messageQueue} (not supported with ${packageManager})`,
-    value: messageQueue,
-    disabled: !isMqSupportsPm({ messageQueue, packageManager }),
-  });
-
-const isMqSupportsPm = <
-  T extends { messageQueue: MessageQueue; packageManager: PackageManager },
->({ messageQueue, packageManager }: T) =>
-  messageQueues[messageQueue].packageManagers.includes(packageManager);

package/src/init/ask/pm.ts

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

@@ -1,27 +0,0 @@
-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 })),
-  });