@memberjunction/integration-engine 5.41.0 → 5.43.0

package/dist/CustomColumnPromotion.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Promotion planner — the brain of the post-sync custom-column step (gaps.md §2, M2).
+ *
+ * After a sync, the values a source returned with no field map are parked as JSON in the
+ * {@link CUSTOM_OVERFLOW_COLUMN} system column (M1 capture). This module decides, from a
+ * coverage scan of that column, WHICH of those keys earn a real column and WHAT bounded
+ * type each should get. It is PURE — no DB, no RSU, no I/O — so the genuinely new logic is
+ * fully unit-testable. The server-side orchestrator (M2b) feeds the resulting plan into the
+ * EXISTING refresh pipeline (SchemaEvolution ADD COLUMN → RSU → IntegrationSchemaSync IOF →
+ * field map); this module never touches schema itself.
+ *
+ * Design rules (from gaps.md §2 + the connector-code conventions):
+ * - Provable-only / never fabricate: a key earns a column only on PERVASIVENESS evidence
+ *   (coverage ≥ threshold), never on a single malformed row. PK/FK are NEVER inferred here —
+ *   customs are always emitted nullable, non-PK, non-FK (classification is deferred to D4).
+ * - Generous bounded typing (the NVARCHAR(MAX) problem): size columns comfortably from the
+ *   observed samples and err LARGER — a roomy bounded column beats a truncating tight one,
+ *   and both beat MAX. Only fall back to MAX/TEXT when the observed length genuinely can't be
+ *   bounded. Narrow to number/boolean/datetime ONLY when every non-null sample unambiguously
+ *   supports it; otherwise default to a (generously bounded) string — that is the safe choice
+ *   that can hold anything the source later returns.
+ * - Terminate / never re-promote: a key whose column already exists is skipped, so the
+ *   capture→promote loop converges instead of re-promoting forever.
+ */
+/** The schema-builder field-type family + the concrete per-dialect SQL types we infer. */
+export interface InferredColumnType {
+    /** Schema-builder SchemaFieldType family ('string' | 'number' | 'boolean' | 'datetime'). */
+    SchemaFieldType: 'string' | 'number' | 'boolean' | 'datetime';
+    /** Concrete SQL Server column type, e.g. `NVARCHAR(255)`, `BIGINT`, `DATETIMEOFFSET`. */
+    SqlServerType: string;
+    /** Concrete PostgreSQL column type, e.g. `VARCHAR(255)`, `BIGINT`, `TIMESTAMPTZ`. */
+    PostgresType: string;
+    /** Bound for string types (null for non-string or when unbounded → MAX/TEXT). */
+    MaxLength: number | null;
+}
+/** Per-key statistics from a coverage scan of the overflow column for one (CompanyIntegration, entity). */
+export interface OverflowKeyStats {
+    /** The source key as it appears in the overflow JSON. */
+    Key: string;
+    /** Rows in which the key was present with a non-null value. */
+    Occurrences: number;
+    /** Total rows scanned (rows that had any overflow JSON). */
+    TotalRows: number;
+    /** A bounded sample of observed values for this key, for type inference. */
+    SampleValues: unknown[];
+}
+/** A key that earned a real column, with its inferred bounded type. */
+export interface PromotionCandidate {
+    /** The source key → becomes both the SourceFieldName (field map) and the column name. */
+    Key: string;
+    /** Pervasiveness in [0,1] = Occurrences / TotalRows. */
+    Coverage: number;
+    /** The inferred, generously-bounded column type. */
+    Inferred: InferredColumnType;
+}
+/** Tuning + context for {@link planPromotions}. */
+export interface PromotionPlanOptions {
+    /**
+     * Minimum coverage (in [0,1]) a key must clear to earn a column. Default 0 — §23: a custom key
+     * earns a column on FIRST occurrence (presence, not prevalence); appearing in even one row is
+     * enough. Raise this only if a caller deliberately wants to suppress sparse keys. The captured
+     * values are never lost regardless — they stay in the overflow JSON until promoted.
+     */
+    CoverageThreshold?: number;
+    /**
+     * Column names that already exist on the target entity (case-insensitive). A key whose
+     * column already exists is NOT re-promoted — this is what makes the loop terminate.
+     */
+    ExistingColumnNames?: ReadonlySet<string>;
+}
+/**
+ * Plans which overflow keys to promote to real columns. Pure; deterministic (sorted by key).
+ *
+ * @param stats - per-key coverage statistics from the overflow scan
+ * @param opts  - coverage threshold + the set of already-existing column names
+ * @returns the promotion candidates, sorted by key for stable, replayable output
+ */
+export declare function planPromotions(stats: OverflowKeyStats[], opts?: PromotionPlanOptions): PromotionCandidate[];
+/**
+ * Infers a generously-bounded column type from observed sample values. Narrows to
+ * boolean/number/datetime ONLY when EVERY non-null sample unambiguously supports it;
+ * otherwise defaults to a comfortably-bounded string. Never returns MAX/TEXT unless the
+ * observed string length genuinely can't be bounded.
+ */
+export declare function inferColumnTypeFromSamples(samples: unknown[]): InferredColumnType;
+/**
+ * Builds per-key coverage statistics from a SAMPLE of rows that carried overflow JSON.
+ * Each row's overflow column is a JSON object string (what M1 parked); this tallies, per key,
+ * how many sampled rows had it non-null and collects a bounded sample of its values for type
+ * inference. Robust to malformed/empty JSON (such rows contribute to TotalRows but no keys).
+ *
+ * Coverage is therefore computed over the SAMPLE (bounded memory at any table size) — a
+ * statistically sound basis for the pervasiveness decision; the exactness the threshold needs
+ * (a key on ~half the rows vs. a junk key on one) survives sampling.
+ *
+ * @param overflowJsonStrings - the raw overflow-column value from each sampled row
+ * @param sampleCap - max values retained per key (default {@link DEFAULT_SAMPLE_CAP})
+ */
+export declare function buildOverflowStats(overflowJsonStrings: Array<string | null | undefined>, sampleCap?: number): OverflowKeyStats[];
+/**
+ * Sanitizes a source key into a safe SQL/MJ column identifier (letters, digits, underscore;
+ * never leading-digit; bounded length). The original key is kept as the field map's
+ * SourceFieldName; the sanitized form becomes the column + DestinationFieldName. Returns the
+ * BASE name only — collision resolution (suffixing) is the orchestrator's job since it needs
+ * the existing-column context.
+ */
+export declare function sanitizeColumnName(key: string): string;
+//# sourceMappingURL=CustomColumnPromotion.d.ts.map

package/dist/CustomColumnPromotion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomColumnPromotion.d.ts","sourceRoot":"","sources":["../src/CustomColumnPromotion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,0FAA0F;AAC1F,MAAM,WAAW,kBAAkB;IAC/B,4FAA4F;IAC5F,eAAe,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;IAC9D,yFAAyF;IACzF,aAAa,EAAE,MAAM,CAAC;IACtB,qFAAqF;IACrF,YAAY,EAAE,MAAM,CAAC;IACrB,iFAAiF;IACjF,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,2GAA2G;AAC3G,MAAM,WAAW,gBAAgB;IAC7B,yDAAyD;IACzD,GAAG,EAAE,MAAM,CAAC;IACZ,+DAA+D;IAC/D,WAAW,EAAE,MAAM,CAAC;IACpB,4DAA4D;IAC5D,SAAS,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,YAAY,EAAE,OAAO,EAAE,CAAC;CAC3B;AAED,uEAAuE;AACvE,MAAM,WAAW,kBAAkB;IAC/B,yFAAyF;IACzF,GAAG,EAAE,MAAM,CAAC;IACZ,wDAAwD;IACxD,QAAQ,EAAE,MAAM,CAAC;IACjB,oDAAoD;IACpD,QAAQ,EAAE,kBAAkB,CAAC;CAChC;AAED,mDAAmD;AACnD,MAAM,WAAW,oBAAoB;IACjC;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,mBAAmB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CAC7C;AAmBD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC1B,KAAK,EAAE,gBAAgB,EAAE,EACzB,IAAI,GAAE,oBAAyB,GAChC,kBAAkB,EAAE,CAsBtB;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,kBAAkB,CA4BjF;AAwCD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAC9B,mBAAmB,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EACrD,SAAS,GAAE,MAA2B,GACvC,gBAAgB,EAAE,CA0BpB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKtD"}

package/dist/CustomColumnPromotion.js

@@ -0,0 +1,202 @@
+/**
+ * Promotion planner — the brain of the post-sync custom-column step (gaps.md §2, M2).
+ *
+ * After a sync, the values a source returned with no field map are parked as JSON in the
+ * {@link CUSTOM_OVERFLOW_COLUMN} system column (M1 capture). This module decides, from a
+ * coverage scan of that column, WHICH of those keys earn a real column and WHAT bounded
+ * type each should get. It is PURE — no DB, no RSU, no I/O — so the genuinely new logic is
+ * fully unit-testable. The server-side orchestrator (M2b) feeds the resulting plan into the
+ * EXISTING refresh pipeline (SchemaEvolution ADD COLUMN → RSU → IntegrationSchemaSync IOF →
+ * field map); this module never touches schema itself.
+ *
+ * Design rules (from gaps.md §2 + the connector-code conventions):
+ * - Provable-only / never fabricate: a key earns a column only on PERVASIVENESS evidence
+ *   (coverage ≥ threshold), never on a single malformed row. PK/FK are NEVER inferred here —
+ *   customs are always emitted nullable, non-PK, non-FK (classification is deferred to D4).
+ * - Generous bounded typing (the NVARCHAR(MAX) problem): size columns comfortably from the
+ *   observed samples and err LARGER — a roomy bounded column beats a truncating tight one,
+ *   and both beat MAX. Only fall back to MAX/TEXT when the observed length genuinely can't be
+ *   bounded. Narrow to number/boolean/datetime ONLY when every non-null sample unambiguously
+ *   supports it; otherwise default to a (generously bounded) string — that is the safe choice
+ *   that can hold anything the source later returns.
+ * - Terminate / never re-promote: a key whose column already exists is skipped, so the
+ *   capture→promote loop converges instead of re-promoting forever.
+ */
+const DEFAULT_COVERAGE_THRESHOLD = 0; // §23 — presence-based: a key seen in even one row earns a column.
+/** SQL Server's largest bounded NVARCHAR before MAX; above this we must use MAX/TEXT. */
+const MAX_BOUNDED_STRING = 4000;
+/** Floor for a generous string bound — never size a custom string column tighter than this. */
+const MIN_STRING_BOUND = 255;
+/**
+ * Minimum all-integer sample before we trust the field is INTEGRAL and narrow to BIGINT (#A9). Below this
+ * a handful of integer samples does NOT prove the unscanned tail is integer-only — a later decimal would be
+ * silently rejected by BIGINT (dead-lettered). Under the threshold we use wide fixed-point (which holds
+ * integers too), so a later decimal never fails; the column can still re-promote to BIGINT once enough
+ * integer evidence accrues.
+ */
+const MIN_SAMPLE_FOR_INTEGER_NARROW = 12;
+/** Matches an ISO-8601-ish date / datetime so we don't mistake "5" or "2020" for a date. */
+const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?)?$/;
+/**
+ * Plans which overflow keys to promote to real columns. Pure; deterministic (sorted by key).
+ *
+ * @param stats - per-key coverage statistics from the overflow scan
+ * @param opts  - coverage threshold + the set of already-existing column names
+ * @returns the promotion candidates, sorted by key for stable, replayable output
+ */
+export function planPromotions(stats, opts = {}) {
+    const threshold = opts.CoverageThreshold ?? DEFAULT_COVERAGE_THRESHOLD;
+    const existing = lowercaseSet(opts.ExistingColumnNames);
+    const candidates = [];
+    for (const stat of stats) {
+        // Terminate / never re-promote: the column already exists.
+        if (existing.has(stat.Key.toLowerCase()))
+            continue;
+        // Guard div-by-zero only; §23 — presence is enough (default threshold 0), so a key seen in
+        // even one row earns a column. A higher bar is opt-in via CoverageThreshold.
+        if (stat.TotalRows <= 0)
+            continue;
+        const coverage = stat.Occurrences / stat.TotalRows;
+        if (coverage < threshold)
+            continue;
+        candidates.push({
+            Key: stat.Key,
+            Coverage: coverage,
+            Inferred: inferColumnTypeFromSamples(stat.SampleValues),
+        });
+    }
+    return candidates.sort((a, b) => a.Key.localeCompare(b.Key));
+}
+/**
+ * Infers a generously-bounded column type from observed sample values. Narrows to
+ * boolean/number/datetime ONLY when EVERY non-null sample unambiguously supports it;
+ * otherwise defaults to a comfortably-bounded string. Never returns MAX/TEXT unless the
+ * observed string length genuinely can't be bounded.
+ */
+export function inferColumnTypeFromSamples(samples) {
+    const nonNull = samples.filter(v => v !== null && v !== undefined);
+    // No evidence → a safe, generous default string.
+    if (nonNull.length === 0)
+        return stringType(MIN_STRING_BOUND);
+    if (nonNull.every(isBoolean)) {
+        return { SchemaFieldType: 'boolean', SqlServerType: 'BIT', PostgresType: 'BOOLEAN', MaxLength: null };
+    }
+    if (nonNull.every(isFiniteNumber)) {
+        // Narrow to BIGINT only with an ADEQUATE all-integer sample (#A9). A small all-integer sample
+        // doesn't prove the field is always integral — a decimal in the unscanned tail would be silently
+        // rejected by BIGINT. Below the threshold, use wide fixed-point (which holds integers too).
+        const confidentInteger = nonNull.length >= MIN_SAMPLE_FOR_INTEGER_NARROW && nonNull.every(v => Number.isInteger(v));
+        return confidentInteger
+            ? { SchemaFieldType: 'number', SqlServerType: 'BIGINT', PostgresType: 'BIGINT', MaxLength: null }
+            // Generous fixed-point — wide precision so we don't truncate or reject decimals.
+            : { SchemaFieldType: 'number', SqlServerType: 'DECIMAL(38,10)', PostgresType: 'DECIMAL(38,10)', MaxLength: null };
+    }
+    if (nonNull.every(isIsoDateString)) {
+        return { SchemaFieldType: 'datetime', SqlServerType: 'DATETIMEOFFSET', PostgresType: 'TIMESTAMPTZ', MaxLength: null };
+    }
+    // Default: a generously-bounded string sized to comfortably hold the longest observed value.
+    const longest = Math.max(...nonNull.map(v => String(v).length));
+    return stringType(generousStringBound(longest));
+}
+/** Builds a string {@link InferredColumnType}; bound===null ⇒ unbounded (MAX/TEXT). */
+function stringType(bound) {
+    if (bound === null) {
+        return { SchemaFieldType: 'string', SqlServerType: 'NVARCHAR(MAX)', PostgresType: 'TEXT', MaxLength: null };
+    }
+    return { SchemaFieldType: 'string', SqlServerType: `NVARCHAR(${bound})`, PostgresType: `VARCHAR(${bound})`, MaxLength: bound };
+}
+/**
+ * Generous bound for a string column: double the longest observed length (room to grow),
+ * floored at {@link MIN_STRING_BOUND}; if that would exceed the bounded limit, fall back to
+ * unbounded (null → MAX/TEXT) since it genuinely can't be bounded safely.
+ */
+function generousStringBound(longestObserved) {
+    const doubled = Math.max(longestObserved * 2, MIN_STRING_BOUND);
+    return doubled > MAX_BOUNDED_STRING ? null : doubled;
+}
+function isBoolean(v) {
+    return typeof v === 'boolean';
+}
+function isFiniteNumber(v) {
+    return typeof v === 'number' && Number.isFinite(v);
+}
+function isIsoDateString(v) {
+    return typeof v === 'string' && ISO_DATE_RE.test(v) && !Number.isNaN(Date.parse(v));
+}
+function lowercaseSet(set) {
+    if (!set || set.size === 0)
+        return new Set();
+    return new Set([...set].map(s => s.toLowerCase()));
+}
+/** Max distinct sample values retained per key for type inference (bounded memory). */
+const DEFAULT_SAMPLE_CAP = 20;
+/**
+ * Builds per-key coverage statistics from a SAMPLE of rows that carried overflow JSON.
+ * Each row's overflow column is a JSON object string (what M1 parked); this tallies, per key,
+ * how many sampled rows had it non-null and collects a bounded sample of its values for type
+ * inference. Robust to malformed/empty JSON (such rows contribute to TotalRows but no keys).
+ *
+ * Coverage is therefore computed over the SAMPLE (bounded memory at any table size) — a
+ * statistically sound basis for the pervasiveness decision; the exactness the threshold needs
+ * (a key on ~half the rows vs. a junk key on one) survives sampling.
+ *
+ * @param overflowJsonStrings - the raw overflow-column value from each sampled row
+ * @param sampleCap - max values retained per key (default {@link DEFAULT_SAMPLE_CAP})
+ */
+export function buildOverflowStats(overflowJsonStrings, sampleCap = DEFAULT_SAMPLE_CAP) {
+    const byKey = new Map();
+    let totalRows = 0;
+    for (const raw of overflowJsonStrings) {
+        totalRows++;
+        const parsed = safeParseObject(raw);
+        if (!parsed)
+            continue;
+        for (const [key, value] of Object.entries(parsed)) {
+            if (value === null || value === undefined)
+                continue;
+            let entry = byKey.get(key);
+            if (!entry) {
+                entry = { occurrences: 0, samples: [] };
+                byKey.set(key, entry);
+            }
+            entry.occurrences++;
+            if (entry.samples.length < sampleCap)
+                entry.samples.push(value);
+        }
+    }
+    return [...byKey.entries()].map(([key, e]) => ({
+        Key: key,
+        Occurrences: e.occurrences,
+        TotalRows: totalRows,
+        SampleValues: e.samples,
+    }));
+}
+/**
+ * Sanitizes a source key into a safe SQL/MJ column identifier (letters, digits, underscore;
+ * never leading-digit; bounded length). The original key is kept as the field map's
+ * SourceFieldName; the sanitized form becomes the column + DestinationFieldName. Returns the
+ * BASE name only — collision resolution (suffixing) is the orchestrator's job since it needs
+ * the existing-column context.
+ */
+export function sanitizeColumnName(key) {
+    let name = key.replace(/[^A-Za-z0-9_]/g, '_').replace(/_+/g, '_').replace(/^_+|_+$/g, '');
+    if (name.length === 0)
+        name = 'Custom';
+    if (/^[0-9]/.test(name))
+        name = `c_${name}`;
+    return name.length > 120 ? name.slice(0, 120) : name;
+}
+function safeParseObject(raw) {
+    if (!raw || typeof raw !== 'string')
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=CustomColumnPromotion.js.map

package/dist/CustomColumnPromotion.js.map

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

package/dist/CustomOverflow.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Name of the per-record custom-overflow column. Written on every integration table
+ * alongside the other `__mj_integration_*` columns when present. Holds a JSON object of
+ * the source fields a record returned that have NO field map — the "extra" keys the
+ * target table doesn't (yet) have a column for.
+ *
+ * This is the capture half of framework-level custom-column support (gaps.md §2). A
+ * source with no schema/describe endpoint (the PropFuel class) can only learn its full
+ * field set by reading data; a static catalog then silently drops any extra key at
+ * {@link MapSingleRecord} (only mapped fields get persisted). Rather than lose them, the
+ * unmapped keys are parked here, on the row, in the SAME write as the mapped fields — so
+ * capture costs no extra round-trip. A post-sync Runtime-Schema-Updation (RSU) pass later
+ * reads this column back out and promotes pervasive keys to real columns (ADD COLUMN +
+ * CodeGen + a field map). It does NOT backfill historical values: once the field map exists
+ * the key is no longer "unmapped", so the NEXT sync maps it natively and populates the new
+ * column with the LIVE source value (a full sync repopulates every row; an incremental fills
+ * rows as they next change) — and stops re-capturing it here. The loop converges go-forward.
+ *
+ * Shape mirrors {@link CONTENT_HASH_COLUMN}: a JSON-serialized string sidecar, identical
+ * in kind to `__mj_integration_LastSyncedSnapshot`. SS `NVARCHAR(MAX)` / PG `TEXT`; the
+ * post-sync coverage scan + spread cast `::jsonb` on Postgres when they query it.
+ *
+ * This is BACKEND PLUMBING, not user-facing metadata. It is a SYSTEM field — in the same
+ * hidden/internal class as `__mj_integration_ContentHash` & the other `__mj_integration_*`
+ * columns: metadata-registered only so the engine's `entity.Set(...)`/`entity.Fields` write
+ * path is permitted to touch it (so it is NOT an out-of-band "phantom" column the engine
+ * writes blind), but NOT surfaced or managed through the metadata-driven framework — not in
+ * forms, not user-mappable, not "a field" anyone works with. It is machinery.
+ *
+ * The things that genuinely ENTER the metadata-driven framework are the columns this gets
+ * PROMOTED into: a pervasive key here is turned into a real user-facing, mappable EntityField
+ * (IntegrationSchemaSync IOF → RSU ADD COLUMN → CodeGen → md.Refresh) BEFORE the engine maps
+ * to it. So: backend staging until promotion, first-class metadata-driven schema after. Only
+ * the JSON *values* parked here are ever transient.
+ *
+ * Gated everywhere by EntityInfo field presence, so it is a no-op on tables that predate
+ * the column. CRUCIAL invariant: when a record has NO unmapped keys, NOTHING is written
+ * here — empty across all rows is the signal that no RSU pass is needed, which is what
+ * keeps a customs-free sync byte-identical to today (single-stage, zero overhead).
+ */
+export declare const CUSTOM_OVERFLOW_COLUMN = "__mj_integration_CustomOverflow";
+/**
+ * Computes the unmapped subset of a record's external fields: every key the source
+ * returned that is NOT the SourceFieldName of any active field map.
+ *
+ * Pure + O(columns) — no per-row allocation beyond the result object, which is empty
+ * (and discarded by the caller) for the common no-customs case.
+ *
+ * Honest limit (documented in gaps.md §2): a field consumed only indirectly — e.g. as a
+ * `combine`/`custom` transform input rather than as a map's own SourceFieldName — will
+ * also appear here. That is harmless (the value is still in `Fields`); the post-sync
+ * promotion stage applies a coverage + novelty filter before it ever creates a column.
+ *
+ * @param externalFields - the full source record (`ExternalRecord.Fields`)
+ * @param mappedSourceFieldNames - SourceFieldName of every active field map
+ * @returns the extra keys + values, or an empty object when everything was mapped
+ */
+export declare function computeUnmappedFields(externalFields: Record<string, unknown>, mappedSourceFieldNames: ReadonlySet<string>): Record<string, unknown>;
+/**
+ * Whether a computed unmapped-field object carries anything worth persisting. Used by
+ * both the per-record write gate and (later) the post-sync RSU trigger gate.
+ */
+export declare function hasUnmappedFields(unmapped: Record<string, unknown> | undefined | null): boolean;
+//# sourceMappingURL=CustomOverflow.d.ts.map

package/dist/CustomOverflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomOverflow.d.ts","sourceRoot":"","sources":["../src/CustomOverflow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,sBAAsB,oCAAoC,CAAC;AAExE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CACjC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvC,sBAAsB,EAAE,WAAW,CAAC,MAAM,CAAC,GAC5C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQzB;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAE/F"}

package/dist/CustomOverflow.js

@@ -0,0 +1,74 @@
+/**
+ * Name of the per-record custom-overflow column. Written on every integration table
+ * alongside the other `__mj_integration_*` columns when present. Holds a JSON object of
+ * the source fields a record returned that have NO field map — the "extra" keys the
+ * target table doesn't (yet) have a column for.
+ *
+ * This is the capture half of framework-level custom-column support (gaps.md §2). A
+ * source with no schema/describe endpoint (the PropFuel class) can only learn its full
+ * field set by reading data; a static catalog then silently drops any extra key at
+ * {@link MapSingleRecord} (only mapped fields get persisted). Rather than lose them, the
+ * unmapped keys are parked here, on the row, in the SAME write as the mapped fields — so
+ * capture costs no extra round-trip. A post-sync Runtime-Schema-Updation (RSU) pass later
+ * reads this column back out and promotes pervasive keys to real columns (ADD COLUMN +
+ * CodeGen + a field map). It does NOT backfill historical values: once the field map exists
+ * the key is no longer "unmapped", so the NEXT sync maps it natively and populates the new
+ * column with the LIVE source value (a full sync repopulates every row; an incremental fills
+ * rows as they next change) — and stops re-capturing it here. The loop converges go-forward.
+ *
+ * Shape mirrors {@link CONTENT_HASH_COLUMN}: a JSON-serialized string sidecar, identical
+ * in kind to `__mj_integration_LastSyncedSnapshot`. SS `NVARCHAR(MAX)` / PG `TEXT`; the
+ * post-sync coverage scan + spread cast `::jsonb` on Postgres when they query it.
+ *
+ * This is BACKEND PLUMBING, not user-facing metadata. It is a SYSTEM field — in the same
+ * hidden/internal class as `__mj_integration_ContentHash` & the other `__mj_integration_*`
+ * columns: metadata-registered only so the engine's `entity.Set(...)`/`entity.Fields` write
+ * path is permitted to touch it (so it is NOT an out-of-band "phantom" column the engine
+ * writes blind), but NOT surfaced or managed through the metadata-driven framework — not in
+ * forms, not user-mappable, not "a field" anyone works with. It is machinery.
+ *
+ * The things that genuinely ENTER the metadata-driven framework are the columns this gets
+ * PROMOTED into: a pervasive key here is turned into a real user-facing, mappable EntityField
+ * (IntegrationSchemaSync IOF → RSU ADD COLUMN → CodeGen → md.Refresh) BEFORE the engine maps
+ * to it. So: backend staging until promotion, first-class metadata-driven schema after. Only
+ * the JSON *values* parked here are ever transient.
+ *
+ * Gated everywhere by EntityInfo field presence, so it is a no-op on tables that predate
+ * the column. CRUCIAL invariant: when a record has NO unmapped keys, NOTHING is written
+ * here — empty across all rows is the signal that no RSU pass is needed, which is what
+ * keeps a customs-free sync byte-identical to today (single-stage, zero overhead).
+ */
+export const CUSTOM_OVERFLOW_COLUMN = '__mj_integration_CustomOverflow';
+/**
+ * Computes the unmapped subset of a record's external fields: every key the source
+ * returned that is NOT the SourceFieldName of any active field map.
+ *
+ * Pure + O(columns) — no per-row allocation beyond the result object, which is empty
+ * (and discarded by the caller) for the common no-customs case.
+ *
+ * Honest limit (documented in gaps.md §2): a field consumed only indirectly — e.g. as a
+ * `combine`/`custom` transform input rather than as a map's own SourceFieldName — will
+ * also appear here. That is harmless (the value is still in `Fields`); the post-sync
+ * promotion stage applies a coverage + novelty filter before it ever creates a column.
+ *
+ * @param externalFields - the full source record (`ExternalRecord.Fields`)
+ * @param mappedSourceFieldNames - SourceFieldName of every active field map
+ * @returns the extra keys + values, or an empty object when everything was mapped
+ */
+export function computeUnmappedFields(externalFields, mappedSourceFieldNames) {
+    const unmapped = {};
+    for (const key of Object.keys(externalFields)) {
+        if (!mappedSourceFieldNames.has(key)) {
+            unmapped[key] = externalFields[key];
+        }
+    }
+    return unmapped;
+}
+/**
+ * Whether a computed unmapped-field object carries anything worth persisting. Used by
+ * both the per-record write gate and (later) the post-sync RSU trigger gate.
+ */
+export function hasUnmappedFields(unmapped) {
+    return unmapped != null && Object.keys(unmapped).length > 0;
+}
+//# sourceMappingURL=CustomOverflow.js.map

package/dist/CustomOverflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomOverflow.js","sourceRoot":"","sources":["../src/CustomOverflow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,iCAAiC,CAAC;AAExE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,qBAAqB,CACjC,cAAuC,EACvC,sBAA2C;IAE3C,MAAM,QAAQ,GAA4B,EAAE,CAAC;IAC7C,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC;QAC5C,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACnC,QAAQ,CAAC,GAAG,CAAC,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC;QACxC,CAAC;IACL,CAAC;IACD,OAAO,QAAQ,CAAC;AACpB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,QAAoD;IAClF,OAAO,QAAQ,IAAI,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;AAChE,CAAC"}

package/dist/FieldMappingEngine.d.ts

@@ -1,24 +1,23 @@
 import type { ICompanyIntegrationFieldMap } from './entity-types.js';
 import type { ExternalRecord, MappedRecord } from './types.js';
 /**
- * Engine responsible for applying field-level mappings and transformations
- * from external records to MJ entity fields.
+ * Engine responsible for applying field-level mappings and transformations from external records to
+ * MJ entity fields.
+ *
+ * The per-value transform pipeline (direct / regex / split / combine / lookup / format / coerce /
+ * substring / custom) is owned by the shared {@link FieldTransformEngine} in `@memberjunction/global`
+ * and reused here, so integration sync and the rules-based bulk-update processor run the *exact same*
+ * transform implementation — one place to fix, one place to extend. This engine keeps only the
+ * integration-specific concerns: source flattening, field-map iteration, and unmapped-field overflow
+ * capture. See the Field Rules guide in `@memberjunction/global` for the shared engine, and
+ * `EntityFieldRules` in `@memberjunction/core` for the metadata-aware entity-update sibling.
  */
 export declare class FieldMappingEngine {
+    /** The shared transform pipeline. Holds its own LRU cache of compiled custom expressions. */
+    private readonly transformEngine;
     /**
-     * Cache of compiled custom-expression functions, keyed by the expression string, so an
-     * identical expression is compiled once instead of once per record in a mapping batch.
-     *
-     * A failed compile is cached as the `Error` it threw — a malformed expression is therefore
-     * compiled a single time (then re-thrown from cache on every record) rather than recompiled
-     * on the per-record error path. Bounded via {@link MJLruCache} because the owning
-     * `IntegrationEngine` is a process-lifetime singleton; expression cardinality is normally
-     * tiny (it tracks configured field maps), so the 1000-entry default is comfortably ample.
-     */
-    private readonly customFunctionCache;
-    /**
-     * Applies field mappings to a batch of external records, producing mapped records
-     * ready for match resolution and persistence.
+     * Applies field mappings to a batch of external records, producing mapped records ready for match
+     * resolution and persistence.
      *
      * @param records - External records to map
      * @param fieldMaps - Active field map entities defining source→destination mappings
@@ -31,86 +30,13 @@ export declare class FieldMappingEngine {
      */
     private MapSingleRecord;
     /**
-     * Applies a single field mapping, including the full transform pipeline.
-     * Returns undefined if the field should be skipped (OnError: Skip).
+     * Applies a single field mapping, including the full transform pipeline (delegated to the shared
+     * {@link FieldTransformEngine}). Returns undefined if the field should be skipped (OnError: Skip).
      */
     private ApplyFieldMapping;
     /**
      * Parses the JSON transform pipeline string into typed TransformStep objects.
      */
     private ParseTransformPipeline;
-    /**
-     * Executes a single transform step, applying the configured transformation
-     * and handling errors according to the step's OnError strategy.
-     */
-    private ExecuteTransformStep;
-    /**
-     * Dispatches to the appropriate transform handler based on step type.
-     */
-    private DispatchTransform;
-    /**
-     * Handles a transform error according to the OnError strategy.
-     */
-    private HandleTransformError;
-    /**
-     * Direct pass-through, applying default value if source is null/undefined.
-     */
-    private ApplyDirect;
-    /**
-     * Applies a regex replacement to a string value.
-     */
-    private ApplyRegex;
-    /**
-     * Splits a string value and extracts a part by index.
-     */
-    private ApplySplit;
-    /**
-     * Combines multiple source fields with a separator.
-     */
-    private ApplyCombine;
-    /**
-     * Performs a case-insensitive value lookup/mapping.
-     */
-    private ApplyLookup;
-    /**
-     * Applies date/number/string formatting.
-     */
-    private ApplyFormat;
-    /**
-     * Basic date formatting supporting ISO and common format tokens.
-     */
-    private FormatDate;
-    /**
-     * Coerces a value to the specified target type.
-     */
-    private ApplyCoerce;
-    /**
-     * Coerces a value to a number, throwing on NaN.
-     */
-    private CoerceToNumber;
-    /**
-     * Coerces a value to boolean, supporting common truthy/falsy strings.
-     */
-    private CoerceToBoolean;
-    /**
-     * Extracts a substring from a string value.
-     */
-    private ApplySubstring;
-    /**
-     * Evaluates a custom JavaScript expression.
-     * The expression has access to `value` (current field value) and `fields` (all record fields).
-     */
-    private ApplyCustom;
-    /**
-     * Returns the compiled function for an expression, compiling and caching on first use.
-     * If the expression failed to compile previously, the cached error is re-thrown — a
-     * malformed expression is compiled exactly once across an entire batch.
-     */
-    private GetCompiledExpression;
-    /**
-     * Compiles a custom expression into a callable, returning the thrown `Error` instead of
-     * propagating it so the caller can cache compile failures alongside successes.
-     */
-    private compileExpression;
 }
 //# sourceMappingURL=FieldMappingEngine.d.ts.map

package/dist/FieldMappingEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FieldMappingEngine.d.ts","sourceRoot":"","sources":["../src/FieldMappingEngine.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAe/D;;;GAGG;AACH,qBAAa,kBAAkB;IAC3B;;;;;;;;;OASG;IACH,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAwD;IAE5F;;;;;;;;OAQG;IACI,KAAK,CACR,OAAO,EAAE,cAAc,EAAE,EACzB,SAAS,EAAE,2BAA2B,EAAE,EACxC,UAAU,EAAE,MAAM,GACnB,YAAY,EAAE;IAKjB;;OAEG;IACH,OAAO,CAAC,eAAe;IAsBvB;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAgBzB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAY9B;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAkB5B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA6BzB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAW5B;;OAEG;IACH,OAAO,CAAC,WAAW;IAOnB;;OAEG;IACH,OAAO,CAAC,UAAU;IAMlB;;OAEG;IACH,OAAO,CAAC,UAAU;IAMlB;;OAEG;IACH,OAAO,CAAC,YAAY;IAKpB;;OAEG;IACH,OAAO,CAAC,WAAW;IASnB;;OAEG;IACH,OAAO,CAAC,WAAW;IAkBnB;;OAEG;IACH,OAAO,CAAC,UAAU;IAOlB;;OAEG;IACH,OAAO,CAAC,WAAW;IAoBnB;;OAEG;IACH,OAAO,CAAC,cAAc;IAUtB;;OAEG;IACH,OAAO,CAAC,eAAe;IAOvB;;OAEG;IACH,OAAO,CAAC,cAAc;IAQtB;;;OAGG;IACH,OAAO,CAAC,WAAW;IAcnB;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAY7B;;;OAGG;IACH,OAAO,CAAC,iBAAiB;CAQ5B"}
+{"version":3,"file":"FieldMappingEngine.d.ts","sourceRoot":"","sources":["../src/FieldMappingEngine.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/D;;;;;;;;;;;GAWG;AACH,qBAAa,kBAAkB;IAC3B,6FAA6F;IAC7F,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA8B;IAE9D;;;;;;;;OAQG;IACI,KAAK,CACR,OAAO,EAAE,cAAc,EAAE,EACzB,SAAS,EAAE,2BAA2B,EAAE,EACxC,UAAU,EAAE,MAAM,GACnB,YAAY,EAAE;IAKjB;;OAEG;IACH,OAAO,CAAC,eAAe;IAyCvB;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAUzB;;OAEG;IACH,OAAO,CAAC,sBAAsB;CAWjC"}