import * as Context from "effect/Context"; import * as Duration from "effect/Duration"; import * as Effect from "effect/Effect"; import * as Formatter from "effect/Formatter"; import * as Schedule from "effect/Schedule"; import picomatch from "picomatch"; import { emit, type ApplyStatus } from "./Events.ts"; import { isProviderCollectionService, isProviderService, providerForMode, type ProviderService, } from "./Provider.ts"; import type { ProviderMode } from "./ProviderMode.ts"; import { stronglyConnectedComponents } from "./Util/scc.ts"; // Account-wide teardown: enumerate everything the registered providers can see // and delete it, ignoring stack state entirely. This is the engine behind // `alchemy nuke` — a blunt instrument for cleaning a test account, not part of // any stack's lifecycle. /** A provider call that failed. These are collected into results, never thrown. */ export interface ProviderFailure { readonly provider: string; readonly operation: "list" | "delete"; readonly message: string; } /** One cloud object a provider's `list()` turned up, bound to its provider. */ export interface Target { /** Unique within a scan; names the target's row in progress events and views. */ readonly key: string; readonly providerId: string; readonly displayName: string; readonly attributes: Record; readonly provider: ProviderService; } export interface DiscoverOptions { readonly mode: ProviderMode; /** Provider-id globs to include. Omitted means every provider. */ readonly include?: ReadonlyArray; /** Provider-id globs to exclude. Applied after {@link DiscoverOptions.include}. */ readonly exclude?: ReadonlyArray; } export interface ListOptions extends DiscoverOptions { /** The built provider context — what a stack's `providers` layer produced. */ readonly context: Context.Context; readonly concurrency?: number | "unbounded"; readonly timeoutSeconds?: number; } export type Strategy = /** Delete in dependency order, retrying a wave until it stops making progress. */ | { readonly type: "coordinated" } /** Delete everything at once, retrying each object on its own. */ | { readonly type: "independent"; readonly retries: number }; export interface DestroyOptions { readonly targets: ReadonlyArray; readonly context: Context.Context; readonly strategy: Strategy; readonly concurrency?: number | "unbounded"; readonly timeoutSeconds?: number; } export interface Result { readonly requested: number; readonly deleted: ReadonlyArray; readonly failed: ReadonlyArray<{ readonly resource: Target; readonly failure: ProviderFailure; }>; /** Skipped because something they depend on could not be deleted first. */ readonly held: ReadonlyArray<{ readonly resource: Target; readonly blockedBy: ReadonlyArray; }>; readonly passes: number; } interface DiscoveredProvider { readonly id: string; readonly provider: ProviderService; } const failure = ( provider: string, operation: ProviderFailure["operation"], cause: unknown, ): ProviderFailure => ({ provider, operation, message: typeof cause === "string" ? cause : Formatter.format(cause), }); /** * One provider's failure, typed or defect, must not abort an account-wide * sweep: credential layers die on a rejected token, so collect both. */ const settle = (effect: Effect.Effect) => Effect.result(effect.pipe(Effect.catchDefect((defect) => Effect.fail(defect)))); /** Deletions here run out-of-band, so nothing reports through an apply session. */ const silent = { note: () => Effect.void, }; /** * Walk the built provider context for everything deletable. A provider opts * out with `nuke.skip` (not ours to delete) or `nuke.singleton` (an * account-level object that has to survive). * * Dual registrations (`ProviderLayer.dual`) build nothing until asked and * keep their `nuke` metadata on the variants, so each provider is resolved * to the scan mode's variant first — mode-agnostic providers resolve to * themselves in a live scan and are not part of a local one. */ const discover = Effect.fn(function* ( context: Context.Context, { mode, include, exclude }: DiscoverOptions, ) { const registered = new Map(); for (const [key, value] of context.mapUnsafe.entries()) { if (isProviderCollectionService(value)) { for (const [id, provider] of Object.entries(value.providers)) { registered.set(id, provider); } } else if (typeof key === "string" && key.includes(".") && isProviderService(value)) { registered.set(key, value); } } const included = include?.length ? picomatch([...include]) : () => true; const excluded = exclude?.length ? picomatch([...exclude]) : () => false; const output: DiscoveredProvider[] = []; for (const [id, registration] of registered) { if (!included(id) || excluded(id)) continue; if (mode === "local" && registration.modes === undefined) continue; const provider = yield* providerForMode(registration, mode); if (provider.nuke?.singleton || provider.nuke?.skip) continue; output.push({ id, provider }); } return output.sort((a, b) => a.id.localeCompare(b.id)); }); const nameKeys = [ "workerName", "functionName", "bucketName", "tableName", "queueName", "repositoryName", "databaseName", "projectName", "domainName", "hostname", "displayName", "name", ]; const displayName = (attributes: Record) => nameKeys .map((key) => attributes[key]) .find((value): value is string => typeof value === "string" && value.length > 0) ?? Object.values(attributes).find( (value): value is string => typeof value === "string" && value.length > 0, ) ?? "unknown"; const groupBy = (items: ReadonlyArray, key: (item: T) => string) => { const groups = new Map(); for (const item of items) { const id = key(item); groups.set(id, [...(groups.get(id) ?? []), item]); } return groups; }; const addEdge = (edges: Map>, from: string, to: string) => { const values = edges.get(from) ?? new Set(); values.add(to); edges.set(from, values); }; /** Ask every selected provider what exists. Provider failures are collected, not thrown. */ export const list = ( options: ListOptions, ): Effect.Effect<{ readonly resources: ReadonlyArray; readonly failures: ReadonlyArray; }> => Effect.gen(function* () { const failures: ProviderFailure[] = []; const resources: Target[] = []; const providers = yield* discover(options.context, options).pipe( Effect.provide(options.context), ); yield* emit({ type: "nuke.scan.started", total: providers.length }); yield* Effect.forEach( providers, ({ id, provider }) => Effect.gen(function* () { yield* emit({ type: "nuke.scan.provider.started", provider: id }); const result = yield* settle( Effect.gen(function* () { const listed = yield* provider .list() .pipe(Effect.timeout(Duration.seconds(options.timeoutSeconds ?? 60))); return { provider, listed }; }).pipe(Effect.provide(options.context)), ); if (result._tag === "Failure") { const error = failure(id, "list", result.failure); failures.push(error); yield* emit({ type: "nuke.scan.provider.completed", provider: id, resources: 0, error: error.message, }); return; } for (const raw of result.success.listed) { const attributes = (raw ?? {}) as Record; resources.push({ key: `${id}/${resources.length}`, providerId: id, displayName: displayName(attributes), attributes, provider: result.success.provider, }); } yield* emit({ type: "nuke.scan.provider.completed", provider: id, resources: result.success.listed.length, }); }), { concurrency: options.concurrency ?? 16, discard: true }, ); return { resources, failures }; }); /** Delete the given targets under the chosen {@link Strategy}. */ export const destroy = ({ targets, context, strategy, concurrency = 16, timeoutSeconds = 120, }: DestroyOptions): Effect.Effect => Effect.gen(function* () { // Each target reports as an apply row under its `key`. const status = (resource: Target, status: ApplyStatus, message?: string) => emit({ type: "apply.resource.status", fqn: resource.key, id: resource.providerId, resourceType: resource.providerId, status, message, }); const onPass = (pass: number) => emit({ type: "nuke.pass.started", pass }); const onDeleted = (resource: Target) => status(resource, "deleted").pipe( Effect.andThen( emit({ type: "nuke.resource.deleted", provider: resource.providerId, resource: resource.displayName, }), ), ); const onFailed = (resource: Target, message: string) => status(resource, "fail", message).pipe( Effect.andThen( emit({ type: "nuke.resource.failed", provider: resource.providerId, resource: resource.displayName, message, }), ), ); const deleted: Target[] = []; const failed: Array = []; const held: Array = []; let passes = 0; // Account-wide scans have no state rows: delete must derive identity from // `output` alone — `olds` just mirrors it and `instanceId` is unavailable. const attempt = (resource: Target) => Effect.gen(function* () { yield* status(resource, "deleting"); return yield* resource.provider .delete({ id: resource.displayName, fqn: resource.displayName, instanceId: "", olds: resource.attributes as never, output: resource.attributes as never, session: silent, bindings: [], force: true, }) .pipe(Effect.timeout(Duration.seconds(timeoutSeconds)), Effect.provide(context)); }); if (strategy.type === "independent") { passes = 1; yield* onPass(passes); yield* Effect.forEach( targets, (resource) => settle( attempt(resource).pipe( Effect.retry({ schedule: Schedule.min([ Schedule.exponential("1 second"), Schedule.spaced("15 seconds"), ]), times: strategy.retries, }), ), ).pipe( Effect.tap((result) => { if (result._tag === "Success") { deleted.push(resource); return onDeleted(resource); } const why = failure(resource.providerId, "delete", result.failure); failed.push({ resource, failure: why }); return onFailed(resource, why.message); }), ), { concurrency: concurrency, discard: true }, ); } else { const typeIds = [...new Set(targets.map(({ providerId }) => providerId))]; const providerOf = new Map(targets.map(({ providerId, provider }) => [providerId, provider])); const successors = new Map>(); const predecessors = new Map>(); for (const id of typeIds) { const globs = providerOf.get(id)?.nuke?.dependsOn; if (!globs?.length) continue; const matches = picomatch([...globs]); for (const other of typeIds) { if (other === id || !matches(other)) continue; addEdge(successors, id, other); addEdge(predecessors, other, id); } } const grouped = stronglyConnectedComponents(typeIds, (id) => successors.get(id) ?? []); const componentOf = new Map(); grouped.forEach((component, index) => component.forEach((id) => componentOf.set(id, index))); const layerOf = grouped.map(() => 0); for (let index = grouped.length - 1; index >= 0; index--) { for (const id of grouped[index]!) { for (const predecessor of predecessors.get(id) ?? []) { const predecessorComponent = componentOf.get(predecessor)!; if (predecessorComponent !== index) { layerOf[index] = Math.max(layerOf[index]!, layerOf[predecessorComponent]! + 1); } } } } const waves: string[][] = []; grouped.forEach((component, index) => (waves[layerOf[index]!] ??= []).push(...component)); const byType = groupBy(targets, ({ providerId }) => providerId); const remainingCount = new Map([...byType].map(([id, resources]) => [id, resources.length])); for (const wave of waves) { let runnable: Target[] = []; const heldTypes = new Set(); for (const typeId of wave) { const resources = byType.get(typeId) ?? []; const blockers = [...(predecessors.get(typeId) ?? [])].filter( (predecessor) => componentOf.get(predecessor) !== componentOf.get(typeId) && (remainingCount.get(predecessor) ?? 0) > 0, ); if (blockers.length > 0) { heldTypes.add(typeId); yield* Effect.forEach(resources, (resource) => status(resource, "skipped", `Held back by ${blockers.join(", ")}`), ); held.push( ...resources.map((resource) => ({ resource, blockedBy: blockers, })), ); } else runnable = [...runnable, ...resources]; } let remaining = runnable; while (remaining.length > 0) { passes += 1; yield* onPass(passes); const results = yield* Effect.forEach( remaining, (resource) => Effect.gen(function* () { const result = yield* settle(attempt(resource)); if (result._tag === "Success") { deleted.push(resource); yield* onDeleted(resource); } return { resource, result }; }), { concurrency: concurrency }, ); const next: Target[] = []; for (const { resource, result } of results) { if (result._tag === "Failure") next.push(resource); } if (next.length === remaining.length) { for (const { resource, result } of results) { if (result._tag !== "Failure") continue; const why = failure(resource.providerId, "delete", result.failure); failed.push({ resource, failure: why }); yield* onFailed(resource, why.message); } break; } remaining = next; } const failuresByType = groupBy( failed.map(({ resource }) => resource), ({ providerId }) => providerId, ); for (const typeId of wave) { // Held types were never attempted: keep their full count so waves // gated on them stay blocked instead of seeing a spurious zero. if (heldTypes.has(typeId)) continue; remainingCount.set(typeId, failuresByType.get(typeId)?.length ?? 0); } } } return { requested: targets.length, deleted, failed, held, passes, } satisfies Result; });