@dudousxd/nestjs-catalog 0.18.0 → 0.20.0

package/dist/catalog.pipeline.d.ts

@@ -27,6 +27,39 @@ export type ConnectorKind = (typeof CONNECTOR_KINDS)[number];
  * entirely. Anything narrowing a stored value narrows against *this*.
  */
 export declare function isConnectorKind(value: unknown): value is ConnectorKind;
+/**
+ * How the bytes behind a `file` or `s3` connector are read as records.
+ *
+ * A list rather than a loose string, for the reason {@link CONNECTOR_KINDS} is
+ * one: this used to be compared against string literals in the parser and
+ * spelled out again in a dropdown, and the two had no way to disagree loudly.
+ * The parser's chain also *ended* in JSON, so a format it did not recognise was
+ * not refused — it was read as JSON, and a spreadsheet handed to `JSON.parse`
+ * fails with a syntax error that names a byte offset rather than the format.
+ *
+ * `xlsx` is the odd one and is named for what it is: the only member whose
+ * payload is binary. The other three are text, and everything that reads them
+ * decodes the bytes first. Anything deciding something *per format* narrows
+ * against this and answers {@link unreachableSourceFormat}.
+ */
+export declare const SOURCE_FORMATS: readonly ["csv", "ndjson", "json", "xlsx"];
+export type SourceFormat = (typeof SOURCE_FORMATS)[number];
+/** Same reason as {@link isConnectorKind}: one list, no second copy to drift. */
+export declare function isSourceFormat(value: unknown): value is SourceFormat;
+/**
+ * The format that never compiles quietly.
+ *
+ * The {@link unreachableNodeKind} of formats, and it exists for the same reason:
+ * a member added to {@link SOURCE_FORMATS} without a branch in the parser should
+ * be a type error naming the file, not a connector that offers a format in a
+ * dropdown and then reads the file as JSON.
+ *
+ * It throws as well as failing to compile, because a connector config is JSON
+ * that outlives the build that wrote it: a `format` stored by a newer deployment
+ * and read by an older one is possible, and falling back to a default for it
+ * would be exactly the silent path this closes.
+ */
+export declare function unreachableSourceFormat(format: never, where: string): never;
 /**
  * What a published workflow runs as. **Not an authored object.**
  *
@@ -1042,6 +1075,13 @@ export interface WorkflowSinkNode extends WorkflowNodeBase, ReusableNodeRef {
  * answers are two documented shapes, and anything else fails the node naming
  * the workflow, the version and the child run id.
  *
+ * All of the paragraph above describes the **envelope** mode, which is the
+ * default and what every stored call node is. {@link callMode} names the other
+ * one: a plain call sends {@link config} verbatim, so a workflow that has never
+ * heard of this catalog can be called without being edited — and gives up the
+ * ability to hand rows back, because it is told no key to stage them under. See
+ * {@link WORKFLOW_CALL_MODES}.
+ *
  * ## `config` is not a credential store
  *
  * Named `config` rather than `input` so it travels the same path a source
@@ -1067,9 +1107,109 @@ export interface WorkflowCallNode extends WorkflowNodeBase {
      * to *this* graph and is a number. This one identifies somebody else's code.
      */
     callVersion: string;
-    /** Parameters the author typed, handed to the child under `input`. */
+    /**
+     * Parameters the author typed. Where they land depends on
+     * {@link WorkflowCallNode.callMode}: under `input` in an envelope call, and as
+     * the whole of the child's payload in a plain one.
+     */
     config: Record<string, unknown>;
+    /**
+     * Whether the child is handed a {@link WorkflowCallEnvelope} or the bare
+     * {@link config}. See {@link WORKFLOW_CALL_MODES}, which is where the choice
+     * is argued.
+     *
+     * Absent means `'envelope'`, which is what every call node stored before this
+     * field existed is and what every one of them has always done. Read it through
+     * {@link workflowCallMode} rather than defaulting it a second time — one
+     * default, no second copy to drift.
+     */
+    callMode?: WorkflowCallMode;
 }
+/**
+ * What a {@link WorkflowCallNode} puts on the wire, and the whole of it.
+ *
+ * ## Why there is a second mode at all
+ *
+ * The catalog could not call a workflow that does not know about the catalog.
+ * A `call` node wraps the author's `config` in a {@link WorkflowCallEnvelope},
+ * so a workflow that already exists — one registered years before this package,
+ * whose body reads `data["proc"]` — receives `{catalog: {...}, input: {proc:
+ * ...}}` and dies on the first key it looks for. The only repair available was
+ * to edit the callee, which inverts the dependency exactly the wrong way round:
+ * every workflow anybody wanted to call would have to start depending on this
+ * package's contract, and a Python workflow registered in another repository
+ * would have to be changed to be reachable from a graph.
+ *
+ * ## Why the nesting is not being loosened instead
+ *
+ * The envelope nests for one stated reason, which is on {@link
+ * WorkflowCallEnvelope}: an author's parameter called `runId` must not be able
+ * to shadow the run id. That reason is sound and it is not being weakened. It
+ * simply does not reach the plain mode, because a plain call sends **no catalog
+ * metadata at all** — there is no `runId`, no `nodeId`, no contract number on
+ * the wire, so there is nothing a parameter could shadow. The flat payload is
+ * not the envelope with its guard removed; it is a different, smaller promise.
+ *
+ * ## What the plain mode costs, which is not small
+ *
+ * No `runId` and no `nodeId` means the callee has no key to stage rows under.
+ * Rows travel through the stage store addressed by `(runId, nodeId, batch)` —
+ * see {@link WorkflowStageRef} — and a callee that was told neither cannot
+ * write where the next node would read. So a plain call **cannot return rows to
+ * the graph**, and that is not a convention anybody could follow more carefully:
+ * it is arithmetic. `validateWorkflow` refuses a plain call with an outbound
+ * edge for exactly this reason (`call-plain-has-output`), and its return value
+ * is not read as a row count — see {@link readWorkflowCallOutput} for the shape
+ * that is deliberately *not* consulted on this path.
+ *
+ * A plain call is therefore for its **effect**: run the thing, and let something
+ * else in the graph produce what gets committed.
+ *
+ * ## Why a mode on the node rather than a second node kind or a boolean
+ *
+ * A boolean is the shape {@link WORKFLOW_PREDICATE_KINDS} argues against one
+ * level down, and for the reason it gives: a `plain?: boolean` beside a future
+ * third wire format is two optional flags whose combinations nobody defined, and
+ * every reader invents its own rule for which wins. A closed list with an
+ * exhaustiveness guard ({@link unreachableCallMode}) makes a third format a
+ * compile error naming the files that have to answer for it.
+ *
+ * A second node *kind* was the other candidate and it is too big. The kind list
+ * is deliberately small and every entry earns it by doing something no wiring
+ * can express (see {@link WORKFLOW_NODE_KINDS}). A plain call does the same
+ * thing a call does at the level the graph reasons about — it hands this
+ * position to a workflow somebody else registered, pinned by name and version.
+ * What differs is the payload. Splitting the kind would duplicate `callName`,
+ * `callVersion`, `config`, the pin check, the picker, the plan entry and the
+ * canvas node for a difference of one field, and every place that today writes
+ * `node.kind === 'call'` would have to remember to write both — which is the
+ * hand-maintained list going quiet that {@link NODE_KIND_IS_REUSABLE} exists to
+ * stop.
+ */
+export declare const WORKFLOW_CALL_MODES: readonly ["envelope", "plain"];
+export type WorkflowCallMode = (typeof WORKFLOW_CALL_MODES)[number];
+/** Same reason as {@link isConnectorKind}: one list, no second copy to drift. */
+export declare function isWorkflowCallMode(value: unknown): value is WorkflowCallMode;
+/**
+ * {@link unreachableNodeKind}, one level down, and for the identical reason.
+ *
+ * Every branch over {@link WorkflowCallMode} ends here, so a third wire format
+ * added to the list without a rule for building its payload, hashing it,
+ * validating it or reading its answer is a type error naming the file. It throws
+ * as well, because a mode arrives as JSON out of a column and a build older than
+ * the data is a thing that happens.
+ */
+export declare function unreachableCallMode(mode: never, where: string): never;
+/**
+ * The mode this call node runs in, with the default applied once.
+ *
+ * Absent means `'envelope'` — that is what every node stored before the field
+ * existed is, and reading it as anything else would silently change what a
+ * deployment's graphs already do. One function so that the store, the runner,
+ * the hash and the canvas cannot each carry their own `?? 'envelope'` and have
+ * one of them drift.
+ */
+export declare function workflowCallMode(node: WorkflowCallNode): WorkflowCallMode;
 /**
  * The kinds of test an {@link WorkflowIfNode} can make.
  *
@@ -1919,6 +2059,29 @@ export interface VersionPinCopy {
     detail: string;
 }
 export declare function describeVersionPin(version: number | undefined, subject: string): VersionPinCopy;
+/**
+ * The same question about a whole graph: does it follow its latest save, or does
+ * it run a version somebody chose?
+ *
+ * Shares {@link VersionPinCopy} and its two labels with
+ * {@link describeVersionPin} deliberately. A console that said "pinned to v6"
+ * about a transform node and invented different words for a graph would be two
+ * vocabularies for one idea, and the reader would have to work out whether they
+ * meant the same thing — which is the confusion the whole notion of a pin exists
+ * to remove.
+ *
+ * The *detail* differs, and only where the facts do. Two of them:
+ *
+ * - A node's pin can outlive the revision it names, because `catalog_revision`
+ *   is capped. A graph's cannot: releases are never evicted, precisely because
+ *   the one a live pointer names is the graph production is running. So this
+ *   copy makes no eviction caveat, and must not acquire one.
+ * - Following the latest is *cheap* for a node — everybody moves together, which
+ *   is often the point. For a graph it means editing is deploying, which is the
+ *   hazard this field was added to remove. So the unpinned sentence here is a
+ *   warning where the node's is a trade-off.
+ */
+export declare function describeLiveVersion(workflow: CatalogWorkflow): VersionPinCopy;
 /**
  * Which side of an {@link WorkflowIfNode} a wire leaves by.
  *
@@ -2062,6 +2225,51 @@ export interface CatalogWorkflow {
     version: number;
     /** Fingerprint of the graph at this version. See {@link workflowGraphHash}. */
     graphHash: string;
+    /**
+     * Which released version a run of this graph gets when nobody names one.
+     *
+     * **Absent means follow the latest**, which is what every graph in every
+     * deployment does today and what every existing graph keeps doing until
+     * somebody points this at something. Absence is a real answer rather than a
+     * state waiting to be filled in — the same stance {@link WorkflowCallNode}
+     * takes from the other side, where a call that named no version would run
+     * whichever one is registered when the load happens.
+     *
+     * Present, it names a {@link CatalogWorkflowRelease} — and from that moment
+     * **editing this graph stops being deploying it**. A save bumps
+     * {@link version} as it always did; the next scheduled window still runs the
+     * released version this names, because a cron tick that executed whatever the
+     * canvas happened to hold is a deploy nobody performed. Moving it is
+     * {@link CatalogWorkflowReleaseStore.setLiveWorkflowVersion}, which is a
+     * deliberate act by a named principal, and moving it *backwards* is the whole
+     * of rollback.
+     *
+     * ## Why this is a column here and not a row in an environments table
+     *
+     * Because the row is already per-environment. Environments in this catalog are
+     * physically isolated — one database each, see `catalog.environment.ts` — so
+     * this `catalog_workflow` row exists once per environment already, and a
+     * second dimension keyed on the environment id would be a table whose every
+     * query filtered on a constant. The environment is the connection, and it has
+     * been since environments were added.
+     *
+     * That is also why the field is not called `productionVersion`. "Production"
+     * in this catalog is the *name of an environment* — see `CatalogEnvironment`
+     * in `catalog.environment.ts` — so a column called that, on a row which
+     * already lives inside exactly one environment, would read as naming a
+     * different one.
+     *
+     * ## Why it does not cross a promotion
+     *
+     * `planPromotion` is explicit that version numbers do not cross: a version
+     * counts edits made in the environment it lives in, so dev's v7 and
+     * production's v7 are unrelated numbers. A pointer *to* a version inherits
+     * that argument whole — carrying this field would point the target's live
+     * pointer at whatever its own seventh edit happened to be. So
+     * `PromotableWorkflow` does not carry it, and a promoted graph arrives
+     * following the latest, exactly as a newly created one does.
+     */
+    liveVersion?: number;
     /**
      * The type the sink writes.
      *
@@ -2296,6 +2504,18 @@ export interface WorkflowCallOutput {
  * schema for a workflow's output anywhere in the durable contract, and no way
  * to reach one if there were. So the check is here, at the one moment the
  * answer exists, and it names what it saw.
+ *
+ * ## Not called at all for a plain call, which is a decision and not an omission
+ *
+ * A plain call is handed no run id and no node id, so its callee could not have
+ * staged anything under `(runId, nodeId, batch)` even if it wanted to. Running
+ * this over its answer would be worse than pointless in both directions: a
+ * callee that happens to return `{batches, rowCount}` meaning something else
+ * entirely would have this graph go and read a stage that does not exist, and a
+ * callee returning one of the two would fail the node over a key it was never
+ * told about. So the plain path reports zero rows unconditionally and reads
+ * nothing — see `WorkflowRunnerService.callOutput`, which is where that is
+ * enforced rather than merely intended.
  */
 export declare function readWorkflowCallOutput(value: unknown): WorkflowCallOutput | undefined;
 /**
@@ -2421,7 +2641,7 @@ export interface CallableWorkflowBlock {
 }
 export declare function callableWorkflowBlock(ref: CallableWorkflowRef): CallableWorkflowBlock | undefined;
 /** Every way a graph can be refused. Exported so a canvas can key off the code. */
-export declare const WORKFLOW_ISSUE_CODES: readonly ["empty", "invalid-node-id", "duplicate-node-id", "edge-endpoint-missing", "self-edge", "duplicate-edge", "cycle", "no-source", "source-has-input", "no-sink", "duplicate-sink-type", "sink-has-output", "unreachable", "dead-end", "transform-not-named", "call-not-named", "if-not-named", "if-threshold-invalid", "if-needs-one-input", "branch-not-labelled", "branch-on-plain-edge", "filter-predicate-invalid", "filter-narrows-unacknowledged", "filter-narrows-nothing", "version-pin-invalid"];
+export declare const WORKFLOW_ISSUE_CODES: readonly ["empty", "invalid-node-id", "duplicate-node-id", "edge-endpoint-missing", "self-edge", "duplicate-edge", "cycle", "no-source", "source-has-input", "no-sink", "duplicate-sink-type", "sink-has-output", "unreachable", "dead-end", "transform-not-named", "call-not-named", "call-plain-has-output", "if-not-named", "if-threshold-invalid", "if-needs-one-input", "branch-not-labelled", "branch-on-plain-edge", "filter-predicate-invalid", "filter-narrows-unacknowledged", "filter-narrows-nothing", "version-pin-invalid"];
 export type WorkflowIssueCode = (typeof WORKFLOW_ISSUE_CODES)[number];
 export interface WorkflowValidationIssue {
     code: WorkflowIssueCode;
@@ -2718,6 +2938,172 @@ export interface CatalogWorkflowStore {
         enabled?: boolean;
     }, changedBy: string): Promise<CatalogWorkflow>;
 }
+/**
+ * One version of a graph, kept exactly as it was, because somebody said so.
+ *
+ * ## The archive `CatalogWorkflow` argues against, and why this is not it
+ *
+ * {@link CatalogWorkflow} states plainly that a graph is not revisioned, and the
+ * decisive reason it gives is the counter: {@link CatalogWorkflow.version} is
+ * bumped on **draft** edits by design, so archiving one body per version would
+ * store every autosave of a canvas somebody is still dragging boxes around on —
+ * and under a bounded archive that noise would evict the versions that actually
+ * ran. **That argument is correct and nothing here weakens it.** It is an
+ * argument against archiving *saves*, and this archives *releases*: a release is
+ * minted only by `releaseWorkflow`, which is a route a person presses, and a
+ * canvas autosave does not reach it. So the counter stays cheap to inflate, the
+ * archive stays keyed on a deliberate act, and the two now compose because they
+ * are counting different things.
+ *
+ * The second half of that docblock — that a graph is a structure and a line
+ * differ over serialised JSON would report a dragged box as a change — is also
+ * untouched. This is not a diff feature. It stores the graph so a version can be
+ * *run*, and diffing graphs remains a graph problem deserving a screen that
+ * draws one.
+ *
+ * ## Why not `catalog_revision`, which already archives versioned bodies
+ *
+ * Two reasons, and the second is the one that decides it.
+ *
+ * `CatalogRevision.body` is text a person typed — a transform's code, a saved
+ * query's SQL — and every route over it is built to render text. A graph is
+ * nodes and edges, and folding it into that column would put JSON nobody wrote
+ * in front of a differ built for source.
+ *
+ * The one that decides it is {@link CATALOG_REVISION_LIMIT}. That cap is right
+ * for code, for the reason its own docblock gives: revisions grow with how often
+ * somebody edits, which nobody meters. A release does not grow that way — it
+ * grows with how often somebody deliberately ships — and, crucially, a release
+ * is the thing a live pointer names. An eviction rule over this table could
+ * delete the graph that production is *currently running*, turning
+ * {@link CatalogWorkflow.liveVersion} into a pin nothing can honour and stopping
+ * a working pipeline on a retention policy. **So releases are never evicted.**
+ * That makes this an unbounded table, which this codebase is careful about — and
+ * it earns it on the same test `catalog_audit_event` and `catalog_connector_run`
+ * pass: one row per thing a person deliberately did, at a rate an operator can
+ * read off their own change process.
+ *
+ * ## Immutable, and there is no route that removes one
+ *
+ * Nothing edits a release and nothing deletes one. That is the strongest form of
+ * "refuse to delete the version that is live": there is no operation to refuse.
+ * The one exception is {@link CatalogWorkflowStore.deleteWorkflow}, which takes
+ * the graph, its connector and its whole run history — releases go with it,
+ * because nothing survives that could still name one. (The opposite call is made
+ * for a transform, whose revisions outlive it precisely *because* runs that ran
+ * them survive.)
+ */
+export interface CatalogWorkflowRelease {
+    /**
+     * `{workflowId}:{version}`, derived rather than random.
+     *
+     * The same construction `revisionKey` uses in the MikroORM store and for the
+     * same property: releasing the same version twice cannot append a second copy,
+     * because the second write would collide with the first rather than land
+     * beside it.
+     */
+    id: string;
+    workflowId: string;
+    /**
+     * The {@link CatalogWorkflow.version} this release IS.
+     *
+     * The same number, not a parallel sequence. A release sequence of its own was
+     * the alternative and it is worse in the one place it matters: a run records
+     * `workflowVersion`, so a second numbering would mean a run naming "v3" and an
+     * operator reading "release 3" could be two different graphs, which is exactly
+     * the ambiguity the edit counter was made cheap to avoid.
+     */
+    version: number;
+    /** Fingerprint of the graph as released. See {@link workflowGraphHash}. */
+    graphHash: string;
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+    /** The type the sink committed at this version. */
+    targetType: string;
+    /** Whatever the releaser wanted to say about it. */
+    notes?: string;
+    releasedBy: string;
+    releasedAt: string;
+}
+/**
+ * Minting releases, and pointing at one.
+ *
+ * Its own interface mixed in optionally, for the reason {@link
+ * CatalogWorkflowStore} is: a store written against the previous shape must keep
+ * compiling, and "this deployment cannot hold releases" has to be a sentence a
+ * UI can say rather than a method missing at run time.
+ *
+ * The split from `CatalogWorkflowStore` is not only compatibility. These four
+ * are the only members in this file that can change *what a cron executes*
+ * without touching a graph, and keeping them behind their own predicate means a
+ * store can hold graphs without acquiring that power by accident.
+ */
+export interface CatalogWorkflowReleaseStore {
+    /**
+     * Freeze the graph as it currently stands, under its current version.
+     *
+     * **The only thing that mints one.** Not `saveWorkflow`, which is the autosave
+     * this whole feature exists to stop being a deploy; not `publishWorkflow`,
+     * which is idempotent and is called by a promotion apply — a release minted as
+     * a side effect of promoting configuration into an environment would be a
+     * release nobody in that environment chose.
+     *
+     * Refuses a draft, for the reason `WORKFLOW_STATUSES` already gives about what
+     * a connector may point at and what a promotion may carry: what gets shipped
+     * should be something a person declared finished.
+     *
+     * **Idempotent per version.** Releasing a graph whose current version is
+     * already released answers with the existing release rather than minting a
+     * second or overwriting its notes — the graph has not changed, so a second
+     * release would be a record of an event that did not happen, and re-attributing
+     * the first one would erase who actually shipped it.
+     */
+    releaseWorkflow(id: string, releasedBy: string, options?: {
+        notes?: string;
+    }): Promise<CatalogWorkflowRelease>;
+    /** Newest first. */
+    listWorkflowReleases(id: string): Promise<CatalogWorkflowRelease[]>;
+    /**
+     * The graph as it was at a released version, or `undefined`.
+     *
+     * `undefined` for a version that was never released as much as for a workflow
+     * that does not exist, and callers must treat the two the same way: **fail,
+     * never fall back to the latest.** Running the current graph because the named
+     * one could not be produced is precisely the substitution a pin is written
+     * down to prevent.
+     *
+     * Answers with a whole {@link CatalogWorkflow} rather than the bare release,
+     * because that is what a run needs: the released graph, carried on the row's
+     * present identity. The graph fields — nodes, edges, `targetType`,
+     * `graphHash`, `version` — come from the release. The operational ones —
+     * `name`, `status`, `schedule`, `enabled`, `liveVersion` — come from the row
+     * as it is now, because they are not part of what was released. A cron somebody
+     * changed this morning applies to the version that is live, not to whatever
+     * cron was on the row the day it was released.
+     */
+    getWorkflowAt(id: string, version: number): Promise<CatalogWorkflow | undefined>;
+    /**
+     * Point {@link CatalogWorkflow.liveVersion} at a released version — or clear it.
+     *
+     * One method for going live, for rolling back and for going back to following
+     * the latest, because they are one act with a different argument. Rollback in
+     * particular is not a separate mechanism to build and test: it is this call
+     * with a smaller number, and it works because the older graph is still stored.
+     *
+     * Refuses a version with no release behind it, naming what there is. A pointer
+     * accepted at a number nothing can produce would be a pipeline that stops at
+     * its next window, discovered by a load failing rather than by the person who
+     * typed it.
+     *
+     * `undefined` clears the pointer and takes the graph back to following the
+     * latest. Allowed rather than refused — it is the state every graph in every
+     * deployment is in, so refusing would strand anything that ever went live —
+     * and stated as a decision because it hands back exactly the hazard the
+     * pointer removes: from that moment, saving the graph changes what the next
+     * window runs.
+     */
+    setLiveWorkflowVersion(id: string, version: number | undefined, changedBy: string): Promise<CatalogWorkflow>;
+}
 /**
  * Where the rows between two nodes actually sit.
  *
@@ -2767,6 +3153,36 @@ export interface CatalogStageStore {
  * does, because a flag is a claim and a method is the thing itself.
  */
 export declare function supportsWorkflows(store: CatalogPipelineStore): store is CatalogPipelineStore & CatalogWorkflowStore;
+/**
+ * Whether this store can mint a release and be pointed at one.
+ *
+ * All four asked for by name, for the reason `supportsWorkflows` asks for
+ * `publishWorkflow` and `saveWorkflowSchedule` by name rather than assuming they
+ * arrive together: a store with the mint and not the pointer would narrow
+ * cleanly here, let somebody release a graph, and then fail on the call that was
+ * supposed to make it run.
+ *
+ * {@link getWorkflowAt} is the one whose absence is least visible and most
+ * expensive. A store that could hold a `liveVersion` and not resolve it would
+ * point a scheduled load at a version it cannot produce — and the only place
+ * that shows up is a cron window that stops firing.
+ */
+export declare function supportsWorkflowReleases(store: CatalogPipelineStore): store is CatalogPipelineStore & CatalogWorkflowReleaseStore;
+/**
+ * Which version of this graph a run gets when the caller names none.
+ *
+ * The one implementation of "follow the latest unless something is live", shared
+ * by the scheduler and by the manual run route so the two cannot disagree about
+ * what a cron does and what the button next to it does. That divergence is not
+ * hypothetical: the schedule used to live on the connector and on the workflow
+ * at once, and the whole of `ConnectorScheduler`'s docblock is about what it
+ * cost to have two copies of one answer.
+ *
+ * Not a fallback in the defensive sense. `liveVersion` absent is a stated
+ * position — this graph follows its head — and this function is where that
+ * position is turned into a number, not where a missing value is patched over.
+ */
+export declare function liveWorkflowVersion(workflow: CatalogWorkflow): number;
 /**
  * Whether this store keeps a transform's history.
  *
@@ -2834,7 +3250,7 @@ export type CatalogLoadExpectationStore = Required<Pick<CatalogPipelineStore, 'l
  * an editor whose save has nowhere to go.
  */
 export declare function supportsLoadExpectations(store: CatalogPipelineStore): store is CatalogPipelineStore & CatalogLoadExpectationStore;
-export interface CatalogPipelineStore extends Partial<CatalogWorkflowStore>, Partial<CatalogStageStore> {
+export interface CatalogPipelineStore extends Partial<CatalogWorkflowStore>, Partial<CatalogWorkflowReleaseStore>, Partial<CatalogStageStore> {
     listConnectors(): Promise<CatalogConnector[]>;
     getConnector(id: string): Promise<CatalogConnector | undefined>;
     saveConnector(input: Omit<CatalogConnector, 'id' | 'createdAt' | 'updatedAt' | 'createdBy'> & {