@memberjunction/materialization 0.0.0 → 6.1.0-edge.4

package/dist/MaterializationRefresher.d.ts

@@ -0,0 +1,621 @@
+import { IMetadataProvider, UserInfo, EntityInfo } from '@memberjunction/core';
+import { MJMaterializedResultEntity } from '@memberjunction/core-entities';
+/**
+ * Synthetic surrogate key column name for query-materialized tables. MUST match CodeGenLib's
+ * `MATERIALIZATION_SURROGATE_COLUMN` (materializationAnalysis.ts) — CodeGen creates the column with
+ * this name and the refresher must regenerate it on every rebuild. (A shared low-level home for this
+ * constant is a follow-up; duplicated deliberately to avoid a runtime dependency on the dev-time CodeGenLib.)
+ */
+export declare const MATERIALIZATION_SURROGATE_COLUMN = "__mj_MaterializedRowID";
+/**
+ * Force a full rebuild after this many consecutive incremental (Incremental/DirtyGroupRecompute)
+ * refreshes. The incremental delete-detection guard only trips on a NET source row-count drop; a
+ * delete BALANCED by an insert in the same window (net-zero change) leaves the deleted row's group
+ * stale until another change touches it. This periodic full rebuild bounds that drift to at most
+ * this many refresh cycles without requiring the author to schedule a manual FullRebuild.
+ */
+export declare const FULL_REBUILD_EVERY_N_INCREMENTAL_REFRESHES = 10;
+/**
+ * Safety lag subtracted from the probed `MAX(__mj_UpdatedAt)` before it is persisted as the incremental
+ * watermark. Closes a commit-ordering skew: a source row whose `__mj_UpdatedAt` was stamped at write-time T1
+ * but whose transaction COMMITS after the fingerprint probe (which already read a higher `MAX = T2 > T1`) would,
+ * without this lag, be permanently excluded by the strict `__mj_UpdatedAt > watermark` filter on the next pass.
+ * Storing `MAX - overlap` makes the next incremental RE-scan the last `overlap` window; the MERGE/`ON CONFLICT`
+ * upsert is idempotent so re-scanning already-applied rows is harmless. The overlap only needs to exceed the
+ * source's typical commit latency — longer skews are still backstopped by {@link FULL_REBUILD_EVERY_N_INCREMENTAL_REFRESHES}.
+ */
+export declare const WATERMARK_SAFETY_OVERLAP_MS = 10000;
+/**
+ * Minimal structural type for a runtime SQL-executing provider. Both SQLServerDataProvider and
+ * PostgreSQLDataProvider expose `ExecuteSQL`; we depend on the shape, not the concrete class, to
+ * avoid coupling this engine to a specific provider package.
+ */
+export interface ISQLExecutor {
+    /**
+     * Execute SQL, optionally with positional bind parameters. `parameters` is a positional array bound
+     * as `@p0,@p1,…` on SQL Server (`request.input('p'+i)`) and `$1,$2,…` on PostgreSQL (node-pg values) —
+     * both MJ data providers accept this shape. Omit it for plain (DDL / no-value) statements.
+     */
+    ExecuteSQL<T = unknown>(sql: string, parameters?: unknown): Promise<T[]>;
+    /** Database platform of the executing provider ('sqlserver' | 'postgresql'); absent => treated as SQL Server. */
+    PlatformKey?: string;
+}
+/** Outcome of refreshing a single materialized result. */
+export interface MaterializationRefreshResult {
+    Success: boolean;
+    RowCount?: number;
+    ErrorMessage?: string;
+}
+/**
+ * Runtime engine that refreshes materialized query/entity results (materialization plan §11).
+ *
+ * v1: **full rebuild** with an **atomic wrapper-view swap** — build a shadow table from the source,
+ * repoint the stable wrapper view at it, then drop the stale table and rename the shadow into the
+ * canonical name. Readers (via the wrapper view) never see a half-populated or locked result.
+ * Cross-engine: SQL Server and PostgreSQL — the swap statements differ per engine (see the two
+ * `buildFullRebuild*` methods), selected at runtime from the provider's `PlatformKey`.
+ *
+ * Invoked by the scheduled-job refresh driver, and reusable by a manual "refresh now" path.
+ */
+export declare class MaterializationRefresher {
+    /**
+     * Forced-full-rebuild cadence decision: should this refresh be forced to a full rebuild? True once the
+     * count of consecutive incremental refreshes since the last full rebuild has reached
+     * {@link FULL_REBUILD_EVERY_N_INCREMENTAL_REFRESHES}. Pure (no IO) so the cadence boundary is
+     * unit-testable without a provider/DB. Null-safe: an unset counter is treated as 0.
+     */
+    static shouldForceFullRebuild(refreshesSinceFullRebuild: number | null | undefined): boolean;
+    /**
+     * Forced-full-rebuild cadence counter transition. Increments on a genuine incremental refresh; resets to
+     * 0 on any full rebuild — so the counter measures how many refreshes we've gone WITHOUT a full reconcile.
+     * Pure (no IO) so the increment/reset semantics are unit-testable. Null-safe: an unset counter is 0.
+     */
+    static nextRefreshesSinceFullRebuild(current: number | null | undefined, ranIncremental: boolean): number;
+    /** A plain, unquoted SQL identifier: leading letter/underscore, then letters/digits/underscores. */
+    private static readonly SAFE_SQL_IDENTIFIER;
+    /** Cached API-key row-filter targets for this refresher; `null` = not yet enumerated (see
+     *  {@link loadAPIKeyRowFilterTargets}). `'unknown'` is a LOADED state meaning "assume restricted". */
+    private _apiKeyRowFilterTargets;
+    /**
+     * Guards the schema/table/view identifiers that get interpolated into materialization DDL/DML — names
+     * read from the *writable* `MJ: Materialized Results` metadata row. A materialization's names are always
+     * CodeName-derived (`materialized_<CodeName>`, schema `__mj`), so a legitimate row always passes. The
+     * assertion exists so a tampered metadata row can never drive the privileged refresh job's
+     * `EXEC(...)` / `sp_rename` / `CREATE VIEW` / `RENAME TO` statements to run arbitrary DDL: a value that
+     * matches {@link SAFE_SQL_IDENTIFIER} cannot contain `]`, `"`, or `'`, so this one check closes BOTH the
+     * identifier-quoting and the T-SQL string-literal injection surfaces the swap builders would otherwise
+     * expose. Fails closed — throws (→ the refresh is reported as failed) rather than emitting a suspect
+     * statement. This is the refresh-path complement to the mint-path dialect quoting.
+     */
+    private static assertSafeObjectNames;
+    /**
+     * Non-throwing form of the identifier check. Needed by callers on the FAILURE path, which is precisely
+     * where {@link assertSafeObjectNames} may have just thrown — those callers must be able to re-check and
+     * decline quietly rather than re-enter (or bypass) the assertion that already rejected the value.
+     * @internal exposed for unit testing; not part of the supported surface.
+     */
+    static isSafeObjectName(value: string): boolean;
+    /**
+     * Resolves the SQL that the READ path would execute for `queryId` on the engine we are refreshing against,
+     * so the snapshot is built from the same statement live serves. Mirrors the read path's
+     * `QueryInfo.GetPlatformSQL(PlatformKey)`, whose precedence is: `MJ: Query SQLs` child row for the platform
+     * → legacy PlatformVariants → base SQL.
+     *
+     * `GetPlatformSQL` lives on the metadata `QueryInfo`, not on the generated `MJQueryEntity`, so the variant
+     * is resolved through the provider's query metadata. Falls back to the entity's own SQL when the query
+     * isn't present in that metadata (e.g. a provider whose cache hasn't loaded it), which reproduces exactly
+     * the previous behavior rather than failing the refresh.
+     *
+     * @returns the platform-resolved SQL, or null when neither source yields a non-empty statement.
+     * @internal exposed for unit testing; not part of the supported surface.
+     */
+    static resolvePlatformQuerySQL(provider: IMetadataProvider, queryId: string, entitySql: string | null, isPostgres: boolean): string | null;
+    /**
+     * Builds the ordered SQL statements for a SQL Server full rebuild with atomic swap (plan §11.2).
+     * Pure (no IO) so the swap sequence is unit-testable. Each returned string runs as its own batch.
+     *
+     * - query case (`surrogateColumn` set): the synthetic IDENTITY surrogate is (re)generated via
+     *   `SELECT IDENTITY(int,1,1) AS <surrogate>, src.* INTO <shadow>`;
+     * - base-view case (no surrogate): `SELECT * INTO <shadow>` copies the source shape (incl. its PK column).
+     */
+    static buildFullRebuildStatementsSQLServer(opts: {
+        schema: string;
+        tableName: string;
+        viewName: string;
+        sourceSelect: string;
+        surrogateColumn?: string;
+        hashKeyColumns?: {
+            name: string;
+            type: string;
+        }[];
+        /** Run-unique shadow table name (see {@link makeShadowTableName}) so two concurrent refreshes of the
+         *  same materialization never share a shadow. Defaults to the legacy fixed name when omitted. */
+        shadowName?: string;
+    }): string[];
+    /**
+     * Builds the ordered SQL statements for a PostgreSQL full rebuild with atomic swap (plan §11.2) —
+     * the PG counterpart to {@link buildFullRebuildStatementsSQLServer}. Pure (no IO), unit-testable.
+     *
+     * Engine differences vs. SQL Server:
+     * - **Identifier quoting:** schema bare, object double-quoted (`__mj."materialized_x"`), matching the
+     *   CodeGen provider's `QuoteSchema` convention so the view repoint references the same names.
+     * - **Surrogate (query case):** the synthetic surrogate is generated **as the first column** via
+     *   `ROW_NUMBER() OVER ()` (a stable 1..N snapshot id; deterministic hashing is §5/Phase 3). It MUST
+     *   be first because CodeGen prepends the surrogate, and PG's `CREATE OR REPLACE VIEW` is strict about
+     *   column order (SQLSTATE 42P16) — an appended surrogate would break the repoint.
+     * - **Swap:** `CREATE OR REPLACE VIEW` (not `CREATE OR ALTER`), `ALTER TABLE ... RENAME TO` (not
+     *   `sp_rename`), and `DROP TABLE IF EXISTS ... CASCADE` (PG blocks dropping a table a view depends on;
+     *   CASCADE clears a transient wrapper-view dependency from a partially-failed prior run — the view is
+     *   recreated within this sequence, so the stable contract is restored before the method returns).
+     */
+    static buildFullRebuildStatementsPostgreSQL(opts: {
+        schema: string;
+        tableName: string;
+        viewName: string;
+        sourceSelect: string;
+        surrogateColumn?: string;
+        hashKeyColumns?: {
+            name: string;
+            type: string;
+        }[];
+        /** Run-unique shadow table name (see {@link makeShadowTableName}) so two concurrent refreshes of the
+         *  same materialization never share a shadow. Defaults to the legacy fixed name when omitted. */
+        shadowName?: string;
+    }): string[];
+    /**
+     * Selects the materializations due for refresh: those with no `NextRefreshAt` (never run) or whose
+     * `NextRefreshAt` is at/before `now`. Pure (unit-testable); the caller supplies the candidate rows
+     * (e.g. all non-disabled, scheduled materializations).
+     */
+    static filterDue<T extends {
+        NextRefreshAt?: Date | null;
+    }>(rows: T[], now: Date): T[];
+    /**
+     * Full-rebuild refresh of a single materialized result, then updates LastRefreshedAt / RowCount /
+     * Status='Active' (and `NextRefreshAt` when provided via options). Returns a structured result
+     * rather than throwing (errors are logged + reported).
+     */
+    RefreshOne(matResult: MJMaterializedResultEntity, contextUser: UserInfo, provider: IMetadataProvider, options?: {
+        nextRefreshAt?: Date | null;
+    }): Promise<MaterializationRefreshResult>;
+    /**
+     * Drops a run's shadow table if it exists, swallowing any error (used only on the RefreshOne failure path so
+     * a crashed/failed rebuild leaves no orphan). Uses IF EXISTS so it's a no-op when the shadow was never
+     * created or was already renamed into the canonical table on success.
+     */
+    /**
+     * Restores `XACT_ABORT` to the connection default after a failed refresh, swallowing any error. SQL Server
+     * only — PostgreSQL has no equivalent session setting, so this is a no-op there. Needed because a batch
+     * that aborts mid-swap never reaches the trailing `SET XACT_ABORT OFF` in its own statement list.
+     */
+    private resetXactAbortBestEffort;
+    private dropShadowTableBestEffort;
+    /**
+     * Common failure exit for RefreshOne. Advances `NextRefreshAt` so a persistently-failing materialization
+     * backs off to its configured cadence instead of being retried on every sweep (the driver's filterDue
+     * treats an unchanged past/null NextRefreshAt as still-due — an unbounded rebuild/read storm against the
+     * source DB). Called only from PRE-SUCCESS failure paths: thrown errors caught in RefreshOne AND the
+     * returned {Success:false} paths for external-entity/query read failure and unresolvable source. (The
+     * post-success Save-failure path deliberately does NOT use this — see the comment there — because matResult
+     * would carry the full success state and re-Saving it would contradict the reported failure.)
+     *
+     * Only NextRefreshAt is written, via the SAME guarded conditional UPDATE the success path uses
+     * (`WHERE Status NOT IN ('DriftHold','Disabled')`) — so a concurrent hold/disable is genuinely never
+     * clobbered. (BaseEntity.Save could NOT guarantee this: its spUpdate binds every field with ISNULL + a
+     * PK-only WHERE, so the stale in-memory Status='Active' would have overwritten a concurrent hold even though
+     * this method never assigns Status — the previous "not dirtying Status keeps it safe" reasoning was wrong.)
+     * Best-effort and non-throwing: an update failure is logged, not thrown (the next sweep re-attempts). No-op
+     * when the caller supplied no schedule (a manual "refresh now" with no options).
+     */
+    private failRefresh;
+    /** Core-schema reference for the `MJ: Materialized Results` metadata table. NOT `matResult.SchemaName` —
+     *  that is the SNAPSHOT table's schema, which differs for a base-view materialization of a non-core entity.
+     *  The metadata row lives where the entity is defined (`__mj`), read from the entity metadata. */
+    private materializedResultTableRef;
+    /** Persists the terminal SUCCESS state (Status='Active' + LastRefreshedAt/RowCount/Watermark/SourceRowCount/
+     *  RefreshesSinceFullRebuild [+ NextRefreshAt]) via {@link execGuardedMaterializedResultUpdate}. Reads the
+     *  values from `matResult` (RefreshOne has already assigned them in-memory). Returns false when the row was
+     *  concurrently held/disabled (the UPDATE matched 0 rows). */
+    private persistTerminalStateGuarded;
+    /** Runs an UPDATE against the MaterializedResult metadata row guarded by `Status NOT IN ('DriftHold',
+     *  'Disabled')` — the atomic primitive that makes a status/state write unable to clobber a concurrently-set
+     *  hold. Returns true iff exactly the target row was updated (i.e. it was still Active). The affected count is
+     *  read back cross-engine: SQL Server via `@@ROWCOUNT`, PostgreSQL via a `RETURNING`-counting CTE. `matResult.ID`
+     *  is a trusted entity PK (UUID), interpolated the same way the refresher interpolates its other metadata. */
+    private execGuardedMaterializedResultUpdate;
+    /**
+     * Phase 3/4: attempt an incremental in-place refresh of a keyed aggregation, recomputing only the
+     * groups whose source rows changed since the watermark. Two strategies share ALL eligibility/guard
+     * logic and differ only in how the recomputed groups are applied:
+     *   - `DirtyGroupRecompute` (Phase 3) — DELETE the dirty groups then INSERT their fresh values;
+     *   - `Incremental` (Phase 4) — UPSERT (MERGE / INSERT…ON CONFLICT) the fresh values onto the
+     *     surrogate key, updating a surviving group's row in place (no churn). CodeGen assigns this to
+     *     keyed single-source ADDITIVE aggregations.
+     * Returns `{handled:true}` when it ran; `{handled:false}` (caller then full-rebuilds) on any
+     * ineligibility OR a tripped guard. Guards (conservative — §10 refuse-under-uncertainty):
+     *  - opt-in strategy for a keyed Query aggregation with a surrogate;
+     *  - a watermark baseline must exist (first run full-rebuilds to establish it);
+     *  - the source must be a SINGLE table exposing `__mj_UpdatedAt` and all key columns;
+     *  - the current source row count must not be LOWER than the last (a net decrease = deletes → full
+     *    rebuild self-heals).
+     * On success it advances the watermark + source-count on `matResult` (persisted by the caller's Save).
+     */
+    private tryRefreshIncremental;
+    /**
+     * Phase 3: compute a Query materialization's source fingerprint (watermark = MAX(__mj_UpdatedAt) + source
+     * row count) so a subsequent DirtyGroupRecompute pass has a baseline. Returns null — meaning no baseline,
+     * so the materialization keeps full-rebuilding (correct by construction) — unless the source is a single
+     * table exposing `__mj_UpdatedAt`. PURE w.r.t. matResult: it does NOT mutate the entity; the caller applies
+     * the returned fingerprint ONLY on the success path, so a failed rebuild never advances the persisted
+     * watermark past data it didn't actually materialize.
+     */
+    private computeSourceFingerprint;
+    /** Extracts the single source table of an aggregation SELECT, or null if it isn't exactly one table. */
+    private resolveSingleSourceTable;
+    /** Column names of a table (ordinal order) via INFORMATION_SCHEMA (identical query on both engines). */
+    private getTableColumns;
+    /**
+     * True only if (schema, table) is a BASE TABLE (not a view) per INFORMATION_SCHEMA.TABLES — used to gate
+     * incremental eligibility, since a watermark is only meaningful on a real table whose `__mj_UpdatedAt` tracks
+     * its own row changes. `TABLE_TYPE = 'BASE TABLE'` is standard on both SQL Server and PostgreSQL. Returns
+     * false when the object isn't found (fail-safe → no incremental).
+     */
+    private sourceIsBaseTable;
+    /**
+     * Probes the source fingerprint used for incremental refresh: MAX(__mj_UpdatedAt) + COUNT(*).
+     *
+     * PRECISION SAFETY: the source column is datetimeoffset (100ns) but JS Date is millisecond-precision, so
+     * `new Date(w)` TRUNCATES the sub-millisecond part — and per the ECMAScript spec Date always truncates
+     * toward the past, never rounds up. That direction is the safe one: the strict incremental filter
+     * `__mj_UpdatedAt > watermark` then treats the exact boundary row (the row whose timestamp WAS the max) as
+     * still `>` the truncated watermark, so it is harmlessly RE-processed next pass (recompute is idempotent)
+     * rather than skipped. A round-UP would be the dangerous case (permanently excluding that row) — which
+     * cannot happen with Date truncation.
+     */
+    private probeSourceFingerprint;
+    /** Counts the rows currently in the materialized wrapper view. */
+    private countMaterialized;
+    /** A SQL datetime literal (ISO-8601 UTC) parsed by both SQL Server and PostgreSQL. */
+    static sqlDateTimeLiteral(date: Date): string;
+    /**
+     * A globally-unique, length-safe shadow-table name for one refresh run. Deliberately NOT derived from the
+     * materialized table name: two refreshes of the SAME materialization (a manual "refresh now" racing the
+     * scheduled sweep, or overlapping sweeps under `ConcurrencyMode=Concurrent`) must not share a shadow, or one
+     * run's `DROP TABLE …__shadow` would yank the table the other is mid-build. A fixed short prefix + a random
+     * token keeps it well under both engines' identifier limits (PG 63 / SQL Server 128) regardless of how long
+     * the canonical table name is. The shadow is renamed INTO the canonical name on success (so it leaves no
+     * residue), and dropped by RefreshOne's failure cleanup on a caught error; only a hard process crash between
+     * shadow creation and swap can leak one — a harmless orphan table with no dependents.
+     */
+    static makeShadowTableName(): string;
+    /**
+     * Applies the incremental-watermark safety overlap: returns `rawMax - WATERMARK_SAFETY_OVERLAP_MS` (null
+     * passes through). Persisting the reduced value makes the next incremental pass RE-scan the last `overlap`
+     * window, so a source row whose transaction commits after the fingerprint probe — but whose `__mj_UpdatedAt`
+     * predates the probed MAX — is re-processed (idempotent MERGE) instead of being skipped forever. Pure and
+     * unit-testable; extracted from probeSourceFingerprint so the skew-safety math is verifiable in isolation.
+     */
+    static applyWatermarkSafetyOverlap(rawMax: Date | null): Date | null;
+    /**
+     * True if an entity is read-RLS-protected — any of its role permissions carries a non-empty `ReadRLSFilterID`.
+     * Matches CodeGenLib's `entityHasRowLevelSecurity` (and MJ's `GetUserRowLevelSecurityWhereClause`, which
+     * sources the read filter solely from `EntityPermission.ReadRLSFilterID`). Used by the runtime leak gate to
+     * refuse refreshing a local mirror of an EXTERNAL RLS-protected entity — a mirror can't reproduce remote RLS.
+     */
+    static entityHasReadRLS(entity: EntityInfo): boolean;
+    /**
+     * The composite row-restriction test the Leak-1 gate uses: role RLS **or** an API-key row filter.
+     *
+     * {@link entityHasReadRLS} covers only the ROLE layer. `EntityInfo`'s equivalent role-only accessor is
+     * deprecated precisely because it omits API-key row filters, so a gate built on it alone judges an
+     * entity fenced only by a key filter to be unrestricted. CodeGen's mint and drift gates compose both
+     * layers; this is the runtime half, kept deliberately symmetric with them.
+     *
+     * @param apiKeyRowFilterTargets lowercased entity names carrying an API-key row filter, or `'unknown'`
+     *        when that layer could not be enumerated — in which case every entity is treated as restricted,
+     *        because refusing to refresh is recoverable and mirroring restricted rows is not.
+     */
+    static entityHasRowLevelRestriction(entity: EntityInfo, apiKeyRowFilterTargets: ReadonlySet<string> | 'unknown'): boolean;
+    /**
+     * Enumerates the entities carrying an API-key row filter, cached for this refresher's lifetime (the gate
+     * runs per materialization; the fence changes far more slowly than a sweep).
+     *
+     * Mirrors CodeGen's enumeration contract exactly, because it shares the rule rather than restating it:
+     * entity NAMES normalized by {@link ResolveSingleEntityResourceTarget}, taken from the `ResourcePattern`
+     * of scope rows that carry a `RowFilterID`. A pattern that function cannot resolve to one exact entity
+     * collapses the WHOLE set to `'unknown'`, since a rule we cannot map may well name the entity we are
+     * about to mirror. Any read failure does the same.
+     */
+    private loadAPIKeyRowFilterTargets;
+    /**
+     * Resolves the source SELECT a refresh rebuilds from: the source entity's base view (base-view case)
+     * or the stored Query's SQL (query case). Returns null when the source can't be resolved.
+     */
+    private resolveSourceSelect;
+    /**
+     * Remove a TOP-LEVEL ORDER BY from a source SELECT so it can be wrapped in a derived table for the rebuild.
+     * See resolveSourceSelect for why (SQL Server error 1033) and why it's safe (a snapshot is unordered).
+     *
+     * Two guards keep this from corrupting results:
+     *  - **PostgreSQL is a no-op** — PG permits ORDER BY inside a derived table, so there's nothing to fix and
+     *    we skip the parser round-trip entirely.
+     *  - **A query with a row-LIMITING clause (SQL Server TOP or OFFSET/FETCH) is left UNCHANGED** — there the
+     *    ORDER BY is both (a) LEGAL in a derived table and (b) SEMANTICALLY REQUIRED: it decides WHICH rows
+     *    TOP/FETCH keep, so stripping it would materialize an arbitrary subset (a silent wrong-data bug). Only a
+     *    BARE top-level ORDER BY (pure presentation sort, no limiting) is both illegal-in-derived-table and safe
+     *    to drop.
+     *
+     * Uses the SQL parser; on any parse/shape surprise, or no top-level ORDER BY, returns the SQL unchanged
+     * (an ORDER BY nested inside a subquery is legal and left intact).
+     */
+    static stripTopLevelOrderBy(sql: string, isPostgres: boolean): string;
+    /**
+     * Phase 1.5 (EDS composition): if this materialization is backed by an EXTERNAL entity base view
+     * (the source entity carries an `ExternalDataSourceID`), returns that entity — the signal to rebuild
+     * by fetching remote rows through the EDS driver rather than by local SQL. Returns null otherwise
+     * (local sources, and — for now — external *queries*, which fall through to the local path).
+     */
+    private resolveExternalEntity;
+    /**
+     * Phase 3: parse the materialization's `KeyColumns` metadata (JSON array of `{name, type}`) into the
+     * hash-key column list, or undefined when it isn't keyed. A null/empty/malformed value yields undefined
+     * — the caller then uses the synthetic IDENTITY/ROW_NUMBER surrogate (Phase 1/2 behavior).
+     */
+    static parseKeyColumns(raw: string | null | undefined): {
+        name: string;
+        type: string;
+    }[] | undefined;
+    /**
+     * Phase 1.5: rebuild a materialized result from an EXTERNAL entity — "mirror external → join locally".
+     * Remote rows can't be read via local SQL, so we fetch them through the EDS read router (read-only)
+     * and persist into the MJ-managed shadow table (CREATE + batched INSERT), then reuse the Phase-1
+     * atomic wrapper-view swap. Once persisted the data is an ordinary local MJ table, joinable with
+     * internal entities.
+     *
+     * RLS is NOT downgraded here (§6.1): base-view materialization REUSES the source entity (no new entity,
+     * no changed permissions), so its `ReadRLSFilterID` is enforced at read time by the standard read
+     * pipeline against the materialized wrapper view exactly as it would be against the live base view
+     * (`DataSource:'Materialized'` only swaps the FROM). The physical mirror holding all rows is correct —
+     * RLS filters at READ, like any base table. (This is why only the QUERY case — a new, differently-shaped
+     * entity that loses source RLS — carries a mint-time refusal gate, not the base-view case.)
+     */
+    private rebuildFromExternalEntity;
+    /**
+     * Runs a {@link buildExternalRebuildPlan}: DDL, then the parameterized insert batches (value binding —
+     * not literal inlining), then the atomic swap. Shared by the external-entity and external-query paths.
+     */
+    private static executeExternalRebuildPlan;
+    /**
+     * Loads the materialization's source stored Query ONCE (Query source type only) and classifies it:
+     * returns the loaded `query` plus `externalSql` — the SQL to run remotely when the query is EXTERNAL
+     * (carries an ExternalDataSourceID: BroadSQL for RowFilterBroad, else the static query SQL), or null
+     * when it's a LOCAL query. The caller reuses this same loaded `query` to build the local source SELECT
+     * (no second Load). Returns null when the source isn't a stored Query.
+     */
+    /**
+     * Resolve a materialization's source Query ID via the `MJ: Materialized Result Queries` join table.
+     * The MR<->Query link lives in that join table (there is no MaterializedResult.SourceQueryID column —
+     * the direct FK formed a circular dependency). Returns null when the materialization has no linked query.
+     */
+    private resolveSourceQueryId;
+    private resolveSourceQuery;
+    /**
+     * Phase 1.5: rebuild a materialized result from an EXTERNAL stored query. Runs the (broad, for
+     * RowFilterBroad) query through the EDS native-query path, then persists the returned rows into the
+     * MJ-managed shadow. Query results have no natural PK, so — mirroring the local query case — a synthetic
+     * surrogate (MATERIALIZATION_SURROGATE_COLUMN) is prepended, populated by 1-based row index; column
+     * types are inferred from the returned values. Row-filter re-application at read is the caller's
+     * ExtraFilter (the Phase-2 convention), same as local RowFilterBroad materializations.
+     */
+    private rebuildFromExternalQuery;
+    /**
+     * Infer a column's SQL type from its fetched values (external-query materialization, where no field
+     * metadata is available). All-null → nvarchar(max)/text; ALL-numbers → int/integer (bigint when any
+     * value exceeds signed-32-bit) else float/double precision; ALL-booleans → bit/boolean; ALL Date OBJECTS
+     * → datetime2/timestamptz; ANYTHING ELSE, including a column whose values are HETEROGENEOUS across rows or
+     * arrive as date STRINGS → nvarchar(max)/text.
+     *
+     * The type is decided from EVERY present value, not just the first: a loosely-typed source (REST/GraphQL)
+     * can return a field that is a number in one row and a string in another; typing the column from row 1
+     * would make later rows fail to bind. Falling back to text (which accepts any value) is the safe answer.
+     *
+     * Date-like STRINGS (ISO-8601 over JSON transport) are deliberately kept as text, NOT coerced to a
+     * temporal column: coerceExternalParamValue binds the raw string and relies on implicit conversion, which
+     * can reject offset-bearing / edge ISO forms and fail the entire rebuild. Text loses nothing that matters
+     * here — fixed-format ISO-8601 strings sort and range-compare CHRONOLOGICALLY under lexicographic text
+     * ordering, so ORDER BY / `> 'YYYY-MM-DD…'` filters stay correct. Only genuine Date objects, whose bind is
+     * well-defined, are typed as datetime2/timestamptz.
+     */
+    static inferSqlType(values: unknown[], isPostgres: boolean): string;
+    /**
+     * External-source full rebuild PLAN (Phase 1.5), cross-engine and PARAMETERIZED. Pure (no IO) →
+     * fully unit-testable (asserts on the emitted SQL + the params arrays). Three parts, run in order:
+     *
+     *  - `preStatements`  — DROP + CREATE the shadow table (pure DDL, no params).
+     *  - `insertBatches`  — batched multi-row INSERTs as `{sql, params}`. NON-NULL values are bound as
+     *    positional parameters (`@pN` on SQL Server, `$N` on PostgreSQL) instead of inlined as literals;
+     *    NULLs are emitted as the literal `NULL` (no bind param — sidesteps driver null-typing quirks and
+     *    carries no injection risk). This keeps the SQL TEXT small and constant regardless of row width or
+     *    value size, so a large external mirror no longer builds enormous statements that pressure the Node
+     *    heap or blow the database's parser/packet limits (the prior inline-VALUES limitation). Batches are
+     *    sized by the engine's bind-parameter ceiling (SQL Server 2100 / PostgreSQL 65535, with headroom),
+     *    capped at 1000 rows/statement.
+     *  - `postStatements` — the atomic wrapper-view swap: transactional on SQL Server (the view only ever
+     *    points at the canonical name; the transaction's Sch-M lock keeps readers on the old snapshot until
+     *    commit — no "Invalid object name …__shadow" window; CREATE VIEW runs via EXEC() as its own batch),
+     *    CASCADE-repoint sequence on PostgreSQL.
+     *
+     * NOTE: the source rows are already fully materialized in memory by the EDS read (RunViewExternal /
+     * RunQueryExternal return the complete result set), so this fixes the SQL-text/packet half of the scale
+     * problem; true end-to-end streaming would require a streaming read API on the EDS router (future work).
+     */
+    static buildExternalRebuildPlan(opts: {
+        schema: string;
+        tableName: string;
+        viewName: string;
+        columns: {
+            name: string;
+            sqlType: string;
+        }[];
+        rows: Record<string, unknown>[];
+        isPostgres: boolean;
+        /** Query case: the synthetic surrogate column to restore a UNIQUE index on post-swap (the minted
+         *  entity's PK). Omit for the base-view case (the source PK column carries its own identity). */
+        surrogateColumn?: string;
+        /** Run-unique shadow table name (see {@link makeShadowTableName}) so two concurrent refreshes of the
+         *  same materialization never share a shadow. Defaults to the legacy fixed name when omitted. */
+        shadowName?: string;
+    }): {
+        preStatements: string[];
+        insertBatches: {
+            sql: string;
+            params: unknown[];
+        }[];
+        postStatements: string[];
+    };
+    /**
+     * Coerce a JS value fetched from an external source into a driver-bindable parameter value:
+     * null/undefined → null (the caller emits a literal `NULL` for these); non-finite numbers → null;
+     * plain objects → JSON text (matches the `inferSqlType` text mapping for object columns); Date and
+     * primitives (boolean/number/string) pass through — the driver binds them to the shadow column type.
+     */
+    static coerceExternalParamValue(value: unknown): unknown;
+    /** Map a SQL-Server-style `SQLFullType` (e.g. `nvarchar(255)`, `int`, `bit`) to a PostgreSQL column type. */
+    static mapSqlTypeToPostgres(sqlFullType: string): string;
+    /**
+     * Quote a SQL identifier for the engine, ESCAPING the closing delimiter so a column name that contains
+     * it can't break out of the quotes: `]`→`]]` (SQL Server), `"`→`""` (PostgreSQL). Column names in the
+     * keyed/incremental builders are CodeGen-derived (entity field / KeyColumns names), so this is a
+     * consistency + robustness guard (matching buildExternalRebuildPlan's escId), not a live-injection fix.
+     */
+    static quoteIdent(name: string, isPostgres: boolean): string;
+    /**
+     * Phase 3: SQL expression producing the CANONICAL TEXT of one key column for the combined-key
+     * surrogate hash (§17.1). Deterministic within an engine; a NULL is replaced by a control-char-wrapped
+     * sentinel (CHAR(30)) so it can't collide with a literal value. `type` is the column's SQL-Server-style
+     * type (EntityFieldInfo.SQLFullType); the base type drives the canonical cast.
+     */
+    static canonicalKeyColumnSql(name: string, type: string, isPostgres: boolean): string;
+    /**
+     * Phase 3: SQL expression computing the combined-key surrogate — `SHA2_256` (lowercase hex) over the
+     * canonical key columns in declared key order (§17.1). Deterministic WITHIN an engine (the
+     * incremental-MERGE / dirty-group match key); cross-engine identity is best-effort.
+     *
+     * COLLISION SAFETY: each canonical part is hashed to a FIXED-WIDTH 64-char hex string FIRST, and the
+     * per-part hashes are what get delimited + hashed. A naive `part1 + CHAR(31) + part2` collides when a
+     * key value itself contains the CHAR(31) delimiter (or the CHAR(30) NULL sentinel) — e.g. ('x\x1f','y')
+     * and ('x','\x1fy') both flatten to `x\x1f\x1fy`. Hashing each part first makes every part pure hex
+     * (0-9a-f), which can NEVER contain a control char, so the delimiter is unambiguous and distinct tuples
+     * can no longer canonicalize to the same string. Each canonical part is NULL-free (COALESCE'd), so the
+     * inner hash inputs are never NULL. (This feature is unreleased, so no existing surrogates need
+     * migrating; a full rebuild regenerates them under the new scheme.)
+     * NOTE: the PostgreSQL `digest()` used here requires the `pgcrypto` extension. MJ's PostgreSQL baseline
+     * already runs `CREATE EXTENSION IF NOT EXISTS "pgcrypto"`, so keyed PG materializations get it for free;
+     * a deployment that dropped that baseline step would see refreshes fail with a clear `function digest(...)
+     * does not exist` — provision pgcrypto to resolve.
+     */
+    static buildHashKeyExpression(keyColumns: {
+        name: string;
+        type: string;
+    }[], isPostgres: boolean): string;
+    /**
+     * Phase 3 (DirtyGroupRecompute): a NULL-safe equality predicate matching the key columns of two
+     * aliases (`(a.[k] = b.[k] OR (a.[k] IS NULL AND b.[k] IS NULL)) AND ...`). Two NULL keys are treated
+     * as equal (a materialized aggregation can legitimately have a NULL grouping value — it's one group).
+     * Portable across SQL Server and PostgreSQL (the `OR ... IS NULL` form works on both; we avoid
+     * `IS NOT DISTINCT FROM`, which SQL Server lacks pre-2022). Pure/unit-testable.
+     */
+    static buildKeyMatchPredicate(aliasA: string, aliasB: string, keyColumns: {
+        name: string;
+    }[], isPostgres: boolean): string;
+    /**
+     * Phase 3 (DirtyGroupRecompute): the ordered statements that incrementally refresh a keyed aggregation
+     * IN PLACE (no shadow swap) by recomputing only the groups whose SOURCE rows changed since `watermarkSql`.
+     * Pure (no IO), so the sequence is unit-testable. Engine-agnostic core; {@link buildDirtyGroupRecomputeStatementsSQLServer}
+     * / {@link buildDirtyGroupRecomputeStatementsPostgreSQL} supply the per-engine quoting + DELETE syntax.
+     *
+     * Semantics (correct within the documented delete caveat — see RefreshOne):
+     *  1. DELETE every materialized row whose group has ANY source row updated since the watermark
+     *     (removes stale values, AND removes a group that shrank/emptied among the changed groups);
+     *  2. INSERT the freshly-computed values for exactly those dirty groups (from the aggregation SELECT,
+     *     filtered by the same "group has a changed source row" predicate), stamping the same hash surrogate
+     *     the full rebuild uses so the key stays stable.
+     * A group whose rows were ALL deleted without any surviving-row update is NOT seen here (the deleted
+     * rows are gone); that case is caught by the source-count-drop → full-rebuild guard in RefreshOne.
+     */
+    private static buildDirtyGroupRecomputeCore;
+    /** SQL Server dirty-group recompute (see {@link buildDirtyGroupRecomputeCore}). */
+    static buildDirtyGroupRecomputeStatementsSQLServer(opts: {
+        schema: string;
+        tableName: string;
+        sourceSchema: string;
+        sourceTable: string;
+        keyColumns: {
+            name: string;
+            type: string;
+        }[];
+        aggregationSelect: string;
+        surrogateColumn: string;
+        dataColumns: string[];
+        updatedAtColumn: string;
+        watermarkSql: string;
+    }): string[];
+    /** PostgreSQL dirty-group recompute (see {@link buildDirtyGroupRecomputeCore}). */
+    static buildDirtyGroupRecomputeStatementsPostgreSQL(opts: {
+        schema: string;
+        tableName: string;
+        sourceSchema: string;
+        sourceTable: string;
+        keyColumns: {
+            name: string;
+            type: string;
+        }[];
+        aggregationSelect: string;
+        surrogateColumn: string;
+        dataColumns: string[];
+        updatedAtColumn: string;
+        watermarkSql: string;
+    }): string[];
+    /**
+     * Phase 4 (RefreshStrategy = 'Incremental'): incrementally refresh a keyed ADDITIVE aggregation by
+     * recomputing only the changed groups and UPSERTING them onto the surrogate key — an in-place MERGE
+     * (SQL Server) / INSERT…ON CONFLICT (PostgreSQL) rather than the DirtyGroupRecompute delete-then-insert.
+     * The recomputed source is identical (the aggregation restricted to groups with a source row changed
+     * since the watermark); the difference is that a surviving group's row is UPDATED in place — no churn,
+     * no transient absence, one atomic statement. Correct for insert/update; a net source-count drop
+     * (deletes) still falls back to full rebuild via the RefreshOne guard. Requires the surrogate to be
+     * unique (it is the materialized table's PK). Pure (no IO) / unit-testable.
+     */
+    static buildIncrementalMergeStatementsSQLServer(opts: {
+        schema: string;
+        tableName: string;
+        sourceSchema: string;
+        sourceTable: string;
+        keyColumns: {
+            name: string;
+            type: string;
+        }[];
+        aggregationSelect: string;
+        surrogateColumn: string;
+        dataColumns: string[];
+        updatedAtColumn: string;
+        watermarkSql: string;
+    }): string[];
+    /** PostgreSQL incremental upsert — the INSERT…ON CONFLICT counterpart of the SQL Server MERGE above. */
+    static buildIncrementalMergeStatementsPostgreSQL(opts: {
+        schema: string;
+        tableName: string;
+        sourceSchema: string;
+        sourceTable: string;
+        keyColumns: {
+            name: string;
+            type: string;
+        }[];
+        aggregationSelect: string;
+        surrogateColumn: string;
+        dataColumns: string[];
+        updatedAtColumn: string;
+        watermarkSql: string;
+    }): string[];
+}
+//# sourceMappingURL=MaterializationRefresher.d.ts.map

package/dist/MaterializationRefresher.d.ts.map

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