meadow-integration 1.0.18 → 1.0.19

package/docs/README.md

@@ -158,5 +158,6 @@ Both pipelines share the Fable service provider pattern for dependency injection
 - [Comprehensions](comprehensions.md) -- The comprehension data format in detail
 - [Programmatic API](programmatic-api.md) -- Using services directly in your code
 - [Integration Adapter](integration-adapter.md) -- Pushing data to Meadow REST APIs
+- [Comprehension Push Configuration](comprehension-push/configuration.md) -- CLI options and config file for pushing comprehensions
 - [Data Clone Overview](data-clone/overview.md) -- Synchronizing remote APIs to local databases
 - [Examples](examples-walkthrough.md) -- Walkthrough of all runnable examples

package/docs/_sidebar.md

@@ -14,12 +14,17 @@
   - [Comprehensions](comprehensions.md)
   - [Mapping Files](mapping-files.md)
 
+- Comprehension Push
+
+  - [Integration Adapter](integration-adapter.md)
+  - [Push Configuration](comprehension-push/configuration.md)
+
 - Data Synchronization
 
   - [Data Clone Overview](data-clone/overview.md)
   - [Connection Manager](data-clone/connection-manager.md)
   - [Sync Modes](data-clone/sync-modes.md)
-  - [Configuration](data-clone/configuration.md)
+  - [Clone Configuration](data-clone/configuration.md)
   - [Docker Deployment](data-clone/docker.md)
 
 - CLI Reference

package/docs/comprehension-push/configuration.md

@@ -0,0 +1,308 @@
+# Comprehension Push Configuration Reference
+
+The `load_comprehension` command (aliases: `load`, `push`) pushes a comprehension JSON file to a Meadow REST API using the Integration Adapter service. It is configured through a `.meadow.config.json` file and/or CLI flags.
+
+## Configuration File
+
+The configuration file is named `.meadow.config.json`. The CLI toolkit automatically searches for this file using the same cascading strategy as the data-clone command.
+
+### Cascading Resolution Order
+
+1. **Current working directory** -- `.meadow.config.json` in the directory where the command is run.
+2. **Parent directories** -- Walks up the directory tree searching for `.meadow.config.json`.
+3. **Home directory** -- `~/.meadow.config.json` as a fallback.
+
+Settings from the configuration file are merged with the built-in defaults. CLI flags override configuration file values.
+
+## Full Configuration Schema
+
+```json
+{
+    "Source": {
+        "ServerURL": "https://api.example.com/1.0/",
+        "UserID": "integration_user",
+        "Password": "integration_password"
+    },
+    "SessionManager": {
+        "Sessions": {
+            "Default": {
+                "ServerURL": "https://api.example.com/1.0/",
+                "Credentials": {
+                    "username": "session_user",
+                    "password": "session_password"
+                }
+            }
+        }
+    }
+}
+```
+
+The `load_comprehension` command uses the same `Source` block as the `data-clone` command, and the same `SessionManager` block. The `Destination`, `SchemaPath`, and `Sync` blocks are not used by this command.
+
+## Section Reference
+
+### Source
+
+Configuration for the Meadow REST API server to push comprehension data to.
+
+| Property | Type | Default | Description |
+|----------|------|---------|-------------|
+| `ServerURL` | string | `"https://localhost:8080/1.0/"` | Base URL of the Meadow API (must include trailing `/1.0/`) |
+| `UserID` | string or false | `false` | Username for API authentication; set to `false` to skip built-in auth |
+| `Password` | string or false | `false` | Password for API authentication; set to `false` to skip built-in auth |
+
+When `UserID` and `Password` are both `false`, the command skips built-in authentication. You can still authenticate via `SessionManager` (see below).
+
+### SessionManager
+
+Optional session-based authentication using `pict-sessionmanager`. This is the same mechanism used by the `data-clone` command, so the same `.meadow.config.json` file can drive both operations against the same server.
+
+| Property | Type | Default | Description |
+|----------|------|---------|-------------|
+| `Sessions` | object | `{}` | Map of session name to session configuration |
+
+Each session is an object with:
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `ServerURL` | string | The server URL for this session |
+| `Credentials` | object | Credential key-value pairs to pass to the authenticator |
+
+When `SessionManager.Sessions` is empty or omitted, session-based authentication is skipped.
+
+#### Authentication Order
+
+The command authenticates in this order:
+
+1. **SessionManager** -- If `SessionManager.Sessions` is configured, each session is authenticated first. The SessionManager is connected to the REST client so credentials are auto-injected into all subsequent requests.
+2. **Built-in credentials** -- If `Source.UserID` and `Source.Password` are set, the command authenticates with the API using the standard `Authenticate` endpoint.
+3. **No authentication** -- If neither is configured, requests are made unauthenticated.
+
+Both mechanisms can be used together. SessionManager handles token/cookie injection while built-in auth provides a direct login.
+
+## CLI Flag Overrides
+
+All configuration values can be overridden via CLI flags. CLI flags take precedence over values from `.meadow.config.json`.
+
+### Source (API) Flags
+
+| Flag | Long Form | Description |
+|------|-----------|-------------|
+| `-a` | `--api_server` | API server URL (maps to `Source.ServerURL`) |
+| `-u` | `--api_username` | API username (maps to `Source.UserID`) |
+| `-w` | `--api_password` | API password (maps to `Source.Password`) |
+
+### GUID Flags
+
+| Flag | Long Form | Default | Description |
+|------|-----------|---------|-------------|
+| `-p` | `--prefix` | `"INTG-DEF"` | Adapter-set GUID marshal prefix. Applied to all entities. |
+| `-e` | `--entityguidprefix` | Auto-generated | Per-entity GUID marshal prefix. Overrides the auto-generated prefix for all entities. |
+| | `--allowguidtruncation` | `false` | Allow automatic prefix truncation when a generated GUID exceeds the server's column size. Without this flag, oversized GUIDs cause an error. |
+
+The generated Meadow GUID follows this pattern:
+
+```
+{prefix}-{entityguidprefix}-{ExternalGUID}
+```
+
+For example, with `--prefix "MYAPP"` and entity `Book` with a comprehension GUID of `Book_1`:
+
+```
+MYAPP-E-Book-Book_1
+```
+
+When `--entityguidprefix` is not specified, the auto-generated prefix is the capital letters of the entity name (e.g. `Book` -> `B`, `BookAuthorJoin` -> `BAJ`).
+
+### Batch and Performance Flags
+
+| Flag | Long Form | Default | Description |
+|------|-----------|---------|-------------|
+| | `--bulkupsert` | `"true"` | Enable bulk upsert mode. Set to `"false"` to force single-record upserts. |
+| | `--batchsize` | `100` | Number of records per bulk upsert batch. |
+| | `--progressinterval` | `100` | How often (in records) to log per-entity progress. |
+| | `--metaprogressinterval` | `0` | How often (in records) to log cross-entity meta progress. `0` disables meta progress logging. |
+
+### Other Flags
+
+| Flag | Long Form | Default | Description |
+|------|-----------|---------|-------------|
+| | `--logfile` | None | Path to write log output to a file. |
+
+## Complete Working Examples
+
+### Example 1: Minimal -- Push with CLI Credentials
+
+No config file needed. Everything on the command line:
+
+```bash
+mdwint load_comprehension ./my-data.json \
+  --api_server "https://api.example.com/1.0/" \
+  --api_username "admin" \
+  --api_password "admin_password" \
+  --prefix "MYAPP"
+```
+
+### Example 2: Config File with Built-in Authentication
+
+`.meadow.config.json`:
+
+```json
+{
+    "Source": {
+        "ServerURL": "https://api.example.com/1.0/",
+        "UserID": "integration_user",
+        "Password": "integration_password"
+    }
+}
+```
+
+Run:
+
+```bash
+mdwint load_comprehension ./entities.json
+```
+
+### Example 3: Config File with SessionManager (Same as Clone)
+
+This is the key use case: the same `.meadow.config.json` used for `data-clone` also works for `load_comprehension`, so you can clone data from a server and push comprehensions to the same server using the same credentials.
+
+`.meadow.config.json`:
+
+```json
+{
+    "Source": {
+        "ServerURL": "https://api.example.com/1.0/",
+        "UserID": "admin",
+        "Password": "admin_password"
+    },
+    "SessionManager": {
+        "Sessions": {
+            "Default": {
+                "ServerURL": "https://api.example.com/1.0/",
+                "Credentials": {
+                    "username": "admin",
+                    "password": "admin_password"
+                }
+            }
+        }
+    },
+    "Destination": {
+        "Provider": "MySQL",
+        "MySQL": {
+            "server": "127.0.0.1",
+            "database": "meadow_clone"
+        }
+    },
+    "SchemaPath": "./schema/Model-Extended.json"
+}
+```
+
+Clone data, then push a comprehension -- both use the same config:
+
+```bash
+mdwint data-clone
+mdwint load_comprehension ./new-records.json --prefix "IMPORT-2026"
+```
+
+### Example 4: Large Import with Progress Tracking
+
+```bash
+mdwint load_comprehension ./large-dataset.json \
+  --api_server "https://api.example.com/1.0/" \
+  --api_username "admin" \
+  --api_password "admin_password" \
+  --prefix "BULK" \
+  --batchsize 200 \
+  --metaprogressinterval 500 \
+  --progressinterval 50
+```
+
+This logs per-entity progress every 50 records and overall progress every 500 records.
+
+### Example 5: Allow GUID Truncation for One-Time Import
+
+When the generated GUID (prefix + external GUID) exceeds the server's GUID column size, the command errors by default. For one-time imports where GUID stability is not critical, you can allow automatic prefix truncation:
+
+```bash
+mdwint load_comprehension ./legacy-import.json \
+  --api_server "https://api.example.com/1.0/" \
+  --api_username "admin" \
+  --api_password "admin_password" \
+  --prefix "LEGACY-IMPORT-2026" \
+  --allowguidtruncation
+```
+
+The adapter truncates the prefix to fit the column size while preserving the full external GUID.
+
+### Example 6: Single-Record Upserts (Disable Bulk)
+
+For debugging or when the server does not support bulk upserts:
+
+```bash
+mdwint load_comprehension ./debug-data.json \
+  --api_server "https://localhost:8080/1.0/" \
+  --bulkupsert false
+```
+
+## Comprehension File Format
+
+The comprehension file is a JSON object where top-level keys are entity names and values are objects keyed by GUID containing record data:
+
+```json
+{
+    "Book": {
+        "Book_1": {
+            "GUIDBook": "Book_1",
+            "Title": "The Hunger Games",
+            "Language": "eng"
+        },
+        "Book_2": {
+            "GUIDBook": "Book_2",
+            "Title": "Harry Potter",
+            "Language": "eng"
+        }
+    },
+    "Author": {
+        "Author_SC": {
+            "GUIDAuthor": "Author_SC",
+            "Name": "Suzanne Collins"
+        }
+    }
+}
+```
+
+Entities are processed in the order they appear in the file. Entities referenced by other entities (via foreign key GUIDs) should appear first so their Meadow IDs are available for cross-entity lookups.
+
+### Cross-Entity GUID Resolution
+
+Source records can reference other entities using GUID fields. The adapter resolves these to Meadow IDs during marshaling:
+
+- **`GUIDEntityName`** -- External system GUID. The adapter looks up the corresponding Meadow ID from the session's local GUID map (populated when that entity was pushed earlier in the same session).
+- **`_GUIDEntityName`** -- Meadow GUID (underscore prefix). The adapter performs an async server API lookup (`GET /Entity/By/GUIDEntity/{GUID}`) to resolve the Meadow ID. Use this for records that reference entities already on the server but not pushed in the current session.
+
+For example, a BookAuthorJoin record referencing an existing Author already on the server:
+
+```json
+{
+    "BookAuthorJoin": {
+        "BAJ_1": {
+            "GUIDBookAuthorJoin": "BAJ_1",
+            "GUIDBook": "Book_1",
+            "_GUIDAuthor": "Author_SC"
+        }
+    }
+}
+```
+
+Here `GUIDBook` is resolved from the session map (Book was pushed earlier), while `_GUIDAuthor` triggers a server lookup.
+
+## Using the Explanation Command
+
+The CLI includes a built-in command to display the resolved configuration:
+
+```bash
+mdwint config
+```
+
+This shows the merged result of default values, configuration file values, and CLI overrides, helping you verify what settings will be used before running a push.

package/docs/integration-adapter.md

@@ -1,6 +1,6 @@
 # Integration Adapter
 
-The Integration Adapter is the bridge between comprehension data and a running Meadow REST API.  It handles record marshaling, GUID generation, schema validation, batch operations, and retry logic.
+The Integration Adapter is the bridge between comprehension data and a running Meadow REST API.  It handles record marshaling, GUID generation, schema validation, batch operations, progress tracking, and retry logic.
 
 ## Overview
 
@@ -12,6 +12,7 @@ Source Records (from comprehension or external system)
         |
         v
     marshalRecord()  -- map external GUIDs to Meadow GUIDs
+                     -- resolve _GUID fields via async server lookup
                      -- validate against Meadow schema
                      -- truncate strings to schema limits
                      -- strip reserved fields (CreateDate, etc.)
@@ -19,11 +20,28 @@ Source Records (from comprehension or external system)
         v
     pushRecordsToServer()  -- single or bulk upsert
                            -- automatic retry on failure
+                           -- per-entity progress tracking
+                           -- meta (cross-entity) progress tracking
         |
         v
     GUIDMap updated  -- Meadow IDs stored for cross-entity lookups
 ```
 
+## REST Client Injection
+
+The adapter supports flexible REST client injection. You can provide a client in three ways:
+
+1. **Explicit injection** via `setRestClient(pClient)` or `options.Client`
+2. **Auto-resolved** from `fable.MeadowCloneRestClient` (used by the CLI command)
+3. **Legacy fallback** from `fable.EntityProvider` (backwards compatible)
+
+```javascript
+const adapter = libAdapter.getAdapter(myFable, 'Book', 'BK');
+adapter.setRestClient(myFable.MeadowCloneRestClient);
+```
+
+The client should expose: `upsertEntity`, `upsertEntities`, `getEntityByGUID`, `getEntity`, `deleteEntity`, and `getJSON`.
+
 ## GUID Marshaling
 
 External system GUIDs are transformed into deterministic Meadow GUIDs using this pattern:
@@ -41,19 +59,60 @@ Meadow GUID:   "INTG-DEF-E-Book-12345"
 
 This ensures GUIDs are unique across integration sets and entities.
 
+### GUID Length Validation
+
+The adapter validates that generated GUIDs do not exceed the server's GUID column size. The maximum length is resolved from (in order):
+
+1. **Explicit `GUIDMaxLength` option** -- positive integer overrides everything
+2. **`GUIDColumnSizes` map** -- per-entity sizes passed in options (e.g. from a schema build step)
+3. **Live server schema** -- fetched via `GET /Entity/Schema` during `integrateRecords()`
+4. **`DefaultGUIDColumnSize`** -- fallback (default: 36)
+
+When a GUID exceeds the maximum length:
+
+- **Default behavior** (`AllowGUIDTruncation: false`): Throws an error with a clear message showing the GUID, prefix, and limit.
+- **Truncation mode** (`AllowGUIDTruncation: true`): The prefix is progressively truncated to fit while preserving the full external GUID. Use this for one-time imports where GUID stability is not required.
+
 ### Cross-Entity GUID Resolution
 
-When a source record contains GUID fields for other entities (e.g. `GUIDAuthor` on a BookAuthorJoin record), the adapter looks up the corresponding Meadow ID via the GUIDMap:
+When a source record contains GUID fields for other entities, the adapter resolves them to Meadow IDs:
+
+#### External GUIDs (`GUIDEntityName`)
+
+Fields starting with `GUID` (without underscore) are treated as external system GUIDs. The adapter looks up the corresponding Meadow ID from the session's local External GUID Map:
+
+```javascript
+// Source: { GUIDBookAuthorJoin: "BAJ_1", GUIDBook: "Book_1", GUIDAuthor: "Author_5" }
+// Adapter resolves:
+//   GUIDBook "Book_1" -> ExternalGUIDMap -> Meadow GUID -> GUIDMap -> IDBook: 42
+//   GUIDAuthor "Author_5" -> ExternalGUIDMap -> Meadow GUID -> GUIDMap -> IDAuthor: 17
+```
+
+This requires the referenced entity to have been integrated earlier in the same session.
+
+#### Meadow GUIDs (`_GUIDEntityName`)
+
+Fields starting with `_GUID` (underscore prefix) are treated as Meadow GUIDs that may already exist on the server. The adapter performs an **async server API lookup** via `getIDFromGUIDAsync`:
+
+```javascript
+// Source: { GUIDProduct: "Prod_1", _GUIDMaterial: "LADOTD-Material-9999M99999" }
+// Adapter resolves:
+//   _GUIDMaterial -> async GET /Material/By/GUIDMaterial/LADOTD-Material-9999M99999 -> IDMaterial: 5012
+```
+
+Use this for records that reference entities already on the server but not pushed in the current session.
+
+#### Destination Field Overrides (`_Dest_IDEntity_*_Via_*`)
+
+For explicit control over which ID field a resolved GUID maps to:
 
 ```javascript
-// Source record: { GUIDBookAuthorJoin: "BAJ_1", GUIDBook: "Book_1", GUIDAuthor: "Author_5" }
-// Adapter marshals:
-//   - GUIDBookAuthorJoin -> "INTG-DEF-E-BookAuthorJoin-BAJ_1"
-//   - GUIDBook -> looks up Meadow ID for external GUID "Book_1" -> IDBook: 42
-//   - GUIDAuthor -> looks up Meadow ID for external GUID "Author_5" -> IDAuthor: 17
+// Source: { "_Dest_IDEntity_IDCustomField_Via_GUIDMaterial": "some-guid-value" }
+// Adapter resolves the GUID via server lookup and sets:
+//   record.IDCustomField = resolvedID
 ```
 
-This is why entity integration order matters -- entities that are referenced by other entities should be integrated first so their IDs are available in the GUIDMap.
+This is useful when the foreign key column name doesn't follow the standard `ID{EntityName}` pattern.
 
 ## Batch Processing
 
@@ -64,13 +123,36 @@ The adapter automatically switches between single and bulk upsert modes:
 
 ## Retry Logic
 
-Failed upsert operations are retried up to `RecordPushRetryThreshold` times (default 5), with a hard cap of 50 retries.  The adapter validates server responses to confirm:
+Failed upsert operations are retried up to `RecordPushRetryThreshold` times (default 5), with a hard cap of 50 retries. The adapter validates server responses to confirm:
 
 1. The response contains the entity ID field
 2. The ID is a positive number
 3. The response GUID matches the sent GUID
 
-If validation fails, the record is retried.
+If validation fails, the record is retried. Specific error types are handled without retry:
+
+- **Duplicate entry errors** -- Logged as warnings and skipped
+- **GUID length rejections** -- Logged as errors and skipped
+- **Server create rejections** -- Logged as errors and skipped
+
+When the retry threshold is exhausted, the adapter attempts a fallback read of the record by GUID to populate the GUID-to-ID mapping even if the upsert failed.
+
+## Progress Tracking
+
+### Per-Entity Progress
+
+Every entity push creates a progress tracker via `fable.ProgressTrackerSet`. The tracker logs status at each record (single mode) or each batch (bulk mode).
+
+### Meta Progress
+
+For cross-entity progress tracking across an entire comprehension push, callers can set:
+
+```javascript
+adapter.MetaProgressTrackerHash = myTrackerHash;
+adapter.MetaProgressTrackerLogInterval = 500; // log every ~500 records
+```
+
+The meta tracker uses a threshold-crossing interval check rather than exact modulo, so bulk increments (e.g. +100 per batch) reliably trigger logging when they cross an interval boundary.
 
 ## Schema Validation
 
@@ -78,7 +160,8 @@ When `integrateRecords()` is called, the adapter fetches the entity schema from
 
 - String fields are truncated to their schema-defined `size`
 - Non-string fields are passed through
-- Unknown fields (not in schema) are dropped
+- When `SimpleMarshal` is true, all schema-matched fields are passed through without type coercion
+- When `ForceMarshal` is true, fields not found in the schema are still included
 - Reserved fields (`CreateDate`, `UpdateDate`, `Deleted`, `DeleteDate`) are always stripped
 
 ## Delete Operations
@@ -91,19 +174,85 @@ The `load_comprehension` command wraps the Integration Adapter for CLI use:
 
 ```shell
 npx meadow-integration load_comprehension ./my-comprehension.json \
-  -p "MY-PREFIX" \
-  -e "MY-ENTITY-PREFIX"
+  --api_server "https://api.example.com/1.0/" \
+  --api_username "admin" \
+  --api_password "admin_password" \
+  --prefix "MY-PREFIX" \
+  --batchsize 200 \
+  --metaprogressinterval 500
 ```
 
-This automatically creates adapters for every entity in the comprehension and processes them in sequence.
+This automatically creates adapters for every entity in the comprehension, injects the REST client and SessionManager credentials, and processes entities in sequence.
+
+See [Comprehension Push Configuration](comprehension-push/configuration.md) for full CLI options and configuration details.
+
+## Programmatic Usage
+
+```javascript
+const libMeadowIntegration = require('meadow-integration');
+const libFable = require('fable');
+
+let myFable = new libFable({ /* ... */ });
+
+// Register the adapter service type
+myFable.serviceManager.addServiceType('IntegrationAdapter',
+    libMeadowIntegration.IntegrationAdapter);
+
+// Get or create an adapter for 'Book'
+let bookAdapter = libMeadowIntegration.IntegrationAdapter.getAdapter(
+    myFable, 'Book', 'BK', { SimpleMarshal: true, ForceMarshal: true });
+
+// Inject a REST client
+bookAdapter.setRestClient(myRestClient);
+
+// Add source records
+bookAdapter.addSourceRecord({ GUIDBook: "Book_1", Title: "The Hunger Games" });
+bookAdapter.addSourceRecord({ GUIDBook: "Book_2", Title: "Harry Potter" });
+
+// Integrate (fetch schema, marshal, push)
+bookAdapter.integrateRecords((pError) =>
+{
+    if (pError)
+    {
+        console.error('Integration failed:', pError);
+        return;
+    }
+    console.log('Books integrated successfully.');
+});
+```
 
 ## Static Helper
 
 The `getAdapter()` static method provides a convenient way to get or create an adapter:
 
 ```javascript
-const libAdapter = require('meadow-integration/source/Meadow-Service-Integration-Adapter.js');
+const libAdapter = require('meadow-integration').IntegrationAdapter;
 
 // Gets existing adapter for 'Book' or creates a new one
 let tmpAdapter = libAdapter.getAdapter(myFable, 'Book', 'BK');
+
+// With custom options (e.g. SimpleMarshal, ForceMarshal, AllowGUIDTruncation)
+let tmpAdapter = libAdapter.getAdapter(myFable, 'Book', 'BK',
+    { SimpleMarshal: true, ForceMarshal: true, AllowGUIDTruncation: true });
 ```
+
+## Adapter Options Reference
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `Entity` | string | `"DefaultEntity"` | The Meadow entity name |
+| `AdapterSetGUIDMarshalPrefix` | string or false | `false` (falls back to `"INTG-DEF"`) | Prefix for the adapter set in generated GUIDs |
+| `EntityGUIDMarshalPrefix` | string or false | `false` (auto: `"E-{Entity}"`) | Per-entity prefix in generated GUIDs |
+| `GUIDMaxLength` | number | `0` (auto-detect) | Maximum GUID length; 0 = resolve from schema |
+| `GUIDColumnSizes` | object | `{}` | Per-entity GUID column sizes (entity name -> max size) |
+| `DefaultGUIDColumnSize` | number | `36` | Fallback GUID column size |
+| `AllowGUIDTruncation` | boolean | `false` | Allow prefix truncation for oversized GUIDs |
+| `SimpleMarshal` | boolean | `false` | Pass through schema-matched fields without type coercion |
+| `ForceMarshal` | boolean | `false` | Include fields not found in schema |
+| `PerformUpserts` | boolean | `true` | Enable upsert operations |
+| `PerformDeletes` | boolean | `true` | Enable delete operations |
+| `RecordPushRetryThreshold` | number | `5` | Max retries per record/batch |
+| `RecordThresholdForBulkUpsert` | number | `1000` | Record count above which bulk mode is used |
+| `BulkUpsertBatchSize` | number | `100` | Records per bulk upsert batch |
+| `ProgressLogInterval` | number | `100` | Per-entity progress log interval |
+| `Client` | object | `null` | REST client instance (alternative to `setRestClient()`) |

package/examples/example-comprehension-push.meadow.config.json

@@ -0,0 +1,23 @@
+{
+	"Source":
+	{
+		"ServerURL": "https://api.example.com/1.0/",
+		"UserID": "integration_user",
+		"Password": "integration_password"
+	},
+	"SessionManager":
+	{
+		"Sessions":
+		{
+			"Default":
+			{
+				"ServerURL": "https://api.example.com/1.0/",
+				"Credentials":
+				{
+					"username": "session_user",
+					"password": "session_password"
+				}
+			}
+		}
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "meadow-integration",
-    "version": "1.0.18",
+    "version": "1.0.19",
     "description": "Meadow Data Integration",
     "bin": {
         "mdwint": "source/cli/Meadow-Integration-CLI-Run.js"

package/source/Meadow-Integration.js

@@ -8,6 +8,9 @@ const libSyncEntityInitial = require(`./services/clone/Meadow-Service-Sync-Entit
 const libSyncEntityOngoing = require(`./services/clone/Meadow-Service-Sync-Entity-Ongoing.js`);
 const libOperation = require(`./services/clone/Meadow-Service-Operation.js`);
 
+const libIntegrationAdapter = require(`./Meadow-Service-Integration-Adapter.js`);
+const libGUIDMap = require(`./Meadow-Service-Integration-GUIDMap.js`);
+
 module.exports = (
 	{
 		TabularCheck: libTabularCheck,
@@ -18,5 +21,8 @@ module.exports = (
 		Sync: libSync,
 		SyncEntityInitial: libSyncEntityInitial,
 		SyncEntityOngoing: libSyncEntityOngoing,
-		Operation: libOperation
+		Operation: libOperation,
+
+		IntegrationAdapter: libIntegrationAdapter,
+		GUIDMap: libGUIDMap
 	});