@dudousxd/nestjs-catalog 0.12.0 → 0.13.0

package/dist/catalog.events.d.ts

@@ -106,10 +106,17 @@ export interface CatalogEventPayloads {
         snapshotId: string;
     };
     /**
-     * Someone changed a label, description, unit or visibility.
+     * Someone changed a label, description, unit or visibility — or stated how a
+     * type reconciles deletes.
      *
-     * Presentation-only, and emitted anyway: "who renamed this column and when"
-     * is a governance question, and the answer is otherwise nowhere.
+     * Presentation was the whole of it once, and emitted anyway: "who renamed this
+     * column and when" is a governance question whose answer is otherwise nowhere.
+     * Per-type load expectations then arrived on the same event, and a delete
+     * strategy is not presentation — it decides whether an incremental load of the
+     * type may commit at all. `changed` tells the two apart (`expectation.deletes`
+     * and `expectation.cleared` against the field names a rename carries), which is
+     * why widening this event was better than minting a second one nobody's
+     * recorder would have been reading.
      */
     'type.curated': {
         typeName: string;

package/dist/catalog.pipeline.d.ts

@@ -122,6 +122,211 @@ export interface CatalogConnector {
     lastRunAt?: string;
     lastRunStatus?: 'succeeded' | 'failed' | 'running';
 }
+/**
+ * What a load has to be true of before it is allowed to become the data
+ * everybody reads.
+ *
+ * Two failures live here, and they are the same failure seen from two ends: a
+ * load that is *fresh and wrong*. Every signal this catalog publishes about a
+ * type — `lastCommittedAt`, the age badge on the Model screen, a green run in
+ * the runs list — reports on whether a load HAPPENED. None of them reports on
+ * whether what it loaded resembles the dataset it replaced, and a snapshot
+ * commit is atomic, so the moment a wrong load commits it is indistinguishable
+ * from a right one until somebody counts rows by hand.
+ *
+ * - **Deletes.** An incremental connector asks its source for what changed
+ *   since a watermark. A row physically removed from the source never changes
+ *   again, so it is never returned again, so `carryForward` copies it into
+ *   every subsequent snapshot forever. The catalog does not go wrong at any
+ *   point; it simply never finds out. See {@link DeleteReconciliation}.
+ * - **Collapse.** A source-side filter change, a broken `WHERE`, a partial
+ *   outage: the connector returns 12 rows where it returned 40,000, the
+ *   snapshot commits, and the freshness signals all say healthy — correctly,
+ *   because it IS fresh. See {@link RowCountBound}.
+ *
+ * **Why a policy object and not a column on the connector.** Both facts are
+ * statements about a *type*, not about the reader of a source. "It is
+ * acceptable that `Employee` accumulates rows deleted upstream" and "`Employee`
+ * must never lose half its rows in one load" stay true whether the rows arrive
+ * from a connector, from a workflow sink, or from an application POSTing to the
+ * publish API — and all three of those paths end at the same two methods on
+ * `PublishService`, which is where these are enforced. A per-connector field
+ * would have covered one of the three and would have had to be checked in three
+ * places to cover the rest.
+ *
+ * The second reason is who should be able to change it. Accepting that a
+ * dataset silently accumulates deleted rows is not a checkbox decision; it is
+ * the kind of thing that should appear in a diff with a reason attached, which
+ * is why {@link DeleteReconciliation} makes the reason a required field.
+ */
+export interface CatalogLoadExpectations {
+    /** Applied to every type that has no entry of its own. */
+    default?: LoadExpectation;
+    /**
+     * Keyed by object type name. Merged OVER {@link default} field by field, so a
+     * host can set one house-wide row-count bound and still say something about
+     * deletes for the three types that are loaded incrementally.
+     */
+    byType?: Record<string, LoadExpectation>;
+}
+export interface LoadExpectation {
+    /**
+     * How deletions at the source reach this type. **Absent means the load is
+     * refused**, which is the whole mechanism — see {@link
+     * refuseUndeclaredDeletes}.
+     */
+    deletes?: DeleteReconciliation;
+    /**
+     * How far one load may move this type's row count. Merged over
+     * {@link DEFAULT_ROW_COUNT_BOUND}, so a host that only wants to raise
+     * `maxShrink` writes exactly that one field.
+     */
+    rowCount?: Partial<RowCountBound>;
+}
+/**
+ * How a type that is loaded incrementally learns about rows that were deleted.
+ *
+ * Three answers, and the honest thing to say about them up front is that only
+ * one is *policed*. What this file enforces is that somebody chose one and
+ * wrote down why — because the state being prevented is nobody having thought
+ * about it at all, and that state is invisible by construction.
+ *
+ * The fourth answer, tombstones off a change feed, is the correct one and is
+ * deliberately not here. It needs the source to publish a delete stream, the
+ * catalog to hold a delete log per type, and the merge to apply it — which is
+ * a larger machine than the problem justifies today, and adding a strategy name
+ * that nothing implements would be exactly the dropdown-with-a-lie this
+ * codebase refuses everywhere else.
+ */
+export type DeleteReconciliation = 
+/**
+ * Nothing reconciles them, and that is a decision somebody made.
+ *
+ * The legitimate cases are real and common: an append-only ledger where rows
+ * are never removed, a source that only ever soft-retires records by changing
+ * a status the transform can see, or a dataset where a handful of stale rows
+ * is genuinely cheaper than a nightly full read. What is not legitimate is
+ * arriving here by default, which is why {@link because} cannot be omitted.
+ */
+{
+    strategy: 'accepted';
+    because: string;
+}
+/**
+ * The source marks a deletion instead of performing one, and the watermark
+ * therefore sees it — a `deleted_at` that moves, a status column that flips —
+ * so the deleted row arrives as an ordinary change and the transform drops it
+ * or the type keeps it flagged.
+ *
+ * The strongest of the three, and the one that pushes a requirement onto a
+ * source that may refuse it. Not verifiable from here: the catalog cannot
+ * tell a source that soft-deletes from one that claims to, so this is a
+ * declaration like the one above. It is a separate value anyway because the
+ * two say completely different things to the next person who reads the
+ * config, and collapsing them would lose that.
+ */
+ | {
+    strategy: 'soft-deleted-at-source';
+    because: string;
+    column?: string;
+}
+/**
+ * Full reads reconcile, incremental reads fill the gaps between them.
+ *
+ * The interval is the trade-off, and it is stated in time rather than in runs
+ * because "reconciled daily" is what anybody actually means and because the
+ * only thing the catalog can count is the snapshots a store chooses to
+ * report, which is a window of unknown depth. {@link refuseStaleReconciliation}
+ * makes the interval real: once the newest full load of the type is older
+ * than `withinMs`, incremental loads of it stop committing.
+ */
+ | {
+    strategy: 'periodic-full-reload';
+    because: string;
+    withinMs: number;
+};
+/**
+ * How far a single load may move a type's row count before it is refused.
+ *
+ * **Asymmetric on purpose.** A type that doubles has usually had a good day —
+ * a backfill landed, a new base was onboarded, a source finished catching up.
+ * A type that loses 90% has almost never had a good day. Bounding both sides by
+ * the same number would mean picking a growth bound loose enough to be useless
+ * as a shrink bound, or a shrink bound tight enough to refuse every backfill.
+ *
+ * **Conditional on the store, and a host configuring this should know which
+ * condition.** {@link refuseRowCountDrift} is pure and decides on two numbers;
+ * somebody has to fetch them, and both come from members that are optional on
+ * the store interface. Without `currentSnapshot` there is no served baseline;
+ * without `listSnapshots`, or from a `listSnapshots` whose window does not
+ * reach the snapshot about to be committed, there is no count for the pending
+ * one. Either way the bound is not applied to that commit. That is the same
+ * permissive-rather-than-punishing stance {@link CARRIED_FROM_LABEL} takes for
+ * the same reason — an adapter that records less than the bundled one is not
+ * the failure this file exists for — but it means a number written here is a
+ * bound the store has to be able to measure, not one it is guaranteed to have.
+ * `PublishService.assertRowCountIsPlausible` is where that is decided; a skip
+ * that is not said out loud there is a bound believed to be on and off, which
+ * is the one outcome neither this file nor that one may produce.
+ */
+export interface RowCountBound {
+    /**
+     * The largest fraction of the previously served snapshot a load may lose.
+     * `0.5` refuses a load that comes back with less than half of what is live.
+     */
+    maxShrink: number;
+    /**
+     * The ratio above which growth is refused — `10` refuses a load ten times the
+     * size of the previous one. **Absent means growth is never refused**, which is
+     * the default, because the failure this file exists for is collapse and a
+     * growth bound that fires on a legitimate backfill teaches people to raise
+     * every bound in this object until none of them do anything.
+     */
+    maxGrowth?: number;
+    /**
+     * Below this many rows in the previously served snapshot, no ratio applies.
+     *
+     * A percentage of a small number is noise. A four-row lookup table dropping to
+     * one is a 75% collapse and is also a Tuesday, and a bound that fires on it is
+     * a bound somebody switches off — taking the forty-thousand-row types with it.
+     */
+    minRows: number;
+}
+/**
+ * A per-type expectation as an operator set it, with who and when.
+ *
+ * The layer between a host's `byType` entry and its `default`. It exists because
+ * the control the docblocks above argue for was never "it must be in code" —
+ * it is that **somebody chose a strategy and wrote down why**, which needs
+ * attribution and visibility rather than compilation. A host object gives the
+ * reason a place to live and gives attribution to nobody: a `git blame` on a
+ * deployment's wiring names whoever last reformatted the file. So the reason
+ * arrives with the principal that set it and the instant they did, and the
+ * declaration requirement is unchanged — {@link refuseUndeclaredDeletes} asks
+ * the same question of a stored row as it does of a host one.
+ *
+ * The grain is still the type, and only the type. A connector, a workflow sink
+ * and an application POSTing to the publish API all end at the same two
+ * `PublishService` methods and all have the same delete problem, so a per-
+ * connector or per-workflow row would give one dataset several answers to one
+ * question — see {@link CatalogLoadExpectations}, which argues it at length and
+ * is unaffected by this layer existing.
+ *
+ * Both policy fields are optional, and a row may carry either, both or neither:
+ * precedence is resolved field by field, so an operator raising a shrink bound
+ * says nothing about deletes and does not have to.
+ */
+export interface StoredLoadExpectation {
+    typeName: string;
+    deletes?: DeleteReconciliation;
+    rowCount?: Partial<RowCountBound>;
+    /** Principal id of whoever set it. */
+    setBy: string;
+    /** Actor id when a person was behind the principal — the audit's real subject. */
+    setByActor?: string;
+    /** ISO 8601. */
+    setAt: string;
+}
 /**
  * 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
@@ -852,6 +1057,37 @@ export declare function supportsWorkflows(store: CatalogPipelineStore): store is
  */
 export declare function supportsTransformRevisions(store: CatalogPipelineStore): store is CatalogPipelineStore & Required<Pick<CatalogPipelineStore, 'listTransformRevisions'>>;
 export declare function supportsWorkflowStages(store: CatalogPipelineStore): store is CatalogPipelineStore & CatalogStageStore;
+/**
+ * A store that really does hold operator-set expectations, all four members
+ * present.
+ *
+ * Derived from {@link CatalogPipelineStore} rather than declared as a separate
+ * interface the way {@link CatalogWorkflowStore} is, and the difference is not
+ * stylistic: these four are optional members OF the pipeline store, so writing
+ * them out a second time here would be a copy that can drift from the one the
+ * signatures are read from. `CatalogWorkflowStore` predates that lesson and is
+ * mixed in through `Partial<>`, which reaches the same place from the other
+ * side.
+ */
+export type CatalogLoadExpectationStore = Required<Pick<CatalogPipelineStore, 'listLoadExpectations' | 'getLoadExpectation' | 'saveLoadExpectation' | 'clearLoadExpectation'>>;
+/**
+ * Whether an operator can set a load expectation on this deployment at all.
+ *
+ * The methods rather than a flag, the same argument as {@link supportsWorkflows}
+ * — and all four of them by name rather than one standing in for the rest, for
+ * that function's other reason: the write path and the read path are used at
+ * different moments, so a store with the getter and not the setter would narrow
+ * cleanly here and fail on the save, after the screen had already offered an
+ * editor.
+ *
+ * A store that has none of them is not broken and is not second-class. It
+ * behaves exactly as every store did before this existed: the host's
+ * `CATALOG_LOAD_EXPECTATIONS` object is the only layer, which is a complete and
+ * supported answer. What this probe buys is that the console can say "this
+ * deployment's store cannot hold operator-set expectations" instead of offering
+ * 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> {
     listConnectors(): Promise<CatalogConnector[]>;
     getConnector(id: string): Promise<CatalogConnector | undefined>;
@@ -905,6 +1141,53 @@ export interface CatalogPipelineStore extends Partial<CatalogWorkflowStore>, Par
      * that bound costs.
      */
     listTransformRevisions?(id: string): Promise<CatalogRevision[]>;
+    /**
+     * Per-type load expectations as an operator set them.
+     *
+     * **Optional**, and here more deliberately than anywhere else in this
+     * interface. `@dudousxd/nestjs-catalog-store-mikro-orm` is not the only
+     * implementation — a host may have written its own against an earlier shape of
+     * this file — and every one of them satisfies `CatalogPipelineStore` today.
+     * Widening it with four required members would turn all of them into compile
+     * errors for a feature that is purely additive, and, worse, would do it
+     * *silently* to the ones checked structurally: `isPipelineStore` and the
+     * `supports*` probes narrow on methods, so a store that no longer satisfies
+     * the interface is discovered by a caller, at run time, rather than by a build.
+     * {@link supportsLoadExpectations} is how a caller asks, and a store that
+     * implements none of these behaves exactly as it does today — the host's
+     * `CATALOG_LOAD_EXPECTATIONS` object is then the whole policy.
+     *
+     * These hold rows; they do not resolve them. Precedence — a host's `byType`
+     * entry over a stored row over the host's `default`, field by field — is the
+     * pipeline package's business, beside the enforcement functions that consume
+     * it, and it stays pure and synchronous. A store that resolved would be a
+     * second place the precedence is decided, which for a policy whose whole point
+     * is "somebody decided this" is the one duplication that cannot be tolerated.
+     */
+    listLoadExpectations?(): Promise<StoredLoadExpectation[]>;
+    getLoadExpectation?(typeName: string): Promise<StoredLoadExpectation | undefined>;
+    /**
+     * Upsert, keyed by type name, recording the principal and the instant.
+     *
+     * `setBy` and `setByActor` are arguments rather than fields on the
+     * `expectation` for the reason `startRun` records attribution the way it does:
+     * a caller cannot claim them. `setAt` is not an input at all — a stored
+     * timestamp a client could choose is not an audit record.
+     *
+     * `setByActor` is the person behind the principal when there was one. The
+     * write route requires a human, so in practice there always is; it is
+     * separate from `setBy` because a principal is a key and an actor is a
+     * subject, and the trail needs the second to answer "who decided this".
+     */
+    saveLoadExpectation?(typeName: string, expectation: Pick<StoredLoadExpectation, 'deletes' | 'rowCount'>, setBy: string, setByActor?: string): Promise<StoredLoadExpectation>;
+    /**
+     * Drop the stored row for a type. The host's layer is untouched, so a type the
+     * deployment declared in code keeps that declaration.
+     *
+     * `false` means there was nothing stored, which is a fact a caller may report
+     * and never an error.
+     */
+    clearLoadExpectation?(typeName: string): Promise<boolean>;
     startRun(input: {
         connectorId: string;
         snapshotId: string;

package/dist/catalog.pipeline.js

@@ -23,6 +23,7 @@ exports.isWorkflowEdge = isWorkflowEdge;
 exports.supportsWorkflows = supportsWorkflows;
 exports.supportsTransformRevisions = supportsTransformRevisions;
 exports.supportsWorkflowStages = supportsWorkflowStages;
+exports.supportsLoadExpectations = supportsLoadExpectations;
 exports.isPipelineStore = isPipelineStore;
 /**
  * Where a connector pulls from.
@@ -729,6 +730,29 @@ function supportsTransformRevisions(store) {
 function supportsWorkflowStages(store) {
     return typeof store.writeStage === 'function' && typeof store.readStage === 'function';
 }
+/**
+ * Whether an operator can set a load expectation on this deployment at all.
+ *
+ * The methods rather than a flag, the same argument as {@link supportsWorkflows}
+ * — and all four of them by name rather than one standing in for the rest, for
+ * that function's other reason: the write path and the read path are used at
+ * different moments, so a store with the getter and not the setter would narrow
+ * cleanly here and fail on the save, after the screen had already offered an
+ * editor.
+ *
+ * A store that has none of them is not broken and is not second-class. It
+ * behaves exactly as every store did before this existed: the host's
+ * `CATALOG_LOAD_EXPECTATIONS` object is the only layer, which is a complete and
+ * supported answer. What this probe buys is that the console can say "this
+ * deployment's store cannot hold operator-set expectations" instead of offering
+ * an editor whose save has nowhere to go.
+ */
+function supportsLoadExpectations(store) {
+    return (typeof store.listLoadExpectations === 'function' &&
+        typeof store.getLoadExpectation === 'function' &&
+        typeof store.saveLoadExpectation === 'function' &&
+        typeof store.clearLoadExpectation === 'function');
+}
 exports.CATALOG_PIPELINE_STORE = Symbol('CATALOG_PIPELINE_STORE');
 function isPipelineStore(store) {
     return (typeof store === 'object' &&

package/dist/catalog.store.d.ts

@@ -345,6 +345,31 @@ export interface CatalogMergeStore extends CatalogWriteStore {
 export declare const CATALOG_RESERVED_COLUMNS: readonly ["_snapshot_id", "_principal_id", "_loaded_at", "_batch", "_row"];
 export type CatalogReservedColumn = (typeof CATALOG_RESERVED_COLUMNS)[number];
 export declare function isReservedColumn(column: string): boolean;
+/**
+ * Why a name cannot be written into SQL, in the words a publisher is given.
+ *
+ * One class for the whole ecosystem rather than one per adapter, so
+ * `instanceof` is a usable question across packages. The publish-time check in
+ * the pipeline package catches this to tell "that name cannot be an identifier"
+ * from "something else failed inside the store", and with a class per adapter
+ * that check would re-throw the moment the mounted store was not the one it
+ * imported — turning a 400 that names the property into a 500 that names
+ * nothing.
+ */
+export declare class UnsafeIdentifierError extends Error {
+    constructor(value: string);
+}
+/** Whether a name can be written into SQL as it stands. */
+export declare function isSafeIdentifier(value: string): boolean;
+/**
+ * Refuse a name that cannot be a SQL identifier.
+ *
+ * Throws rather than answering, because the caller's next line writes the value
+ * into a statement: a boolean that can be ignored is a boolean that eventually
+ * is. {@link isSafeIdentifier} is there for the callers that are asking rather
+ * than about to build.
+ */
+export declare function assertSafeIdentifier(value: string): void;
 /** One property, and the column it cannot have. */
 export interface CatalogColumnCollision {
     /** `reserved` — it lands on a store column. `shared` — two properties collide. */

package/dist/catalog.store.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CATALOG_STORE = exports.CatalogColumnCollisionError = exports.CATALOG_RESERVED_COLUMNS = exports.CATALOG_SNAPSHOT_MODES = void 0;
+exports.CATALOG_STORE = exports.CatalogColumnCollisionError = exports.UnsafeIdentifierError = exports.CATALOG_RESERVED_COLUMNS = exports.CATALOG_SNAPSHOT_MODES = void 0;
 exports.isCatalogStoreCapabilities = isCatalogStoreCapabilities;
 exports.isReservedColumn = isReservedColumn;
+exports.isSafeIdentifier = isSafeIdentifier;
+exports.assertSafeIdentifier = assertSafeIdentifier;
 exports.findColumnCollisions = findColumnCollisions;
 exports.assertNoColumnCollisions = assertNoColumnCollisions;
 exports.isWriteStore = isWriteStore;
@@ -72,6 +74,73 @@ exports.CATALOG_RESERVED_COLUMNS = [
 function isReservedColumn(column) {
     return exports.CATALOG_RESERVED_COLUMNS.some((reserved) => reserved === column.toLowerCase());
 }
+/**
+ * What a name has to look like before a store will write it into SQL.
+ *
+ * Identifiers are *rejected*, never escaped and never sanitised. Every table
+ * and column name a store emits arrives from another application over HTTP and
+ * ends up in DDL and in SELECT lists, where no placeholder can stand in for it,
+ * so anything outside this character set never becomes SQL at all.
+ *
+ * Here, beside {@link CATALOG_RESERVED_COLUMNS}, for the same reason: it is
+ * part of what the catalog promises a *publisher*. Refuse a property name and
+ * the sentence explaining why is the only statement of the rule most people
+ * will ever read, so it belongs to the contract rather than to whichever
+ * adapter happens to be mounted.
+ *
+ * And for one more reason. It used to be two copies — `store-mikro-orm` and
+ * `store-clickhouse` each carried this pattern and this sentence, byte for
+ * byte — and the publish-time refusal in the pipeline package borrowed the
+ * MySQL one so that publish-time and DDL-time could not disagree about the
+ * character set, the length or the wording. That bought the guarantee for a
+ * MySQL deployment and left a ClickHouse-only one trusting two files to be
+ * edited together. One definition is the guarantee; two identical ones are a
+ * habit.
+ *
+ * 63 characters because it is under MySQL's 64-character ceiling and no engine
+ * a store here targets refuses a name that short, and because the number is
+ * quoted in the refusal below: a per-store limit would mean a publisher being
+ * told a different rule depending on what is mounted, for a name the catalog
+ * would then be unable to promise anything about across a fan-out.
+ *
+ * Not exported. A `RegExp` is mutable and shared state, and the two questions
+ * anyone has of it — "may I?" and "why not?" — are {@link isSafeIdentifier} and
+ * {@link UnsafeIdentifierError}.
+ */
+const SAFE_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]{0,62}$/;
+/**
+ * Why a name cannot be written into SQL, in the words a publisher is given.
+ *
+ * One class for the whole ecosystem rather than one per adapter, so
+ * `instanceof` is a usable question across packages. The publish-time check in
+ * the pipeline package catches this to tell "that name cannot be an identifier"
+ * from "something else failed inside the store", and with a class per adapter
+ * that check would re-throw the moment the mounted store was not the one it
+ * imported — turning a 400 that names the property into a 500 that names
+ * nothing.
+ */
+class UnsafeIdentifierError extends Error {
+    constructor(value) {
+        super(`Refusing to use "${value}" as a SQL identifier: letters, digits and underscore only, starting with a letter or underscore, 63 characters max.`);
+    }
+}
+exports.UnsafeIdentifierError = UnsafeIdentifierError;
+/** Whether a name can be written into SQL as it stands. */
+function isSafeIdentifier(value) {
+    return SAFE_IDENTIFIER.test(value);
+}
+/**
+ * Refuse a name that cannot be a SQL identifier.
+ *
+ * Throws rather than answering, because the caller's next line writes the value
+ * into a statement: a boolean that can be ignored is a boolean that eventually
+ * is. {@link isSafeIdentifier} is there for the callers that are asking rather
+ * than about to build.
+ */
+function assertSafeIdentifier(value) {
+    if (!isSafeIdentifier(value))
+        throw new UnsafeIdentifierError(value);
+}
 /**
  * Every way a type's properties would fight over a physical column.
  *

package/dist/client.d.ts

@@ -9,6 +9,7 @@
  * own UI. The endpoints alone are not an API; the endpoints plus the response
  * types are.
  */
+import type { DeleteReconciliation, LoadExpectation, RowCountBound, StoredLoadExpectation } from './catalog.pipeline';
 export type { AuditQuery, CatalogAuditEvent, CatalogRevision, Dashboard, DashboardCard, QueryVisualization, SaveQueryInput, SavedQuery, } from './catalog.workspace';
 export { CATALOG_REVISION_LIMIT } from './catalog.workspace';
 export type { CatalogQueryRelation, CatalogQueryRequest, CatalogQueryResult, } from './catalog.query';
@@ -106,3 +107,111 @@ export { CONNECTOR_KINDS, isConnectorKind, isTransformLanguage, isWorkflowEdge,
 export { validateWorkflow, WORKFLOW_EXECUTION_MODES, WORKFLOW_ISSUE_CODES, WORKFLOW_NODE_ID_PATTERN, WORKFLOW_NODE_KINDS, WORKFLOW_STATUSES, workflowGraphHash, workflowRunOrder, isWorkflowExecutionMode, isWorkflowNodeKind, isWorkflowStatus, } from './catalog.pipeline';
 export type { WorkflowStatus } from './catalog.pipeline';
 export type { CatalogTrace, CatalogTraceList, CatalogTraceOutcome, CatalogTraceSpan, TraceQuery, } from './catalog.workspace';
+export type { CatalogLoadExpectations, DeleteReconciliation, LoadExpectation, RowCountBound, StoredLoadExpectation, } from './catalog.pipeline';
+/**
+ * The three answers to "how do deletions at the source reach this type", as a
+ * value.
+ *
+ * A list rather than only the union, because the editor on the Model screen has
+ * to offer them and a hand-written array in a component is the copy that drifts
+ * — the same argument {@link CONNECTOR_KINDS} makes one screen over. The server
+ * validates against this too: a `strategy` off the wire is `string` until
+ * something checks it, and the check and the dropdown reading one list is what
+ * stops the two from disagreeing about what is acceptable.
+ *
+ * **There are three and there is deliberately no fourth.** Tombstones off a
+ * change feed is the correct answer and needs machinery nothing here has; a
+ * strategy name that nothing implements is a dropdown with a lie in it. See
+ * `DeleteReconciliation` for the whole argument.
+ */
+export declare const DELETE_RECONCILIATION_STRATEGIES: readonly ["accepted", "soft-deleted-at-source", "periodic-full-reload"];
+export type DeleteReconciliationStrategy = (typeof DELETE_RECONCILIATION_STRATEGIES)[number];
+/** Whether a value off the wire names one of the three. */
+export declare function isDeleteReconciliationStrategy(value: unknown): value is DeleteReconciliationStrategy;
+/**
+ * What an operator sends to set a type's expectation.
+ *
+ * Both fields optional and both meaning "leave this alone" when absent, which is
+ * why they are not simply `LoadExpectation`: a request that omits `rowCount`
+ * has said nothing about row counts, and reading that as "clear it" would let a
+ * form that only renders the delete strategy silently drop a bound somebody set.
+ * Clearing the whole stored row is `DELETE`, which is a decision with a verb on
+ * it.
+ */
+export interface LoadExpectationInput {
+    deletes?: DeleteReconciliation;
+    rowCount?: Partial<RowCountBound>;
+}
+/**
+ * The resolved expectation for one type, and which layer won each field.
+ *
+ * The provenance is the whole reason this is not just a `LoadExpectation`. The
+ * policy is sourced from three layers — `host.byType[type]`, then the stored row
+ * an operator set, then `host.default` — and a screen that showed only the
+ * answer would let somebody edit a field this deployment has pinned in code and
+ * watch the edit vanish on the next read, with nothing anywhere saying why.
+ * {@link hostLocked} is what lets it say "this deployment fixed it" instead.
+ */
+export interface ResolvedLoadExpectation {
+    typeName: string;
+    /** The three layers merged, field by field. What the load is actually judged against. */
+    resolved: LoadExpectation;
+    /**
+     * Which layer supplied the delete strategy.
+     *
+     * `'default'` means the host's house-wide `default` did. `'none'` means
+     * nothing did, anywhere — which is not a gap to be filled in silently: it is
+     * the state that refuses every incremental load of this type, and the one the
+     * screen most needs to name.
+     */
+    deletesFrom: 'host' | 'stored' | 'default' | 'none';
+    /**
+     * Which layer supplied the row-count bound — the strongest one that set any
+     * field of it, since the three are merged key by key rather than replaced
+     * whole.
+     *
+     * There is no `'none'`, and that is a statement rather than an omission: a
+     * bound always applies. Where no layer says anything the built-in
+     * `DEFAULT_ROW_COUNT_BOUND` does, and that is what `'default'` covers as well
+     * as the host's own `default`.
+     */
+    rowCountFrom: 'host' | 'stored' | 'default';
+    /** The operator's row, present whether or not it won anything. */
+    stored?: StoredLoadExpectation;
+    /**
+     * Which fields this deployment declared in code, per field.
+     *
+     * True means a stored value for that field would never apply, so the editor
+     * shows it disabled and says so. Only `host.byType[type]` locks: `host.default`
+     * is the weakest layer and an operator's row beats it, so a house-wide default
+     * is not a lock and must not be drawn as one.
+     */
+    hostLocked: {
+        deletes: boolean;
+        rowCount: boolean;
+    };
+}
+/**
+ * Where the per-type expectations sit, relative to wherever the pipeline
+ * controller was mounted.
+ *
+ * A function of the base path rather than a frozen object like
+ * {@link catalogRoutes}, and the difference is the one `routes.ts` in the React
+ * package draws: the catalog controller's paths cannot move, and these move with
+ * whatever `path` the host passed to `CatalogPipelineModule.forRoot` — the
+ * routes below are `<path>/pipeline/expectations`, and `/pipeline` is only the
+ * default.
+ *
+ * Two builders for four routes: `PUT` and `DELETE` address the same path a `GET`
+ * of one type does, and a builder per verb would be three names for one string.
+ */
+export declare function pipelineExpectationRoutes(basePath?: string): {
+    /** Every stored row, plus the types the host has locked. `GET`, `catalog:read`. */
+    readonly expectations: () => string;
+    /**
+     * One type: `GET` for the resolved expectation and its provenance, `PUT` to
+     * set the stored row, `DELETE` to drop it. The writes need `catalog:curate`
+     * and a signed-in person.
+     */
+    readonly expectation: (typeName: string) => string;
+};

package/dist/client.js

@@ -11,7 +11,9 @@
  * types are.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isWorkflowStatus = exports.isWorkflowNodeKind = exports.isWorkflowExecutionMode = exports.workflowRunOrder = exports.workflowGraphHash = exports.WORKFLOW_STATUSES = 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 = exports.CATALOG_REVISION_LIMIT = void 0;
+exports.DELETE_RECONCILIATION_STRATEGIES = exports.isWorkflowStatus = exports.isWorkflowNodeKind = exports.isWorkflowExecutionMode = exports.workflowRunOrder = exports.workflowGraphHash = exports.WORKFLOW_STATUSES = 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 = exports.CATALOG_REVISION_LIMIT = void 0;
+exports.isDeleteReconciliationStrategy = isDeleteReconciliationStrategy;
+exports.pipelineExpectationRoutes = pipelineExpectationRoutes;
 // A value, not a type: a screen saying how far back the history goes should read
 // the number rather than print one of its own. See its docblock for what the cap
 // costs.
@@ -113,3 +115,56 @@ Object.defineProperty(exports, "workflowRunOrder", { enumerable: true, get: func
 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; } });
 Object.defineProperty(exports, "isWorkflowStatus", { enumerable: true, get: function () { return catalog_pipeline_2.isWorkflowStatus; } });
+/**
+ * The three answers to "how do deletions at the source reach this type", as a
+ * value.
+ *
+ * A list rather than only the union, because the editor on the Model screen has
+ * to offer them and a hand-written array in a component is the copy that drifts
+ * — the same argument {@link CONNECTOR_KINDS} makes one screen over. The server
+ * validates against this too: a `strategy` off the wire is `string` until
+ * something checks it, and the check and the dropdown reading one list is what
+ * stops the two from disagreeing about what is acceptable.
+ *
+ * **There are three and there is deliberately no fourth.** Tombstones off a
+ * change feed is the correct answer and needs machinery nothing here has; a
+ * strategy name that nothing implements is a dropdown with a lie in it. See
+ * `DeleteReconciliation` for the whole argument.
+ */
+exports.DELETE_RECONCILIATION_STRATEGIES = [
+    'accepted',
+    'soft-deleted-at-source',
+    'periodic-full-reload',
+];
+/** Whether a value off the wire names one of the three. */
+function isDeleteReconciliationStrategy(value) {
+    return (typeof value === 'string' &&
+        exports.DELETE_RECONCILIATION_STRATEGIES.includes(value));
+}
+/**
+ * Where the per-type expectations sit, relative to wherever the pipeline
+ * controller was mounted.
+ *
+ * A function of the base path rather than a frozen object like
+ * {@link catalogRoutes}, and the difference is the one `routes.ts` in the React
+ * package draws: the catalog controller's paths cannot move, and these move with
+ * whatever `path` the host passed to `CatalogPipelineModule.forRoot` — the
+ * routes below are `<path>/pipeline/expectations`, and `/pipeline` is only the
+ * default.
+ *
+ * Two builders for four routes: `PUT` and `DELETE` address the same path a `GET`
+ * of one type does, and a builder per verb would be three names for one string.
+ */
+function pipelineExpectationRoutes(basePath = '/pipeline') {
+    const base = basePath.endsWith('/') ? basePath.slice(0, -1) : basePath;
+    return {
+        /** Every stored row, plus the types the host has locked. `GET`, `catalog:read`. */
+        expectations: () => `${base}/expectations`,
+        /**
+         * One type: `GET` for the resolved expectation and its provenance, `PUT` to
+         * set the stored row, `DELETE` to drop it. The writes need `catalog:curate`
+         * and a signed-in person.
+         */
+        expectation: (typeName) => `${base}/expectations/${encodeURIComponent(typeName)}`,
+    };
+}

package/dist/index.d.ts

@@ -8,7 +8,7 @@ export { type CatalogOverlayStore, FileCatalogOverlayStore, InMemoryCatalogOverl
 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, supportsTransformRevisions, isWorkflowEdge, isWorkflowExecutionMode, isWorkflowNode, isWorkflowNodeKind, isWorkflowStatus, 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, WORKFLOW_STATUSES, 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 WorkflowStatus, type WorkflowTransformNode, type WorkflowValidationIssue, } from './catalog.pipeline';
+export { CATALOG_PIPELINE_STORE, type CatalogConnection, type CatalogConnector, type ConnectionCheck, CONNECTOR_KINDS, type CatalogLoadExpectations, type CatalogLoadExpectationStore, type CatalogPipelineStore, type CatalogStageStore, type CatalogTransform, type CatalogWorkflow, type CatalogWorkflowCapabilities, type CatalogWorkflowStore, type ConnectorKind, type ConnectorRun, type DeleteReconciliation, isConnectorKind, isPipelineStore, isTransformLanguage, type LoadExpectation, type RowCountBound, type StoredLoadExpectation, supportsLoadExpectations, supportsTransformRevisions, isWorkflowEdge, isWorkflowExecutionMode, isWorkflowNode, isWorkflowNodeKind, isWorkflowStatus, 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, WORKFLOW_STATUSES, 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 WorkflowStatus, 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';
@@ -18,7 +18,7 @@ export type { CatalogSearchField, CatalogSearchHit, CatalogSearchKind, CatalogSe
 export { type AuditQuery, CATALOG_REVISION_LIMIT, CATALOG_TRACE_OUTCOMES, CATALOG_TRACE_STORE, CATALOG_WORKSPACE_STORE, type CatalogAuditEvent, type CatalogRevision, type CatalogTrace, type CatalogTraceList, type CatalogTraceOutcome, type CatalogTraceSpan, type CatalogTraceStore, type CatalogTraceTotals, type CatalogUnlinkedList, type CatalogWorkspaceStore, type Dashboard, type DashboardCard, type EmbeddedChart, type EmbeddedChartPlacement, type EmbeddedDashboard, embeddedVisualization, isCatalogTraceOutcome, isTraceStore, isWorkspaceStore, type QueryVisualization, type SaveQueryInput, type SavedQuery, supportsSavedQueryRevisions, 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, readableObjectPage, StaticKeyPrincipalResolver, } from './catalog.principal';
 export * from './catalog.access';
-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 { assertNoColumnCollisions, assertSafeIdentifier, 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, isSafeIdentifier, isWriteStore, type SnapshotRef, supportsCarryForward, UnsafeIdentifierError, } 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';
 export { REQUIRED_SCOPES, REQUIRES_HUMAN, RequireHuman, RequireScopes, } from './catalog.route-auth';

package/dist/index.js

@@ -14,8 +14,8 @@ 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.bestMatch = exports.MAX_SEARCH_LIMIT = exports.DEFAULT_SEARCH_LIMIT = exports.CatalogService = exports.SubprocessTransformRunner = exports.toCsv = exports.QueryCache = exports.workflowRunOrder = exports.workflowGraphHash = exports.WORKFLOW_STATUSES = 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.isWorkflowStatus = exports.isWorkflowNodeKind = exports.isWorkflowNode = exports.isWorkflowExecutionMode = exports.isWorkflowEdge = exports.supportsTransformRevisions = 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.curationActor = exports.channelNameFor = exports.catalogEventPhase = exports.UNATTRIBUTED_PRINCIPAL_ID = exports.CATALOG_LIB = exports.CATALOG_EVENTS = exports.CATALOG_EVENT_PHASE_FALLBACK = exports.CATALOG_EVENT_PHASE = exports.CatalogType = exports.CatalogProperty = void 0;
-exports.RequireScopes = exports.RequireHuman = exports.REQUIRES_HUMAN = exports.REQUIRED_SCOPES = 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.readableObjectPage = exports.mayWrite = exports.mayRead = exports.maySeeClassification = exports.PRINCIPAL_ACTOR_SEPARATOR = exports.parsePrincipalId = exports.hasScope = exports.expandScopes = exports.delegatePrincipal = exports.composePrincipalId = exports.CATALOG_PRINCIPAL_RESOLVER = exports.traceOutcomeFilter = exports.supportsSavedQueryRevisions = exports.isWorkspaceStore = exports.isTraceStore = exports.isCatalogTraceOutcome = exports.embeddedVisualization = exports.CATALOG_WORKSPACE_STORE = exports.CATALOG_TRACE_STORE = exports.CATALOG_TRACE_OUTCOMES = exports.CATALOG_REVISION_LIMIT = exports.visibleToPrincipal = exports.searchCatalog = exports.maySearch = exports.emptySearch = void 0;
+exports.MAX_SEARCH_LIMIT = exports.DEFAULT_SEARCH_LIMIT = exports.CatalogService = exports.SubprocessTransformRunner = exports.toCsv = exports.QueryCache = exports.workflowRunOrder = exports.workflowGraphHash = exports.WORKFLOW_STATUSES = 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.isWorkflowStatus = exports.isWorkflowNodeKind = exports.isWorkflowNode = exports.isWorkflowExecutionMode = exports.isWorkflowEdge = exports.supportsTransformRevisions = exports.supportsLoadExpectations = 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.curationActor = exports.channelNameFor = exports.catalogEventPhase = exports.UNATTRIBUTED_PRINCIPAL_ID = exports.CATALOG_LIB = exports.CATALOG_EVENTS = exports.CATALOG_EVENT_PHASE_FALLBACK = exports.CATALOG_EVENT_PHASE = exports.CatalogType = exports.CatalogProperty = void 0;
+exports.RequireScopes = exports.RequireHuman = exports.REQUIRES_HUMAN = exports.REQUIRED_SCOPES = exports.MikroOrmReadStore = exports.UnsafeIdentifierError = exports.supportsCarryForward = exports.isWriteStore = exports.isSafeIdentifier = exports.isReservedColumn = exports.isCatalogStoreCapabilities = exports.findColumnCollisions = exports.CatalogColumnCollisionError = exports.CATALOG_STORE = exports.CATALOG_SNAPSHOT_MODES = exports.CATALOG_RESERVED_COLUMNS = exports.assertSafeIdentifier = exports.assertNoColumnCollisions = exports.StaticKeyPrincipalResolver = exports.readableObjectPage = exports.mayWrite = exports.mayRead = exports.maySeeClassification = exports.PRINCIPAL_ACTOR_SEPARATOR = exports.parsePrincipalId = exports.hasScope = exports.expandScopes = exports.delegatePrincipal = exports.composePrincipalId = exports.CATALOG_PRINCIPAL_RESOLVER = exports.traceOutcomeFilter = exports.supportsSavedQueryRevisions = exports.isWorkspaceStore = exports.isTraceStore = exports.isCatalogTraceOutcome = exports.embeddedVisualization = exports.CATALOG_WORKSPACE_STORE = exports.CATALOG_TRACE_STORE = exports.CATALOG_TRACE_OUTCOMES = exports.CATALOG_REVISION_LIMIT = exports.visibleToPrincipal = exports.searchCatalog = exports.maySearch = exports.emptySearch = exports.bestMatch = 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; } });
@@ -59,6 +59,7 @@ Object.defineProperty(exports, "CONNECTOR_KINDS", { enumerable: true, get: funct
 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, "supportsLoadExpectations", { enumerable: true, get: function () { return catalog_pipeline_1.supportsLoadExpectations; } });
 Object.defineProperty(exports, "supportsTransformRevisions", { enumerable: true, get: function () { return catalog_pipeline_1.supportsTransformRevisions; } });
 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; } });
@@ -133,6 +134,7 @@ Object.defineProperty(exports, "StaticKeyPrincipalResolver", { enumerable: true,
 __exportStar(require("./catalog.access"), exports);
 var catalog_store_1 = require("./catalog.store");
 Object.defineProperty(exports, "assertNoColumnCollisions", { enumerable: true, get: function () { return catalog_store_1.assertNoColumnCollisions; } });
+Object.defineProperty(exports, "assertSafeIdentifier", { enumerable: true, get: function () { return catalog_store_1.assertSafeIdentifier; } });
 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; } });
@@ -140,8 +142,10 @@ Object.defineProperty(exports, "CatalogColumnCollisionError", { enumerable: true
 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, "isSafeIdentifier", { enumerable: true, get: function () { return catalog_store_1.isSafeIdentifier; } });
 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; } });
+Object.defineProperty(exports, "UnsafeIdentifierError", { enumerable: true, get: function () { return catalog_store_1.UnsafeIdentifierError; } });
 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; } });
 var catalog_route_auth_1 = require("./catalog.route-auth");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dudousxd/nestjs-catalog",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "A metadata registry for NestJS: object types, properties and relations, derived from your ORM and enriched with decorators.",
   "license": "MIT",
   "author": "Davide Carvalho",