@mettlecast/domain-cli 0.2.84 → 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.84",
+  "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/__tests__/doctor.test.ts

@@ -863,4 +863,117 @@ describe('runDoctor', () => {
       expect(check?.message).toMatch(/some-command\.ts/);
     });
   });
+
+  describe('email doctor requirements', () => {
+    it('PASS for @no-consumers annotation when email events have the annotation', async () => {
+      await mkdir(join(tempDir, '.mc'), { recursive: true });
+      await mkdir(join(tempDir, 'domains', 'email', 'publishes'), { recursive: true });
+      await writeFile(
+        join(tempDir, '.mc', 'scaffold-config.json'),
+        JSON.stringify({ domainIds: ['email'] })
+      );
+      // Email publishes with @no-consumers annotation
+      await writeFile(
+        join(tempDir, 'domains', 'email', 'publishes', 'events.ts'),
+        [
+          'import { defineEvent } from \'@mettlecast/domain-runtime\';',
+          'import { z } from \'zod\';',
+          '',
+          '// @no-consumers: email events are public integration hooks for downstream projects.',
+          '',
+          'export const emailSent = defineEvent({',
+          '  id: \'email.sent\',',
+          '  versions: [{ version: 1,',
+          '    schema: z.object({ templateKey: z.string() }),',
+          '  }],',
+          '});',
+        ].join('\n')
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'Every event has consumer or annotation');
+      expect(check?.status).toBe('PASS');
+    });
+
+    it('FAIL for @no-consumers annotation when email events lack the annotation', async () => {
+      await mkdir(join(tempDir, '.mc'), { recursive: true });
+      await mkdir(join(tempDir, 'domains', 'email', 'publishes'), { recursive: true });
+      await writeFile(
+        join(tempDir, '.mc', 'scaffold-config.json'),
+        JSON.stringify({ domainIds: ['email'] })
+      );
+      // Email publishes WITHOUT @no-consumers annotation
+      await writeFile(
+        join(tempDir, 'domains', 'email', 'publishes', 'events.ts'),
+        [
+          'import { defineEvent } from \'@mettlecast/domain-runtime\';',
+          'import { z } from \'zod\';',
+          '',
+          'export const emailSent = defineEvent({',
+          '  id: \'email.sent\',',
+          '  versions: [{ version: 1,',
+          '    schema: z.object({ templateKey: z.string() }),',
+          '  }],',
+          '});',
+        ].join('\n')
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'Every event has consumer or annotation');
+      expect(check?.status).toBe('FAIL');
+      expect(check?.message).toContain('email');
+    });
+
+    it('PASS for tenancy trio when email migration includes workspace_id', async () => {
+      await mkdir(join(tempDir, '.mc'), { recursive: true });
+      await mkdir(join(tempDir, 'domains', 'email'), { recursive: true });
+      await mkdir(join(tempDir, 'db', 'migrations'), { recursive: true });
+      await writeFile(
+        join(tempDir, '.mc', 'scaffold-config.json'),
+        JSON.stringify({ domainIds: ['email'] })
+      );
+      // Migration with workspace_id (tenancy trio satisfied)
+      await writeFile(
+        join(tempDir, 'db', 'migrations', '008_email_templates.sql'),
+        [
+          'CREATE TABLE IF NOT EXISTS email_templates (',
+          '  id UUID PRIMARY KEY,',
+          '  tenant_id UUID,',
+          '  workspace_id UUID,',
+          '  org_id UUID',
+          ');',
+        ].join('\n')
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'Migrations declare tenancy trio');
+      expect(check?.status).toBe('PASS');
+    });
+
+    it('FAIL for tenancy trio when email migration lacks workspace_id', async () => {
+      await mkdir(join(tempDir, '.mc'), { recursive: true });
+      await mkdir(join(tempDir, 'domains', 'email'), { recursive: true });
+      await mkdir(join(tempDir, 'db', 'migrations'), { recursive: true });
+      await writeFile(
+        join(tempDir, '.mc', 'scaffold-config.json'),
+        JSON.stringify({ domainIds: ['email'] })
+      );
+      // Migration WITHOUT workspace_id (tenancy trio not satisfied)
+      await writeFile(
+        join(tempDir, 'db', 'migrations', '008_email_templates.sql'),
+        [
+          'CREATE TABLE IF NOT EXISTS email_templates (',
+          '  id UUID PRIMARY KEY,',
+          '  tenant_id UUID,',
+          '  org_id UUID',
+          ');',
+        ].join('\n')
+      );
+
+      const report = await runDoctor({ projectRoot: tempDir });
+      const check = report.checks.find(c => c.name === 'Migrations declare tenancy trio');
+      expect(check?.status).toBe('FAIL');
+      expect(check?.message).toContain('workspace_id');
+    });
+  });
 });

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(