@ankhorage/infra 3.3.0 → 4.1.0

package/src/apiInfrastructure.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from 'bun:test';
+
+import { generateInfrastructure } from './index';
+import { createAppManifest } from './testSupport';
+import type { InfraManifestInput } from './types';
+
+const DEPLOYMENT = { target: 'minikube', monitoring: false } as const;
+
+describe('canonical API infrastructure', () => {
+  test('treats external APIs as infrastructure no-ops', () => {
+    const manifest: InfraManifestInput = {
+      deployment: DEPLOYMENT,
+      modules: [],
+      apis: [
+        {
+          id: 'nutrition',
+          origin: 'external',
+          protocol: 'rest',
+          baseUrl: 'https://api.ankhorage.com/v1/nutrition',
+          endpoints: {},
+        },
+      ],
+    };
+
+    const result = generateInfrastructure(manifest, {
+      appManifest: createAppManifest('nutrition', manifest),
+    });
+
+    expect(result.warnings).not.toContainEqual(expect.stringContaining('infra.apis.nutrition'));
+    expect(listApiArtifactPaths(result.files)).toEqual([]);
+  });
+
+  test('warns for internal APIs without generating partial API infrastructure', () => {
+    const manifest: InfraManifestInput = {
+      deployment: DEPLOYMENT,
+      modules: [],
+      apis: [
+        {
+          id: 'orders',
+          origin: 'internal',
+          protocol: 'rest',
+          basePath: '/api/orders',
+          endpoints: {},
+        },
+      ],
+    };
+
+    const result = generateInfrastructure(manifest, {
+      appManifest: createAppManifest('orders', manifest),
+    });
+
+    expect(result.warnings).toContain(
+      'infra.apis.orders has origin "internal", but internal API provisioning is not supported in Phase 1; no API infrastructure will be generated.',
+    );
+    expect(listApiArtifactPaths(result.files)).toEqual([]);
+  });
+});
+
+function listApiArtifactPaths(files: readonly { readonly path: string }[]): readonly string[] {
+  return files
+    .map((file) => file.path)
+    .filter(
+      (path) =>
+        path.includes('generated-api') ||
+        path.includes('generated_api') ||
+        path.includes('/api/deployment') ||
+        path.includes('/api/service'),
+    );
+}

package/src/generatedApiLedgerCleanup.test.ts

@@ -0,0 +1,72 @@
+import { expect, test } from 'bun:test';
+import { promises as fs } from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { syncProjectInfrastructure } from './projectInfrastructure';
+import { createAppManifest } from './testSupport';
+
+const OBSOLETE_FILES = [
+  'infra/minikube/db/generated-api-resources.json',
+  'infra/minikube/db/migrations/001_generated_api_resources.sql',
+] as const;
+
+test('removes obsolete generated API database artifacts tracked by the infra ledger', async () => {
+  const projectPath = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-api-cleanup-'));
+
+  try {
+    await writeObsoleteArtifacts(projectPath);
+    const manifest = createAppManifest('shop', {
+      deployment: { target: 'minikube', monitoring: false },
+      modules: [],
+    });
+    const result = await syncProjectInfrastructure({
+      projectId: 'shop',
+      projectPath,
+      manifest,
+      generateInfrastructureImpl: () => ({
+        files: [],
+        warnings: [],
+        meta: { target: 'minikube', providers: [] },
+        dependencies: [],
+      }),
+    });
+
+    expect(result.removed).toBe(OBSOLETE_FILES.length);
+    for (const filePath of OBSOLETE_FILES) {
+      expect(await pathExists(path.join(projectPath, filePath))).toBe(false);
+    }
+  } finally {
+    await fs.rm(projectPath, { force: true, recursive: true });
+  }
+});
+
+async function writeObsoleteArtifacts(projectPath: string): Promise<void> {
+  for (const filePath of OBSOLETE_FILES) {
+    const absolutePath = path.join(projectPath, filePath);
+    await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+    await fs.writeFile(absolutePath, 'obsolete', 'utf8');
+  }
+
+  await fs.mkdir(path.join(projectPath, '.ankh'), { recursive: true });
+  await fs.writeFile(
+    path.join(projectPath, '.ankh/infra-ledger.json'),
+    JSON.stringify({
+      schemaVersion: 1,
+      generatedAt: new Date().toISOString(),
+      target: 'minikube',
+      files: OBSOLETE_FILES,
+      warnings: [],
+    }),
+    'utf8',
+  );
+}
+
+async function pathExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/index.ts

@@ -14,12 +14,6 @@ export {
   resolveAuthRedirectConfiguration,
   type ResolveAuthRedirectConfigurationInput,
 } from './authRedirects';
-export {
-  type GeneratedApiDatabaseArtifacts,
-  type GeneratedApiDatabaseDiagnostic,
-  type GeneratedApiDatabaseDiagnosticCode,
-  generateGeneratedApiDatabaseArtifacts,
-} from './generatedApiDatabase';
 export {
   createInfraSecretStoreAdapter,
   type CreateInfraSecretStoreAdapterInput,

package/src/infraApiValidation.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from 'bun:test';
+
+import { validateInfraSupport } from './infraValidation';
+import type { InfraManifestInput } from './types';
+
+describe('canonical API support validation', () => {
+  test('does not warn for external APIs', () => {
+    const manifest: InfraManifestInput = {
+      modules: [],
+      apis: [
+        {
+          id: 'nutrition',
+          origin: 'external',
+          protocol: 'rest',
+          baseUrl: 'https://api.ankhorage.com/v1/nutrition',
+          endpoints: {},
+        },
+      ],
+    };
+
+    expect(validateInfraSupport(manifest)).toEqual([]);
+  });
+
+  test('reports every internal API as unsupported without treating it as invalid', () => {
+    const manifest: InfraManifestInput = {
+      modules: [],
+      apis: [
+        {
+          id: 'orders',
+          origin: 'internal',
+          protocol: 'rest',
+          basePath: '/api/orders',
+          endpoints: {},
+        },
+      ],
+    };
+
+    expect(validateInfraSupport(manifest)).toEqual([
+      'infra.apis.orders has origin "internal", but internal API provisioning is not supported in Phase 1; no API infrastructure will be generated.',
+    ]);
+  });
+});

package/src/infraValidation.ts

@@ -9,7 +9,7 @@ import {
 import type { InfraManifestInput } from './types.js';
 
 export function validateInfraSupport(manifest: InfraManifestInput): readonly string[] {
-  const warnings: string[] = [];
+  const warnings: string[] = [...validateInfraApiSupport(manifest)];
 
   const deploymentTarget = manifest.deployment?.target;
   if (deploymentTarget !== undefined && !isSupported(deploymentTarget, DEPLOYMENT_TARGETS)) {
@@ -69,6 +69,15 @@ export function validateInfraSupport(manifest: InfraManifestInput): readonly str
   return warnings;
 }
 
+export function validateInfraApiSupport(manifest: InfraManifestInput): readonly string[] {
+  return (manifest.apis ?? [])
+    .filter((api) => api.origin === 'internal')
+    .map(
+      (api) =>
+        `infra.apis.${api.id} has origin "internal", but internal API provisioning is not supported in Phase 1; no API infrastructure will be generated.`,
+    );
+}
+
 function warningForUnsupportedValue(args: {
   readonly path: string;
   readonly value: string;

package/src/project/index.test.ts

@@ -5,6 +5,7 @@ import path from 'path';
 
 import { createAppManifest } from '../testSupport.js';
 import {
+  ensureProjectInfrastructureRuntime,
   inspectProjectInfrastructure,
   readProjectInfrastructureEnvironment,
   resolveProjectInfrastructureDatabaseUrl,
@@ -78,6 +79,39 @@ describe('@ankhorage/infra/project', () => {
     });
   });
 
+  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({
@@ -147,3 +181,15 @@ describe('@ankhorage/infra/project', () => {
     });
   });
 });
+
+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

@@ -12,6 +12,7 @@ export {
   syncProjectInfrastructure,
 } from '../projectInfrastructure.js';
 export {
+  ensureProjectInfrastructureRuntime,
   type InfraLifecycleScript,
   type InfraPortForwardInfo,
   InfraScriptExecutionError,

package/src/readme-usage.ts

@@ -29,6 +29,11 @@ import { runCli } from './cli/bin.js';
  * operations accept an explicit project path and do not require Studio or a
  * particular workspace layout.
  *
+ * Running applications can repair their provider-aware host endpoints through
+ * `ensureProjectInfrastructureRuntime()` from `@ankhorage/infra/project`. This
+ * operation only ensures the generated runtime port-forward group; it does not
+ * deploy, bootstrap, or reconcile infrastructure.
+ *
  * @usage
  */
 await runCli(['--help']);

package/src/runtime.ts

@@ -85,6 +85,37 @@ export async function resolveProjectInfrastructurePortForward(args: {
   };
 }
 
+/** Ensures the generated host forwards required by a running application are active. */
+export async function ensureProjectInfrastructureRuntime(args: {
+  readonly projectId: string;
+  readonly projectPath: string;
+  readonly target: string;
+}): Promise<InfraScriptOutput> {
+  try {
+    return await runProjectInfrastructureLifecycle({
+      args: ['start', 'runtime'],
+      projectId: args.projectId,
+      projectPath: args.projectPath,
+      script: 'port-forward',
+      target: args.target,
+    });
+  } catch (error) {
+    if (!(error instanceof InfraScriptExecutionError)) {
+      throw error;
+    }
+
+    const detail = error.stderr.trim() || error.stdout.trim();
+    throw new InfraScriptExecutionError({
+      exitCode: error.exitCode,
+      message: `Failed to ensure infrastructure runtime for project '${args.projectId}'${
+        detail.length > 0 ? `: ${detail}` : '.'
+      }`,
+      stderr: error.stderr,
+      stdout: error.stdout,
+    });
+  }
+}
+
 export async function runProjectInfraScript(args: {
   readonly context: InfraCommandContext;
   readonly projectId: string;

package/src/types.ts

@@ -37,7 +37,7 @@ export interface InfrastructureGenerationOptions {
    */
   readonly appManifest?: Pick<
     AppManifest,
-    'deploy' | 'generatedApis' | 'infra' | 'metadata' | 'navigator' | 'screens' | 'settings'
+    'deploy' | 'infra' | 'metadata' | 'navigator' | 'screens' | 'settings'
   >;
 }
 

package/dist/generatedApiDatabase.d.ts

@@ -1,20 +0,0 @@
-import type { GeneratedApiRegistry } from '@ankhorage/contracts';
-import type { GeneratedInfrastructureFile } from './types';
-export type GeneratedApiDatabaseDiagnosticCode = 'duplicate-field' | 'duplicate-resource-id' | 'duplicate-target' | 'invalid-default' | 'invalid-identifier' | 'invalid-primary-key' | 'invalid-seed' | 'registry-id-mismatch' | 'unsupported-policy' | 'unsupported-provider';
-export interface GeneratedApiDatabaseDiagnostic {
-    readonly code: GeneratedApiDatabaseDiagnosticCode;
-    readonly severity: 'error' | 'warning';
-    readonly apiId: string;
-    readonly resourceId?: string;
-    readonly path?: string;
-    readonly message: string;
-}
-export interface GeneratedApiDatabaseArtifacts {
-    readonly files: readonly GeneratedInfrastructureFile[];
-    readonly diagnostics: readonly GeneratedApiDatabaseDiagnostic[];
-}
-export declare function generateGeneratedApiDatabaseArtifacts(args: {
-    readonly generatedApis: GeneratedApiRegistry | undefined;
-    readonly databaseProvider: string | undefined;
-}): GeneratedApiDatabaseArtifacts;
-//# sourceMappingURL=generatedApiDatabase.d.ts.map

package/dist/generatedApiDatabase.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generatedApiDatabase.d.ts","sourceRoot":"","sources":["../src/generatedApiDatabase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAKV,oBAAoB,EAGrB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,SAAS,CAAC;AAE3D,MAAM,MAAM,kCAAkC,GAC1C,iBAAiB,GACjB,uBAAuB,GACvB,kBAAkB,GAClB,iBAAiB,GACjB,oBAAoB,GACpB,qBAAqB,GACrB,cAAc,GACd,sBAAsB,GACtB,oBAAoB,GACpB,sBAAsB,CAAC;AAE3B,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,IAAI,EAAE,kCAAkC,CAAC;IAClD,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,KAAK,EAAE,SAAS,2BAA2B,EAAE,CAAC;IACvD,QAAQ,CAAC,WAAW,EAAE,SAAS,8BAA8B,EAAE,CAAC;CACjE;AAmBD,wBAAgB,qCAAqC,CAAC,IAAI,EAAE;IAC1D,QAAQ,CAAC,aAAa,EAAE,oBAAoB,GAAG,SAAS,CAAC;IACzD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/C,GAAG,6BAA6B,CA2ChC"}