@dudousxd/nestjs-catalog 0.1.0

package/dist/catalog.pipeline.js

@@ -0,0 +1,606 @@
+"use strict";
+/**
+ * Getting data in: where it comes from, and what turns it into rows.
+ *
+ * The shape NiFi and Airflow both settle on — a source, a transform, a sink —
+ * with the sink fixed, because the sink is the whole point of a catalog. What
+ * is deliberately *not* here is a scheduler: the durable engine already
+ * schedules, retries and checkpoints, and writing a second one would mean two
+ * systems each believing they decide when a load runs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CATALOG_PIPELINE_STORE = exports.WORKFLOW_ISSUE_CODES = exports.WORKFLOW_EXECUTION_MODES = exports.WORKFLOW_NODE_ID_PATTERN = exports.WORKFLOW_NODE_KINDS = exports.TRANSFORM_RUNNER = exports.TRANSFORM_LANGUAGES = exports.CONNECTOR_KINDS = void 0;
+exports.isConnectorKind = isConnectorKind;
+exports.isTransformLanguage = isTransformLanguage;
+exports.isWorkflowNodeKind = isWorkflowNodeKind;
+exports.isWorkflowExecutionMode = isWorkflowExecutionMode;
+exports.validateWorkflow = validateWorkflow;
+exports.workflowRunOrder = workflowRunOrder;
+exports.workflowGraphHash = workflowGraphHash;
+exports.isWorkflowNode = isWorkflowNode;
+exports.isWorkflowEdge = isWorkflowEdge;
+exports.supportsWorkflows = supportsWorkflows;
+exports.supportsWorkflowStages = supportsWorkflowStages;
+exports.isPipelineStore = isPipelineStore;
+/**
+ * Where a connector pulls from.
+ *
+ * Deliberately a short list. Every kind here is one this service can actually
+ * execute — a kind that exists in the type and throws at run time is worse than
+ * one that is absent, because the first looks supported in a dropdown.
+ */
+exports.CONNECTOR_KINDS = [
+    /** A JSON endpoint. */
+    'http',
+    /** A SQL database, by connection URL. Read-only by construction. */
+    'sql',
+    /** A file: local path, or anything `fetch` can GET — CSV, NDJSON, JSON. */
+    'file',
+    /** An object store bucket and prefix — S3, MinIO, anything S3-compatible. */
+    's3',
+    /** Records pasted into the config. For trying a transform against real shapes. */
+    'inline',
+];
+/**
+ * The type is derived from the list, not written beside it.
+ *
+ * A second hand-maintained copy of these names is the bug this shape exists to
+ * prevent: a store that narrows a database string against its own stale array
+ * and falls back to a default turns "the kind you chose" into "the kind that
+ * happened to be first", and the resulting failure names the wrong source
+ * entirely. Anything narrowing a stored value narrows against *this*.
+ */
+function isConnectorKind(value) {
+    return exports.CONNECTOR_KINDS.some((kind) => kind === value);
+}
+/**
+ * TypeScript is Node's own type stripping, so it costs no compiler and no build
+ * step — and types are erased, never checked. A transform with a wrong type
+ * still runs; the editor's try pane is what catches it.
+ */
+exports.TRANSFORM_LANGUAGES = ['javascript', 'typescript', 'python'];
+/** Same reason as {@link isConnectorKind}: one list, no second copy to drift. */
+function isTransformLanguage(value) {
+    return exports.TRANSFORM_LANGUAGES.some((language) => language === value);
+}
+exports.TRANSFORM_RUNNER = Symbol('TRANSFORM_RUNNER');
+/* ---------------------------------------------------------------------------
+ * Workflows: a graph of steps that ends in exactly one commit.
+ *
+ * **Why "workflow" and not "flow".** `FlowView` in the React package is
+ * deliberately *derived* lineage: it reconstructs who fed what from the audit
+ * trail, on the argument that the graph is whatever the publishers actually
+ * did, which is more truthful than a diagram someone has to remember to update.
+ * This is the opposite object — authored by a person, executed as written, and
+ * wrong the moment it disagrees with intent rather than with history. Sharing
+ * the word would put a screen called "Flow" that infers and a screen called
+ * "Flow" that declares next to each other in the same console, and the first
+ * question every reader would ask is which one is real.
+ *
+ * "Workflow" is the word the rest of this ecosystem already uses for authored,
+ * ordered, resumable work — `@dudousxd/nestjs-durable` calls its unit a
+ * workflow and its parts steps — and that agreement is earned rather than
+ * borrowed: when durable is available a catalog workflow *is* compiled into a
+ * durable workflow, one step per node. "Pipeline" was the other candidate and
+ * is already taken by this file's subject as a whole (`CatalogPipelineStore`
+ * holds connectors, transforms and connections), so it would have named both
+ * the container and one thing inside it.
+ * ------------------------------------------------------------------------- */
+/**
+ * What a node can be.
+ *
+ * Three kinds, and they are exactly the three verbs the existing connector
+ * runner already performs in sequence: fetch, transform, publish. Nothing here
+ * is a kind this service cannot execute, which is the same rule
+ * {@link CONNECTOR_KINDS} follows — a kind that exists in the type and throws
+ * at run time is worse than one that is absent, because the first looks
+ * supported in a palette.
+ *
+ * The kinds that were considered and rejected, since a small vocabulary is only
+ * defensible if the omissions are:
+ *
+ * - **filter** — a transform whose code returns a subset of what it was given.
+ *   It needs no new execution path, only a different body, and adding the kind
+ *   would mean two ways to drop rows and two places to look when rows go
+ *   missing.
+ * - **branch / split** — already expressible: a node with two outbound edges is
+ *   read by both successors, each of which filters differently. There is
+ *   nothing for a branch node to *do*.
+ * - **merge / join** — a node with several inbound edges receives its inputs
+ *   concatenated in edge order (see {@link WorkflowEdge}). A keyed join is then
+ *   ordinary code inside the transform, which can already see every record.
+ *   A `merge` kind would have had to carry a strategy field whose values the
+ *   runner would have to implement one by one, and an unimplemented strategy in
+ *   a dropdown is the failure this list exists to avoid.
+ */
+exports.WORKFLOW_NODE_KINDS = [
+    /** Reads records out of a system. The roots of the graph. */
+    'source',
+    /** Runs a {@link CatalogTransform} over what it is given. */
+    'transform',
+    /** Writes into an object type and commits. Exactly one per workflow. */
+    'sink',
+];
+/** Same reason as {@link isConnectorKind}: one list, no second copy to drift. */
+function isWorkflowNodeKind(value) {
+    return exports.WORKFLOW_NODE_KINDS.some((kind) => kind === value);
+}
+/**
+ * The longest a node id may be, and the alphabet it may use.
+ *
+ * Constrained rather than free-form for two concrete reasons. A node id becomes
+ * the name of a durable step, and durable step names are how a replay finds the
+ * checkpoint it already wrote — a step renamed between runs re-executes work
+ * that was already done. And staged rows are addressed by a key built from the
+ * run id, the node id and the batch number, so a node id containing the
+ * separator would let one node read another's rows.
+ */
+exports.WORKFLOW_NODE_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+/**
+ * How a workflow run is executed here.
+ *
+ * `CATALOG_DURABLE` is `own`, `attach` or `off`, so a deployment may genuinely
+ * have no engine, and the model must not pretend otherwise. A workflow that
+ * appeared checkpointed and was not would be the same silent no-op this codebase
+ * already had to remove once, when connectors carried a `schedule` field that
+ * nothing read for months.
+ */
+exports.WORKFLOW_EXECUTION_MODES = [
+    /**
+     * Each node is a durable step. A ten-node graph that fails at node seven
+     * resumes at node seven, because the six before it have checkpoints.
+     */
+    'durable',
+    /**
+     * The whole graph runs inside one call. It still runs, and it still commits
+     * atomically at the sink — but a failure at node seven re-runs node one.
+     */
+    'inline',
+];
+function isWorkflowExecutionMode(value) {
+    return exports.WORKFLOW_EXECUTION_MODES.some((mode) => mode === value);
+}
+/** Every way a graph can be refused. Exported so a canvas can key off the code. */
+exports.WORKFLOW_ISSUE_CODES = [
+    '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',
+];
+/**
+ * Everything that makes a graph unrunnable, in one pure function.
+ *
+ * Pure and dependency-free on purpose, and exported from the browser entry point
+ * as well as the server one, so the canvas and the store run *the same*
+ * validator. A canvas that validates against its own copy of these rules and a
+ * server that validates against another is a canvas that eventually lies —
+ * either by refusing something the server would accept, or, far worse, by
+ * accepting something the server then rejects at run time, halfway through a
+ * load. The server still calls this itself: shared code is not the same as
+ * trusted input, and the store must refuse a graph that arrived by curl.
+ *
+ * Structural problems are reported alone. Reachability computed over edges that
+ * point at nodes which do not exist produces a second page of consequences, and
+ * burying the one real problem under them is how a validation message stops
+ * being read.
+ */
+function validateWorkflow(graph) {
+    const issues = [];
+    const nodes = graph.nodes ?? [];
+    const edges = graph.edges ?? [];
+    if (nodes.length === 0) {
+        return [
+            {
+                code: 'empty',
+                nodeIds: [],
+                message: 'This workflow has no nodes. Running it would commit an empty snapshot over whatever is live, so it is refused rather than saved as something that looks runnable.',
+            },
+        ];
+    }
+    const byId = new Map();
+    for (const node of nodes) {
+        if (!exports.WORKFLOW_NODE_ID_PATTERN.test(node.id)) {
+            issues.push({
+                code: 'invalid-node-id',
+                nodeIds: [node.id],
+                message: `Node id "${node.id}" is not usable. Ids may be 1-64 characters of letters, digits, underscore or hyphen: the id becomes a durable step name and part of the key its staged rows are stored under, and neither can carry arbitrary text safely.`,
+            });
+            // Registered anyway, deliberately. Leaving it out would make every edge
+            // touching it report a *missing node* as well, which sends the reader
+            // looking for a node they can see on the canvas. One problem, one message.
+        }
+        if (byId.has(node.id)) {
+            issues.push({
+                code: 'duplicate-node-id',
+                nodeIds: [node.id],
+                message: `Two nodes share the id "${node.id}". Edges name nodes by id, so a duplicate makes every wire touching it ambiguous.`,
+            });
+            continue;
+        }
+        byId.set(node.id, node);
+    }
+    const seenEdges = new Set();
+    for (const edge of edges) {
+        if (!byId.has(edge.from) || !byId.has(edge.to)) {
+            const missing = byId.has(edge.from) ? edge.to : edge.from;
+            issues.push({
+                code: 'edge-endpoint-missing',
+                nodeIds: [edge.from, edge.to],
+                message: `The edge "${edge.from}" → "${edge.to}" names node "${missing}", which is not in this workflow. It was most likely deleted while the wire stayed behind.`,
+            });
+            continue;
+        }
+        if (edge.from === edge.to) {
+            issues.push({
+                code: 'self-edge',
+                nodeIds: [edge.from],
+                message: `Node "${edge.from}" is wired to itself, which has no order to run in.`,
+            });
+            continue;
+        }
+        const key = `${edge.from}${edge.to}`;
+        if (seenEdges.has(key)) {
+            issues.push({
+                code: 'duplicate-edge',
+                nodeIds: [edge.from, edge.to],
+                message: `Node "${edge.from}" is wired into "${edge.to}" twice, so "${edge.to}" would receive the same rows twice and silently double its input.`,
+            });
+            continue;
+        }
+        seenEdges.add(key);
+    }
+    // Reachability and cycles are only meaningful once the graph is structurally
+    // sound. See the note on this function.
+    if (issues.length > 0)
+        return issues;
+    const outgoing = new Map();
+    const incoming = new Map();
+    for (const node of nodes) {
+        outgoing.set(node.id, []);
+        incoming.set(node.id, []);
+    }
+    for (const edge of edges) {
+        outgoing.get(edge.from)?.push(edge.to);
+        incoming.get(edge.to)?.push(edge.from);
+    }
+    const sources = [];
+    const sinks = [];
+    for (const node of nodes) {
+        if (node.kind === 'source')
+            sources.push(node);
+        if (node.kind === 'sink')
+            sinks.push(node);
+        if (node.kind === 'source' && (incoming.get(node.id)?.length ?? 0) > 0) {
+            issues.push({
+                code: 'source-has-input',
+                nodeIds: [node.id],
+                message: `Source "${node.name}" (${node.id}) has an inbound edge. A source reads from a system, not from another node; wire that node into a transform instead.`,
+            });
+        }
+        if (node.kind === 'sink' && (outgoing.get(node.id)?.length ?? 0) > 0) {
+            issues.push({
+                code: 'sink-has-output',
+                nodeIds: [node.id],
+                message: `Sink "${node.name}" (${node.id}) has an outbound edge. The sink commits the snapshot, so nothing can run after it.`,
+            });
+        }
+        if (node.kind === 'transform' && node.transformId.length === 0) {
+            issues.push({
+                code: 'transform-not-named',
+                nodeIds: [node.id],
+                message: `Transform node "${node.name}" (${node.id}) names no transform, so there is no code for it to run.`,
+            });
+        }
+    }
+    if (sources.length === 0) {
+        issues.push({
+            code: 'no-source',
+            nodeIds: [],
+            message: 'This workflow has no source node, so nothing would ever be read and the sink would commit an empty snapshot.',
+        });
+    }
+    if (sinks.length === 0) {
+        issues.push({
+            code: 'no-sink',
+            nodeIds: [],
+            message: 'This workflow has no sink node. A workflow ends at a sink, because the sink is what writes and commits — without one the graph computes rows and throws them away.',
+        });
+    }
+    // Several sinks are allowed, and the reason is the point of having a graph at
+    // all: one expensive read feeding several outputs. Forbidding it would mean
+    // pulling the same ten million rows twice to derive two types from them.
+    //
+    // What is refused is two sinks writing the *same* type. Each sink commits its
+    // own type independently — there is no distributed transaction here and the
+    // model does not pretend otherwise — but two snapshots of one type in one run
+    // leaves nothing to say which of them the readers should get.
+    const byTargetType = new Map();
+    for (const sink of sinks) {
+        const sharing = byTargetType.get(sink.targetType) ?? [];
+        sharing.push(sink);
+        byTargetType.set(sink.targetType, sharing);
+    }
+    for (const [targetType, sharing] of byTargetType) {
+        if (sharing.length < 2)
+            continue;
+        issues.push({
+            code: 'duplicate-sink-type',
+            nodeIds: sharing.map((sink) => sink.id),
+            message: `${sharing
+                .map((sink) => `"${sink.name}" (${sink.id})`)
+                .join(' and ')} both commit ${targetType}. Two snapshots of one type in a single run leaves nothing to say which one readers should get — wire these branches into one sink, or send them to different types.`,
+        });
+    }
+    // Cycles, by Kahn's algorithm: whatever is left with a non-zero in-degree
+    // after the queue drains is on one.
+    const indegree = new Map();
+    for (const node of nodes) {
+        indegree.set(node.id, incoming.get(node.id)?.length ?? 0);
+    }
+    const queue = nodes.filter((node) => indegree.get(node.id) === 0).map((n) => n.id);
+    const ordered = [];
+    while (queue.length > 0) {
+        const id = queue.shift();
+        if (id === undefined)
+            break;
+        ordered.push(id);
+        for (const next of outgoing.get(id) ?? []) {
+            const remaining = (indegree.get(next) ?? 0) - 1;
+            indegree.set(next, remaining);
+            if (remaining === 0)
+                queue.push(next);
+        }
+    }
+    if (ordered.length !== nodes.length) {
+        // What Kahn's algorithm leaves behind is the cycle *plus* everything
+        // downstream of it, because those never had their in-degree resolved
+        // either. Naming all of it would point at nodes that are perfectly well
+        // wired and merely stuck behind the loop, and a message that names the
+        // wrong node is worse than a vague one. Peeling off nodes with no outgoing
+        // edge inside the leftover set, repeatedly, strips exactly those tails and
+        // leaves the nodes actually on the loop.
+        const stuck = new Set(nodes.filter((node) => !ordered.includes(node.id)).map((node) => node.id));
+        for (let peeled = true; peeled;) {
+            peeled = false;
+            for (const id of stuck) {
+                const continues = (outgoing.get(id) ?? []).some((next) => stuck.has(next));
+                if (continues)
+                    continue;
+                stuck.delete(id);
+                peeled = true;
+            }
+        }
+        const looped = [...stuck];
+        issues.push({
+            code: 'cycle',
+            nodeIds: looped,
+            message: `These nodes form a cycle: ${looped.join(' → ')}. A graph that loops has no order to run in and no point at which the load is finished, so it is refused rather than run until something times out.`,
+        });
+        // Reachability over a cyclic graph reports nodes as unreachable that are
+        // only unreachable *because* of the cycle, which points at the wrong boxes.
+        return issues;
+    }
+    const reachableFromSources = walk(sources.map((node) => node.id), outgoing);
+    const reachesASink = walk(sinks.map((sink) => sink.id), incoming);
+    for (const node of nodes) {
+        if (sources.length > 0 && !reachableFromSources.has(node.id)) {
+            issues.push({
+                code: 'unreachable',
+                nodeIds: [node.id],
+                message: `Node "${node.name}" (${node.id}) is not reachable from any source, so it would never run. Wire a source into it or delete it — a node on the canvas that silently does nothing is the thing this check exists to prevent.`,
+            });
+            continue;
+        }
+        if (sinks.length > 0 && !reachesASink.has(node.id)) {
+            issues.push({
+                code: 'dead-end',
+                nodeIds: [node.id],
+                message: `Node "${node.name}" (${node.id}) leads nowhere: nothing it produces reaches the sink, so it would be computed and thrown away. Every path has to end at the sink.`,
+            });
+        }
+    }
+    return issues;
+}
+/** Breadth-first reachability over one adjacency map. */
+function walk(roots, adjacency) {
+    const seen = new Set(roots);
+    const queue = [...roots];
+    while (queue.length > 0) {
+        const id = queue.shift();
+        if (id === undefined)
+            break;
+        for (const next of adjacency.get(id) ?? []) {
+            if (seen.has(next))
+                continue;
+            seen.add(next);
+            queue.push(next);
+        }
+    }
+    return seen;
+}
+/**
+ * The order the nodes run in, and the inputs each one gets.
+ *
+ * Here rather than in the runner because the wiring rules — a node runs after
+ * everything wired into it, and receives its inputs in edge order — are the same
+ * rules {@link validateWorkflow} enforces, and two implementations of one rule
+ * is how a graph that validated comes out executing differently.
+ *
+ * Throws on an invalid graph rather than returning a best effort. A partial
+ * order over a broken graph is a load that half-happens, which is harder to
+ * recover from than one that never started.
+ */
+function workflowRunOrder(graph) {
+    const issues = validateWorkflow(graph);
+    if (issues.length > 0) {
+        throw new Error(`Refusing to order an invalid workflow: ${issues.map((issue) => issue.message).join(' ')}`);
+    }
+    const byId = new Map(graph.nodes.map((node) => [node.id, node]));
+    const indegree = new Map();
+    const outgoing = new Map();
+    for (const node of graph.nodes) {
+        indegree.set(node.id, 0);
+        outgoing.set(node.id, []);
+    }
+    for (const edge of graph.edges) {
+        indegree.set(edge.to, (indegree.get(edge.to) ?? 0) + 1);
+        outgoing.get(edge.from)?.push(edge.to);
+    }
+    const ready = graph.nodes.filter((node) => indegree.get(node.id) === 0).map((node) => node.id);
+    const order = [];
+    while (ready.length > 0) {
+        const id = ready.shift();
+        if (id === undefined)
+            break;
+        const node = byId.get(id);
+        if (!node)
+            continue;
+        // Edge order, not node order: this is the array a merge reads its inputs
+        // from, and it is part of the fingerprint precisely because it is visible in
+        // the output.
+        const inputs = graph.edges.filter((edge) => edge.to === id).map((edge) => edge.from);
+        order.push({ node, inputs });
+        for (const next of outgoing.get(id) ?? []) {
+            const remaining = (indegree.get(next) ?? 0) - 1;
+            indegree.set(next, remaining);
+            if (remaining === 0)
+                ready.push(next);
+        }
+    }
+    return order;
+}
+/**
+ * A stable fingerprint of what a graph *does*.
+ *
+ * Behaviour only: node ids, kinds, the configuration each kind executes on, and
+ * the edges in their order. Names and canvas positions are excluded, so moving a
+ * box or fixing a typo in a label does not bump the version — the same rule
+ * `saveTransform` already applies when it bumps only on a code change, and for
+ * the same reason. A version number inflated by cosmetic edits is useless for
+ * the one question it exists to answer.
+ *
+ * Nodes are sorted by id because their array order changes nothing; edges are
+ * deliberately *not* sorted, because their order decides what a node with
+ * several inputs receives.
+ *
+ * FNV-1a rather than a hash from `node:crypto`: this file is imported by the
+ * browser entry point, and it is change detection rather than a security
+ * primitive — nobody is defending against a chosen-collision attack on their own
+ * canvas. Two passes with different offsets are concatenated, which is enough
+ * spread that an accidental collision between two graphs of one workflow is not
+ * a thing to plan for.
+ */
+function workflowGraphHash(graph) {
+    const nodes = [...graph.nodes]
+        .sort((left, right) => (left.id < right.id ? -1 : left.id > right.id ? 1 : 0))
+        .map((node) => canonicalNode(node));
+    const edges = graph.edges.map((edge) => `${edge.from}>${edge.to}`);
+    const canonical = JSON.stringify({ nodes, edges });
+    return `${fnv1a(canonical, 0x811c9dc5)}${fnv1a(canonical, 0x01000193)}`;
+}
+/** The parts of a node that change what a run produces. */
+function canonicalNode(node) {
+    if (node.kind === 'source') {
+        return JSON.stringify([
+            node.id,
+            node.kind,
+            node.sourceKind,
+            node.connectionId ?? '',
+            node.secretEnvVar ?? '',
+            node.mode ?? 'full',
+            // Sorted keys, so a canvas that rewrites the object in a different order
+            // does not look like an edit.
+            sortedEntries(node.config),
+        ]);
+    }
+    if (node.kind === 'transform') {
+        // The transform's *version* is deliberately not in here. Editing a
+        // transform is already recorded as a new transform version, and folding it
+        // in would bump every graph that references it — which would say the wiring
+        // changed when it did not.
+        return JSON.stringify([node.id, node.kind, node.transformId]);
+    }
+    return JSON.stringify([node.id, node.kind, node.targetType, node.mode ?? 'full']);
+}
+function sortedEntries(config) {
+    return Object.keys(config)
+        .sort()
+        .map((key) => [key, config[key]]);
+}
+function fnv1a(input, offset) {
+    let hash = offset;
+    for (let index = 0; index < input.length; index += 1) {
+        hash ^= input.charCodeAt(index);
+        // The 32-bit FNV prime, by shifts rather than multiplication, so the result
+        // stays inside a 32-bit integer instead of drifting through float precision.
+        hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+        hash >>>= 0;
+    }
+    return hash.toString(16).padStart(8, '0');
+}
+/**
+ * Narrow a stored node, loudly.
+ *
+ * Used when reading a graph back out of a JSON column, and it throws rather than
+ * skipping what it does not recognise for a reason specific to graphs: dropping
+ * an unknown node silently changes what the workflow does — the surrounding
+ * edges then point at nothing, or worse, the graph still validates and simply
+ * omits a step — and a load that quietly ran nine of ten nodes is far harder to
+ * notice than one that refused to start.
+ */
+function isWorkflowNode(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const id = Reflect.get(value, 'id');
+    const name = Reflect.get(value, 'name');
+    const kind = Reflect.get(value, 'kind');
+    if (typeof id !== 'string' || typeof name !== 'string')
+        return false;
+    if (!isWorkflowNodeKind(kind))
+        return false;
+    if (kind === 'transform') {
+        return typeof Reflect.get(value, 'transformId') === 'string';
+    }
+    if (kind === 'sink') {
+        return typeof Reflect.get(value, 'targetType') === 'string';
+    }
+    const sourceKind = Reflect.get(value, 'sourceKind');
+    const config = Reflect.get(value, 'config');
+    return isConnectorKind(sourceKind) && typeof config === 'object' && config !== null;
+}
+function isWorkflowEdge(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    return (typeof Reflect.get(value, 'from') === 'string' && typeof Reflect.get(value, 'to') === 'string');
+}
+/**
+ * Whether this store can hold workflows at all.
+ *
+ * Checks the methods rather than a flag, the same way {@link isPipelineStore}
+ * does, because a flag is a claim and a method is the thing itself.
+ */
+function supportsWorkflows(store) {
+    return (typeof store.listWorkflows === 'function' &&
+        typeof store.getWorkflow === 'function' &&
+        typeof store.saveWorkflow === 'function');
+}
+function supportsWorkflowStages(store) {
+    return typeof store.writeStage === 'function' && typeof store.readStage === 'function';
+}
+exports.CATALOG_PIPELINE_STORE = Symbol('CATALOG_PIPELINE_STORE');
+function isPipelineStore(store) {
+    return (typeof store === 'object' &&
+        store !== null &&
+        typeof Reflect.get(store, 'listConnectors') === 'function');
+}