@ankhorage/infra 3.3.0 → 4.1.0

package/src/adapters/minikube/base/portForwardRuntime.test.ts

@@ -0,0 +1,288 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+import { promises as fs } from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { generateInfrastructure } from '../../../index.js';
+import { createAppManifest } from '../../../testSupport.js';
+import type { InfraManifestInput } from '../../../types.js';
+
+const temporaryPaths = new Set<string>();
+
+afterEach(async () => {
+  for (const rootPath of temporaryPaths) {
+    await stopFixtureProcesses(rootPath);
+    await fs.rm(rootPath, { force: true, recursive: true });
+  }
+  temporaryPaths.clear();
+});
+
+describe('generated Minikube runtime port-forward lifecycle', () => {
+  test(
+    'keeps healthy app forwarding, repairs a stopped Supabase gateway, and isolates operational forwards',
+    async () => {
+      const fixture = await createPortForwardFixture(createSupabaseManifest(), 'runtime-recovery');
+
+      const firstStart = await runPortForward(fixture, 'start', 'runtime');
+      expect(firstStart.stdout).toContain('app: started');
+      expect(firstStart.stdout).toContain('supabase-gateway: started');
+
+      const appPid = await readForwardPid(fixture, 'app');
+      const firstGatewayPid = await readForwardPid(fixture, 'supabase-gateway');
+      await expectForwardPid(fixture, 'studio', false);
+      await expectForwardPid(fixture, 'db-migration', false);
+
+      const repeatedStart = await runPortForward(fixture, 'start', 'runtime');
+      expect(repeatedStart.stdout).toContain(`app: running (pid ${appPid})`);
+      expect(repeatedStart.stdout).toContain(`supabase-gateway: running (pid ${firstGatewayPid})`);
+      expect(await readForwardPid(fixture, 'app')).toBe(appPid);
+      expect(await readForwardPid(fixture, 'supabase-gateway')).toBe(firstGatewayPid);
+
+      await runPortForward(fixture, 'stop', 'supabase-gateway');
+      expect(await readForwardPid(fixture, 'app')).toBe(appPid);
+      await expectForwardPid(fixture, 'supabase-gateway', false);
+
+      const recovery = await runPortForward(fixture, 'start', 'runtime');
+      expect(recovery.stdout).toContain(`app: running (pid ${appPid})`);
+      expect(recovery.stdout).toContain('supabase-gateway: started');
+      expect(await readForwardPid(fixture, 'app')).toBe(appPid);
+      expect(await readForwardPid(fixture, 'supabase-gateway')).not.toBe(firstGatewayPid);
+      await expectForwardPid(fixture, 'studio', false);
+      await expectForwardPid(fixture, 'db-migration', false);
+
+      await runPortForward(fixture, 'stop', 'runtime');
+    },
+    { timeout: 30_000 },
+  );
+
+  test(
+    'starts only the app forward when no provider owns another runtime endpoint',
+    async () => {
+      const fixture = await createPortForwardFixture(
+        { deployment: { target: 'minikube', monitoring: false }, modules: [] },
+        'runtime-app-only',
+      );
+
+      const result = await runPortForward(fixture, 'start', 'runtime');
+
+      expect(result.stdout).toContain('app: started');
+      expect(result.stdout).not.toContain('supabase-gateway');
+      await expectForwardPid(fixture, 'app', true);
+      await expectForwardPid(fixture, 'supabase-gateway', false);
+      await expectForwardPid(fixture, 'studio', false);
+      await expectForwardPid(fixture, 'db-migration', false);
+
+      await runPortForward(fixture, 'stop', 'runtime');
+    },
+    { timeout: 15_000 },
+  );
+});
+
+interface PortForwardFixture {
+  readonly env: Record<string, string>;
+  readonly processDirectory: string;
+  readonly profile: string;
+  readonly rootPath: string;
+  readonly scriptPath: string;
+}
+
+async function createPortForwardFixture(
+  manifest: InfraManifestInput,
+  profile: string,
+): Promise<PortForwardFixture> {
+  const rootPath = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-port-forward-runtime-'));
+  temporaryPaths.add(rootPath);
+  const generated = generateInfrastructure(manifest, {
+    appManifest: createAppManifest(profile),
+  });
+  const generatedScript = generated.files.find(
+    (file) => file.path === 'infra/minikube/scripts/port-forward.sh',
+  );
+  if (generatedScript === undefined) {
+    throw new Error('Generated port-forward script was missing.');
+  }
+
+  const scriptPath = path.join(rootPath, generatedScript.path);
+  const fakeBin = path.join(rootPath, 'fake-bin');
+  const processDirectory = path.join(rootPath, 'fake-processes');
+  const serverScript = path.join(rootPath, 'forward-server.ts');
+  await fs.mkdir(path.dirname(scriptPath), { recursive: true });
+  await fs.mkdir(fakeBin, { recursive: true });
+  await fs.mkdir(processDirectory, { recursive: true });
+  await fs.writeFile(scriptPath, generatedScript.content, 'utf8');
+  await fs.chmod(scriptPath, 0o755);
+  await fs.writeFile(
+    serverScript,
+    [
+      "const port = Number.parseInt(Bun.argv[2] ?? '', 10);",
+      "Bun.serve({ hostname: '127.0.0.1', port, fetch: () => new Response('ok') });",
+      'await new Promise(() => undefined);',
+      '',
+    ].join('\n'),
+    'utf8',
+  );
+  await writeExecutable(
+    path.join(fakeBin, 'kubectl'),
+    `#!/usr/bin/env bash
+set -euo pipefail
+if [[ " $* " == *" get "* ]]; then
+  exit 0
+fi
+if [[ " $* " != *" port-forward "* ]]; then
+  exit 1
+fi
+endpoint="\${!#}"
+local_port="\${endpoint%%:*}"
+printf 'kubectl %s\n' "$*" > "\${FAKE_PROCESS_DIRECTORY}/$$.command"
+exec bun "\${FAKE_FORWARD_SERVER_SCRIPT}" "\${local_port}"
+`,
+  );
+  await writeExecutable(
+    path.join(fakeBin, 'ps'),
+    `#!/usr/bin/env bash
+set -euo pipefail
+pid=""
+format=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -p) pid="$2"; shift 2 ;;
+    -o) format="$2"; shift 2 ;;
+    *) shift ;;
+  esac
+done
+command_file="\${FAKE_PROCESS_DIRECTORY}/\${pid}.command"
+if [[ -f "\${command_file}" && "\${format}" == "comm=" ]]; then
+  echo kubectl
+elif [[ -f "\${command_file}" && "\${format}" == "command=" ]]; then
+  cat "\${command_file}"
+else
+  /bin/ps -p "\${pid}" -o "\${format}"
+fi
+`,
+  );
+
+  const ports = reserveAvailablePorts(4);
+  return {
+    env: {
+      ...process.env,
+      ANKH_APP_SLUG: profile,
+      APP_PORT_FORWARD_LOCAL_PORT: String(ports[0]),
+      SUPABASE_GATEWAY_FORWARD_LOCAL_PORT: String(ports[1]),
+      SUPABASE_STUDIO_FORWARD_LOCAL_PORT: String(ports[2]),
+      SUPABASE_DB_FORWARD_LOCAL_PORT: String(ports[3]),
+      FAKE_FORWARD_SERVER_SCRIPT: serverScript,
+      FAKE_PROCESS_DIRECTORY: processDirectory,
+      PATH: `${fakeBin}:${process.env.PATH ?? ''}`,
+    },
+    processDirectory,
+    profile,
+    rootPath,
+    scriptPath,
+  };
+}
+
+async function runPortForward(
+  fixture: PortForwardFixture,
+  action: string,
+  name: string,
+): Promise<{ readonly exitCode: number; readonly stderr: string; readonly stdout: string }> {
+  const process = Bun.spawn(['bash', fixture.scriptPath, action, name], {
+    env: fixture.env,
+    stderr: 'pipe',
+    stdout: 'pipe',
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    process.exited,
+    new Response(process.stdout).text(),
+    new Response(process.stderr).text(),
+  ]);
+  if (exitCode !== 0) {
+    throw new Error(`port-forward ${action} ${name} failed (${exitCode}): ${stdout}${stderr}`);
+  }
+  return { exitCode, stderr, stdout };
+}
+
+async function readForwardPid(fixture: PortForwardFixture, name: string): Promise<number> {
+  const value = await fs.readFile(forwardPidPath(fixture, name), 'utf8');
+  return Number.parseInt(value.trim(), 10);
+}
+
+async function expectForwardPid(
+  fixture: PortForwardFixture,
+  name: string,
+  exists: boolean,
+): Promise<void> {
+  expect(await pathExists(forwardPidPath(fixture, name))).toBe(exists);
+}
+
+function forwardPidPath(fixture: PortForwardFixture, name: string): string {
+  return path.join(
+    fixture.rootPath,
+    'infra/minikube/.state/forwards',
+    `${fixture.profile}-${name}.pid`,
+  );
+}
+
+function reserveAvailablePorts(count: number): number[] {
+  const listeners = Array.from({ length: count }, () =>
+    Bun.listen({
+      hostname: '127.0.0.1',
+      port: 0,
+      socket: { data: () => undefined },
+    }),
+  );
+  const ports = listeners.map((listener) => listener.port);
+  listeners.forEach((listener) => listener.stop(true));
+  return ports;
+}
+
+async function writeExecutable(filePath: string, content: string): Promise<void> {
+  await fs.writeFile(filePath, content, 'utf8');
+  await fs.chmod(filePath, 0o755);
+}
+
+async function pathExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function stopFixtureProcesses(rootPath: string): Promise<void> {
+  const stateDirectory = path.join(rootPath, 'infra/minikube/.state/forwards');
+  let entries: string[];
+  try {
+    entries = await fs.readdir(stateDirectory);
+  } catch {
+    return;
+  }
+
+  await Promise.all(
+    entries
+      .filter((entry) => entry.endsWith('.pid'))
+      .map(async (entry) => {
+        const pid = Number.parseInt(
+          await fs.readFile(path.join(stateDirectory, entry), 'utf8'),
+          10,
+        );
+        if (Number.isInteger(pid)) {
+          try {
+            process.kill(pid, 'SIGKILL');
+          } catch {
+            // The generated lifecycle may already have stopped the process.
+          }
+        }
+      }),
+  );
+}
+
+function createSupabaseManifest(): InfraManifestInput {
+  return {
+    deployment: { target: 'minikube', monitoring: false },
+    auth: { scope: 'global', provider: 'supabase' },
+    database: { provider: 'supabase', tier: 'dev' },
+    modules: [],
+  };
+}

package/src/adapters/minikube/base/twoAppIsolation.integration.test.ts

@@ -7,6 +7,7 @@ import { promisify } from 'node:util';
 import { describe, expect, test } from 'bun:test';
 
 import { generateInfrastructure } from '../../../index';
+import { ensureProjectInfrastructureRuntime } from '../../../project/index';
 import { createAppManifest } from '../../../testSupport';
 import type { GeneratedInfrastructureFile, InfraManifestInput } from '../../../types';
 
@@ -16,14 +17,22 @@ const supabaseIsolationTest =
   process.env.ANKH_MINIKUBE_SUPABASE_ISOLATION === '1' ? test : test.skip;
 const TEST_TIMEOUT_MS = 1_800_000;
 const HTTP_TIMEOUT_MS = 60_000;
+const DIAGNOSTIC_TIMEOUT_MS = 60_000;
+const DIAGNOSTIC_OUTPUT_LIMIT = 20_000;
+const APP_ONLY_TEST_PROFILES = ['ankh-isolation-a', 'ankh-isolation-b'] as const;
+const SUPABASE_TEST_PROFILES = ['ankh-isolation-supa-a', 'ankh-isolation-supa-b'] as const;
+type TestOwnedMinikubeProfile =
+  | (typeof APP_ONLY_TEST_PROFILES)[number]
+  | (typeof SUPABASE_TEST_PROFILES)[number];
 
 describe('generated Minikube two-app isolation', () => {
   isolationTest(
     'runs two generated app profiles without sharing cluster resources',
     async () => {
+      await deleteTestOwnedMinikubeProfiles(APP_ONLY_TEST_PROFILES);
       const root = await mkdtemp(path.join(process.cwd(), '.tmp-minikube-isolation-'));
-      const first = await createGeneratedApp(root, 'ankh-isolation-a', 18181);
-      const second = await createGeneratedApp(root, 'ankh-isolation-b', 18182);
+      const first = await createGeneratedApp(root, APP_ONLY_TEST_PROFILES[0], 18181);
+      const second = await createGeneratedApp(root, APP_ONLY_TEST_PROFILES[1], 18182);
 
       try {
         await runScript(first.minikubeRoot, 'up.sh');
@@ -56,16 +65,18 @@ describe('generated Minikube two-app isolation', () => {
   supabaseIsolationTest(
     'runs two generated Supabase-backed profiles without shared runtime state',
     async () => {
+      await deleteTestOwnedMinikubeProfiles(SUPABASE_TEST_PROFILES);
       const root = await mkdtemp(path.join(process.cwd(), '.tmp-minikube-supabase-isolation-'));
       const [firstPorts, secondPorts] = await reserveSupabaseHostPortSets(2);
       if (!firstPorts || !secondPorts) {
         throw new Error('Expected two reserved Supabase host port sets.');
       }
-      const first = await createGeneratedSupabaseApp(root, 'ankh-isolation-supa-a', firstPorts);
-      const second = await createGeneratedSupabaseApp(root, 'ankh-isolation-supa-b', secondPorts);
+      const first = await createGeneratedSupabaseApp(root, SUPABASE_TEST_PROFILES[0], firstPorts);
+      const second = await createGeneratedSupabaseApp(root, SUPABASE_TEST_PROFILES[1], secondPorts);
 
       try {
         await runScript(first.minikubeRoot, 'up.sh');
+        await prepareSecondSupabaseProfile(first.slug, second.slug, root);
         await runScript(second.minikubeRoot, 'up.sh');
 
         await expectProfileOwnsAppNamespace(first.slug);
@@ -75,6 +86,7 @@ describe('generated Minikube two-app isolation', () => {
         await expectNoHostSupabaseComposeContainersFor(first.slug, second.slug);
 
         await expectSupabaseEndToEnd(first);
+        await expectRuntimePortForwardRecovery(first);
         const secondSession = await expectSupabaseEndToEnd(second);
 
         await runScript(second.minikubeRoot, 'down.sh');
@@ -97,6 +109,14 @@ describe('generated Minikube two-app isolation', () => {
   );
 });
 
+async function deleteTestOwnedMinikubeProfiles(
+  profiles: readonly TestOwnedMinikubeProfile[],
+): Promise<void> {
+  for (const profile of profiles) {
+    await execFile('minikube', ['delete', '-p', profile], { timeout: TEST_TIMEOUT_MS });
+  }
+}
+
 async function createGeneratedApp(root: string, slug: string, appPort: number) {
   const appRoot = path.join(root, slug);
   const minikubeRoot = path.join(appRoot, 'infra', 'minikube');
@@ -305,11 +325,182 @@ async function writeGeneratedFiles(
 }
 
 async function runScript(minikubeRoot: string, scriptName: string) {
-  return execFile(path.join(minikubeRoot, 'scripts', scriptName), {
-    cwd: minikubeRoot,
-    env: process.env,
-    timeout: TEST_TIMEOUT_MS,
-  });
+  try {
+    return await execFile(path.join(minikubeRoot, 'scripts', scriptName), {
+      cwd: minikubeRoot,
+      env: process.env,
+      timeout: TEST_TIMEOUT_MS,
+    });
+  } catch (error) {
+    if (scriptName !== 'up.sh') throw error;
+    const diagnostics = await collectFailedUpDiagnostics(minikubeRoot);
+    throw new Error(
+      `Generated ${scriptName} failed:\n${formatUnknownError(error)}\n\n${diagnostics}`,
+      { cause: error },
+    );
+  }
+}
+
+async function prepareSecondSupabaseProfile(
+  sourceProfile: string,
+  targetProfile: string,
+  scratchRoot: string,
+): Promise<void> {
+  const imagesResult = await execFile(
+    'kubectl',
+    [
+      '--context',
+      sourceProfile,
+      '-n',
+      'supabase',
+      'get',
+      'deployments',
+      '-o',
+      'jsonpath={range .items[*].spec.template.spec.containers[*]}{.image}{"\\n"}{end}',
+    ],
+    { timeout: DIAGNOSTIC_TIMEOUT_MS },
+  );
+  const images = [
+    ...new Set(imagesResult.stdout.split(/\r?\n/u).map((image) => image.trim())),
+  ].filter(Boolean);
+  if (images.length === 0) {
+    throw new Error(`Expected Supabase runtime images in profile ${sourceProfile}.`);
+  }
+
+  await execFile(
+    'minikube',
+    ['start', '-p', targetProfile, `--driver=${process.env.MINIKUBE_DRIVER ?? 'docker'}`],
+    { timeout: TEST_TIMEOUT_MS },
+  );
+
+  const imageArchive = path.join(scratchRoot, 'supabase-image-transfer.tar');
+  try {
+    for (const image of images) {
+      await execFile('minikube', ['-p', sourceProfile, 'image', 'save', image, imageArchive], {
+        timeout: TEST_TIMEOUT_MS,
+      });
+      await execFile('minikube', ['-p', targetProfile, 'image', 'load', imageArchive], {
+        timeout: TEST_TIMEOUT_MS,
+      });
+      await rm(imageArchive, { force: true });
+    }
+  } finally {
+    await rm(imageArchive, { force: true });
+  }
+}
+
+async function collectFailedUpDiagnostics(minikubeRoot: string): Promise<string> {
+  let profile: string;
+  try {
+    profile = readRequiredEnv(await readGeneratedEnv(minikubeRoot), 'ANKH_APP_SLUG');
+  } catch (error) {
+    return `Unable to determine the failed Minikube profile: ${formatUnknownError(error)}`;
+  }
+
+  const commands: readonly DiagnosticCommand[] = [
+    {
+      label: 'Minikube status',
+      command: 'minikube',
+      args: ['-p', profile, 'status'],
+    },
+    {
+      label: 'Supabase pods',
+      command: 'kubectl',
+      args: ['--context', profile, '-n', 'supabase', 'get', 'pods', '-o', 'wide'],
+    },
+    {
+      label: 'Postgres deployment',
+      command: 'kubectl',
+      args: ['--context', profile, '-n', 'supabase', 'describe', 'deployment', 'postgres'],
+    },
+    {
+      label: 'Postgres pod',
+      command: 'kubectl',
+      args: [
+        '--context',
+        profile,
+        '-n',
+        'supabase',
+        'describe',
+        'pod',
+        '-l',
+        'app.kubernetes.io/name=supabase-postgres',
+      ],
+    },
+    {
+      label: 'Postgres logs',
+      command: 'kubectl',
+      args: [
+        '--context',
+        profile,
+        '-n',
+        'supabase',
+        'logs',
+        '-l',
+        'app.kubernetes.io/name=supabase-postgres',
+        '--all-containers=true',
+        '--tail=200',
+      ],
+    },
+    {
+      label: 'Supabase events',
+      command: 'kubectl',
+      args: ['--context', profile, '-n', 'supabase', 'get', 'events', '--sort-by=.lastTimestamp'],
+    },
+    {
+      label: 'Supabase volumes',
+      command: 'kubectl',
+      args: ['--context', profile, '-n', 'supabase', 'get', 'pvc,pv'],
+    },
+    {
+      label: 'Docker containers',
+      command: 'docker',
+      args: ['ps', '--format', '{{.Names}}\\t{{.Status}}\\t{{.Image}}'],
+    },
+  ];
+  const output: string[] = [];
+  for (const command of commands) {
+    output.push(await captureDiagnostic(command));
+  }
+  return `Bounded diagnostics for failed Minikube profile ${profile}:\n\n${output.join('\n\n')}`;
+}
+
+interface DiagnosticCommand {
+  readonly label: string;
+  readonly command: string;
+  readonly args: readonly string[];
+}
+
+async function captureDiagnostic(diagnostic: DiagnosticCommand): Promise<string> {
+  const renderedCommand = [diagnostic.command, ...diagnostic.args].join(' ');
+  try {
+    const result = await execFile(diagnostic.command, [...diagnostic.args], {
+      timeout: DIAGNOSTIC_TIMEOUT_MS,
+    });
+    const output = [result.stdout.trim(), result.stderr.trim()].filter(Boolean).join('\n');
+    return `${diagnostic.label}\n$ ${renderedCommand}\n${truncateDiagnostic(output || '(no output)')}`;
+  } catch (error) {
+    return `${diagnostic.label}\n$ ${renderedCommand}\n${truncateDiagnostic(
+      formatUnknownError(error),
+    )}`;
+  }
+}
+
+function formatUnknownError(error: unknown): string {
+  if (!(error instanceof Error)) return String(error);
+  const childProcessError = error as Error & { stderr?: unknown; stdout?: unknown };
+  return [
+    error.message,
+    typeof childProcessError.stdout === 'string' ? childProcessError.stdout.trim() : '',
+    typeof childProcessError.stderr === 'string' ? childProcessError.stderr.trim() : '',
+  ]
+    .filter(Boolean)
+    .join('\n');
+}
+
+function truncateDiagnostic(output: string): string {
+  if (output.length <= DIAGNOSTIC_OUTPUT_LIMIT) return output;
+  return `${output.slice(0, DIAGNOSTIC_OUTPUT_LIMIT)}\n... diagnostic output truncated ...`;
 }
 
 async function removeDockerImage(image: string): Promise<void> {
@@ -369,6 +560,78 @@ async function expectNoHostSupabaseComposeContainersFor(...slugs: string[]) {
   }
 }
 
+async function expectRuntimePortForwardRecovery(app: {
+  appRoot: string;
+  minikubeRoot: string;
+  slug: string;
+}): Promise<void> {
+  const appPidBefore = await readForwardPid(app.minikubeRoot, app.slug, 'app');
+  const gatewayPidBefore = await readForwardPid(app.minikubeRoot, app.slug, 'supabase-gateway');
+
+  await runPortForward(app.minikubeRoot, 'stop', 'supabase-gateway');
+  await runPortForward(app.minikubeRoot, 'stop', 'studio');
+  await runPortForward(app.minikubeRoot, 'stop', 'db-migration');
+
+  await ensureProjectInfrastructureRuntime({
+    projectId: app.slug,
+    projectPath: app.appRoot,
+    target: 'minikube',
+  });
+
+  expect(await readForwardPid(app.minikubeRoot, app.slug, 'app')).toBe(appPidBefore);
+  expect(await readForwardPid(app.minikubeRoot, app.slug, 'supabase-gateway')).not.toBe(
+    gatewayPidBefore,
+  );
+  await expectForwardPidMissing(app.minikubeRoot, app.slug, 'studio');
+  await expectForwardPidMissing(app.minikubeRoot, app.slug, 'db-migration');
+
+  const env = await readGeneratedEnv(app.minikubeRoot);
+  const gatewayUrl = readRequiredEnv(env, 'SUPABASE_PUBLIC_URL');
+  const anonKey = readRequiredEnv(env, 'SUPABASE_ANON_KEY');
+  const response = await fetch(`${gatewayUrl}/auth/v1/health`, {
+    signal: AbortSignal.timeout(HTTP_TIMEOUT_MS),
+    headers: {
+      apikey: anonKey,
+    },
+  });
+  expect(response.ok).toBe(true);
+}
+
+async function runPortForward(
+  minikubeRoot: string,
+  action: 'start' | 'status' | 'stop',
+  name: string,
+): Promise<void> {
+  await execFile(path.join(minikubeRoot, 'scripts', 'port-forward.sh'), [action, name], {
+    cwd: minikubeRoot,
+    env: process.env,
+    timeout: 60_000,
+  });
+}
+
+async function readForwardPid(minikubeRoot: string, slug: string, name: string): Promise<number> {
+  const value = await readFile(forwardPidPath(minikubeRoot, slug, name), 'utf8');
+  return Number.parseInt(value.trim(), 10);
+}
+
+async function expectForwardPidMissing(
+  minikubeRoot: string,
+  slug: string,
+  name: string,
+): Promise<void> {
+  let exists = true;
+  try {
+    await readFile(forwardPidPath(minikubeRoot, slug, name), 'utf8');
+  } catch {
+    exists = false;
+  }
+  expect(exists).toBe(false);
+}
+
+function forwardPidPath(minikubeRoot: string, slug: string, name: string): string {
+  return path.join(minikubeRoot, '.state', 'forwards', `${slug}-${name}.pid`);
+}
+
 interface SupabaseSessionFixture {
   readonly accessToken: string;
   readonly anonKey: string;

package/src/adapters/minikube/index.ts

@@ -1,4 +1,4 @@
-import { generateGeneratedApiDatabaseArtifacts } from '../../generatedApiDatabase';
+import { validateInfraApiSupport } from '../../infraValidation';
 import type {
   GeneratedPackageDependency,
   InfraManifestInput,
@@ -45,21 +45,6 @@ export function generateMinikubeInfra(
   });
   const storageArtifacts = generateStorageArtifacts({ manifest, namespace });
   const secretStoreArtifacts = generateSecretStoreArtifacts({ manifest, namespace });
-  const generatedApiDatabaseArtifacts = generateGeneratedApiDatabaseArtifacts({
-    generatedApis: options.appManifest?.generatedApis,
-    databaseProvider: manifest.database?.provider,
-  });
-  const generatedApiErrors = generatedApiDatabaseArtifacts.diagnostics.filter(
-    (diagnostic) => diagnostic.severity === 'error',
-  );
-
-  if (generatedApiErrors.length > 0) {
-    throw new Error(
-      `Generated API database definition is invalid:\n${generatedApiErrors
-        .map((diagnostic) => `- ${diagnostic.path ?? diagnostic.apiId}: ${diagnostic.message}`)
-        .join('\n')}`,
-    );
-  }
 
   const extraResources = unique([
     ...authArtifacts.resources,
@@ -98,9 +83,6 @@ export function generateMinikubeInfra(
     ...authzArtifacts.warnings,
     ...storageArtifacts.warnings,
     ...secretStoreArtifacts.warnings,
-    ...generatedApiDatabaseArtifacts.diagnostics
-      .filter((diagnostic) => diagnostic.severity === 'warning')
-      .map((diagnostic) => diagnostic.message),
   ]);
 
   return {
@@ -110,7 +92,6 @@ export function generateMinikubeInfra(
       ...authzArtifacts.files,
       ...storageArtifacts.files,
       ...secretStoreArtifacts.files,
-      ...generatedApiDatabaseArtifacts.files,
     ],
     warnings,
     meta: {
@@ -151,7 +132,7 @@ function collectDependencies(manifest: InfraManifestInput): readonly GeneratedPa
 }
 
 function collectWarnings(manifest: InfraManifestInput): string[] {
-  const warnings: string[] = [];
+  const warnings = [...validateInfraApiSupport(manifest)];
 
   if (manifest.deployment?.monitoring) {
     warnings.push(