@ankhorage/infra 4.1.12 → 5.1.0

package/src/index.ts

@@ -1,54 +1,42 @@
-import { generateMinikubeInfra } from './adapters/minikube';
-import type {
-  InfraGenerationInput,
-  InfraManifestInput,
-  InfrastructureGenerationOptions,
-  InfrastructureGenerationResult,
-} from './types';
-
-export {
-  type AuthRedirectConfiguration,
-  type AuthRedirectEnvironment,
-  getLocalAuthRedirectPatterns,
-  normalizeAuthCallbackRoute,
-  resolveAuthRedirectConfiguration,
-  type ResolveAuthRedirectConfigurationInput,
-} from './authRedirects';
-export {
-  createInfraSecretStoreAdapter,
-  type CreateInfraSecretStoreAdapterInput,
-  type InfraSecretStoreProviders,
-} from './secretStore';
+export { createEnvironmentInfraCredentialPort } from './features/environment-lifecycle/adapters/outbound/createEnvironmentInfraCredentialPort.js';
+export { createEnvironmentInfraSecretPort } from './features/environment-lifecycle/adapters/outbound/createEnvironmentInfraSecretPort.js';
+export { createNodeInfraAdapterPackageResolver } from './features/environment-lifecycle/adapters/outbound/createNodeInfraAdapterPackageResolver.js';
 export type {
-  GeneratedFile,
-  GeneratedInfrastructureFile,
-  GeneratedPackageDependency,
-  InfraDiagnostic,
-  InfraGenerationInput,
-  InfraGenerationOptions,
-  InfraGenerationResult,
-  InfraManifestInput,
-  InfrastructureGenerationMeta,
-  InfrastructureGenerationOptions,
-  InfrastructureGenerationResult,
-  PackageDependency,
-} from './types';
-
-export function generateInfra(input: InfraGenerationInput): InfrastructureGenerationResult {
-  return generateInfrastructure(input.manifest, input.options ?? {});
-}
-
-export function generateInfrastructure(
-  manifest: InfraManifestInput,
-  options: InfrastructureGenerationOptions = {},
-): InfrastructureGenerationResult {
-  if (!manifest.deployment) {
-    throw new Error('Deployment configuration is missing.');
-  }
-
-  if (manifest.deployment.target !== 'minikube') {
-    throw new Error(`Unsupported deployment target: ${manifest.deployment.target}`);
-  }
-
-  return generateMinikubeInfra(manifest, options);
-}
+  InfraAdapterPackageModule,
+  InfraAdapterPackageResolver,
+} from './features/environment-lifecycle/application/ports/outbound/infraAdapterPackage.js';
+export { destroyInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/destroyInfraEnvironmentAsync.js';
+export { downInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/downInfraEnvironmentAsync.js';
+export { generateInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/generateInfraEnvironmentAsync.js';
+export { getInfraEnvironmentOutputs } from './features/environment-lifecycle/application/use-cases/getInfraEnvironmentOutputs.js';
+export { planInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/planInfraEnvironmentAsync.js';
+export { resolveInfraAdaptersAsync } from './features/environment-lifecycle/application/use-cases/resolveInfraAdaptersAsync.js';
+export { statusInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/statusInfraEnvironmentAsync.js';
+export { upInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/upInfraEnvironmentAsync.js';
+export { validateInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/validateInfraEnvironmentAsync.js';
+export { orderInfraPlanActions } from './features/environment-lifecycle/domain/orderInfraPlanActions.js';
+export { resolveInfraEnvironment } from './features/environment-lifecycle/domain/resolveInfraEnvironment.js';
+export type {
+  InfraDestroyOperationRequest,
+  InfraDestroyOperationResult,
+  InfraDestroyResult,
+  InfraDownOperationResult,
+  InfraDownResult,
+  InfraGenerateOperationResult,
+  InfraGenerateResult,
+  InfraOperationRequest,
+  InfraOrchestrationDependencies,
+  InfraOutputsOperationResult,
+  InfraOutputsResult,
+  InfraPlanOperationResult,
+  InfraStatusOperationResult,
+  InfraStoredState,
+  InfraUpOperationResult,
+  InfraUpRequest,
+  InfraUpResult,
+  InfraValidateOperationResult,
+  InfraValidateResult,
+  PreparedInfraOperation,
+  ResolvedInfraAdapters,
+  ResolvedInfraEnvironment,
+} from './types/infraOrchestration.js';

package/src/infraComposition.integration.test.ts

@@ -0,0 +1,128 @@
+import type { InfraLedger, InfraManifest, InfraResult } from '@ankhorage/contracts/infra';
+import { expect, test } from 'bun:test';
+
+import { createNodeInfraAdapterPackageResolver } from './features/environment-lifecycle/adapters/outbound/createNodeInfraAdapterPackageResolver.js';
+import { destroyInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/destroyInfraEnvironmentAsync.js';
+import { downInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/downInfraEnvironmentAsync.js';
+import { planInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/planInfraEnvironmentAsync.js';
+import { statusInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/statusInfraEnvironmentAsync.js';
+import { upInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/upInfraEnvironmentAsync.js';
+import type { InfraOrchestrationDependencies } from './types/infraOrchestration.js';
+
+const projectId = 'infra145-orchestrator-acceptance';
+const manifest = {
+  environments: {
+    local: {
+      deployment: {
+        compute: { provider: 'local' },
+        runtime: { provider: 'docker-compose', projectName: projectId },
+      },
+      workloads: [
+        {
+          id: 'web',
+          artifact: { kind: 'image', image: 'nginx:alpine' },
+          ports: [{ name: 'http', port: 80 }],
+          exposure: 'internal',
+        },
+      ],
+    },
+  },
+  modules: [],
+} as const satisfies InfraManifest;
+
+test.skipIf(process.env.ANKH_INFRA_COMPOSITION_E2E !== '1')(
+  'runs the typed lifecycle through real Local and Docker Compose adapters',
+  async () => {
+    const dependencies = createDependencies();
+    let ledger: InfraLedger | undefined;
+    try {
+      const initialPlan = requireSuccess(
+        await planInfraEnvironmentAsync({ projectId, manifest }, dependencies),
+      );
+      expect(initialPlan.actions.some(({ operation }) => operation === 'create')).toBe(true);
+
+      const firstUp = requireSuccess(
+        await upInfraEnvironmentAsync({ projectId, manifest }, dependencies),
+      );
+      const { ledger: firstLedger } = firstUp;
+      ledger = firstLedger;
+      expect(firstUp.resources.some(({ identity }) => identity.resourceId === 'service:web')).toBe(
+        true,
+      );
+      const status = requireSuccess(
+        await statusInfraEnvironmentAsync({ projectId, manifest, previous: ledger }, dependencies),
+      );
+      expect(status.state).toBe('ready');
+      const convergedPlan = requireSuccess(
+        await planInfraEnvironmentAsync({ projectId, manifest, previous: ledger }, dependencies),
+      );
+      expect(convergedPlan.actions.every(({ operation }) => operation === 'noop')).toBe(true);
+
+      const down = requireSuccess(
+        await downInfraEnvironmentAsync({ projectId, manifest, previous: ledger }, dependencies),
+      );
+      const { ledger: downLedger } = down;
+      ledger = downLedger;
+      const resumed = requireSuccess(
+        await upInfraEnvironmentAsync({ projectId, manifest, previous: ledger }, dependencies),
+      );
+      const { ledger: resumedLedger } = resumed;
+      ledger = resumedLedger;
+      const destroyed = requireSuccess(
+        await destroyInfraEnvironmentAsync(
+          {
+            projectId,
+            manifest,
+            environment: 'local',
+            previous: ledger,
+            confirmation: { projectId, environment: 'local' },
+            persistence: { policy: 'retain' },
+          },
+          dependencies,
+        ),
+      );
+      ledger = destroyed.ledger ?? undefined;
+      expect(destroyed.ledger).toBeNull();
+    } finally {
+      if (ledger !== undefined) {
+        await destroyInfraEnvironmentAsync(
+          {
+            projectId,
+            manifest,
+            environment: 'local',
+            previous: ledger,
+            confirmation: { projectId, environment: 'local' },
+            persistence: { policy: 'retain' },
+          },
+          dependencies,
+        );
+      }
+    }
+  },
+  120_000,
+);
+
+function createDependencies(): InfraOrchestrationDependencies {
+  return {
+    adapterResolver: createNodeInfraAdapterPackageResolver(),
+    credentials: { resolveAsync: () => Promise.resolve(success({})) },
+    secrets: {
+      resolveAsync: () =>
+        Promise.resolve({
+          ok: false,
+          diagnostics: [
+            { severity: 'error', code: 'unexpected-secret', message: 'No secret is expected.' },
+          ],
+        }),
+    },
+  };
+}
+
+function requireSuccess<T>(result: InfraResult<T>): T {
+  if (!result.ok) throw new Error(result.diagnostics.map(({ message }) => message).join(' '));
+  return result.value;
+}
+
+function success<T>(value: T): InfraResult<T> {
+  return { ok: true, value, diagnostics: [] };
+}

package/src/infraOperations.test.ts

@@ -0,0 +1,386 @@
+import type {
+  InfraAdapterDescriptor,
+  InfraComputeAdapter,
+  InfraEnvironmentSpec,
+  InfraOwnedResource,
+  InfraPlanAction,
+  InfraResourceIdentity,
+  InfraResourceStatus,
+  InfraResult,
+  InfraRuntimeAdapter,
+  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 { destroyInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/destroyInfraEnvironmentAsync';
+import { downInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/downInfraEnvironmentAsync';
+import { generateInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/generateInfraEnvironmentAsync';
+import { getInfraEnvironmentOutputs } from './features/environment-lifecycle/application/use-cases/getInfraEnvironmentOutputs';
+import { planInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/planInfraEnvironmentAsync';
+import { statusInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/statusInfraEnvironmentAsync';
+import { validateInfraEnvironmentAsync } from './features/environment-lifecycle/application/use-cases/validateInfraEnvironmentAsync';
+import type { InfraOrchestrationDependencies } from './types/infraOrchestration';
+
+const desired = {
+  deployment: { compute: { provider: 'local' }, runtime: { provider: 'docker-compose' } },
+  database: { provider: 'supabase' },
+  secretStore: { provider: 'supabase-vault' },
+} as const satisfies InfraEnvironmentSpec;
+const manifest = { environments: { local: desired }, modules: [] } as const;
+const computeOwner = owner('local', 'host');
+const runtimeOwner = owner('docker-compose', 'runtime');
+const databaseOwner = owner('supabase', 'database');
+const vaultOwner = owner('supabase-vault', 'vault');
+
+describe('provider-neutral lifecycle operations', () => {
+  it('validates and plans without calling a mutating adapter method', async () => {
+    const calls: string[] = [];
+    const dependencies = createDependencies(calls);
+    const validation = await validateInfraEnvironmentAsync(
+      { projectId: 'sample', manifest },
+      dependencies,
+    );
+    const plan = await planInfraEnvironmentAsync({ projectId: 'sample', manifest }, dependencies);
+
+    expect(validation).toMatchObject({ ok: true, value: { environment: 'local' } });
+    expect(plan.ok).toBe(true);
+    if (!plan.ok) throw new Error('Expected plan.');
+    expect(plan.value.actions.map(({ owner: actionOwner }) => actionOwner.resourceId)).toEqual([
+      'host',
+      'runtime',
+      'database',
+      'vault',
+    ]);
+    expect(calls).toContain('local.inspect');
+    expect(calls.some((call) => call.endsWith('.ensure'))).toBe(false);
+    expect(calls.some((call) => call.endsWith('.reconcile'))).toBe(false);
+    expect(calls.some((call) => call.endsWith('.destroy'))).toBe(false);
+  });
+
+  it('plans fresh remote compute and a deferred runtime without inventing an SSH target', async () => {
+    const calls: string[] = [];
+    const remoteManifest = {
+      environments: {
+        local: desired,
+        production: {
+          deployment: {
+            compute: { provider: 'hetzner', location: 'nbg1' },
+            runtime: { provider: 'k3s', topology: { servers: 1, agents: 0 } },
+          },
+        },
+      },
+      modules: [],
+    } as const;
+    const result = await planInfraEnvironmentAsync(
+      { projectId: 'sample', manifest: remoteManifest, environment: 'production' },
+      createDependencies(calls),
+    );
+    expect(result.ok).toBe(true);
+    if (!result.ok) throw new Error('Expected remote plan.');
+    expect(result.value.actions.map(({ owner: actionOwner }) => actionOwner.adapter)).toEqual([
+      'hetzner',
+      'k3s',
+    ]);
+    expect(result.value.actions[1]?.detail).toContain('deferred');
+    expect(calls).not.toContain('k3s.validate');
+    expect(calls).not.toContain('k3s.plan');
+  });
+
+  it('generates review artifacts without reconciliation and preserves safe state', async () => {
+    const calls: string[] = [];
+    const result = await generateInfraEnvironmentAsync(
+      { projectId: 'sample', manifest, previous: ledger() },
+      createDependencies(calls),
+    );
+
+    expect(result.ok).toBe(true);
+    if (!result.ok) throw new Error('Expected generation.');
+    expect(result.value.artifacts).toEqual([
+      { owner: runtimeOwner, path: 'infra/compose.yaml', content: 'services: {}\n' },
+    ]);
+    expect(result.value.ledger.outputs).toEqual(ledger().outputs);
+    expect(calls).toContain('docker-compose.generate');
+    expect(calls.some((call) => call.endsWith('.ensure'))).toBe(false);
+  });
+
+  it('aggregates canonical status and returns only serialized ledger outputs', async () => {
+    const calls: string[] = [];
+    const status = await statusInfraEnvironmentAsync(
+      { projectId: 'sample', manifest, previous: ledger() },
+      createDependencies(calls),
+    );
+    const outputs = getInfraEnvironmentOutputs({
+      projectId: 'sample',
+      manifest,
+      previous: ledger(),
+    });
+
+    expect(status).toMatchObject({ ok: true, value: { state: 'degraded' } });
+    expect(outputs).toMatchObject({
+      ok: true,
+      value: {
+        outputs: [
+          { visibility: 'public', value: 'https://example.test' },
+          { visibility: 'secret', reference: { source: 'secret-store' } },
+        ],
+      },
+    });
+    expect(JSON.stringify(outputs)).not.toContain('resolved-secret');
+  });
+
+  it('suspends optional services in reverse dependency order before runtime', async () => {
+    const calls: string[] = [];
+    const result = await downInfraEnvironmentAsync(
+      { projectId: 'sample', manifest, previous: ledger() },
+      createDependencies(calls),
+    );
+
+    expect(result.ok).toBe(true);
+    expect(calls.filter((call) => call.endsWith('.suspend'))).toEqual([
+      'supabase-vault.suspend',
+      'supabase.suspend',
+      'docker-compose.suspend',
+    ]);
+    if (!result.ok) throw new Error('Expected down.');
+    expect(result.value.ledger.resources).toHaveLength(4);
+  });
+
+  it('refuses mismatched destroy confirmation and destroys in reverse dependency order', async () => {
+    const rejectedCalls: string[] = [];
+    const rejected = await destroyInfraEnvironmentAsync(
+      {
+        projectId: 'sample',
+        manifest,
+        environment: 'local',
+        previous: ledger(),
+        confirmation: { projectId: 'other', environment: 'local' },
+        persistence: { policy: 'retain' },
+      },
+      createDependencies(rejectedCalls),
+    );
+    expect(rejected).toMatchObject({
+      ok: false,
+      diagnostics: [{ code: 'infra-destroy-confirmation-mismatch' }],
+    });
+    expect(rejectedCalls.some((call) => call.endsWith('.destroy'))).toBe(false);
+
+    const calls: string[] = [];
+    const result = await destroyInfraEnvironmentAsync(
+      {
+        projectId: 'sample',
+        manifest,
+        environment: 'local',
+        previous: ledger(),
+        confirmation: { projectId: 'sample', environment: 'local' },
+        persistence: { policy: 'retain' },
+      },
+      createDependencies(calls),
+    );
+    expect(result.ok).toBe(true);
+    expect(calls.filter((call) => call.endsWith('.destroy'))).toEqual([
+      'supabase-vault.destroy',
+      'supabase.destroy',
+      'docker-compose.destroy',
+      'local.destroy',
+    ]);
+  });
+});
+
+function createDependencies(calls: string[]): InfraOrchestrationDependencies {
+  return {
+    adapterResolver: createResolver(calls),
+    credentials: { resolveAsync: () => Promise.resolve(success({})) },
+    secrets: { resolveAsync: () => Promise.resolve(success('resolved-secret')) },
+  };
+}
+
+function createResolver(calls: string[]): InfraAdapterPackageResolver {
+  return {
+    loadAsync(packageName) {
+      const descriptor = descriptorForPackage(packageName);
+      return Promise.resolve({
+        infraAdapterDescriptor: descriptor,
+        createInfraAdapter: () => createAdapter(descriptor, calls),
+      });
+    },
+  };
+}
+
+function createAdapter(descriptor: InfraAdapterDescriptor, calls: string[]): unknown {
+  if (descriptor.kind === 'compute') return createCompute(descriptor, calls);
+  if (descriptor.kind === 'runtime') return createRuntime(descriptor, calls);
+  return createService(descriptor, calls);
+}
+
+function createCompute(descriptor: InfraAdapterDescriptor, calls: string[]): InfraComputeAdapter {
+  const selectedOwner = descriptor.id === 'hetzner' ? owner('hetzner', 'server') : computeOwner;
+  return {
+    descriptor: descriptor as InfraComputeAdapter['descriptor'],
+    validateAsync: () => recordedAsync(calls, `${descriptor.id}.validate`, null),
+    inspectAsync: () =>
+      recordedAsync(calls, `${descriptor.id}.inspect`, {
+        targets:
+          descriptor.id === 'hetzner'
+            ? []
+            : [{ id: 'local', kind: 'local-host', os: 'linux', architecture: 'amd64' }],
+        resources: [resource(selectedOwner)],
+        outputs: [],
+      }),
+    planAsync: () => recordedAsync(calls, `${descriptor.id}.plan`, [action(selectedOwner, [])]),
+    ensureAsync: () =>
+      recordedAsync(calls, `${descriptor.id}.ensure`, { targets: [], resources: [], outputs: [] }),
+    statusAsync: () =>
+      recordedAsync(calls, `${descriptor.id}.status`, [status(selectedOwner, 'ready')]),
+    destroyAsync: () =>
+      recordedAsync(calls, `${descriptor.id}.destroy`, { resources: [], outputs: [] }),
+  };
+}
+
+function createRuntime(descriptor: InfraAdapterDescriptor, calls: string[]): InfraRuntimeAdapter {
+  return {
+    descriptor: descriptor as InfraRuntimeAdapter['descriptor'],
+    validateAsync: () => recordedAsync(calls, `${descriptor.id}.validate`, null),
+    planAsync: () =>
+      recordedAsync(calls, `${descriptor.id}.plan`, [action(runtimeOwner, [computeOwner])]),
+    ensureAsync: () =>
+      recordedAsync(calls, `${descriptor.id}.ensure`, { resources: [], outputs: [] }),
+    statusAsync: () =>
+      recordedAsync(calls, `${descriptor.id}.status`, [status(runtimeOwner, 'degraded')]),
+    suspendAsync: () =>
+      recordedAsync(calls, `${descriptor.id}.suspend`, {
+        resources: [resource(runtimeOwner)],
+        outputs: [],
+      }),
+    destroyAsync: () =>
+      recordedAsync(calls, `${descriptor.id}.destroy`, { resources: [], outputs: [] }),
+    generateAsync: () =>
+      recordedAsync(calls, `${descriptor.id}.generate`, [
+        { owner: runtimeOwner, path: 'infra/compose.yaml', content: 'services: {}\n' },
+      ]),
+  };
+}
+
+function createService(descriptor: InfraAdapterDescriptor, calls: string[]): InfraServiceAdapter {
+  const serviceOwner = descriptor.id === 'supabase' ? databaseOwner : vaultOwner;
+  const dependencies = descriptor.id === 'supabase' ? [runtimeOwner] : [databaseOwner];
+  return {
+    descriptor: descriptor as InfraServiceAdapter['descriptor'],
+    validateAsync: () => recordedAsync(calls, `${descriptor.id}.validate`, null),
+    planAsync: () =>
+      recordedAsync(calls, `${descriptor.id}.plan`, [action(serviceOwner, dependencies)]),
+    desiredWorkloadsAsync: () =>
+      recordedAsync(calls, `${descriptor.id}.workloads`, [workload(descriptor.id)]),
+    reconcileAsync: () =>
+      recordedAsync(calls, `${descriptor.id}.reconcile`, { resources: [], outputs: [] }),
+    statusAsync: () =>
+      recordedAsync(calls, `${descriptor.id}.status`, [status(serviceOwner, 'ready')]),
+    suspendAsync: () =>
+      recordedAsync(calls, `${descriptor.id}.suspend`, {
+        resources: [resource(serviceOwner, true)],
+        outputs: [],
+      }),
+    destroyAsync: () =>
+      recordedAsync(calls, `${descriptor.id}.destroy`, {
+        resources: [resource(serviceOwner, true)],
+        outputs: [],
+      }),
+  };
+}
+
+function ledger() {
+  return {
+    schemaVersion: 1,
+    projectId: 'sample',
+    environment: 'local',
+    targets: [{ id: 'local', kind: 'local-host', os: 'linux', architecture: 'amd64' }],
+    resources: [
+      resource(computeOwner),
+      resource(runtimeOwner),
+      resource(databaseOwner, true),
+      resource(vaultOwner, true),
+    ],
+    outputs: [
+      {
+        owner: runtimeOwner,
+        name: 'url',
+        visibility: 'public',
+        value: 'https://example.test',
+        environmentVariable: 'EXAMPLE_URL',
+      },
+      {
+        owner: vaultOwner,
+        name: 'credential',
+        visibility: 'secret',
+        reference: {
+          source: 'secret-store',
+          projectId: 'sample',
+          environment: 'local',
+          ref: 'example',
+          key: 'password',
+        },
+      },
+    ],
+    artifacts: [],
+  } as const;
+}
+
+function owner(adapter: InfraAdapterDescriptor['id'], resourceId: string): InfraResourceIdentity {
+  return { projectId: 'sample', environment: 'local', adapter, resourceId };
+}
+
+function resource(identity: InfraResourceIdentity, persistent = false): InfraOwnedResource {
+  return {
+    identity,
+    persistent,
+    retention: persistent ? 'retain' : 'delete-on-destroy',
+    dependsOn: [],
+  };
+}
+
+function action(
+  actionOwner: InfraResourceIdentity,
+  dependsOn: readonly InfraResourceIdentity[],
+): InfraPlanAction {
+  return {
+    owner: actionOwner,
+    operation: 'create',
+    impact: 'none',
+    detail: `Create ${actionOwner.resourceId}.`,
+    dependsOn,
+  };
+}
+
+function status(
+  statusOwner: InfraResourceIdentity,
+  state: InfraResourceStatus['state'],
+): InfraResourceStatus {
+  return { owner: statusOwner, state };
+}
+
+function workload(id: string): InfraWorkloadSpec {
+  return { id, artifact: { kind: 'image', image: `example/${id}:1` } };
+}
+
+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 recorded<T>(calls: string[], call: string, value: T): InfraResult<T> {
+  calls.push(call);
+  return success(value);
+}
+
+function recordedAsync<T>(calls: string[], call: string, value: T): Promise<InfraResult<T>> {
+  return Promise.resolve(recorded(calls, call, value));
+}
+
+function success<T>(value: T): InfraResult<T> {
+  return { ok: true, value, diagnostics: [] };
+}