@fedify/cli 2.0.0-pr.479.1919 → 2.0.0

package/src/init/command.ts

@@ -1,135 +0,0 @@
-import {
-  argument,
-  choice,
-  command,
-  constant,
-  type InferValue,
-  merge,
-  message,
-  multiple,
-  object,
-  option,
-  optional,
-  optionNames,
-  or,
-} from "@optique/core";
-import { path } from "@optique/run";
-import { debugOption } from "../globals.ts";
-import {
-  KV_STORE,
-  MESSAGE_QUEUE,
-  PACKAGE_MANAGER,
-  WEB_FRAMEWORK,
-} from "./const.ts";
-
-const webFramework = optional(option(
-  "-w",
-  "--web-framework",
-  choice(WEB_FRAMEWORK, { metavar: "WEB_FRAMEWORK" }),
-  {
-    description: message`The web framework to integrate Fedify with.`,
-  },
-));
-const packageManager = optional(option(
-  "-p",
-  "--package-manager",
-  choice(PACKAGE_MANAGER, { metavar: "PACKAGE_MANAGER" }),
-  {
-    description:
-      message`The package manager to use for installing dependencies.`,
-  },
-));
-const kvStore = optional(option(
-  "-k",
-  "--kv-store",
-  choice(KV_STORE, { metavar: "KV_STORE" }),
-  {
-    description:
-      message`The key-value store to use for caching and some other features.`,
-  },
-));
-const messageQueue = optional(option(
-  "-m",
-  "--message-queue",
-  choice(MESSAGE_QUEUE, { metavar: "MESSAGE_QUEUE" }),
-  {
-    description: message`The message queue to use for background tasks.`,
-  },
-));
-const testMode = option(
-  "--test-mode",
-  {
-    description: message`The test mode to use for testing purposes.`,
-  },
-);
-
-export const initCommand = command(
-  "init",
-  object("Initialization options", {
-    command: constant("init"),
-    dir: optional(argument(path({ metavar: "DIR" }), {
-      description:
-        message`The project directory to initialize.  If a specified directory does not exist, it will be created.`,
-    })),
-    webFramework,
-    packageManager,
-    kvStore,
-    messageQueue,
-    dryRun: option("--dry-run", {
-      description: message`Perform a trial run with no changes made.`,
-    }),
-    debugOption,
-    testMode,
-  }),
-  {
-    brief: message`Initialize a new Fedify project directory.`,
-    description: message`Initialize a new Fedify project directory.
-
-By default, it initializes the current directory.  You can specify a different directory as an argument.
-
-Unless you specify all options (${optionNames(["-w", "--web-framework"])}, ${
-      optionNames(["-p", "--package-manager"])
-    }, ${optionNames(["-k", "--kv-store"])}, and ${
-      optionNames(["-m", "--message-queue"])
-    }), it will prompt you to select the options interactively.`,
-  },
-);
-
-export type InitCommand = InferValue<typeof initCommand>;
-
-const noHydRun = object({
-  noHydRun: option("--no-hyd-run", {
-    description: message`Log outputs without creating files.`,
-  }),
-});
-const noDryRun = object({
-  noDryRun: option("--no-dry-run", {
-    description: message`Test with files creations and installations.`,
-  }),
-});
-export const testInitCommand = command(
-  "test-init",
-  merge(
-    object("Initialization options", {
-      command: constant("test-init"),
-      webFramework: multiple(webFramework),
-      packageManager: multiple(packageManager),
-      kvStore: multiple(kvStore),
-      messageQueue: multiple(messageQueue),
-      debugOption,
-    }),
-    optional(or(noHydRun, noDryRun)),
-  ),
-  {
-    brief: message`Test an initializing command .`,
-    description: message`Test an initializing command on temporary directories.
-
-Unless you specify all options (${optionNames(["-w", "--web-framework"])}, ${
-      optionNames(["-p", "--package-manager"])
-    }, ${optionNames(["-k", "--kv-store"])}, and ${
-      optionNames(["-m", "--message-queue"])
-    }), it will test all combinations of the options.`,
-  },
-);
-
-export type TestInitCommand = InferValue<typeof testInitCommand>;

package/src/init/const.ts

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

@@ -1,17 +0,0 @@
-{
-  "$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

@@ -1,39 +0,0 @@
-{
-  "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

@@ -1,95 +0,0 @@
-{
-  "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"
-    ]
-  }
-}

package/src/init/json/pm.json

@@ -1,47 +0,0 @@
-{
-  "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

@@ -1,42 +0,0 @@
-{
-  "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

@@ -1,43 +0,0 @@
-{
-  "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

@@ -1,41 +0,0 @@
-{
-  "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

@@ -1,223 +0,0 @@
-import {
-  entries,
-  evolve,
-  fromEntries,
-  isObject,
-  map,
-  negate,
-  pipe,
-  throwIf,
-  when,
-} from "@fxts/core";
-import { getLogger } from "@logtape/logtape";
-import type { Message } from "@optique/core";
-import { commandLine, message } from "@optique/core/message";
-import { toMerged } from "es-toolkit";
-import { readFileSync } from "node:fs";
-import { mkdir, readdir, writeFile } from "node:fs/promises";
-import { dirname, join as joinPath } from "node:path";
-import process from "node:process";
-import metadata from "../../deno.json" with { type: "json" };
-import { 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,
-  port: number,
-) => Message = (pm, port) =>
-  message`
-To start the server, run the following command:
-
-  ${commandLine(getDevCommand(pm))}
-
-Then, try look up an actor from your server:
-
-  ${commandLine(`fedify lookup http://localhost:${port}/users/john`)}
-
-`;
-
-export const getDevCommand = (pm: PackageManager) =>
-  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;
-  }
-};
-
-/**
- * Converts a package manager to its corresponding runtime.
- * @param pm - The package manager (deno, bun, npm, yarn, pnpm)
- * @returns The runtime name (deno, bun, or node)
- */
-export const packageManagerToRuntime = (
-  pm: PackageManager,
-): "deno" | "bun" | "node" =>
-  pm === "deno" ? "deno" : pm === "bun" ? "bun" : "node";
-
-export const getNextInitCommand = (
-  pm: PackageManager,
-): string[] => [...createNextAppCommand(pm), ".", "--yes"];
-
-const createNextAppCommand = (pm: PackageManager): string[] =>
-  pm === "deno"
-    ? ["deno", "-Ar", "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",
-  ".",
-  "&&",
-  "rm",
-  "nitro.config.ts", // Remove default nitro config file
-  // This file will be created from template
-];
-
-const createNitroAppCommand = (pm: PackageManager): string[] =>
-  pm === "deno"
-    ? ["deno", "run", "-A"]
-    : pm === "bun"
-    ? ["bunx"]
-    : pm === "npm"
-    ? ["npx"]
-    : [pm, "dlx"];
-
-export const isTest: <
-  T extends { testMode: boolean },
->({ testMode }: T) => boolean = ({ testMode }) => testMode;

package/src/init/mod.ts

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