Fix @fedify/nuxt runtime packaging and fedify init scaffolding edge cases

CHANGES.md

@@ -148,6 +148,25 @@ To be released.
 
 ### @fedify/init
 
+ -  Added a `--allow-non-empty` option to `fedify init` for automated
+    scaffolding in directories that already contain unrelated files.  The
+    command still fails before making changes if any file that Fedify would
+    generate already exists, avoiding accidental merges or appends.
+    [[#716], [#717]]
+
+ -  Fixed `fedify init` so that a directory containing only a freshly
+    initialized Git repository is treated as empty.  Directories whose Git
+    `HEAD` already resolves to a commit, whose Git metadata contains loose or
+    packed refs, stored objects, an index, or reflogs, or that contain any
+    files besides *.git*, still require the existing non-empty-directory
+    confirmation.  [[#716], [#717]]
+
+ -  Fixed generated *biome.json* files to use Biome 2 configuration syntax,
+    matching the `@biomejs/biome` version that `fedify init` installs.
+    Generated projects now enable import organization through Biome's
+    `assist.actions.source.organizeImports` setting instead of the removed
+    top-level `organizeImports` option.  [[#716], [#717]]
+
  -  Fixed errors when using `fedify init` with certain web framework
     integration packages (Astro, ElysiaJS, Nitro) alongside `@fedify/mysql`.
     Environment variables are now properly loaded at runtime, resolving the
@@ -161,6 +180,8 @@ To be released.
 [#649]: https://github.com/fedify-dev/fedify/issues/649
 [#656]: https://github.com/fedify-dev/fedify/pull/656
 [#675]: https://github.com/fedify-dev/fedify/pull/675
+[#716]: https://github.com/fedify-dev/fedify/issues/716
+[#717]: https://github.com/fedify-dev/fedify/pull/717
 
 ### Docs
 

docs/cli.md

@@ -339,6 +339,28 @@ When using `--dry-run`, the command will:
 This option works with all other initialization options, allowing you to preview
 different configurations before making a decision.
 
+### `--allow-non-empty`: Initialize in a non-empty directory
+
+*This option is available since Fedify 2.2.0.*
+
+By default, `fedify init` asks for confirmation before using a directory that
+already contains files.  This prompt protects you from accidentally
+initializing a project in the wrong directory.  In non-interactive scripts or
+CI jobs, use the `--allow-non-empty` option to allow a non-empty target
+directory:
+
+~~~~ sh
+fedify init . --allow-non-empty
+~~~~
+
+This option does not overwrite existing project files.  Before making changes,
+`fedify init` checks the files it would generate and fails if any of them
+already exist.  Unrelated files can remain in the target directory only when
+the selected framework scaffolder accepts them.  Some scaffolders, such as
+*create-next-app*, still reject unrelated files even if `fedify init` skips its
+own confirmation prompt, while a freshly initialized *.git* directory remains
+acceptable.
+
 
 `fedify lookup`: Looking up an ActivityPub object
 -------------------------------------------------

packages/fedify/src/federation/mq.test.ts

@@ -13,6 +13,20 @@ import {
   ParallelMessageQueue,
 } from "./mq.ts";
 
+async function disposeMessageQueue(mq: object): Promise<void> {
+  if (Symbol.asyncDispose in mq) {
+    const dispose = mq[Symbol.asyncDispose];
+    if (typeof dispose === "function") {
+      await dispose.call(mq);
+      return;
+    }
+  }
+  if (Symbol.dispose in mq) {
+    const dispose = mq[Symbol.dispose];
+    if (typeof dispose === "function") dispose.call(mq);
+  }
+}
+
 test("InProcessMessageQueue", async (t) => {
   const mq = new InProcessMessageQueue();
 
@@ -189,10 +203,7 @@ test("MessageQueue.nativeRetrial", async (t) => {
         await globalThis.Deno.openKv(":memory:"),
       );
       assert(mq.nativeRetrial);
-      if (Symbol.dispose in mq) {
-        const dispose = mq[Symbol.dispose];
-        if (typeof dispose === "function") dispose.call(mq);
-      }
+      await disposeMessageQueue(mq);
     });
   }
 
@@ -321,10 +332,7 @@ for (const mqName in queues) {
       controller.abort();
       await listening;
 
-      if (Symbol.dispose in mq) {
-        const dispose = mq[Symbol.dispose];
-        if (typeof dispose === "function") dispose.call(mq);
-      }
+      await disposeMessageQueue(mq);
     },
   });
 }

packages/init/src/action/configs.test.ts

@@ -1,8 +1,14 @@
 import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import test from "node:test";
 import { message } from "@optique/core";
+import { kvStores, messageQueues } from "../lib.ts";
 import type { InitCommandData } from "../types.ts";
+import bareBonesDescription from "../webframeworks/bare-bones.ts";
 import { loadDenoConfig } from "./configs.ts";
+import { patchFiles } from "./patch.ts";
 
 function createInitData(): InitCommandData {
   const data = {
@@ -13,6 +19,7 @@ function createInitData(): InitCommandData {
     kvStore: "denokv",
     messageQueue: "denokv",
     dryRun: false,
+    allowNonEmpty: false,
     testMode: false,
     dir: "/tmp/example",
     initializer: {
@@ -94,3 +101,93 @@ test("loadDenoConfig keeps unstable.temporal before Deno 2.7.0", () => {
     restoreDeno(originalDeno);
   }
 });
+
+test("patchFiles creates a Biome config matching the npm package version", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "fedify-init-biome-"));
+
+  try {
+    const data = await createNpmInitData(dir);
+    await patchFiles(data);
+
+    const packageJson = JSON.parse(
+      await readFile(join(dir, "package.json"), "utf8"),
+    ) as {
+      devDependencies?: Record<string, string>;
+    };
+    const biomeConfig = JSON.parse(
+      await readFile(join(dir, "biome.json"), "utf8"),
+    ) as Record<string, unknown>;
+
+    const biomeVersion = packageJson.devDependencies?.["@biomejs/biome"];
+    const schema = biomeConfig.$schema;
+    assert.ok(typeof biomeVersion === "string");
+    assert.ok(typeof schema === "string");
+    assert.equal(getSchemaVersion(schema), getPackageVersion(biomeVersion));
+    assert.equal(getOrganizeImportsSetting(biomeConfig), "on");
+    assert.equal(
+      "organizeImports" in biomeConfig,
+      false,
+    );
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+async function createNpmInitData(dir: string): Promise<InitCommandData> {
+  const initializer = await bareBonesDescription.init({
+    command: "init",
+    projectName: "example",
+    packageManager: "npm",
+    webFramework: "bare-bones",
+    kvStore: "in-memory",
+    messageQueue: "in-process",
+    dryRun: false,
+    allowNonEmpty: false,
+    testMode: false,
+    dir,
+  });
+
+  const data = {
+    command: "init",
+    projectName: "example",
+    packageManager: "npm",
+    webFramework: "bare-bones",
+    kvStore: "in-memory",
+    messageQueue: "in-process",
+    dryRun: false,
+    allowNonEmpty: false,
+    testMode: false,
+    dir,
+    initializer,
+    kv: kvStores["in-memory"],
+    mq: messageQueues["in-process"],
+    env: {},
+  } satisfies InitCommandData;
+  return data;
+}
+
+function getSchemaVersion(schema: string): string {
+  const match = schema.match(/\/schemas\/(\d+\.\d+\.\d+)\//);
+  assert.ok(match, `Unexpected Biome schema URL: ${schema}`);
+  return match[1];
+}
+
+function getPackageVersion(version: string): string {
+  const match = version.match(/\d+\.\d+\.\d+/);
+  assert.ok(match, `Unexpected Biome package version: ${version}`);
+  return match[0];
+}
+
+function getOrganizeImportsSetting(config: Record<string, unknown>): unknown {
+  const assist = config.assist;
+  assert.ok(isRecord(assist));
+  const actions = assist.actions;
+  assert.ok(isRecord(actions));
+  const source = actions.source;
+  assert.ok(isRecord(source));
+  return source.organizeImports;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value != null;
+}

packages/init/src/action/mod.ts

@@ -12,7 +12,11 @@ import {
   noticeOptions,
   noticePrecommand,
 } from "./notice.ts";
-import { patchFiles, recommendPatchFiles } from "./patch.ts";
+import {
+  assertNoGeneratedFileConflicts,
+  patchFiles,
+  recommendPatchFiles,
+} from "./patch.ts";
 import recommendDependencies from "./recommend.ts";
 import setData from "./set.ts";
 import {
@@ -69,6 +73,7 @@ const handleHydRun = (data: InitCommandData) =>
   pipe(
     data,
     tap(makeDirIfHyd),
+    tap(assertNoGeneratedFileConflicts),
     tap(when(hasCommand, runPrecommand)),
     tap(patchFiles),
     tap(installDependencies),

packages/init/src/action/patch.test.ts

@@ -0,0 +1,115 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { message } from "@optique/core";
+import type { InitCommandData } from "../types.ts";
+import {
+  assertNoGeneratedFileConflicts,
+  GeneratedFileConflictError,
+  getJsonsCacheKey,
+} from "./patch.ts";
+
+test("assertNoGeneratedFileConflicts allows unrelated files", async () => {
+  await withTempDir(async (dir) => {
+    await writeFile(join(dir, "README.md"), "# Example\n");
+
+    await assert.doesNotReject(() =>
+      assertNoGeneratedFileConflicts(createInitData(dir, true))
+    );
+  });
+});
+
+test("assertNoGeneratedFileConflicts rejects existing generated files", async () => {
+  await withTempDir(async (dir) => {
+    await mkdir(join(dir, "src"), { recursive: true });
+    await writeFile(join(dir, "package.json"), "{}\n");
+    await writeFile(join(dir, "src", "main.ts"), "");
+
+    await assert.rejects(
+      () => assertNoGeneratedFileConflicts(createInitData(dir, true)),
+      (error) => {
+        assert.ok(error instanceof GeneratedFileConflictError);
+        assert.deepEqual(error.conflicts, ["src/main.ts", "package.json"]);
+        assert.match(error.message, /src\/main\.ts/);
+        assert.match(error.message, /package\.json/);
+        return true;
+      },
+    );
+  });
+});
+
+test("assertNoGeneratedFileConflicts skips checks without allowNonEmpty", async () => {
+  await withTempDir(async (dir) => {
+    await writeFile(join(dir, "package.json"), "{}\n");
+
+    await assert.doesNotReject(() =>
+      assertNoGeneratedFileConflicts(createInitData(dir, false))
+    );
+  });
+});
+
+test("getJsonsCacheKey stays stable across pipeline clones", () => {
+  const data = createInitData("/tmp/example", true);
+  const cloned = {
+    ...data,
+    files: { "src/main.ts": "" },
+    jsons: { "package.json": {} },
+  };
+
+  assert.equal(getJsonsCacheKey(cloned), getJsonsCacheKey(data));
+});
+
+function createInitData(
+  dir: string,
+  allowNonEmpty: boolean,
+): InitCommandData {
+  const data = {
+    command: "init",
+    projectName: "example",
+    packageManager: "npm",
+    webFramework: "bare-bones",
+    kvStore: "in-memory",
+    messageQueue: "in-process",
+    dryRun: false,
+    allowNonEmpty,
+    testMode: false,
+    dir,
+    initializer: {
+      federationFile: "src/federation.ts",
+      loggingFile: "src/logging.ts",
+      instruction: message`done`,
+      tasks: {},
+      compilerOptions: {},
+      files: {
+        "src/main.ts": "",
+      },
+    },
+    kv: {
+      label: "In-Memory",
+      packageManagers: ["npm"],
+      imports: {},
+      object: "new MemoryKvStore()",
+    },
+    mq: {
+      label: "In-Process",
+      packageManagers: ["npm"],
+      imports: {},
+      object: "new InProcessMessageQueue()",
+    },
+    env: {},
+  } satisfies InitCommandData;
+  return data;
+}
+
+async function withTempDir(
+  fn: (dir: string) => Promise<void>,
+): Promise<void> {
+  const dir = await mkdtemp(join(tmpdir(), "fedify-init-patch-"));
+  try {
+    await fn(dir);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}