@ankhorage/infra 4.1.12 → 5.1.0

package/src/infraUp.test.ts

@@ -0,0 +1,260 @@
+import type {
+  InfraAdapterDescriptor,
+  InfraComputeAdapter,
+  InfraDiagnostic,
+  InfraEnvironmentSpec,
+  InfraOutput,
+  InfraResult,
+  InfraRuntimeAdapter,
+  InfraRuntimeDesiredState,
+  InfraServiceAdapter,
+  InfraWorkloadSpec,
+} from '@ankhorage/contracts/infra';
+import { INFRA_ADAPTER_CATALOG } from '@ankhorage/contracts/infra';
+import { describe, expect, it } from 'bun:test';
+
+import type { InfraAdapterPackageResolver } from './features/environment-lifecycle/application/ports/outbound/infraAdapterPackage';
+import { upInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/upInfraEnvironmentAsync';
+import type { InfraOrchestrationDependencies } from './types/infraOrchestration';
+
+const environment = {
+  deployment: { compute: { provider: 'local' }, runtime: { provider: 'docker-compose' } },
+  database: { provider: 'supabase' },
+  auth: { provider: 'supabase' },
+  authz: { provider: 'cerbos', kind: 'ABAC' },
+  workloads: [workload('app')],
+} as const satisfies InfraEnvironmentSpec;
+const manifest = { environments: { local: environment }, modules: [] } as const;
+
+describe('environment up orchestration', () => {
+  it('validates before mutation and reconciles compute, runtime and deduplicated services', async () => {
+    const calls: string[] = [];
+    const observedRuntimeDesired: InfraRuntimeDesiredState[] = [];
+    const observedServiceOutputs: InfraOutput[][] = [];
+    const dependencies = createDependencies(calls, observedRuntimeDesired, observedServiceOutputs);
+    const result = await upInfraEnvironmentAsync({ projectId: 'sample', manifest }, dependencies);
+
+    expect(result.ok).toBe(true);
+    expect(calls).toEqual([
+      'local.validate',
+      'supabase.validate',
+      'cerbos.validate',
+      'supabase.workloads',
+      'cerbos.workloads',
+      'local.ensure',
+      'docker-compose.validate',
+      'docker-compose.ensure',
+      'supabase.reconcile',
+      'cerbos.reconcile',
+    ]);
+    expect(observedRuntimeDesired).toHaveLength(2);
+    expect(observedRuntimeDesired[0]?.workloads.map(({ id }) => id)).toEqual([
+      'app',
+      'supabase',
+      'cerbos',
+    ]);
+    expect(observedRuntimeDesired[0]?.targets).toEqual([
+      { id: 'local', kind: 'local-host', os: 'linux', architecture: 'amd64' },
+    ]);
+    expect(observedServiceOutputs).toHaveLength(2);
+    expect(observedServiceOutputs[0]?.map(({ name }) => name)).toEqual([
+      'computeEndpoint',
+      'runtimeEndpoint',
+    ]);
+    if (!result.ok) throw new Error('Expected successful up.');
+    expect(result.value.environment).toBe('local');
+    expect(result.value.outputs.map(({ name }) => name)).toEqual([
+      'computeEndpoint',
+      'runtimeEndpoint',
+      'supabaseOutput',
+      'cerbosOutput',
+    ]);
+    expect(result.diagnostics.map(({ code }) => code)).toEqual(['compute-warning']);
+  });
+
+  it('stops before mutation when service validation fails', async () => {
+    const calls: string[] = [];
+    const dependencies = createDependencies(calls, [], [], 'supabase.validate');
+    const result = await upInfraEnvironmentAsync({ projectId: 'sample', manifest }, dependencies);
+
+    expect(result).toMatchObject({ ok: false, diagnostics: [{ code: 'fixture-failure' }] });
+    expect(calls).toEqual(['local.validate', 'supabase.validate']);
+  });
+
+  it('does not reconcile services after a runtime failure', async () => {
+    const calls: string[] = [];
+    const dependencies = createDependencies(calls, [], [], 'docker-compose.ensure');
+    const result = await upInfraEnvironmentAsync({ projectId: 'sample', manifest }, dependencies);
+
+    expect(result.ok).toBe(false);
+    expect(calls.at(-1)).toBe('docker-compose.ensure');
+    expect(calls).not.toContain('supabase.reconcile');
+  });
+});
+
+function createDependencies(
+  calls: string[],
+  runtimeDesired: InfraRuntimeDesiredState[],
+  serviceOutputs: InfraOutput[][],
+  failure?: string,
+): InfraOrchestrationDependencies {
+  return {
+    adapterResolver: createResolver(calls, runtimeDesired, serviceOutputs, failure),
+    credentials: { resolveAsync: () => Promise.resolve(success({})) },
+    secrets: { resolveAsync: () => Promise.resolve(success('secret')) },
+  };
+}
+
+function createResolver(
+  calls: string[],
+  runtimeDesired: InfraRuntimeDesiredState[],
+  serviceOutputs: InfraOutput[][],
+  failure?: string,
+): InfraAdapterPackageResolver {
+  return {
+    loadAsync(packageName) {
+      const descriptor = descriptorForPackage(packageName);
+      return Promise.resolve({
+        infraAdapterDescriptor: descriptor,
+        createInfraAdapter: () =>
+          createAdapter(descriptor, calls, runtimeDesired, serviceOutputs, failure),
+      });
+    },
+  };
+}
+
+function createAdapter(
+  descriptor: InfraAdapterDescriptor,
+  calls: string[],
+  runtimeDesired: InfraRuntimeDesiredState[],
+  serviceOutputs: InfraOutput[][],
+  failure?: string,
+): unknown {
+  if (descriptor.kind === 'compute') return createCompute(descriptor, calls, failure);
+  if (descriptor.kind === 'runtime')
+    return createRuntime(descriptor, calls, runtimeDesired, failure);
+  return createService(descriptor, calls, serviceOutputs, failure);
+}
+
+function createCompute(
+  descriptor: InfraAdapterDescriptor,
+  calls: string[],
+  failure?: string,
+): InfraComputeAdapter {
+  return {
+    descriptor: descriptor as InfraComputeAdapter['descriptor'],
+    validateAsync: () => recordAsync(calls, `${descriptor.id}.validate`, failure, null),
+    inspectAsync: () => Promise.resolve(success({ resources: [], outputs: [], targets: [] })),
+    planAsync: () => Promise.resolve(success([])),
+    ensureAsync: () => {
+      const recorded = record(calls, `${descriptor.id}.ensure`, failure, {
+        resources: [],
+        outputs: [publicOutput('local', 'compute', 'computeEndpoint')],
+        targets: [{ id: 'local', kind: 'local-host', os: 'linux', architecture: 'amd64' } as const],
+      });
+      return Promise.resolve(
+        recorded.ok ? { ...recorded, diagnostics: [diagnostic('compute-warning')] } : recorded,
+      );
+    },
+    statusAsync: () => Promise.resolve(success([])),
+    destroyAsync: () => Promise.resolve(success({ resources: [], outputs: [] })),
+  };
+}
+
+function createRuntime(
+  descriptor: InfraAdapterDescriptor,
+  calls: string[],
+  observed: InfraRuntimeDesiredState[],
+  failure?: string,
+): InfraRuntimeAdapter {
+  return {
+    descriptor: descriptor as InfraRuntimeAdapter['descriptor'],
+    validateAsync: (_context, desired) => {
+      observed.push(desired);
+      return Promise.resolve(record(calls, `${descriptor.id}.validate`, failure, null));
+    },
+    planAsync: () => Promise.resolve(success([])),
+    ensureAsync: (_context, desired) => {
+      observed.push(desired);
+      return Promise.resolve(
+        record(calls, `${descriptor.id}.ensure`, failure, {
+          resources: [],
+          outputs: [publicOutput('docker-compose', 'runtime', 'runtimeEndpoint')],
+        }),
+      );
+    },
+    statusAsync: () => Promise.resolve(success([])),
+    suspendAsync: () => Promise.resolve(success({ resources: [], outputs: [] })),
+    destroyAsync: () => Promise.resolve(success({ resources: [], outputs: [] })),
+  };
+}
+
+function createService(
+  descriptor: InfraAdapterDescriptor,
+  calls: string[],
+  observed: InfraOutput[][],
+  failure?: string,
+): InfraServiceAdapter {
+  return {
+    descriptor: descriptor as InfraServiceAdapter['descriptor'],
+    validateAsync: () => recordAsync(calls, `${descriptor.id}.validate`, failure, null),
+    planAsync: () => Promise.resolve(success([])),
+    desiredWorkloadsAsync: () =>
+      recordAsync(calls, `${descriptor.id}.workloads`, failure, [workload(descriptor.id)]),
+    reconcileAsync: (_context, outputs) => {
+      observed.push([...outputs]);
+      return Promise.resolve(
+        record(calls, `${descriptor.id}.reconcile`, failure, {
+          resources: [],
+          outputs: [publicOutput(descriptor.id, descriptor.id, `${descriptor.id}Output`)],
+        }),
+      );
+    },
+    statusAsync: () => Promise.resolve(success([])),
+    destroyAsync: () => Promise.resolve(success({ resources: [], outputs: [] })),
+  };
+}
+
+function record<T>(calls: string[], call: string, failure: string | undefined, value: T) {
+  calls.push(call);
+  return failure === call
+    ? ({ ok: false, diagnostics: [diagnostic('fixture-failure')] } as const)
+    : success(value);
+}
+
+function recordAsync<T>(calls: string[], call: string, failure: string | undefined, value: T) {
+  return Promise.resolve(record(calls, call, failure, value));
+}
+
+function workload(id: string): InfraWorkloadSpec {
+  return { id, artifact: { kind: 'image', image: `example/${id}:1` } };
+}
+
+function publicOutput(
+  adapter: InfraAdapterDescriptor['id'],
+  resourceId: string,
+  name: string,
+): InfraOutput {
+  return {
+    owner: { projectId: 'sample', environment: 'local', adapter, resourceId },
+    name,
+    visibility: 'public',
+    value: `https://${resourceId}.example.test`,
+  };
+}
+
+function descriptorForPackage(packageName: string): InfraAdapterDescriptor {
+  const descriptor = Object.values(INFRA_ADAPTER_CATALOG).find(
+    ({ package: candidate }) => candidate === packageName,
+  );
+  if (descriptor === undefined) throw new Error('Unexpected package.');
+  return descriptor;
+}
+
+function diagnostic(code: string): InfraDiagnostic {
+  return { severity: 'warning', code, message: code };
+}
+
+function success<T>(value: T): InfraResult<T> {
+  return { ok: true, value, diagnostics: [] };
+}

package/src/metadata/index.ts

@@ -4,4 +4,4 @@ export {
   INFRA_PACKAGE_METADATA,
   INFRA_PACKAGE_NAME,
   INFRA_PACKAGE_VERSION,
-} from '../packageMetadata.js';
+} from '../constants.js';

package/src/package.test.ts

@@ -10,11 +10,13 @@ describe('package metadata', () => {
       provider: './dist/cli/index.js',
       capabilities: [
         'infra.validate',
+        'infra.plan',
         'infra.generate',
-        'infra.status',
         'infra.up',
+        'infra.status',
+        'infra.outputs',
         'infra.down',
-        'infra.secret-store',
+        'infra.destroy',
       ],
     } as const satisfies AnkhPackageMetadata;
 

package/src/project/index.test.ts

@@ -1,195 +1,17 @@
-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,
+  createProjectInfraLifecycle,
+  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(createProjectInfraLifecycle).toBeFunction();
+    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,15 @@
-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 { createProjectInfraLifecycle } from '../features/environment-lifecycle/composition/createProjectInfraLifecycle.js';
+export { resolveProjectFile } from '../features/environment-lifecycle/utils/resolveProjectFile.js';
+export type {
+  CreateProjectInfraLifecycleOptions,
+  InfraArtifactWriteResult,
+  ProjectInfraDestroyRequest,
+  ProjectInfraLifecycle,
+  ProjectInfraOperationRequest,
+  ResolvedInfraProject,
+} from '../types/infraProject.js';