@mettlecast/domain-cli 0.2.0

package/src/__tests__/commands/create-project.test.ts

@@ -0,0 +1,712 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+// Mock all external dependencies
+vi.mock('../../utils/s3-fetch.js', () => ({
+  fetchVersionsJson: vi.fn(),
+  fetchModulesJson: vi.fn(),
+  fetchModuleTarball: vi.fn(),
+}));
+
+vi.mock('node:readline', () => ({
+  createInterface: vi.fn(),
+}));
+
+vi.mock('node:child_process', () => ({
+  execSync: vi.fn(),
+}));
+
+vi.mock('../../utils/logger.js', () => ({
+  cliLogger: {
+    info: vi.fn(),
+    warn: vi.fn(),
+  },
+}));
+
+// Import after mocking
+import { runCreateProject } from '../../commands/create-project.js';
+import { fetchVersionsJson, fetchModulesJson, fetchModuleTarball } from '../../utils/s3-fetch.js';
+import { createInterface } from 'node:readline';
+import { execSync } from 'node:child_process';
+import * as tar from 'tar';
+import { Readable } from 'node:stream';
+
+const mockFetchVersionsJson = vi.mocked(fetchVersionsJson);
+const mockFetchModulesJson = vi.mocked(fetchModulesJson);
+const mockFetchModuleTarball = vi.mocked(fetchModuleTarball);
+const mockCreateInterface = vi.mocked(createInterface);
+const mockExecSync = vi.mocked(execSync);
+
+/**
+ * Create a minimal in-memory tarball with the given files.
+ * Each file is a { path, content, isTemplate } object.
+ */
+async function createTestTarball(files: Array<{
+  path: string;
+  content: string;
+  isTemplate: boolean;
+}>): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    const pack = tar.create({ gzip: true }, files.map((f) => ({ path: f.path })));
+
+    pack.on('data', (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+
+    pack.on('end', () => {
+      resolve(Buffer.concat(chunks));
+    });
+
+    pack.on('error', reject);
+
+    // Write mock data
+    for (const file of files) {
+      pack.write({ path: file.path, content: file.content });
+    }
+    pack.end();
+  });
+}
+
+/**
+ * Helper to create a MANIFEST.json for a tarball
+ */
+function createTarballManifest(files: Array<{ path: string; isTemplate: boolean }>): string {
+  return JSON.stringify(
+    files.map((f) => ({
+      path: f.path,
+      sha256: 'fakehash',
+      isTemplate: f.isTemplate,
+    })),
+    null,
+    2
+  );
+}
+
+/**
+ * Mock the readline interface with pre-set answers
+ */
+function mockReadlineWithAnswers(answers: Record<string, string>): void {
+  const answerQueue = Object.values(answers);
+  let answerIdx = 0;
+
+  const mockRl = {
+    question: vi.fn((question: string, callback: (answer: string) => void) => {
+      const answer = answerQueue[answerIdx] || '';
+      answerIdx++;
+      setImmediate(() => callback(answer));
+    }),
+    close: vi.fn(),
+  };
+
+  mockCreateInterface.mockReturnValue(mockRl as any);
+}
+
+describe('runCreateProject', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `test-tib-${randomUUID()}`);
+    vi.clearAllMocks();
+    mockExecSync.mockImplementation(() => '');
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('AC1: No @mettlecast/* or @mettlecast/* in generated package.json', async () => {
+    const outputDir = join(tempDir, 'project1');
+
+    // Mock versions and modules
+    mockFetchVersionsJson.mockResolvedValue({
+      latest: '1.0.0',
+      versions: ['1.0.0'],
+    });
+
+    mockFetchModulesJson.mockResolvedValue({
+      scaffoldVersion: '1.0.0',
+      releasedAt: '2026-05-08',
+      modules: [
+        {
+          id: 'core',
+          version: '1.0.0',
+          description: 'Core module',
+          dependencies: [],
+          tarball: 'core.tar.gz',
+          sha256: 'abc123',
+        },
+        {
+          id: 'backend-lambda',
+          version: '1.0.0',
+          description: 'Backend Lambda',
+          dependencies: ['core'],
+          tarball: 'backend-lambda.tar.gz',
+          sha256: 'def456',
+        },
+      ],
+      compatibility: { cliMinVersion: '0.1.0', nodeMinVersion: '18.0.0' },
+    });
+
+    // Create a fake package.json with no @mettlecast/* deps
+    const packageJsonContent = JSON.stringify({
+      name: 'test-project',
+      version: '1.0.0',
+      dependencies: {
+        express: '^4.18.0',
+        'uuid': '^9.0.0',
+      },
+      devDependencies: {
+        typescript: '^5.0.0',
+      },
+    });
+
+    // Create tarballs with package.json
+    const coreTarball = await createTestTarball([
+      {
+        path: 'package.json.tpl',
+        content: packageJsonContent,
+        isTemplate: false,
+      },
+      {
+        path: 'MANIFEST.json',
+        content: createTarballManifest([
+          { path: 'package.json.tpl', isTemplate: false },
+        ]),
+        isTemplate: false,
+      },
+    ]);
+
+    const backendTarball = await createTestTarball([
+      {
+        path: 'src/index.ts',
+        content: 'export const handler = async () => ({});',
+        isTemplate: false,
+      },
+      {
+        path: 'MANIFEST.json',
+        content: createTarballManifest([{ path: 'src/index.ts', isTemplate: false }]),
+        isTemplate: false,
+      },
+    ]);
+
+    mockFetchModuleTarball
+      .mockResolvedValueOnce(coreTarball)
+      .mockResolvedValueOnce(backendTarball);
+
+    mockReadlineWithAnswers({
+      projectName: 'test-project',
+      awsRegion: 'eu-north-1',
+      awsAccountId: '123456789012',
+      database: '',
+      auth: '',
+      frontend: '',
+      flows: '',
+      outputDir: outputDir,
+      scaffoldVersion: '1.0.0',
+    });
+
+    await runCreateProject({ name: 'test-project', outDir: tempDir });
+
+    // Read the generated package.json
+    const pkgPath = join(outputDir, 'package.json');
+    const pkgContent = await readFile(pkgPath, 'utf-8');
+
+    expect(pkgContent).not.toContain('@mettlecast/');
+    expect(pkgContent).not.toContain('@mettlecast/');
+    expect(pkgContent).toContain('express');
+  });
+
+  it('AC5: Generated domain imports use local path instead of @mettlecast/domain-runtime', async () => {
+    const outputDir = join(tempDir, 'project2');
+
+    mockFetchVersionsJson.mockResolvedValue({
+      latest: '1.0.0',
+      versions: ['1.0.0'],
+    });
+
+    mockFetchModulesJson.mockResolvedValue({
+      scaffoldVersion: '1.0.0',
+      releasedAt: '2026-05-08',
+      modules: [
+        {
+          id: 'core',
+          version: '1.0.0',
+          description: 'Core module',
+          dependencies: [],
+          tarball: 'core.tar.gz',
+          sha256: 'abc123',
+        },
+        {
+          id: 'backend-lambda',
+          version: '1.0.0',
+          description: 'Backend Lambda',
+          dependencies: ['core'],
+          tarball: 'backend-lambda.tar.gz',
+          sha256: 'def456',
+        },
+        {
+          id: 'auth-cognito',
+          version: '1.0.0',
+          description: 'Auth Cognito',
+          dependencies: ['core', 'backend-lambda'],
+          tarball: 'auth-cognito.tar.gz',
+          sha256: 'ghi789',
+        },
+      ],
+      compatibility: { cliMinVersion: '0.1.0', nodeMinVersion: '18.0.0' },
+    });
+
+    const coreTarball = await createTestTarball([
+      {
+        path: 'lib/domain-runtime.ts',
+        content: 'export const defineApi = () => {};',
+        isTemplate: false,
+      },
+      {
+        path: 'MANIFEST.json',
+        content: createTarballManifest([
+          { path: 'lib/domain-runtime.ts', isTemplate: false },
+        ]),
+        isTemplate: false,
+      },
+    ]);
+
+    const backendTarball = await createTestTarball([
+      {
+        path: 'MANIFEST.json',
+        content: createTarballManifest([]),
+        isTemplate: false,
+      },
+    ]);
+
+    const authTarball = await createTestTarball([
+      {
+        path: 'domains/auth/api/login.ts',
+        content: 'import { defineApi } from "../../lib/domain-runtime";',
+        isTemplate: false,
+      },
+      {
+        path: 'MANIFEST.json',
+        content: createTarballManifest([
+          { path: 'domains/auth/api/login.ts', isTemplate: false },
+        ]),
+        isTemplate: false,
+      },
+    ]);
+
+    mockFetchModuleTarball
+      .mockResolvedValueOnce(coreTarball)
+      .mockResolvedValueOnce(backendTarball)
+      .mockResolvedValueOnce(authTarball);
+
+    mockReadlineWithAnswers({
+      projectName: 'test-project',
+      awsRegion: 'eu-north-1',
+      awsAccountId: '123456789012',
+      database: '',
+      auth: 'y',
+      frontend: '',
+      flows: '',
+      adminEmail: 'admin@example.com',
+      outputDir: outputDir,
+      scaffoldVersion: '1.0.0',
+    });
+
+    await runCreateProject({ name: 'test-project', outDir: tempDir });
+
+    // Read the generated auth login file
+    const authPath = join(outputDir, 'domains/auth/api/login.ts');
+    const authContent = await readFile(authPath, 'utf-8');
+
+    expect(authContent).toContain('../../lib/domain-runtime');
+    expect(authContent).not.toContain('@mettlecast/domain-runtime');
+  });
+
+  it('Core module files are written before backend-lambda files (topological order)', async () => {
+    const outputDir = join(tempDir, 'project3');
+    const writeCallOrder: string[] = [];
+
+    mockFetchVersionsJson.mockResolvedValue({
+      latest: '1.0.0',
+      versions: ['1.0.0'],
+    });
+
+    mockFetchModulesJson.mockResolvedValue({
+      scaffoldVersion: '1.0.0',
+      releasedAt: '2026-05-08',
+      modules: [
+        {
+          id: 'core',
+          version: '1.0.0',
+          description: 'Core module',
+          dependencies: [],
+          tarball: 'core.tar.gz',
+          sha256: 'abc123',
+        },
+        {
+          id: 'backend-lambda',
+          version: '1.0.0',
+          description: 'Backend Lambda',
+          dependencies: ['core'],
+          tarball: 'backend-lambda.tar.gz',
+          sha256: 'def456',
+        },
+      ],
+      compatibility: { cliMinVersion: '0.1.0', nodeMinVersion: '18.0.0' },
+    });
+
+    const coreTarball = await createTestTarball([
+      {
+        path: 'core-file.txt',
+        content: 'core',
+        isTemplate: false,
+      },
+      {
+        path: 'MANIFEST.json',
+        content: createTarballManifest([
+          { path: 'core-file.txt', isTemplate: false },
+        ]),
+        isTemplate: false,
+      },
+    ]);
+
+    const backendTarball = await createTestTarball([
+      {
+        path: 'backend-file.txt',
+        content: 'backend',
+        isTemplate: false,
+      },
+      {
+        path: 'MANIFEST.json',
+        content: createTarballManifest([
+          { path: 'backend-file.txt', isTemplate: false },
+        ]),
+        isTemplate: false,
+      },
+    ]);
+
+    // Spy on writeFile to track order
+    let originalWriteFile: any;
+    let writeFileOrder: string[] = [];
+
+    // Import and spy
+    const fsModule = await import('node:fs/promises');
+    originalWriteFile = fsModule.writeFile;
+    vi.spyOn(fsModule, 'writeFile').mockImplementation(async (path, content) => {
+      writeFileOrder.push(String(path));
+      return originalWriteFile(path, content);
+    });
+
+    mockFetchModuleTarball
+      .mockResolvedValueOnce(coreTarball)
+      .mockResolvedValueOnce(backendTarball);
+
+    mockReadlineWithAnswers({
+      projectName: 'test-project',
+      awsRegion: 'eu-north-1',
+      awsAccountId: '123456789012',
+      database: '',
+      auth: '',
+      frontend: '',
+      flows: '',
+      outputDir: outputDir,
+      scaffoldVersion: '1.0.0',
+    });
+
+    await runCreateProject({ name: 'test-project', outDir: tempDir });
+
+    // Find indices of core and backend files in write order
+    const coreFileIdx = writeFileOrder.findIndex((p) => p.includes('core-file.txt'));
+    const backendFileIdx = writeFileOrder.findIndex((p) => p.includes('backend-file.txt'));
+
+    expect(coreFileIdx).toBeLessThan(backendFileIdx);
+  });
+
+  it('Header comment present in generated .ts files', async () => {
+    const outputDir = join(tempDir, 'project4');
+
+    mockFetchVersionsJson.mockResolvedValue({
+      latest: '1.0.0',
+      versions: ['1.0.0'],
+    });
+
+    mockFetchModulesJson.mockResolvedValue({
+      scaffoldVersion: '1.0.0',
+      releasedAt: '2026-05-08',
+      modules: [
+        {
+          id: 'core',
+          version: '1.0.0',
+          description: 'Core module',
+          dependencies: [],
+          tarball: 'core.tar.gz',
+          sha256: 'abc123',
+        },
+        {
+          id: 'backend-lambda',
+          version: '1.0.0',
+          description: 'Backend Lambda',
+          dependencies: ['core'],
+          tarball: 'backend-lambda.tar.gz',
+          sha256: 'def456',
+        },
+      ],
+      compatibility: { cliMinVersion: '0.1.0', nodeMinVersion: '18.0.0' },
+    });
+
+    const coreTarball = await createTestTarball([
+      {
+        path: 'lib/helpers.ts',
+        content: 'export const helper = () => {};',
+        isTemplate: false,
+      },
+      {
+        path: 'MANIFEST.json',
+        content: createTarballManifest([
+          { path: 'lib/helpers.ts', isTemplate: false },
+        ]),
+        isTemplate: false,
+      },
+    ]);
+
+    const backendTarball = await createTestTarball([
+      {
+        path: 'src/handler.ts',
+        content: 'export const handler = async () => ({});',
+        isTemplate: false,
+      },
+      {
+        path: 'MANIFEST.json',
+        content: createTarballManifest([
+          { path: 'src/handler.ts', isTemplate: false },
+        ]),
+        isTemplate: false,
+      },
+    ]);
+
+    mockFetchModuleTarball
+      .mockResolvedValueOnce(coreTarball)
+      .mockResolvedValueOnce(backendTarball);
+
+    mockReadlineWithAnswers({
+      projectName: 'test-project',
+      awsRegion: 'eu-north-1',
+      awsAccountId: '123456789012',
+      database: '',
+      auth: '',
+      frontend: '',
+      flows: '',
+      outputDir: outputDir,
+      scaffoldVersion: '1.0.0',
+    });
+
+    await runCreateProject({ name: 'test-project', outDir: tempDir });
+
+    // Read both generated .ts files
+    const helperPath = join(outputDir, 'lib/helpers.ts');
+    const helperContent = await readFile(helperPath, 'utf-8');
+    expect(helperContent).toMatch(/^\/\/ @mc-scaffold:/);
+
+    const handlerPath = join(outputDir, 'src/handler.ts');
+    const handlerContent = await readFile(handlerPath, 'utf-8');
+    expect(handlerContent).toMatch(/^\/\/ @mc-scaffold:/);
+  });
+
+  it('Manifest written with correct schema and all file entries', async () => {
+    const outputDir = join(tempDir, 'project5');
+
+    mockFetchVersionsJson.mockResolvedValue({
+      latest: '1.0.0',
+      versions: ['1.0.0'],
+    });
+
+    mockFetchModulesJson.mockResolvedValue({
+      scaffoldVersion: '1.0.0',
+      releasedAt: '2026-05-08',
+      modules: [
+        {
+          id: 'core',
+          version: '1.0.0',
+          description: 'Core module',
+          dependencies: [],
+          tarball: 'core.tar.gz',
+          sha256: 'abc123',
+        },
+        {
+          id: 'backend-lambda',
+          version: '1.0.0',
+          description: 'Backend Lambda',
+          dependencies: ['core'],
+          tarball: 'backend-lambda.tar.gz',
+          sha256: 'def456',
+        },
+      ],
+      compatibility: { cliMinVersion: '0.1.0', nodeMinVersion: '18.0.0' },
+    });
+
+    const coreTarball = await createTestTarball([
+      {
+        path: 'core-config.json',
+        content: JSON.stringify({ coreValue: true }),
+        isTemplate: false,
+      },
+      {
+        path: 'MANIFEST.json',
+        content: createTarballManifest([
+          { path: 'core-config.json', isTemplate: false },
+        ]),
+        isTemplate: false,
+      },
+    ]);
+
+    const backendTarball = await createTestTarball([
+      {
+        path: 'backend-config.json',
+        content: JSON.stringify({ backendValue: true }),
+        isTemplate: false,
+      },
+      {
+        path: 'MANIFEST.json',
+        content: createTarballManifest([
+          { path: 'backend-config.json', isTemplate: false },
+        ]),
+        isTemplate: false,
+      },
+    ]);
+
+    mockFetchModuleTarball
+      .mockResolvedValueOnce(coreTarball)
+      .mockResolvedValueOnce(backendTarball);
+
+    mockReadlineWithAnswers({
+      projectName: 'test-project',
+      awsRegion: 'eu-north-1',
+      awsAccountId: '123456789012',
+      database: '',
+      auth: '',
+      frontend: '',
+      flows: '',
+      outputDir: outputDir,
+      scaffoldVersion: '1.0.0',
+    });
+
+    await runCreateProject({ name: 'test-project', outDir: tempDir });
+
+    // Read the manifest
+    const manifestPath = join(outputDir, '.mc/manifest.json');
+    const manifestContent = await readFile(manifestPath, 'utf-8');
+    const manifest = JSON.parse(manifestContent);
+
+    // Verify schema fields
+    expect(manifest.$schema).toBeDefined();
+    expect(manifest.scaffoldVersion).toBe('1.0.0');
+    expect(manifest.projectName).toBe('test-project');
+    expect(manifest.awsRegion).toBe('eu-north-1');
+    expect(manifest.createdAt).toBeDefined();
+    expect(manifest.updatedAt).toBeDefined();
+    expect(manifest.enabledModules).toContain('core');
+    expect(manifest.enabledModules).toContain('backend-lambda');
+
+    // Verify file entries
+    expect(manifest.files).toBeInstanceOf(Array);
+    expect(manifest.files.length).toBeGreaterThanOrEqual(2);
+
+    const coreFile = manifest.files.find((f: any) => f.path === 'core-config.json');
+    expect(coreFile).toBeDefined();
+    expect(coreFile.module).toBe('core');
+    expect(coreFile.moduleVersion).toBe('1.0.0');
+    expect(coreFile.sha256).toBeDefined();
+    expect(coreFile.wasTemplate).toBe(false);
+    expect(coreFile.installedAt).toBeDefined();
+
+    const backendFile = manifest.files.find((f: any) => f.path === 'backend-config.json');
+    expect(backendFile).toBeDefined();
+    expect(backendFile.module).toBe('backend-lambda');
+    expect(backendFile.moduleVersion).toBe('1.0.0');
+  });
+
+  it('Scaffold config written with correct module list', async () => {
+    const outputDir = join(tempDir, 'project6');
+
+    mockFetchVersionsJson.mockResolvedValue({
+      latest: '1.0.0',
+      versions: ['1.0.0'],
+    });
+
+    mockFetchModulesJson.mockResolvedValue({
+      scaffoldVersion: '1.0.0',
+      releasedAt: '2026-05-08',
+      modules: [
+        {
+          id: 'core',
+          version: '1.0.0',
+          description: 'Core module',
+          dependencies: [],
+          tarball: 'core.tar.gz',
+          sha256: 'abc123',
+        },
+        {
+          id: 'backend-lambda',
+          version: '1.0.0',
+          description: 'Backend Lambda',
+          dependencies: ['core'],
+          tarball: 'backend-lambda.tar.gz',
+          sha256: 'def456',
+        },
+        {
+          id: 'db-aurora',
+          version: '1.0.0',
+          description: 'DB Aurora',
+          dependencies: ['core'],
+          tarball: 'db-aurora.tar.gz',
+          sha256: 'jkl012',
+        },
+      ],
+      compatibility: { cliMinVersion: '0.1.0', nodeMinVersion: '18.0.0' },
+    });
+
+    const minimalTarball = await createTestTarball([
+      {
+        path: 'MANIFEST.json',
+        content: createTarballManifest([]),
+        isTemplate: false,
+      },
+    ]);
+
+    mockFetchModuleTarball
+      .mockResolvedValue(minimalTarball);
+
+    mockReadlineWithAnswers({
+      projectName: 'test-project',
+      awsRegion: 'eu-north-1',
+      awsAccountId: '123456789012',
+      database: 'y',
+      auth: '',
+      frontend: '',
+      flows: '',
+      outputDir: outputDir,
+      scaffoldVersion: '1.0.0',
+    });
+
+    await runCreateProject({ name: 'test-project', outDir: tempDir });
+
+    // Read scaffold config
+    const configPath = join(outputDir, '.mc/scaffold-config.json');
+    const configContent = await readFile(configPath, 'utf-8');
+    const config = JSON.parse(configContent);
+
+    expect(config.scaffoldVersion).toBe('1.0.0');
+    expect(config.projectName).toBe('test-project');
+    expect(config.awsRegion).toBe('eu-north-1');
+    expect(config.awsAccountId).toBe('123456789012');
+    expect(config.enabledModules).toContain('core');
+    expect(config.enabledModules).toContain('backend-lambda');
+    expect(config.enabledModules).toContain('db-aurora');
+    expect(config.domainIds).toEqual([]);
+    expect(config.flowIds).toEqual([]);
+  });
+});