meadow-integration 1.0.4 → 1.0.6

package/docs/api/sync-entity-initial.md

@@ -0,0 +1,227 @@
+# MeadowSyncEntityInitial
+
+Performs a full initial synchronization of a single entity from a remote Meadow API server to a local database. Downloads all records that do not yet exist locally by comparing max IDs, then inserts missing records in paginated batches.
+
+**Source:** `source/services/clone/Meadow-Service-Sync-Entity-Initial.js`
+
+**Extends:** `fable-serviceproviderbase`
+
+**Service Type:** `MeadowSyncEntityInitial`
+
+## Constructor
+
+```js
+const syncEntity = fable.serviceManager.instantiateServiceProvider('MeadowSyncEntityInitial', pOptions, pServiceHash);
+```
+
+### Options
+
+| Option | Type | Required | Default | Description |
+|--------|------|----------|---------|-------------|
+| `MeadowEntitySchema` | `object` | Yes | -- | Entity schema object containing `TableName`, `Columns` (array), and `MeadowSchema`. |
+| `ConnectionPool` | `object` | No | -- | Database connection pool (used for table/index creation). |
+| `PageSize` | `number` | No | `100` | Number of records per paginated download request. |
+
+**Validation:** The constructor throws an `Error` if:
+- `MeadowEntitySchema` is missing or not an object.
+- `MeadowEntitySchema.TableName` is missing or empty.
+- `MeadowEntitySchema.Columns` is missing or not a non-empty array.
+- `MeadowEntitySchema.MeadowSchema` is missing.
+
+## Properties
+
+### `EntitySchema`
+
+`object` -- Deep copy of the provided `MeadowEntitySchema` option.
+
+### `DefaultIdentifier`
+
+`string` -- The default identifier column name from `EntitySchema.MeadowSchema.DefaultIdentifier` (typically `'IDAnimal'`, `'IDCustomer'`, etc.).
+
+### `PageSize`
+
+`number` -- Records per download page.
+
+### `Meadow`
+
+The Meadow ORM instance for this entity, loaded from the entity's `MeadowSchema` package object. Set by `initialize()`.
+
+### `operation`
+
+`MeadowOperation` -- Instance of the operation utility for timestamps and progress tracking.
+
+## Methods
+
+### `initialize(fCallback)`
+
+Prepares the entity for synchronization by creating the local database table (if it does not exist) and setting up indexes on GUID and Deleted columns.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `fCallback` | `function(pError)` | Callback invoked when initialization is complete. |
+
+**Behavior:**
+1. Loads the Meadow ORM instance from the entity's schema package.
+2. Calls the provider's `createTable()` to ensure the table exists.
+3. If the schema has a GUID column (`DataType == 'GUID'`), creates a unique index on it.
+4. If the schema has a `Deleted` column, creates a non-unique index on it.
+5. Index creation requires `fable.MeadowConnectionManager` to be available.
+
+### `marshalRecord(pSourceRecord)`
+
+Transforms a server-side record into a local record suitable for insertion, based on the entity schema columns.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pSourceRecord` | `object` | The record object from the server. |
+
+**Returns:** `object` -- The marshaled record with only schema-defined columns.
+
+**Transformation rules:**
+- `null`/`undefined` values are skipped.
+- Object values are JSON-stringified.
+- `DateTime` columns are formatted to `'YYYY-MM-DD HH:mm:ss.SSS'` in UTC.
+- Empty string values are skipped (except for DateTime).
+- Columns ending in `JSON` auto-stringify the corresponding non-JSON property from the source (e.g., `MetadataJSON` from `Metadata`).
+
+### `sync(fCallback)`
+
+Executes the full initial sync algorithm for this entity.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `fCallback` | `function()` | Callback invoked when sync completes (errors are logged, not passed). |
+
+**Algorithm:**
+
+1. **Get local max ID** -- Reads the highest-ID record from the local database.
+2. **Get local count** -- Counts all local records.
+3. **Get server max ID** -- Requests max ID from `{Entity}/Max/{DefaultIdentifier}`.
+4. **Get server count** -- Requests count from `{Entity}s/Count`.
+5. **Calculate estimated records** -- `Server.RecordCount - Local.RecordCount`.
+6. **Generate paginated URLs** -- Creates URL partials filtered to `{DefaultIdentifier} > {LocalMaxID}`, sorted ascending, paginated by `PageSize`.
+7. **Download and insert** -- For each page, downloads records and for each record:
+   - Checks if the record already exists locally by ID.
+   - If not found, marshals the record and creates it with identity insert enabled and all auto-stamps disabled.
+   - Updates the progress tracker after each insert.
+8. **Early termination** -- If an empty page is returned, stops downloading.
+
+**Progress tracking:** Uses `MeadowOperation` with tracker hash `FullSync-{TableName}`.
+
+## Usage Examples
+
+### Direct Instantiation and Sync
+
+```js
+const libFable = require('fable');
+const libSyncEntityInitial = require('meadow-integration/source/services/clone/Meadow-Service-Sync-Entity-Initial');
+
+const fable = new libFable({ Product: 'CloneApp' });
+
+fable.serviceManager.addServiceType('MeadowSyncEntityInitial', libSyncEntityInitial);
+
+const entitySchema = {
+	TableName: 'Customer',
+	Columns:
+	[
+		{ Column: 'IDCustomer', DataType: 'AutoIdentity' },
+		{ Column: 'GUIDCustomer', DataType: 'GUID' },
+		{ Column: 'Name', DataType: 'String' },
+		{ Column: 'Email', DataType: 'String' },
+		{ Column: 'CreateDate', DataType: 'DateTime' },
+		{ Column: 'UpdateDate', DataType: 'DateTime' },
+		{ Column: 'Deleted', DataType: 'Boolean' }
+	],
+	MeadowSchema:
+	{
+		DefaultIdentifier: 'IDCustomer',
+		Schema: [
+			{ Column: 'IDCustomer' },
+			{ Column: 'GUIDCustomer' },
+			{ Column: 'Name' },
+			{ Column: 'Email' },
+			{ Column: 'CreateDate' },
+			{ Column: 'UpdateDate' },
+			{ Column: 'Deleted' }
+		]
+	}
+};
+
+const syncEntity = fable.serviceManager.instantiateServiceProvider('MeadowSyncEntityInitial',
+	{
+		MeadowEntitySchema: entitySchema,
+		ConnectionPool: connectionPool,
+		PageSize: 500
+	},
+	'SyncEntity-Customer');
+
+syncEntity.initialize(
+	(pError) =>
+	{
+		if (pError)
+		{
+			console.error('Initialization failed:', pError);
+			return;
+		}
+
+		syncEntity.sync(
+			() =>
+			{
+				console.log('Initial sync of Customer complete.');
+			});
+	});
+```
+
+### Marshaling a Record Manually
+
+```js
+const serverRecord = {
+	IDCustomer: 42,
+	GUIDCustomer: 'abc-123-def',
+	Name: 'Alice',
+	Email: 'alice@example.com',
+	CreateDate: '2024-01-15T10:30:00.000Z',
+	UpdateDate: '2024-06-20T14:00:00.000Z',
+	Deleted: 0,
+	Metadata: { tier: 'premium' }
+};
+
+const localRecord = syncEntity.marshalRecord(serverRecord);
+// localRecord =>
+// {
+//   IDCustomer: 42,
+//   GUIDCustomer: 'abc-123-def',
+//   Name: 'Alice',
+//   Email: 'alice@example.com',
+//   CreateDate: '2024-01-15 10:30:00.000',
+//   UpdateDate: '2024-06-20 14:00:00.000',
+//   Deleted: 0
+// }
+```
+
+## Sync Flow Diagram
+
+```
+Local DB                                Remote Server
+--------                                -------------
+1. Get max ID (local)
+2. Get count (local)
+                                        3. GET /Entity/Max/IDEntity
+                                        4. GET /Entitys/Count
+5. Calculate estimated new records
+6. Generate paginated URL list
+                                        7. GET /Entitys/FilteredTo/FBV~ID~GT~{localMax}~/0/{pageSize}
+8. For each record:
+   - Read by ID locally
+   - If not found: marshal + create
+                                        9. GET next page...
+10. Repeat until pages exhausted
+```
+
+## Related Services
+
+- [MeadowSync](./sync.md) -- The orchestrator that creates and manages instances of this class.
+- [MeadowSyncEntityOngoing](./sync-entity-ongoing.md) -- The ongoing/differential variant of entity sync.
+- [MeadowCloneRestClient](./clone-rest-client.md) -- Used via `fable.MeadowCloneRestClient` to download records.
+- [MeadowOperation](./operation.md) -- Provides timestamp and progress tracking utilities used during sync.
+- [MeadowConnectionManager](./connection-manager.md) -- Provides the connection pool and index creation.

package/docs/api/sync-entity-ongoing.md

@@ -0,0 +1,244 @@
+# MeadowSyncEntityOngoing
+
+Performs ongoing (differential) synchronization of a single entity from a remote Meadow API server to a local database. Uses UpdateDate-based comparison to detect changed records, creating new records or updating existing ones as needed.
+
+**Source:** `source/services/clone/Meadow-Service-Sync-Entity-Ongoing.js`
+
+**Extends:** `fable-serviceproviderbase`
+
+**Service Type:** `MeadowSyncEntityOngoing`
+
+## Constructor
+
+```js
+const syncEntity = fable.serviceManager.instantiateServiceProvider('MeadowSyncEntityOngoing', pOptions, pServiceHash);
+```
+
+### Options
+
+| Option | Type | Required | Default | Description |
+|--------|------|----------|---------|-------------|
+| `MeadowEntitySchema` | `object` | Yes | -- | Entity schema object containing `TableName`, `Columns` (array), and `MeadowSchema`. |
+| `ConnectionPool` | `object` | No | -- | Database connection pool (used for table/index creation). |
+| `PageSize` | `number` | No | `100` | Number of records per paginated download request. |
+
+**Validation:** Same as `MeadowSyncEntityInitial` -- throws errors for missing or invalid schema properties.
+
+## Properties
+
+### `EntitySchema`
+
+`object` -- Deep copy of the provided `MeadowEntitySchema` option.
+
+### `DefaultIdentifier`
+
+`string` -- The default identifier column name from `EntitySchema.MeadowSchema.DefaultIdentifier`.
+
+### `PageSize`
+
+`number` -- Records per download page.
+
+### `Meadow`
+
+The Meadow ORM instance for this entity. Set by `initialize()`.
+
+### `operation`
+
+`MeadowOperation` -- Instance of the operation utility for timestamps and progress tracking.
+
+## Methods
+
+### `initialize(fCallback)`
+
+Prepares the entity for synchronization. Identical behavior to `MeadowSyncEntityInitial.initialize()`: creates the local table if needed and sets up GUID (unique) and Deleted (non-unique) indexes.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `fCallback` | `function(pError)` | Callback invoked when initialization is complete. |
+
+### `marshalRecord(pSourceRecord)`
+
+Transforms a server-side record into a local record suitable for insertion or update.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pSourceRecord` | `object` | The record object from the server. |
+
+**Returns:** `object` -- The marshaled record.
+
+**Differences from Initial sync marshaling:**
+- Does **not** perform UTC DateTime formatting. Values are copied as-is (unlike Initial sync which formats DateTime columns to `'YYYY-MM-DD HH:mm:ss.SSS'`).
+- Otherwise follows the same column-mapping logic: skips null/undefined, stringifies objects, handles `*JSON` columns.
+
+### `addSyncAnticipateEntry(tmpSyncState, tmpAnticipate)`
+
+Adds a recursive anticipate entry for paginated sync. This is an internal method that implements the core download-and-sync loop for ongoing sync.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `tmpSyncState` | `object` | Mutable sync state tracking `LastRequestedID`, `RequestsPerformed`, `EstimatedRequestCount`. |
+| `tmpAnticipate` | `object` | Fable Anticipate instance for managing asynchronous operations. |
+
+**Recursive pagination pattern:**
+1. Downloads a page of records filtered to `ID > LastRequestedID`, sorted ascending.
+2. For each record in the page, adds an anticipate entry that:
+   - Updates `LastRequestedID` to track progress.
+   - Reads the local record by ID.
+   - If found: compares `UpdateDate` between server and local. Skips if difference is less than 5ms.
+   - If the record exists and dates differ: marshals and updates via `Meadow.doUpdate()`.
+   - If the record does not exist: marshals and creates via `Meadow.doCreate()` with identity insert enabled.
+3. After processing the page, if `RequestsPerformed < EstimatedRequestCount`, recursively calls `addSyncAnticipateEntry` to fetch the next page.
+
+### `sync(fCallback)`
+
+Executes the full ongoing sync algorithm for this entity.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `fCallback` | `function()` | Callback invoked when sync completes (errors are logged, not passed). |
+
+**Algorithm:**
+
+1. **Detect UpdateDate column** -- Checks if the entity schema has an `UpdateDate` column.
+2. **Get local max ID** -- Reads the highest-ID record from the local database.
+3. **Get local max UpdateDate** -- Reads the record with the most recent `UpdateDate`.
+4. **Get local count** -- Counts all local records.
+5. **Get server max ID** -- Requests from `{Entity}/Max/{DefaultIdentifier}`.
+6. **Get server max UpdateDate** -- Requests from `{Entity}/Max/UpdateDate`.
+7. **Get server count** -- Requests from `{Entity}s/Count`.
+8. **Calculate estimated requests** -- `ceil(Server.RecordCount / PageSize)`.
+9. **Begin recursive sync** -- Calls `addSyncAnticipateEntry()` to start the paginated download-and-sync loop. All records on the server are scanned (not just those newer than the local max).
+
+**Progress tracking:** Uses `MeadowOperation` with tracker hash `UpdateSync-{TableName}`.
+
+## Differences from Initial Sync
+
+| Aspect | Initial | Ongoing |
+|--------|---------|---------|
+| **Strategy** | ID-based gap fill | Full scan with UpdateDate comparison |
+| **Filter** | Only records with `ID > LocalMaxID` | All records, paginated by ascending ID |
+| **Existing records** | Skips (already present) | Compares `UpdateDate`, updates if changed |
+| **DateTime marshaling** | Formats to `YYYY-MM-DD HH:mm:ss.SSS` UTC | Copies values as-is |
+| **Pagination** | Pre-computed URL list | Recursive anticipate pattern |
+| **UpdateDate threshold** | N/A | Skips updates if difference < 5ms |
+| **Progress tracker hash** | `FullSync-{TableName}` | `UpdateSync-{TableName}` |
+
+## Usage Examples
+
+### Direct Instantiation and Ongoing Sync
+
+```js
+const libFable = require('fable');
+const libSyncEntityOngoing = require('meadow-integration/source/services/clone/Meadow-Service-Sync-Entity-Ongoing');
+
+const fable = new libFable({ Product: 'CloneApp' });
+
+fable.serviceManager.addServiceType('MeadowSyncEntityOngoing', libSyncEntityOngoing);
+
+const entitySchema = {
+	TableName: 'Order',
+	Columns:
+	[
+		{ Column: 'IDOrder', DataType: 'AutoIdentity' },
+		{ Column: 'GUIDOrder', DataType: 'GUID' },
+		{ Column: 'CustomerID', DataType: 'Integer' },
+		{ Column: 'Total', DataType: 'Decimal' },
+		{ Column: 'CreateDate', DataType: 'DateTime' },
+		{ Column: 'UpdateDate', DataType: 'DateTime' },
+		{ Column: 'Deleted', DataType: 'Boolean' }
+	],
+	MeadowSchema:
+	{
+		DefaultIdentifier: 'IDOrder',
+		Schema:
+		[
+			{ Column: 'IDOrder' },
+			{ Column: 'GUIDOrder' },
+			{ Column: 'CustomerID' },
+			{ Column: 'Total' },
+			{ Column: 'CreateDate' },
+			{ Column: 'UpdateDate' },
+			{ Column: 'Deleted' }
+		]
+	}
+};
+
+const syncEntity = fable.serviceManager.instantiateServiceProvider('MeadowSyncEntityOngoing',
+	{
+		MeadowEntitySchema: entitySchema,
+		ConnectionPool: connectionPool,
+		PageSize: 250
+	},
+	'SyncEntity-Order');
+
+syncEntity.initialize(
+	(pError) =>
+	{
+		if (pError)
+		{
+			console.error('Initialization failed:', pError);
+			return;
+		}
+
+		syncEntity.sync(
+			() =>
+			{
+				console.log('Ongoing sync of Order complete.');
+			});
+	});
+```
+
+### Using via MeadowSync Orchestrator
+
+```js
+const sync = fable.serviceManager.instantiateServiceProvider('MeadowSync',
+	{
+		ConnectionPool: connectionPool,
+		PageSize: 200,
+		SyncEntityList: ['Customer', 'Order', 'Product']
+	});
+
+// Set ongoing mode before loading schema
+sync.SyncMode = 'Ongoing';
+
+sync.loadMeadowSchema(compiledSchema,
+	(pLoadError) =>
+	{
+		sync.syncAll(
+			(pSyncError) =>
+			{
+				console.log('Ongoing sync of all entities complete.');
+			});
+	});
+```
+
+## Sync Flow Diagram
+
+```
+Local DB                                Remote Server
+--------                                -------------
+1. Check for UpdateDate column
+2. Get max ID (local)
+3. Get max UpdateDate (local)
+4. Get count (local)
+                                        5. GET /Entity/Max/IDEntity
+                                        6. GET /Entity/Max/UpdateDate
+                                        7. GET /Entitys/Count
+8. Calculate estimated request count
+                                        9. GET page (ID > LastRequestedID, ascending)
+10. For each record:
+    - Read by ID locally
+    - If found & UpdateDate diff >= 5ms: marshal + update
+    - If not found: marshal + create
+    - Update LastRequestedID
+                                        11. Recursively fetch next page...
+12. Repeat until all pages processed
+```
+
+## Related Services
+
+- [MeadowSync](./sync.md) -- The orchestrator that creates and manages instances of this class.
+- [MeadowSyncEntityInitial](./sync-entity-initial.md) -- The initial full-sync variant.
+- [MeadowCloneRestClient](./clone-rest-client.md) -- Used via `fable.MeadowCloneRestClient` to download records.
+- [MeadowOperation](./operation.md) -- Provides timestamp and progress tracking utilities.
+- [MeadowConnectionManager](./connection-manager.md) -- Provides the connection pool and index creation.

package/docs/api/sync.md

@@ -0,0 +1,213 @@
+# MeadowSync
+
+Top-level synchronization orchestrator for the data-clone pipeline. Loads a Meadow schema, creates per-entity sync objects (Initial or Ongoing), and coordinates syncing all entities in sequence.
+
+**Source:** `source/services/clone/Meadow-Service-Sync.js`
+
+**Extends:** `fable-serviceproviderbase`
+
+**Service Type:** `MeadowSync`
+
+## Constructor
+
+```js
+const sync = fable.serviceManager.instantiateServiceProvider('MeadowSync', pOptions);
+```
+
+### Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `SyncEntityList` | `Array<string>` | `[]` | Ordered list of entity table names to sync. If empty, all entities in the schema are synced. Also read from `fable.ProgramConfiguration.SyncEntityList`. |
+| `SyncEntityOptions` | `object` | `{}` | Per-entity sync options keyed by table name. Also read from `fable.ProgramConfiguration.SyncEntityOptions`. |
+| `ConnectionPool` | `object` | *(none)* | Database connection pool passed through to per-entity sync objects. |
+| `PageSize` | `number` | `100` | Number of records per download page, passed through to per-entity sync objects. |
+
+## Properties
+
+### `SyncMode`
+
+`string` -- Controls which sync strategy is used when `loadMeadowSchema()` creates entity sync objects.
+
+| Value | Behavior |
+|-------|----------|
+| `'Initial'` *(default)* | Creates `MeadowSyncEntityInitial` instances. Performs a full ID-based sync of all missing records. |
+| `'Ongoing'` | Creates `MeadowSyncEntityOngoing` instances. Performs UpdateDate-based differential sync, creating or updating records. |
+
+Set this property **before** calling `loadMeadowSchema()`.
+
+### `SyncEntityList`
+
+`Array<string>` -- The list of entity table names to synchronize, in order. Populated from options, `ProgramConfiguration`, or automatically from the loaded schema.
+
+### `SyncEntityOptions`
+
+`object` -- Per-entity options map. Keys are table names.
+
+### `MeadowSyncEntities`
+
+`object` -- Map of table name to instantiated `MeadowSyncEntityInitial` or `MeadowSyncEntityOngoing` service instances. Populated by `loadMeadowSchema()`.
+
+### `MeadowSchemaTableList`
+
+`Array<string>` -- List of all table names found in the loaded Meadow schema. Set by `loadMeadowSchema()`.
+
+## Methods
+
+### `loadMeadowSchema(pSchema, fCallback)`
+
+Loads a compiled Meadow schema and creates per-entity sync objects.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pSchema` | `object` | A compiled Meadow schema with a `Tables` property. Each key is a table name; each value is an entity schema object with `TableName`, `Columns`, and `MeadowSchema`. |
+| `fCallback` | `function(pError)` | Callback invoked after all entity sync objects are initialized (tables created, indexes set up). |
+
+**Behavior:**
+1. Iterates through every table in the schema.
+2. For tables that are in `SyncEntityList` (or all tables if the list is empty), creates a sync entity object according to `SyncMode`.
+3. Calls `initialize()` on each entity sync object to ensure the local table and indexes exist.
+4. If `SyncEntityList` was empty, populates it with all initialized entity names.
+
+### `syncEntity(pEntityHash, fCallback)`
+
+Syncs a single entity by its table name.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `pEntityHash` | `string` | The table name of the entity to sync (e.g. `'Animal'`). |
+| `fCallback` | `function(pError)` | Callback invoked when the entity sync completes. |
+
+Logs a warning and returns immediately if the entity does not exist in `MeadowSyncEntities`.
+
+### `syncAll(fCallback)`
+
+Syncs all entities in `SyncEntityList` sequentially.
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `fCallback` | `function(pError)` | Callback invoked when all entities have been synced. |
+
+Iterates through `SyncEntityList` with a concurrency of 1, calling `syncEntity()` for each.
+
+## Usage Examples
+
+### Full Initial Sync Workflow
+
+```js
+const libFable = require('fable');
+const libConnectionManager = require('meadow-integration/source/services/clone/Meadow-Service-ConnectionManager');
+const libRestClient = require('meadow-integration/source/services/clone/Meadow-Service-RestClient');
+const libSync = require('meadow-integration/source/services/clone/Meadow-Service-Sync');
+
+const fable = new libFable({ Product: 'DataClone' });
+
+// Register services
+fable.serviceManager.addServiceType('MeadowConnectionManager', libConnectionManager);
+fable.serviceManager.addServiceType('MeadowCloneRestClient', libRestClient);
+fable.serviceManager.addServiceType('MeadowSync', libSync);
+
+// Instantiate connection manager
+const connectionManager = fable.serviceManager.instantiateServiceProvider('MeadowConnectionManager',
+	{
+		Provider: 'MySQL',
+		MySQL: { server: '127.0.0.1', user: 'root', password: '', database: 'clone_db' }
+	});
+
+// Instantiate REST client
+const restClient = fable.serviceManager.instantiateServiceProvider('MeadowCloneRestClient',
+	{
+		ServerURL: 'https://api.example.com/1.0/',
+		UserID: 'sync_user',
+		Password: 'sync_password'
+	});
+
+// Connect, authenticate, then sync
+connectionManager.connect(
+	(pConnError) =>
+	{
+		if (pConnError) { throw pConnError; }
+
+		restClient.authenticate(
+			(pAuthError) =>
+			{
+				if (pAuthError) { throw pAuthError; }
+
+				const sync = fable.serviceManager.instantiateServiceProvider('MeadowSync',
+					{
+						ConnectionPool: connectionManager.ConnectionPool,
+						PageSize: 200,
+						SyncEntityList: ['Customer', 'Order', 'Product']
+					});
+
+				// Use initial sync mode (the default)
+				sync.SyncMode = 'Initial';
+
+				const meadowSchema = require('./my-compiled-schema.json');
+				sync.loadMeadowSchema(meadowSchema,
+					(pLoadError) =>
+					{
+						if (pLoadError) { throw pLoadError; }
+
+						sync.syncAll(
+							(pSyncError) =>
+							{
+								if (pSyncError)
+								{
+									console.error('Sync failed:', pSyncError);
+								}
+								else
+								{
+									console.log('Initial sync complete!');
+								}
+
+								restClient.deauthenticate(() => { process.exit(0); });
+							});
+					});
+			});
+	});
+```
+
+### Ongoing (Differential) Sync
+
+```js
+const sync = fable.serviceManager.instantiateServiceProvider('MeadowSync',
+	{
+		ConnectionPool: connectionManager.ConnectionPool,
+		PageSize: 100
+	});
+
+// Switch to ongoing mode before loading schema
+sync.SyncMode = 'Ongoing';
+
+sync.loadMeadowSchema(meadowSchema,
+	(pLoadError) =>
+	{
+		sync.syncAll(
+			(pSyncError) =>
+			{
+				console.log('Ongoing sync complete!');
+			});
+	});
+```
+
+### Syncing a Single Entity
+
+```js
+sync.loadMeadowSchema(meadowSchema,
+	(pLoadError) =>
+	{
+		sync.syncEntity('Customer',
+			(pSyncError) =>
+			{
+				console.log('Customer sync complete!');
+			});
+	});
+```
+
+## Related Services
+
+- [MeadowConnectionManager](./connection-manager.md) -- Provides the database connection pool.
+- [MeadowCloneRestClient](./clone-rest-client.md) -- REST client used by entity sync objects to download records.
+- [MeadowSyncEntityInitial](./sync-entity-initial.md) -- Created by MeadowSync when `SyncMode` is `'Initial'`.
+- [MeadowSyncEntityOngoing](./sync-entity-ongoing.md) -- Created by MeadowSync when `SyncMode` is `'Ongoing'`.