@mettlecast/domain-cli 0.2.0

package/dist/utils/token-substitution.js

@@ -0,0 +1,52 @@
+/**
+ * Replace all {{TOKEN}} placeholders in a template string with values from ctx.
+ * Throws if an unknown token is encountered.
+ */
+export function applyTokens(template, ctx) {
+    return template.replace(/\{\{([A-Z_]+)\}\}/g, (match, key) => {
+        const value = ctx[key];
+        if (value === undefined) {
+            throw new Error(`Unknown scaffold token: {{${key}}}`);
+        }
+        return value;
+    });
+}
+/**
+ * Build a TokenContext from a scaffold config and resolved version.
+ */
+export function buildTokenContext(config, scaffoldVersion, cliVersion) {
+    const name = config.projectName;
+    return {
+        PROJECT_NAME: name,
+        PROJECT_NAME_PASCAL: toPascalCase(name),
+        PROJECT_NAME_UPPER: toUpperSnakeCase(name),
+        AWS_REGION: config.awsRegion,
+        AWS_ACCOUNT_ID: config.awsAccountId,
+        ADMIN_EMAIL: config.adminEmail ?? '',
+        SCAFFOLD_VERSION: scaffoldVersion,
+        SCAFFOLD_DATE: new Date().toISOString().split('T')[0],
+        TIB_CLI_VERSION: cliVersion,
+    };
+}
+function toPascalCase(kebab) {
+    return kebab
+        .split('-')
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+function toUpperSnakeCase(kebab) {
+    return kebab.replace(/-/g, '_').toUpperCase();
+}
+/**
+ * Returns true if the given file extension indicates the file should receive token substitution.
+ * Only .tpl files are substituted.
+ */
+export function isTemplateFile(filename) {
+    return filename.endsWith('.tpl');
+}
+/**
+ * Strip the .tpl extension from a filename to get the install path.
+ */
+export function stripTplExtension(filename) {
+    return filename.endsWith('.tpl') ? filename.slice(0, -4) : filename;
+}

package/dist/utils/zod-extractor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Utilities for extracting Zod schemas to JSON Schema format.
+ * Uses zod-to-json-schema to convert live Zod objects to JSON-serializable schema.
+ */
+/**
+ * Extract a Zod schema to its JSON Schema representation.
+ * @param schema - A Zod schema object (e.g., z.object({...})).
+ * @returns JSON Schema object or null if extraction fails.
+ */
+export declare function extractZodSchema(schema: unknown): Record<string, unknown> | null;

package/dist/utils/zod-extractor.js

@@ -0,0 +1,28 @@
+/**
+ * Utilities for extracting Zod schemas to JSON Schema format.
+ * Uses zod-to-json-schema to convert live Zod objects to JSON-serializable schema.
+ */
+import { zodToJsonSchema } from 'zod-to-json-schema';
+/**
+ * Extract a Zod schema to its JSON Schema representation.
+ * @param schema - A Zod schema object (e.g., z.object({...})).
+ * @returns JSON Schema object or null if extraction fails.
+ */
+export function extractZodSchema(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return null;
+    }
+    try {
+        // Check if this looks like a Zod schema by inspecting for the parse method
+        if (typeof schema.parse === 'function') {
+            // Use type assertion to bypass TypeScript compatibility issues with zod versions
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const jsonSchema = zodToJsonSchema(schema);
+            return jsonSchema;
+        }
+    }
+    catch {
+        // Silently return null if extraction fails
+    }
+    return null;
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@mettlecast/domain-cli",
+  "version": "0.2.0",
+  "type": "module",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "bin": {
+    "mc-domain-module": "./dist/cli.js"
+  },
+  "exports": {
+    ".": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "dev": "tsx ./src/cli.ts",
+    "test": "vitest"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.0.0",
+    "@aws-sdk/client-sfn": "^3.0.0",
+    "@mettlecast/domain-runtime": "*",
+    "@mettlecast/domain-cdk-packer": "*",
+    "commander": "^12.0.0",
+    "fastify": "^5.0.0",
+    "tar": "^7.0.0",
+    "tsx": "^4.0.0",
+    "zod-to-json-schema": "^3.0.0",
+    "pino": "^9.0.0",
+    "pino-pretty": "^11.0.0",
+    "dotenv": "^16.0.0",
+    "semver": "^7.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/semver": "^7.0.0",
+    "@types/tar": "^6.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.0.0"
+  }
+}

package/src/__tests__/build-registry.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('../builder/load-module.js', () => ({
+  loadModuleExports: vi.fn(),
+}));
+vi.mock('../utils/file-helpers.js', () => ({
+  walkDomainDir: vi.fn(),
+}));
+
+import { buildRegistry } from '../builder/build-registry.js';
+import { loadModuleExports } from '../builder/load-module.js';
+import { walkDomainDir } from '../utils/file-helpers.js';
+
+const mockLoadModuleExports = vi.mocked(loadModuleExports);
+const mockWalkDomainDir = vi.mocked(walkDomainDir);
+
+describe('buildRegistry', () => {
+  const DOMAIN_ROOT = '/fake/domains/billing';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('throws if domain.config.ts is missing', async () => {
+    mockWalkDomainDir.mockResolvedValue({
+      domain: undefined,
+      apis: [],
+      webhooks: [],
+      subscribers: [],
+      actions: [],
+      schedules: [],
+      jobs: [],
+      integrations: [],
+      publishes: undefined,
+    });
+
+    await expect(buildRegistry(DOMAIN_ROOT)).rejects.toThrow('domain.config.ts not found');
+  });
+
+  it('throws if domain.config.ts has no domain export', async () => {
+    mockWalkDomainDir.mockResolvedValue({
+      domain: '/fake/domains/billing/domain.config.ts',
+      apis: [],
+      webhooks: [],
+      subscribers: [],
+      actions: [],
+      schedules: [],
+      jobs: [],
+      integrations: [],
+      publishes: undefined,
+    });
+    mockLoadModuleExports.mockResolvedValue([]);
+
+    await expect(buildRegistry(DOMAIN_ROOT)).rejects.toThrow("no 'domain' export found");
+  });
+
+  it('builds a registry with domain + one api', async () => {
+    mockWalkDomainDir.mockResolvedValue({
+      domain: '/fake/domains/billing/domain.config.ts',
+      apis: ['/fake/domains/billing/api/get-invoice.ts'],
+      webhooks: [],
+      subscribers: [],
+      actions: [],
+      schedules: [],
+      jobs: [],
+      integrations: [],
+      publishes: undefined,
+    });
+
+    mockLoadModuleExports
+      .mockResolvedValueOnce([
+        { _kind: 'domain', _exportName: 'default', id: 'billing', name: 'Billing', tenancy: 'required' },
+      ])
+      .mockResolvedValueOnce([
+        { _kind: 'api', _exportName: 'getInvoice', id: 'get-invoice', path: '/invoices/:id', auth: { type: 'jwt' } },
+      ]);
+
+    const { registry, warnings } = await buildRegistry(DOMAIN_ROOT);
+
+    expect(warnings).toHaveLength(0);
+    expect(registry.schemaVersion).toBe('1');
+    expect(registry.domain.id).toBe('billing');
+    expect(registry.apis).toHaveLength(1);
+    expect(registry.apis[0]!.id).toBe('get-invoice');
+    expect(registry.apis[0]!.path).toBe('/invoices/:id');
+    expect(registry.apis[0]!.authType).toBe('jwt');
+    expect(registry.apis[0]!.handlerFile).toBe('api/get-invoice.ts');
+  });
+
+  it('collects warnings when a file fails to load', async () => {
+    mockWalkDomainDir.mockResolvedValue({
+      domain: '/fake/domains/billing/domain.config.ts',
+      apis: ['/fake/domains/billing/api/broken.ts'],
+      webhooks: [],
+      subscribers: [],
+      actions: [],
+      schedules: [],
+      jobs: [],
+      integrations: [],
+      publishes: undefined,
+    });
+
+    mockLoadModuleExports
+      .mockResolvedValueOnce([
+        { _kind: 'domain', _exportName: 'default', id: 'billing', name: 'Billing', tenancy: 'required' },
+      ])
+      .mockRejectedValueOnce(new Error('tsx error'));
+
+    const { registry, warnings } = await buildRegistry(DOMAIN_ROOT);
+
+    expect(warnings).toHaveLength(1);
+    expect(warnings[0]).toContain('tsx error');
+    expect(registry.apis).toHaveLength(0);
+  });
+});

package/src/__tests__/build-types.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import { buildActionsTypes } from '../builder/build-types.js';
+import type { DomainRegistry } from '@mettlecast/domain-cdk-packer';
+
+describe('buildActionsTypes', () => {
+  it('generates .d.ts with action overloads', () => {
+    const registry: DomainRegistry = {
+      schemaVersion: '1',
+      domainRoot: '/test/auth',
+      domain: { id: 'auth', kind: 'domain', name: 'Auth', tenancy: 'required' },
+      apis: [],
+      webhooks: [],
+      subscribers: [],
+      schedules: [],
+      jobs: [],
+      actions: [
+        {
+          id: 'verify-token',
+          kind: 'action',
+          handlerFile: 'verify-token.ts',
+          visibility: 'domain',
+          idempotent: false,
+        },
+      ],
+      integrations: [],
+      events: [],
+    };
+
+    const output = buildActionsTypes([registry]);
+
+    expect(output).toContain("declare module '@mettlecast/domain-runtime'");
+    expect(output).toContain("interface ActionsProxy");
+    expect(output).toContain("call(actionId: 'auth.verify-token'");
+    expect(output).toContain("Promise<unknown>");
+  });
+
+  it('generates overloads for multiple domains', () => {
+    const auth: DomainRegistry = {
+      schemaVersion: '1',
+      domainRoot: '/test/auth',
+      domain: { id: 'auth', kind: 'domain', name: 'Auth', tenancy: 'required' },
+      apis: [],
+      webhooks: [],
+      subscribers: [],
+      schedules: [],
+      jobs: [],
+      actions: [
+        { id: 'verify', kind: 'action', handlerFile: 'verify.ts', visibility: 'workspace', idempotent: true },
+      ],
+      integrations: [],
+      events: [],
+    };
+
+    const payments: DomainRegistry = {
+      schemaVersion: '1',
+      domainRoot: '/test/payments',
+      domain: { id: 'payments', kind: 'domain', name: 'Payments', tenancy: 'required' },
+      apis: [],
+      webhooks: [],
+      subscribers: [],
+      schedules: [],
+      jobs: [],
+      actions: [
+        { id: 'charge', kind: 'action', handlerFile: 'charge.ts', visibility: 'domain', idempotent: false },
+      ],
+      integrations: [],
+      events: [],
+    };
+
+    const output = buildActionsTypes([auth, payments]);
+
+    expect(output).toContain("call(actionId: 'auth.verify'");
+    expect(output).toContain("call(actionId: 'payments.charge'");
+  });
+
+  it('returns valid TypeScript .d.ts syntax', () => {
+    const registry: DomainRegistry = {
+      schemaVersion: '1',
+      domainRoot: '/test',
+      domain: { id: 'test', kind: 'domain', name: 'Test', tenancy: 'none' },
+      apis: [],
+      webhooks: [],
+      subscribers: [],
+      schedules: [],
+      jobs: [],
+      actions: [],
+      integrations: [],
+      events: [],
+    };
+
+    const output = buildActionsTypes([registry]);
+
+    // Should start with comment
+    expect(output).toMatch(/^\/\/ Generated by/);
+    // Should have export
+    expect(output).toContain('export {};');
+    // Should close module
+    expect(output).toContain('}');
+  });
+});

package/src/__tests__/builder/walkDomainDir.test.ts

@@ -0,0 +1,140 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rmdir, mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { walkDomainDir } from '../../utils/file-helpers.js';
+
+describe('walkDomainDir recursive walk', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'tib-walk-test-'));
+  });
+
+  afterEach(async () => {
+    try {
+      await rmdir(tmpDir, { recursive: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  it('should find .ts files at root of api directory', async () => {
+    const apiDir = join(tmpDir, 'api');
+    await mkdir(apiDir, { recursive: true });
+    await writeFile(join(apiDir, 'simple.ts'), 'export const api = {}');
+
+    const paths = await walkDomainDir(tmpDir);
+
+    expect(paths.apis).toContain(join(apiDir, 'simple.ts'));
+  });
+
+  it('should recursively find .ts files in nested api directories', async () => {
+    const nestedDir = join(tmpDir, 'api', 'users', 'v1');
+    await mkdir(nestedDir, { recursive: true });
+    await writeFile(join(nestedDir, 'get.ts'), 'export const api = {}');
+
+    const paths = await walkDomainDir(tmpDir);
+
+    expect(paths.apis).toContain(join(nestedDir, 'get.ts'));
+  });
+
+  it('should skip __tests__ directories', async () => {
+    const testDir = join(tmpDir, 'api', '__tests__');
+    await mkdir(testDir, { recursive: true });
+    await writeFile(join(testDir, 'test.ts'), 'export const test = {}');
+
+    const paths = await walkDomainDir(tmpDir);
+
+    expect(paths.apis).not.toContain(join(testDir, 'test.ts'));
+  });
+
+  it('should skip dist directories', async () => {
+    const distDir = join(tmpDir, 'api', 'dist');
+    await mkdir(distDir, { recursive: true });
+    await writeFile(join(distDir, 'bundle.ts'), 'export const bundle = {}');
+
+    const paths = await walkDomainDir(tmpDir);
+
+    expect(paths.apis).not.toContain(join(distDir, 'bundle.ts'));
+  });
+
+  it('should skip node_modules directories', async () => {
+    const nodeModulesDir = join(tmpDir, 'api', 'node_modules');
+    await mkdir(nodeModulesDir, { recursive: true });
+    await writeFile(join(nodeModulesDir, 'dep.ts'), 'export const dep = {}');
+
+    const paths = await walkDomainDir(tmpDir);
+
+    expect(paths.apis).not.toContain(join(nodeModulesDir, 'dep.ts'));
+  });
+
+  it('should discover files in all domain primitive directories', async () => {
+    // Create files in all conventional directories
+    const dirs = ['api', 'webhooks', 'subscribers', 'actions', 'schedules', 'jobs', 'integrations'];
+
+    for (const dir of dirs) {
+      const dirPath = join(tmpDir, dir, 'nested', 'deep');
+      await mkdir(dirPath, { recursive: true });
+      await writeFile(join(dirPath, `${dir}-handler.ts`), `export const ${dir} = {}`);
+    }
+
+    const paths = await walkDomainDir(tmpDir);
+
+    // Verify files are found in correct slots
+    expect(paths.apis.some(p => p.includes('api-handler.ts'))).toBe(true);
+    expect(paths.webhooks.some(p => p.includes('webhooks-handler.ts'))).toBe(true);
+    expect(paths.subscribers.some(p => p.includes('subscribers-handler.ts'))).toBe(true);
+    expect(paths.actions.some(p => p.includes('actions-handler.ts'))).toBe(true);
+    expect(paths.schedules.some(p => p.includes('schedules-handler.ts'))).toBe(true);
+    expect(paths.jobs.some(p => p.includes('jobs-handler.ts'))).toBe(true);
+    expect(paths.integrations.some(p => p.includes('integrations-handler.ts'))).toBe(true);
+  });
+
+  it('should find domain.config.ts at root', async () => {
+    await writeFile(join(tmpDir, 'domain.config.ts'), 'export const domain = {}');
+
+    const paths = await walkDomainDir(tmpDir);
+
+    expect(paths.domain).toBe(join(tmpDir, 'domain.config.ts'));
+  });
+
+  it('should find publishes/events.ts', async () => {
+    const publishDir = join(tmpDir, 'publishes');
+    await mkdir(publishDir, { recursive: true });
+    await writeFile(join(publishDir, 'events.ts'), 'export const events = {}');
+
+    const paths = await walkDomainDir(tmpDir);
+
+    expect(paths.publishes).toBe(join(publishDir, 'events.ts'));
+  });
+
+  it('should return empty arrays for missing directories', async () => {
+    const paths = await walkDomainDir(tmpDir);
+
+    expect(paths.apis).toEqual([]);
+    expect(paths.webhooks).toEqual([]);
+    expect(paths.subscribers).toEqual([]);
+    expect(paths.actions).toEqual([]);
+    expect(paths.schedules).toEqual([]);
+    expect(paths.jobs).toEqual([]);
+    expect(paths.integrations).toEqual([]);
+  });
+
+  it('should return undefined for missing domain.config.ts and publishes/events.ts', async () => {
+    const paths = await walkDomainDir(tmpDir);
+
+    expect(paths.domain).toBeUndefined();
+    expect(paths.publishes).toBeUndefined();
+  });
+
+  it('should handle deeply nested files', async () => {
+    const deepPath = join(tmpDir, 'api', 'v1', 'users', 'admin', 'permissions');
+    await mkdir(deepPath, { recursive: true });
+    await writeFile(join(deepPath, 'check.ts'), 'export const api = {}');
+
+    const paths = await walkDomainDir(tmpDir);
+
+    expect(paths.apis.some(p => p.includes('check.ts'))).toBe(true);
+  });
+});

package/src/__tests__/commands/add-domain.test.ts

@@ -0,0 +1,174 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtemp, rmdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { readFile, stat } from 'node:fs/promises';
+import { runAddDomain, type AddDomainOptions } from '../../commands/add-domain.js';
+import { getScaffoldConfig } from '../../utils/scaffold-config.js';
+
+describe('add-domain command', () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await mkdtemp(join(tmpdir(), 'tib-test-'));
+  });
+
+  afterEach(async () => {
+    // Clean up temp directory
+    try {
+      await rmdir(tmpDir, { recursive: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  });
+
+  it('should scaffold a new domain with valid kebab-case id', async () => {
+    const opts: AddDomainOptions = {
+      id: 'test-domain',
+      tenancy: 'required',
+      domainsDir: tmpDir,
+    };
+
+    await runAddDomain(opts);
+
+    // Verify directory structure
+    const domainDir = join(tmpDir, 'test-domain');
+    await stat(join(domainDir, 'api'));
+    await stat(join(domainDir, 'subscribers'));
+    await stat(join(domainDir, 'publishes'));
+
+    // Verify skeleton files
+    const configContent = await readFile(join(domainDir, 'domain.config.ts'), 'utf8');
+    expect(configContent).toContain(`id: 'test-domain'`);
+    expect(configContent).toContain(`tenancy: 'required'`);
+
+    const apiContent = await readFile(join(domainDir, 'api', 'example.ts'), 'utf8');
+    expect(apiContent).toContain(`id: 'example'`);
+    expect(apiContent).toContain('defineApi');
+
+    const eventsContent = await readFile(join(domainDir, 'publishes', 'events.ts'), 'utf8');
+    expect(eventsContent).toContain(`id: 'test-domain.example'`);
+    expect(eventsContent).toContain('defineEvent');
+  });
+
+  it('should scaffold CLAUDE.md and README.md with correct content', async () => {
+    const opts: AddDomainOptions = {
+      id: 'my-feature',
+      tenancy: 'required',
+      domainsDir: tmpDir,
+    };
+
+    await runAddDomain(opts);
+
+    const domainDir = join(tmpDir, 'my-feature');
+
+    // CLAUDE.md must exist
+    await stat(join(domainDir, 'CLAUDE.md'));
+    const claudeContent = await readFile(join(domainDir, 'CLAUDE.md'), 'utf8');
+    expect(claudeContent).toContain('my-feature');
+    expect(claudeContent).toContain('domain owner');
+
+    // README.md must exist
+    await stat(join(domainDir, 'README.md'));
+    const readmeContent = await readFile(join(domainDir, 'README.md'), 'utf8');
+    // Title-cased domain name should appear in README
+    expect(readmeContent).toContain('My Feature');
+  });
+
+  it('should register domain in scaffold config', async () => {
+    const opts: AddDomainOptions = {
+      id: 'another-domain',
+      tenancy: 'none',
+      domainsDir: tmpDir,
+    };
+
+    await runAddDomain(opts);
+
+    // Verify scaffold config
+    const config = await getScaffoldConfig(tmpDir);
+    expect(config.domainIds).toContain('another-domain');
+  });
+
+  it('should be idempotent — calling twice should not duplicate', async () => {
+    const opts: AddDomainOptions = {
+      id: 'idempotent-domain',
+      tenancy: 'system',
+      domainsDir: tmpDir,
+    };
+
+    await runAddDomain(opts);
+
+    // Read config after first scaffold
+    let config = await getScaffoldConfig(tmpDir);
+    const count1 = config.domainIds.filter(id => id === 'idempotent-domain').length;
+    expect(count1).toBe(1);
+
+    // Try to scaffold again (should fail because directory exists)
+    await expect(runAddDomain(opts)).rejects.toThrow(/already exists/);
+
+    // Verify config still has only one entry
+    config = await getScaffoldConfig(tmpDir);
+    const count2 = config.domainIds.filter(id => id === 'idempotent-domain').length;
+    expect(count2).toBe(1);
+  });
+
+  it('should reject invalid kebab-case ids', async () => {
+    const invalidIds = ['MyDomain', '123-foo', 'foo_bar', 'Foo-Bar', '-foo'];
+
+    for (const id of invalidIds) {
+      const opts: AddDomainOptions = {
+        id,
+        tenancy: 'required',
+        domainsDir: tmpDir,
+      };
+
+      await expect(runAddDomain(opts)).rejects.toThrow(/Invalid domain id/);
+    }
+  });
+
+  it('should sort domain ids in scaffold config', async () => {
+    // Scaffold in non-alphabetical order
+    await runAddDomain({
+      id: 'zebra-domain',
+      tenancy: 'required',
+      domainsDir: tmpDir,
+    });
+
+    await runAddDomain({
+      id: 'alpha-domain',
+      tenancy: 'required',
+      domainsDir: tmpDir,
+    });
+
+    const config = await getScaffoldConfig(tmpDir);
+    expect(config.domainIds).toEqual(['alpha-domain', 'zebra-domain']);
+  });
+
+  it('should set correct tenancy mode in templates', async () => {
+    await runAddDomain({
+      id: 'system-domain',
+      tenancy: 'system',
+      domainsDir: tmpDir,
+    });
+
+    const configContent = await readFile(join(tmpDir, 'system-domain', 'domain.config.ts'), 'utf8');
+    expect(configContent).toContain(`tenancy: 'system'`);
+
+    const apiContent = await readFile(join(tmpDir, 'system-domain', 'api', 'example.ts'), 'utf8');
+    expect(apiContent).toContain(`tenancy: 'system'`);
+    // For 'system' tenancy, path should not include /v1/tenants/{tenantId}
+    expect(apiContent).toContain(`path: '/v1/system-domain/example'`);
+  });
+
+  it('should use correct path structure for required tenancy', async () => {
+    await runAddDomain({
+      id: 'tenant-domain',
+      tenancy: 'required',
+      domainsDir: tmpDir,
+    });
+
+    const apiContent = await readFile(join(tmpDir, 'tenant-domain', 'api', 'example.ts'), 'utf8');
+    // For 'required' tenancy, path should include /v1/tenants/{tenantId}
+    expect(apiContent).toContain(`path: '/v1/tenants/{tenantId}/tenant-domain/example'`);
+  });
+});