@ankhorage/infra 4.1.12 → 5.0.0

package/src/commands.ts

@@ -1,404 +0,0 @@
-import type { AnkhCapabilityId, AnkhCommandDescriptor } from '@ankhorage/contracts/cli';
-
-import type { InfraCommandContext, InfraCommandRunResult } from './commandContext.js';
-import { validateInfraSupport } from './infraValidation.js';
-import { INFRA_CAPABILITIES, INFRA_COMMAND_CATEGORY } from './packageMetadata.js';
-import type { ResolvedInfraProject } from './project.js';
-import { resolveInfraProject } from './project.js';
-import type { InfraSyncResult } from './projectInfrastructure.js';
-import {
-  resolveProjectInfrastructureTarget,
-  syncProjectInfrastructure,
-} from './projectInfrastructure.js';
-import type { InfraLifecycleScript } from './runtime.js';
-import { runProjectInfraScript } from './runtime.js';
-
-type InfraCommandName = 'down' | 'generate' | 'status' | 'up' | 'validate';
-
-interface InfraCommandRunRequest {
-  readonly context: InfraCommandContext;
-  readonly projectId?: string;
-}
-
-type InfraCommandImplementation = (
-  request: InfraCommandRunRequest,
-  services: InfraCommandServices,
-) => Promise<InfraCommandRunResult>;
-
-export interface InfraCommandDefinition {
-  readonly capability: AnkhCapabilityId;
-  readonly path: readonly [InfraCommandName];
-  readonly standaloneName: InfraCommandName;
-  readonly summary: string;
-  readonly run: InfraCommandImplementation;
-}
-
-export interface InfraCommandInvocation {
-  readonly argv: readonly string[];
-  readonly command: InfraCommandDefinition;
-  readonly context: InfraCommandContext;
-}
-
-export interface InfraCommandServices {
-  readonly resolveProject: (options: {
-    readonly cwd: string;
-    readonly projectId?: string;
-  }) => Promise<ResolvedInfraProject>;
-  readonly resolveProjectInfrastructureTarget: (args: {
-    readonly manifest: ResolvedInfraProject['manifest'];
-    readonly projectPath: string;
-  }) => Promise<string | null>;
-  readonly runProjectInfraScript: (args: {
-    readonly context: InfraCommandContext;
-    readonly projectId: string;
-    readonly projectPath: string;
-    readonly script: InfraLifecycleScript;
-    readonly target: string;
-  }) => Promise<void>;
-  readonly syncProjectInfrastructure: (args: {
-    readonly manifest: ResolvedInfraProject['manifest'];
-    readonly projectId: string;
-    readonly projectPath: string;
-  }) => Promise<InfraSyncResult>;
-  readonly validateInfraSupport: typeof validateInfraSupport;
-}
-
-export interface RunInfraCommandOptions {
-  readonly runCommandImpl?: RunInfraCommandImpl;
-  readonly services?: Partial<InfraCommandServices>;
-}
-
-export type RunInfraCommandImpl = (
-  request: InfraCommandInvocation,
-  options?: RunInfraCommandOptions,
-) => Promise<InfraCommandRunResult>;
-
-const COMMAND_CAPABILITIES = {
-  validate: INFRA_CAPABILITIES[0],
-  generate: INFRA_CAPABILITIES[1],
-  status: INFRA_CAPABILITIES[2],
-  up: INFRA_CAPABILITIES[3],
-  down: INFRA_CAPABILITIES[4],
-} as const satisfies Record<InfraCommandName, AnkhCapabilityId>;
-
-export const INFRA_COMMANDS = [
-  {
-    standaloneName: 'validate',
-    path: ['validate'],
-    capability: COMMAND_CAPABILITIES.validate,
-    summary: 'Validate infra support for a project manifest.',
-    run: runValidateCommand,
-  },
-  {
-    standaloneName: 'generate',
-    path: ['generate'],
-    capability: COMMAND_CAPABILITIES.generate,
-    summary: 'Generate infra artifacts and update the infra ledger for a project.',
-    run: runGenerateCommand,
-  },
-  {
-    standaloneName: 'status',
-    path: ['status'],
-    capability: COMMAND_CAPABILITIES.status,
-    summary: 'Run the generated runtime status script for a project.',
-    run: runStatusCommand,
-  },
-  {
-    standaloneName: 'up',
-    path: ['up'],
-    capability: COMMAND_CAPABILITIES.up,
-    summary: 'Generate infra artifacts, then run the generated up script.',
-    run: runUpCommand,
-  },
-  {
-    standaloneName: 'down',
-    path: ['down'],
-    capability: COMMAND_CAPABILITIES.down,
-    summary: 'Run the generated down script for a project.',
-    run: runDownCommand,
-  },
-] as const satisfies readonly InfraCommandDefinition[];
-
-export async function runInfraCommand(
-  request: InfraCommandInvocation,
-  options: RunInfraCommandOptions = {},
-): Promise<InfraCommandRunResult> {
-  const services = createInfraCommandServices(options.services);
-
-  try {
-    const parsedArgs = parseCommandArguments(request.command, request.argv);
-    if (parsedArgs.kind === 'help') {
-      request.context.writeStdout(renderCommandHelp(request.command));
-      return { exitCode: 0 };
-    }
-
-    return await request.command.run(
-      {
-        context: request.context,
-        projectId: parsedArgs.projectId,
-      },
-      services,
-    );
-  } catch (error) {
-    request.context.writeStderr(renderCommandFailure(request.command.standaloneName, error));
-    return { exitCode: 1 };
-  }
-}
-
-export function createProviderCommandDescriptors(): readonly AnkhCommandDescriptor[] {
-  return INFRA_COMMANDS.map((command) => ({
-    capability: command.capability,
-    path: command.path,
-    summary: command.summary,
-  }));
-}
-
-export function findInfraCommandByStandaloneName(value: string): InfraCommandDefinition | null {
-  return INFRA_COMMANDS.find((command) => command.standaloneName === value) ?? null;
-}
-
-export function renderRootHelp(version: string): string {
-  const commandLines = INFRA_COMMANDS.map(
-    (command) => `  ${command.standaloneName.padEnd(8, ' ')} ${command.summary}`,
-  ).join('\n');
-
-  return [
-    `@ankhorage/infra v${version}`,
-    '',
-    'Usage:',
-    `  ankhorage-infra <command> [project]`,
-    `  ankh ${INFRA_COMMAND_CATEGORY} <command> [project]`,
-    '',
-    'Commands:',
-    commandLines,
-    '',
-    'Project resolution:',
-    '  Pass [project], or omit it when cwd is inside apps/<project>.',
-    '',
-  ].join('\n');
-}
-
-export function renderUnknownCommand(value: string): string {
-  return [`Unknown infra command: ${value}`, '', 'Run ankhorage-infra --help', ''].join('\n');
-}
-
-function renderCommandHelp(command: InfraCommandDefinition): string {
-  return [
-    `${command.summary}`,
-    '',
-    'Usage:',
-    `  ankhorage-infra ${command.standaloneName} [project]`,
-    `  ankh ${INFRA_COMMAND_CATEGORY} ${command.path.join(' ')} [project]`,
-    '',
-    'Project resolution:',
-    '  Pass [project], or omit it when cwd is inside apps/<project>.',
-    '',
-  ].join('\n');
-}
-
-function createInfraCommandServices(
-  overrides: Partial<InfraCommandServices> = {},
-): InfraCommandServices {
-  return {
-    resolveProject: overrides.resolveProject ?? resolveInfraProject,
-    resolveProjectInfrastructureTarget:
-      overrides.resolveProjectInfrastructureTarget ?? resolveProjectInfrastructureTarget,
-    runProjectInfraScript: overrides.runProjectInfraScript ?? runProjectInfraScript,
-    syncProjectInfrastructure: overrides.syncProjectInfrastructure ?? syncProjectInfrastructure,
-    validateInfraSupport: overrides.validateInfraSupport ?? validateInfraSupport,
-  };
-}
-
-function parseCommandArguments(
-  command: InfraCommandDefinition,
-  argv: readonly string[],
-): { readonly kind: 'help' } | { readonly kind: 'run'; readonly projectId?: string } {
-  if (argv.length === 1 && isHelpToken(argv[0])) {
-    return { kind: 'help' };
-  }
-
-  if (argv.length > 1) {
-    throw new Error(`Infra ${command.standaloneName} accepts at most one project argument.`);
-  }
-
-  return {
-    kind: 'run',
-    projectId: argv[0],
-  };
-}
-
-async function runValidateCommand(
-  request: InfraCommandRunRequest,
-  services: InfraCommandServices,
-): Promise<InfraCommandRunResult> {
-  const project = await services.resolveProject({
-    cwd: request.context.cwd,
-    projectId: request.projectId,
-  });
-  const warnings = [...services.validateInfraSupport(project.manifest.infra)];
-
-  request.context.writeStdout(`projectId: ${project.projectId}\n`);
-  request.context.writeStdout(`infraConfigSupport: ${warnings.length === 0 ? 'ok' : 'warnings'}\n`);
-  writeWarnings(request.context, warnings);
-
-  return { exitCode: 0 };
-}
-
-async function runGenerateCommand(
-  request: InfraCommandRunRequest,
-  services: InfraCommandServices,
-): Promise<InfraCommandRunResult> {
-  const project = await services.resolveProject({
-    cwd: request.context.cwd,
-    projectId: request.projectId,
-  });
-
-  request.context.writeStdout(`Regenerating infrastructure for project: ${project.projectId}...\n`);
-
-  const result = await services.syncProjectInfrastructure({
-    manifest: project.manifest,
-    projectId: project.projectId,
-    projectPath: project.projectPath,
-  });
-
-  if (result.skipped !== undefined) {
-    request.context.writeStdout(`Skipped: ${result.skipped.reason}\n`);
-    return { exitCode: 0 };
-  }
-
-  request.context.writeStdout(`Generated: ${result.generated}, removed stale: ${result.removed}\n`);
-  writeWarnings(request.context, result.warnings);
-
-  return { exitCode: 0 };
-}
-
-async function runStatusCommand(
-  request: InfraCommandRunRequest,
-  services: InfraCommandServices,
-): Promise<InfraCommandRunResult> {
-  const project = await services.resolveProject({
-    cwd: request.context.cwd,
-    projectId: request.projectId,
-  });
-  const target = await services.resolveProjectInfrastructureTarget({
-    manifest: project.manifest,
-    projectPath: project.projectPath,
-  });
-
-  if (target === null) {
-    throw new Error(
-      `Project '${project.projectId}' has no infrastructure target. Run infra generation first.`,
-    );
-  }
-
-  await services.runProjectInfraScript({
-    context: request.context,
-    projectId: project.projectId,
-    projectPath: project.projectPath,
-    script: 'status',
-    target,
-  });
-
-  return { exitCode: 0 };
-}
-
-async function runUpCommand(
-  request: InfraCommandRunRequest,
-  services: InfraCommandServices,
-): Promise<InfraCommandRunResult> {
-  const project = await services.resolveProject({
-    cwd: request.context.cwd,
-    projectId: request.projectId,
-  });
-
-  request.context.writeStdout(`Preparing infrastructure for project: ${project.projectId}...\n`);
-
-  const generateResult = await services.syncProjectInfrastructure({
-    manifest: project.manifest,
-    projectId: project.projectId,
-    projectPath: project.projectPath,
-  });
-
-  if (generateResult.skipped !== undefined) {
-    request.context.writeStdout(`Skipped: ${generateResult.skipped.reason}\n`);
-    return { exitCode: 0 };
-  }
-
-  writeWarnings(request.context, generateResult.warnings);
-
-  const target = await services.resolveProjectInfrastructureTarget({
-    manifest: project.manifest,
-    projectPath: project.projectPath,
-  });
-
-  if (project.manifest.infra.deployment === undefined || target === null) {
-    throw new Error(
-      `Project '${project.projectId}' has no infra.deployment target configured in ankh.config.json.`,
-    );
-  }
-
-  await services.runProjectInfraScript({
-    context: request.context,
-    projectId: project.projectId,
-    projectPath: project.projectPath,
-    script: 'up',
-    target,
-  });
-  request.context.writeStdout('Infrastructure is up.\n');
-
-  return { exitCode: 0 };
-}
-
-async function runDownCommand(
-  request: InfraCommandRunRequest,
-  services: InfraCommandServices,
-): Promise<InfraCommandRunResult> {
-  const project = await services.resolveProject({
-    cwd: request.context.cwd,
-    projectId: request.projectId,
-  });
-  const target = await services.resolveProjectInfrastructureTarget({
-    manifest: project.manifest,
-    projectPath: project.projectPath,
-  });
-
-  if (target === null) {
-    throw new Error(
-      `Project '${project.projectId}' has no infrastructure target. Run infra generation first.`,
-    );
-  }
-
-  await services.runProjectInfraScript({
-    context: request.context,
-    projectId: project.projectId,
-    projectPath: project.projectPath,
-    script: 'down',
-    target,
-  });
-  request.context.writeStdout('Infrastructure is down.\n');
-
-  return { exitCode: 0 };
-}
-
-function writeWarnings(context: InfraCommandContext, warnings: readonly string[]): void {
-  if (warnings.length === 0) {
-    return;
-  }
-
-  context.writeStderr('Warnings:\n');
-  for (const warning of warnings) {
-    context.writeStderr(`- ${warning}\n`);
-  }
-}
-
-function renderCommandFailure(commandName: InfraCommandName, error: unknown): string {
-  return `Infra ${commandName} failed: ${getErrorMessage(error)}\n`;
-}
-
-function getErrorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-function isHelpToken(value: string | undefined): boolean {
-  return value === '--help' || value === '-h' || value === 'help';
-}

package/src/generatedApiLedgerCleanup.test.ts

@@ -1,72 +0,0 @@
-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/infraApiValidation.test.ts

@@ -1,42 +0,0 @@
-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

@@ -1,99 +0,0 @@
-import {
-  AUTH_PROVIDERS,
-  AUTH_SCOPES,
-  AUTHZ_ENGINES,
-  DATABASE_PROVIDERS,
-  DEPLOYMENT_TARGETS,
-} from '@ankhorage/contracts';
-
-import type { InfraManifestInput } from './types.js';
-
-export function validateInfraSupport(manifest: InfraManifestInput): readonly string[] {
-  const warnings: string[] = [...validateInfraApiSupport(manifest)];
-
-  const deploymentTarget = manifest.deployment?.target;
-  if (deploymentTarget !== undefined && !isSupported(deploymentTarget, DEPLOYMENT_TARGETS)) {
-    warnings.push(
-      warningForUnsupportedValue({
-        path: 'infra.deployment.target',
-        value: deploymentTarget,
-        supported: DEPLOYMENT_TARGETS,
-      }),
-    );
-  }
-
-  const databaseProvider = manifest.database?.provider;
-  if (databaseProvider !== undefined && !isSupported(databaseProvider, DATABASE_PROVIDERS)) {
-    warnings.push(
-      warningForUnsupportedValue({
-        path: 'infra.database.provider',
-        value: databaseProvider,
-        supported: DATABASE_PROVIDERS,
-      }),
-    );
-  }
-
-  const authProvider = manifest.auth?.provider;
-  if (authProvider !== undefined && !isSupported(authProvider, AUTH_PROVIDERS)) {
-    warnings.push(
-      warningForUnsupportedValue({
-        path: 'infra.auth.provider',
-        value: authProvider,
-        supported: AUTH_PROVIDERS,
-      }),
-    );
-  }
-
-  const authScope = manifest.auth?.scope;
-  if (authScope !== undefined && !isSupported(authScope, AUTH_SCOPES)) {
-    warnings.push(
-      warningForUnsupportedValue({
-        path: 'infra.auth.scope',
-        value: authScope,
-        supported: AUTH_SCOPES,
-      }),
-    );
-  }
-
-  const authzEngine = manifest.auth?.authorization?.engine;
-  if (authzEngine !== undefined && !isSupported(authzEngine, AUTHZ_ENGINES)) {
-    warnings.push(
-      warningForUnsupportedValue({
-        path: 'infra.auth.authorization.engine',
-        value: authzEngine,
-        supported: AUTHZ_ENGINES,
-      }),
-    );
-  }
-
-  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;
-  readonly supported: readonly string[];
-}): string {
-  return `${args.path} "${args.value}" is not currently supported by implemented generators. Supported values: ${formatSupportedValues(args.supported)}.`;
-}
-
-function formatSupportedValues(values: readonly string[]): string {
-  if (values.length === 0) {
-    return '(none)';
-  }
-
-  return values.join(', ');
-}
-
-function isSupported(value: string, supported: readonly string[]): boolean {
-  return supported.includes(value);
-}

package/src/minikubeImageLifecycle.test.ts

@@ -1,35 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-
-import { generateInfrastructure } from './index';
-import { createAppManifest } from './testSupport';
-import type { InfraManifestInput } from './types';
-
-describe('minikube generated app image lifecycle', () => {
-  test('exposes generated cleanup flags and Docker image labels', () => {
-    const manifest: InfraManifestInput = {
-      deployment: {
-        target: 'minikube',
-        monitoring: false,
-      },
-      modules: [],
-    };
-
-    const result = generateInfrastructure(manifest, { appManifest: createAppManifest('shop') });
-
-    const envExample = result.files.find((file) => file.path === 'infra/minikube/.env.example');
-    expect(envExample?.content).toContain('APP_IMAGE=ankh/shop:dev');
-    expect(envExample?.content).toContain('APP_IMAGE_CLEANUP_ON_DESTROY=true');
-    expect(envExample?.content).toContain('APP_IMAGE_CLEANUP_MINIKUBE=true');
-    expect(envExample?.content).toContain('APP_IMAGE_CLEANUP_DOCKER=true');
-
-    const appBuildScript = result.files.find(
-      (file) => file.path === 'infra/minikube/scripts/build-app-image.sh',
-    );
-    expect(appBuildScript?.content).toContain('docker build');
-    expect(appBuildScript?.content).toContain('--label "ankhorage.kind=generated-app"');
-    expect(appBuildScript?.content).toContain('--label "ankhorage.app_slug=${PROFILE}"');
-    expect(appBuildScript?.content).toContain('--label "ankhorage.image=${APP_IMAGE}"');
-    expect(appBuildScript?.content).toContain('-t "${APP_IMAGE}"');
-    expect(appBuildScript?.content).toContain('-f "${DOCKERFILE_PATH}"');
-  });
-});

package/src/projectDatabase.ts

@@ -1,27 +0,0 @@
-import { readProjectInfrastructureEnvironment } from './projectEnvironment.js';
-
-const DATABASE_URL_KEYS = [
-  'ANKH_SECRET_STORE_DATABASE_URL',
-  'SUPABASE_DB_URL',
-  'POSTGRES_URL',
-  'DB_URL',
-  'DATABASE_URL',
-] as const;
-
-export async function resolveProjectInfrastructureDatabaseUrl(args: {
-  readonly projectPath: string;
-  readonly target: string;
-}): Promise<string | null> {
-  const environment = await readProjectInfrastructureEnvironment({
-    keys: DATABASE_URL_KEYS,
-    projectPath: args.projectPath,
-    target: args.target,
-  });
-
-  for (const key of DATABASE_URL_KEYS) {
-    const value = environment[key]?.trim();
-    if (value) return value;
-  }
-
-  return null;
-}