import { existsSync } from "node:fs"; import * as Effect from "effect/Effect"; import * as FileSystem from "effect/FileSystem"; import * as Layer from "effect/Layer"; import * as Path from "effect/Path"; import type { PlatformError } from "effect/PlatformError"; import { dotAlchemyDirectory } from "../AlchemyContext.ts"; import { decodeFqn, encodeFqn } from "../FQN.ts"; import { recordStateStoreInit } from "../Telemetry/Metrics.ts"; import { writeFileAtomic } from "../Util/AtomicFile.ts"; import { initialCwd } from "../Util/Node.ts"; import { STATE_STORE_VERSION } from "./HttpStateApi.ts"; import { State, StateStoreError, type StateService } from "./State.ts"; import { encodeState, reviveState } from "./StateEncoding.ts"; export const localState = () => Layer.effect( State, Effect.gen(function* () { const context = yield* Effect.context(); const make = makeLocalState().pipe(recordStateStoreInit, Effect.provideContext(context)); return yield* Effect.cached(make); }), ); export const makeLocalState = () => Effect.gen(function* () { const fs = yield* FileSystem.FileSystem; const path = yield* Path.Path; const dotAlchemy = yield* dotAlchemyDirectory; // Keep the store anchored across deploy/destroy even if another task changes cwd. const stateDir = path.resolve(initialCwd, dotAlchemy, "state"); const fail = (err: PlatformError) => Effect.fail( new StateStoreError({ message: err.message, cause: err, }), ); const recover = (effect: Effect.Effect) => effect.pipe( Effect.catchTag("PlatformError", (e) => e.reason._tag === "NotFound" ? Effect.void : fail(e), ), ); // Directory-level NotFound recovery with a trust-but-verify twist. // // `list` and `deleteStack` treat a missing stage/stack directory as // "no state" — the legitimate shape for a never-deployed (or fully // destroyed) stack. But a FALSE NotFound here is catastrophic: a // destroy that cannot see its state plans "no changes" and silently // leaks every cloud resource of the stack. So before recovering, the // async result is cross-checked with a synchronous `existsSync` — a // deliberately independent code path (`node:fs`, not the FileSystem // service) so a misbehaving async fs answer cannot vouch for itself. // If the directory actually exists, fail loudly instead of degrading // to an empty listing. A directory cannot legitimately reappear // between the two checks: nothing recreates a stage dir concurrently // with the session that is listing or deleting it. const recoverMissingDir = (dir: string, effect: Effect.Effect) => effect.pipe( Effect.catchTag("PlatformError", (e) => { if (e.reason._tag !== "NotFound") return fail(e); return Effect.flatMap( Effect.sync(() => existsSync(dir)), (exists) => exists ? Effect.fail( new StateStoreError({ message: `state store reported NotFound for '${dir}', but the directory exists — ` + `refusing to treat the stack's state as empty (a destroy acting on this ` + `answer would leak every resource of the stack)`, cause: e, }), ) : Effect.void, ); }), ); const stageDir = ({ stack, stage }: { stack: string; stage: string }) => path.join(stateDir, stack, stage); const resource = ({ stack, stage, fqn }: { stack: string; stage: string; fqn: string }) => path.join(stateDir, stack, stage, `${encodeFqn(fqn)}.json`); const outputFile = ({ stack, stage }: { stack: string; stage: string }) => path.join(stateDir, stack, stage, `__stack_output__.json`); // Write state files atomically so a concurrent `get` (e.g. a parallel // test reading shared `.alchemy/state`) never observes a truncated, // mid-write file — which would otherwise surface as `JSON.parse("")` → // "Unexpected end of JSON input". const writeAtomic = (file: string, contents: string) => writeFileAtomic(fs, file, contents); // Parse a state file, tolerating an empty read. A zero-length file can // linger from a write that was interrupted before this atomic-write change // (or any non-atomic external writer); treat it as "absent" rather than // throwing a JSON parse error that would abort the whole operation. const parseState = (contents: string) => contents.trim().length === 0 ? undefined : JSON.parse(contents, reviveState); const created = new Set(); const ensure = (dir: string) => created.has(dir) ? Effect.void : fs .makeDirectory(dir, { recursive: true }) .pipe(Effect.tap(() => Effect.sync(() => created.add(dir)))); const state: StateService = { id: "local", getVersion: () => Effect.succeed(STATE_STORE_VERSION), listStacks: () => fs.readDirectory(stateDir).pipe( recover, Effect.map((files) => files ?? []), ), listStages: (stack: string) => fs.readDirectory(path.join(stateDir, stack)).pipe( recover, Effect.map((files) => files ?? []), ), get: (request) => fs.readFile(resource(request)).pipe( Effect.map((file) => parseState(file.toString())), recover, ), getReplacedResources: Effect.fn(function* (request) { return (yield* Effect.forEach(yield* state.list(request), (fqn) => state.get({ stack: request.stack, stage: request.stage, fqn, }), )).filter((r) => r?.status === "replaced"); }), set: (request) => ensure(stageDir(request)).pipe( Effect.flatMap(() => writeAtomic(resource(request), JSON.stringify(encodeState(request.value), null, 2)), ), recover, Effect.map(() => request.value), ), delete: (request) => fs.remove(resource(request)).pipe(recover), deleteStack: ({ stack, stage }) => Effect.suspend(() => { const dir = stage === undefined ? path.join(stateDir, stack) : stageDir({ stack, stage }); return fs.remove(dir, { recursive: true }).pipe( (eff) => recoverMissingDir(dir, eff), // Drop cached `ensure`d directories under the removed tree, or a // later `set` for the same (stack, stage) skips makeDirectory and // its write fails with NotFound — silently swallowed by `recover`. Effect.tap(() => Effect.sync(() => { for (const cached of created) { if (cached === dir || cached.startsWith(dir + path.sep)) { created.delete(cached); } } }), ), // Deleting the last stage leaves an empty `{stack}/` husk that // `listStacks` would keep reporting forever (and durable // per-test scratch stacks would accumulate one per test). Prune // it when no stages remain. The read-then-remove is not racy: // nothing recreates a stage dir concurrently with the session // that is deleting it (same invariant as recoverMissingDir). Effect.tap(() => { if (stage === undefined) return Effect.void; const stackDir = path.join(stateDir, stack); return fs.readDirectory(stackDir).pipe( Effect.flatMap((entries) => entries.length === 0 ? fs .remove(stackDir, { recursive: true }) .pipe(Effect.tap(() => Effect.sync(() => created.delete(stackDir)))) : Effect.void, ), Effect.ignore, ); }), ); }), list: (request) => fs.readDirectory(stageDir(request)).pipe( (eff) => recoverMissingDir(stageDir(request), eff), Effect.map((files) => (files ?? []) // Only decode committed state files. Exclude: // - the `__stack_output__.json` bookkeeping file — `decodeFqn` // turns `__` into `/`, which would slip the literal name past // a bare-name filter and make the engine look up a // non-existent resource; // - in-flight `*.tmp` files written by `writeAtomic` (and any // other non-`.json` entry), which are not resources. .filter((file) => file.endsWith(".json") && file !== "__stack_output__.json") .map((file) => decodeFqn(file.replace(/\.json$/, ""))), ), ), getOutput: (request) => fs.readFile(outputFile(request)).pipe( Effect.map((file) => parseState(file.toString())), recover, ), setOutput: (request) => ensure(stageDir(request)).pipe( Effect.flatMap(() => writeAtomic( outputFile(request), JSON.stringify(encodeState(request.value as any), null, 2), ), ), recover, Effect.map(() => request.value), ), }; return state; });