@smthrs/engine-store 0.0.0-stage → 1.0.0-rc.3

package/dist/cjs/internal/RetentionOps.d.ts

@@ -0,0 +1,414 @@
+/**
+ * Retention: the one operation that deletes finished run state.
+ *
+ * Nothing in the composition removed a `flows_runs` row or anything that hangs
+ * off one. Every run a workspace ever finished stayed in `.flows/engine.db`
+ * with its attempts, its persisted deferred completions and clock deadlines,
+ * its journal entries, and its checkpoints, and journal compaction is off by
+ * default (`SqlJournal` `Options.compaction`), so the file only grew. This
+ * module is the deletion side, and the whole of it: one operation, run
+ * explicitly.
+ *
+ * Three properties make it safe to run against a live workspace.
+ *
+ * - **One transaction.** Every delete runs inside a single `journal.transact`,
+ *   so a crash leaves either a run with all of its rows or none of them —
+ *   never a run row whose history is gone, or history whose run row is gone.
+ * - **Terminal and aged only.** A run is a candidate only when its status is
+ *   `completed`, `failed`, or `cancelled` AND it finished before the cutoff.
+ *   A running, pending, or suspended run is never a candidate at any age.
+ * - **Nothing a live run still needs.** A candidate is retained when a live
+ *   run stands on either side of it in the lineage, over BOTH relations that
+ *   make one run the parent of another: the `flows_run_parents` edge a spawned
+ *   child is recorded under, and the reserved `parent_run_id` column the
+ *   rounds of one trampoline lineage are chained through. Upward: an aged
+ *   terminal run with a live ancestor stays, because a parent reads a settled
+ *   child's result out of its run row (`agent/await`) and a parent parked on
+ *   an approval, a deferred, or a timer can be parked for longer than the
+ *   threshold before it ever asks. Downward: an aged terminal run whose
+ *   descendant is still live stays, because deleting it would leave that
+ *   descendant's `parent_run_id` pointing at nothing and would drop the live
+ *   descendant's lineage edges with the `flows_run_parents_gc` trigger.
+ * - **Explicit.** Nothing schedules this. Automatic retention stays opt-in,
+ *   for the reason `ArtifactGc` states: deletion is the irreversible
+ *   direction, and a human approving a plan must be approving the deletions.
+ *
+ * Journal history is deleted outright rather than compacted to a checkpoint.
+ * `Journal.checkpoint` and `Journal.compact` are owner-fenced — `SqlJournal`'s
+ * `fenceGuard` requires a consensus lease held by the exact owner passed in —
+ * so neither can be called for a finished, ownerless run at all. Deleting the run's entries and checkpoints is strictly stronger than
+ * compacting them to a checkpoint, and it happens in the same transaction as
+ * the run row, which is the property a compaction could not have given.
+ *
+ * The operation is idempotent. With a positive integer limit and a fixed,
+ * finite, acyclic run lineage, each successful non-dry pass deletes at least
+ * one collectable run until none remain. Continuation children are selected
+ * before parents; parents pinned by excluded children do not consume the
+ * bound. Runs protected by age or live lineage remain until eligible.
+ *
+ * @since 0.1.0
+ */
+import * as Journal from "@smthrs/journal/Journal";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+import type { SqlError } from "effect/unstable/sql/SqlError";
+/**
+ * Stable error codes returned by retention.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const RetentionErrorCode: Schema.Literals<readonly ["scan_failed", "delete_failed"]>;
+/**
+ * Stable error codes returned by retention.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type RetentionErrorCode = typeof RetentionErrorCode.Type;
+declare const RetentionError_base: Schema.Class<RetentionError, Schema.TaggedStruct<"@smthrs/engine-store/RetentionError", {
+    readonly code: Schema.Literals<readonly ["scan_failed", "delete_failed"]>;
+    readonly message: Schema.String;
+    readonly cause: Schema.optional<Schema.Unknown>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A retention pass that could not complete.
+ *
+ * `scan_failed` means the candidate set could not be computed and nothing was
+ * deleted. `delete_failed` means the candidate set held but a delete refused;
+ * the transaction rolled back, so nothing was deleted then either, and
+ * re-running converges once the cause is fixed.
+ *
+ * @category errors
+ * @since 0.1.0
+ */
+export declare class RetentionError extends RetentionError_base {
+}
+/**
+ * Options for one retention pass.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface RetainOptions {
+    /**
+     * How long a run must have been finished to be collected, in milliseconds.
+     * A run's age is measured from `finished_at_ms`, or from `created_at_ms`
+     * for a terminal row that never recorded one. Zero collects every terminal
+     * run; a negative value is read as zero.
+     */
+    readonly olderThanMs: number;
+    /**
+     * Largest number of runs one pass deletes. Defaults to
+     * {@link defaultLimit}. Retention is idempotent, so a workspace with more
+     * aged runs than the bound converges over repeated passes instead of
+     * holding one long write transaction open. A negative value is read as
+     * zero, so a pass under a mistyped bound deletes nothing.
+     */
+    readonly limit?: number | undefined;
+    /** Compute and report the pass without deleting anything. */
+    readonly dryRun?: boolean | undefined;
+}
+/**
+ * What one retention pass did, or — under `dryRun` — would do.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface RetainReport {
+    /** Runs finished at or before this instant were candidates. */
+    readonly cutoffMs: number;
+    /** The runs deleted, oldest first. */
+    readonly runIds: ReadonlyArray<string>;
+    /**
+     * Aged terminal runs left in place because a descendant of theirs is not
+     * terminal, or is terminal and is not being deleted by this pass. They
+     * become collectable once that descendant is. At most `limit` of them are
+     * reported, the oldest first, so the report costs no more than the pass.
+     */
+    readonly retainedForLiveDescendants: ReadonlyArray<string>;
+    /**
+     * Aged terminal runs left in place because an ancestor of theirs is not
+     * terminal. That ancestor can still read the run's settled result through
+     * `agent/await`, which answers out of the run row. They become collectable
+     * once every ancestor is terminal — a terminal ancestor holds nothing back,
+     * whatever its own age. A run retained for both reasons is reported under
+     * {@link retainedForLiveDescendants}, and at most `limit` runs are reported.
+     */
+    readonly retainedForLiveAncestors: ReadonlyArray<string>;
+    readonly runs: number;
+    readonly attempts: number;
+    readonly clockDeadlines: number;
+    readonly deferredCompletions: number;
+    readonly journalEntries: number;
+    readonly journalCheckpoints: number;
+    /** Producer identities journal compaction kept after deleting event payloads. */
+    readonly journalIdentities: number;
+    /** Time-travel archive rows; always zero where that table is not installed. */
+    readonly archiveEntries: number;
+    /** Time-travel receipt rows reached through their audits. */
+    readonly timeTravelReceipts: number;
+    readonly dryRun: boolean;
+}
+/**
+ * Explicit run retention.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Service {
+    /**
+     * Deletes up to `limit` aged terminal runs and their dependents atomically.
+     * With a positive integer limit and a fixed, finite, acyclic lineage, each
+     * successful non-dry pass makes progress until all collectable runs are gone,
+     * including continuation chains longer than the bound. Age and live-lineage
+     * protection still apply. Explicit only; nothing schedules this operation.
+     */
+    readonly retain: (options: RetainOptions) => Effect.Effect<RetainReport, RetentionError | Journal.JournalError>;
+}
+declare const Retention_base: Context.ServiceClass<Retention, "@smthrs/engine-store/Retention", Service>;
+/**
+ * Service tag for run retention.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export declare class Retention extends Retention_base {
+}
+/**
+ * Runs deleted by one pass when the caller names no bound. Large enough that
+ * an ordinary workspace finishes in one pass, small enough that the write
+ * transaction stays short on a workspace that has never been collected.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const defaultLimit = 1000;
+/**
+ * One table a deleted run leaves rows in.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface RunScopedTable {
+    readonly table: string;
+    /** The column naming the run. */
+    readonly column: string;
+    /**
+     * Whether the migration ladder this package composes installs the table.
+     *
+     * A ladder table missing from an engine database is a broken schema, so
+     * {@link installedTables} can be asked to keep it and let the delete refuse.
+     * A table beyond the ladder belongs to a store the host may simply not have
+     * composed, and is skipped when the catalog does not list it.
+     */
+    readonly ladder: boolean;
+    /**
+     * Whether the table also holds the runs' journal companion streams
+     * (`JournalEvent.companionRunId`), which name a run through a derived id
+     * rather than the run id itself. {@link companionStreams} lists them.
+     */
+    readonly companions?: boolean | undefined;
+}
+/**
+ * The journal companion streams a run owns beside its own stream. A deleted
+ * run's companion streams go with it.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const companionStreams: ReadonlyArray<string>;
+/**
+ * Every table a deleted run leaves rows in, and the column naming the run.
+ *
+ * ONE inventory, because two passes read it: {@link Service.retain} over the
+ * engine ladder, and `Retention.collect` over whatever a host's file holds. A
+ * table listed by only one of them is a table the other leaks forever. Tables
+ * are listed rather than discovered from foreign keys because the set spans
+ * six packages that migrate into one database, and a silently missing entry is
+ * exactly that leak.
+ *
+ * The run rows themselves are not here: they go last and in generation order,
+ * which {@link deleteRuns} does after this list.
+ * `flows_time_travel_receipts` is reached through its audit rather than listed
+ * here because the upstream table has no run column: its `audit_id` points to
+ * `flows_time_travel_audits.id`, whose row carries `run_id`.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const runScopedTables: ReadonlyArray<RunScopedTable>;
+/**
+ * The statuses a run can never leave.
+ *
+ * @category constants
+ * @since 1.0.0
+ */
+export declare const terminalStatuses: ReadonlyArray<string>;
+/**
+ * The prelude every scan opens with: which runs a live run stands above, and
+ * which it stands below.
+ *
+ * Two relations make one run the parent of another, and a walk over either one
+ * alone misses half the lineage. A SPAWNED child records its parent as a
+ * `flows_run_parents` edge, one row per parent so a diamond records both, and
+ * leaves `parent_run_id` NULL: the engine reserves that column for the rounds
+ * of one trampoline lineage (`RunDriver.continueLineage`). The edge is the
+ * relation every `agent/await` depends on. `link` is both relations as one
+ * edge list.
+ *
+ * `under_live` is every run reachable downward from a run that is not
+ * terminal. Those runs have a live ancestor, which can still read a settled
+ * result out of their run row. `over_live` is every run reachable upward from
+ * one. Those runs have a live descendant, whose own lineage the
+ * `flows_run_parents_gc` trigger would drop with them. An edge whose parent
+ * row is gone is not reachable from `live` at all, so it holds nothing back,
+ * and since only terminal runs are ever deleted it never can.
+ *
+ * The walks carry run ids and nothing else, so `UNION` makes them terminate on
+ * their own: a corrupt edge that closed a cycle adds a row the set already
+ * holds, and the walk stops. That matters because these reads run inside the
+ * pass's write transaction. They are SQLite-specific, like the `sqlite_master`
+ * probe below, and rc.0 is SQLite-only.
+ *
+ * `parentEdges: false` drops the `flows_run_parents` half of `link`. A
+ * database that carries the run rows but not the engine's edge table — the
+ * control plane's, which migrates the run store and the journal and nothing
+ * else — has no edges to walk, and reading the missing table would fail the
+ * whole scan. The `parent_run_id` half still runs, so the continuation
+ * lineage is guarded there too. The retention pass itself always walks both.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const lineagePrelude: (options: {
+    readonly parentEdges: boolean;
+}) => string;
+/**
+ * The bound one pass may delete, as both passes read it.
+ *
+ * Clamped, not interpolated: SQLite reads a negative `LIMIT` as no limit at
+ * all, which would make a mistyped bound a full sweep, and rejects `NaN` or a
+ * fraction as a datatype mismatch. Anything that is not a non-negative safe
+ * integer is read as zero, so the pass deletes nothing.
+ *
+ * @category constructors
+ * @since 1.0.0
+ */
+export declare const normalizeLimit: (limit: number | undefined) => number;
+/**
+ * The runs one pass deletes: at most `limit` of them, children before parents.
+ *
+ * The one candidate query, shared by {@link Service.retain} and
+ * `Retention.collect`. A trampoline parent always finishes before its
+ * successor, so an oldest-first window over a lineage longer than the bound
+ * held only ancestors, each pinned by the round just outside the window, and
+ * every later pass selected the same window and deleted nothing. Depth walks
+ * from roots, visiting each continuation row once; corrupt cycles have no
+ * root and cannot enter the deletion set. Excluded runs and their ancestors
+ * are dropped before the bound, so pinned parents cannot consume it. The
+ * result is presented oldest first.
+ *
+ * @category getters
+ * @since 1.0.0
+ */
+export declare const candidatesOf: (sql: SqlClient.SqlClient, options: {
+    readonly cutoffMs: number;
+    readonly inclusive: boolean;
+    readonly parentEdges: boolean;
+    readonly pins?: ReadonlyArray<string> | undefined;
+    readonly limit: number;
+}) => Effect.Effect<ReadonlyArray<Candidate>, SqlError>;
+/**
+ * A run a pass proposes to delete, and the run it names as its parent.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Candidate {
+    readonly runId: string;
+    readonly parentRunId: string | null;
+}
+/**
+ * What one deletion pass removed, or would remove under `dryRun`.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface DeletionReport {
+    /** The candidates deleted, in the order they were given. */
+    readonly runIds: ReadonlyArray<string>;
+    /** Candidates kept because a run outside the pass still names them. */
+    readonly pinned: ReadonlyArray<string>;
+    /**
+     * Rows counted per table, `flows_runs` included, zeroes omitted. Counted
+     * whether or not the pass deletes, so a dry run reports the same numbers.
+     */
+    readonly deleted: Readonly<Record<string, number>>;
+}
+/**
+ * The {@link runScopedTables} entries this database actually has.
+ *
+ * `assumeLadder` keeps every entry the ladder installs whether the catalog
+ * lists it or not. {@link Service.retain} passes `true`: this package composes
+ * the run-store, journal, step-cache and engine migrations, so a ladder table
+ * missing from the file it is pointed at is a broken schema, and a delete that
+ * refuses says so. `Retention.collect` passes `false`, because it also runs
+ * against the control plane's database, which migrates the run store and the
+ * journal and nothing else; there a missing ladder table is a host that
+ * composed fewer stores, and the pass still owes it a complete sweep of what
+ * it has.
+ *
+ * The catalog read is SQLite-specific, like the lineage prelude above and the
+ * `flows_run_parents_gc` trigger this package ships. rc.0 is SQLite-only.
+ *
+ * @category getters
+ * @since 0.1.0
+ */
+export declare const installedTables: (sql: SqlClient.SqlClient, options: {
+    readonly assumeLadder: boolean;
+}) => Effect.Effect<ReadonlyArray<RunScopedTable>, RetentionError>;
+/**
+ * Deletes `candidates` and every row the inventory says names them.
+ *
+ * The one deletion in this package. Both passes call it, so neither can be
+ * holding a shorter table list than the other, and neither can be deleting
+ * run rows in an order the self-referential foreign key refuses: a handoff
+ * parent always sorts before its successor, so a pass that deleted in age
+ * order broke as soon as one lineage straddled a chunk boundary.
+ *
+ * The caller owns the transaction. Nothing here is atomic on its own, and a
+ * pass that removed the dependents of every candidate and then refused on the
+ * run rows would have destroyed history it could not put back.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const deleteRuns: (sql: SqlClient.SqlClient, candidates: ReadonlyArray<Candidate>, options: {
+    readonly dryRun: boolean;
+    readonly assumeLadder: boolean;
+}) => Effect.Effect<DeletionReport, RetentionError>;
+/**
+ * Builds the retention operation over the composition's own durable tables.
+ *
+ * The scan reads `flows_runs` directly, the way `DurableEngineState` and
+ * `ArtifactGc` do: this package composes the run-store, journal, and engine
+ * migrations, so the schema is its own.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: () => Effect.Effect<Service, never, SqlClient.SqlClient | Journal.Journal>;
+/**
+ * Provides run retention. Nothing schedules `retain()`; invoking it stays an
+ * explicit caller decision.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: Layer.Layer<Retention, never, SqlClient.SqlClient | Journal.Journal>;
+export {};
+//# sourceMappingURL=RetentionOps.d.ts.map

package/dist/cjs/internal/RetentionOps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RetentionOps.d.ts","sourceRoot":"","sources":["../../../src/internal/RetentionOps.ts"],"names":[],"mappings":"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"}