@fedify/cli 1.8.11 → 2.0.0-dev.1757

package/src/init/action/dir.ts

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

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

@@ -0,0 +1,59 @@
+import { always, concat, pipe, tap, toArray, unless, when } from "@fxts/core";
+import { notEmpty, runSubCommand, set } from "../../utils.ts";
+import type { InitCommandData } from "../types.ts";
+import {
+  getAddDepsArgs,
+  getDependencies,
+  getDevDependencies,
+  joinDepsVer,
+} from "./deps.ts";
+import { noticeErrorWhileAddDeps } from "./notice.ts";
+import { isDeno } from "./utils.ts";
+
+const installDependencies = (data: InitCommandData) =>
+  pipe(
+    data,
+    tap(installDeps),
+    unless(isDeno, tap(installDevDeps)),
+  );
+
+export default installDependencies;
+
+type Deps = Record<string, string>;
+
+const installDeps = (data: InitCommandData) =>
+  pipe(
+    data,
+    set("dependencies", getDependencies),
+    getAddDepsCommand,
+    when(notEmpty, runAddDeps(data)),
+  );
+
+const installDevDeps = (data: InitCommandData) =>
+  pipe(
+    data,
+    set("dependencies", getDevDependencies),
+    set("dev", always(true)),
+    getAddDepsCommand,
+    when(notEmpty, runAddDeps(data)),
+  );
+
+const getAddDepsCommand = <
+  T extends InitCommandData & {
+    dependencies: Deps;
+    dev?: boolean;
+  },
+>(data: T) =>
+  pipe(
+    data,
+    joinDepsVer,
+    when(notEmpty<string[]>, concat(getAddDepsArgs(data))),
+    toArray,
+  );
+
+const runAddDeps =
+  <T extends { dir: string }>({ dir }: T) => (command: string[]) =>
+    runSubCommand(command, {
+      cwd: dir,
+      stdio: "inherit",
+    }).catch(noticeErrorWhileAddDeps(command));

package/src/init/action/mod.ts

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

@@ -0,0 +1,101 @@
+import { message } from "@optique/core";
+import { print, printError } from "@optique/run";
+import { flow } from "es-toolkit";
+import { colors, type RequiredNotNull } from "../../utils.ts";
+import type { InitCommand } from "../command.ts";
+import type { InitCommandData } from "../types.ts";
+
+type PrintMessage = (...args: Parameters<typeof message>) => void;
+const printMessage: PrintMessage = flow(message, print);
+const printErrorMessage: PrintMessage = flow(message, printError);
+
+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`  ${key}=${value}`;
+
+export function noticeHowToRun(
+  { initializer: { instruction, federationFile } }: InitCommandData,
+) {
+  printMessage`${instruction}`;
+  printMessage`Start by editing the ${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

@@ -0,0 +1,212 @@
+import { apply, entries, forEach, pipe, pipeLazy, tap } from "@fxts/core";
+import { toMerged } from "es-toolkit";
+import { readFile } from "node:fs/promises";
+import { formatJson, merge, 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 Node.js/Bun 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,
+    }
+    : {
+      "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.
+ * This allows users to 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 (non-dry-run) 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>;
+}
+
+/**
+ * Higher-order function that processes all files with a given processing function.
+ * Takes a processing function (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,
+    forEach(
+      pipeLazy(
+        joinDir(dir),
+        apply(patchContent),
+        apply(process),
+      ),
+    ),
+  );
+
+/**
+ * Patches file content by either merging JSON objects 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.
+ *
+ * @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(prev) : {}, merge(data), formatJson);
+
+/**
+ * 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
+ */
+async function readFileIfExists(path: string): Promise<string> {
+  try {
+    return await readFile(path, "utf8");
+  } catch (e) {
+    throwUnlessNotExists(e);
+    return "";
+  }
+}

package/src/init/action/precommand.ts

@@ -0,0 +1,22 @@
+import { 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) => {
+    console.error("Failed to run the precommand:", e);
+    exit(1);
+  });
+
+export default runPrecommand;

package/src/init/action/recommend.ts

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

package/src/init/action/set.ts

@@ -0,0 +1,78 @@
+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,
+  PackageManager,
+} 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 {
+    webFramework: keyof typeof webFrameworks;
+    projectName: string;
+    packageManager: PackageManager;
+  },
+>({
+  webFramework,
+  projectName,
+  packageManager,
+}: T) =>
+  webFrameworks[webFramework].init(
+    projectName,
+    packageManager,
+  ));
+
+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),
+);