meadow-integration 1.0.23 → 1.0.25

package/source/services/clone/Meadow-Service-Sync-Entity-OngoingEventualConsistency.js

@@ -0,0 +1,353 @@
+const libMeadowSyncEntityOngoing = require('./Meadow-Service-Sync-Entity-Ongoing.js');
+
+class MeadowSyncEntityOngoingEventualConsistency extends libMeadowSyncEntityOngoing
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'MeadowSyncEntityOngoingEventualConsistency';
+
+		// Milliseconds devoted to backwards bisection of existing records before
+		// moving on to pull new records.  Default 30 seconds.
+		this.BackSyncTimeLimit = (typeof(this.options.BackSyncTimeLimit) === 'number')
+			? this.options.BackSyncTimeLimit
+			: 30000;
+	}
+
+	// Bisect an ID range with a time budget.  Checks the budget at the start of
+	// each recursive call and stops when time is exhausted.  Otherwise identical
+	// to the inherited _bisectRange, except it subdivides upper-half-first so
+	// that the most recently created records (high IDs) are prioritized.
+	_bisectRangeWithTimeBudget(pMinID, pMaxID, pDepth, pStartTime, pTimeLimit, fCallback)
+	{
+		// Time budget check
+		if (Date.now() - pStartTime >= pTimeLimit)
+		{
+			return fCallback();
+		}
+
+		// Global record cap check
+		if (this.MaxRecordsPerEntity > 0 && this._totalSyncedThisSync >= this.MaxRecordsPerEntity)
+		{
+			return fCallback();
+		}
+
+		const tmpRangeSize = pMaxID - pMinID + 1;
+		const tmpIDCol = this.DefaultIdentifier;
+		const tmpRangeFilter = `FBV~${tmpIDCol}~GE~${pMinID}~FBV~${tmpIDCol}~LE~${pMaxID}`;
+
+		this._getLocalCount(pMinID, pMaxID,
+			(pLocalCountError, pLocalCount) =>
+			{
+				if (pLocalCountError)
+				{
+					this.fable.log.warn(`${this.EntitySchema.TableName}: bisect local count error for range ${pMinID}-${pMaxID}: ${pLocalCountError}`);
+					return fCallback();
+				}
+
+				this._getServerCount(tmpRangeFilter,
+					(pServerCountError, pServerCount) =>
+					{
+						if (pServerCountError)
+						{
+							this.fable.log.warn(`${this.EntitySchema.TableName}: bisect server count error for range ${pMinID}-${pMaxID}: ${pServerCountError}`);
+							return fCallback();
+						}
+
+						if (pLocalCount === pServerCount)
+						{
+							if (!this._hasUpdateDate)
+							{
+								this._incrementProgress(pServerCount);
+								return fCallback();
+							}
+
+							this._getLocalMaxUpdateDate(pMinID, pMaxID,
+								(pLocalMaxErr, pLocalMaxDate) =>
+								{
+									if (pLocalMaxErr || !pLocalMaxDate)
+									{
+										return fCallback();
+									}
+
+									const tmpMaxDateFilter = `${tmpRangeFilter}~FSF~UpdateDate~DESC~DESC`;
+									this._getServerRecords(tmpMaxDateFilter, 0, 1,
+										(pServerMaxErr, pServerMaxRecords) =>
+										{
+											if (pServerMaxErr || !pServerMaxRecords || pServerMaxRecords.length < 1)
+											{
+												return fCallback();
+											}
+
+											const tmpServerMaxDate = pServerMaxRecords[0].UpdateDate;
+											const tmpMaxDateDiff = Math.abs(this._normalizeDateUTC(pLocalMaxDate).diff(this._normalizeDateUTC(tmpServerMaxDate)));
+
+											if (tmpMaxDateDiff <= this.DateTimePrecisionMS)
+											{
+												this._incrementProgress(pServerCount);
+												return fCallback();
+											}
+
+											this.fable.log.info(`${this.EntitySchema.TableName}: date mismatch in range ${pMinID}-${pMaxID} (local max: ${pLocalMaxDate}, server max: ${tmpServerMaxDate})`);
+											if (tmpRangeSize <= this.BisectMinRangeSize)
+											{
+												return this._pullRangeFromServer(pMinID, pMaxID, fCallback);
+											}
+											return this._subdivideRangeReversed(pMinID, pMaxID, pDepth, pStartTime, pTimeLimit, fCallback);
+										});
+								});
+							return;
+						}
+
+						// Counts differ
+						this.fable.log.info(`${this.EntitySchema.TableName}: count mismatch in range ${pMinID}-${pMaxID} (local: ${pLocalCount}, server: ${pServerCount})`);
+
+						if (tmpRangeSize <= this.BisectMinRangeSize)
+						{
+							return this._pullRangeFromServer(pMinID, pMaxID, fCallback);
+						}
+
+						return this._subdivideRangeReversed(pMinID, pMaxID, pDepth, pStartTime, pTimeLimit, fCallback);
+					});
+			});
+	}
+
+	// Split a range in half and bisect the UPPER half first so that recently
+	// created/modified records (high IDs) are checked before older records.
+	_subdivideRangeReversed(pMinID, pMaxID, pDepth, pStartTime, pTimeLimit, fCallback)
+	{
+		const tmpMidID = Math.floor((pMinID + pMaxID) / 2);
+
+		this.fable.log.info(`${this.EntitySchema.TableName}: subdividing range ${pMinID}-${pMaxID} at ID ${tmpMidID} (depth ${pDepth}, upper half first)`);
+
+		// Upper half first (reversed from standard bisection)
+		this._bisectRangeWithTimeBudget(tmpMidID + 1, pMaxID, pDepth + 1, pStartTime, pTimeLimit,
+			() =>
+			{
+				// Then lower half (if time remains -- checked at entry of next call)
+				this._bisectRangeWithTimeBudget(pMinID, tmpMidID, pDepth + 1, pStartTime, pTimeLimit, fCallback);
+			});
+	}
+
+	_syncInternal(fCallback)
+	{
+		this.operation.createTimeStamp('EntityOngoingEventualConsistencySync');
+
+		this._totalSyncedThisSync = 0;
+		this._recordsCreated = 0;
+		this._recordsUpdated = 0;
+
+		const tmpSyncState = (
+			{
+				Local: { MaxIDEntity: -1, RecordCount: 0 },
+				Server: { MaxIDEntity: -1, RecordCount: 0 },
+			});
+
+		this._hasUpdateDate = false;
+		this._hasDeletedColumn = false;
+
+		if (this.EntitySchema && this.EntitySchema.MeadowSchema && Array.isArray(this.EntitySchema.MeadowSchema.Schema))
+		{
+			for (let i = 0; i < this.EntitySchema.MeadowSchema.Schema.length; i++)
+			{
+				const tmpColumn = this.EntitySchema.MeadowSchema.Schema[i];
+				if (tmpColumn.Column == 'UpdateDate')
+				{
+					this._hasUpdateDate = true;
+				}
+				if (tmpColumn.Type == 'Deleted' || tmpColumn.Column == 'Deleted')
+				{
+					this._hasDeletedColumn = true;
+				}
+			}
+		}
+
+		this.fable.log.info(`Syncing with ONGOING EVENTUAL CONSISTENCY STRATEGY entity ${this.EntitySchema.TableName} (BackSyncTimeLimit: ${this.BackSyncTimeLimit}ms, UpdateDate: ${this._hasUpdateDate}, Deleted: ${this._hasDeletedColumn})...`);
+
+		this.fable.Utility.waterfall(
+			[
+				// ---- Stage 1: Gather local stats ----
+				(fStageComplete) =>
+				{
+					const tmpQuery = this.Meadow.query;
+					tmpQuery.setSort({ Column: this.DefaultIdentifier, Direction: 'Descending' });
+					tmpQuery.setCap(1);
+					if (!this._hasDeletedColumn)
+					{
+						tmpQuery.setDisableDeleteTracking(true);
+					}
+					this.Meadow.doRead(tmpQuery,
+						(pReadError, pQuery, pRecord) =>
+						{
+							if (pReadError)
+							{
+								this.fable.log.error(`Error reading local max entity ID ${this.EntitySchema.TableName}: ${pReadError}`);
+								return fStageComplete(`Error reading local max entity ID ${this.EntitySchema.TableName}: ${pReadError}`);
+							}
+							if (pRecord)
+							{
+								tmpSyncState.Local.MaxIDEntity = pRecord[this.DefaultIdentifier];
+								this.fable.log.info(`Found local max entity ID ${this.EntitySchema.TableName}: ${tmpSyncState.Local.MaxIDEntity}`);
+							}
+							else
+							{
+								this.fable.log.info(`No local records for ${this.EntitySchema.TableName}.`);
+							}
+							return fStageComplete();
+						});
+				},
+				(fStageComplete) =>
+				{
+					// Local count
+					const tmpQuery = this.Meadow.query;
+					if (!this._hasDeletedColumn)
+					{
+						tmpQuery.setDisableDeleteTracking(true);
+					}
+					this.Meadow.doCount(tmpQuery,
+						(pCountError, pQuery, pCount) =>
+						{
+							if (pCountError)
+							{
+								this.fable.log.error(`Error getting local count of ${this.EntitySchema.TableName}: ${pCountError}`);
+								return fStageComplete(`Error getting local count of ${this.EntitySchema.TableName}: ${pCountError}`);
+							}
+							tmpSyncState.Local.RecordCount = pCount;
+							this.fable.log.info(`Local count ${this.EntitySchema.TableName}: ${tmpSyncState.Local.RecordCount}`);
+							return fStageComplete();
+						});
+				},
+
+				// ---- Stage 2: Gather server stats ----
+				(fStageComplete) =>
+				{
+					this.fable.MeadowCloneRestClient.getJSON(`${this.EntitySchema.TableName}/Max/${this.DefaultIdentifier}`,
+						(pError, pResponse, pBody) =>
+						{
+							if (pError)
+							{
+								this.fable.log.warn(`Could not get server max entity ID for ${this.EntitySchema.TableName} (${pError}); continuing sync.`);
+								return fStageComplete();
+							}
+							if (pBody && pBody.hasOwnProperty(this.DefaultIdentifier))
+							{
+								tmpSyncState.Server.MaxIDEntity = pBody[this.DefaultIdentifier];
+								this.fable.log.info(`Found server max entity ID ${this.EntitySchema.TableName}: ${tmpSyncState.Server.MaxIDEntity}`);
+							}
+							return fStageComplete();
+						});
+				},
+				(fStageComplete) =>
+				{
+					this._getServerCount(null,
+						(pError, pCount) =>
+						{
+							if (pError)
+							{
+								this.fable.log.warn(`Could not get server count for ${this.EntitySchema.TableName} (${pError}); estimating from max ID.`);
+								tmpSyncState.Server.RecordCount = tmpSyncState.Server.MaxIDEntity > 0 ? tmpSyncState.Server.MaxIDEntity : 0;
+								return fStageComplete();
+							}
+							tmpSyncState.Server.RecordCount = pCount;
+							this.fable.log.info(`Server count ${this.EntitySchema.TableName}: ${tmpSyncState.Server.RecordCount}`);
+							return fStageComplete();
+						});
+				},
+
+				// Create progress tracker
+				(fStageComplete) =>
+				{
+					let tmpTrackerTotal = (this.MaxRecordsPerEntity > 0)
+						? Math.min(tmpSyncState.Server.RecordCount, this.MaxRecordsPerEntity)
+						: tmpSyncState.Server.RecordCount;
+					this.operation.createProgressTracker(tmpTrackerTotal, `FullSync-${this.EntitySchema.TableName}`);
+					return fStageComplete();
+				},
+
+				// ---- Stage 3: Time-budgeted backwards bisection ----
+				(fStageComplete) =>
+				{
+					if (tmpSyncState.Local.MaxIDEntity < 1)
+					{
+						this.fable.log.info(`${this.EntitySchema.TableName}: no local records; skipping backwards bisection.`);
+						return fStageComplete();
+					}
+
+					const tmpBackSyncStartTime = Date.now();
+					this.fable.log.info(`${this.EntitySchema.TableName}: starting backwards bisection with ${this.BackSyncTimeLimit}ms time budget (ID range 1-${tmpSyncState.Local.MaxIDEntity})...`);
+
+					this._bisectRangeWithTimeBudget(1, tmpSyncState.Local.MaxIDEntity, 0, tmpBackSyncStartTime, this.BackSyncTimeLimit,
+						() =>
+						{
+							const tmpElapsed = Date.now() - tmpBackSyncStartTime;
+							const tmpExhausted = tmpElapsed >= this.BackSyncTimeLimit;
+							this.fable.log.info(`${this.EntitySchema.TableName}: backwards bisection ${tmpExhausted ? 'time budget exhausted' : 'complete'} after ${tmpElapsed}ms.`);
+							return fStageComplete();
+						});
+				},
+
+				// ---- Stage 4: Pull new records by ID ----
+				(fStageComplete) =>
+				{
+					if (tmpSyncState.Server.MaxIDEntity <= tmpSyncState.Local.MaxIDEntity)
+					{
+						this.fable.log.info(`${this.EntitySchema.TableName}: no new records by ID (server max ${tmpSyncState.Server.MaxIDEntity} <= local max ${tmpSyncState.Local.MaxIDEntity}).`);
+						return fStageComplete();
+					}
+
+					const tmpIDCol = this.DefaultIdentifier;
+					const tmpFilter = `FBV~${tmpIDCol}~GT~${tmpSyncState.Local.MaxIDEntity}~FSF~${tmpIDCol}~ASC~ASC`;
+					const tmpEstimated = tmpSyncState.Server.MaxIDEntity - tmpSyncState.Local.MaxIDEntity;
+
+					this.fable.log.info(`${this.EntitySchema.TableName}: pulling new records with ID > ${tmpSyncState.Local.MaxIDEntity} (~${tmpEstimated} estimated)...`);
+
+					this._pullServerRecords(tmpFilter, tmpEstimated,
+						(pError, pSyncedCount) =>
+						{
+							if (pError)
+							{
+								this.fable.log.warn(`${this.EntitySchema.TableName}: error pulling new records by ID: ${pError}`);
+							}
+							else
+							{
+								this.fable.log.info(`${this.EntitySchema.TableName}: pulled ${pSyncedCount} new records by ID.`);
+							}
+							return fStageComplete();
+						});
+				},
+			],
+			(pError) =>
+			{
+				if (pError)
+				{
+					this.fable.log.error(`Error performing ongoing eventual consistency sync ${this.EntitySchema.TableName}: ${pError}`, { Error: pError });
+				}
+
+				let tmpTracker = this.operation.progressTrackers[`FullSync-${this.EntitySchema.TableName}`];
+				if (tmpTracker)
+				{
+					tmpTracker.CurrentCount = tmpTracker.TotalCount;
+				}
+
+				this.fable.log.info(`${this.EntitySchema.TableName}: ongoing eventual consistency sync complete.`);
+
+				this.syncResults = {
+					Created: this._recordsCreated,
+					Updated: this._recordsUpdated,
+					Deleted: 0,
+					ServerRecordCount: tmpSyncState.Server.RecordCount,
+					LocalRecordCount: tmpSyncState.Local.RecordCount
+				};
+
+				if (this.SyncDeletedRecords)
+				{
+					return this.syncDeletedRecords(() => { return fCallback(); });
+				}
+
+				return fCallback();
+			});
+	}
+}
+
+module.exports = MeadowSyncEntityOngoingEventualConsistency;

package/source/services/clone/Meadow-Service-Sync-Entity-TrueUp.js

@@ -0,0 +1,199 @@
+const libMeadowSyncEntityOngoing = require('./Meadow-Service-Sync-Entity-Ongoing.js');
+
+class MeadowSyncEntityTrueUp extends libMeadowSyncEntityOngoing
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+
+		this.serviceType = 'MeadowSyncEntityTrueUp';
+
+		// Page size for the linear keyset-paginated walk.  Larger than the normal
+		// PageSize because there is no bisection overhead -- we just walk every record.
+		this.TrueUpPageSize = (typeof(this.options.TrueUpPageSize) === 'number')
+			? this.options.TrueUpPageSize
+			: 500;
+	}
+
+	_syncInternal(fCallback)
+	{
+		this.operation.createTimeStamp('EntityTrueUpSync');
+
+		this._totalSyncedThisSync = 0;
+		this._recordsCreated = 0;
+		this._recordsUpdated = 0;
+
+		const tmpSyncState = (
+			{
+				Server: { MaxIDEntity: -1, RecordCount: 0 },
+			});
+
+		this._hasDeletedColumn = false;
+
+		if (this.EntitySchema && this.EntitySchema.MeadowSchema && Array.isArray(this.EntitySchema.MeadowSchema.Schema))
+		{
+			for (let i = 0; i < this.EntitySchema.MeadowSchema.Schema.length; i++)
+			{
+				const tmpColumn = this.EntitySchema.MeadowSchema.Schema[i];
+				if (tmpColumn.Type == 'Deleted' || tmpColumn.Column == 'Deleted')
+				{
+					this._hasDeletedColumn = true;
+				}
+			}
+		}
+
+		this.fable.log.info(`Syncing with TRUE-UP STRATEGY entity ${this.EntitySchema.TableName} (TrueUpPageSize: ${this.TrueUpPageSize})...`);
+
+		this.fable.Utility.waterfall(
+			[
+				// ---- Stage 1: Gather server stats ----
+				(fStageComplete) =>
+				{
+					this.fable.MeadowCloneRestClient.getJSON(`${this.EntitySchema.TableName}/Max/${this.DefaultIdentifier}`,
+						(pError, pResponse, pBody) =>
+						{
+							if (pError)
+							{
+								this.fable.log.warn(`Could not get server max entity ID for ${this.EntitySchema.TableName} (${pError}); continuing sync.`);
+								return fStageComplete();
+							}
+							if (pBody && pBody.hasOwnProperty(this.DefaultIdentifier))
+							{
+								tmpSyncState.Server.MaxIDEntity = pBody[this.DefaultIdentifier];
+								this.fable.log.info(`Found server max entity ID ${this.EntitySchema.TableName}: ${tmpSyncState.Server.MaxIDEntity}`);
+							}
+							return fStageComplete();
+						});
+				},
+				(fStageComplete) =>
+				{
+					this._getServerCount(null,
+						(pError, pCount) =>
+						{
+							if (pError)
+							{
+								this.fable.log.warn(`Could not get server count for ${this.EntitySchema.TableName} (${pError}); estimating from max ID.`);
+								tmpSyncState.Server.RecordCount = tmpSyncState.Server.MaxIDEntity > 0 ? tmpSyncState.Server.MaxIDEntity : 0;
+								return fStageComplete();
+							}
+							tmpSyncState.Server.RecordCount = pCount;
+							this.fable.log.info(`Server count ${this.EntitySchema.TableName}: ${tmpSyncState.Server.RecordCount}`);
+							return fStageComplete();
+						});
+				},
+
+				// Create progress tracker
+				(fStageComplete) =>
+				{
+					let tmpTrackerTotal = (this.MaxRecordsPerEntity > 0)
+						? Math.min(tmpSyncState.Server.RecordCount, this.MaxRecordsPerEntity)
+						: tmpSyncState.Server.RecordCount;
+					this.operation.createProgressTracker(tmpTrackerTotal, `FullSync-${this.EntitySchema.TableName}`);
+					return fStageComplete();
+				},
+
+				// ---- Stage 2: Linear keyset-paginated walk ----
+				(fStageComplete) =>
+				{
+					if (tmpSyncState.Server.MaxIDEntity < 1)
+					{
+						this.fable.log.info(`${this.EntitySchema.TableName}: no records on server; nothing to true-up.`);
+						return fStageComplete();
+					}
+
+					const tmpIDCol = this.DefaultIdentifier;
+					let tmpCursorID = 0;
+					let tmpTotalProcessed = 0;
+
+					const fFetchPage = () =>
+					{
+						// Global record cap check
+						if (this.MaxRecordsPerEntity > 0 && this._totalSyncedThisSync >= this.MaxRecordsPerEntity)
+						{
+							this.fable.log.info(`${this.EntitySchema.TableName}: global record cap reached (${this._totalSyncedThisSync}/${this.MaxRecordsPerEntity}); stopping true-up.`);
+							return fStageComplete();
+						}
+
+						const tmpFilter = `FBV~${tmpIDCol}~GT~${tmpCursorID}~FSF~${tmpIDCol}~ASC~ASC`;
+
+						this._getServerRecords(tmpFilter, 0, this.TrueUpPageSize,
+							(pError, pRecords) =>
+							{
+								if (pError)
+								{
+									this.fable.log.error(`Error fetching ${this.EntitySchema.TableName} true-up page at cursor ${tmpCursorID}: ${pError}`);
+									return fStageComplete(pError);
+								}
+								if (!pRecords || pRecords.length < 1)
+								{
+									this.fable.log.info(`${this.EntitySchema.TableName}: true-up walk complete (${tmpTotalProcessed} records processed).`);
+									return fStageComplete();
+								}
+
+								this.fable.Utility.eachLimit(pRecords, 5,
+									(pRecord, fRecordDone) =>
+									{
+										this._upsertRecord(pRecord,
+											() =>
+											{
+												tmpTotalProcessed++;
+												this._totalSyncedThisSync++;
+												return setImmediate(fRecordDone);
+											});
+									},
+									(pUpsertError) =>
+									{
+										this._incrementProgress(pRecords.length);
+
+										// Advance cursor to max ID seen in this page
+										tmpCursorID = pRecords[pRecords.length - 1][tmpIDCol];
+
+										if (pRecords.length < this.TrueUpPageSize)
+										{
+											this.fable.log.info(`${this.EntitySchema.TableName}: true-up walk complete (${tmpTotalProcessed} records processed).`);
+											return fStageComplete();
+										}
+
+										this.fable.log.info(`${this.EntitySchema.TableName}: true-up progress ${tmpTotalProcessed} of ~${tmpSyncState.Server.RecordCount} records (cursor at ID ${tmpCursorID})...`);
+										return setImmediate(fFetchPage);
+									});
+							});
+					};
+
+					fFetchPage();
+				},
+			],
+			(pError) =>
+			{
+				if (pError)
+				{
+					this.fable.log.error(`Error performing true-up sync ${this.EntitySchema.TableName}: ${pError}`, { Error: pError });
+				}
+
+				let tmpTracker = this.operation.progressTrackers[`FullSync-${this.EntitySchema.TableName}`];
+				if (tmpTracker)
+				{
+					tmpTracker.CurrentCount = tmpTracker.TotalCount;
+				}
+
+				this.fable.log.info(`${this.EntitySchema.TableName}: true-up sync complete.`);
+
+				this.syncResults = {
+					Created: this._recordsCreated,
+					Updated: this._recordsUpdated,
+					Deleted: 0,
+					ServerRecordCount: tmpSyncState.Server.RecordCount,
+					LocalRecordCount: 0
+				};
+
+				if (this.SyncDeletedRecords)
+				{
+					return this.syncDeletedRecords(() => { return fCallback(); });
+				}
+
+				return fCallback();
+			});
+	}
+}
+
+module.exports = MeadowSyncEntityTrueUp;

package/source/services/clone/Meadow-Service-Sync.js

@@ -1,6 +1,9 @@
 const libFableServiceProviderBase = require('fable-serviceproviderbase');
 const libMeadowSyncEntityInitial = require('./Meadow-Service-Sync-Entity-Initial.js');
 const libMeadowSyncEntityOngoing = require('./Meadow-Service-Sync-Entity-Ongoing.js');
+const libMeadowSyncEntityOngoingEventualConsistency = require('./Meadow-Service-Sync-Entity-OngoingEventualConsistency.js');
+const libMeadowSyncEntityTrueUp = require('./Meadow-Service-Sync-Entity-TrueUp.js');
+const libMeadowSyncEntityComparisonOnly = require('./Meadow-Service-Sync-Entity-ComparisonOnly.js');
 
 class MeadowSync extends libFableServiceProviderBase
 {
@@ -20,6 +23,21 @@ class MeadowSync extends libFableServiceProviderBase
 			this.fable.ServiceManager.addServiceType('MeadowSyncEntityOngoing', libMeadowSyncEntityOngoing);
 		}
 
+		if (!this.fable.ServiceManager.servicesMap.hasOwnProperty('MeadowSyncEntityOngoingEventualConsistency'))
+		{
+			this.fable.ServiceManager.addServiceType('MeadowSyncEntityOngoingEventualConsistency', libMeadowSyncEntityOngoingEventualConsistency);
+		}
+
+		if (!this.fable.ServiceManager.servicesMap.hasOwnProperty('MeadowSyncEntityTrueUp'))
+		{
+			this.fable.ServiceManager.addServiceType('MeadowSyncEntityTrueUp', libMeadowSyncEntityTrueUp);
+		}
+
+		if (!this.fable.ServiceManager.servicesMap.hasOwnProperty('MeadowSyncEntityComparisonOnly'))
+		{
+			this.fable.ServiceManager.addServiceType('MeadowSyncEntityComparisonOnly', libMeadowSyncEntityComparisonOnly);
+		}
+
 		// If this is empty, we will sync everything in the loaded Schema.
 		// Otherwise, we will go through this list and sync them in this order.
 		this.SyncEntityList = [];
@@ -103,6 +121,28 @@ class MeadowSync extends libFableServiceProviderBase
 			this.SyncDeletedRecordsQueryString = this.options.SyncDeletedRecordsQueryString;
 		}
 
+		// Milliseconds devoted to backwards bisection in OngoingEventualConsistency mode.
+		this.BackSyncTimeLimit = 30000;
+		if (this.fable.ProgramConfiguration.hasOwnProperty('BackSyncTimeLimit'))
+		{
+			this.BackSyncTimeLimit = parseInt(this.fable.ProgramConfiguration.BackSyncTimeLimit, 10) || 30000;
+		}
+		else if (this.options.hasOwnProperty('BackSyncTimeLimit'))
+		{
+			this.BackSyncTimeLimit = parseInt(this.options.BackSyncTimeLimit, 10) || 30000;
+		}
+
+		// Page size for the linear keyset-paginated walk in TrueUp mode.
+		this.TrueUpPageSize = 500;
+		if (this.fable.ProgramConfiguration.hasOwnProperty('TrueUpPageSize'))
+		{
+			this.TrueUpPageSize = parseInt(this.fable.ProgramConfiguration.TrueUpPageSize, 10) || 500;
+		}
+		else if (this.options.hasOwnProperty('TrueUpPageSize'))
+		{
+			this.TrueUpPageSize = parseInt(this.options.TrueUpPageSize, 10) || 500;
+		}
+
 		this.MeadowSchema = false;
 		this.MeadowSchemaTableList = false;
 
@@ -142,6 +182,8 @@ class MeadowSync extends libFableServiceProviderBase
 						MaxRecordsPerEntity: this.MaxRecordsPerEntity,
 						DateTimePrecisionMS: this.DateTimePrecisionMS,
 						UseAdvancedIDPagination: this.UseAdvancedIDPagination,
+						BackSyncTimeLimit: this.BackSyncTimeLimit,
+						TrueUpPageSize: this.TrueUpPageSize,
 					};
 
 					// Apply per-entity option overrides if configured
@@ -151,16 +193,29 @@ class MeadowSync extends libFableServiceProviderBase
 					}
 
 					let tmpSyncEntity;
+					let tmpServiceTypeName;
 
-					if (this.SyncMode == 'Ongoing')
+					switch (this.SyncMode)
 					{
-						tmpSyncEntity = this.fable.serviceManager.instantiateServiceProvider('MeadowSyncEntityOngoing', tmpSyncEntityOptions, `SyncEntity-${tmpEntitySchema.TableName}`);
-					}
-					else
-					{
-						tmpSyncEntity = this.fable.serviceManager.instantiateServiceProvider('MeadowSyncEntityInitial', tmpSyncEntityOptions, `SyncEntity-${tmpEntitySchema.TableName}`);
+						case 'Ongoing':
+							tmpServiceTypeName = 'MeadowSyncEntityOngoing';
+							break;
+						case 'OngoingEventualConsistency':
+							tmpServiceTypeName = 'MeadowSyncEntityOngoingEventualConsistency';
+							break;
+						case 'TrueUp':
+							tmpServiceTypeName = 'MeadowSyncEntityTrueUp';
+							break;
+						case 'ComparisonOnly':
+							tmpServiceTypeName = 'MeadowSyncEntityComparisonOnly';
+							break;
+						default:
+							tmpServiceTypeName = 'MeadowSyncEntityInitial';
+							break;
 					}
 
+					tmpSyncEntity = this.fable.serviceManager.instantiateServiceProvider(tmpServiceTypeName, tmpSyncEntityOptions, `SyncEntity-${tmpEntitySchema.TableName}`);
+
 					this.MeadowSyncEntities[tmpEntitySchema.TableName] = tmpSyncEntity;
 
 					return tmpSyncEntity.initialize((pInitError) =>