@ankhorage/infra 4.1.12 → 5.1.0

package/src/projectLifecycle.test.ts

@@ -0,0 +1,136 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import type { InfraEnvironmentSpec, InfraLedger, InfraResult } from '@ankhorage/contracts/infra';
+import { afterEach, expect, test } from 'bun:test';
+
+import { createProjectInfraLifecycle, readStoredInfraStateAsync } from './project/index.js';
+import type { InfraLifecycleOperations } from './types/infraCli.js';
+import type { InfraDestroyOperationRequest } from './types/infraOrchestration.js';
+
+const temporaryPaths = new Set<string>();
+
+afterEach(async () => {
+  await Promise.all(
+    [...temporaryPaths].map((entry) => fs.rm(entry, { force: true, recursive: true })),
+  );
+  temporaryPaths.clear();
+});
+
+test('runs typed project lifecycle operations with canonical state and artifact ownership', async () => {
+  const projectPath = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-project-lifecycle-'));
+  temporaryPaths.add(projectPath);
+  const destroyRequests: InfraDestroyOperationRequest[] = [];
+  const lifecycle = createProjectInfraLifecycle({
+    services: {
+      createDependencies: () => ({
+        adapterResolver: { loadAsync: () => Promise.resolve({}) },
+        credentials: { resolveAsync: () => Promise.resolve(success({})) },
+        secrets: { resolveAsync: () => Promise.resolve(success('secret')) },
+      }),
+      operations: createOperations(destroyRequests),
+    },
+  });
+  const request = {
+    projectId: 'sample',
+    projectPath,
+    manifest: { environments: { local: desired }, modules: [] },
+    environment: 'local' as const,
+  };
+
+  const generated = await lifecycle.generateAsync(request);
+  expect(generated.ok).toBe(true);
+  expect(await fs.readFile(path.join(projectPath, 'infra/example.txt'), 'utf8')).toBe('generated');
+  expect((await readStoredInfraStateAsync(projectPath, 'local'))?.ledger).toEqual(ledger);
+
+  const outputs = await lifecycle.outputsAsync(request);
+  expect(outputs.ok && outputs.value.outputs).toEqual(ledger.outputs);
+
+  const destroyed = await lifecycle.destroyAsync({
+    ...request,
+    confirmation: { projectId: 'sample', environment: 'local' },
+    persistence: { policy: 'retain' },
+  });
+  expect(destroyed.ok).toBe(true);
+  expect(destroyRequests[0]?.confirmation).toEqual({ projectId: 'sample', environment: 'local' });
+  expect(await readStoredInfraStateAsync(projectPath, 'local')).toBeNull();
+  expect(await fileExists(path.join(projectPath, 'infra/example.txt'))).toBe(false);
+});
+
+const desired = {
+  deployment: {
+    compute: { provider: 'local' },
+    runtime: { provider: 'docker-compose' },
+  },
+} as const satisfies InfraEnvironmentSpec;
+
+const owner = {
+  projectId: 'sample',
+  environment: 'local',
+  adapter: 'docker-compose',
+  resourceId: 'runtime',
+} as const;
+
+const ledger = {
+  schemaVersion: 1,
+  projectId: 'sample',
+  environment: 'local',
+  targets: [],
+  resources: [],
+  outputs: [{ owner, name: 'url', visibility: 'public', value: 'https://example.test' }],
+  artifacts: [{ owner, path: 'infra/example.txt' }],
+} as const satisfies InfraLedger;
+
+/*** Create deterministic operation fakes while recording destructive authorization. */
+function createOperations(
+  destroyRequests: InfraDestroyOperationRequest[],
+): InfraLifecycleOperations {
+  return {
+    validate: () => Promise.resolve(success({ environment: 'local' })),
+    plan: (request) =>
+      Promise.resolve(success({ projectId: request.projectId, environment: 'local', actions: [] })),
+    generate: () =>
+      Promise.resolve(
+        success({
+          environment: 'local',
+          artifacts: [{ owner, path: 'infra/example.txt', content: 'generated' }],
+          ledger,
+        }),
+      ),
+    up: () =>
+      Promise.resolve(
+        success({ environment: 'local', targets: [], resources: [], outputs: [], ledger }),
+      ),
+    status: (request) =>
+      Promise.resolve(
+        success({
+          projectId: request.projectId,
+          environment: 'local',
+          state: 'ready',
+          resources: [],
+        }),
+      ),
+    outputs: () => success({ environment: 'local', outputs: ledger.outputs }),
+    down: () => Promise.resolve(success({ environment: 'local', ledger })),
+    destroy: (request) => {
+      destroyRequests.push(request);
+      return Promise.resolve(success({ environment: 'local', ledger: null }));
+    },
+  };
+}
+
+/*** Create one successful Infra result for operation fakes. */
+function success<T>(value: T): InfraResult<T> {
+  return { ok: true, value, diagnostics: [] };
+}
+
+/*** Report whether a generated artifact still exists. */
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/readme-usage.ts

@@ -1,39 +1,30 @@
-import { runCli } from './cli/bin.js';
+import { runInfraCliAsync } from './cli/runInfraCliAsync.js';
 
 /***
- * Provider, CLI, and project API surface
+ * Provider-neutral infrastructure lifecycle
  *
- * `@ankhorage/infra` owns infrastructure generation, project reconciliation,
- * and generated lifecycle execution.
+ * `@ankhorage/infra` resolves only the compute, runtime, and service adapter packages selected by
+ * an environment-aware Infra manifest. Its typed use cases own orchestration, dependency ordering,
+ * safe outputs, deterministic artifacts, and environment-scoped ownership state. Provider packages
+ * own all technology-specific implementation.
  *
- * The same owner implementation backs CLI consumers and the public
- * `@ankhorage/infra/project` application-service boundary. Trusted hosts such
- * as Studio should call that subpath instead of reproducing ledger, generated
- * file, lifecycle-script, or port-forward configuration semantics.
- *
- * CLI entrypoints:
- *
- * - `ankh infra ...`
- * - `bunx @ankhorage/infra ...`
- *
- * Current command surface:
+ * The standalone CLI and `ankh infra` expose the same lifecycle:
  *
  * - `validate`
+ * - `plan`
  * - `generate`
- * - `status`
  * - `up`
+ * - `status`
+ * - `outputs`
  * - `down`
+ * - `destroy`
  *
- * Project resolution for the CLI is workspace-aware: pass `[project]`, or
- * omit it when cwd is already inside `apps/<project>`. Programmatic project
- * 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.
+ * `local` is the only default environment. Destruction always requires an explicit environment and
+ * exact `<project>:<environment>` confirmation. Persistent resources remain retained unless each
+ * exact owned resource is separately authorized with `--delete-resource <adapter>:<resourceId>`.
+ * Environment-style outputs print only explicitly public values with an environment-variable name;
+ * secret outputs remain references.
  *
  * @usage
  */
-await runCli(['--help']);
+await runInfraCliAsync(['--help']);

package/src/testSupport.ts

@@ -3,7 +3,7 @@ import { promises as fs } from 'fs';
 import os from 'os';
 import path from 'path';
 
-import type { InfraCommandContext } from './commandContext.js';
+import type { InfraCommandContext } from './types/infraCli.js';
 
 export interface CapturedCommandContext {
   readonly context: InfraCommandContext;
@@ -79,7 +79,17 @@ export async function createWorkspaceFixture(
 
 export function createAppManifest(
   projectId: string,
-  infra: AppManifest['infra'] = { modules: [] },
+  infra: AppManifest['infra'] = {
+    environments: {
+      local: {
+        deployment: {
+          compute: { provider: 'local' },
+          runtime: { provider: 'docker-compose' },
+        },
+      },
+    },
+    modules: [],
+  },
 ): AppManifest {
   return {
     metadata: {

package/src/types/infraCli.ts

@@ -0,0 +1,115 @@
+import type { AnkhCapabilityId } from '@ankhorage/contracts/cli';
+import type { AppEnvironmentId } from '@ankhorage/contracts/environments';
+import type { InfraEnvironmentSpec } from '@ankhorage/contracts/infra';
+
+import type { readStoredInfraStateAsync } from '../features/environment-lifecycle/adapters/outbound/readStoredInfraStateAsync.js';
+import type { removeStoredInfraStateAsync } from '../features/environment-lifecycle/adapters/outbound/removeStoredInfraStateAsync.js';
+import type { writeInfraGeneratedArtifactsAsync } from '../features/environment-lifecycle/adapters/outbound/writeInfraGeneratedArtifactsAsync.js';
+import type { writeStoredInfraStateAsync } from '../features/environment-lifecycle/adapters/outbound/writeStoredInfraStateAsync.js';
+import type { destroyInfraEnvironmentAsync } from '../features/environment-lifecycle/application/use-cases/destroyInfraEnvironmentAsync.js';
+import type { downInfraEnvironmentAsync } from '../features/environment-lifecycle/application/use-cases/downInfraEnvironmentAsync.js';
+import type { generateInfraEnvironmentAsync } from '../features/environment-lifecycle/application/use-cases/generateInfraEnvironmentAsync.js';
+import type { getInfraEnvironmentOutputs } from '../features/environment-lifecycle/application/use-cases/getInfraEnvironmentOutputs.js';
+import type { planInfraEnvironmentAsync } from '../features/environment-lifecycle/application/use-cases/planInfraEnvironmentAsync.js';
+import type { statusInfraEnvironmentAsync } from '../features/environment-lifecycle/application/use-cases/statusInfraEnvironmentAsync.js';
+import type { upInfraEnvironmentAsync } from '../features/environment-lifecycle/application/use-cases/upInfraEnvironmentAsync.js';
+import type { validateInfraEnvironmentAsync } from '../features/environment-lifecycle/application/use-cases/validateInfraEnvironmentAsync.js';
+import type {
+  InfraOperationRequest,
+  InfraOrchestrationDependencies,
+  InfraStoredState,
+} from './infraOrchestration.js';
+import type { ResolvedInfraProject } from './infraProject.js';
+
+type InfraCommandName =
+  'validate' | 'plan' | 'generate' | 'up' | 'status' | 'outputs' | 'down' | 'destroy';
+
+export interface InfraCommandContext {
+  readonly cwd: string;
+  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly version: string;
+  writeStdout(text: string): void;
+  writeStderr(text: string): void;
+}
+
+export interface InfraCommandRunResult {
+  readonly exitCode: number;
+}
+
+export interface ParsedInfraArguments {
+  readonly projectId?: string;
+  readonly environment?: AppEnvironmentId;
+  readonly format: 'human' | 'json' | 'env';
+  readonly confirmation?: string;
+  readonly deleteResources: readonly string[];
+}
+
+export interface InfraCommandRunRequest {
+  readonly context: InfraCommandContext;
+  readonly arguments: ParsedInfraArguments;
+}
+
+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 InfraLifecycleOperations {
+  readonly validate: typeof validateInfraEnvironmentAsync;
+  readonly plan: typeof planInfraEnvironmentAsync;
+  readonly generate: typeof generateInfraEnvironmentAsync;
+  readonly up: typeof upInfraEnvironmentAsync;
+  readonly status: typeof statusInfraEnvironmentAsync;
+  readonly outputs: typeof getInfraEnvironmentOutputs;
+  readonly down: typeof downInfraEnvironmentAsync;
+  readonly destroy: typeof destroyInfraEnvironmentAsync;
+}
+
+export interface InfraCommandServices {
+  readonly resolveProject: (options: {
+    readonly cwd: string;
+    readonly projectId?: string;
+  }) => Promise<ResolvedInfraProject>;
+  readonly readState: typeof readStoredInfraStateAsync;
+  readonly writeState: typeof writeStoredInfraStateAsync;
+  readonly removeState: typeof removeStoredInfraStateAsync;
+  readonly writeArtifacts: typeof writeInfraGeneratedArtifactsAsync;
+  readonly operations: InfraLifecycleOperations;
+  readonly createDependencies: (context: InfraCommandContext) => InfraOrchestrationDependencies;
+}
+
+export interface RunInfraCommandOptions {
+  readonly services?: Partial<InfraCommandServices>;
+}
+
+export interface CreateInfraRuntimeProviderOptions {
+  readonly runCommandImpl?: RunInfraCommandImpl;
+  readonly services?: Partial<InfraCommandServices>;
+}
+
+export type RunInfraCommandImpl = (
+  request: InfraCommandInvocation,
+  options?: RunInfraCommandOptions,
+) => Promise<InfraCommandRunResult>;
+
+export interface PreparedInfraCommandOperation {
+  readonly project: ResolvedInfraProject;
+  readonly state: InfraStoredState | null;
+  readonly desired: InfraEnvironmentSpec;
+  readonly operation: InfraOperationRequest;
+  readonly dependencies: InfraOrchestrationDependencies;
+}

package/src/types/infraOrchestration.ts

@@ -0,0 +1,126 @@
+import type { AppEnvironmentId } from '@ankhorage/contracts/environments';
+import type {
+  InfraComputeAdapter,
+  InfraComputeSnapshot,
+  InfraComputeTarget,
+  InfraDestroyRequest,
+  InfraEnvironmentSpec,
+  InfraExecutionContext,
+  InfraGeneratedArtifact,
+  InfraLedger,
+  InfraManifest,
+  InfraOutput,
+  InfraOwnedResource,
+  InfraPlan,
+  InfraResult,
+  InfraRuntimeAdapter,
+  InfraRuntimeDesiredState,
+  InfraServiceAdapter,
+  InfraStatus,
+} from '@ankhorage/contracts/infra';
+
+import type { InfraAdapterPackageResolver } from '../features/environment-lifecycle/application/ports/outbound/infraAdapterPackage.js';
+
+export interface ResolvedInfraEnvironment {
+  readonly id: AppEnvironmentId;
+  readonly desired: InfraEnvironmentSpec;
+  readonly manifest: InfraManifest;
+}
+
+export interface InfraEnvironmentResolutionRequest {
+  readonly environment?: string;
+  readonly manifest: InfraManifest;
+  readonly operation:
+    'validate' | 'plan' | 'generate' | 'up' | 'status' | 'outputs' | 'down' | 'destroy';
+}
+
+export interface ResolvedInfraAdapters {
+  readonly compute: InfraComputeAdapter;
+  readonly runtime: InfraRuntimeAdapter;
+  readonly services: readonly InfraServiceAdapter[];
+}
+
+export interface InfraStoredState {
+  readonly schemaVersion: 1;
+  readonly desired: InfraEnvironmentSpec;
+  readonly ledger: InfraLedger;
+}
+
+export interface PreparedInfraOperation {
+  readonly environment: ResolvedInfraEnvironment;
+  readonly context: InfraExecutionContext;
+  readonly adapters: ResolvedInfraAdapters;
+  readonly compute: InfraComputeSnapshot;
+  readonly runtimeDesired: InfraRuntimeDesiredState;
+}
+
+export interface InfraOrchestrationDependencies {
+  readonly adapterResolver: InfraAdapterPackageResolver;
+  readonly credentials: InfraExecutionContext['credentials'];
+  readonly secrets: InfraExecutionContext['secrets'];
+}
+
+export interface InfraOperationRequest {
+  readonly projectId: string;
+  readonly manifest: InfraManifest;
+  readonly environment?: string;
+  readonly previous?: InfraLedger;
+  readonly previousDesired?: InfraEnvironmentSpec;
+  readonly signal?: AbortSignal;
+}
+
+export interface InfraDestroyOperationRequest extends InfraOperationRequest {
+  readonly confirmation: InfraDestroyRequest['confirmation'];
+  readonly persistence: InfraDestroyRequest['persistence'];
+}
+
+export interface InfraValidateResult {
+  readonly environment: AppEnvironmentId;
+}
+
+export type InfraValidateOperationResult = InfraResult<InfraValidateResult>;
+
+export type InfraUpRequest = InfraOperationRequest;
+
+export interface InfraUpResult {
+  readonly environment: AppEnvironmentId;
+  readonly targets: readonly InfraComputeTarget[];
+  readonly resources: readonly InfraOwnedResource[];
+  readonly outputs: readonly InfraOutput[];
+  readonly ledger: InfraLedger;
+}
+
+export type InfraUpOperationResult = InfraResult<InfraUpResult>;
+
+export type InfraPlanOperationResult = InfraResult<InfraPlan>;
+
+export interface InfraGenerateResult {
+  readonly environment: AppEnvironmentId;
+  readonly artifacts: readonly InfraGeneratedArtifact[];
+  readonly ledger: InfraLedger;
+}
+
+export type InfraGenerateOperationResult = InfraResult<InfraGenerateResult>;
+
+export type InfraStatusOperationResult = InfraResult<InfraStatus>;
+
+export interface InfraOutputsResult {
+  readonly environment: AppEnvironmentId;
+  readonly outputs: readonly InfraOutput[];
+}
+
+export type InfraOutputsOperationResult = InfraResult<InfraOutputsResult>;
+
+export interface InfraDownResult {
+  readonly environment: AppEnvironmentId;
+  readonly ledger: InfraLedger;
+}
+
+export type InfraDownOperationResult = InfraResult<InfraDownResult>;
+
+export interface InfraDestroyResult {
+  readonly environment: AppEnvironmentId;
+  readonly ledger: InfraLedger | null;
+}
+
+export type InfraDestroyOperationResult = InfraResult<InfraDestroyResult>;

package/src/types/infraProject.ts

@@ -0,0 +1,58 @@
+import type { AppManifest } from '@ankhorage/contracts';
+import type { AppEnvironmentId } from '@ankhorage/contracts/environments';
+import type { InfraDestroyRequest, InfraManifest } from '@ankhorage/contracts/infra';
+
+import type { InfraCommandServices } from './infraCli.js';
+import type {
+  InfraDestroyOperationResult,
+  InfraDownOperationResult,
+  InfraGenerateOperationResult,
+  InfraOutputsOperationResult,
+  InfraPlanOperationResult,
+  InfraStatusOperationResult,
+  InfraUpOperationResult,
+  InfraValidateOperationResult,
+} from './infraOrchestration.js';
+
+export interface InfraArtifactWriteResult {
+  readonly written: number;
+  readonly removed: number;
+}
+
+export interface ResolvedInfraProject {
+  readonly appsRoot: string;
+  readonly manifest: AppManifest;
+  readonly manifestPath: string;
+  readonly projectId: string;
+  readonly projectPath: string;
+  readonly workspaceRoot: string;
+}
+
+export interface ProjectInfraOperationRequest {
+  readonly projectId: string;
+  readonly projectPath: string;
+  readonly manifest: InfraManifest;
+  readonly environment: AppEnvironmentId;
+  readonly executionEnvironment?: Readonly<Record<string, string | undefined>>;
+  readonly signal?: AbortSignal;
+}
+
+export interface ProjectInfraDestroyRequest extends ProjectInfraOperationRequest {
+  readonly confirmation: InfraDestroyRequest['confirmation'];
+  readonly persistence: InfraDestroyRequest['persistence'];
+}
+
+export interface ProjectInfraLifecycle {
+  validateAsync(request: ProjectInfraOperationRequest): Promise<InfraValidateOperationResult>;
+  planAsync(request: ProjectInfraOperationRequest): Promise<InfraPlanOperationResult>;
+  generateAsync(request: ProjectInfraOperationRequest): Promise<InfraGenerateOperationResult>;
+  upAsync(request: ProjectInfraOperationRequest): Promise<InfraUpOperationResult>;
+  statusAsync(request: ProjectInfraOperationRequest): Promise<InfraStatusOperationResult>;
+  outputsAsync(request: ProjectInfraOperationRequest): Promise<InfraOutputsOperationResult>;
+  downAsync(request: ProjectInfraOperationRequest): Promise<InfraDownOperationResult>;
+  destroyAsync(request: ProjectInfraDestroyRequest): Promise<InfraDestroyOperationResult>;
+}
+
+export interface CreateProjectInfraLifecycleOptions {
+  readonly services?: Partial<InfraCommandServices>;
+}

package/dist/adapters/minikube/auth/index.d.ts

@@ -1,8 +0,0 @@
-import type { InfraManifestInput, InfrastructureGenerationOptions } from '../../../types';
-import { type MinikubeAdapterArtifacts } from '../contracts';
-export declare function generateAuthProviderArtifacts(args: {
-    appManifest: InfrastructureGenerationOptions['appManifest'];
-    manifest: InfraManifestInput;
-    namespace: string;
-}): MinikubeAdapterArtifacts;
-//# sourceMappingURL=index.d.ts.map

package/dist/adapters/minikube/auth/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/adapters/minikube/auth/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,+BAA+B,EAAE,MAAM,gBAAgB,CAAC;AAC1F,OAAO,EAA0B,KAAK,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAIrF,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAClD,WAAW,EAAE,+BAA+B,CAAC,aAAa,CAAC,CAAC;IAC5D,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,wBAAwB,CA8B3B"}

package/dist/adapters/minikube/auth/index.js

@@ -1,29 +0,0 @@
-import { emptyMinikubeArtifacts } from '../contracts';
-import { generateSupabaseAuthArtifacts } from './supabase';
-import { generateTargetAwareSupabaseOAuthRuntimeArtifacts } from './targetAwareOAuthRuntime';
-export function generateAuthProviderArtifacts(args) {
-    const { appManifest, manifest, namespace } = args;
-    const { auth } = manifest;
-    if (!auth) {
-        return emptyMinikubeArtifacts();
-    }
-    if (auth.provider !== 'supabase') {
-        throw new Error(`Unsupported auth provider for minikube adapter: "${auth.provider}". Only "supabase" is currently supported.`);
-    }
-    const providerArtifacts = generateSupabaseAuthArtifacts({ manifest, namespace });
-    const oauthArtifacts = generateTargetAwareSupabaseOAuthRuntimeArtifacts({
-        appManifest,
-        manifest,
-    });
-    return {
-        files: [...providerArtifacts.files, ...oauthArtifacts.files],
-        resources: [...providerArtifacts.resources, ...oauthArtifacts.resources],
-        providerLifecycle: [
-            ...providerArtifacts.providerLifecycle,
-            ...oauthArtifacts.providerLifecycle,
-        ],
-        envEntries: [...providerArtifacts.envEntries, ...oauthArtifacts.envEntries],
-        warnings: [...providerArtifacts.warnings, ...oauthArtifacts.warnings],
-    };
-}
-//# sourceMappingURL=index.js.map

package/dist/adapters/minikube/auth/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/adapters/minikube/auth/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAiC,MAAM,cAAc,CAAC;AACrF,OAAO,EAAE,6BAA6B,EAAE,MAAM,YAAY,CAAC;AAC3D,OAAO,EAAE,gDAAgD,EAAE,MAAM,2BAA2B,CAAC;AAE7F,MAAM,UAAU,6BAA6B,CAAC,IAI7C;IACC,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IAClD,MAAM,EAAE,IAAI,EAAE,GAAG,QAAQ,CAAC;IAE1B,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,OAAO,sBAAsB,EAAE,CAAC;IAClC,CAAC;IAED,IAAI,IAAI,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CACb,oDAAoD,IAAI,CAAC,QAAQ,4CAA4C,CAC9G,CAAC;IACJ,CAAC;IAED,MAAM,iBAAiB,GAAG,6BAA6B,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,CAAC;IACjF,MAAM,cAAc,GAAG,gDAAgD,CAAC;QACtE,WAAW;QACX,QAAQ;KACT,CAAC,CAAC;IAEH,OAAO;QACL,KAAK,EAAE,CAAC,GAAG,iBAAiB,CAAC,KAAK,EAAE,GAAG,cAAc,CAAC,KAAK,CAAC;QAC5D,SAAS,EAAE,CAAC,GAAG,iBAAiB,CAAC,SAAS,EAAE,GAAG,cAAc,CAAC,SAAS,CAAC;QACxE,iBAAiB,EAAE;YACjB,GAAG,iBAAiB,CAAC,iBAAiB;YACtC,GAAG,cAAc,CAAC,iBAAiB;SACpC;QACD,UAAU,EAAE,CAAC,GAAG,iBAAiB,CAAC,UAAU,EAAE,GAAG,cAAc,CAAC,UAAU,CAAC;QAC3E,QAAQ,EAAE,CAAC,GAAG,iBAAiB,CAAC,QAAQ,EAAE,GAAG,cAAc,CAAC,QAAQ,CAAC;KACtE,CAAC;AACJ,CAAC","sourcesContent":["import type { InfraManifestInput, InfrastructureGenerationOptions } from '../../../types';\nimport { emptyMinikubeArtifacts, type MinikubeAdapterArtifacts } from '../contracts';\nimport { generateSupabaseAuthArtifacts } from './supabase';\nimport { generateTargetAwareSupabaseOAuthRuntimeArtifacts } from './targetAwareOAuthRuntime';\n\nexport function generateAuthProviderArtifacts(args: {\n  appManifest: InfrastructureGenerationOptions['appManifest'];\n  manifest: InfraManifestInput;\n  namespace: string;\n}): MinikubeAdapterArtifacts {\n  const { appManifest, manifest, namespace } = args;\n  const { auth } = manifest;\n\n  if (!auth) {\n    return emptyMinikubeArtifacts();\n  }\n\n  if (auth.provider !== 'supabase') {\n    throw new Error(\n      `Unsupported auth provider for minikube adapter: \"${auth.provider}\". Only \"supabase\" is currently supported.`,\n    );\n  }\n\n  const providerArtifacts = generateSupabaseAuthArtifacts({ manifest, namespace });\n  const oauthArtifacts = generateTargetAwareSupabaseOAuthRuntimeArtifacts({\n    appManifest,\n    manifest,\n  });\n\n  return {\n    files: [...providerArtifacts.files, ...oauthArtifacts.files],\n    resources: [...providerArtifacts.resources, ...oauthArtifacts.resources],\n    providerLifecycle: [\n      ...providerArtifacts.providerLifecycle,\n      ...oauthArtifacts.providerLifecycle,\n    ],\n    envEntries: [...providerArtifacts.envEntries, ...oauthArtifacts.envEntries],\n    warnings: [...providerArtifacts.warnings, ...oauthArtifacts.warnings],\n  };\n}\n"]}

package/dist/adapters/minikube/auth/oauthRuntime.d.ts

@@ -1,4 +0,0 @@
-import type { InfraManifestInput } from '../../../types';
-import type { MinikubeAdapterArtifacts } from '../contracts';
-export declare function generateSupabaseOAuthRuntimeArtifacts(manifest: InfraManifestInput): MinikubeAdapterArtifacts;
-//# sourceMappingURL=oauthRuntime.d.ts.map

package/dist/adapters/minikube/auth/oauthRuntime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"oauthRuntime.d.ts","sourceRoot":"","sources":["../../../../src/adapters/minikube/auth/oauthRuntime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACzD,OAAO,KAAK,EAAE,wBAAwB,EAA6B,MAAM,cAAc,CAAC;AAQxF,wBAAgB,qCAAqC,CACnD,QAAQ,EAAE,kBAAkB,GAC3B,wBAAwB,CAwB1B"}