@ankhorage/infra 0.0.0

package/src/index.ts

@@ -0,0 +1,43 @@
+import { generateMinikubeInfra } from './adapters/minikube';
+import type {
+  InfraGenerationInput,
+  InfraManifestInput,
+  InfrastructureGenerationOptions,
+  InfrastructureGenerationResult,
+} from './types';
+
+export type { DatasetInfrastructureArtifacts } from './datasets';
+export { generateDatasetInfrastructureArtifacts } from './datasets';
+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);
+}

package/src/minikubeImageLifecycle.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from 'bun:test';
+
+import { generateInfrastructure } from './index';
+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,
+      },
+      plugins: [],
+    };
+
+    const result = generateInfrastructure(manifest, { namespaceHint: '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_DOWN=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.namespace=${NAMESPACE}"');
+    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/types.ts

@@ -0,0 +1,82 @@
+import type { AppManifest, InfraManifest } from '@ankhorage/contracts';
+
+export interface GeneratedInfrastructureFile {
+  /**
+   * Path relative to the target app root.
+   */
+  readonly path: string;
+  readonly content: string;
+  readonly executable?: boolean;
+}
+
+export interface GeneratedPackageDependency {
+  readonly name: string;
+  readonly version: string;
+  readonly reason: string;
+}
+
+export interface InfrastructureGenerationMeta {
+  readonly target: NonNullable<InfraManifest['deployment']>['target'];
+  readonly providers: readonly string[];
+}
+
+export interface InfrastructureGenerationResult {
+  readonly files: readonly GeneratedInfrastructureFile[];
+  readonly warnings: readonly string[];
+  readonly meta: InfrastructureGenerationMeta;
+  readonly dependencies: readonly GeneratedPackageDependency[];
+}
+
+export interface InfrastructureGenerationOptions {
+  /**
+   * Optional namespace hint from caller context, such as app slug or project id.
+   */
+  readonly namespaceHint?: string;
+  /**
+   * Optional app-level context used by provider/engine-specific generators.
+   */
+  readonly appManifest?: Pick<
+    AppManifest,
+    'data' | 'metadata' | 'navigator' | 'screens' | 'settings'
+  >;
+}
+
+export interface InfraGenerationInput {
+  /**
+   * Infra manifest section from an app manifest.
+   */
+  readonly manifest: InfraManifestInput;
+  /**
+   * Optional root used by callers that want to keep output intent alongside generation.
+   * The generator itself still returns relative file paths and does not write to disk.
+   */
+  readonly outputRoot?: string;
+  readonly options?: InfrastructureGenerationOptions;
+}
+
+export type InfraGenerationOptions = InfrastructureGenerationOptions;
+export type InfraGenerationResult = InfrastructureGenerationResult;
+export type GeneratedFile = GeneratedInfrastructureFile;
+export type PackageDependency = GeneratedPackageDependency;
+
+export interface InfraDiagnostic {
+  readonly severity: 'warning';
+  readonly message: string;
+}
+
+type InfraStorageProvider = NonNullable<InfraManifest['storage']>['provider'] | 'supabase';
+
+interface InfraStorageSpecInput {
+  readonly provider: InfraStorageProvider;
+  readonly buckets: readonly string[];
+}
+
+/**
+ * Infra-local manifest input type.
+ *
+ * This is intentionally broader than `@ankhorage/contracts` to allow adapters to support
+ * additional providers before the shared contracts package officially includes them.
+ */
+export type InfraManifestInput = Omit<InfraManifest, 'storage'> & {
+  readonly storage?: InfraStorageSpecInput;
+};