@mettlecast/domain-cli 0.2.85 → 0.2.86

package/dist/commands/build-catalog.js

@@ -120,9 +120,8 @@ export async function runBuildCatalog(registryDir) {
             });
         }
     }
-    const mcDir = join(process.cwd(), '.mc');
-    await mkdir(mcDir, { recursive: true });
-    const outPath = join(mcDir, 'domain-registry.json');
+    const outPath = join(dir, 'domain-registry.json');
+    await mkdir(dir, { recursive: true });
     await writeFile(outPath, JSON.stringify(catalog), 'utf8');
     cliLogger.info({ outPath, domains: catalog.domains.length, actions: catalog.actions.length, events: catalog.events.length, jobs: catalog.jobs.length, schedules: catalog.schedules.length, integrations: catalog.integrations.length }, 'Domain catalog written');
     return catalog;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mettlecast/domain-cli",
-  "version": "0.2.85",
+  "version": "0.2.86",
   "type": "module",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",

package/src/__tests__/commands/build-catalog.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { writeFile, readFile, mkdir } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+import { rmSync } from 'node:fs';
+import { runBuildCatalog } from '../../commands/build-catalog.js';
+
+describe('build-catalog', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `tib-build-catalog-${Math.random().toString(36).slice(2)}`);
+    await mkdir(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  /**
+   * Regression test for #5087.
+   * When registryDir is explicitly given, the catalog output must be written
+   * to that directory (resolved) — NOT to process.cwd()/.mc.
+   * This ensures --mc-dir controls both read and write locations.
+   */
+  it('writes catalog to the resolved registryDir, not to cwd/.mc (#5087)', async () => {
+    // Arrange: seed a temp .mc directory with one per-domain registry file.
+    const mcDir = join(tempDir, '.mc');
+    await mkdir(mcDir, { recursive: true });
+
+    await writeFile(
+      join(mcDir, 'test-domain-registry.json'),
+      JSON.stringify({
+        domain: { id: 'test-domain', name: 'Test Domain', tenancy: 'required' },
+        actions: [],
+        events: [],
+        subscribers: [],
+        jobs: [],
+        schedules: [],
+        integrations: [],
+      })
+    );
+
+    // Capture hash of the project's existing domain-registry.json (if any)
+    // so we can assert the test did NOT overwrite it.
+    const projectCatalogPath = join(process.cwd(), '.mc', 'domain-registry.json');
+    const beforeHash = existsSync(projectCatalogPath)
+      ? createHash('sha256').update(readFileSync(projectCatalogPath)).digest('hex')
+      : null;
+
+    // Act: pass explicit registryDir (the temp .mc dir)
+    const catalog = await runBuildCatalog(mcDir);
+
+    // Assert — output landed inside the resolved registryDir
+    const outPath = join(mcDir, 'domain-registry.json');
+    expect(existsSync(outPath)).toBe(true);
+
+    const onDisk = JSON.parse(await readFile(outPath, 'utf8'));
+    expect(onDisk.version).toBe(2);
+    expect(onDisk.generatedAt).toBeDefined();
+    expect(onDisk.domains).toHaveLength(1);
+    expect(onDisk.domains[0]?.id).toBe('test-domain');
+
+    // Returned catalog matches what was written
+    expect(catalog.domains[0]?.id).toBe('test-domain');
+
+    // Assert — project .mc/domain-registry.json must NOT have been touched
+    const afterHash = existsSync(projectCatalogPath)
+      ? createHash('sha256').update(readFileSync(projectCatalogPath)).digest('hex')
+      : null;
+    expect(afterHash).toBe(beforeHash);
+  });
+
+  it('preserves default behavior when registryDir is omitted', async () => {
+    // Seed cwd/.mc with a temp registry file. We can't actually create
+    // files in cwd, but we CAN verify the default directory resolution
+    // produces the expected path relative to cwd.
+    // Instead, create a temp dir and pass no argument, then verify
+    // the function resolves dir to process.cwd() + '/.mc'.
+    // Since the project's .mc may have real registries, just verify
+    // no error is thrown and a valid catalog is returned.
+    const catalog = await runBuildCatalog();
+    expect(catalog.version).toBe(2);
+    expect(Array.isArray(catalog.domains)).toBe(true);
+    expect(Array.isArray(catalog.actions)).toBe(true);
+  });
+});

package/src/commands/build-catalog.ts

@@ -213,9 +213,8 @@ export async function runBuildCatalog(registryDir?: string): Promise<DomainCatal
     }
   }
 
-  const mcDir = join(process.cwd(), '.mc');
-  await mkdir(mcDir, { recursive: true });
-  const outPath = join(mcDir, 'domain-registry.json');
+  const outPath = join(dir, 'domain-registry.json');
+  await mkdir(dir, { recursive: true });
   await writeFile(outPath, JSON.stringify(catalog), 'utf8');
 
   cliLogger.info(