@ankhorage/infra 4.1.12 → 5.0.0

package/src/project/index.test.ts

@@ -1,195 +1,15 @@
-import { afterEach, describe, expect, test } from 'bun:test';
-import { promises as fs } from 'fs';
-import os from 'os';
-import path from 'path';
+import { describe, expect, test } from 'bun:test';
 
-import { createAppManifest } from '../testSupport.js';
 import {
-  ensureProjectInfrastructureRuntime,
-  inspectProjectInfrastructure,
-  readProjectInfrastructureEnvironment,
-  resolveProjectInfrastructureDatabaseUrl,
-  resolveProjectInfrastructurePortForward,
-  runProjectInfrastructureLifecycle,
+  readStoredInfraStateAsync,
+  resolveInfraProjectAsync,
+  writeInfraGeneratedArtifactsAsync,
 } from './index.js';
 
-const temporaryPaths: string[] = [];
-
-afterEach(async () => {
-  await Promise.all(
-    temporaryPaths.splice(0).map((entry) => fs.rm(entry, { force: true, recursive: true })),
-  );
-});
-
-async function createProjectFixture(): Promise<string> {
-  const projectPath = await fs.mkdtemp(path.join(os.tmpdir(), 'ankh-infra-project-'));
-  temporaryPaths.push(projectPath);
-  const infraRoot = path.join(projectPath, 'infra', 'minikube');
-  const scriptsRoot = path.join(infraRoot, 'scripts');
-  await fs.mkdir(scriptsRoot, { recursive: true });
-  await fs.writeFile(
-    path.join(scriptsRoot, 'status.sh'),
-    "#!/usr/bin/env bash\nprintf 'status-ok'\nprintf 'status-warning' >&2\n",
-    'utf8',
-  );
-  await fs.writeFile(
-    path.join(infraRoot, '.env.example'),
-    [
-      'APP_PORT_FORWARD_LOCAL_PORT=48123',
-      'SITE_URL=http://example.local',
-      'DATABASE_URL=postgres://example',
-      'PRIVATE_VALUE=not-selected',
-      '',
-    ].join('\n'),
-    'utf8',
-  );
-  return projectPath;
-}
-
 describe('@ankhorage/infra/project', () => {
-  test('executes generated lifecycle scripts without exposing script paths to consumers', async () => {
-    const projectPath = await createProjectFixture();
-    const stdout: string[] = [];
-    const stderr: string[] = [];
-
-    const result = await runProjectInfrastructureLifecycle({
-      projectId: 'example',
-      projectPath,
-      script: 'status',
-      target: 'minikube',
-      onStdout: (chunk) => stdout.push(chunk),
-      onStderr: (chunk) => stderr.push(chunk),
-    });
-
-    expect(result).toEqual({ stdout: 'status-ok', stderr: 'status-warning' });
-    expect(stdout.join('')).toBe('status-ok');
-    expect(stderr.join('')).toBe('status-warning');
-  });
-
-  test('resolves the generated app port-forward endpoint through the owner API', async () => {
-    const projectPath = await createProjectFixture();
-    const result = await resolveProjectInfrastructurePortForward({
-      projectPath,
-      target: 'minikube',
-    });
-
-    expect(result).toEqual({
-      localPort: 48123,
-      url: 'http://127.0.0.1:48123',
-    });
-  });
-
-  test('ensures the generated runtime port-forward group through the owner API', async () => {
-    const projectPath = await createProjectFixture();
-    const scriptPath = path.join(projectPath, 'infra', 'minikube', 'scripts', 'port-forward.sh');
-    await fs.writeFile(scriptPath, '#!/usr/bin/env bash\nprintf \'%s\' "$*"\n', 'utf8');
-
-    const result = await ensureProjectInfrastructureRuntime({
-      projectId: 'example',
-      projectPath,
-      target: 'minikube',
-    });
-
-    expect(result).toEqual({ stdout: 'start runtime', stderr: '' });
-  });
-
-  test('reports actionable runtime-forward failures without reconciling infrastructure', async () => {
-    const projectPath = await createProjectFixture();
-    const scriptPath = path.join(projectPath, 'infra', 'minikube', 'scripts', 'port-forward.sh');
-    await fs.writeFile(
-      scriptPath,
-      '#!/usr/bin/env bash\necho "app: target app/service/app-runtime not found"\nexit 1\n',
-      'utf8',
-    );
-
-    await expectRejectMessage(
-      ensureProjectInfrastructureRuntime({
-        projectId: 'example',
-        projectPath,
-        target: 'minikube',
-      }),
-      "Failed to ensure infrastructure runtime for project 'example': app: target app/service/app-runtime not found",
-    );
-  });
-
-  test('reads only requested runtime environment values from the generated fallback', async () => {
-    const projectPath = await createProjectFixture();
-    const result = await readProjectInfrastructureEnvironment({
-      keys: ['SITE_URL', 'MISSING_VALUE'],
-      projectPath,
-      target: 'minikube',
-    });
-
-    expect(result).toEqual({ SITE_URL: 'http://example.local' });
-  });
-
-  test('prefers generated runtime environment and resolves the trusted database URL', async () => {
-    const projectPath = await createProjectFixture();
-    const envPath = path.join(projectPath, 'infra', 'minikube', '.env');
-    await fs.writeFile(
-      envPath,
-      'SITE_URL=http://runtime.local\nDATABASE_URL=postgres://runtime\n',
-      'utf8',
-    );
-
-    const environment = await readProjectInfrastructureEnvironment({
-      keys: ['SITE_URL'],
-      projectPath,
-      target: 'minikube',
-    });
-    const databaseUrl = await resolveProjectInfrastructureDatabaseUrl({
-      projectPath,
-      target: 'minikube',
-    });
-
-    expect(environment).toEqual({ SITE_URL: 'http://runtime.local' });
-    expect(databaseUrl).toBe('postgres://runtime');
-  });
-
-  test('inspects deployment and generated state through the owner ledger', async () => {
-    const projectPath = await createProjectFixture();
-    await fs.mkdir(path.join(projectPath, '.ankh'), { recursive: true });
-    await fs.writeFile(
-      path.join(projectPath, '.ankh', 'infra-ledger.json'),
-      JSON.stringify({
-        schemaVersion: 1,
-        generatedAt: '2026-08-12T04:00:00.000Z',
-        target: 'minikube',
-        files: ['infra/minikube/.env.example', 'infra/minikube/scripts/status.sh'],
-        warnings: ['generated warning'],
-      }),
-      'utf8',
-    );
-    const manifest = createAppManifest('example', {
-      deployment: { monitoring: false, target: 'minikube' },
-      modules: [],
-    });
-
-    const result = await inspectProjectInfrastructure({
-      manifest,
-      projectId: 'example',
-      projectPath,
-    });
-
-    expect(result).toEqual({
-      generated: true,
-      generatedAt: '2026-08-12T04:00:00.000Z',
-      hasDeployment: true,
-      target: 'minikube',
-      trackedFiles: 2,
-      warnings: ['generated warning'],
-    });
+  test('exports project resolution, safe state and artifact owner APIs', () => {
+    expect(resolveInfraProjectAsync).toBeFunction();
+    expect(readStoredInfraStateAsync).toBeFunction();
+    expect(writeInfraGeneratedArtifactsAsync).toBeFunction();
   });
 });
-
-async function expectRejectMessage(
-  promise: Promise<unknown>,
-  expectedMessage: string,
-): Promise<void> {
-  try {
-    await promise;
-    throw new Error('Expected operation to reject.');
-  } catch (error) {
-    expect(error instanceof Error ? error.message : String(error)).toContain(expectedMessage);
-  }
-}

package/src/project/index.ts

@@ -1,22 +1,7 @@
-export {
-  type ResolvedInfraProject,
-  resolveInfraProject as resolveInfraWorkspaceProject,
-} from '../project.js';
-export { resolveProjectInfrastructureDatabaseUrl } from '../projectDatabase.js';
-export { readProjectInfrastructureEnvironment } from '../projectEnvironment.js';
-export {
-  type InfraProjectInspection,
-  type InfraSyncResult,
-  inspectProjectInfrastructure,
-  resolveProjectInfrastructureTarget,
-  syncProjectInfrastructure,
-} from '../projectInfrastructure.js';
-export {
-  ensureProjectInfrastructureRuntime,
-  type InfraLifecycleScript,
-  type InfraPortForwardInfo,
-  InfraScriptExecutionError,
-  type InfraScriptOutput,
-  resolveProjectInfrastructurePortForward,
-  runProjectInfrastructureLifecycle,
-} from '../runtime.js';
+export { readStoredInfraStateAsync } from '../features/environment-lifecycle/adapters/outbound/readStoredInfraStateAsync.js';
+export { removeStoredInfraStateAsync } from '../features/environment-lifecycle/adapters/outbound/removeStoredInfraStateAsync.js';
+export { resolveInfraProjectAsync } from '../features/environment-lifecycle/adapters/outbound/resolveInfraProjectAsync.js';
+export { writeInfraGeneratedArtifactsAsync } from '../features/environment-lifecycle/adapters/outbound/writeInfraGeneratedArtifactsAsync.js';
+export { writeStoredInfraStateAsync } from '../features/environment-lifecycle/adapters/outbound/writeStoredInfraStateAsync.js';
+export { resolveProjectFile } from '../features/environment-lifecycle/utils/resolveProjectFile.js';
+export type { InfraArtifactWriteResult, ResolvedInfraProject } from '../types/infraProject.js';

package/src/project.test.ts

@@ -3,216 +3,66 @@ import { promises as fs } from 'fs';
 import os from 'os';
 import path from 'path';
 
-import { resolveInfraProject } from './project.js';
-import { createAppManifest, createWorkspaceFixture } from './testSupport.js';
+import { resolveInfraProjectAsync } from './features/environment-lifecycle/adapters/outbound/resolveInfraProjectAsync.js';
+import { createWorkspaceFixture } from './testSupport.js';
 
-const tempRoots = new Set<string>();
+const temporaryPaths = new Set<string>();
 
 afterEach(async () => {
   await Promise.all(
-    [...tempRoots].map((rootPath) => fs.rm(rootPath, { force: true, recursive: true })),
+    [...temporaryPaths].map((entry) => fs.rm(entry, { force: true, recursive: true })),
   );
-  tempRoots.clear();
+  temporaryPaths.clear();
 });
 
-describe('resolveInfraProject', () => {
-  test('resolves an explicit project id from the workspace root', async () => {
+describe('project resolution', () => {
+  test('resolves explicit and cwd-inferred projects with canonical manifests', async () => {
     const fixture = await createWorkspaceFixture();
-    tempRoots.add(fixture.rootPath);
-
-    const project = await resolveInfraProject({
+    temporaryPaths.add(fixture.rootPath);
+    const explicit = await resolveInfraProjectAsync({
       cwd: fixture.rootPath,
       projectId: fixture.projectId,
     });
-
-    expect(project.projectId).toBe('shop');
-    expect(project.projectPath).toBe(fixture.projectPath);
-    expect(project.workspaceRoot).toBe(fixture.rootPath);
-  });
-
-  test('infers the project id from cwd inside apps/<project>', async () => {
-    const fixture = await createWorkspaceFixture();
-    tempRoots.add(fixture.rootPath);
-
-    const nestedPath = path.join(fixture.projectPath, 'src', 'modules');
-    await fs.mkdir(nestedPath, { recursive: true });
-
-    const project = await resolveInfraProject({
-      cwd: nestedPath,
-    });
-
-    expect(project.projectId).toBe('shop');
-    expect(project.projectPath).toBe(fixture.projectPath);
-  });
-
-  test('loads the fallback manifest when ankh.config.json is missing', async () => {
-    const fixture = await createWorkspaceFixture({
-      manifestFile: 'missing',
-    });
-    tempRoots.add(fixture.rootPath);
-
-    const project = await resolveInfraProject({
-      cwd: fixture.rootPath,
-      projectId: fixture.projectId,
-    });
-
-    expect(project.manifest.metadata.name).toBe('shop');
-    expect(project.manifest.metadata.slug).toBe('shop');
-    expect(project.manifest.infra.modules).toEqual([]);
-  });
-
-  test('rejects malformed manifest JSON', async () => {
-    const fixture = await createWorkspaceFixture({
-      manifestFile: 'invalid-json',
-    });
-    tempRoots.add(fixture.rootPath);
-
-    await expectRejectMessage(
-      resolveInfraProject({
-        cwd: fixture.rootPath,
-        projectId: fixture.projectId,
-      }),
-      'Project manifest is not valid JSON',
-    );
-  });
-
-  test('rejects traversal project ids', async () => {
-    const fixture = await createWorkspaceFixture();
-    tempRoots.add(fixture.rootPath);
-
-    await expectRejectMessage(
-      resolveInfraProject({
-        cwd: fixture.rootPath,
-        projectId: '../shop',
-      }),
-      'Invalid project id:',
+    const inferred = await resolveInfraProjectAsync({ cwd: fixture.projectPath });
+    expect(explicit.projectPath).toBe(fixture.projectPath);
+    expect(inferred.projectId).toBe(fixture.projectId);
+    expect(explicit.manifest.infra.environments.local.deployment.runtime.provider).toBe(
+      'docker-compose',
     );
   });
 
-  test('rejects explicit project ids with nested traversal segments', async () => {
-    const fixture = await createWorkspaceFixture();
-    tempRoots.add(fixture.rootPath);
-
-    await expectRejectMessage(
-      resolveInfraProject({
-        cwd: fixture.rootPath,
-        projectId: 'shop/../other',
-      }),
-      'Invalid project id:',
-    );
+  test('requires a real manifest and rejects malformed JSON', async () => {
+    const missing = await createWorkspaceFixture({ manifestFile: 'missing' });
+    const invalid = await createWorkspaceFixture({ manifestFile: 'invalid-json' });
+    temporaryPaths.add(missing.rootPath);
+    temporaryPaths.add(invalid.rootPath);
+    expect(
+      await captureError(resolveInfraProjectAsync({ cwd: missing.rootPath, projectId: 'shop' })),
+    ).toContain('Project manifest not found');
+    expect(
+      await captureError(resolveInfraProjectAsync({ cwd: invalid.rootPath, projectId: 'shop' })),
+    ).toContain('Project manifest is not valid JSON');
   });
 
-  test('rejects explicit absolute project ids', async () => {
+  test('rejects traversal and projects outside an Ankh workspace', async () => {
     const fixture = await createWorkspaceFixture();
-    tempRoots.add(fixture.rootPath);
-
-    await expectRejectMessage(
-      resolveInfraProject({
-        cwd: fixture.rootPath,
-        projectId: '/tmp/shop',
-      }),
-      'Invalid project id:',
-    );
-  });
-
-  test('rejects explicit dot project ids', async () => {
-    const fixture = await createWorkspaceFixture();
-    tempRoots.add(fixture.rootPath);
-
-    await expectRejectMessage(
-      resolveInfraProject({
-        cwd: fixture.rootPath,
-        projectId: '.',
-      }),
-      'Invalid project id:',
-    );
-  });
-
-  test('rejects explicit dot-dot project ids', async () => {
-    const fixture = await createWorkspaceFixture();
-    tempRoots.add(fixture.rootPath);
-
-    await expectRejectMessage(
-      resolveInfraProject({
-        cwd: fixture.rootPath,
-        projectId: '..',
-      }),
-      'Invalid project id:',
-    );
-  });
-
-  test('rejects explicit empty project ids', async () => {
-    const fixture = await createWorkspaceFixture();
-    tempRoots.add(fixture.rootPath);
-
-    await expectRejectMessage(
-      resolveInfraProject({
-        cwd: fixture.rootPath,
-        projectId: '',
-      }),
-      'Invalid project id:',
-    );
-  });
-
-  test('rejects explicit blank project ids', async () => {
-    const fixture = await createWorkspaceFixture();
-    tempRoots.add(fixture.rootPath);
-
-    await expectRejectMessage(
-      resolveInfraProject({
-        cwd: fixture.rootPath,
-        projectId: '   ',
-      }),
-      'Invalid project id:',
-    );
-  });
-
-  test('fails when no workspace root can be found', async () => {
-    const rootPath = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-no-root-'));
-    tempRoots.add(rootPath);
-
-    await expectRejectMessage(
-      resolveInfraProject({
-        cwd: rootPath,
-        projectId: 'shop',
-      }),
-      'Could not find an Ankh workspace root',
-    );
-  });
-
-  test('reads a valid project manifest', async () => {
-    const manifest = createAppManifest('cards', {
-      deployment: {
-        monitoring: false,
-        target: 'minikube',
-      },
-      modules: [],
-    });
-    const fixture = await createWorkspaceFixture({
-      manifest,
-      projectId: 'cards',
-    });
-    tempRoots.add(fixture.rootPath);
-
-    const project = await resolveInfraProject({
-      cwd: fixture.rootPath,
-      projectId: 'cards',
-    });
-
-    expect(project.manifest.metadata.name).toBe('cards');
-    expect(project.manifest.infra.deployment?.target).toBe('minikube');
+    const outside = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-outside-'));
+    temporaryPaths.add(fixture.rootPath);
+    temporaryPaths.add(outside);
+    expect(
+      await captureError(resolveInfraProjectAsync({ cwd: fixture.rootPath, projectId: '../shop' })),
+    ).toContain('Invalid project id');
+    expect(
+      await captureError(resolveInfraProjectAsync({ cwd: outside, projectId: 'shop' })),
+    ).toContain('Could not find an Ankh workspace root');
   });
 });
 
-async function expectRejectMessage(promise: Promise<unknown>, text: string): Promise<void> {
-  let didReject = false;
-
+async function captureError(operation: Promise<unknown>): Promise<string> {
   try {
-    await promise;
+    await operation;
   } catch (error) {
-    didReject = true;
-    expect(error instanceof Error ? error.message : String(error)).toContain(text);
+    return error instanceof Error ? error.message : String(error);
   }
-
-  expect(didReject).toBe(true);
+  throw new Error('Expected operation to fail.');
 }

package/src/projectContractsParser.test.ts

@@ -2,7 +2,7 @@ import { afterEach, expect, test } from 'bun:test';
 import { promises as fs } from 'fs';
 import path from 'path';
 
-import { resolveInfraProject } from './project.js';
+import { resolveInfraProjectAsync } from './features/environment-lifecycle/adapters/outbound/resolveInfraProjectAsync.js';
 import { createAppManifest, createWorkspaceFixture } from './testSupport.js';
 
 const tempRoots = new Set<string>();
@@ -33,7 +33,7 @@ test('Infra rejects nested manifest shapes rejected by Contracts', async () => {
   );
 
   const error = await captureError(
-    resolveInfraProject({ cwd: fixture.rootPath, projectId: fixture.projectId }),
+    resolveInfraProjectAsync({ cwd: fixture.rootPath, projectId: fixture.projectId }),
   );
   expect(error.message).toContain('Project manifest has an invalid shape');
 });