@memberjunction/integration-connectors 5.40.2 → 5.42.0

package/dist/NetForumConnector.js

@@ -5,496 +5,769 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 /**
- * ⚠️ NEEDS REWORK BEFORE SHIPPING — 3 known wire-level gaps ⚠️
+ * NetForumConnector — netFORUM Enterprise xWeb SOAP/XML integration connector.
  *
- * 2026-05-20 vendor-truth audit:
+ * Protocol: SOAP 1.1 over HTTPS. There is NO `BaseSOAPIntegrationConnector` in the
+ * engine — the only protocol bases are `BaseIntegrationConnector` (grandparent) and
+ * `BaseRESTIntegrationConnector`. This connector rides `BaseRESTIntegrationConnector`
+ * and implements SOAP over its HTTP seam: it POSTs SOAP 1.1 envelopes to
+ * `/xweb/secure/netForumXML.asmx` via `MakeHTTPRequest` and parses the XML in
+ * `NormalizeResponse`. The transport is text/xml, not JSON.
  *
- *   1. Auth token is returned in the WWW-Authenticate RESPONSE HEADER, not in the
- *      JSON body. Vendor doc quote: "The token is in the WWW-Authenticate header.
- *      The value will look like: 'Bearer token = eb5667ab-25ac-45c9-b831-23b43be8f194'".
- *      Current code (line ~195) parses response.json() expecting `{ Token: string }` —
- *      will fail to extract the token from every real authenticate call.
- *   2. `LastModifiedDate` is not a canonical NetForum column. Each facade uses a
- *      prefixed name (`ind_last_updated_dt` for Individual, `evt_last_updated_dt`
- *      for Event, etc.). FetchChanges currently emits `szWhereClause=LastModifiedDate
- *      >= '<wm>'` which yields zero rows or a query error on every object.
- *   3. `DeleteFacadeObject` is not in any reachable vendor doc snippet. Get/Insert/
- *      Update facade methods are documented. SupportsDelete=true may need to flip
- *      false, or use a different method (vendor refers to "soft-deletes" generically).
+ * ── Wire truth (from the public WSDL: sources/netForumXML_asm.wsdl, 5.9 MB, 277 ops) ──
  *
- * Vendor doc URLs:
- *   - xWeb Overview: https://documentation.abila.com/netforum-enterprise/2017.1/Content/xWeb/XWeb_Overview.htm
- *   - JSON over xWeb: http://documentation.abila.com/netforum-enterprise/2017.1/Content/xWeb/JSON_Over_xWeb_Overview.htm
- *   - xWeb Methods: https://nfesupport.zendesk.com/hc/en-us/articles/10639146855565
- *   - Authenticate: https://nfesupport.zendesk.com/hc/en-us/articles/10639139863309-Authenticate
+ *   Endpoint   : POST <tenantHost>/xweb/secure/netForumXML.asmx   (Content-Type: text/xml; charset=utf-8)
+ *   Namespace  : http://www.avectra.com/2005/   (Avectra-era, retained by Community Brands)
+ *   SOAPAction : http://www.avectra.com/2005/<MethodName>
+ *
+ *   Auth (TWO-STEP, SOAP — NOT HTTP Basic / WWW-Authenticate / Bearer):
+ *     1. Authenticate(userName, password) → AuthenticateResult (the token string).
+ *        The Authenticate envelope carries NO AuthorizationToken header — it is the bootstrap.
+ *     2. Every subsequent data/CRUD call carries the token in the SOAP HEADER element:
+ *          <AuthorizationToken xmlns="http://www.avectra.com/2005/"><Token>{token}</Token></AuthorizationToken>
+ *        (NOT an HTTP Authorization header.) Source: WSDL `AuthorizationToken` complexType +
+ *        `<soap:header part="AuthorizationToken">` on every WEB-prefixed / GetQuery operation binding.
+ *
+ *   Read (door = GetQuery):
+ *     GetQuery(szObjectName, szColumnList, szWhereClause?, szOrderBy?) → GetQueryResult
+ *       - GetQueryResult is a `<s:any>` wildcard DataSet — flattened rows, one element per row.
+ *       - Incremental: szWhereClause = "<watermarkField> >= '<wm>'" where the watermark column is
+ *         the IO's per-facade `IncrementalWatermarkField` (e.g. ind_change_date, evt_*_change_date).
+ *         There is NO canonical `LastModifiedDate` column — the field is per-facade and is read
+ *         from metadata, never hardcoded.
+ *       - Row limit: szObjectName supports an `@TOP -1` / `@TOP N` modifier to bypass / bound the
+ *         server-side DataGrid row cap. The connector requests the modifier from the IO's accessPath.
  *
- * Auth: Two-step token auth.
- *   1. POST /xWeb/Signon.asmx with credentials → returns auth token in SOAP header
- *   2. JSON mode: POST /xWeb/JSON/Authenticate with Basic Auth → returns token
- *      Pass token as Authorization: Bearer {token} on subsequent calls
- * Base URL: https://{site}/xWeb/JSON/{MethodName} (JSON mode)
- *           https://{site}/xWeb/netForumXML.asmx (SOAP mode)
- * Pagination: Results returned in full via WEBQuery/GetQuery — no standard offset/limit
- * Rate limits: Instance-dependent (not documented)
- * Incremental: Via query parameters (date range filters in WEBQuery)
- * CRUD: Via facade CRUD methods (GetFacadeObject, InsertFacadeObject, UpdateFacadeObject, DeleteFacadeObject)
+ *   Discovery (mechanism, NOT a baked catalog):
+ *     - Standard objects come from the Declared metadata (the persisted IntegrationObject rows in
+ *       the engine cache — credential-free docs → static metadata, case 1). `DiscoverObjects`
+ *       returns the cache; it does NOT enumerate a hardcoded `NF_OBJECTS` array (that was the bug
+ *       this IMPROVE round removes).
+ *     - Per-object field definitions come from `GetQueryDefinition(szObjectName)` at runtime
+ *       (credential-gated, case 2): the response carries the SQL column definition
+ *       (Object → ListTable → ListFromTables → ListFromTable[] → Columns → Column[]). The connector
+ *       parses that into ExternalFieldSchema. With no credential it falls back to the Declared
+ *       fields. The customer's own installed query objects (variable per installation) are reached
+ *       the same way — GetQueryDefinition is the discovery MECHANISM, never an answer baked in code.
+ *     - `DiscoveryIsAuthoritative` is FALSE: discovery extends the Declared baseline, it does not
+ *       enumerate the full credential gamut, so absence in a refresh must NEVER deactivate.
  *
- * API Categories:
- *   - JSON over xWeb (implemented) — RESTful JSON wrapper over xWeb methods
- *   - SOAP xWeb (NOT implemented) — legacy XML, JSON mode preferred
- *   - SQL Views (NOT implemented) — direct SQL access, not API-based
- *   - Webhooks (NOT available) — no webhook/CDC support in NetForum
+ *   Write (facade CRUD — only where metadata declares the capability + per-operation columns):
+ *     - Create/Update route through the IO's per-operation columns (CreateAPIPath/CreateMethod/
+ *       CreateBodyShape/CreateBodyKey/CreateIDLocation, Update*) which name the SOAP operation
+ *       (e.g. WEBIndividualInsert, InsertFacadeObject). The connector wraps the attributes in a
+ *       SOAP envelope for that operation and routes the result through BuildCreatedResult so a 2xx
+ *       with no record key fails loudly (no silent record loss / duplicate-create next sync).
+ *     - SupportsDelete = false. `DeleteFacadeObject` is not confirmed in any reachable vendor doc;
+ *       netFORUM prefers soft-delete via status flags. Held false until verified.
+ *
+ * Vendor doc URLs:
+ *   - WSDL (primary)  : https://myasm.asm.org/xweb/secure/netforumxml.asmx?WSDL
+ *   - xWeb Overview   : https://documentation.abila.com/netforum-enterprise/2017.1/Content/xWeb/XWeb_Overview.htm
+ *   - GetQuery        : https://documentation.abila.com/netforum-enterprise/2017.1/Content/xWeb/Methods/GetQuery.htm
  */
 import { RegisterClass } from '@memberjunction/global';
 import { Metadata } from '@memberjunction/core';
 import { BaseIntegrationConnector, BaseRESTIntegrationConnector, } from '@memberjunction/integration-engine';
+// ─── Constants ───────────────────────────────────────────────────────
+/** Avectra-era SOAP namespace, retained by Community Brands. All ops + types use it. */
+const SOAP_NS = 'http://www.avectra.com/2005/';
+/** Canonical xWeb SOAP endpoint path (per-tenant host; path is constant). */
+const DEFAULT_SOAP_PATH = '/xweb/secure/netForumXML.asmx';
 const MAX_RETRIES = 3;
 const REQUEST_TIMEOUT_MS = 30_000;
 const MIN_REQUEST_INTERVAL_MS = 200;
-// NetForum facade objects — each maps to a GetFacadeObject/WEBQuery target
-const NF_OBJECTS = [
-    { Name: 'Individual', DisplayName: 'Individual', Description: 'Individual contacts/members', SupportsWrite: true, Fields: [
-            { Name: 'ind_cst_key', DisplayName: 'Customer Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Customer GUID' },
-            { Name: 'ind_last_updated_dt', DisplayName: 'Last Updated', Type: 'datetime', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'Incremental date' },
-        ] },
-    { Name: 'Organization', DisplayName: 'Organization', Description: 'Organization/company records', SupportsWrite: true, Fields: [
-            { Name: 'org_cst_key', DisplayName: 'Customer Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Customer GUID' },
-        ] },
-    { Name: 'Membership', DisplayName: 'Membership', Description: 'Membership records', SupportsWrite: true, Fields: [
-            { Name: 'mbr_key', DisplayName: 'Membership Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Membership GUID' },
-            { Name: 'mbr_cst_key', DisplayName: 'Customer Key', Type: 'string', IsRequired: false, IsReadOnly: false, IsPrimaryKey: false, Description: 'FK → Individual/Organization' },
-        ] },
-    { Name: 'MembershipType', DisplayName: 'Membership Type', Description: 'Membership type definitions', SupportsWrite: false, Fields: [
-            { Name: 'mbt_key', DisplayName: 'Type Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Type GUID' },
-        ] },
-    { Name: 'Event', DisplayName: 'Event', Description: 'Events and conferences', SupportsWrite: true, Fields: [
-            { Name: 'evt_key', DisplayName: 'Event Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Event GUID' },
-            { Name: 'evt_start_dt', DisplayName: 'Start Date', Type: 'datetime', IsRequired: false, IsReadOnly: false, IsPrimaryKey: false, Description: 'Incremental date' },
-        ] },
-    { Name: 'EventRegistration', DisplayName: 'Event Registration', Description: 'Event registrations', SupportsWrite: true, Fields: [
-            { Name: 'reg_key', DisplayName: 'Registration Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Registration GUID' },
-            { Name: 'reg_evt_key', DisplayName: 'Event Key', Type: 'string', IsRequired: true, IsReadOnly: false, IsPrimaryKey: false, Description: 'FK → Event' },
-            { Name: 'reg_cst_key', DisplayName: 'Customer Key', Type: 'string', IsRequired: false, IsReadOnly: false, IsPrimaryKey: false, Description: 'FK → Individual' },
-        ] },
-    { Name: 'Committee', DisplayName: 'Committee', Description: 'Committees and boards', SupportsWrite: true, Fields: [
-            { Name: 'cmt_key', DisplayName: 'Committee Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Committee GUID' },
-        ] },
-    { Name: 'CommitteeMember', DisplayName: 'Committee Member', Description: 'Committee membership', SupportsWrite: true, Fields: [
-            { Name: 'cmm_key', DisplayName: 'Member Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Committee member GUID' },
-            { Name: 'cmm_cmt_key', DisplayName: 'Committee Key', Type: 'string', IsRequired: true, IsReadOnly: false, IsPrimaryKey: false, Description: 'FK → Committee' },
-            { Name: 'cmm_cst_key', DisplayName: 'Customer Key', Type: 'string', IsRequired: false, IsReadOnly: false, IsPrimaryKey: false, Description: 'FK → Individual' },
-        ] },
-    { Name: 'Invoice', DisplayName: 'Invoice', Description: 'Invoices', SupportsWrite: true, Fields: [
-            { Name: 'inv_key', DisplayName: 'Invoice Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Invoice GUID' },
-            { Name: 'inv_cst_key', DisplayName: 'Customer Key', Type: 'string', IsRequired: false, IsReadOnly: false, IsPrimaryKey: false, Description: 'FK → Individual/Organization' },
-        ] },
-    { Name: 'Payment', DisplayName: 'Payment', Description: 'Payment records', SupportsWrite: true, Fields: [
-            { Name: 'pmt_key', DisplayName: 'Payment Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Payment GUID' },
-        ] },
-    { Name: 'Product', DisplayName: 'Product', Description: 'Products for sale', SupportsWrite: true, Fields: [
-            { Name: 'prd_key', DisplayName: 'Product Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Product GUID' },
-        ] },
-    { Name: 'Order', DisplayName: 'Order', Description: 'Sales orders', SupportsWrite: true, Fields: [
-            { Name: 'ord_key', DisplayName: 'Order Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Order GUID' },
-            { Name: 'ord_cst_key', DisplayName: 'Customer Key', Type: 'string', IsRequired: false, IsReadOnly: false, IsPrimaryKey: false, Description: 'FK → Individual/Organization' },
-        ] },
-    { Name: 'Donation', DisplayName: 'Donation', Description: 'Donation/gift records', SupportsWrite: true, Fields: [
-            { Name: 'don_key', DisplayName: 'Donation Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Donation GUID' },
-            { Name: 'don_cst_key', DisplayName: 'Customer Key', Type: 'string', IsRequired: false, IsReadOnly: false, IsPrimaryKey: false, Description: 'FK → Individual/Organization' },
-        ] },
-    { Name: 'Address', DisplayName: 'Address', Description: 'Customer addresses', SupportsWrite: true, Fields: [
-            { Name: 'adr_key', DisplayName: 'Address Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Address GUID' },
-            { Name: 'adr_cst_key', DisplayName: 'Customer Key', Type: 'string', IsRequired: false, IsReadOnly: false, IsPrimaryKey: false, Description: 'FK → Individual/Organization' },
-        ] },
-    { Name: 'Session', DisplayName: 'Session', Description: 'Event sessions', SupportsWrite: true, Fields: [
-            { Name: 'ses_key', DisplayName: 'Session Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Session GUID' },
-            { Name: 'ses_evt_key', DisplayName: 'Event Key', Type: 'string', IsRequired: true, IsReadOnly: false, IsPrimaryKey: false, Description: 'FK → Event' },
-        ] },
-    { Name: 'Subscription', DisplayName: 'Subscription', Description: 'Publication subscriptions', SupportsWrite: true, Fields: [
-            { Name: 'sub_key', DisplayName: 'Subscription Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Subscription GUID' },
-            { Name: 'sub_cst_key', DisplayName: 'Customer Key', Type: 'string', IsRequired: false, IsReadOnly: false, IsPrimaryKey: false, Description: 'FK → Individual/Organization' },
-        ] },
-    { Name: 'Certification', DisplayName: 'Certification', Description: 'Professional certifications', SupportsWrite: true, Fields: [
-            { Name: 'crt_key', DisplayName: 'Certification Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'Certification GUID' },
-            { Name: 'crt_cst_key', DisplayName: 'Customer Key', Type: 'string', IsRequired: false, IsReadOnly: false, IsPrimaryKey: false, Description: 'FK → Individual' },
-        ] },
-    { Name: 'ContinuingEducation', DisplayName: 'CE Credit', Description: 'Continuing education credits', SupportsWrite: true, Fields: [
-            { Name: 'ceu_key', DisplayName: 'CE Key', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: true, Description: 'CE GUID' },
-            { Name: 'ceu_cst_key', DisplayName: 'Customer Key', Type: 'string', IsRequired: false, IsReadOnly: false, IsPrimaryKey: false, Description: 'FK → Individual' },
-        ] },
-];
+/** Session-token TTL. netFORUM does not publish a token lifetime; re-auth on 401 covers expiry. */
+const TOKEN_TTL_MS = 3_600_000;
 let NetForumConnector = class NetForumConnector extends BaseRESTIntegrationConnector {
     constructor() {
         super(...arguments);
         this.tokenCache = null;
         this.lastRequestTime = 0;
+        // ─── Per-object config helpers ───────────────────────────────────
+        /** Remembered integration ID from the last fetch, so StableOrderingKey can read the cache. */
+        this.LastIntegrationID = null;
     }
     get IntegrationName() { return 'NetForum Enterprise'; }
+    // Capability flags — kept in lockstep with the metadata's per-operation columns.
+    // Create/Update are declared on a subset of IOs (those with WEB*Insert/Update or a facade op);
+    // the generic CRUD path throws for an IO whose columns are null, so a flag here only asserts
+    // "at least one IO supports it". Delete stays false (DeleteFacadeObject unconfirmed in docs).
     get SupportsCreate() { return true; }
     get SupportsUpdate() { return true; }
-    // Vendor docs document InsertFacadeObject + UpdateFacadeObject; no DeleteFacadeObject
-    // appears in any reachable doc page. NetForum more commonly uses status flags ("soft
-    // delete") rather than hard delete. Keeping the flag false until DeleteFacadeObject
-    // is confirmed from a real vendor source — DeleteRecord returns a clean error.
     get SupportsDelete() { return false; }
     /**
-     * Resolves the canonical "last modified" column for a NetForum facade object.
-     * NetForum uses prefixed names (ind_last_updated_dt, evt_last_updated_dt, etc.)
-     * rather than a universal LastModifiedDate column. Falls back to the column
-     * declared in NF_OBJECTS, then to a generic 'last_updated_dt' if no static
-     * entry exists.
+     * §7 — discovery is NOT an authoritative full-gamut enumeration. `DiscoverObjects` returns the
+     * Declared baseline (engine cache) and GetQueryDefinition only extends per-object fields; neither
+     * enumerates the complete set of objects the credentials expose (customer-installed queries vary).
+     * So absence in a refresh proves nothing → the comprehensive-refresh deactivation path must stay
+     * off. Returning false keeps the Declared metadata safe from wrongful deactivation.
      */
-    ResolveWatermarkColumn(objectName) {
-        const obj = NF_OBJECTS.find(o => o.Name.toLowerCase() === objectName.toLowerCase());
-        if (obj) {
-            // Look for an explicit timestamp field on the static catalog
-            const timestampField = obj.Fields.find(f => /datetime/i.test(f.Type) && /last|updated|modified/i.test(f.Name));
-            if (timestampField)
-                return timestampField.Name;
-        }
-        // Fallback: NetForum's most common naming convention is <prefix>_last_updated_dt.
-        // Without a known prefix per object, return a generic name + warn.
-        console.warn(`[NetForum] No known watermark column for object '${objectName}'; using fallback 'last_updated_dt'`);
-        return 'last_updated_dt';
-    }
+    get DiscoveryIsAuthoritative() { return false; }
+    // ─── Auth — two-step SOAP token ──────────────────────────────────
     /**
-     * Resolves the PROVABLE watermark column for a NetForum facade object — i.e.
-     * a column the object's OWN static catalog declares as a datetime whose name
-     * matches last/updated/modified. Unlike ResolveWatermarkColumn(), this NEVER
-     * falls back to a guessed name: if the object declares no such field, it
-     * returns undefined so callers leave IncrementalWatermarkField unset.
+     * Step 1 of the two-step auth: POST a SOAP `Authenticate(userName, password)` envelope (which
+     * carries NO AuthorizationToken header — it is the bootstrap) and read the token string from
+     * `AuthenticateResult`. The token is cached and re-used until its TTL elapses or a 401 forces
+     * re-auth. Credentials go in the SOAP body elements — there is no HTTP Basic / Bearer here.
      */
-    ResolveDeclaredWatermarkColumn(objectName) {
-        const obj = NF_OBJECTS.find(o => o.Name.toLowerCase() === objectName.toLowerCase());
-        const timestampField = obj?.Fields.find(f => /datetime/i.test(f.Type) && /last|updated|modified/i.test(f.Name));
-        return timestampField?.Name;
+    async Authenticate(ci, cu) {
+        const config = await this.ParseConfig(ci, cu);
+        if (this.tokenCache && this.tokenCache.ExpiresAt > Date.now() + 60_000) {
+            return { Token: this.tokenCache.Token, Config: config };
+        }
+        const body = this.BuildSoapEnvelope('Authenticate', {
+            userName: config.Username,
+            password: config.Password,
+        });
+        const url = `${config.BaseURL}${DEFAULT_SOAP_PATH}`;
+        const headers = this.SoapHeaders('Authenticate');
+        const response = await this.MakeRawHTTPRequest(url, 'POST', headers, body);
+        if (response.Status < 200 || response.Status >= 300) {
+            throw new Error(`NetForum Authenticate failed: HTTP ${response.Status}`);
+        }
+        const token = this.ParseSoapScalar(this.AsText(response.Body), 'AuthenticateResult');
+        if (!token) {
+            throw new Error('NetForum Authenticate response contained no token (AuthenticateResult element)');
+        }
+        this.tokenCache = { Token: token, ExpiresAt: Date.now() + TOKEN_TTL_MS };
+        return { Token: token, Config: config };
     }
-    /**
-     * Resolves a field's declared foreign-key target to a sibling object actually
-     * declared in NF_OBJECTS. The static catalog encodes FK intent in the field
-     * Description (e.g. 'FK → Event'). This promotes that declaration into the
-     * framework's IsForeignKey/ForeignKeyTarget slots — but ONLY when the target
-     * resolves to exactly ONE declared sibling object. Polymorphic targets
-     * (e.g. 'FK → Individual/Organization') name two objects and are skipped.
-     */
-    ResolveForeignKeyTarget(description) {
-        if (!description)
-            return null;
-        const match = description.match(/^FK\s*(?:→|->)\s*(.+)$/i);
-        if (!match)
-            return null;
-        const target = match[1].trim();
-        // Polymorphic refs (e.g. 'Individual/Organization') name multiple objects — skip.
-        if (target.includes('/'))
-            return null;
-        const sibling = NF_OBJECTS.find(o => o.Name.toLowerCase() === target.toLowerCase());
-        return sibling ? sibling.Name : null;
+    async ParseConfig(ci, cu, provider) {
+        if (ci.CredentialID) {
+            const fromCred = await this.ParseConfigFromCredential(ci.CredentialID, cu, provider);
+            if (fromCred)
+                return fromCred;
+        }
+        if (ci.Configuration) {
+            const parsed = JSON.parse(ci.Configuration);
+            return this.ExtractConfig(parsed);
+        }
+        throw new Error('NetForum connector requires either CredentialID or Configuration JSON');
     }
-    GetIntegrationObjects() { return NF_OBJECTS; }
-    GetActionGeneratorConfig() {
-        const config = super.GetActionGeneratorConfig();
-        if (!config)
+    async ParseConfigFromCredential(credentialID, cu, provider) {
+        const md = provider ?? new Metadata();
+        const cred = await md.GetEntityObject('MJ: Credentials', cu);
+        const loaded = await cred.Load(credentialID);
+        if (!loaded || !cred.Values)
             return null;
-        config.IconClass = 'fa-solid fa-network-wired';
-        config.CategoryDescription = 'NetForum Enterprise AMS for members, events, committees, and orders';
-        config.ParentCategoryName = 'Association Management';
-        config.IncludeSearch = true;
-        config.IncludeList = true;
-        return config;
+        const values = JSON.parse(cred.Values);
+        return this.ExtractConfig(values);
+    }
+    ExtractConfig(values) {
+        const get = (...keys) => {
+            for (const key of keys) {
+                const hit = Object.entries(values).find(([k]) => k.toLowerCase() === key.toLowerCase());
+                if (hit)
+                    return String(hit[1] ?? '');
+            }
+            return undefined;
+        };
+        const baseURL = get('BaseURL', 'BaseUrl', 'base_url');
+        const username = get('Username', 'username', 'user', 'userName');
+        const password = get('Password', 'password', 'pass');
+        if (!baseURL)
+            throw new Error('NetForum configuration missing required field: BaseURL');
+        if (!username)
+            throw new Error('NetForum configuration missing required field: Username');
+        if (!password)
+            throw new Error('NetForum configuration missing required field: Password');
+        return { BaseURL: this.StripTrailingSlash(baseURL), Username: username, Password: password };
+    }
+    StripTrailingSlash(s) { return s.replace(/\/+$/, ''); }
+    async TestConnection(ci, cu) {
+        try {
+            const auth = await this.Authenticate(ci, cu);
+            // Read-only smoke: GetVersion is a harmless, token-gated SystemInfo op.
+            const url = `${auth.Config.BaseURL}${DEFAULT_SOAP_PATH}`;
+            const body = this.BuildSoapEnvelope('GetVersion', {}, auth.Token);
+            const r = await this.MakeRawHTTPRequest(url, 'POST', this.SoapHeaders('GetVersion'), body);
+            return r.Status >= 200 && r.Status < 300
+                ? { Success: true, Message: 'Connected to netFORUM Enterprise xWeb (SOAP)' }
+                : { Success: false, Message: `xWeb returned HTTP ${r.Status}` };
+        }
+        catch (err) {
+            return { Success: false, Message: err instanceof Error ? err.message : String(err) };
+        }
     }
-    async DiscoverObjects(_ci, _cu) {
-        return NF_OBJECTS.map(o => ({ Name: o.Name, Label: o.DisplayName, Description: o.Description, SupportsIncrementalSync: true, SupportsWrite: o.SupportsWrite ?? false }));
+    // ─── Discovery — Declared cache + runtime GetQueryDefinition ──────
+    /**
+     * Standard objects = the Declared metadata (engine cache of persisted IntegrationObject rows).
+     * NO hardcoded catalog. The base implementation reads exactly the credential-free Declared
+     * universe; a live credential only ADDS customer-installed query objects (the Discovered
+     * extension), it never supplies the baseline — so this re-yields the standard universe
+     * credential-free and the runtime structure self-check passes without a token.
+     */
+    async DiscoverObjects(ci, cu) {
+        return super.DiscoverObjects(ci, cu);
     }
+    /**
+     * Two-stage field discovery. Stage 1 returns the Declared field set (engine cache). Stage 2, when
+     * a credential is available, calls the GetQueryDefinition MECHANISM and parses the returned SQL
+     * column definition (Object → ListTable → ListFromTables → Column[]) into ExternalFieldSchema —
+     * this surfaces customer-added columns the static metadata never saw. With no credential, or on
+     * any error, it degrades to the Declared fields (never throws, never bakes a catalog).
+     */
     async DiscoverFields(ci, objectName, cu) {
-        // Dynamic: fetch one record via GetQuery to discover all fields
+        const declared = await super.DiscoverFields(ci, objectName, cu);
+        // The base FieldEntityToSchema folds PK into IsUniqueKey and never sets IsPrimaryKey, so
+        // re-derive the honest IsPrimaryKey from the cached IOF entities (which carry it explicitly).
+        const pkNames = this.DeclaredPrimaryKeyNames(ci, objectName);
+        const declaredByName = new Map(declared.map(f => [f.Name.toLowerCase(), { ...f, IsPrimaryKey: pkNames.has(f.Name.toLowerCase()) }]));
         try {
             const auth = await this.Authenticate(ci, cu);
-            const headers = this.BuildHeaders(auth);
-            const url = `${auth.Config.BaseURL}/xWeb/JSON/GetQuery?szObjectName=${objectName}&szColumnList=*&intRecordCount=1`;
-            const response = await this.MakeHTTPRequest(auth, url, 'GET', headers);
-            if (response.Status === 200) {
-                const records = this.NormalizeResponse(response.Body, null);
-                if (records.length > 0)
-                    return this.InferFieldsFromSample(records[0], objectName);
+            const url = `${auth.Config.BaseURL}${DEFAULT_SOAP_PATH}`;
+            const body = this.BuildSoapEnvelope('GetQueryDefinition', { szObjectName: objectName }, auth.Token);
+            const r = await this.MakeRawHTTPRequest(url, 'POST', this.SoapHeaders('GetQueryDefinition'), body);
+            if (r.Status >= 200 && r.Status < 300) {
+                const discovered = this.ParseQueryDefinition(this.AsText(r.Body), declaredByName);
+                if (discovered.length > 0)
+                    return discovered;
             }
         }
-        catch { /* fall through to static */ }
-        const obj = NF_OBJECTS.find(o => o.Name.toLowerCase() === objectName.toLowerCase());
-        if (!obj)
-            return [];
-        return obj.Fields.map(f => {
-            const fkTarget = this.ResolveForeignKeyTarget(f.Description);
-            return {
-                Name: f.Name, Label: f.DisplayName, Description: f.Description, DataType: f.Type,
-                IsRequired: f.IsRequired, IsUniqueKey: f.IsPrimaryKey, IsReadOnly: f.IsReadOnly,
-                IsForeignKey: fkTarget !== null, ForeignKeyTarget: fkTarget,
-            };
-        });
+        catch {
+            // credential-free / network / parse failure → fall through to Declared
+        }
+        return declared;
     }
-    InferFieldsFromSample(sample, objectName) {
-        const staticObj = NF_OBJECTS.find(o => o.Name.toLowerCase() === objectName.toLowerCase());
-        const staticMap = new Map((staticObj?.Fields ?? []).map(f => [f.Name.toLowerCase(), f]));
-        const fields = [];
-        for (const [key, value] of Object.entries(sample)) {
-            const sf = staticMap.get(key.toLowerCase());
-            const fkTarget = this.ResolveForeignKeyTarget(sf?.Description);
-            fields.push({
-                Name: key, Label: sf?.DisplayName ?? key, Description: sf?.Description ?? '',
-                DataType: sf?.Type ?? this.InferType(value),
-                IsRequired: sf?.IsRequired ?? false, IsUniqueKey: sf?.IsPrimaryKey ?? false, IsReadOnly: sf?.IsReadOnly ?? false,
-                IsForeignKey: fkTarget !== null, ForeignKeyTarget: fkTarget,
+    /**
+     * Parses a GetQueryDefinition response (the SQL column definition) into ExternalFieldSchema[].
+     * Each `<Column>` carries mdc_name / mdc_description / mdc_data_type / mdc_nullable /
+     * mdc_width_max. Declared metadata wins for PK identity (a column definition does not mark a PK);
+     * discovery contributes the full column corpus + provable nullability/length.
+     */
+    ParseQueryDefinition(xml, declaredByName) {
+        const out = [];
+        const seen = new Set();
+        for (const colXml of this.ExtractElements(xml, 'Column')) {
+            const name = this.ParseSoapScalar(colXml, 'mdc_name');
+            if (!name || seen.has(name.toLowerCase()))
+                continue;
+            seen.add(name.toLowerCase());
+            const declared = declaredByName.get(name.toLowerCase());
+            const dataType = this.ParseSoapScalar(colXml, 'mdc_data_type');
+            const description = this.ParseSoapScalar(colXml, 'mdc_description');
+            const nullable = this.ParseSoapScalar(colXml, 'mdc_nullable');
+            const widthRaw = this.ParseSoapScalar(colXml, 'mdc_width_max');
+            const maxLength = widthRaw && /^\d+$/.test(widthRaw) ? Number(widthRaw) : null;
+            // AllowsNull provable-only: 'mdc_nullable' is an explicit source flag. "0"/"false"/"no" ⇒ NOT NULL.
+            const allowsNull = nullable == null
+                ? undefined
+                : !/^(0|false|no|n)$/i.test(nullable.trim());
+            out.push({
+                Name: name,
+                Label: declared?.Label ?? name,
+                Description: declared?.Description ?? (description || undefined),
+                DataType: declared?.DataType ?? this.MapSoapType(dataType),
+                IsRequired: declared?.IsRequired ?? false,
+                AllowsNull: allowsNull,
+                IsPrimaryKey: declared?.IsPrimaryKey ?? false,
+                IsUniqueKey: declared?.IsUniqueKey ?? false,
+                IsReadOnly: declared?.IsReadOnly ?? false,
+                IsForeignKey: declared?.IsForeignKey ?? false,
+                ForeignKeyTarget: declared?.ForeignKeyTarget ?? null,
+                MaxLength: maxLength,
             });
         }
-        return fields;
+        // Re-add any Declared field GetQueryDefinition did not surface (provable-only baseline never lost).
+        for (const [key, f] of declaredByName) {
+            if (!seen.has(key))
+                out.push(f);
+        }
+        return out;
     }
-    InferType(v) {
-        if (v === null || v === undefined)
+    MapSoapType(sqlType) {
+        if (!sqlType)
             return 'string';
-        if (typeof v === 'number')
-            return Number.isInteger(v) ? 'number' : 'decimal';
-        if (typeof v === 'boolean')
-            return 'boolean';
-        if (typeof v === 'string' && /^\d{4}-\d{2}-\d{2}/.test(v))
+        const t = sqlType.toLowerCase();
+        if (/(date|time)/.test(t))
             return 'datetime';
+        if (/(int|bigint|smallint|tinyint)/.test(t))
+            return 'number';
+        if (/(decimal|numeric|money|float|real)/.test(t))
+            return 'decimal';
+        if (/bit/.test(t))
+            return 'boolean';
+        if (/uniqueidentifier/.test(t))
+            return 'string';
         return 'string';
     }
+    // ─── FetchChanges — GetQuery door walk + per-facade watermark ─────
     /**
-     * Override IntrospectSchema so the schema-builder receives the framework's
-     * provable static metadata: foreign keys (declared via each FK field's
-     * 'FK → <Sibling>' Description, resolved to a declared sibling object) and,
-     * for objects whose own catalog declares a last/updated/modified datetime
-     * column, IncrementalWatermarkField. No watermark is invented — objects
-     * without a declared timestamp leave the slot unset.
+     * Fetches a batch via the GetQuery door. Walks the IO's access path from Configuration: the door
+     * (GetQuery), the query object name, and any top modifier (@TOP -1 to bypass the DataGrid row
+     * cap). Incremental sync uses the IO's per-facade `IncrementalWatermarkField` in the
+     * szWhereClause — there is NO canonical LastModifiedDate; the field is metadata-driven.
+     *
+     * Full-record pass-through: every parsed row becomes ExternalRecord.Fields verbatim — never a
+     * filtered/narrow literal — so the framework's custom-column capture sees every column the query
+     * returned, including customer-added ones.
      */
-    async IntrospectSchema(companyIntegration, contextUser) {
-        const objects = await this.DiscoverObjects(companyIntegration, contextUser);
-        const result = { Objects: [] };
-        for (const obj of objects) {
-            const fields = await this.DiscoverFields(companyIntegration, obj.Name, contextUser);
-            const sourceFields = fields.map(f => ({
-                Name: f.Name,
-                Label: f.Label ?? f.Name,
-                Description: f.Description,
-                SourceType: f.DataType,
-                IsRequired: f.IsRequired ?? false,
-                IsPrimaryKey: f.IsUniqueKey ?? false,
-                IsForeignKey: f.IsForeignKey ?? false,
-                ForeignKeyTarget: f.ForeignKeyTarget ?? null,
-                MaxLength: null,
-                Precision: null,
-                Scale: null,
-                DefaultValue: null,
-            }));
-            result.Objects.push({
-                ExternalName: obj.Name,
-                ExternalLabel: obj.Label ?? obj.Name,
-                Description: obj.Description,
-                Fields: sourceFields,
-                PrimaryKeyFields: sourceFields.filter(f => f.IsPrimaryKey).map(f => f.Name),
-                Relationships: sourceFields
-                    .filter(f => f.IsForeignKey && f.ForeignKeyTarget)
-                    .map(f => ({ FieldName: f.Name, TargetObject: f.ForeignKeyTarget, TargetField: 'ID' })),
-                // Only set when the object's OWN catalog declares a last/updated/modified
-                // datetime column (provable). Undefined otherwise — never guessed.
-                IncrementalWatermarkField: this.ResolveDeclaredWatermarkColumn(obj.Name),
-            });
-        }
-        return result;
-    }
-    // ─── Auth (JSON mode) ──────────────────────────────────────────────
-    async Authenticate(ci, cu) {
-        if (this.tokenCache && this.tokenCache.ExpiresAt > Date.now() + 60_000) {
-            const config = await this.ParseConfig(ci, cu);
-            return { Token: this.tokenCache.Token, TokenType: 'Bearer', Config: config };
+    async FetchChanges(ctx) {
+        const auth = await this.Authenticate(ctx.CompanyIntegration, ctx.ContextUser);
+        const obj = this.GetCachedObject(ctx.CompanyIntegration.IntegrationID, ctx.ObjectName);
+        const cfg = this.ParseObjectConfig(obj);
+        const accessPath = cfg.accessPath ?? {};
+        const queryObject = accessPath.queryObject ?? accessPath.doorArgs?.szObjectName ?? ctx.ObjectName;
+        const topModifier = accessPath.doorArgs?.topModifier ?? '@TOP -1';
+        const szObjectName = topModifier ? `${queryObject} ${topModifier}` : queryObject;
+        const args = { szObjectName, szColumnList: '*' };
+        const watermarkField = obj.IncrementalWatermarkField ?? undefined;
+        if (ctx.WatermarkValue && watermarkField) {
+            args.szWhereClause = `${watermarkField} >= '${this.EscapeSqlLiteral(ctx.WatermarkValue)}'`;
         }
-        const config = await this.ParseConfig(ci, cu);
-        const basicAuth = Buffer.from(`${config.Username}:${config.Password}`).toString('base64');
-        const response = await fetch(`${config.BaseURL}/xWeb/JSON/Authenticate`, {
-            method: 'POST', headers: { 'Authorization': `Basic ${basicAuth}`, 'Content-Type': 'application/json' },
-            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
-        });
-        if (!response.ok)
-            throw new Error(`NetForum auth failed: ${response.status}`);
-        // Vendor doc canonical: the token is returned in the WWW-Authenticate
-        // RESPONSE HEADER, in the form: 'Bearer token = <guid>'. Older versions
-        // sometimes also place it in a JSON body; fall back to body parsing if
-        // the header isn't present.
-        let token = null;
-        const wwwAuth = response.headers.get('www-authenticate') || response.headers.get('WWW-Authenticate');
-        if (wwwAuth) {
-            // Match patterns like:  'Bearer token = abcd-1234'  or  'Bearer abcd-1234'
-            const match = wwwAuth.match(/Bearer\s+(?:token\s*=\s*)?([A-Fa-f0-9-]{8,})/i);
-            if (match)
-                token = match[1];
+        const orderingKey = cfg.stableOrderingKey ?? this.PrimaryKeyFieldName(obj);
+        if (orderingKey)
+            args.szOrderBy = orderingKey;
+        const url = `${auth.Config.BaseURL}${this.SoapEndpoint(cfg)}`;
+        const envelope = this.BuildSoapEnvelope('GetQuery', args, auth.Token);
+        const response = await this.MakeRawHTTPRequest(url, 'POST', this.SoapHeaders('GetQuery'), envelope);
+        if (response.Status < 200 || response.Status >= 300) {
+            throw new Error(`NetForum GetQuery(${ctx.ObjectName}) failed: HTTP ${response.Status}`);
         }
-        if (!token) {
-            try {
-                const body = await response.json();
-                token = body['Token'] ?? body['token'] ?? null;
+        const rows = this.NormalizeResponse(response.Body, null);
+        const pkField = this.PrimaryKeyFieldName(obj);
+        const warnings = rows.length === 0
+            ? [{ Code: 'ZERO_ROWS', Message: `GetQuery(${szObjectName}) returned no rows.` }]
+            : undefined;
+        // Highest ordering-key value seen → keyset resume position when no watermark exists.
+        let maxKey;
+        const records = rows.map(row => {
+            const externalID = pkField ? String(row[pkField] ?? '') : '';
+            if (orderingKey) {
+                const v = row[orderingKey];
+                if (v != null) {
+                    const s = String(v);
+                    if (maxKey === undefined || s > maxKey)
+                        maxKey = s;
+                }
             }
-            catch {
-                /* not JSON */
+            return { ExternalID: externalID, ObjectType: ctx.ObjectName, Fields: row };
+        });
+        // Watermark: when this IO has a watermark field, the engine narrows next sync from the max
+        // seen. GetQuery returns the full result set in one call → HasMore is always false.
+        let newWatermark;
+        if (watermarkField) {
+            for (const row of rows) {
+                const v = row[watermarkField];
+                if (v != null) {
+                    const s = String(v);
+                    if (newWatermark === undefined || s > newWatermark)
+                        newWatermark = s;
+                }
             }
         }
-        if (!token) {
-            throw new Error('NetForum auth response contained no token (checked WWW-Authenticate header and JSON body)');
+        return {
+            Records: records,
+            HasMore: false,
+            Warnings: warnings,
+            NewWatermarkValue: newWatermark,
+            NextAfterKeyValue: maxKey,
+        };
+    }
+    EscapeSqlLiteral(v) { return v.replace(/'/g, "''"); }
+    // ─── CRUD — SOAP facade ops via per-operation metadata columns ────
+    /**
+     * Create via the SOAP operation named in the IO's CreateBodyKey / Configuration.writeOps.createOp
+     * (e.g. WEBIndividualInsert, InsertFacadeObject). The attributes are wrapped in a SOAP envelope
+     * for that operation; the new key is read from the response and routed through BuildCreatedResult,
+     * so a 2xx that carries no record key FAILS loudly (the silent-create-loss invariant).
+     *
+     * Overridden (not the generic per-operation REST path) because the body must be a SOAP envelope,
+     * not a JSON body — the generic CreateRecord builds a JSON body. We still honor the metadata
+     * columns (operation name) and still call BuildCreatedResult.
+     */
+    async CreateRecord(ctx) {
+        const ci = ctx.CompanyIntegration;
+        const obj = this.GetCachedObject(ci.IntegrationID, ctx.ObjectName);
+        if (!obj.SupportsCreate) {
+            return { Success: false, StatusCode: 0, ErrorMessage: `CreateRecord not supported for "${ctx.ObjectName}".` };
+        }
+        const cfg = this.ParseObjectConfig(obj);
+        const operation = obj.CreateBodyKey ?? cfg.writeOps?.createOp;
+        if (!operation) {
+            return { Success: false, StatusCode: 0, ErrorMessage: `Create of "${ctx.ObjectName}" has no SOAP operation configured (CreateBodyKey).` };
         }
-        this.tokenCache = { Token: token, ExpiresAt: Date.now() + (3600 * 1000) };
-        return { Token: token, TokenType: 'Bearer', Config: config };
+        const auth = await this.Authenticate(ci, ctx.ContextUser);
+        const url = `${auth.Config.BaseURL}${this.SoapEndpoint(cfg)}`;
+        const envelope = this.BuildSoapEnvelope(operation, ctx.Attributes, auth.Token);
+        const r = await this.MakeRawHTTPRequest(url, 'POST', this.SoapHeaders(operation), envelope);
+        if (r.Status < 200 || r.Status >= 300) {
+            return { Success: false, ExternalID: '', StatusCode: r.Status, ErrorMessage: `Create of "${ctx.ObjectName}" failed: HTTP ${r.Status}` };
+        }
+        const externalID = this.ExtractKeyFromResponse(r.Body);
+        return this.BuildCreatedResult(externalID, r.Status, ctx.ObjectName);
     }
-    async ParseConfig(ci, cu, provider) {
-        // Use typed property — never .Get()/.Set() on entity-typed objects (CLAUDE.md §2b).
-        const credentialID = ci.CredentialID;
-        if (credentialID) {
-            const md = provider ?? new Metadata();
-            const cred = await md.GetEntityObject('MJ: Credentials', cu);
-            if (await cred.Load(credentialID) && cred.Values) {
-                const p = JSON.parse(cred.Values);
-                return { BaseURL: p['BaseURL'] ?? '', Username: p['Username'] ?? '', Password: p['Password'] ?? '' };
-            }
+    /**
+     * Update via the SOAP operation named in UpdateBodyKey / Configuration.writeOps.updateOp.
+     * netFORUM exposes no ETag / If-Match — updates are last-write-wins.
+     */
+    async UpdateRecord(ctx) {
+        const ci = ctx.CompanyIntegration;
+        const obj = this.GetCachedObject(ci.IntegrationID, ctx.ObjectName);
+        if (!obj.SupportsUpdate) {
+            return { Success: false, ExternalID: ctx.ExternalID, StatusCode: 0, ErrorMessage: `UpdateRecord not supported for "${ctx.ObjectName}".` };
+        }
+        const cfg = this.ParseObjectConfig(obj);
+        const operation = obj.UpdateBodyKey ?? cfg.writeOps?.updateOp;
+        if (!operation) {
+            return { Success: false, ExternalID: ctx.ExternalID, StatusCode: 0, ErrorMessage: `Update of "${ctx.ObjectName}" has no SOAP operation configured (UpdateBodyKey).` };
         }
-        throw new Error('No NetForum credentials found.');
+        const auth = await this.Authenticate(ci, ctx.ContextUser);
+        const url = `${auth.Config.BaseURL}${this.SoapEndpoint(cfg)}`;
+        const pkField = this.PrimaryKeyFieldName(obj);
+        const attributes = pkField
+            ? { [pkField]: ctx.ExternalID, ...ctx.Attributes }
+            : { ...ctx.Attributes };
+        const envelope = this.BuildSoapEnvelope(operation, attributes, auth.Token);
+        const r = await this.MakeRawHTTPRequest(url, 'POST', this.SoapHeaders(operation), envelope);
+        if (r.Status >= 200 && r.Status < 300) {
+            return { Success: true, ExternalID: ctx.ExternalID, StatusCode: r.Status };
+        }
+        return { Success: false, ExternalID: ctx.ExternalID, StatusCode: r.Status, ErrorMessage: `Update of "${ctx.ObjectName}" failed: HTTP ${r.Status}` };
     }
-    async TestConnection(ci, cu) {
+    /**
+     * Delete is not supported. DeleteFacadeObject is not confirmed in any reachable vendor doc and
+     * netFORUM prefers soft-delete via status flags. SupportsDelete is false, so this returns a clean
+     * error rather than silently claiming success.
+     */
+    async DeleteRecord(ctx) {
+        return {
+            Success: false,
+            ExternalID: ctx.ExternalID,
+            StatusCode: 0,
+            ErrorMessage: 'NetForum connector does not support delete (DeleteFacadeObject unconfirmed; netFORUM uses soft-delete via status flags).',
+        };
+    }
+    ExtractKeyFromResponse(body) {
+        const xml = this.AsText(body);
+        // The Insert/Create ops return the new GUID — scan common result/key element names.
+        for (const tag of ['key', 'Key', 'AddResult', 'InsertResult', 'CreateResult', 'WEBIndividualInsertResult', 'cst_key']) {
+            const v = this.ParseSoapScalar(xml, tag);
+            if (v && v.trim().length > 0)
+                return v.trim();
+        }
+        // Fallback: first GUID-shaped token anywhere in the body.
+        const guid = xml.match(/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/);
+        return guid ? guid[0] : undefined;
+    }
+    // ─── Stable ordering key (no-watermark resume) ───────────────────
+    /**
+     * Returns the IO's stable, monotonic ordering column (the PK / Configuration.stableOrderingKey)
+     * so the engine can keyset-resume objects that have no incremental watermark. Null when the IO is
+     * unknown or has no stable key — keyset resume is simply unavailable then, not an error.
+     */
+    StableOrderingKey(objectName) {
+        const ci = this.LastIntegrationID;
+        if (!ci)
+            return null;
         try {
-            const auth = await this.Authenticate(ci, cu);
-            // Try fetching one Individual record
-            const url = `${auth.Config.BaseURL}/xWeb/JSON/GetQuery?szObjectName=Individual&szColumnList=ind_cst_key&intRecordCount=1`;
-            const r = await this.MakeHTTPRequest(auth, url, 'GET', this.BuildHeaders(auth));
-            return r.Status === 200 ? { Success: true, Message: 'Connected to NetForum Enterprise' } : { Success: false, Message: `API returned ${r.Status}` };
+            const obj = this.GetCachedObject(ci, objectName);
+            const cfg = this.ParseObjectConfig(obj);
+            return cfg.stableOrderingKey ?? this.PrimaryKeyFieldName(obj) ?? null;
         }
-        catch (err) {
-            return { Success: false, Message: err instanceof Error ? err.message : String(err) };
+        catch {
+            return null;
+        }
+    }
+    // ─── SOAP envelope + XML helpers ─────────────────────────────────
+    /** Required SOAP 1.1 HTTP headers for a given operation. */
+    SoapHeaders(operation) {
+        return {
+            'Content-Type': 'text/xml; charset=utf-8',
+            'SOAPAction': `${SOAP_NS}${operation}`,
+            'User-Agent': 'MemberJunction-Integration/1.0',
+        };
+    }
+    /**
+     * Builds a SOAP 1.1 envelope for `operation` with the given body args. When a token is provided
+     * (every call except Authenticate), the AuthorizationToken header element carries it — this is
+     * the documented SOAP token carrier, NOT an HTTP Authorization header. Values are XML-escaped.
+     */
+    BuildSoapEnvelope(operation, args, token) {
+        const header = token
+            ? `<soap:Header><AuthorizationToken xmlns="${SOAP_NS}"><Token>${this.EscapeXml(token)}</Token></AuthorizationToken></soap:Header>`
+            : '<soap:Header/>';
+        const argXml = Object.entries(args)
+            .map(([k, v]) => this.ArgElement(k, v))
+            .join('');
+        return `<?xml version="1.0" encoding="utf-8"?>` +
+            `<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">` +
+            header +
+            `<soap:Body><${operation} xmlns="${SOAP_NS}">${argXml}</${operation}></soap:Body>` +
+            `</soap:Envelope>`;
+    }
+    /** Serializes one SOAP arg. Objects become nested elements; scalars become escaped text. */
+    ArgElement(name, value) {
+        if (value === null || value === undefined)
+            return `<${name} />`;
+        if (typeof value === 'object') {
+            const inner = Object.entries(value)
+                .map(([k, v]) => this.ArgElement(k, v))
+                .join('');
+            return `<${name}>${inner}</${name}>`;
         }
+        return `<${name}>${this.EscapeXml(String(value))}</${name}>`;
+    }
+    EscapeXml(s) {
+        return s
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&apos;');
+    }
+    UnescapeXml(s) {
+        return s
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&apos;/g, "'")
+            .replace(/&#(\d+);/g, (_m, d) => String.fromCharCode(Number(d)))
+            .replace(/&amp;/g, '&');
+    }
+    /**
+     * Extracts the text content of the FIRST occurrence of a scalar element by local name, ignoring
+     * namespace prefixes. Returns undefined when absent. Used for AuthenticateResult, mdc_* columns,
+     * and create-result keys.
+     */
+    ParseSoapScalar(xml, localName) {
+        const re = new RegExp(`<(?:[\\w.-]+:)?${this.EscapeRegExp(localName)}\\b[^>]*>([\\s\\S]*?)</(?:[\\w.-]+:)?${this.EscapeRegExp(localName)}>`);
+        const m = re.exec(xml);
+        if (!m)
+            return undefined;
+        return this.UnescapeXml(m[1]).trim();
+    }
+    /** Returns the inner XML of every occurrence of an element by local name (namespace-agnostic). */
+    ExtractElements(xml, localName) {
+        const re = new RegExp(`<(?:[\\w.-]+:)?${this.EscapeRegExp(localName)}\\b[^>]*>([\\s\\S]*?)</(?:[\\w.-]+:)?${this.EscapeRegExp(localName)}>`, 'g');
+        const out = [];
+        let m;
+        while ((m = re.exec(xml)) !== null)
+            out.push(m[1]);
+        return out;
     }
-    GetBaseURL(_ci, auth) { return auth.Config.BaseURL; }
-    BuildPaginatedURL(basePath, _o, _p, _off) { return basePath; }
+    EscapeRegExp(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+    /**
+     * Strips the SOAP envelope and the GetQueryResult wrapper, returning each flattened row as a
+     * plain object of column→value. netFORUM GetQuery returns a DataSet of repeated row elements
+     * (the row element name is the query's "Result"/"<Object>" element). We locate the GetQueryResult
+     * payload, then treat every direct child element that itself contains child elements as a row.
+     */
     NormalizeResponse(rawBody, _key) {
-        if (Array.isArray(rawBody))
-            return rawBody;
-        const body = rawBody;
-        // NetForum returns DataSet-style { Table: [{...}] } or array
-        for (const key of Object.keys(body)) {
-            if (Array.isArray(body[key]))
-                return body[key];
-        }
-        if (body && Object.keys(body).length > 0)
-            return [body];
-        return [];
+        const xml = this.AsText(rawBody);
+        if (!xml)
+            return [];
+        // Unwrap the GetQueryResult body (the <s:any> DataSet). Fall back to the whole body.
+        const resultElems = this.ExtractElements(xml, 'GetQueryResult');
+        const payload = resultElems.length > 0 ? resultElems[0] : xml;
+        return this.ParseRowSet(payload);
     }
-    ExtractPaginationInfo(_rb, _pt, _cp, _co, _ps) {
-        return { HasMore: false }; // NetForum returns full result sets
+    /**
+     * Parses a flattened row set. The DataSet shape is `<Results><Result>...cols...</Result>...` (the
+     * outer/inner names vary by query, e.g. IndividualObjects/IndividualObject). We find the most
+     * common repeated leaf-bearing element name and treat each as a row of column elements.
+     */
+    ParseRowSet(xml) {
+        // Identify candidate row element names: any tag that recurs AND contains nested elements.
+        const topTags = this.TopLevelTagNames(xml);
+        // The row wrapper is usually a single outer element (e.g. <Results>); descend one level if so.
+        let scope = xml;
+        if (topTags.length === 1) {
+            const inner = this.ExtractElements(xml, topTags[0]);
+            if (inner.length === 1 && /</.test(inner[0]))
+                scope = inner[0];
+        }
+        const rowTagCounts = new Map();
+        for (const tag of this.TopLevelTagNames(scope)) {
+            rowTagCounts.set(tag, (rowTagCounts.get(tag) ?? 0) + 1);
+        }
+        // Pick the most frequent row tag (ties → first). A single-row result still has count 1.
+        let rowTag;
+        let best = 0;
+        for (const [tag, count] of rowTagCounts) {
+            if (count > best) {
+                best = count;
+                rowTag = tag;
+            }
+        }
+        if (!rowTag)
+            return [];
+        const rows = [];
+        for (const rowXml of this.ExtractElements(scope, rowTag)) {
+            const row = this.ParseRowColumns(rowXml);
+            if (Object.keys(row).length > 0)
+                rows.push(row);
+        }
+        return rows;
     }
-    // ─── FetchChanges — via GetQuery JSON method ───────────────────────
-    async FetchChanges(ctx) {
-        const auth = await this.Authenticate(ctx.CompanyIntegration, ctx.ContextUser);
-        const headers = this.BuildHeaders(auth);
-        // Use GetQuery for listing records
-        let url = `${auth.Config.BaseURL}/xWeb/JSON/GetQuery?szObjectName=${ctx.ObjectName}&szColumnList=*`;
-        if (ctx.WatermarkValue) {
-            // NetForum facades each use their own prefixed last-modified column.
-            // 'LastModifiedDate' is NOT a vendor column. Look it up from the static
-            // catalog (NF_OBJECTS lists e.g. 'ind_last_updated_dt' for Individual,
-            // 'evt_last_updated_dt' for Event, etc.). Fall back to the connector's
-            // earlier-guessed name only when the catalog has no entry.
-            const wmCol = this.ResolveWatermarkColumn(ctx.ObjectName);
-            url += `&szWhereClause=${encodeURIComponent(`${wmCol} >= '${ctx.WatermarkValue}'`)}`;
-        }
-        const response = await this.MakeHTTPRequest(auth, url, 'GET', headers);
-        if (response.Status < 200 || response.Status >= 300)
-            throw new Error(`NetForum ${ctx.ObjectName} error: ${response.Status}`);
-        const records = this.NormalizeResponse(response.Body, null);
-        // Determine PK field from static definition
-        const obj = NF_OBJECTS.find(o => o.Name.toLowerCase() === ctx.ObjectName.toLowerCase());
-        const pkField = obj?.Fields.find(f => f.IsPrimaryKey)?.Name ?? 'key';
-        return {
-            Records: records.map(r => ({ ExternalID: String(r[pkField] ?? r['key'] ?? ''), ObjectType: ctx.ObjectName, Fields: r })),
-            HasMore: false,
-        };
+    /** Parses one row's column elements into a flat object (full-record — every column kept). */
+    ParseRowColumns(rowXml) {
+        const row = {};
+        const re = /<([\w.-]+)\b[^>]*?(\/)?>(?:([\s\S]*?)<\/\1>)?/g;
+        let m;
+        while ((m = re.exec(rowXml)) !== null) {
+            const tag = m[1];
+            const selfClosing = m[2] === '/';
+            const content = m[3];
+            if (selfClosing || content === undefined) {
+                row[tag] = null;
+                continue;
+            }
+            // Flattened GetQuery rows carry scalar columns; keep the unescaped text value.
+            row[tag] = this.UnescapeXml(content);
+        }
+        return row;
     }
-    // ─── CRUD — via facade methods ─────────────────────────────────────
-    async CreateRecord(ctx) {
-        const auth = await this.Authenticate(ctx.CompanyIntegration, ctx.ContextUser);
-        const headers = { ...this.BuildHeaders(auth), 'Content-Type': 'application/json' };
-        const url = `${auth.Config.BaseURL}/xWeb/JSON/InsertFacadeObject`;
-        const payload = { szObjectName: ctx.ObjectName, oRecord: ctx.Attributes };
-        const r = await this.MakeHTTPRequest(auth, url, 'POST', headers, payload);
-        if (r.Status >= 200 && r.Status < 300) {
-            const body = r.Body;
-            const newKey = body['key'] == null ? undefined : String(body['key']);
-            return this.BuildCreatedResult(newKey, r.Status, ctx.ObjectName);
+    /**
+     * Returns the local names of the direct (top-level) child elements of an XML fragment, by a
+     * depth scan over open/close/self-close tags (so a tag opened at depth 0 is a direct child).
+     */
+    TopLevelTagNames(xml) {
+        const names = [];
+        let depth = 0;
+        const tokenRe = /<\/?([\w.-]+)\b[^>]*?(\/)?>/g;
+        let t;
+        while ((t = tokenRe.exec(xml)) !== null) {
+            const full = t[0];
+            const name = t[1];
+            const selfClose = t[2] === '/';
+            const isClose = full.startsWith('</');
+            if (isClose) {
+                depth--;
+                continue;
+            }
+            if (depth === 0)
+                names.push(name);
+            if (!selfClose)
+                depth++;
         }
-        return { Success: false, ExternalID: '', StatusCode: r.Status, ErrorMessage: `Create failed: ${r.Status}` };
+        return names;
     }
-    async UpdateRecord(ctx) {
-        const auth = await this.Authenticate(ctx.CompanyIntegration, ctx.ContextUser);
-        const headers = { ...this.BuildHeaders(auth), 'Content-Type': 'application/json' };
-        const url = `${auth.Config.BaseURL}/xWeb/JSON/UpdateFacadeObject`;
-        const payload = { szObjectName: ctx.ObjectName, szObjectKey: ctx.ExternalID, oRecord: ctx.Attributes };
-        const r = await this.MakeHTTPRequest(auth, url, 'POST', headers, payload);
-        if (r.Status >= 200 && r.Status < 300)
-            return { Success: true, ExternalID: ctx.ExternalID, StatusCode: r.Status };
-        return { Success: false, ExternalID: ctx.ExternalID, StatusCode: r.Status, ErrorMessage: `Update failed: ${r.Status}` };
+    ExtractPaginationInfo(_rb, _pt, _cp, _co, _ps) {
+        // GetQuery returns the full result set in one call — no protocol-level pagination.
+        return { HasMore: false };
     }
-    async DeleteRecord(ctx) {
-        const auth = await this.Authenticate(ctx.CompanyIntegration, ctx.ContextUser);
-        const headers = { ...this.BuildHeaders(auth), 'Content-Type': 'application/json' };
-        const url = `${auth.Config.BaseURL}/xWeb/JSON/DeleteFacadeObject`;
-        const payload = { szObjectName: ctx.ObjectName, szObjectKey: ctx.ExternalID };
-        const r = await this.MakeHTTPRequest(auth, url, 'POST', headers, payload);
-        if (r.Status >= 200 && r.Status < 300)
-            return { Success: true, ExternalID: ctx.ExternalID, StatusCode: r.Status };
-        return { Success: false, ExternalID: ctx.ExternalID, StatusCode: r.Status, ErrorMessage: `Delete failed: ${r.Status}` };
+    GetBaseURL(_ci, auth) {
+        return auth.Config.BaseURL;
     }
-    BuildHeaders(auth) {
-        return { 'Authorization': `Bearer ${auth.Token}`, 'Accept': 'application/json', 'User-Agent': 'MemberJunction-Integration/1.0' };
+    /** The base-class abstract BuildHeaders — defers to SoapHeaders for the active operation. */
+    BuildHeaders(_auth) {
+        return { 'Content-Type': 'text/xml; charset=utf-8', 'User-Agent': 'MemberJunction-Integration/1.0' };
     }
+    /** The base-class abstract MakeHTTPRequest — routes through the raw transport. */
     async MakeHTTPRequest(_auth, url, method, headers, body) {
+        return this.MakeRawHTTPRequest(url, method, headers, typeof body === 'string' ? body : (body == null ? undefined : String(body)));
+    }
+    /**
+     * Raw SOAP transport: POSTs the XML envelope, retries on 401 (re-auth)/429/5xx, and returns the
+     * response body as text (SOAP is text/xml). Never logs credentials, the token, or PII.
+     *
+     * `protected` so a unit-test subclass can override this single transport seam to feed canned
+     * SOAP responses (no live network, no credentials) — the only seam tests need to mock.
+     */
+    async MakeRawHTTPRequest(url, method, headers, body) {
         await this.Throttle();
         for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-            const c = new AbortController();
-            const t = setTimeout(() => c.abort(), REQUEST_TIMEOUT_MS);
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
             try {
-                const opts = { method, headers, signal: c.signal };
-                if (body && method !== 'GET')
-                    opts.body = JSON.stringify(body);
+                const opts = { method, headers, signal: controller.signal };
+                if (body !== undefined && method !== 'GET')
+                    opts.body = body;
                 const response = await fetch(url, opts);
-                clearTimeout(t);
+                clearTimeout(timer);
                 this.lastRequestTime = Date.now();
                 if (response.status === 401 && attempt === 0) {
                     this.tokenCache = null;
                     continue;
                 }
-                if (response.status === 429) {
-                    await this.Sleep(Math.min(1000 * Math.pow(2, attempt) + Math.random() * 500, 60_000));
+                if (response.status === 429 && attempt < MAX_RETRIES) {
+                    await this.Sleep(this.RetryAfterMs(response, attempt));
                     continue;
                 }
                 if (response.status >= 500 && attempt < MAX_RETRIES) {
                     await this.Sleep(Math.min(1000 * Math.pow(2, attempt), 30_000));
                     continue;
                 }
-                const rb = await (response.headers.get('content-type')?.includes('json') ? response.json() : response.text());
+                const text = await response.text();
                 const h = {};
                 response.headers.forEach((v, k) => { h[k.toLowerCase()] = v; });
-                return { Status: response.status, Body: rb, Headers: h };
+                return { Status: response.status, Body: text, Headers: h };
             }
             catch (e) {
-                clearTimeout(t);
+                clearTimeout(timer);
                 if (e instanceof Error && e.name === 'AbortError')
                     throw new Error(`NetForum request timed out: ${url}`);
-                throw e;
+                if (attempt >= MAX_RETRIES)
+                    throw e;
+                await this.Sleep(Math.min(1000 * Math.pow(2, attempt), 30_000));
             }
         }
         throw new Error(`NetForum request failed after ${MAX_RETRIES} retries: ${url}`);
     }
-    async Throttle() { const e = Date.now() - this.lastRequestTime; if (e < MIN_REQUEST_INTERVAL_MS)
-        await this.Sleep(MIN_REQUEST_INTERVAL_MS - e); }
+    RetryAfterMs(response, attempt) {
+        const ra = response.headers.get('retry-after');
+        if (ra) {
+            const secs = Number(ra);
+            if (!Number.isNaN(secs))
+                return Math.min(secs * 1000, 60_000);
+        }
+        return Math.min(1000 * Math.pow(2, attempt) + Math.random() * 500, 60_000);
+    }
+    ExtractRetryAfterMs(error) {
+        if (error && typeof error === 'object' && 'Headers' in error) {
+            const headers = error.Headers;
+            const ra = headers?.['retry-after'];
+            if (ra) {
+                const secs = Number(ra);
+                if (!Number.isNaN(secs))
+                    return secs * 1000;
+            }
+        }
+        return undefined;
+    }
+    async Throttle() {
+        const elapsed = Date.now() - this.lastRequestTime;
+        if (elapsed < MIN_REQUEST_INTERVAL_MS)
+            await this.Sleep(MIN_REQUEST_INTERVAL_MS - elapsed);
+    }
     Sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
-    GetDefaultFieldMappings(objectName) {
-        const obj = NF_OBJECTS.find(o => o.Name.toLowerCase() === objectName.toLowerCase());
-        if (!obj)
-            return [];
-        return obj.Fields.map(f => ({ SourceFieldName: f.Name, DestinationFieldName: f.Name, IsKeyField: f.IsPrimaryKey }));
+    ParseObjectConfig(obj) {
+        this.LastIntegrationID = obj.IntegrationID ?? this.LastIntegrationID;
+        if (!obj.Configuration)
+            return {};
+        try {
+            return JSON.parse(obj.Configuration);
+        }
+        catch {
+            return {};
+        }
+    }
+    SoapEndpoint(cfg) {
+        return cfg.soapEndpoint ?? DEFAULT_SOAP_PATH;
+    }
+    PrimaryKeyFieldName(obj) {
+        const fields = this.GetCachedFields(obj.ID);
+        const pk = fields.find(f => f.IsPrimaryKey);
+        return pk?.Name;
+    }
+    /** Lowercased names of the IO's declared primary-key fields, read from the cached IOF entities. */
+    DeclaredPrimaryKeyNames(ci, objectName) {
+        try {
+            const obj = this.GetCachedObject(ci.IntegrationID, objectName);
+            return new Set(this.GetCachedFields(obj.ID).filter(f => f.IsPrimaryKey).map(f => f.Name.toLowerCase()));
+        }
+        catch {
+            return new Set();
+        }
+    }
+    AsText(body) {
+        if (typeof body === 'string')
+            return body;
+        if (body == null)
+            return '';
+        return String(body);
     }
 };
 NetForumConnector = __decorate([