@ankhorage/infra 7.1.107 → 7.2.1

package/src/cli/createInfraRuntimeProvider.ts

@@ -1,11 +1,7 @@
 import type { AnkhRuntimeCommandProvider } from '@ankhorage/ankh';
 
-import {
-  INFRA_CAPABILITIES,
-  INFRA_COMMAND_CATEGORY,
-  INFRA_PACKAGE_NAME,
-  INFRA_PACKAGE_VERSION,
-} from '../constants.js';
+import { CAPABILITIES } from '../capabilities/index.js';
+import { INFRA_COMMAND_CATEGORY, INFRA_PACKAGE_NAME, INFRA_PACKAGE_VERSION } from '../constants.js';
 import type { CreateInfraRuntimeProviderOptions } from '../types/infraCli.js';
 import { INFRA_COMMANDS } from './constants.js';
 import { createProviderCommandDescriptors } from './createProviderCommandDescriptors.js';
@@ -20,7 +16,7 @@ export function createInfraRuntimeProvider(
     id: INFRA_PACKAGE_NAME,
     category: INFRA_COMMAND_CATEGORY,
     version: INFRA_PACKAGE_VERSION,
-    capabilities: [...INFRA_CAPABILITIES],
+    capabilities: CAPABILITIES,
     commands: createProviderCommandDescriptors(),
     handlers: INFRA_COMMANDS.map((command) => ({
       path: command.path,

package/src/cli/index.test.ts

@@ -1,22 +1,14 @@
 import type { AnkhRuntimeCommandProvider } from '@ankhorage/ankh';
 import { describe, expect, test } from 'bun:test';
 
+import { CAPABILITIES } from '../capabilities/index.js';
 import { createProviderCommandDescriptors } from './createProviderCommandDescriptors.js';
 import provider, { createInfraRuntimeProvider } from './index.js';
 
 describe('Infra Ankh provider', () => {
-  test('publishes all eight canonical capabilities and handlers', () => {
+  test('publishes the canonical capability descriptors and handlers', () => {
     const expected = createInfraRuntimeProvider() satisfies AnkhRuntimeCommandProvider;
-    expect(expected.capabilities).toEqual([
-      'infra.validate',
-      'infra.plan',
-      'infra.generate',
-      'infra.up',
-      'infra.status',
-      'infra.outputs',
-      'infra.down',
-      'infra.destroy',
-    ]);
+    expect(expected.capabilities).toEqual(CAPABILITIES);
     expect(expected.commands).toEqual(createProviderCommandDescriptors());
     expect(expected.handlers).toHaveLength(8);
     expect(provider.handlers).toHaveLength(8);

package/src/commands.test.ts

@@ -3,6 +3,7 @@ import type { AppManifest } from '@ankhorage/contracts';
 import type { InfraEnvironmentSpec, InfraLedger, InfraResult } from '@ankhorage/contracts/infra';
 import { describe, expect, test } from 'bun:test';
 
+import { CAPABILITIES } from './capabilities/index.js';
 import { INFRA_COMMANDS } from './cli/constants.js';
 import { createInfraRuntimeProvider } from './cli/createInfraRuntimeProvider.js';
 import { createProviderCommandDescriptors } from './cli/createProviderCommandDescriptors.js';
@@ -17,6 +18,9 @@ describe('canonical Infra commands', () => {
   test('exposes the same locked eight-command surface everywhere', () => {
     const names = ['validate', 'plan', 'generate', 'up', 'status', 'outputs', 'down', 'destroy'];
     expect(INFRA_COMMANDS.map(({ standaloneName }) => standaloneName)).toEqual(names);
+    expect(INFRA_COMMANDS.map(({ capability }) => capability)).toEqual(
+      CAPABILITIES.map(({ id }) => id),
+    );
     expect(createProviderCommandDescriptors().map(({ path }) => path.join(' '))).toEqual(names);
     const help = renderProviderHelp({
       commandPrefix: ['ankhorage-infra'],

package/src/constants.ts

@@ -1,28 +1,14 @@
-import type {
-  AnkhCapabilityId,
-  AnkhCommandCategory,
-  AnkhPackageMetadata,
-} from '@ankhorage/contracts/cli';
+import type { AnkhCommandCategory, AnkhPackageMetadata } from '@ankhorage/contracts/cli';
 
 import packageJson from '../package.json';
+import { CAPABILITIES } from './capabilities/index.js';
 
 export const INFRA_PACKAGE_NAME = packageJson.name;
 export const INFRA_PACKAGE_VERSION = packageJson.version;
 export const INFRA_PACKAGE_DESCRIPTION = packageJson.description;
 export const INFRA_COMMAND_CATEGORY = 'infra' as const satisfies AnkhCommandCategory;
-export const INFRA_CAPABILITIES = [
-  'infra.validate',
-  'infra.plan',
-  'infra.generate',
-  'infra.up',
-  'infra.status',
-  'infra.outputs',
-  'infra.down',
-  'infra.destroy',
-] as const satisfies readonly AnkhCapabilityId[];
-
 export const INFRA_PACKAGE_METADATA = {
   category: INFRA_COMMAND_CATEGORY,
   provider: './dist/cli/index.js',
-  capabilities: INFRA_CAPABILITIES,
+  capabilities: CAPABILITIES,
 } as const satisfies AnkhPackageMetadata;

package/src/metadata/index.ts

@@ -1,5 +1,4 @@
 export {
-  INFRA_CAPABILITIES,
   INFRA_COMMAND_CATEGORY,
   INFRA_PACKAGE_METADATA,
   INFRA_PACKAGE_NAME,

package/src/package.test.ts

@@ -1,41 +1,39 @@
-import type { AnkhPackageMetadata } from '@ankhorage/contracts/cli';
+import { areCapabilitiesEqual, isCapability } from '@ankhorage/contracts/capabilities';
 import { describe, expect, test } from 'bun:test';
 
 import packageJson from '../package.json';
+import { CAPABILITIES } from './capabilities/index.js';
 
 describe('package metadata', () => {
-  test('publishes the expected Ankh metadata and bin entry', () => {
-    const expectedAnkhMetadata = {
-      category: 'infra',
-      provider: './dist/cli/index.js',
-      capabilities: [
-        'infra.validate',
-        'infra.plan',
-        'infra.generate',
-        'infra.up',
-        'infra.status',
-        'infra.outputs',
-        'infra.down',
-        'infra.destroy',
-      ],
-    } as const satisfies AnkhPackageMetadata;
-
+  test('publishes the canonical capability catalog and bin entry', () => {
     expect(packageJson.name).toBe('@ankhorage/infra');
     expect(packageJson.type).toBe('module');
     expect(packageJson.bin).toEqual({
       'ankhorage-infra': './dist/cli/bin.js',
     });
-    expect(packageJson.ankh).toEqual(expectedAnkhMetadata);
+    expect(packageJson.ankh.category).toBe('infra');
+    expect(packageJson.ankh.provider).toBe('./dist/cli/index.js');
+    expect(packageJson.ankh.capabilities).toHaveLength(CAPABILITIES.length);
+    expect(packageJson.ankh.capabilities.every(isCapability)).toBeTrue();
+    expect(packageJson.ankh.capabilities).toEqual(CAPABILITIES);
     expect(packageJson.exports['./project']).toEqual({
       types: './dist/project/index.d.ts',
       import: './dist/project/index.js',
       default: './dist/project/index.js',
     });
-    expect(JSON.parse(JSON.stringify(expectedAnkhMetadata))).toEqual(expectedAnkhMetadata);
+    expect(packageJson.exports['./capabilities']).toEqual({
+      types: './dist/capabilities/index.d.ts',
+      import: './dist/capabilities/index.js',
+      default: './dist/capabilities/index.js',
+    });
+  });
 
-    const capabilityText = JSON.stringify(packageJson.ankh.capabilities);
-    expect(capabilityText).not.toContain('portForward');
-    expect(capabilityText).not.toContain('port-forward');
-    expect(capabilityText).not.toContain('port.forward');
+  test('rejects string-only and conflicting capability metadata publication', () => {
+    for (const [index, capability] of CAPABILITIES.entries()) {
+      const published = packageJson.ankh.capabilities.at(index);
+      if (published === undefined) throw new Error('Published capability metadata is incomplete.');
+      expect(typeof published).toBe('object');
+      expect(areCapabilitiesEqual(published, capability)).toBeTrue();
+    }
   });
 });

package/src/types/infraCli.ts

@@ -1,4 +1,4 @@
-import type { AnkhCapabilityId } from '@ankhorage/contracts/cli';
+import type { Capability } from '@ankhorage/contracts/capabilities';
 import type { AppEnvironmentId } from '@ankhorage/contracts/environments';
 import type {
   InfraEnvironmentSpec,
@@ -57,7 +57,7 @@ type InfraCommandImplementation = (
 ) => Promise<InfraCommandRunResult>;
 
 export interface InfraCommandDefinition {
-  readonly capability: AnkhCapabilityId;
+  readonly capability: Capability['id'];
   readonly path: readonly [InfraCommandName];
   readonly standaloneName: InfraCommandName;
   readonly summary: string;