@memberjunction/integration-engine 5.49.0 → 5.51.0

package/dist/RecordMapBatch.d.ts

@@ -0,0 +1,162 @@
+import { IMetadataProvider, type UserInfo } from '@memberjunction/core';
+/** One external↔MJ mapping awaiting write. */
+export interface PendingRecordMap {
+    /** The MJ entity the mapping is for. Batches are keyed on this + CompanyIntegrationID. */
+    EntityID: string;
+    /** The external system's ID for the record. */
+    ExternalID: string;
+    /** The MJ record's primary key, '|'-joined for composite PKs. */
+    EntityRecordID: string;
+}
+/** A mapping that did not make it to the database, with the reason. */
+export interface RecordMapFailure {
+    ExternalID: string;
+    EntityID: string;
+    ErrorMessage: string;
+}
+/**
+ * Batched writer for `MJ: Company Integration Record Maps`.
+ *
+ * **Why this exists.** The per-record `SaveRecordMap` costs three round trips — a `RunView` to
+ * find an existing mapping, a `Load`, and a `Save` — for *every* record the sync touches,
+ * including records it decided not to change. On a no-change full sync that is roughly 60% of
+ * the total cost: we pay full price to discover there is nothing to do.
+ *
+ * **What it does instead.** It queues mappings and resolves a whole chunk against the database in
+ * ONE `RunView`, then writes only the rows that are actually new or actually point somewhere
+ * different. On an incremental sync where mappings are stable that is one read and zero writes
+ * per chunk, against 3N round trips before.
+ *
+ * **Every write goes through the provider's entity layer, never hand-written SQL.** `RunView` and
+ * `GetEntityObject`/`Save()` are dialect-agnostic by construction — `Save()` lands in the
+ * CodeGen-generated `spCreate`/`spUpdate` for the entity, on whichever platform the provider is —
+ * so this file contains no SQL text, no `ExecuteSQL`, and no platform branch that could be right
+ * on SQL Server and wrong on Postgres. The one place SQL text is unavoidable is a `RunView`
+ * `ExtraFilter`, and both its identifiers and its literals are quoted through the provider's own
+ * dialect, the same seam `buildContentHashPrefetchFilter` uses.
+ *
+ * Going through the entity layer also means the writes get everything a direct statement would
+ * have skipped: field validation, `__mj_CreatedAt`/`__mj_UpdatedAt`, Record Changes tracking, and
+ * — the one that bites silently — the save event that drives `LocalCacheManager` invalidation.
+ * This entity is read by `RunView` elsewhere in this engine, so a raw `UPDATE` here would leave
+ * those cached reads stale until their TTL (see `ScheduledJobEngine.updateJobStatistics`, which
+ * has to invalidate by hand for exactly that reason).
+ *
+ * **Per-row error attribution is the hard requirement, not an extra.** Batching without it trades
+ * a slow correct sync for a fast wrong one: one malformed row would silently take out its 499
+ * neighbours. Here attribution is structural rather than reconstructed — each mapping is its own
+ * `Save()` returning its own boolean, so a failure names the row that failed and the other rows in
+ * the chunk are unaffected. There is no read-back-and-diff step because there is nothing to
+ * reconstruct.
+ *
+ * **Durability note.** Mappings are written slightly later than the record they describe, so a
+ * process killed between the two loses that window's map rows. That is recoverable by design:
+ * the next sync re-matches those records by primary key (see `MatchEngine.FindByKeyFields`) and
+ * re-establishes the mapping. It cannot produce duplicates — the write is an upsert keyed on
+ * (CompanyIntegration, Entity, ExternalID).
+ */
+export declare class RecordMapBatch {
+    private readonly provider;
+    private readonly companyIntegrationID;
+    private readonly contextUser;
+    private readonly saveSingle;
+    /**
+     * Hard ceiling on the chunk size. A chunk becomes one `IN (…)` list in a `RunView` filter, so
+     * the filter text grows linearly with the chunk; past 5,000 IDs it starts approaching filter
+     * length and query-plan limits on both platforms.
+     */
+    static readonly CHUNK_SIZE_CEILING = 5000;
+    /**
+     * Chunk size. 500 keeps the generated filter well inside length limits.
+     * Read from MJ_INTEGRATION_RECORD_MAP_CHUNK_SIZE at class-init and clamped to
+     * [1, CHUNK_SIZE_CEILING].
+     */
+    static readonly ChunkSize: number;
+    /**
+     * How many map rows are saved concurrently within a chunk.
+     *
+     * The writes are independent — each is its own row, keyed on its own external ID — so they do
+     * not have to be serialized. Bounded rather than unbounded so a first-ever sync of a large
+     * entity cannot open 500 simultaneous requests against the connection pool the rest of the
+     * sync is also using.
+     */
+    static readonly WriteConcurrency = 10;
+    /** Reads + clamps the chunk size from env; warns once when a configured value is clamped down. */
+    private static computeChunkSize;
+    /**
+     * Queued mappings, keyed `EntityID|ExternalID` — the upsert's own key, so the map both
+     * dedups and preserves queue order (JS Maps iterate in insertion order). A Map rather than
+     * an array because dedup on every Queue() would otherwise be a scan of the whole batch.
+     */
+    private pending;
+    private failures;
+    /** The dedup key. EntityID is a UUID, so the separator cannot appear in the left half. */
+    private static pendingKey;
+    /**
+     * @param provider          the provider that owns this sync's connection
+     * @param companyIntegrationID the CompanyIntegration all queued mappings belong to
+     * @param contextUser       user context for the writes
+     * @param saveSingle        the original one-row upsert, used when the chunk read fails
+     */
+    constructor(provider: IMetadataProvider, companyIntegrationID: string, contextUser: UserInfo, saveSingle: (companyIntegrationID: string, externalID: string, entityID: string, entityRecordID: string, contextUser: UserInfo) => Promise<void>);
+    /** Mappings that failed to write, with the external ID that owns each failure. */
+    get Failures(): readonly RecordMapFailure[];
+    /** Returns the failures accumulated so far and clears them, so a caller reports each once. */
+    TakeFailures(): RecordMapFailure[];
+    /**
+     * Drops everything queued but not yet written.
+     *
+     * Called when the batch transaction that produced these mappings rolled back: the records
+     * they point at do not exist, so writing the mappings would leave the map pointing at
+     * nothing. The per-record retry path re-queues whatever actually commits.
+     */
+    Discard(): void;
+    /**
+     * Queues a mapping. **Never writes** — the caller decides when a flush is safe.
+     *
+     * Queuing deliberately does not auto-flush on a full chunk. Queue() is called from inside the
+     * apply pass's batch transaction, and a flush fired from there would write map rows within
+     * that transaction, which `Discard()` could no longer un-queue on rollback. The apply loop
+     * calls {@link Flush} once per batch, after commit — which also bounds `pending` to one
+     * batch's worth of mappings.
+     *
+     * Queuing the same external ID twice within a window keeps only the latest — the mapping is
+     * an upsert, so the last value written would win anyway.
+     */
+    Queue(mapping: PendingRecordMap): void;
+    /** Writes everything queued. Safe to call repeatedly; a no-op when the queue is empty. */
+    Flush(): Promise<void>;
+    /**
+     * Resolves one chunk against the database in a single read, then writes only what differs.
+     *
+     * A mapping whose row already points at the same MJ record needs no write at all — that is
+     * the common case on an incremental sync and the reason this is cheaper than the per-record
+     * path even though the writes themselves are per-row.
+     */
+    private flushChunk;
+    /**
+     * Reads the chunk's existing map rows in one query, keyed by external ID. Returns null when
+     * the read fails, which is deliberately distinct from an empty map (read succeeded, nothing
+     * there) — the two lead to different write paths.
+     */
+    private readExisting;
+    /**
+     * Writes one mapping through the provider's entity layer — update in place when a row already
+     * exists, insert otherwise. A failure is attributed to this external ID and nothing else.
+     */
+    private writeOne;
+    /** Fallback when the chunk read failed: one row at a time through the original upsert. */
+    private writeIndividually;
+    /**
+     * The provider's dialect, for the one place SQL text is unavoidable — a `RunView`
+     * `ExtraFilter`. Same seam `buildContentHashPrefetchFilter` uses, so both filters this engine
+     * builds quote by the platform's own rule rather than a hand-rolled `replace(/'/g, "''")`
+     * that happens to match it today.
+     *
+     * Narrowed with `instanceof` rather than cast: `IMetadataProvider` in general carries no
+     * dialect (a client-side provider has none), and null routes to the per-row path instead of
+     * guessing an escaping rule.
+     */
+    private get quoter();
+}
+//# sourceMappingURL=RecordMapBatch.d.ts.map

package/dist/RecordMapBatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordMapBatch.d.ts","sourceRoot":"","sources":["../src/RecordMapBatch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,iBAAiB,EAAW,KAAK,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAIvG,8CAA8C;AAC9C,MAAM,WAAW,gBAAgB;IAC7B,0FAA0F;IAC1F,QAAQ,EAAE,MAAM,CAAC;IACjB,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,cAAc,EAAE,MAAM,CAAC;CAC1B;AAED,uEAAuE;AACvE,MAAM,WAAW,gBAAgB;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACxB;AAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,cAAc;IAyDnB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,oBAAoB;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,UAAU;IA3D/B;;;;OAIG;IACH,gBAAuB,kBAAkB,QAAS;IAElD;;;;OAIG;IACH,gBAAuB,SAAS,SAAqC;IAErE;;;;;;;OAOG;IACH,gBAAuB,gBAAgB,MAAM;IAE7C,kGAAkG;IAClG,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAW/B;;;;OAIG;IACH,OAAO,CAAC,OAAO,CAAuC;IACtD,OAAO,CAAC,QAAQ,CAA0B;IAE1C,0FAA0F;IAC1F,OAAO,CAAC,MAAM,CAAC,UAAU;IAIzB;;;;;OAKG;gBAEkB,QAAQ,EAAE,iBAAiB,EAC3B,oBAAoB,EAAE,MAAM,EAC5B,WAAW,EAAE,QAAQ,EACrB,UAAU,EAAE,CACzB,oBAAoB,EAAE,MAAM,EAC5B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,QAAQ,KACpB,OAAO,CAAC,IAAI,CAAC;IAGtB,kFAAkF;IAClF,IAAW,QAAQ,IAAI,SAAS,gBAAgB,EAAE,CAEjD;IAED,8FAA8F;IACvF,YAAY,IAAI,gBAAgB,EAAE;IAMzC;;;;;;OAMG;IACI,OAAO,IAAI,IAAI;IAItB;;;;;;;;;;;OAWG;IACI,KAAK,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAI7C,0FAA0F;IAC7E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAsBnC;;;;;;OAMG;YACW,UAAU;IAiBxB;;;;OAIG;YACW,YAAY;IAoC1B;;;OAGG;YACW,QAAQ;IAqCtB,0FAA0F;YAC5E,iBAAiB;IAmB/B;;;;;;;;;OASG;IACH,OAAO,KAAK,MAAM,GAEjB;CACJ"}

package/dist/RecordMapBatch.js

@@ -0,0 +1,283 @@
+import { DatabaseProviderBase, RunView } from '@memberjunction/core';
+import { quoteTextLiteral } from './prefetchFilter.js';
+/**
+ * Batched writer for `MJ: Company Integration Record Maps`.
+ *
+ * **Why this exists.** The per-record `SaveRecordMap` costs three round trips — a `RunView` to
+ * find an existing mapping, a `Load`, and a `Save` — for *every* record the sync touches,
+ * including records it decided not to change. On a no-change full sync that is roughly 60% of
+ * the total cost: we pay full price to discover there is nothing to do.
+ *
+ * **What it does instead.** It queues mappings and resolves a whole chunk against the database in
+ * ONE `RunView`, then writes only the rows that are actually new or actually point somewhere
+ * different. On an incremental sync where mappings are stable that is one read and zero writes
+ * per chunk, against 3N round trips before.
+ *
+ * **Every write goes through the provider's entity layer, never hand-written SQL.** `RunView` and
+ * `GetEntityObject`/`Save()` are dialect-agnostic by construction — `Save()` lands in the
+ * CodeGen-generated `spCreate`/`spUpdate` for the entity, on whichever platform the provider is —
+ * so this file contains no SQL text, no `ExecuteSQL`, and no platform branch that could be right
+ * on SQL Server and wrong on Postgres. The one place SQL text is unavoidable is a `RunView`
+ * `ExtraFilter`, and both its identifiers and its literals are quoted through the provider's own
+ * dialect, the same seam `buildContentHashPrefetchFilter` uses.
+ *
+ * Going through the entity layer also means the writes get everything a direct statement would
+ * have skipped: field validation, `__mj_CreatedAt`/`__mj_UpdatedAt`, Record Changes tracking, and
+ * — the one that bites silently — the save event that drives `LocalCacheManager` invalidation.
+ * This entity is read by `RunView` elsewhere in this engine, so a raw `UPDATE` here would leave
+ * those cached reads stale until their TTL (see `ScheduledJobEngine.updateJobStatistics`, which
+ * has to invalidate by hand for exactly that reason).
+ *
+ * **Per-row error attribution is the hard requirement, not an extra.** Batching without it trades
+ * a slow correct sync for a fast wrong one: one malformed row would silently take out its 499
+ * neighbours. Here attribution is structural rather than reconstructed — each mapping is its own
+ * `Save()` returning its own boolean, so a failure names the row that failed and the other rows in
+ * the chunk are unaffected. There is no read-back-and-diff step because there is nothing to
+ * reconstruct.
+ *
+ * **Durability note.** Mappings are written slightly later than the record they describe, so a
+ * process killed between the two loses that window's map rows. That is recoverable by design:
+ * the next sync re-matches those records by primary key (see `MatchEngine.FindByKeyFields`) and
+ * re-establishes the mapping. It cannot produce duplicates — the write is an upsert keyed on
+ * (CompanyIntegration, Entity, ExternalID).
+ */
+export class RecordMapBatch {
+    /**
+     * Hard ceiling on the chunk size. A chunk becomes one `IN (…)` list in a `RunView` filter, so
+     * the filter text grows linearly with the chunk; past 5,000 IDs it starts approaching filter
+     * length and query-plan limits on both platforms.
+     */
+    static { this.CHUNK_SIZE_CEILING = 5_000; }
+    /**
+     * Chunk size. 500 keeps the generated filter well inside length limits.
+     * Read from MJ_INTEGRATION_RECORD_MAP_CHUNK_SIZE at class-init and clamped to
+     * [1, CHUNK_SIZE_CEILING].
+     */
+    static { this.ChunkSize = RecordMapBatch.computeChunkSize(); }
+    /**
+     * How many map rows are saved concurrently within a chunk.
+     *
+     * The writes are independent — each is its own row, keyed on its own external ID — so they do
+     * not have to be serialized. Bounded rather than unbounded so a first-ever sync of a large
+     * entity cannot open 500 simultaneous requests against the connection pool the rest of the
+     * sync is also using.
+     */
+    static { this.WriteConcurrency = 10; }
+    /** Reads + clamps the chunk size from env; warns once when a configured value is clamped down. */
+    static computeChunkSize() {
+        const ceiling = RecordMapBatch.CHUNK_SIZE_CEILING;
+        const raw = parseInt(process.env.MJ_INTEGRATION_RECORD_MAP_CHUNK_SIZE ?? '', 10);
+        if (!Number.isFinite(raw) || raw <= 0)
+            return 500;
+        if (raw > ceiling) {
+            console.warn(`[RecordMapBatch] MJ_INTEGRATION_RECORD_MAP_CHUNK_SIZE=${raw} exceeds the maximum ${ceiling} — clamped to ${ceiling}.`);
+            return ceiling;
+        }
+        return raw;
+    }
+    /** The dedup key. EntityID is a UUID, so the separator cannot appear in the left half. */
+    static pendingKey(entityID, externalID) {
+        return `${entityID}|${externalID}`;
+    }
+    /**
+     * @param provider          the provider that owns this sync's connection
+     * @param companyIntegrationID the CompanyIntegration all queued mappings belong to
+     * @param contextUser       user context for the writes
+     * @param saveSingle        the original one-row upsert, used when the chunk read fails
+     */
+    constructor(provider, companyIntegrationID, contextUser, saveSingle) {
+        this.provider = provider;
+        this.companyIntegrationID = companyIntegrationID;
+        this.contextUser = contextUser;
+        this.saveSingle = saveSingle;
+        /**
+         * Queued mappings, keyed `EntityID|ExternalID` — the upsert's own key, so the map both
+         * dedups and preserves queue order (JS Maps iterate in insertion order). A Map rather than
+         * an array because dedup on every Queue() would otherwise be a scan of the whole batch.
+         */
+        this.pending = new Map();
+        this.failures = [];
+    }
+    /** Mappings that failed to write, with the external ID that owns each failure. */
+    get Failures() {
+        return this.failures;
+    }
+    /** Returns the failures accumulated so far and clears them, so a caller reports each once. */
+    TakeFailures() {
+        const taken = this.failures;
+        this.failures = [];
+        return taken;
+    }
+    /**
+     * Drops everything queued but not yet written.
+     *
+     * Called when the batch transaction that produced these mappings rolled back: the records
+     * they point at do not exist, so writing the mappings would leave the map pointing at
+     * nothing. The per-record retry path re-queues whatever actually commits.
+     */
+    Discard() {
+        this.pending.clear();
+    }
+    /**
+     * Queues a mapping. **Never writes** — the caller decides when a flush is safe.
+     *
+     * Queuing deliberately does not auto-flush on a full chunk. Queue() is called from inside the
+     * apply pass's batch transaction, and a flush fired from there would write map rows within
+     * that transaction, which `Discard()` could no longer un-queue on rollback. The apply loop
+     * calls {@link Flush} once per batch, after commit — which also bounds `pending` to one
+     * batch's worth of mappings.
+     *
+     * Queuing the same external ID twice within a window keeps only the latest — the mapping is
+     * an upsert, so the last value written would win anyway.
+     */
+    Queue(mapping) {
+        this.pending.set(RecordMapBatch.pendingKey(mapping.EntityID, mapping.ExternalID), mapping);
+    }
+    /** Writes everything queued. Safe to call repeatedly; a no-op when the queue is empty. */
+    async Flush() {
+        if (this.pending.size === 0)
+            return;
+        const queued = Array.from(this.pending.values());
+        this.pending.clear();
+        // Group by entity: the mapping's identity includes EntityID, so a chunk read has to be
+        // scoped to one entity to be answerable in a single filter.
+        const byEntity = new Map();
+        for (const m of queued) {
+            const bucket = byEntity.get(m.EntityID);
+            if (bucket)
+                bucket.push(m);
+            else
+                byEntity.set(m.EntityID, [m]);
+        }
+        for (const [entityID, mappings] of byEntity) {
+            for (let i = 0; i < mappings.length; i += RecordMapBatch.ChunkSize) {
+                await this.flushChunk(entityID, mappings.slice(i, i + RecordMapBatch.ChunkSize));
+            }
+        }
+    }
+    /**
+     * Resolves one chunk against the database in a single read, then writes only what differs.
+     *
+     * A mapping whose row already points at the same MJ record needs no write at all — that is
+     * the common case on an incremental sync and the reason this is cheaper than the per-record
+     * path even though the writes themselves are per-row.
+     */
+    async flushChunk(entityID, chunk) {
+        const existing = await this.readExisting(entityID, chunk);
+        if (!existing) {
+            // The read is what makes the batched path safe; without it we cannot tell an insert
+            // from an update, and guessing either way produces a duplicate map row. Fall back to
+            // the per-record upsert, which does its own read.
+            await this.writeIndividually(entityID, chunk);
+            return;
+        }
+        const work = chunk.filter(m => existing.get(m.ExternalID)?.EntityRecordID !== m.EntityRecordID);
+        for (let i = 0; i < work.length; i += RecordMapBatch.WriteConcurrency) {
+            const slice = work.slice(i, i + RecordMapBatch.WriteConcurrency);
+            await Promise.all(slice.map(m => this.writeOne(entityID, m, existing.get(m.ExternalID)?.ID)));
+        }
+    }
+    /**
+     * Reads the chunk's existing map rows in one query, keyed by external ID. Returns null when
+     * the read fails, which is deliberately distinct from an empty map (read succeeded, nothing
+     * there) — the two lead to different write paths.
+     */
+    async readExisting(entityID, chunk) {
+        const q = this.quoter;
+        if (!q)
+            return null; // no dialect to quote with — the per-row path resolves each row itself
+        // The external IDs are the only free-text values here (the other two are UUIDs), and they
+        // are compared against an nvarchar column — see `quoteTextLiteral`.
+        const inList = chunk.map(m => quoteTextLiteral(m.ExternalID, q)).join(',');
+        const rv = new RunView();
+        const result = await rv.RunView({
+            EntityName: 'MJ: Company Integration Record Maps',
+            ExtraFilter: `${q.QuoteIdentifier('CompanyIntegrationID')}=${q.QuoteStringLiteral(this.companyIntegrationID)} ` +
+                `AND ${q.QuoteIdentifier('EntityID')}=${q.QuoteStringLiteral(entityID)} ` +
+                `AND ${q.QuoteIdentifier('ExternalSystemRecordID')} IN (${inList})`,
+            Fields: ['ID', 'ExternalSystemRecordID', 'EntityRecordID'],
+            IgnoreMaxRows: true, // a chunk can exceed the entity's default row cap
+            ResultType: 'simple',
+            BypassCache: true, // this decides INSERT vs UPDATE; a stale miss duplicates the row
+        }, this.contextUser);
+        if (!result.Success)
+            return null;
+        const byExternalID = new Map();
+        for (const row of result.Results) {
+            // First row wins if the table somehow carries a duplicate for this key: writing to
+            // whichever we saw last would flip the mapping between syncs for no reason.
+            if (!byExternalID.has(row.ExternalSystemRecordID)) {
+                byExternalID.set(row.ExternalSystemRecordID, { ID: row.ID, EntityRecordID: row.EntityRecordID });
+            }
+        }
+        return byExternalID;
+    }
+    /**
+     * Writes one mapping through the provider's entity layer — update in place when a row already
+     * exists, insert otherwise. A failure is attributed to this external ID and nothing else.
+     */
+    async writeOne(entityID, mapping, existingID) {
+        try {
+            const recordMap = await this.provider.GetEntityObject('MJ: Company Integration Record Maps', this.contextUser);
+            if (existingID) {
+                const loaded = await recordMap.Load(existingID);
+                // The row was read a moment ago, so a failure to load means it has since been
+                // deleted. Insert rather than abandon the mapping.
+                if (!loaded)
+                    recordMap.NewRecord();
+            }
+            else {
+                recordMap.NewRecord();
+            }
+            recordMap.CompanyIntegrationID = this.companyIntegrationID;
+            recordMap.EntityID = entityID;
+            recordMap.ExternalSystemRecordID = mapping.ExternalID;
+            recordMap.EntityRecordID = mapping.EntityRecordID;
+            if (!await recordMap.Save()) {
+                this.failures.push({
+                    ExternalID: mapping.ExternalID,
+                    EntityID: entityID,
+                    ErrorMessage: `Record map write failed: ${recordMap.LatestResult?.CompleteMessage ?? 'unknown error'}`,
+                });
+            }
+        }
+        catch (err) {
+            this.failures.push({
+                ExternalID: mapping.ExternalID,
+                EntityID: entityID,
+                ErrorMessage: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    /** Fallback when the chunk read failed: one row at a time through the original upsert. */
+    async writeIndividually(entityID, chunk) {
+        console.warn(`[RecordMapBatch] Could not read existing record maps for ${chunk.length} mapping(s); ` +
+            `falling back to per-row upserts so each row resolves itself.`);
+        for (const m of chunk) {
+            try {
+                await this.saveSingle(this.companyIntegrationID, m.ExternalID, entityID, m.EntityRecordID, this.contextUser);
+            }
+            catch (err) {
+                this.failures.push({
+                    ExternalID: m.ExternalID,
+                    EntityID: entityID,
+                    ErrorMessage: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+    }
+    /**
+     * The provider's dialect, for the one place SQL text is unavoidable — a `RunView`
+     * `ExtraFilter`. Same seam `buildContentHashPrefetchFilter` uses, so both filters this engine
+     * builds quote by the platform's own rule rather than a hand-rolled `replace(/'/g, "''")`
+     * that happens to match it today.
+     *
+     * Narrowed with `instanceof` rather than cast: `IMetadataProvider` in general carries no
+     * dialect (a client-side provider has none), and null routes to the per-row path instead of
+     * guessing an escaping rule.
+     */
+    get quoter() {
+        return this.provider instanceof DatabaseProviderBase ? this.provider.Dialect : null;
+    }
+}
+//# sourceMappingURL=RecordMapBatch.js.map

package/dist/RecordMapBatch.js.map

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

package/dist/prefetchFilter.d.ts

@@ -11,11 +11,29 @@
  * targets, so it does NOT reintroduce the "SS brackets break Postgres" problem that motivated the
  * previous (unsafe) unquoted form.
  */
+import type { DatabasePlatform } from '@memberjunction/core';
 /** The minimal dialect surface this builder needs; satisfied by `DatabaseProviderBase.Dialect` (SQLDialect). */
 export interface SqlQuoter {
     QuoteIdentifier(name: string): string;
     QuoteStringLiteral(value: string): string;
+    /** Which platform the quoter is for. Always present on a real `SQLDialect`. */
+    PlatformKey?: DatabasePlatform;
 }
+/**
+ * Quotes a value as a string literal that a **Unicode text column** comparison will actually match.
+ *
+ * On SQL Server a bare `'…'` is a *varchar* literal: every character outside the database's
+ * collation codepage is replaced with `?` before the comparison runs. On the default
+ * `SQL_Latin1_General_CP1_CI_AS`, an external ID of `ünïcödé-Ω-日本語` becomes `ünïcödé-O-???`, so
+ * `ExternalSystemRecordID = '…'` matches the (nvarchar) row zero times — the record reads as
+ * unmapped and the sync creates it a second time in the customer's external system. `N'…'` makes
+ * the literal nvarchar, which is what every MJ string column already is, so there is no implicit
+ * conversion on the column and the index seek is unaffected.
+ *
+ * PostgreSQL literals are already Unicode and it has no `N` prefix, hence the platform check
+ * rather than an unconditional prefix.
+ */
+export declare function quoteTextLiteral(value: string, q: SqlQuoter): string;
 /**
  * @param pkNames the entity's primary-key field name(s), in `PrimaryKeys` order.
  * @param ids     the `MatchedMJRecordID` values — a single value per record for a single PK, or the

package/dist/prefetchFilter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prefetchFilter.d.ts","sourceRoot":"","sources":["../src/prefetchFilter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,gHAAgH;AAChH,MAAM,WAAW,SAAS;IACtB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IACtC,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;CAC7C;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,SAAS,GAAG,MAAM,CAarG"}
+{"version":3,"file":"prefetchFilter.d.ts","sourceRoot":"","sources":["../src/prefetchFilter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,gHAAgH;AAChH,MAAM,WAAW,SAAS;IACtB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IACtC,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1C,+EAA+E;IAC/E,WAAW,CAAC,EAAE,gBAAgB,CAAC;CAClC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,SAAS,GAAG,MAAM,CAGpE;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,SAAS,GAAG,MAAM,CAarG"}

package/dist/prefetchFilter.js

@@ -1,16 +1,21 @@
 /**
- * Builds the WHERE filter for the content-hash prefetch (`IntegrationEngine.PrefetchContentHashes`)
- * — the bulk stored-hash lookup that powers the idempotent-skip fast path.
+ * Quotes a value as a string literal that a **Unicode text column** comparison will actually match.
  *
- * Both the PK identifier(s) AND the value literals are quoted through the provider's SQL dialect.
- * Quoting the IDENTIFIER is the fix for MJ#3047: an integration object whose PK column name is a SQL
- * reserved word (e.g. Zendesk `custom_objects.key`) otherwise yields `WHERE key IN (...)`, which the
- * database rejects. `PrefetchContentHashes` swallows that error (best-effort), so the prefetch returns
- * empty and the content-hash idempotency skip can never engage — every unchanged record is re-written
- * on each sync. Dialect-aware quoting (SQL Server `[key]`, PostgreSQL `"key"`) keeps it valid on both
- * targets, so it does NOT reintroduce the "SS brackets break Postgres" problem that motivated the
- * previous (unsafe) unquoted form.
+ * On SQL Server a bare `'…'` is a *varchar* literal: every character outside the database's
+ * collation codepage is replaced with `?` before the comparison runs. On the default
+ * `SQL_Latin1_General_CP1_CI_AS`, an external ID of `ünïcödé-Ω-日本語` becomes `ünïcödé-O-???`, so
+ * `ExternalSystemRecordID = '…'` matches the (nvarchar) row zero times — the record reads as
+ * unmapped and the sync creates it a second time in the customer's external system. `N'…'` makes
+ * the literal nvarchar, which is what every MJ string column already is, so there is no implicit
+ * conversion on the column and the index seek is unaffected.
+ *
+ * PostgreSQL literals are already Unicode and it has no `N` prefix, hence the platform check
+ * rather than an unconditional prefix.
  */
+export function quoteTextLiteral(value, q) {
+    const quoted = q.QuoteStringLiteral(value);
+    return q.PlatformKey === 'sqlserver' ? `N${quoted}` : quoted;
+}
 /**
  * @param pkNames the entity's primary-key field name(s), in `PrimaryKeys` order.
  * @param ids     the `MatchedMJRecordID` values — a single value per record for a single PK, or the

package/dist/prefetchFilter.js.map

@@ -1 +1 @@
-{"version":3,"file":"prefetchFilter.js","sourceRoot":"","sources":["../src/prefetchFilter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAQH;;;;;;GAMG;AACH,MAAM,UAAU,8BAA8B,CAAC,OAAiB,EAAE,GAAa,EAAE,CAAY;IACzF,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,4CAA4C;QAC5C,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACzE,OAAO,GAAG,CAAC,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,MAAM,GAAG,CAAC;IAC7D,CAAC;IACD,2FAA2F;IAC3F,mFAAmF;IACnF,OAAO,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;QACjB,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACrC,OAAO,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CACjC,GAAG,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,kBAAkB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,GAAG,CAAC;IAC5G,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AACpB,CAAC"}
+{"version":3,"file":"prefetchFilter.js","sourceRoot":"","sources":["../src/prefetchFilter.ts"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAa,EAAE,CAAY;IACxD,MAAM,MAAM,GAAG,CAAC,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;IAC3C,OAAO,CAAC,CAAC,WAAW,KAAK,WAAW,CAAC,CAAC,CAAC,IAAI,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;AACjE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,8BAA8B,CAAC,OAAiB,EAAE,GAAa,EAAE,CAAY;IACzF,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,4CAA4C;QAC5C,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,kBAAkB,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACzE,OAAO,GAAG,CAAC,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,MAAM,GAAG,CAAC;IAC7D,CAAC;IACD,2FAA2F;IAC3F,mFAAmF;IACnF,OAAO,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;QACjB,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACrC,OAAO,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CACjC,GAAG,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,kBAAkB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,GAAG,CAAC;IAC5G,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AACpB,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@memberjunction/integration-engine",
   "type": "module",
-  "version": "5.49.0",
+  "version": "5.51.0",
   "description": "MemberJunction Integration Engine - orchestration, field mapping, and connector framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,12 +14,12 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@memberjunction/core": "5.49.0",
-    "@memberjunction/core-entities": "5.49.0",
-    "@memberjunction/global": "5.49.0",
-    "@memberjunction/integration-engine-base": "5.49.0",
-    "@memberjunction/integration-pk-classifier": "5.49.0",
-    "@memberjunction/integration-progress-artifacts": "5.49.0"
+    "@memberjunction/core": "5.51.0",
+    "@memberjunction/core-entities": "5.51.0",
+    "@memberjunction/global": "5.51.0",
+    "@memberjunction/integration-engine-base": "5.51.0",
+    "@memberjunction/integration-pk-classifier": "5.51.0",
+    "@memberjunction/integration-progress-artifacts": "5.51.0"
   },
   "devDependencies": {
     "tsc-alias": "^1.8.16",