@dudousxd/nestjs-catalog 0.1.0

package/dist/catalog.workspace.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * The things people make *with* a catalog, as opposed to the model itself:
+ * saved queries, dashboards, and the record of what happened to all of it.
+ *
+ * Kept apart from the store interfaces because these are optional in a
+ * different way. A store that cannot run SQL simply has no saved queries; a
+ * store with no event log still serves every read. A host should be able to
+ * mount the catalog without any of this and notice nothing missing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CATALOG_WORKSPACE_STORE = exports.CATALOG_TRACE_STORE = exports.CATALOG_TRACE_OUTCOMES = void 0;
+exports.isCatalogTraceOutcome = isCatalogTraceOutcome;
+exports.traceOutcomeFilter = traceOutcomeFilter;
+exports.isTraceStore = isTraceStore;
+exports.isWorkspaceStore = isWorkspaceStore;
+/**
+ * The same events, told as stories instead of as a list.
+ *
+ * A flat trail answers "what happened" and is useless for "what happened to
+ * *this load*" — the question anybody actually has when a number looks wrong.
+ * The spine of the answer is already in the data and needed no new plumbing:
+ * a connector run, the snapshot it writes, every batch, the commit and the
+ * finish all carry the same `snapshotId`, and when the durable engine schedules
+ * the run that id *is* the durable run id. So a trace is not something this
+ * library invents; it is the correlation that was always there, grouped.
+ *
+ * What is deliberately *not* here is a parent for events that carry no such id.
+ * A curation edit and a transform change are standalone acts, and the fact that
+ * one happened in the same second as a load is a coincidence, not causality —
+ * attaching them to the nearest run would fabricate a lineage that reads as
+ * evidence. They come back separately, as {@link CatalogTraceList.unlinked}.
+ */
+exports.CATALOG_TRACE_OUTCOMES = [
+    /**
+     * Something claimed to start and has not reported back. Never rendered as a
+     * result: a load still in flight has no rows anybody should be relying on.
+     */
+    'running',
+    /** It reached a terminal event that said so. */
+    'succeeded',
+    /** It reached a terminal event that said it did not. */
+    'failed',
+    /**
+     * It stopped without ever saying how it went — batches written and never
+     * committed, a snapshot dropped, a process that died between the two.
+     *
+     * Its own outcome rather than being folded into "failed" or, far worse, left
+     * to look successful because rows did land. Uncommitted rows are invisible to
+     * readers, so a trace that ends here moved no data at all, and a screen that
+     * showed it in green would be reporting a silent data loss as a good night.
+     */
+    'incomplete',
+];
+/**
+ * Narrows an outcome that arrived as a string — a query parameter, a database
+ * column. Same reason as every other guard in this package: a second
+ * hand-maintained copy of these names is what drifts.
+ */
+function isCatalogTraceOutcome(value) {
+    return exports.CATALOG_TRACE_OUTCOMES.some((outcome) => outcome === value);
+}
+/**
+ * Normalises {@link TraceQuery.outcome} to a list, or `undefined` for no filter.
+ *
+ * Exported so a store and a controller narrow it the same way. The distinction
+ * that has to survive is `undefined` (no filter) versus `[]` (a filter nothing
+ * satisfies), and a store hand-rolling this is one `?? []` away from collapsing
+ * the two.
+ */
+function traceOutcomeFilter(outcome) {
+    if (outcome === undefined)
+        return undefined;
+    return Array.isArray(outcome) ? outcome : [outcome];
+}
+exports.CATALOG_TRACE_STORE = Symbol('CATALOG_TRACE_STORE');
+function isTraceStore(store) {
+    return (typeof store === 'object' &&
+        store !== null &&
+        typeof Reflect.get(store, 'listTraces') === 'function');
+}
+function isWorkspaceStore(store) {
+    return (typeof store === 'object' &&
+        store !== null &&
+        typeof Reflect.get(store, 'listSavedQueries') === 'function');
+}
+exports.CATALOG_WORKSPACE_STORE = Symbol('CATALOG_WORKSPACE_STORE');

package/dist/client.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The browser-facing entry point: `@dudousxd/nestjs-catalog/client`.
+ *
+ * Types and route builders only — nothing here imports NestJS, MikroORM or
+ * anything Node-only, so a browser bundle can take a dependency on it without
+ * pulling the server in.
+ *
+ * This exists so the HTTP surface is genuinely usable by someone writing their
+ * own UI. The endpoints alone are not an API; the endpoints plus the response
+ * types are.
+ */
+export type { AuditQuery, CatalogAuditEvent, Dashboard, DashboardCard, QueryVisualization, SaveQueryInput, SavedQuery, } from './catalog.workspace';
+export type { CatalogQueryRelation, CatalogQueryRequest, CatalogQueryResult, } from './catalog.query';
+export type { CatalogGraph, CatalogObjectPage, CatalogObjectQuery, CatalogObjectTypeDef, CatalogOverlay, CatalogPropertyDef, CatalogRelationDef, CatalogSnapshot, RelationKind, ScalarType, } from './catalog.types';
+/** What a tier-0 edit to a type may change. */
+export interface TypePatch {
+    displayName?: string;
+    pluralDisplayName?: string;
+    description?: string;
+    icon?: string;
+    group?: string;
+    titleProperty?: string;
+}
+/** What a tier-0 edit to a property may change. */
+export interface PropertyPatch {
+    displayName?: string;
+    description?: string;
+    hidden?: boolean;
+    order?: number;
+    classification?: string;
+    unit?: string;
+}
+export interface ObjectQueryParams {
+    page?: number;
+    size?: number;
+    search?: string;
+    sort?: string;
+    dir?: 'asc' | 'desc';
+}
+/**
+ * Builds the paths the catalog controller serves, relative to wherever it was
+ * mounted. Kept as string builders rather than a fetch wrapper so the host
+ * keeps its own HTTP client, interceptors and auth.
+ */
+export declare const catalogRoutes: {
+    readonly snapshot: () => string;
+    readonly graph: () => string;
+    readonly type: (name: string) => string;
+    readonly property: (name: string, property: string) => string;
+    readonly reset: () => string;
+    readonly objects: (name: string) => string;
+    readonly snapshots: (name: string) => string;
+    readonly queryRelations: () => string;
+    readonly query: () => string;
+    readonly workspaceCapabilities: () => string;
+    readonly savedQueries: () => string;
+    readonly savedQuery: (id: string) => string;
+    readonly runSavedQuery: (id: string) => string;
+    readonly exportSavedQuery: (id: string) => string;
+    readonly dashboards: () => string;
+    readonly dashboard: (id: string) => string;
+    readonly events: () => string;
+    readonly traces: () => string;
+    readonly trace: (id: string) => string;
+};
+export type { CatalogConnection, CatalogConnector, ConnectionCheck, CatalogTransform, CatalogWorkflow, CatalogWorkflowCapabilities, ConnectorKind, ConnectorRun, TransformLanguage, TransformResult, WorkflowEdge, WorkflowExecutionMode, WorkflowGraph, WorkflowIssueCode, WorkflowNode, WorkflowNodeKind, WorkflowNodeOutcome, WorkflowSinkNode, WorkflowSourceNode, WorkflowStageRef, WorkflowTransformNode, WorkflowValidationIssue, } from './catalog.pipeline';
+export { CONNECTOR_KINDS, isConnectorKind, isTransformLanguage, isWorkflowEdge, isWorkflowNode, TRANSFORM_LANGUAGES, } from './catalog.pipeline';
+/**
+ * The workflow validator, shipped to the browser deliberately.
+ *
+ * A canvas has to be able to say "this graph has a cycle" while somebody is
+ * drawing it, and the only way for that answer to match what the server will do
+ * is for both to run this function. The alternative — a canvas with its own
+ * copy of the rules — is a canvas that eventually lies: either it refuses
+ * something the server would take, or it accepts something the server rejects
+ * halfway through a load. This is the exception to "types only" on this entry
+ * point, and it is safe to make because these functions are pure and import
+ * nothing.
+ *
+ * `workflowGraphHash` is here for the same reason: a canvas can tell whether
+ * what is on screen still matches the saved version without asking.
+ * `WORKFLOW_NODE_ID_PATTERN` and `WORKFLOW_NODE_KINDS` are what a palette and an
+ * id field should be built from rather than from a second copy that drifts.
+ */
+export { validateWorkflow, WORKFLOW_EXECUTION_MODES, WORKFLOW_ISSUE_CODES, WORKFLOW_NODE_ID_PATTERN, WORKFLOW_NODE_KINDS, workflowGraphHash, workflowRunOrder, isWorkflowExecutionMode, isWorkflowNodeKind, } from './catalog.pipeline';
+export type { CatalogTrace, CatalogTraceList, CatalogTraceOutcome, CatalogTraceSpan, TraceQuery, } from './catalog.workspace';

package/dist/client.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * The browser-facing entry point: `@dudousxd/nestjs-catalog/client`.
+ *
+ * Types and route builders only — nothing here imports NestJS, MikroORM or
+ * anything Node-only, so a browser bundle can take a dependency on it without
+ * pulling the server in.
+ *
+ * This exists so the HTTP surface is genuinely usable by someone writing their
+ * own UI. The endpoints alone are not an API; the endpoints plus the response
+ * types are.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWorkflowNodeKind = exports.isWorkflowExecutionMode = exports.workflowRunOrder = exports.workflowGraphHash = exports.WORKFLOW_NODE_KINDS = exports.WORKFLOW_NODE_ID_PATTERN = exports.WORKFLOW_ISSUE_CODES = exports.WORKFLOW_EXECUTION_MODES = exports.validateWorkflow = exports.TRANSFORM_LANGUAGES = exports.isWorkflowNode = exports.isWorkflowEdge = exports.isTransformLanguage = exports.isConnectorKind = exports.CONNECTOR_KINDS = exports.catalogRoutes = void 0;
+/**
+ * Builds the paths the catalog controller serves, relative to wherever it was
+ * mounted. Kept as string builders rather than a fetch wrapper so the host
+ * keeps its own HTTP client, interceptors and auth.
+ */
+exports.catalogRoutes = {
+    snapshot: () => '/catalog',
+    graph: () => '/catalog/graph',
+    type: (name) => `/catalog/types/${encodeURIComponent(name)}`,
+    property: (name, property) => `/catalog/types/${encodeURIComponent(name)}/properties/${encodeURIComponent(property)}`,
+    reset: () => '/catalog/reset',
+    objects: (name) => `/catalog/objects/${encodeURIComponent(name)}`,
+    snapshots: (name) => `/catalog/objects/${encodeURIComponent(name)}/snapshots`,
+    queryRelations: () => '/catalog/query/relations',
+    query: () => '/catalog/query',
+    workspaceCapabilities: () => '/catalog/workspace/capabilities',
+    savedQueries: () => '/catalog/saved-queries',
+    savedQuery: (id) => `/catalog/saved-queries/${encodeURIComponent(id)}`,
+    runSavedQuery: (id) => `/catalog/saved-queries/${encodeURIComponent(id)}/run`,
+    exportSavedQuery: (id) => `/catalog/saved-queries/${encodeURIComponent(id)}/export.csv`,
+    dashboards: () => '/catalog/dashboards',
+    dashboard: (id) => `/catalog/dashboards/${encodeURIComponent(id)}`,
+    events: () => '/catalog/events',
+    // Grouped into one causal story each, rather than the flat list `events`
+    // returns. Both exist because they answer different questions: "what happened
+    // recently" and "what happened during that load".
+    traces: () => '/catalog/events/traces',
+    trace: (id) => `/catalog/events/traces/${encodeURIComponent(id)}`,
+};
+// Values, not types: a form that offers the kinds should read them from here
+// rather than keeping a copy that drifts.
+var catalog_pipeline_1 = require("./catalog.pipeline");
+Object.defineProperty(exports, "CONNECTOR_KINDS", { enumerable: true, get: function () { return catalog_pipeline_1.CONNECTOR_KINDS; } });
+Object.defineProperty(exports, "isConnectorKind", { enumerable: true, get: function () { return catalog_pipeline_1.isConnectorKind; } });
+Object.defineProperty(exports, "isTransformLanguage", { enumerable: true, get: function () { return catalog_pipeline_1.isTransformLanguage; } });
+// The canvas narrows nodes and edges it reads back from HTTP. Without these
+// it either imports them from the package root — dragging NestJS and MikroORM
+// into a browser bundle — or writes its own copy of the checks, which is the
+// drift this entry point exists to prevent.
+Object.defineProperty(exports, "isWorkflowEdge", { enumerable: true, get: function () { return catalog_pipeline_1.isWorkflowEdge; } });
+Object.defineProperty(exports, "isWorkflowNode", { enumerable: true, get: function () { return catalog_pipeline_1.isWorkflowNode; } });
+Object.defineProperty(exports, "TRANSFORM_LANGUAGES", { enumerable: true, get: function () { return catalog_pipeline_1.TRANSFORM_LANGUAGES; } });
+/**
+ * The workflow validator, shipped to the browser deliberately.
+ *
+ * A canvas has to be able to say "this graph has a cycle" while somebody is
+ * drawing it, and the only way for that answer to match what the server will do
+ * is for both to run this function. The alternative — a canvas with its own
+ * copy of the rules — is a canvas that eventually lies: either it refuses
+ * something the server would take, or it accepts something the server rejects
+ * halfway through a load. This is the exception to "types only" on this entry
+ * point, and it is safe to make because these functions are pure and import
+ * nothing.
+ *
+ * `workflowGraphHash` is here for the same reason: a canvas can tell whether
+ * what is on screen still matches the saved version without asking.
+ * `WORKFLOW_NODE_ID_PATTERN` and `WORKFLOW_NODE_KINDS` are what a palette and an
+ * id field should be built from rather than from a second copy that drifts.
+ */
+var catalog_pipeline_2 = require("./catalog.pipeline");
+Object.defineProperty(exports, "validateWorkflow", { enumerable: true, get: function () { return catalog_pipeline_2.validateWorkflow; } });
+Object.defineProperty(exports, "WORKFLOW_EXECUTION_MODES", { enumerable: true, get: function () { return catalog_pipeline_2.WORKFLOW_EXECUTION_MODES; } });
+Object.defineProperty(exports, "WORKFLOW_ISSUE_CODES", { enumerable: true, get: function () { return catalog_pipeline_2.WORKFLOW_ISSUE_CODES; } });
+Object.defineProperty(exports, "WORKFLOW_NODE_ID_PATTERN", { enumerable: true, get: function () { return catalog_pipeline_2.WORKFLOW_NODE_ID_PATTERN; } });
+Object.defineProperty(exports, "WORKFLOW_NODE_KINDS", { enumerable: true, get: function () { return catalog_pipeline_2.WORKFLOW_NODE_KINDS; } });
+Object.defineProperty(exports, "workflowGraphHash", { enumerable: true, get: function () { return catalog_pipeline_2.workflowGraphHash; } });
+Object.defineProperty(exports, "workflowRunOrder", { enumerable: true, get: function () { return catalog_pipeline_2.workflowRunOrder; } });
+Object.defineProperty(exports, "isWorkflowExecutionMode", { enumerable: true, get: function () { return catalog_pipeline_2.isWorkflowExecutionMode; } });
+Object.defineProperty(exports, "isWorkflowNodeKind", { enumerable: true, get: function () { return catalog_pipeline_2.isWorkflowNodeKind; } });

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { CatalogProperty, type CatalogPropertyOptions, CatalogType, type CatalogTypeOptions, } from './catalog.decorators';
+export { CATALOG_EVENT_PHASE, CATALOG_EVENT_PHASE_FALLBACK, CATALOG_EVENTS, CATALOG_LIB, type CatalogEvent, type CatalogEventPayloads, catalogEventPhase, channelNameFor, emitCatalog, } from './catalog.events';
+export { CatalogModule } from './catalog.module';
+export { assertReadOnlyShape, type CatalogQueryRelation, type CatalogQueryRequest, type CatalogQueryResult, type CatalogQueryStore, isQueryStore, } from './catalog.query';
+export { CATALOG_OPTIONS, type CatalogModuleOptions } from './catalog.options';
+export { type CatalogOverlayStore, FileCatalogOverlayStore, InMemoryCatalogOverlayStore, } from './catalog.overlay-store';
+export { CATALOG_OVERLAY_STORE } from './catalog.overlay-store.token';
+export { MikroOrmCatalogRegistry } from './catalog.registry';
+export { CatalogRegistry } from './catalog.registry.base';
+export { CATALOG_PIPELINE_STORE, type CatalogConnection, type CatalogConnector, type ConnectionCheck, CONNECTOR_KINDS, type CatalogPipelineStore, type CatalogStageStore, type CatalogTransform, type CatalogWorkflow, type CatalogWorkflowCapabilities, type CatalogWorkflowStore, type ConnectorKind, type ConnectorRun, isConnectorKind, isPipelineStore, isTransformLanguage, isWorkflowEdge, isWorkflowExecutionMode, isWorkflowNode, isWorkflowNodeKind, supportsWorkflows, supportsWorkflowStages, TRANSFORM_RUNNER, TRANSFORM_LANGUAGES, type TransformLanguage, type TransformResult, type TransformRunner, validateWorkflow, WORKFLOW_EXECUTION_MODES, WORKFLOW_ISSUE_CODES, WORKFLOW_NODE_ID_PATTERN, WORKFLOW_NODE_KINDS, type WorkflowEdge, type WorkflowExecutionMode, type WorkflowGraph, workflowGraphHash, type WorkflowIssueCode, type WorkflowNode, type WorkflowNodeKind, type WorkflowNodeOutcome, type WorkflowNodeStepInput, type WorkflowNodeStepOutput, workflowRunOrder, type WorkflowSinkNode, type WorkflowSourceNode, type WorkflowStageRef, type WorkflowTransformNode, type WorkflowValidationIssue, } from './catalog.pipeline';
+export * from './catalog.environment';
+export { QueryCache, toCsv } from './catalog.query-cache';
+export { SubprocessTransformRunner, type TransformRunnerOptions, } from './transform-runner';
+export { CatalogService } from './catalog.service';
+export { type AuditQuery, CATALOG_TRACE_OUTCOMES, CATALOG_TRACE_STORE, CATALOG_WORKSPACE_STORE, type CatalogAuditEvent, type CatalogTrace, type CatalogTraceList, type CatalogTraceOutcome, type CatalogTraceSpan, type CatalogTraceStore, type CatalogTraceTotals, type CatalogUnlinkedList, type CatalogWorkspaceStore, type Dashboard, type DashboardCard, isCatalogTraceOutcome, isTraceStore, isWorkspaceStore, type QueryVisualization, type SaveQueryInput, type SavedQuery, type TraceQuery, traceOutcomeFilter, } from './catalog.workspace';
+export { CATALOG_PRINCIPAL_RESOLVER, type CatalogActor, type CatalogGrants, type CatalogPrincipal, type CatalogPrincipalResolver, type CatalogScope, composePrincipalId, delegatePrincipal, expandScopes, hasScope, parsePrincipalId, PRINCIPAL_ACTOR_SEPARATOR, maySeeClassification, mayRead, mayWrite, StaticKeyPrincipalResolver, } from './catalog.principal';
+export { assertNoColumnCollisions, CATALOG_RESERVED_COLUMNS, CATALOG_SNAPSHOT_MODES, CATALOG_STORE, type CarryForwardResult, type CatalogColumnCollision, CatalogColumnCollisionError, type CatalogMergeStore, type CatalogReadQuery, type CatalogReadResult, type CatalogReadStore, type CatalogReservedColumn, type CatalogSnapshotMode, type CatalogStoreCapabilities, type CatalogWriteStore, type ColumnCollisionOptions, findColumnCollisions, isCatalogStoreCapabilities, isReservedColumn, isWriteStore, type SnapshotRef, supportsCarryForward, } from './catalog.store';
+export { MikroOrmReadStore } from './stores/mikro-orm-read.store';
+export type { CatalogGraph, CatalogObjectPage, CatalogObjectQuery, CatalogObjectTypeDef, CatalogOverlay, CatalogPropertyDef, CatalogRelationDef, CatalogSnapshot, RelationKind, ScalarType, } from './catalog.types';

package/dist/index.js

@@ -0,0 +1,109 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CATALOG_PRINCIPAL_RESOLVER = exports.traceOutcomeFilter = exports.isWorkspaceStore = exports.isTraceStore = exports.isCatalogTraceOutcome = exports.CATALOG_WORKSPACE_STORE = exports.CATALOG_TRACE_STORE = exports.CATALOG_TRACE_OUTCOMES = exports.CatalogService = exports.SubprocessTransformRunner = exports.toCsv = exports.QueryCache = exports.workflowRunOrder = exports.workflowGraphHash = exports.WORKFLOW_NODE_KINDS = exports.WORKFLOW_NODE_ID_PATTERN = exports.WORKFLOW_ISSUE_CODES = exports.WORKFLOW_EXECUTION_MODES = exports.validateWorkflow = exports.TRANSFORM_LANGUAGES = exports.TRANSFORM_RUNNER = exports.supportsWorkflowStages = exports.supportsWorkflows = exports.isWorkflowNodeKind = exports.isWorkflowNode = exports.isWorkflowExecutionMode = exports.isWorkflowEdge = exports.isTransformLanguage = exports.isPipelineStore = exports.isConnectorKind = exports.CONNECTOR_KINDS = exports.CATALOG_PIPELINE_STORE = exports.CatalogRegistry = exports.MikroOrmCatalogRegistry = exports.CATALOG_OVERLAY_STORE = exports.InMemoryCatalogOverlayStore = exports.FileCatalogOverlayStore = exports.CATALOG_OPTIONS = exports.isQueryStore = exports.assertReadOnlyShape = exports.CatalogModule = exports.emitCatalog = exports.channelNameFor = exports.catalogEventPhase = exports.CATALOG_LIB = exports.CATALOG_EVENTS = exports.CATALOG_EVENT_PHASE_FALLBACK = exports.CATALOG_EVENT_PHASE = exports.CatalogType = exports.CatalogProperty = void 0;
+exports.MikroOrmReadStore = exports.supportsCarryForward = exports.isWriteStore = exports.isReservedColumn = exports.isCatalogStoreCapabilities = exports.findColumnCollisions = exports.CatalogColumnCollisionError = exports.CATALOG_STORE = exports.CATALOG_SNAPSHOT_MODES = exports.CATALOG_RESERVED_COLUMNS = exports.assertNoColumnCollisions = exports.StaticKeyPrincipalResolver = exports.mayWrite = exports.mayRead = exports.maySeeClassification = exports.PRINCIPAL_ACTOR_SEPARATOR = exports.parsePrincipalId = exports.hasScope = exports.expandScopes = exports.delegatePrincipal = exports.composePrincipalId = void 0;
+var catalog_decorators_1 = require("./catalog.decorators");
+Object.defineProperty(exports, "CatalogProperty", { enumerable: true, get: function () { return catalog_decorators_1.CatalogProperty; } });
+Object.defineProperty(exports, "CatalogType", { enumerable: true, get: function () { return catalog_decorators_1.CatalogType; } });
+var catalog_events_1 = require("./catalog.events");
+Object.defineProperty(exports, "CATALOG_EVENT_PHASE", { enumerable: true, get: function () { return catalog_events_1.CATALOG_EVENT_PHASE; } });
+Object.defineProperty(exports, "CATALOG_EVENT_PHASE_FALLBACK", { enumerable: true, get: function () { return catalog_events_1.CATALOG_EVENT_PHASE_FALLBACK; } });
+Object.defineProperty(exports, "CATALOG_EVENTS", { enumerable: true, get: function () { return catalog_events_1.CATALOG_EVENTS; } });
+Object.defineProperty(exports, "CATALOG_LIB", { enumerable: true, get: function () { return catalog_events_1.CATALOG_LIB; } });
+Object.defineProperty(exports, "catalogEventPhase", { enumerable: true, get: function () { return catalog_events_1.catalogEventPhase; } });
+Object.defineProperty(exports, "channelNameFor", { enumerable: true, get: function () { return catalog_events_1.channelNameFor; } });
+Object.defineProperty(exports, "emitCatalog", { enumerable: true, get: function () { return catalog_events_1.emitCatalog; } });
+var catalog_module_1 = require("./catalog.module");
+Object.defineProperty(exports, "CatalogModule", { enumerable: true, get: function () { return catalog_module_1.CatalogModule; } });
+var catalog_query_1 = require("./catalog.query");
+Object.defineProperty(exports, "assertReadOnlyShape", { enumerable: true, get: function () { return catalog_query_1.assertReadOnlyShape; } });
+Object.defineProperty(exports, "isQueryStore", { enumerable: true, get: function () { return catalog_query_1.isQueryStore; } });
+var catalog_options_1 = require("./catalog.options");
+Object.defineProperty(exports, "CATALOG_OPTIONS", { enumerable: true, get: function () { return catalog_options_1.CATALOG_OPTIONS; } });
+var catalog_overlay_store_1 = require("./catalog.overlay-store");
+Object.defineProperty(exports, "FileCatalogOverlayStore", { enumerable: true, get: function () { return catalog_overlay_store_1.FileCatalogOverlayStore; } });
+Object.defineProperty(exports, "InMemoryCatalogOverlayStore", { enumerable: true, get: function () { return catalog_overlay_store_1.InMemoryCatalogOverlayStore; } });
+var catalog_overlay_store_token_1 = require("./catalog.overlay-store.token");
+Object.defineProperty(exports, "CATALOG_OVERLAY_STORE", { enumerable: true, get: function () { return catalog_overlay_store_token_1.CATALOG_OVERLAY_STORE; } });
+var catalog_registry_1 = require("./catalog.registry");
+Object.defineProperty(exports, "MikroOrmCatalogRegistry", { enumerable: true, get: function () { return catalog_registry_1.MikroOrmCatalogRegistry; } });
+var catalog_registry_base_1 = require("./catalog.registry.base");
+Object.defineProperty(exports, "CatalogRegistry", { enumerable: true, get: function () { return catalog_registry_base_1.CatalogRegistry; } });
+var catalog_pipeline_1 = require("./catalog.pipeline");
+Object.defineProperty(exports, "CATALOG_PIPELINE_STORE", { enumerable: true, get: function () { return catalog_pipeline_1.CATALOG_PIPELINE_STORE; } });
+Object.defineProperty(exports, "CONNECTOR_KINDS", { enumerable: true, get: function () { return catalog_pipeline_1.CONNECTOR_KINDS; } });
+Object.defineProperty(exports, "isConnectorKind", { enumerable: true, get: function () { return catalog_pipeline_1.isConnectorKind; } });
+Object.defineProperty(exports, "isPipelineStore", { enumerable: true, get: function () { return catalog_pipeline_1.isPipelineStore; } });
+Object.defineProperty(exports, "isTransformLanguage", { enumerable: true, get: function () { return catalog_pipeline_1.isTransformLanguage; } });
+Object.defineProperty(exports, "isWorkflowEdge", { enumerable: true, get: function () { return catalog_pipeline_1.isWorkflowEdge; } });
+Object.defineProperty(exports, "isWorkflowExecutionMode", { enumerable: true, get: function () { return catalog_pipeline_1.isWorkflowExecutionMode; } });
+Object.defineProperty(exports, "isWorkflowNode", { enumerable: true, get: function () { return catalog_pipeline_1.isWorkflowNode; } });
+Object.defineProperty(exports, "isWorkflowNodeKind", { enumerable: true, get: function () { return catalog_pipeline_1.isWorkflowNodeKind; } });
+Object.defineProperty(exports, "supportsWorkflows", { enumerable: true, get: function () { return catalog_pipeline_1.supportsWorkflows; } });
+Object.defineProperty(exports, "supportsWorkflowStages", { enumerable: true, get: function () { return catalog_pipeline_1.supportsWorkflowStages; } });
+Object.defineProperty(exports, "TRANSFORM_RUNNER", { enumerable: true, get: function () { return catalog_pipeline_1.TRANSFORM_RUNNER; } });
+Object.defineProperty(exports, "TRANSFORM_LANGUAGES", { enumerable: true, get: function () { return catalog_pipeline_1.TRANSFORM_LANGUAGES; } });
+Object.defineProperty(exports, "validateWorkflow", { enumerable: true, get: function () { return catalog_pipeline_1.validateWorkflow; } });
+Object.defineProperty(exports, "WORKFLOW_EXECUTION_MODES", { enumerable: true, get: function () { return catalog_pipeline_1.WORKFLOW_EXECUTION_MODES; } });
+Object.defineProperty(exports, "WORKFLOW_ISSUE_CODES", { enumerable: true, get: function () { return catalog_pipeline_1.WORKFLOW_ISSUE_CODES; } });
+Object.defineProperty(exports, "WORKFLOW_NODE_ID_PATTERN", { enumerable: true, get: function () { return catalog_pipeline_1.WORKFLOW_NODE_ID_PATTERN; } });
+Object.defineProperty(exports, "WORKFLOW_NODE_KINDS", { enumerable: true, get: function () { return catalog_pipeline_1.WORKFLOW_NODE_KINDS; } });
+Object.defineProperty(exports, "workflowGraphHash", { enumerable: true, get: function () { return catalog_pipeline_1.workflowGraphHash; } });
+Object.defineProperty(exports, "workflowRunOrder", { enumerable: true, get: function () { return catalog_pipeline_1.workflowRunOrder; } });
+// The environment surface: which catalog database a call is served from, and
+// how a connector or a transform is promoted between them.
+__exportStar(require("./catalog.environment"), exports);
+var catalog_query_cache_1 = require("./catalog.query-cache");
+Object.defineProperty(exports, "QueryCache", { enumerable: true, get: function () { return catalog_query_cache_1.QueryCache; } });
+Object.defineProperty(exports, "toCsv", { enumerable: true, get: function () { return catalog_query_cache_1.toCsv; } });
+var transform_runner_1 = require("./transform-runner");
+Object.defineProperty(exports, "SubprocessTransformRunner", { enumerable: true, get: function () { return transform_runner_1.SubprocessTransformRunner; } });
+var catalog_service_1 = require("./catalog.service");
+Object.defineProperty(exports, "CatalogService", { enumerable: true, get: function () { return catalog_service_1.CatalogService; } });
+var catalog_workspace_1 = require("./catalog.workspace");
+Object.defineProperty(exports, "CATALOG_TRACE_OUTCOMES", { enumerable: true, get: function () { return catalog_workspace_1.CATALOG_TRACE_OUTCOMES; } });
+Object.defineProperty(exports, "CATALOG_TRACE_STORE", { enumerable: true, get: function () { return catalog_workspace_1.CATALOG_TRACE_STORE; } });
+Object.defineProperty(exports, "CATALOG_WORKSPACE_STORE", { enumerable: true, get: function () { return catalog_workspace_1.CATALOG_WORKSPACE_STORE; } });
+Object.defineProperty(exports, "isCatalogTraceOutcome", { enumerable: true, get: function () { return catalog_workspace_1.isCatalogTraceOutcome; } });
+Object.defineProperty(exports, "isTraceStore", { enumerable: true, get: function () { return catalog_workspace_1.isTraceStore; } });
+Object.defineProperty(exports, "isWorkspaceStore", { enumerable: true, get: function () { return catalog_workspace_1.isWorkspaceStore; } });
+Object.defineProperty(exports, "traceOutcomeFilter", { enumerable: true, get: function () { return catalog_workspace_1.traceOutcomeFilter; } });
+var catalog_principal_1 = require("./catalog.principal");
+Object.defineProperty(exports, "CATALOG_PRINCIPAL_RESOLVER", { enumerable: true, get: function () { return catalog_principal_1.CATALOG_PRINCIPAL_RESOLVER; } });
+Object.defineProperty(exports, "composePrincipalId", { enumerable: true, get: function () { return catalog_principal_1.composePrincipalId; } });
+Object.defineProperty(exports, "delegatePrincipal", { enumerable: true, get: function () { return catalog_principal_1.delegatePrincipal; } });
+Object.defineProperty(exports, "expandScopes", { enumerable: true, get: function () { return catalog_principal_1.expandScopes; } });
+Object.defineProperty(exports, "hasScope", { enumerable: true, get: function () { return catalog_principal_1.hasScope; } });
+Object.defineProperty(exports, "parsePrincipalId", { enumerable: true, get: function () { return catalog_principal_1.parsePrincipalId; } });
+Object.defineProperty(exports, "PRINCIPAL_ACTOR_SEPARATOR", { enumerable: true, get: function () { return catalog_principal_1.PRINCIPAL_ACTOR_SEPARATOR; } });
+Object.defineProperty(exports, "maySeeClassification", { enumerable: true, get: function () { return catalog_principal_1.maySeeClassification; } });
+Object.defineProperty(exports, "mayRead", { enumerable: true, get: function () { return catalog_principal_1.mayRead; } });
+Object.defineProperty(exports, "mayWrite", { enumerable: true, get: function () { return catalog_principal_1.mayWrite; } });
+Object.defineProperty(exports, "StaticKeyPrincipalResolver", { enumerable: true, get: function () { return catalog_principal_1.StaticKeyPrincipalResolver; } });
+var catalog_store_1 = require("./catalog.store");
+Object.defineProperty(exports, "assertNoColumnCollisions", { enumerable: true, get: function () { return catalog_store_1.assertNoColumnCollisions; } });
+Object.defineProperty(exports, "CATALOG_RESERVED_COLUMNS", { enumerable: true, get: function () { return catalog_store_1.CATALOG_RESERVED_COLUMNS; } });
+Object.defineProperty(exports, "CATALOG_SNAPSHOT_MODES", { enumerable: true, get: function () { return catalog_store_1.CATALOG_SNAPSHOT_MODES; } });
+Object.defineProperty(exports, "CATALOG_STORE", { enumerable: true, get: function () { return catalog_store_1.CATALOG_STORE; } });
+Object.defineProperty(exports, "CatalogColumnCollisionError", { enumerable: true, get: function () { return catalog_store_1.CatalogColumnCollisionError; } });
+Object.defineProperty(exports, "findColumnCollisions", { enumerable: true, get: function () { return catalog_store_1.findColumnCollisions; } });
+Object.defineProperty(exports, "isCatalogStoreCapabilities", { enumerable: true, get: function () { return catalog_store_1.isCatalogStoreCapabilities; } });
+Object.defineProperty(exports, "isReservedColumn", { enumerable: true, get: function () { return catalog_store_1.isReservedColumn; } });
+Object.defineProperty(exports, "isWriteStore", { enumerable: true, get: function () { return catalog_store_1.isWriteStore; } });
+Object.defineProperty(exports, "supportsCarryForward", { enumerable: true, get: function () { return catalog_store_1.supportsCarryForward; } });
+var mikro_orm_read_store_1 = require("./stores/mikro-orm-read.store");
+Object.defineProperty(exports, "MikroOrmReadStore", { enumerable: true, get: function () { return mikro_orm_read_store_1.MikroOrmReadStore; } });

package/dist/stores/mikro-orm-read.store.d.ts

@@ -0,0 +1,20 @@
+import { EntityManager } from '@mikro-orm/core';
+import { MikroOrmCatalogRegistry } from '../catalog.registry';
+import type { CatalogReadQuery, CatalogReadResult, CatalogReadStore, CatalogStoreCapabilities } from '../catalog.store';
+import type { CatalogObjectTypeDef } from '../catalog.types';
+/**
+ * Reads objects straight out of the application's own tables, through the ORM
+ * that already maps them.
+ *
+ * The default store, and the one that needs no infrastructure: there is no copy
+ * to keep in sync and no load to schedule, so the catalog is never stale. The
+ * trade is that there is also no history — the tables hold current state, and
+ * nothing here can show you last Tuesday.
+ */
+export declare class MikroOrmReadStore implements CatalogReadStore {
+    private readonly registry;
+    private readonly em;
+    readonly capabilities: CatalogStoreCapabilities;
+    constructor(registry: MikroOrmCatalogRegistry, em: EntityManager);
+    read(type: CatalogObjectTypeDef, fields: string[], query: CatalogReadQuery): Promise<CatalogReadResult>;
+}

package/dist/stores/mikro-orm-read.store.js

@@ -0,0 +1,120 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MikroOrmReadStore = void 0;
+const core_1 = require("@mikro-orm/core");
+const common_1 = require("@nestjs/common");
+const catalog_registry_1 = require("../catalog.registry");
+/**
+ * Reads objects straight out of the application's own tables, through the ORM
+ * that already maps them.
+ *
+ * The default store, and the one that needs no infrastructure: there is no copy
+ * to keep in sync and no load to schedule, so the catalog is never stale. The
+ * trade is that there is also no history — the tables hold current state, and
+ * nothing here can show you last Tuesday.
+ */
+let MikroOrmReadStore = class MikroOrmReadStore {
+    registry;
+    em;
+    capabilities = {
+        snapshots: 'none',
+        writable: false,
+        timeTravel: false,
+    };
+    constructor(registry, em) {
+        this.registry = registry;
+        this.em = em;
+    }
+    async read(type, fields, query) {
+        const em = this.em.fork();
+        // The constructor, not the name: `EntityName` dropped `string` in MikroORM
+        // 7. The registry only holds classes for types that survived the include /
+        // exclude filter, so an excluded entity cannot be reached by guessing.
+        const entityClass = this.registry.getEntityClass(type.name);
+        if (!entityClass) {
+            throw new common_1.NotFoundException(`Unknown object type: ${type.name}`);
+        }
+        const size = query.size ?? 25;
+        const page = query.page ?? 1;
+        // No explicit type arguments: `findAndCount` declares `Fields extends string
+        // = never`, so naming even one generic makes the rest fall back to their
+        // defaults and types `fields` as `never[]`. Inference gets it right.
+        const [rows, total] = await em.findAndCount(entityClass, buildWhere(type, query.search), {
+            limit: size,
+            offset: (page - 1) * size,
+            orderBy: buildOrderBy(type, query.sort, query.dir),
+            fields,
+        });
+        return {
+            total,
+            rows: rows.map((row) => serialize(row, fields)),
+        };
+    }
+};
+exports.MikroOrmReadStore = MikroOrmReadStore;
+exports.MikroOrmReadStore = MikroOrmReadStore = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [catalog_registry_1.MikroOrmCatalogRegistry,
+        core_1.EntityManager])
+], MikroOrmReadStore);
+/**
+ * Only string columns the catalog says are visible.
+ *
+ * A search that reached a classified column would leak it through row
+ * membership even though the value is never rendered.
+ */
+function buildWhere(type, search) {
+    const term = search?.trim();
+    if (!term)
+        return {};
+    const searchable = type.properties.filter((p) => !p.hidden && p.type === 'string' && !p.classification);
+    if (searchable.length === 0)
+        return {};
+    return { $or: searchable.map((p) => ({ [p.name]: { $like: `%${term}%` } })) };
+}
+/** Only ever a column the catalog vouched for; falls back to the key. */
+function buildOrderBy(type, sort, dir) {
+    const direction = dir === 'desc' ? 'desc' : 'asc';
+    const known = sort ? type.properties.find((p) => p.name === sort && !p.hidden) : undefined;
+    if (known)
+        return { [known.name]: direction };
+    const [pk] = type.primaryKey;
+    return pk ? { [pk]: direction } : {};
+}
+/**
+ * Make one column value safe for `JSON.stringify`.
+ *
+ * BigInt is the case that matters: `JSON.stringify` throws outright on it, so a
+ * single `bigint` column anywhere in a table turns the whole generic read into
+ * a 500. It becomes a string rather than a number on purpose — a value is only
+ * stored as BigInt when it might exceed `Number.MAX_SAFE_INTEGER`, and silently
+ * rounding it would be worse than the type change.
+ */
+function toJsonValue(value) {
+    if (typeof value === 'bigint')
+        return value.toString();
+    if (value instanceof Date)
+        return value.toISOString();
+    if (Buffer.isBuffer(value))
+        return value.toString('base64');
+    return value;
+}
+/** Whitelist by field, so a column the catalog hides can never be returned. */
+function serialize(row, fields) {
+    const out = {};
+    if (!row || typeof row !== 'object')
+        return out;
+    for (const field of fields) {
+        out[field] = toJsonValue(Reflect.get(row, field));
+    }
+    return out;
+}

package/dist/transform-runner.d.ts

@@ -0,0 +1,54 @@
+import type { CatalogTransform, TransformLanguage, TransformResult, TransformRunner } from './catalog.pipeline';
+export interface TransformRunnerOptions {
+    /**
+     * A Python virtualenv whose interpreter runs transforms.
+     *
+     * The supported way to give transforms libraries. PEP 668 stops a service
+     * installing into the system Python, and it is right to: a transform that
+     * can `pip install` is a transform that can change what every other
+     * transform sees. An image provisions a venv, points this at it, and the set
+     * of available libraries becomes a deployment decision with a Dockerfile line
+     * behind it rather than something code negotiates at runtime.
+     */
+    pythonVenv?: string;
+}
+/**
+ * Runs a transform in a child process, with a clock on it.
+ *
+ * **This is not a security boundary.** It stops accidents — an infinite loop, a
+ * runaway allocation, a stray read of `process.env.DATABASE_PASSWORD` — because
+ * the child gets a timeout and an empty environment. It does not stop code
+ * written to escape it: a child process can still open sockets and read the
+ * filesystem as whatever user the service runs as.
+ *
+ * That is a deliberate trade for the case this is built for, where transforms
+ * are written by the same people who already have database access. A catalog
+ * that accepts transforms from anyone else needs a container, gVisor, or a WASM
+ * runtime — and `TransformRunner` is an interface precisely so that swap is a
+ * provider change rather than a rewrite.
+ *
+ * `node:vm` was the other option and is worse on both counts: it is famously
+ * not an isolation boundary either, and it cannot be killed mid-loop.
+ */
+export declare class SubprocessTransformRunner implements TransformRunner {
+    private readonly options;
+    private readonly logger;
+    private pythonPath;
+    private packages;
+    constructor(options?: TransformRunnerOptions);
+    available(): Promise<TransformLanguage[]>;
+    /**
+     * Which Python libraries a transform can import here.
+     *
+     * Reported rather than assumed. "pandas is available" is a property of the
+     * image, and a UI that promises it on an image without it turns a deployment
+     * difference into a runtime traceback the author cannot act on.
+     */
+    pythonPackages(): Promise<string[]>;
+    run(transform: Pick<CatalogTransform, 'language' | 'code'>, records: unknown[], options?: {
+        timeoutMs?: number;
+    }): Promise<TransformResult>;
+    private spawn;
+    /** Cached, including the negative answer — probing on every run is wasteful. */
+    private resolvePython;
+}