@fedify/cli 2.0.0-pr.474.1879 → 2.0.0-pr.479.1900

package/src/init/webframeworks.ts

@@ -6,6 +6,7 @@ import {
   getNextInitCommand,
   getNitroInitCommand,
   PACKAGE_VERSION,
+  packageManagerToRuntime,
   readTemplate,
 } from "./lib.ts";
 import type { WebFrameworks } from "./types.ts";
@@ -14,21 +15,27 @@ const webFrameworks: WebFrameworks = {
   hono: {
     label: "Hono",
     packageManagers: PACKAGE_MANAGER,
-    init: (projectName, pm) => ({
+    init: ({ projectName, packageManager: pm }) => ({
       dependencies: pm === "deno"
         ? {
           "@std/dotenv": "^0.225.2",
           "@hono/hono": "^4.5.0",
           "@hongminhee/x-forwarded-fetch": "^0.2.0",
+          "@fedify/hono": PACKAGE_VERSION,
         }
         : pm === "bun"
-        ? { hono: "^4.5.0", "x-forwarded-fetch": "^0.2.0" }
+        ? {
+          hono: "^4.5.0",
+          "x-forwarded-fetch": "^0.2.0",
+          "@fedify/hono": PACKAGE_VERSION,
+        }
         : {
           "@dotenvx/dotenvx": "^1.14.1",
           hono: "^4.5.0",
           "@hono/node-server": "^1.12.0",
           tsx: "^4.17.0",
           "x-forwarded-fetch": "^0.2.0",
+          "@fedify/hono": PACKAGE_VERSION,
         },
       devDependencies: pm === "bun" ? { "@types/bun": "^1.1.6" } : {},
       federationFile: "src/federation.ts",
@@ -37,13 +44,12 @@ const webFrameworks: WebFrameworks = {
         "src/app.tsx": pipe(
           "hono/app.tsx",
           readTemplate,
-          replace(
-            /\/\* hono \*\//,
-            pm === "deno" ? "@hono/hono" : "hono",
-          ),
-        )
-          .replace(/\/\* logger \*\//, projectName),
-        "src/index.ts": readTemplate(`hono/index/${pm}.ts`),
+          replace(/\/\* hono \*\//, pm === "deno" ? "@hono/hono" : "hono"),
+          replace(/\/\* logger \*\//, projectName),
+        ),
+        "src/index.ts": readTemplate(
+          `hono/index/${packageManagerToRuntime(pm)}.ts`,
+        ),
       },
       compilerOptions: pm === "deno" ? undefined : {
         "lib": ["ESNext", "DOM"],
@@ -69,15 +75,16 @@ const webFrameworks: WebFrameworks = {
           ? "bun run ./src/index.ts"
           : "dotenvx run -- node --import tsx ./src/index.ts",
       },
-      instruction: getInstruction(pm),
+      instruction: getInstruction(pm, 8000),
     }),
+    defaultPort: 8000,
   },
   express: {
     label: "Express",
-    packageManagers: ["bun", "npm", "yarn", "pnpm"] as const,
-    init: (projectName, pm) => ({
+    packageManagers: PACKAGE_MANAGER,
+    init: ({ projectName, packageManager: pm }) => ({
       dependencies: {
-        express: "^4.19.2",
+        "npm:express": "^4.19.2",
         "@fedify/express": PACKAGE_VERSION,
         ...(pm !== "deno" && pm !== "bun"
           ? { "@dotenvx/dotenvx": "^1.14.1", tsx: "^4.17.0" }
@@ -107,18 +114,23 @@ const webFrameworks: WebFrameworks = {
       tasks: {
         "dev": pm === "bun"
           ? "bun run --hot ./src/index.ts"
+          : pm === "deno"
+          ? "deno run --allow-net --allow-env --allow-sys --watch ./src/index.ts"
           : "dotenvx run -- tsx watch ./src/index.ts",
         "prod": pm === "bun"
           ? "bun run ./src/index.ts"
+          : pm === "deno"
+          ? "deno run --allow-net --allow-env --allow-sys ./src/index.ts"
           : "dotenvx run -- node --import tsx ./src/index.ts",
       },
-      instruction: getInstruction(pm),
+      instruction: getInstruction(pm, 8000),
     }),
+    defaultPort: 8000,
   },
   nitro: {
     label: "Nitro",
     packageManagers: PACKAGE_MANAGER,
-    init: (_, pm) => ({
+    init: ({ packageManager: pm, testMode }) => ({
       command: getNitroInitCommand(pm),
       dependencies: { "@fedify/h3": PACKAGE_VERSION },
       federationFile: "server/federation.ts",
@@ -129,14 +141,18 @@ const webFrameworks: WebFrameworks = {
         ),
         "server/error.ts": readTemplate("nitro/server/error.ts"),
         "nitro.config.ts": readTemplate("nitro/nitro.config.ts"),
+        ...(
+          testMode ? { ".env": readTemplate("nitro/.env.test") } : {}
+        ),
       },
-      instruction: getInstruction(pm),
+      instruction: getInstruction(pm, 3000),
     }),
+    defaultPort: 3000,
   },
   next: {
     label: "Next.js",
     packageManagers: PACKAGE_MANAGER,
-    init: (_, pm) => ({
+    init: ({ packageManager: pm }) => ({
       label: "Next.js",
       command: getNextInitCommand(pm),
       dependencies: { "@fedify/next": PACKAGE_VERSION },
@@ -144,8 +160,9 @@ const webFrameworks: WebFrameworks = {
       federationFile: "federation/index.ts",
       loggingFile: "logging.ts",
       files: { "middleware.ts": readTemplate("next/middleware.ts") },
-      instruction: getInstruction(pm),
+      instruction: getInstruction(pm, 3000),
     }),
+    defaultPort: 3000,
   },
 } as const;
 export default webFrameworks;

package/src/mod.ts

@@ -6,7 +6,12 @@ import {
   runGenerateVocab,
 } from "./generate-vocab/mod.ts";
 import { inboxCommand, runInbox } from "./inbox.tsx";
-import { initCommand, runInit } from "./init/mod.ts";
+import {
+  initCommand,
+  runInit,
+  runTestInit,
+  testInitCommand,
+} from "./init/mod.ts";
 import { lookupCommand, runLookup } from "./lookup.ts";
 import { nodeInfoCommand, runNodeInfo } from "./nodeinfo.ts";
 import { runTunnel, tunnelCommand } from "./tunnel.ts";
@@ -20,6 +25,7 @@ const command = or(
   nodeInfoCommand,
   tunnelCommand,
   generateVocabCommand,
+  testInitCommand,
 );
 
 async function main() {
@@ -48,6 +54,9 @@ async function main() {
   if (result.command === "generate-vocab") {
     await runGenerateVocab(result);
   }
+  if (result.command === "test-init") {
+    await runTestInit(result);
+  }
 }
 
 await main();

package/src/nodeinfo.ts

@@ -16,6 +16,7 @@ import {
   optional,
   or,
   string,
+  text,
 } from "@optique/core";
 import { print, printError } from "@optique/run";
 import type { ChalkInstance } from "chalk";
@@ -111,7 +112,7 @@ export async function runNodeInfo(
     }
     spinner.succeed("NodeInfo document fetched.");
 
-    console.log(formatObject(nodeInfo, undefined, true));
+    print(message`${text(formatObject(nodeInfo, undefined, true))}`);
     return;
   }
   const nodeInfo = await getNodeInfo(url, {

package/src/utils.ts

@@ -1,7 +1,9 @@
 import { isObject } from "@fxts/core";
+import { message } from "@optique/core";
+import { print, printError } from "@optique/run";
 import { Chalk } from "chalk";
 import { highlight } from "cli-highlight";
-import { toMerged } from "es-toolkit";
+import { flow, toMerged } from "es-toolkit";
 import { spawn } from "node:child_process";
 import { writeFile } from "node:fs/promises";
 import process from "node:process";
@@ -59,18 +61,68 @@ export const isNotFoundError = (e: unknown): e is { code: "ENOENT" } =>
   "code" in e &&
   e.code === "ENOENT";
 
-export const runSubCommand = <Opt extends Parameters<typeof spawn>[2]>(
+export class CommandError extends Error {
+  public commandLine: string;
+  constructor(
+    message: string,
+    public stdout: string,
+    public stderr: string,
+    public code: number,
+    public command: string[],
+  ) {
+    super(message);
+    this.name = "CommandError";
+    this.commandLine = command.join(" ");
+  }
+}
+
+export const runSubCommand = async <Opt extends Parameters<typeof spawn>[2]>(
   command: string[],
   options: Opt,
 ): Promise<{
   stdout: string;
   stderr: string;
-}> =>
-  new Promise((resolve, reject) => {
-    const child = spawn(command[0], command.slice(1), options);
+}> => {
+  const commands = // split by "&&"
+    command.reduce<string[][]>((acc, cur) => {
+      if (cur === "&&") {
+        acc.push([]);
+      } else {
+        if (acc.length === 0) acc.push([]);
+        acc[acc.length - 1].push(cur);
+      }
+      return acc;
+    }, []);
+
+  const results = { stdout: "", stderr: "" };
+
+  for (const cmd of commands) {
+    try {
+      const result = await runSingularCommand(cmd, options);
+      results.stdout += (results.stdout ? "\n" : "") + result.stdout;
+      results.stderr += (results.stderr ? "\n" : "") + result.stderr;
+    } catch (e) {
+      if (e instanceof CommandError) {
+        results.stdout += (results.stdout ? "\n" : "") + e.stdout;
+        results.stderr += (results.stderr ? "\n" : "") + e.stderr;
+      }
+      throw e;
+    }
+  }
+  return results;
+};
 
+const runSingularCommand = (
+  command: string[],
+  options: Parameters<typeof spawn>[2],
+) =>
+  new Promise<{
+    stdout: string;
+    stderr: string;
+  }>((resolve, reject) => {
     let stdout = "";
     let stderr = "";
+    const child = spawn(command[0], command.slice(1), options);
 
     child.stdout?.on("data", (data) => {
       stdout += data.toString();
@@ -79,11 +131,23 @@ export const runSubCommand = <Opt extends Parameters<typeof spawn>[2]>(
       stderr += data.toString();
     });
 
-    child.on("close", () => {
-      resolve({
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-      });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve({
+          stdout: stdout.trim(),
+          stderr: stderr.trim(),
+        });
+      } else {
+        reject(
+          new CommandError(
+            `Command exited with code ${code ?? "unknown"}`,
+            stdout.trim(),
+            stderr.trim(),
+            code ?? -1,
+            command,
+          ),
+        );
+      }
     });
 
     child.on("error", (error) => {
@@ -103,6 +167,12 @@ export const replace = (
 ) =>
 (text: string): string => text.replace(pattern, replacement as string);
 
+export const replaceAll = (
+  pattern: string | RegExp,
+  replacement: string | ((substring: string, ...args: unknown[]) => string),
+) =>
+(text: string): string => text.replaceAll(pattern, replacement as string);
+
 export const getOsType = () => process.platform;
 
 export async function writeTextFile(
@@ -134,3 +204,51 @@ export const notEmptyObj = <T extends Record<PropertyKey, never> | object>(
 ): obj is Exclude<T, Record<PropertyKey, never>> => Object.keys(obj).length > 0;
 
 export const exit = (code: number) => process.exit(code);
+
+/**
+ * Generic type to represent the types of the items in iterables.
+ */
+export type ItersItems<T extends Iterable<unknown>[]> = T extends [] ? []
+  : T extends [infer Head, ...infer Tail]
+    ? Head extends Iterable<infer Item>
+      ? Tail extends Iterable<unknown>[] ? [Item, ...ItersItems<Tail>]
+      : [Item]
+    : never
+  : never;
+
+/**
+ * ```haskell
+ * product::[[a], [b], ...] -> [[a, b, ...]]
+ * ```
+ *
+ * Cartesian product of the input iterables.
+ * Inspired by Python's `itertools.product`.
+ *
+ * @param {...Iterable<unknown>} iters - The input iterables to compute the Cartesian product.
+ * @returns {Generator<ItersItems<T>>} A generator that yields arrays containing one element from each iterable.
+ *
+ * @example
+ * ```ts
+ * const iter1 = [1, 2];
+ * const iter2 = ['a', 'b'];
+ * const iter3 = [true, false];
+ * const productIter = product(iter1, iter2, iter3);
+ * console.log(Array.from(productIter)); // Output: [[1, 'a', true], [1, 'a', false], [
+ */
+export function* product<T extends Iterable<unknown>[]>(
+  ...[head, ...tail]: T
+): Generator<ItersItems<T>> {
+  if (!head) yield [] as ItersItems<T>;
+  else {
+    for (const x of head) {
+      for (const xs of product(...tail)) yield [x, ...xs] as ItersItems<T>;
+    }
+  }
+}
+
+export type GeneratedType<T extends Generator> = T extends
+  Generator<unknown, infer R, unknown> ? R : never;
+
+type PrintMessage = (...args: Parameters<typeof message>) => void;
+export const printMessage: PrintMessage = flow(message, print);
+export const printErrorMessage: PrintMessage = flow(message, printError);