@ankhorage/infra 4.1.10 → 5.0.0

package/src/index.test.ts

@@ -1,319 +1,26 @@
-import type { AppManifest } from '@ankhorage/contracts';
 import { describe, expect, test } from 'bun:test';
 
-import { generateInfrastructure } from './index';
-import type { InfraManifestInput } from './types';
-
-describe('generateInfrastructure', () => {
-  test('generates minikube artifacts for app-owned Kubernetes infrastructure', () => {
-    const manifest: InfraManifestInput = {
-      deployment: {
-        target: 'minikube',
-        monitoring: false,
-      },
-      auth: {
-        scope: 'global',
-        provider: 'supabase',
-        authorization: {
-          kind: 'ABAC',
-          engine: 'cerbos',
-        },
-        signIn: {
-          identifiers: ['email', 'username'],
-        },
-        signUp: {
-          requiredFields: ['email', 'password'],
-          optionalFields: ['firstName', 'lastName'],
-          signUpPolicy: 'requireVerification',
-        },
-        profile: {
-          fields: ['email', 'firstName', 'lastName', 'avatarUrl'],
-        },
-      },
-      database: {
-        provider: 'supabase',
-        tier: 'dev',
-      },
-      storage: {
-        provider: 'auto',
-        buckets: ['assets'],
-      },
-      networking: {
-        domain: 'alpha.local',
-        cdn: false,
-      },
-      modules: [],
-    };
-
-    const result = generateInfrastructure(manifest, { appManifest: createAppManifest('alpha') });
-    const paths = result.files.map((file) => file.path);
-
-    expect(result.meta.target).toBe('minikube');
-    expect(result.meta.providers).toEqual(['auto', 'cerbos', 'supabase']);
-    expect(paths).toContain('infra/minikube/k8s/namespaces/app.yaml');
-    expect(paths).toContain('infra/minikube/k8s/namespaces/supabase.yaml');
-    expect(paths).toContain('infra/minikube/k8s/app/deployment.yaml');
-    expect(paths).toContain('infra/minikube/k8s/app/service.yaml');
-    expect(paths).toContain('infra/minikube/k8s/supabase/postgres.yaml');
-    expect(paths).toContain('infra/minikube/k8s/supabase/gateway.yaml');
-    expect(paths).toContain('infra/minikube/k8s/auth/supabase/supabase-auth.configmap.yaml');
-    expect(paths).toContain('infra/minikube/k8s/auth/supabase/app-runtime-auth.env.configmap.yaml');
-    expect(paths).toContain('infra/minikube/k8s/authz/cerbos/cerbos.policy.configmap.yaml');
-    expect(paths).toContain('infra/minikube/k8s/authz/cerbos/cerbos.deployment.yaml');
-    expect(paths).toContain('infra/minikube/k8s/storage/supabase/supabase-storage.configmap.yaml');
-    expect(paths).toContain(
-      'infra/minikube/k8s/storage/supabase/app-runtime-storage.env.configmap.yaml',
-    );
-    expect(paths).toContain('infra/minikube/scripts/up.sh');
-    expect(paths).toContain('infra/minikube/scripts/down.sh');
-    expect(paths).toContain('infra/minikube/scripts/reset.sh');
-    expect(paths).toContain('infra/minikube/scripts/destroy.sh');
-    expect(paths).toContain('infra/minikube/scripts/status.sh');
-    expect(paths).toContain('infra/minikube/scripts/port-forward.sh');
-    expect(paths).not.toContain('infra/minikube/scripts/supabase-local-env.sh');
-
-    const envExample = getFile(result.files, 'infra/minikube/.env.example');
-    expect(envExample).toContain('ANKH_APP_SLUG=alpha');
-    expect(envExample).not.toContain('SUPABASE_RUNTIME_ENABLED=');
-    expect(envExample).toContain('EXPO_PUBLIC_SUPABASE_URL=');
-    expect(envExample).toContain('APP_IMAGE=ankh/alpha:dev');
-    expect(envExample).not.toContain('MINIKUBE_PROFILE=');
-    expect(envExample).not.toContain('SUPABASE_PROJECT_DIR=');
-
-    const upScript = getFile(result.files, 'infra/minikube/scripts/up.sh');
-    expect(upScript).toContain('SUPABASE_RUNTIME_ENABLED="true"');
-    expect(upScript).not.toContain('SUPABASE_RUNTIME_ENABLED="${SUPABASE_RUNTIME_ENABLED');
-    expect(upScript).toContain('minikube start -p "${PROFILE}"');
-    expect(upScript).toContain('kubectl --context "${PROFILE}" apply -k "${K8S_DIR}"');
-    expect(upScript).toContain(
-      'SUPABASE_TELEMETRY_DISABLED=1 supabase --yes migration up --db-url "${SUPABASE_DB_URL}"',
-    );
-    expect(upScript).not.toContain('supabase migration up --db-url "${SUPABASE_DB_URL}"');
-    expect(upScript).toContain('create secret generic supabase-runtime-secrets');
-    expect(upScript).toContain('create secret generic supabase-public-runtime');
-    expect(upScript).toContain('rollout status deployment/app-runtime --timeout=180s');
-    expect(upScript).not.toContain('supabase start');
-    expect(upScript).not.toContain('supabase status');
-
-    const appDeployment = getFile(result.files, 'infra/minikube/k8s/app/deployment.yaml');
-    expect(appDeployment).toContain('namespace: app');
-    expect(appDeployment).toContain('image: ankh/alpha:dev');
-    expect(appDeployment).toContain('name: supabase-public-runtime');
-    expect(appDeployment).not.toContain('supabase-auth-secrets');
-
-    const runtimeGuide = getFile(result.files, 'infra/minikube/auth/supabase-runtime-wiring.md');
-    expect(runtimeGuide).toContain('supabase-public-runtime');
-    expect(runtimeGuide).toContain('${APP_SOURCE_DIR}/.env.local');
-    expect(runtimeGuide).not.toContain('SUPABASE_SERVICE_ROLE_KEY');
-  });
-
-  test('generates minikube storage artifacts for explicit supabase provider with normalized buckets', () => {
-    const manifest: InfraManifestInput = {
-      deployment: {
-        target: 'minikube',
-        monitoring: false,
-      },
-      auth: {
-        scope: 'global',
-        provider: 'supabase',
-      },
-      database: {
-        provider: 'supabase',
-        tier: 'dev',
-      },
-      storage: {
-        provider: 'supabase',
-        buckets: ['assets', ' assets ', '', 'assets', 'uploads'],
-      },
-      modules: [],
-    };
-
-    const result = generateInfrastructure(manifest, {
-      appManifest: createAppManifest('shop'),
-    });
-
-    expect(result.warnings).toContain(
-      'Storage buckets are configured but not created automatically yet. Ensure buckets exist in Supabase Storage: assets,uploads.',
-    );
-
-    const storageConfig = getFile(
-      result.files,
-      'infra/minikube/k8s/storage/supabase/supabase-storage.configmap.yaml',
-    );
-    expect(storageConfig).toContain('namespace: app');
-    expect(storageConfig).toContain('STORAGE_BUCKETS: "assets,uploads"');
-    expect(storageConfig).toContain('STORAGE_DEFAULT_BUCKET: "assets"');
-  });
-
-  test('generates route and screen cerbos policies when app manifest context is provided', () => {
-    const manifest: InfraManifestInput = {
-      deployment: {
-        target: 'minikube',
-        monitoring: false,
-      },
-      auth: {
-        scope: 'global',
-        provider: 'supabase',
-        authorization: {
-          kind: 'ABAC',
-          engine: 'cerbos',
-        },
-      },
-      database: {
-        provider: 'supabase',
-        tier: 'dev',
-      },
-      modules: [],
-    };
-
-    const appManifest: Pick<AppManifest, 'metadata' | 'navigator' | 'screens' | 'settings'> = {
-      metadata: {
-        name: 'Shop',
-        slug: 'shop',
-        version: '1.0.0',
-        themeId: 'default',
-      },
-      navigator: {
-        type: 'stack',
-        routes: [
-          { name: 'sign-in', screenId: 'screen-sign-in' },
-          { name: 'sign-up', screenId: 'screen-sign-up', guards: ['public'] },
-          { name: 'index', screenId: 'screen-home' },
-          { name: 'cart', screenId: 'screen-cart', guards: ['auth'] },
-        ],
-      },
-      screens: {
-        'screen-sign-in': {
-          id: 'screen-sign-in',
-          name: 'SignIn',
-          root: { id: 'sign-in-root', type: 'View', children: [] },
-        },
-        'screen-sign-up': {
-          id: 'screen-sign-up',
-          name: 'SignUp',
-          root: { id: 'sign-up-root', type: 'View', children: [] },
-        },
-        'screen-home': {
-          id: 'screen-home',
-          name: 'Home',
-          root: { id: 'home-root', type: 'View', children: [] },
-        },
-        'screen-cart': {
-          id: 'screen-cart',
-          name: 'Cart',
-          root: { id: 'cart-root', type: 'View', children: [] },
-        },
-      },
-      settings: {
-        localization: {
-          defaultLocale: 'en',
-          locales: ['en'],
-        },
-        authFlow: {
-          signInRoute: '/sign-in',
-          signUpRoute: '/sign-up',
-          signOutRoute: '/sign-out',
-          unauthorizedRoute: '/sign-in',
-          postSignInRoute: '/',
-        },
-      },
-    };
-
-    const result = generateInfrastructure(manifest, { appManifest });
-    const cerbosPolicy = getFile(
-      result.files,
-      'infra/minikube/k8s/authz/cerbos/cerbos.policy.configmap.yaml',
-    );
-
-    expect(cerbosPolicy).toContain('route.resource_policy.yaml: |');
-    expect(cerbosPolicy).toContain('screen.resource_policy.yaml: |');
-    expect(cerbosPolicy).toContain(
-      'expr: "request.resource.attr.route in [\\"sign-in\\",\\"sign-up\\"]"',
-    );
-    expect(cerbosPolicy).toContain(
-      'expr: "request.resource.attr.route in [\\"cart\\",\\"index\\"]"',
-    );
-  });
-
-  test('throws for missing deployment', () => {
-    const manifest: InfraManifestInput = {
-      modules: [],
-    };
-
-    expect(() => generateInfrastructure(manifest)).toThrow('Deployment configuration is missing.');
-  });
-
-  test('throws for unsupported deployment target', () => {
-    const manifest: InfraManifestInput = {
-      deployment: {
-        target: 'kubernetes',
-        monitoring: false,
-      },
-      modules: [],
-    };
-
-    expect(() => generateInfrastructure(manifest)).toThrow(
-      'Unsupported deployment target: kubernetes',
-    );
-  });
-
-  test('requires canonical app slug for minikube infrastructure', () => {
-    const manifest: InfraManifestInput = {
-      deployment: {
-        target: 'minikube',
-        monitoring: false,
-      },
-      database: {
-        provider: 'supabase',
-        tier: 'dev',
-      },
-      modules: [],
-    };
-
-    expect(() => generateInfrastructure(manifest, { namespaceHint: 'shop' })).toThrow(
-      'Cannot generate Minikube infrastructure: appManifest.metadata.slug is required.',
-    );
-    expect(() =>
-      generateInfrastructure(manifest, {
-        appManifest: createAppManifest('Scanner App'),
-      }),
-    ).toThrow('appManifest.metadata.slug must be a canonical lowercase slug up to 40 characters');
+import * as infra from './index.js';
+
+describe('@ankhorage/infra', () => {
+  test('exports only the provider-neutral lifecycle and composition APIs', () => {
+    expect(infra).toContainAllKeys([
+      'createEnvironmentInfraCredentialPort',
+      'createEnvironmentInfraSecretPort',
+      'createNodeInfraAdapterPackageResolver',
+      'destroyInfraEnvironmentAsync',
+      'downInfraEnvironmentAsync',
+      'generateInfraEnvironmentAsync',
+      'getInfraEnvironmentOutputs',
+      'orderInfraPlanActions',
+      'planInfraEnvironmentAsync',
+      'resolveInfraAdaptersAsync',
+      'resolveInfraEnvironment',
+      'statusInfraEnvironmentAsync',
+      'upInfraEnvironmentAsync',
+      'validateInfraEnvironmentAsync',
+    ]);
+    expect(Object.keys(infra)).not.toContain('createMinikubeAdapter');
+    expect(Object.keys(infra)).not.toContain('resolveAuthRedirectConfiguration');
   });
 });
-
-function getFile(files: readonly { path: string; content: string }[], path: string): string {
-  const file = files.find((candidate) => candidate.path === path);
-  if (!file) throw new Error(`Missing generated file: ${path}`);
-  return file.content;
-}
-
-function createAppManifest(
-  slug: string,
-): Pick<AppManifest, 'metadata' | 'navigator' | 'screens' | 'settings'> {
-  return {
-    metadata: {
-      name: slug,
-      slug,
-      version: '1.0.0',
-      themeId: 'default',
-    },
-    navigator: {
-      type: 'stack',
-      routes: [],
-    },
-    screens: {},
-    settings: {
-      localization: {
-        defaultLocale: 'en',
-        locales: ['en'],
-      },
-      authFlow: {
-        signInRoute: '/sign-in',
-        signUpRoute: '/sign-up',
-        signOutRoute: '/sign-out',
-        unauthorizedRoute: '/sign-in',
-        postSignInRoute: '/',
-      },
-    },
-  };
-}

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: [] };
+}