@ankhorage/infra 0.0.0

package/src/adapters/minikube/contracts.ts

@@ -0,0 +1,17 @@
+import type { GeneratedInfrastructureFile } from '../../types';
+
+export interface MinikubeAdapterArtifacts {
+  files: GeneratedInfrastructureFile[];
+  resources: string[];
+  envEntries: string[];
+  warnings: string[];
+}
+
+export function emptyMinikubeArtifacts(): MinikubeAdapterArtifacts {
+  return {
+    files: [],
+    resources: [],
+    envEntries: [],
+    warnings: [],
+  };
+}

package/src/adapters/minikube/index.ts

@@ -0,0 +1,149 @@
+import { generateDatasetInfrastructureArtifacts } from '../../datasets';
+import type {
+  GeneratedPackageDependency,
+  InfraManifestInput,
+  InfrastructureGenerationOptions,
+  InfrastructureGenerationResult,
+} from '../../types';
+import { generateAuthProviderArtifacts } from './auth';
+import { generateAuthorizationArtifacts } from './authz';
+import { generateMinikubeBaseArtifacts } from './base';
+import { generateStorageArtifacts } from './storage';
+
+const DEFAULT_NAMESPACE = 'ankh-app';
+
+export function generateMinikubeInfra(
+  manifest: InfraManifestInput,
+  options: InfrastructureGenerationOptions = {},
+): InfrastructureGenerationResult {
+  if (manifest.deployment?.target !== 'minikube') {
+    throw new Error(
+      `Minikube adapter only supports deployment target "minikube" (received "${manifest.deployment?.target ?? 'undefined'}").`,
+    );
+  }
+
+  if (manifest.database?.provider && manifest.database.provider !== 'supabase') {
+    throw new Error(
+      `Unsupported database provider for minikube adapter: "${manifest.database.provider}". Only "supabase" is implemented.`,
+    );
+  }
+
+  const namespace = resolveNamespace(manifest, options);
+
+  const authArtifacts = generateAuthProviderArtifacts({ manifest, namespace });
+  const authzArtifacts = generateAuthorizationArtifacts({
+    manifest,
+    namespace,
+    appManifest: options.appManifest,
+  });
+  const storageArtifacts = generateStorageArtifacts({ manifest, namespace });
+  const datasetArtifacts = generateDatasetInfrastructureArtifacts({
+    data: options.appManifest?.data,
+    databaseProvider: manifest.database?.provider,
+  });
+
+  const extraResources = unique([
+    ...authArtifacts.resources,
+    ...authzArtifacts.resources,
+    ...storageArtifacts.resources,
+  ]);
+  const extraEnvEntries = unique([
+    ...authArtifacts.envEntries,
+    ...authzArtifacts.envEntries,
+    ...storageArtifacts.envEntries,
+  ]);
+
+  const baseFiles = generateMinikubeBaseArtifacts({
+    manifest,
+    namespace,
+    extraResources,
+    extraEnvEntries,
+  });
+
+  const warnings = unique([
+    ...collectWarnings(manifest),
+    ...authArtifacts.warnings,
+    ...authzArtifacts.warnings,
+    ...storageArtifacts.warnings,
+    ...datasetArtifacts.warnings,
+  ]);
+
+  return {
+    files: [
+      ...baseFiles,
+      ...authArtifacts.files,
+      ...authzArtifacts.files,
+      ...storageArtifacts.files,
+      ...datasetArtifacts.files,
+    ],
+    warnings,
+    meta: {
+      target: 'minikube',
+      providers: collectProviders(manifest),
+    },
+    dependencies: collectDependencies(manifest),
+  };
+}
+
+function collectProviders(manifest: InfraManifestInput): string[] {
+  const providers = new Set<string>();
+
+  if (manifest.auth?.provider) providers.add(manifest.auth.provider);
+  if (manifest.auth?.authorization.engine) providers.add(manifest.auth.authorization.engine);
+  if (manifest.database?.provider) providers.add(manifest.database.provider);
+  if (manifest.storage?.provider) providers.add(manifest.storage.provider);
+  if (manifest.state?.provider) providers.add(manifest.state.provider);
+
+  return [...providers].sort();
+}
+
+function collectDependencies(manifest: InfraManifestInput): readonly GeneratedPackageDependency[] {
+  if (manifest.state?.provider !== 'legend') {
+    return [];
+  }
+
+  return [
+    {
+      name: '@ankhorage/state-legend',
+      version: '^0.1.0',
+      reason: 'Selected by infra.state.provider=legend.',
+    },
+  ];
+}
+
+function collectWarnings(manifest: InfraManifestInput): string[] {
+  const warnings: string[] = [];
+
+  if (manifest.deployment?.monitoring) {
+    warnings.push(
+      'Monitoring is enabled in manifest, but monitoring stack resources are not generated yet.',
+    );
+  }
+
+  if (manifest.networking?.cdn) {
+    warnings.push('CDN is enabled in manifest, but CDN resources are not generated for minikube.');
+  }
+
+  return warnings;
+}
+
+function resolveNamespace(
+  manifest: InfraManifestInput,
+  options: InfrastructureGenerationOptions,
+): string {
+  const source =
+    manifest.networking?.domain?.trim() ?? options.namespaceHint?.trim() ?? DEFAULT_NAMESPACE;
+
+  const normalized = source
+    .toLowerCase()
+    .replace(/[^a-z0-9-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+
+  const safe = normalized.slice(0, 63).replace(/-+$/g, '');
+  return safe || DEFAULT_NAMESPACE;
+}
+
+function unique(values: string[]): string[] {
+  return [...new Set(values)];
+}

package/src/adapters/minikube/storage/index.ts

@@ -0,0 +1,91 @@
+import type { InfraManifestInput } from '../../../types';
+import { emptyMinikubeArtifacts, type MinikubeAdapterArtifacts } from '../contracts';
+import { generateSupabaseStorageArtifacts } from './supabase';
+
+export function generateStorageArtifacts(args: {
+  manifest: InfraManifestInput;
+  namespace: string;
+}): MinikubeAdapterArtifacts {
+  const { manifest, namespace } = args;
+  const spec = manifest.storage;
+
+  if (!spec) {
+    return emptyMinikubeArtifacts();
+  }
+
+  const buckets = normalizeBuckets(spec.buckets);
+  const { provider } = spec;
+  const includeSupabaseConnectionEnvEntries = manifest.auth?.provider !== 'supabase';
+  const emptyBucketsWarning =
+    'Storage buckets are empty after normalization; no storage artifacts generated.';
+
+  switch (provider) {
+    case 'auto': {
+      const shouldResolveToSupabase =
+        manifest.database?.provider === 'supabase' || manifest.auth?.provider === 'supabase';
+
+      if (!shouldResolveToSupabase) {
+        return {
+          ...emptyMinikubeArtifacts(),
+          warnings: [
+            'Storage provider "auto" could not be resolved for minikube; no storage artifacts generated.',
+          ],
+        };
+      }
+
+      if (buckets.length === 0) {
+        return {
+          ...emptyMinikubeArtifacts(),
+          warnings: [emptyBucketsWarning],
+        };
+      }
+
+      return generateSupabaseStorageArtifacts({
+        namespace,
+        buckets,
+        includeSupabaseConnectionEnvEntries,
+      });
+    }
+    case 'supabase': {
+      if (buckets.length === 0) {
+        return {
+          ...emptyMinikubeArtifacts(),
+          warnings: [emptyBucketsWarning],
+        };
+      }
+
+      return generateSupabaseStorageArtifacts({
+        namespace,
+        buckets,
+        includeSupabaseConnectionEnvEntries,
+      });
+    }
+    case 's3':
+    case 'r2':
+      return {
+        ...emptyMinikubeArtifacts(),
+        warnings: [
+          `Storage provider "${provider}" is not implemented for minikube yet; no storage artifacts generated.`,
+        ],
+      };
+    default: {
+      const exhaustiveCheck: never = provider;
+      return exhaustiveCheck;
+    }
+  }
+}
+
+function normalizeBuckets(rawBuckets: readonly string[]): string[] {
+  const normalized: string[] = [];
+  const seen = new Set<string>();
+
+  for (const raw of rawBuckets) {
+    const bucket = raw.trim();
+    if (!bucket) continue;
+    if (seen.has(bucket)) continue;
+    seen.add(bucket);
+    normalized.push(bucket);
+  }
+
+  return normalized;
+}

package/src/adapters/minikube/storage/supabase/index.ts

@@ -0,0 +1,112 @@
+import type { MinikubeAdapterArtifacts } from '../../contracts';
+
+export function generateSupabaseStorageArtifacts(args: {
+  namespace: string;
+  buckets: string[];
+  includeSupabaseConnectionEnvEntries: boolean;
+}): MinikubeAdapterArtifacts {
+  const { namespace, buckets, includeSupabaseConnectionEnvEntries } = args;
+  const root = 'infra/minikube/k8s/storage/supabase';
+  const resourceRoot = 'storage/supabase';
+  const bucketsCsv = buckets.join(',');
+  const defaultBucket = buckets[0] ?? '';
+
+  const envEntries = [
+    'STORAGE_PROVIDER=supabase',
+    'STORAGE_RUNTIME_MODE=local',
+    `STORAGE_BUCKETS=${bucketsCsv}`,
+    `STORAGE_DEFAULT_BUCKET=${defaultBucket}`,
+    'EXPO_PUBLIC_STORAGE_PROVIDER=supabase',
+    `EXPO_PUBLIC_STORAGE_BUCKETS=${bucketsCsv}`,
+    `EXPO_PUBLIC_STORAGE_DEFAULT_BUCKET=${defaultBucket}`,
+  ];
+
+  if (includeSupabaseConnectionEnvEntries) {
+    envEntries.push(
+      '',
+      '# Supabase provider connection details',
+      'SUPABASE_SECRET_SYNC_ENABLED=true',
+      'SUPABASE_URL=',
+      'SUPABASE_ANON_KEY=',
+      'SUPABASE_SERVICE_ROLE_KEY=',
+      'SUPABASE_JWT_SECRET=',
+      'EXPO_PUBLIC_SUPABASE_URL=',
+      'EXPO_PUBLIC_SUPABASE_ANON_KEY=',
+    );
+  }
+
+  return {
+    files: [
+      {
+        path: `${root}/supabase-storage.configmap.yaml`,
+        content: getSupabaseStorageConfigMap({
+          namespace,
+          bucketsCsv,
+          defaultBucket,
+        }),
+      },
+      {
+        path: `${root}/app-runtime-storage.env.configmap.yaml`,
+        content: getRuntimeStorageEnvConfigMap({
+          namespace,
+          bucketsCsv,
+          defaultBucket,
+        }),
+      },
+    ],
+    resources: [
+      `${resourceRoot}/supabase-storage.configmap.yaml`,
+      `${resourceRoot}/app-runtime-storage.env.configmap.yaml`,
+    ],
+    envEntries,
+    warnings: [
+      `Storage buckets are configured but not created automatically yet. Ensure buckets exist in Supabase Storage: ${bucketsCsv}.`,
+    ],
+  };
+}
+
+function getSupabaseStorageConfigMap(args: {
+  namespace: string;
+  bucketsCsv: string;
+  defaultBucket: string;
+}) {
+  const { namespace, bucketsCsv, defaultBucket } = args;
+
+  return `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: supabase-storage-config
+  namespace: ${namespace}
+data:
+  STORAGE_PROVIDER: "supabase"
+  STORAGE_BUCKETS: "${escapeYamlDoubleQuoted(bucketsCsv)}"
+  STORAGE_DEFAULT_BUCKET: "${escapeYamlDoubleQuoted(defaultBucket)}"
+`;
+}
+
+function getRuntimeStorageEnvConfigMap(args: {
+  namespace: string;
+  bucketsCsv: string;
+  defaultBucket: string;
+}) {
+  const { namespace, bucketsCsv, defaultBucket } = args;
+
+  return `apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: app-runtime-storage-env
+  namespace: ${namespace}
+data:
+  STORAGE_PROVIDER: "supabase"
+  STORAGE_RUNTIME_MODE: "local"
+  STORAGE_BUCKETS: "${escapeYamlDoubleQuoted(bucketsCsv)}"
+  STORAGE_DEFAULT_BUCKET: "${escapeYamlDoubleQuoted(defaultBucket)}"
+  EXPO_PUBLIC_STORAGE_PROVIDER: "supabase"
+  EXPO_PUBLIC_STORAGE_BUCKETS: "${escapeYamlDoubleQuoted(bucketsCsv)}"
+  EXPO_PUBLIC_STORAGE_DEFAULT_BUCKET: "${escapeYamlDoubleQuoted(defaultBucket)}"
+`;
+}
+
+function escapeYamlDoubleQuoted(value: string): string {
+  return value.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
+}

package/src/datasets.test.ts

@@ -0,0 +1,178 @@
+import type { AppManifest } from '@ankhorage/contracts';
+import { describe, expect, test } from 'bun:test';
+
+import { generateInfrastructure } from './index';
+import type { InfraManifestInput } from './types';
+
+describe('dataset infrastructure generation', () => {
+  test('generates provider-neutral dataset, seed, API, and OpenAPI artifacts', () => {
+    const manifest: InfraManifestInput = {
+      deployment: {
+        target: 'minikube',
+        monitoring: false,
+      },
+      database: {
+        provider: 'supabase',
+        tier: 'dev',
+      },
+      plugins: [],
+    };
+
+    const appManifest: Pick<
+      AppManifest,
+      'data' | 'metadata' | 'navigator' | 'screens' | 'settings'
+    > = {
+      metadata: {
+        name: 'Cards',
+        slug: 'cards',
+        version: '1.0.0',
+        themeId: 'default',
+      },
+      data: {
+        datasets: {
+          poker_situations: {
+            id: 'poker_situations',
+            label: 'Poker situations',
+            description: 'App-owned poker trainer situations.',
+            collection: {
+              name: 'poker_situations',
+              primaryKey: 'id',
+              fields: [
+                { name: 'id', type: 'uuid', required: true, unique: true },
+                { name: 'title', type: 'text', required: true },
+                { name: 'description', type: 'text', required: true },
+                { name: 'availableActions', type: 'json' },
+                { name: 'correctAction', type: 'text' },
+              ],
+            },
+            operations: ['list', 'read', 'create'],
+            seed: [
+              {
+                title: 'Button faces a raise',
+                description: 'Choose the best action with position and stack depth in mind.',
+                availableActions: [
+                  { label: 'Fold', value: 'fold' },
+                  { label: 'Call', value: 'call' },
+                  { label: 'Raise', value: 'raise' },
+                ],
+                correctAction: 'raise',
+              },
+            ],
+          },
+        },
+      },
+      navigator: {
+        type: 'stack',
+        routes: [],
+      },
+      screens: {},
+      settings: {
+        localization: {
+          defaultLocale: 'en',
+          locales: ['en'],
+        },
+        authFlow: {
+          signInRoute: '/sign-in',
+          signUpRoute: '/sign-up',
+          signOutRoute: '/sign-out',
+          unauthorizedRoute: '/sign-in',
+          postSignInRoute: '/',
+        },
+      },
+    };
+
+    const result = generateInfrastructure(manifest, { namespaceHint: 'cards', appManifest });
+    const rerun = generateInfrastructure(manifest, { namespaceHint: 'cards', appManifest });
+    const paths = result.files.map((file) => file.path);
+
+    expect(result.files).toEqual(rerun.files);
+    expect(paths).toContain('infra/minikube/db/datasets.json');
+    expect(paths).toContain('infra/minikube/db/dataset-seed.json');
+    expect(paths).toContain('infra/minikube/db/migrations/001_datasets.sql');
+    expect(paths).toContain('infra/minikube/db/seeds/001_dataset_seed.sql');
+    expect(paths).toContain('infra/minikube/db/README.md');
+    expect(paths).toContain('src/generated/datasets/collections.ts');
+    expect(paths).toContain('src/generated/datasets/appDatasetApi.ts');
+    expect(paths).toContain('src/generated/datasets/datasetApiHandlers.ts');
+    expect(paths).toContain('src/generated/datasets/openapi.json');
+
+    const collectionsFile = result.files.find(
+      (file) => file.path === 'src/generated/datasets/collections.ts',
+    );
+    expect(collectionsFile?.content).toContain('GENERATED_DATASETS');
+    expect(collectionsFile?.content).toContain('poker_situations');
+    expect(collectionsFile?.content).toContain('availableActions');
+
+    const apiFile = result.files.find(
+      (file) => file.path === 'src/generated/datasets/appDatasetApi.ts',
+    );
+    expect(apiFile?.content).toContain('poker_situations.list');
+    expect(apiFile?.content).toContain('/api/datasets/poker_situations');
+    expect(apiFile?.content).toContain('poker_situations.read');
+    expect(apiFile?.content).toContain('/api/datasets/poker_situations/{id}');
+
+    const handlersFile = result.files.find(
+      (file) => file.path === 'src/generated/datasets/datasetApiHandlers.ts',
+    );
+    expect(handlersFile?.content).toContain('handleGeneratedDatasetList');
+    expect(handlersFile?.content).toContain('handleGeneratedDatasetCreate');
+    expect(handlersFile?.content).toContain('createGeneratedDatasetMemoryStore');
+    expect(handlersFile?.content).toContain('poker_situations');
+
+    const openApiFile = result.files.find(
+      (file) => file.path === 'src/generated/datasets/openapi.json',
+    );
+    expect(openApiFile?.content).toContain('Generated app dataset API');
+    expect(openApiFile?.content).toContain('poker_situations.create');
+    expect(openApiFile?.content).toContain('x-ankh-dataset');
+
+    const migrationFile = result.files.find(
+      (file) => file.path === 'infra/minikube/db/migrations/001_datasets.sql',
+    );
+    expect(migrationFile?.content).toContain('create extension if not exists pgcrypto');
+    expect(migrationFile?.content).toContain(
+      'create table if not exists "public"."poker_situations"',
+    );
+    expect(migrationFile?.content).toContain('"id" uuid default gen_random_uuid() primary key');
+    expect(migrationFile?.content).toContain('"availableActions" jsonb');
+
+    const seedFile = result.files.find(
+      (file) => file.path === 'infra/minikube/db/dataset-seed.json',
+    );
+    expect(seedFile?.content).toContain('Button faces a raise');
+    expect(seedFile?.content).toContain('correctAction');
+    expect(seedFile?.content).toContain('"id"');
+
+    const seedSqlFile = result.files.find(
+      (file) => file.path === 'infra/minikube/db/seeds/001_dataset_seed.sql',
+    );
+    expect(seedSqlFile?.content).toContain('insert into "public"."poker_situations"');
+    expect(seedSqlFile?.content).toContain('Button faces a raise');
+    expect(seedSqlFile?.content).toContain('on conflict ("id") do nothing');
+  });
+
+  test('reports selected state adapter dependencies', () => {
+    const manifest: InfraManifestInput = {
+      deployment: {
+        target: 'minikube',
+        monitoring: false,
+      },
+      state: {
+        provider: 'legend',
+        persistence: 'none',
+      },
+      plugins: [],
+    };
+
+    const result = generateInfrastructure(manifest, { namespaceHint: 'cards' });
+
+    expect(result.meta.providers).toContain('legend');
+    expect(result.dependencies).toEqual([
+      {
+        name: '@ankhorage/state-legend',
+        version: '^0.1.0',
+        reason: 'Selected by infra.state.provider=legend.',
+      },
+    ]);
+  });
+});