@fedify/cli 2.0.0-pr.479.1922 → 2.0.1

package/src/init/action/deps.ts

@@ -1,161 +0,0 @@
-import {
-  always,
-  entries,
-  filter,
-  fromEntries,
-  map,
-  pipe,
-  when,
-} from "@fxts/core";
-import { join as joinPath } from "node:path";
-import { merge, replace } from "../../utils.ts";
-import { PACKAGE_VERSION } from "../lib.ts";
-import type { InitCommandData, PackageManager } from "../types.ts";
-import { PACKAGES_PATH } from "./const.ts";
-import { isDeno } from "./utils.ts";
-
-type Deps = Record<string, string>;
-
-/**
- * Gathers all dependencies required for the project based on the initializer,
- * key-value store, and message queue configurations.
- *
- * @param data - Web Framework initializer, key-value store and
- *               message queue descriptions
- * @returns A record of dependencies with their versions
- */
-export const getDependencies = (
-  { initializer, kv, mq, testMode, packageManager }: Pick<
-    InitCommandData,
-    "initializer" | "kv" | "mq" | "packageManager" | "testMode"
-  >,
-): Deps =>
-  pipe(
-    {
-      "@fedify/fedify": PACKAGE_VERSION,
-      "@logtape/logtape": "^1.1.0",
-    },
-    merge(initializer.dependencies),
-    merge(kv.dependencies),
-    merge(mq.dependencies),
-    when(
-      always(testMode),
-      isDeno({ packageManager }) ? removeFedifyDeps : addLocalFedifyDeps,
-    ),
-    normalizePackageNames(packageManager),
-  );
-
-const removeFedifyDeps = (deps: Deps): Deps =>
-  pipe(
-    deps,
-    entries,
-    filter(([name]) => !name.includes("@fedify")),
-    fromEntries,
-  );
-
-const addLocalFedifyDeps = (deps: Deps): Deps =>
-  pipe(
-    deps,
-    entries,
-    map(when(
-      ([name]) => name.includes("@fedify/"),
-      (
-        [name, _version],
-      ): [string, string] => [name, convertFedifyToLocal(name)],
-    )),
-    fromEntries,
-  );
-
-const convertFedifyToLocal = (name: string): string =>
-  pipe(
-    name,
-    replace("@fedify/", ""),
-    (pkg) => joinPath(PACKAGES_PATH, pkg),
-  );
-
-/** Gathers all devDependencies required for the project based on the
- * initializer, key-value store, and message queue configurations,
- * including Biome for linting/formatting.
- *
- * @param data - Web Framework initializer, key-value store
- *               and message queue descriptions
- * @returns A record of devDependencies with their versions
- */
-export const getDevDependencies = (
-  { initializer, kv, mq, packageManager }: Pick<
-    InitCommandData,
-    "initializer" | "kv" | "mq" | "packageManager"
-  >,
-): Deps =>
-  pipe(
-    {
-      "@biomejs/biome": "^2.2.4",
-    },
-    merge(initializer.devDependencies),
-    merge(kv.devDependencies),
-    merge(mq.devDependencies),
-    normalizePackageNames(packageManager),
-  );
-
-/**
- * Generates the command-line arguments needed to add dependencies
- * or devDependencies using the specified package manager.
- * If it is devDependencies, the '-D' flag is included.
- *
- * @param param0 - Object containing the package manager and a boolean
- *                 indicating if dev dependencies are to be added
- * @yields The command-line arguments as strings
- */
-export function* getAddDepsArgs<
-  T extends { packageManager: PackageManager; dev?: boolean },
->({ packageManager, dev = false }: T): Generator<string> {
-  yield packageManager;
-  yield "add";
-  if (dev) yield "-D";
-}
-
-/**
- * Joins package names with their versions for installation dependencies.
- * For Deno, it prefixes packages with 'jsr:'
- * unless they already start with 'npm:' or 'jsr:'.
- *
- * @param data - Package manager and dependencies to be joined with versions
- * @returns \{ name: `${registry}:${package}@${version}` } for deno
- */
-export const joinDepsReg = (pm: PackageManager) => //
-(dependencies: Deps): Deps =>
-  pipe(
-    dependencies,
-    entries,
-    map(([name, version]): [string, string] => [
-      name.substring(4),
-      `${name}@${getPackageVersion(pm, version)}`,
-    ]),
-    fromEntries,
-  );
-
-const getPackageVersion = (pm: PackageManager, version: string) =>
-  pm !== "deno" && version.includes("+")
-    ? version.substring(0, version.indexOf("+"))
-    : version;
-
-const normalizePackageNames = (pm: PackageManager) => (deps: Deps): Deps =>
-  pipe(
-    deps,
-    entries,
-    map(([name, version]): [string, string] => [
-      getPackageName(pm, name),
-      version,
-    ]),
-    fromEntries,
-  );
-
-const getPackageName = (pm: PackageManager, name: string) =>
-  pm !== "deno"
-    ? name.startsWith("npm:")
-      ? name.replace("npm:", "") // not deno, have npm: prefix, remove it
-      : name // not deno, no prefix, keep it
-    : name.startsWith("npm:")
-    ? name // deno, have npm: prefix, keep it
-    : `jsr:${name}` // deno, no prefix, add jsr: prefix
-;

package/src/init/action/dir.ts

@@ -1,11 +0,0 @@
-import { mkdir } from "node:fs/promises";
-import type { InitCommandData } from "../types.ts";
-
-/**
- * Creates the target directory if it does not exist.
- *
- * @param data - The directory
- * @returns A promise that resolves when the directory is created
- */
-export const makeDirIfHyd = ({ dir }: InitCommandData): //
-Promise<string | undefined> => mkdir(dir, { recursive: true });

package/src/init/action/env.ts

@@ -1,14 +0,0 @@
-import { entries, forEach, pipeLazy, tap, toArray, when } from "@fxts/core";
-import { notEmpty } from "../../utils.ts";
-import type { InitCommandIo } from "../types.ts";
-import { noticeConfigEnv, noticeEnvKeyValue } from "./notice.ts";
-
-const recommendConfigEnv: InitCommandIo = pipeLazy(
-  (data) => data.env,
-  entries,
-  toArray<Iterable<[string, string]>>,
-  when(notEmpty, tap<[string, string][], void>(noticeConfigEnv)),
-  forEach(noticeEnvKeyValue),
-);
-
-export default recommendConfigEnv;

package/src/init/action/install.ts

@@ -1,24 +0,0 @@
-import { apply, pipe } from "@fxts/core";
-import { CommandError, runSubCommand } from "../../utils.ts";
-import type { InitCommandData } from "../types.ts";
-
-const installDependencies = (data: InitCommandData) =>
-  pipe(
-    data,
-    ({ packageManager, dir }) =>
-      [[packageManager, "install"], { cwd: dir }] as //
-      Parameters<typeof runSubCommand>,
-    apply(runSubCommand),
-  ).catch((e) => {
-    if (e instanceof CommandError) {
-      console.error(
-        `Failed to install dependencies using ${data.packageManager}.`,
-      );
-      console.error("Command:", e.commandLine);
-      if (e.stderr) console.error("Error:", e.stderr);
-      throw e;
-    }
-    throw e;
-  });
-
-export default installDependencies;

package/src/init/action/mod.ts

@@ -1,66 +0,0 @@
-import { pipe, tap, unless, when } from "@fxts/core";
-import askOptions from "../ask/mod.ts";
-import type { InitCommand } from "../command.ts";
-import type { InitCommandData } from "../types.ts";
-import { makeDirIfHyd } from "./dir.ts";
-import recommendConfigEnv from "./env.ts";
-import installDependencies from "./install.ts";
-import {
-  drawDinosaur,
-  noticeHowToRun,
-  noticeOptions,
-  noticePrecommand,
-} from "./notice.ts";
-import { patchFiles, recommendPatchFiles } from "./patch.ts";
-import runPrecommand from "./precommand.ts";
-import recommendDependencies from "./recommend.ts";
-import setData from "./set.ts";
-import { hasCommand, isDry } from "./utils.ts";
-
-/**
- *             options: InitCommand
- *                ├ drawDinosaur
- *          ┌─────┴──────┐
- *          │ askOptions │ InitCommand -> InitCommandOptions
- *          └─────┬──────┘
- *                ├ noticeOptions
- *           ┌────┴────┐
- *           │ setData │ InitCommandOptions -> InitCommandData
- *           └────┬────┘
- *              ┌─┴─┐ isDry
- * handleDryRun ┤   ├ handleHydRun
- *              └─┬─┘
- *                ├ recommendConfigEnv
- *                ├ noticeHowToRun
- */
-const runInit = (options: InitCommand) =>
-  pipe(
-    options,
-    tap(drawDinosaur),
-    askOptions,
-    tap(noticeOptions),
-    setData,
-    when(isDry, handleDryRun),
-    unless(isDry, handleHydRun),
-    tap(recommendConfigEnv),
-    tap(noticeHowToRun),
-  );
-
-export default runInit;
-
-const handleDryRun = (data: InitCommandData) =>
-  pipe(
-    data,
-    tap(when(hasCommand, noticePrecommand)),
-    tap(recommendPatchFiles),
-    tap(recommendDependencies),
-  );
-
-const handleHydRun = (data: InitCommandData) =>
-  pipe(
-    data,
-    tap(makeDirIfHyd),
-    tap(when(hasCommand, runPrecommand)),
-    tap(patchFiles),
-    tap(installDependencies),
-  );

package/src/init/action/notice.ts

@@ -1,103 +0,0 @@
-import { text } from "@optique/core";
-import { flow } from "es-toolkit";
-import {
-  colors,
-  printErrorMessage,
-  printMessage,
-  type RequiredNotNull,
-} from "../../utils.ts";
-import type { InitCommand } from "../command.ts";
-import type { InitCommandData } from "../types.ts";
-
-export function drawDinosaur() {
-  const d = flow(colors.bgBlue, colors.black);
-  const f = colors.blue;
-  console.error(`\
-${d("             ___   ")}  ${f(" _____        _ _  __")}
-${d("            /'_')  ")}  ${f("|  ___|__  __| (_)/ _|_   _")}
-${d("     .-^^^-/  /    ")}  ${f("| |_ / _ \\/ _` | | |_| | | |")}
-${d("   __/       /     ")}  ${f("|  _|  __/ (_| | |  _| |_| |")}
-${d("  <__.|_|-|_|      ")}  ${f("|_|  \\___|\\__,_|_|_|  \\__, |")}
-${d("                   ")}  ${f("                      |___/")}
-`);
-}
-
-export const noticeOptions: (options: RequiredNotNull<InitCommand>) => void = (
-  {
-    packageManager,
-    webFramework,
-    kvStore,
-    messageQueue,
-  },
-) =>
-  printMessage`
-  Package manager: ${packageManager};
-  Web framework: ${webFramework};
-  Key–value store: ${kvStore};
-  Message queue: ${messageQueue};
-`;
-
-export const noticeDry = () =>
-  printMessage`🔍 DRY RUN MODE - No files will be created\n`;
-
-export function noticePrecommand({
-  initializer: { command },
-  dir,
-}: InitCommandData) {
-  printMessage`📦 Would run command:`;
-  printMessage`  cd ${dir}`;
-  printMessage`  ${command!.join(" ")}\n`;
-}
-
-export const noticeFilesToCreate = () =>
-  //
-  printMessage`📄 Would create files:\n`;
-
-export const noticeFilesToInsert = () =>
-  printMessage`Would create/update JSON files:\n`;
-
-export const noticeDepsIfExist = () =>
-  printMessage`📦 Would install dependencies:`;
-
-export const noticeDevDepsIfExist = () =>
-  printMessage`📦 Would install dev dependencies:`;
-
-export const noticeDeps = ([name, version]: [string, string]) =>
-  printMessage`${name}@${version}`;
-
-export function displayFile(
-  path: string,
-  content: string,
-  emoji: string = "📄",
-) {
-  printMessage`${emoji} ${path}`;
-  printMessage`${"─".repeat(60)}`;
-  printMessage`${content}`;
-  printMessage`${"─".repeat(60)}\n`;
-}
-
-export const noticeConfigEnv = () =>
-  printMessage`Note that you probably want to edit the ${".env"} file.
-It currently contains the following values:\n`;
-
-export const noticeEnvKeyValue = ([key, value]: [string, string]) => {
-  printMessage`${text(`  ${key}='${value}'`)}`;
-};
-
-export const noticeHowToRun = (
-  { initializer: { instruction, federationFile } }: InitCommandData,
-) =>
-  printMessage`
-${instruction}
-    
-Start by editing the ${text(federationFile)} file to define your federation!
-`;
-
-export function noticeErrorWhileAddDeps(command: string[]) {
-  return (error: unknown) => {
-    printErrorMessage`The command ${command.join(" ")} failed with the error: ${
-      String(error)
-    }`;
-    throw new Error("Failed to add dependencies.");
-  };
-}

package/src/init/action/patch.ts

@@ -1,233 +0,0 @@
-import { always, apply, entries, map, pipe, pipeLazy, tap } from "@fxts/core";
-import { toMerged } from "es-toolkit";
-import { readFile } from "node:fs/promises";
-import { formatJson, merge, replaceAll, set } from "../../utils.ts";
-import { createFile, throwUnlessNotExists } from "../lib.ts";
-import type { InitCommandData } from "../types.ts";
-import {
-  devToolConfigs,
-  loadDenoConfig,
-  loadPackageJson,
-  loadTsConfig,
-} from "./configs.ts";
-import {
-  displayFile,
-  noticeFilesToCreate,
-  noticeFilesToInsert,
-} from "./notice.ts";
-import { getImports, loadFederation, loadLogging } from "./templates.ts";
-import { joinDir, stringifyEnvs } from "./utils.ts";
-
-/**
- * Main function that initializes the project by creating necessary files and configurations.
- * Handles both dry-run mode (recommending files) and actual file creation.
- * Orchestrates the entire file generation and writing process.
- *
- * @param data - The initialization command data containing project
- *               configuration
- * @returns A processed data object with files and JSONs ready for creation
- */
-export const patchFiles = (data: InitCommandData) =>
-  pipe(
-    data,
-    set("files", getFiles),
-    set("jsons", getJsons),
-    createFiles,
-  );
-
-export const recommendPatchFiles = (data: InitCommandData) =>
-  pipe(
-    data,
-    set("files", getFiles),
-    set("jsons", getJsons),
-    recommendFiles,
-  );
-
-/**
- * Generates text-based files (TypeScript, environment files) for the project.
- * Creates federation configuration, logging setup, environment variables, and
- * framework-specific files by processing templates and combining them with
- * project-specific data.
- *
- * @param data - The initialization command data
- * @returns A record of file paths to their string content
- */
-const getFiles = <
-  T extends InitCommandData,
->(data: T) => ({
-  [data.initializer.federationFile]: loadFederation({
-    imports: getImports(data),
-    ...data,
-  }),
-  [data.initializer.loggingFile]: loadLogging(data),
-  ".env": stringifyEnvs(data.env),
-  ...data.initializer.files,
-});
-
-/**
- * Generates JSON configuration files based on the package manager type.
- * Creates different sets of configuration files for Deno vs other environments,
- * including compiler configs, package manifests, and development
- * tool configurations.
- *
- * @param data - The initialization command data
- * @returns A record of file paths to their JSON object content
- */
-const getJsons = <
-  T extends InitCommandData,
->(data: T): Record<string, object> =>
-  data.packageManager === "deno"
-    ? {
-      "deno.json": loadDenoConfig(data).data,
-      [devToolConfigs["vscSetDeno"].path]: devToolConfigs["vscSetDeno"].data,
-      [devToolConfigs["vscExtDeno"].path]: devToolConfigs["vscExtDeno"].data,
-    }
-    : {
-      ...(data.initializer.compilerOptions
-        ? { "tsconfig.json": loadTsConfig(data).data }
-        : {}),
-      "package.json": loadPackageJson(data).data,
-      [devToolConfigs["biome"].path]: devToolConfigs["biome"].data,
-      [devToolConfigs["vscSet"].path]: devToolConfigs["vscSet"].data,
-      [devToolConfigs["vscExt"].path]: devToolConfigs["vscExt"].data,
-    };
-
-/**
- * Handles dry-run mode by recommending files to be created without actually
- * creating them.
- * Displays what files would be created and shows their content for user review,
- * so users can preview the initialization process before committing to it.
- *
- * @param data - The initialization command data with files and JSONs prepared
- * @returns The processed data with recommendations displayed
- */
-const recommendFiles = (data: InitCommandWithFiles) =>
-  pipe(
-    data,
-    tap(noticeFilesToCreate),
-    tap(processAllFiles(displayFile)),
-    tap(noticeFilesToInsert),
-    set("files", ({ jsons }) => jsons),
-    tap(processAllFiles(displayFile)),
-  );
-
-/**
- * Actually creates files on the filesystem during normal execution.
- * Merges text files and JSON files together and writes them to disk.
- * This performs the actual file system operations to initialize the project.
- *
- * @param data - The initialization command data with files and JSONs prepared
- * @returns The processed data after files have been created
- */
-const createFiles = (data: InitCommandWithFiles) =>
-  pipe(
-    data,
-    set("files", ({ jsons, files }) => toMerged(files, jsons)),
-    tap(processAllFiles(createFile)),
-  );
-
-interface InitCommandWithFiles extends InitCommandData {
-  files: Record<string, string>;
-  jsons: Record<string, object>;
-}
-
-/**
- * Processes all files with a given processing function.
- * Takes a processor (either display or create) and applies it to all files
- * in the target directory, handling path resolution and content patching.
- *
- * @param process - Function to process each file (either display or create)
- * @returns A function that processes all files in the given directory with the provided processor
- */
-const processAllFiles = (
-  process: (path: string, content: string) => void | Promise<void>,
-) =>
-({ dir, files }: InitCommandWithFiles) =>
-  pipe(
-    files,
-    entries,
-    map(
-      pipeLazy(
-        joinDir(dir),
-        apply(patchContent),
-        apply(process),
-      ),
-    ),
-    Array.fromAsync,
-  );
-
-/**
- * Patches file content by either merging JSON or appending text content.
- * Handles existing files by reading their current content and intelligently
- * combining it with new content based on the content type (JSON vs text).
- *
- * @param path - The file path to patch
- * @param content - The new content (either string or object)
- * @returns A tuple containing the file path and the final content string
- */
-async function patchContent(
-  path: string,
-  content: string | object,
-): Promise<[string, string]> {
-  const prev = await readFileIfExists(path);
-  const data = typeof content === "object"
-    ? mergeJson(prev, content)
-    : appendText(prev, content);
-  return [path, data];
-}
-
-/**
- * Merges new JSON data with existing JSON content and formats the result.
- * Parses existing JSON content (if any) and deep merges it with new data,
- * then formats the result for consistent output.
- * Supports JSONC (JSON with Comments) by removing comments before parsing.
- *
- * @param prev - The previous JSON content as string
- * @param data - The new data object to merge
- * @returns Formatted JSON string with merged content
- */
-const mergeJson = (prev: string, data: object): string =>
-  pipe(
-    prev ? JSON.parse(removeJsonComments(prev)) : {},
-    merge(data),
-    formatJson,
-  );
-
-/**
- * Removes single-line (//) and multi-line (/* *\/) comments from JSON string.
- * This allows parsing JSONC (JSON with Comments) files.
- *
- * @param jsonString - The JSON string potentially containing comments
- * @returns JSON string with comments removed
- */
-const removeJsonComments = (jsonString: string): string =>
-  pipe(
-    jsonString,
-    replaceAll(/\/\/.*$/gm, ""),
-    replaceAll(/\/\*[\s\S]*?\*\//g, ""),
-  );
-
-/**
- * Appends new text content to existing text content line by line.
- * Concatenates new content lines with existing content lines,
- * preserving line structure and formatting.
- *
- * @param prev - The previous text content
- * @param data - The new text content to append
- * @returns Combined text content as a single string
- */
-const appendText = (prev: string, data: string) =>
-  prev ? `${prev}\n${data}` : data;
-
-/**
- * Safely reads a file if it exists, returns empty string if it doesn't exist.
- * Provides error handling to distinguish between "file not found" and other
- * file system errors, throwing only for unexpected errors.
- *
- * @param path - The file path to read
- * @returns The file content as string, or empty string if file doesn't exist
- * @throws Error if file access fails for reasons other than file not existing
- */
-const readFileIfExists = (path: string): Promise<string> =>
-  readFile(path, "utf8")
-    .catch(pipeLazy(tap(throwUnlessNotExists), always("")));

package/src/init/action/precommand.ts

@@ -1,29 +0,0 @@
-import { CommandError, exit, runSubCommand } from "../../utils.ts";
-import type { InitCommandData } from "../types.ts";
-
-/**
- * Runs the precommand specified in the initializer to set up the project.
- *
- * @param data - The initialization command data containing the initializer command and directory
- * @returns A promise that resolves when the precommand has been executed
- */
-const runPrecommand = ({
-  initializer: { command },
-  dir,
-}: InitCommandData) =>
-  runSubCommand(command!, {
-    cwd: dir,
-    stdio: "inherit",
-  }).catch((e) => {
-    if (e instanceof CommandError) {
-      console.error("Failed to run the precommand.");
-      console.error("Command:", e.commandLine);
-      if (e.stderr) console.error("Error:", e.stderr);
-      if (e.stdout) console.error("Output:", e.stdout);
-    } else {
-      console.error("Failed to run the precommand:", e);
-    }
-    exit(1);
-  });
-
-export default runPrecommand;

package/src/init/action/recommend.ts

@@ -1,38 +0,0 @@
-import { map, peek, pipeLazy, tap, unless, when } from "@fxts/core";
-import { notEmpty } from "../../utils.ts";
-import type { InitCommandIo } from "../types.ts";
-import { getDependencies, getDevDependencies } from "./deps.ts";
-import {
-  noticeDeps,
-  noticeDepsIfExist,
-  noticeDevDepsIfExist,
-} from "./notice.ts";
-import { isDeno } from "./utils.ts";
-
-const recommendDeps: InitCommandIo = pipeLazy(
-  getDependencies,
-  Object.entries<string>,
-  when(notEmpty<[string, string][]>, tap(noticeDepsIfExist)),
-  peek(noticeDeps),
-);
-
-const recommendDevDeps: InitCommandIo = pipeLazy(
-  getDevDependencies,
-  Object.entries<string>,
-  when(notEmpty<[string, string][]>, tap(noticeDevDepsIfExist)),
-  map(noticeDeps),
-);
-
-/**
- * Recommends dependencies and devDependencies to be added to package.json.
- * Skips devDependencies recommendation if the package manager is Deno.
- *
- * @param data - The initialization command data
- * @returns An InitCommandIo function that performs the recommendation
- */
-const recommendDependencies: InitCommandIo = pipeLazy(
-  tap(recommendDeps),
-  unless(isDeno, tap(recommendDevDeps)),
-);
-
-export default recommendDependencies;