@memberjunction/integration-connectors 5.35.0 → 5.36.0

package/dist/Reach360Connector.js

@@ -0,0 +1,710 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { RegisterClass } from '@memberjunction/global';
+import { Metadata } from '@memberjunction/core';
+import { BaseIntegrationConnector, BaseRESTIntegrationConnector, } from '@memberjunction/integration-engine';
+// ─── Constants ────────────────────────────────────────────────────────
+const REACH360_BASE_URL = 'https://api.reach360.com';
+/** Default max retries when a request fails with a retryable error. */
+const DEFAULT_MAX_RETRIES = 3;
+/** Default HTTP request timeout (ms). */
+const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+/** Minimum interval between outbound requests (ms) — Reach 360 rate limits are undocumented. */
+const DEFAULT_MIN_REQUEST_INTERVAL_MS = 250;
+/** Default page size when the caller does not specify one — Reach 360 uses 50. Max 100. */
+const DEFAULT_PAGE_SIZE = 50;
+/** Absolute ceiling for requested page size per the documented API. */
+const MAX_PAGE_SIZE = 100;
+// ─── Static Action Metadata ───────────────────────────────────────────
+/**
+ * Objects exposed through the action generator. Mirrors the runtime metadata
+ * defined in `metadata/integrations/.reach360.json` but is maintained here so
+ * action generation does not require a live connection.
+ */
+const REACH360_OBJECTS = [
+    {
+        Name: 'Courses', DisplayName: 'Courses',
+        Description: 'Courses authored in Articulate Rise/Storyline/Microlearning or imported SCORM/xAPI content.',
+        SupportsWrite: false,
+        Fields: [
+            { Name: 'id', DisplayName: 'ID', Type: 'string', IsRequired: true, IsReadOnly: true, IsPrimaryKey: true, Description: 'Unique identifier of the course' },
+            { Name: 'title', DisplayName: 'Title', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'Course title' },
+            { Name: 'contentType', DisplayName: 'Content Type', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'Content source (rise/storyline/microlearning/imported)' },
+            { Name: 'coverImageUrl', DisplayName: 'Cover Image URL', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'URL for course cover image' },
+            { Name: 'authorUrl', DisplayName: 'Author URL', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'HATEOAS URL for course author' },
+            { Name: 'url', DisplayName: 'URL', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'Canonical URL for this course' },
+        ],
+    },
+    {
+        Name: 'Users', DisplayName: 'Users',
+        Description: 'Reach 360 users — created via invitation or SSO provisioning.',
+        SupportsWrite: false,
+        Fields: [
+            { Name: 'id', DisplayName: 'ID', Type: 'string', IsRequired: true, IsReadOnly: true, IsPrimaryKey: true, Description: 'Unique identifier of the user' },
+            { Name: 'email', DisplayName: 'Email', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'User email — natural key' },
+            { Name: 'role', DisplayName: 'Role', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'learner | author | admin' },
+            { Name: 'firstName', DisplayName: 'First Name', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'User first name' },
+            { Name: 'lastName', DisplayName: 'Last Name', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'User last name' },
+            { Name: 'lastActiveAt', DisplayName: 'Last Active At', Type: 'datetime', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'Last platform activity timestamp' },
+            { Name: 'articulate360User', DisplayName: 'Articulate 360 User', Type: 'boolean', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'Managed by Articulate 360 Teams subscription' },
+        ],
+    },
+    {
+        Name: 'Groups', DisplayName: 'Groups',
+        Description: 'Groups used for user tagging/categorization and course assignment. UI-created; API supports membership mutations.',
+        SupportsWrite: false,
+        Fields: [
+            { Name: 'id', DisplayName: 'ID', Type: 'string', IsRequired: true, IsReadOnly: true, IsPrimaryKey: true, Description: 'Unique identifier of the group' },
+            { Name: 'name', DisplayName: 'Name', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'Group name' },
+            { Name: 'description', DisplayName: 'Description', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'Group description' },
+            { Name: 'usersUrl', DisplayName: 'Users URL', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'HATEOAS URL for group members' },
+            { Name: 'coursesUrl', DisplayName: 'Courses URL', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'HATEOAS URL for group courses' },
+        ],
+    },
+    {
+        Name: 'LearningPaths', DisplayName: 'Learning Paths',
+        Description: 'Ordered sequences of courses — created in the UI; enrollments manageable via API.',
+        SupportsWrite: false,
+        Fields: [
+            { Name: 'id', DisplayName: 'ID', Type: 'string', IsRequired: true, IsReadOnly: true, IsPrimaryKey: true, Description: 'Unique identifier of the learning path' },
+            { Name: 'title', DisplayName: 'Title', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'Learning path title' },
+            { Name: 'description', DisplayName: 'Description', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'Learning path description' },
+        ],
+    },
+    {
+        Name: 'ActivityReport', DisplayName: 'Activity Report',
+        Description: 'Account-wide session activity feed — primary source for incremental engagement data.',
+        SupportsWrite: false,
+        Fields: [
+            { Name: 'courseId', DisplayName: 'Course ID', Type: 'string', IsRequired: true, IsReadOnly: true, IsPrimaryKey: true, Description: 'Course identifier' },
+            { Name: 'userId', DisplayName: 'User ID', Type: 'string', IsRequired: true, IsReadOnly: true, IsPrimaryKey: true, Description: 'User identifier' },
+            { Name: 'status', DisplayName: 'Status', Type: 'string', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'Session status' },
+            { Name: 'startedAt', DisplayName: 'Started At', Type: 'datetime', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'Session start timestamp' },
+            { Name: 'completedAt', DisplayName: 'Completed At', Type: 'datetime', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'Session completion timestamp (watermark field)' },
+            { Name: 'durationSeconds', DisplayName: 'Duration', Type: 'integer', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'Session active duration in seconds' },
+            { Name: 'quizScore', DisplayName: 'Quiz Score', Type: 'decimal', IsRequired: false, IsReadOnly: true, IsPrimaryKey: false, Description: 'Quiz score when applicable' },
+        ],
+    },
+];
+/**
+ * Maps lowercase object names to the top-level response key that holds the
+ * record array for list endpoints. Reach 360 wraps every list response under
+ * a plural key (`courses`, `users`, `sessions`, etc.) alongside `nextUrl`.
+ */
+const REACH360_RESPONSE_DATA_KEYS = {
+    courses: 'courses',
+    users: 'users',
+    groups: 'groups',
+    learningpaths: 'learningPaths',
+    activityreport: 'sessions',
+};
+/** Maps lowercase object names to their list API paths (relative to base URL). */
+const REACH360_API_PATHS = {
+    courses: '/courses',
+    users: '/users',
+    groups: '/groups',
+    learningpaths: '/learning-paths',
+    activityreport: '/reports/activity',
+};
+// ─── Connector Implementation ─────────────────────────────────────────
+/**
+ * Connector for the Reach 360 LMS REST API.
+ *
+ * Reach 360 is Articulate's lightweight cloud LMS. The API is documented only
+ * as HTML articles (no OpenAPI spec) and exposes ~25 endpoints across Courses,
+ * Users, Groups, Learning Paths, Reports, Invitations and Completions.
+ *
+ * Auth: a single static Bearer token generated in the Reach 360 admin UI. No
+ * OAuth flow, no refresh tokens. The token is sent on every request as
+ * `Authorization: Bearer {apiKey}`.
+ *
+ * Pagination: cursor-based. List responses include a `nextUrl` pointer that
+ * encodes the next cursor; follow until null.
+ *
+ * Incremental sync: Reach 360 has no CDC endpoint and no server-side date
+ * filtering on list endpoints. Instead, `/reports/activity` acts as a
+ * session-level change stream; callers filter client-side by `completedAt`.
+ */
+let Reach360Connector = class Reach360Connector extends BaseRESTIntegrationConnector {
+    constructor() {
+        super(...arguments);
+        /** Timestamp of the last HTTP request — used for throttling. */
+        this.lastRequestTime = 0;
+    }
+    // ── Capability getters ────────────────────────────────────────────
+    get SupportsCreate() { return true; } // Invitations, Completions
+    get SupportsUpdate() { return true; } // Groups update via PUT /groups/{groupId}; other primary resources still return 400 in UpdateRecord
+    get SupportsDelete() { return true; } // User delete, group membership removal
+    get IntegrationName() { return 'Reach360'; }
+    // ── Action generation ─────────────────────────────────────────────
+    /**
+     * Returns the static object catalog for action generation. Derived from
+     * Articulate's documented endpoint catalog (no OpenAPI spec exists).
+     */
+    GetIntegrationObjects() {
+        return REACH360_OBJECTS;
+    }
+    GetActionGeneratorConfig() {
+        const objects = this.GetIntegrationObjects();
+        if (objects.length === 0)
+            return null;
+        return {
+            IntegrationName: 'Reach360',
+            CategoryName: 'Reach360',
+            IconClass: 'fa-solid fa-graduation-cap',
+            Objects: objects,
+            IncludeSearch: false,
+            IncludeList: false,
+            CategoryDescription: 'Reach 360 LMS integration actions',
+            ParentCategoryName: 'Learning',
+        };
+    }
+    GetDefaultConfiguration() {
+        return {
+            DefaultSchemaName: 'Reach360',
+            DefaultObjects: [
+                {
+                    SourceObjectName: 'Users',
+                    TargetTableName: 'Reach360_User',
+                    TargetEntityName: 'Reach360 Users',
+                    SyncEnabled: true,
+                    FieldMappings: this.GetDefaultFieldMappings('Users', 'Contacts'),
+                },
+                {
+                    SourceObjectName: 'Courses',
+                    TargetTableName: 'Reach360_Course',
+                    TargetEntityName: 'Reach360 Courses',
+                    SyncEnabled: true,
+                    FieldMappings: this.GetDefaultFieldMappings('Courses', 'Courses'),
+                },
+                {
+                    SourceObjectName: 'ActivityReport',
+                    TargetTableName: 'Reach360_Activity',
+                    TargetEntityName: 'Reach360 Activity',
+                    SyncEnabled: true,
+                    FieldMappings: [],
+                },
+            ],
+        };
+    }
+    GetDefaultFieldMappings(objectName, _entityName) {
+        switch (objectName) {
+            case 'Users':
+                return [
+                    { SourceFieldName: 'id', DestinationFieldName: 'ExternalID', IsKeyField: true },
+                    { SourceFieldName: 'email', DestinationFieldName: 'Email' },
+                    { SourceFieldName: 'firstName', DestinationFieldName: 'FirstName' },
+                    { SourceFieldName: 'lastName', DestinationFieldName: 'LastName' },
+                ];
+            case 'Courses':
+                return [
+                    { SourceFieldName: 'id', DestinationFieldName: 'ExternalID', IsKeyField: true },
+                    { SourceFieldName: 'title', DestinationFieldName: 'Title' },
+                ];
+            default:
+                return [];
+        }
+    }
+    // ─── TestConnection ──────────────────────────────────────────────
+    /**
+     * Verifies connectivity by hitting GET /users?limit=1. A 2xx response with
+     * a recognizable envelope confirms both credentials and rate-limit posture.
+     */
+    async TestConnection(companyIntegration, contextUser) {
+        try {
+            const auth = await this.Authenticate(companyIntegration, contextUser);
+            const url = `${REACH360_BASE_URL}/users?limit=1`;
+            const headers = this.BuildHeaders(auth);
+            const resp = await this.MakeHTTPRequest(auth, url, 'GET', headers);
+            if (resp.Status < 200 || resp.Status >= 300) {
+                return { Success: false, Message: `Reach360 TestConnection failed: HTTP ${resp.Status}` };
+            }
+            return {
+                Success: true,
+                Message: 'Successfully connected to Reach 360',
+                ServerVersion: 'Reach 360 REST API v1',
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { Success: false, Message: `Connection failed: ${message}` };
+        }
+    }
+    // ─── Discovery ────────────────────────────────────────────────────
+    /**
+     * Overrides the base cache-driven discovery so the connector is usable
+     * before the integration metadata has been seeded into the DB (e.g. at
+     * first setup). Returns the static REACH360_OBJECTS catalog.
+     */
+    async DiscoverObjects(_companyIntegration, _contextUser) {
+        return REACH360_OBJECTS.map(obj => ({
+            Name: obj.Name,
+            Label: obj.DisplayName,
+            Description: obj.Description,
+            SupportsIncrementalSync: obj.Name === 'ActivityReport' || obj.Name === 'Users',
+            SupportsWrite: obj.SupportsWrite,
+        }));
+    }
+    /**
+     * Returns the static field list for the named object. Reach 360 has no
+     * custom-field system, so there is no runtime enrichment to perform.
+     */
+    async DiscoverFields(_companyIntegration, objectName, _contextUser) {
+        const obj = REACH360_OBJECTS.find(o => o.Name.toLowerCase() === objectName.toLowerCase());
+        if (!obj)
+            return [];
+        return obj.Fields.map(f => ({
+            Name: f.Name,
+            Label: f.DisplayName,
+            Description: f.Description,
+            DataType: f.Type,
+            IsRequired: f.IsRequired,
+            IsUniqueKey: f.IsPrimaryKey,
+            IsReadOnly: f.IsReadOnly,
+        }));
+    }
+    // ─── FetchChanges (cursor pagination) ────────────────────────────
+    /**
+     * Reach 360 uses cursor pagination via `nextUrl`. Fetches the configured
+     * page size, follows the cursor chain until either `nextUrl` is null or
+     * `BatchSize` is reached.
+     *
+     * For `ActivityReport` and `Users` objects the caller's watermark is
+     * applied client-side against `completedAt` / `lastActiveAt` respectively.
+     */
+    async FetchChanges(ctx) {
+        const auth = await this.Authenticate(ctx.CompanyIntegration, ctx.ContextUser);
+        const objLower = ctx.ObjectName.toLowerCase();
+        const path = REACH360_API_PATHS[objLower];
+        if (!path) {
+            console.warn(`[Reach360] No API path mapped for object "${ctx.ObjectName}"`);
+            return { Records: [], HasMore: false };
+        }
+        const dataKey = REACH360_RESPONSE_DATA_KEYS[objLower] ?? objLower;
+        const pageSize = Math.min(ctx.BatchSize ?? DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE);
+        const initialUrl = ctx.CurrentCursor
+            ? this.DecodeCursor(ctx.CurrentCursor)
+            : `${REACH360_BASE_URL}${path}?limit=${pageSize}`;
+        const { records, nextCursor } = await this.fetchCursorBatch(auth, initialUrl, dataKey, ctx.BatchSize);
+        const { filtered, newWatermark } = this.applyClientWatermark(records, objLower, ctx.WatermarkValue);
+        const externalRecords = filtered.map(r => this.toExternalRecord(r, ctx.ObjectName));
+        return {
+            Records: externalRecords,
+            HasMore: nextCursor != null,
+            NextCursor: nextCursor ?? undefined,
+            NewWatermarkValue: !nextCursor && newWatermark ? newWatermark : undefined,
+        };
+    }
+    /**
+     * Walks the `nextUrl` chain starting from `startUrl` and accumulates up to
+     * `batchSize` records. Returns the raw record array and the final cursor
+     * (base64-encoded `nextUrl` when more remain, or null).
+     */
+    async fetchCursorBatch(auth, startUrl, dataKey, batchSize) {
+        const all = [];
+        let url = startUrl;
+        const limit = batchSize > 0 ? batchSize : Number.MAX_SAFE_INTEGER;
+        while (url && all.length < limit) {
+            const headers = this.BuildHeaders(auth);
+            const resp = await this.MakeHTTPRequest(auth, url, 'GET', headers);
+            if (resp.Status < 200 || resp.Status >= 300) {
+                throw new Error(`Reach360 GET ${url} returned HTTP ${resp.Status}`);
+            }
+            const body = (resp.Body ?? {});
+            const arr = body[dataKey];
+            if (Array.isArray(arr)) {
+                all.push(...arr);
+            }
+            const next = typeof body.nextUrl === 'string' && body.nextUrl.length > 0 ? body.nextUrl : null;
+            if (!next || all.length >= limit) {
+                return { records: all.slice(0, limit), nextCursor: all.length >= limit && next ? this.EncodeCursor(next) : null };
+            }
+            url = next;
+        }
+        return { records: all, nextCursor: null };
+    }
+    /**
+     * Applies a client-side watermark filter against the appropriate date
+     * field for the given object. Returns records newer than the watermark
+     * plus the latest observed timestamp (to update the watermark after the
+     * final page).
+     */
+    applyClientWatermark(records, objLower, watermark) {
+        const dateField = this.watermarkFieldFor(objLower);
+        if (!dateField)
+            return { filtered: records, newWatermark: null };
+        const watermarkDate = watermark ? new Date(watermark) : null;
+        let latest = null;
+        const filtered = [];
+        for (const rec of records) {
+            const raw = rec[dateField];
+            if (typeof raw !== 'string' || raw.length === 0) {
+                filtered.push(rec);
+                continue;
+            }
+            const parsed = new Date(raw);
+            if (isNaN(parsed.getTime())) {
+                filtered.push(rec);
+                continue;
+            }
+            if (!latest || parsed > latest)
+                latest = parsed;
+            if (!watermarkDate || parsed > watermarkDate)
+                filtered.push(rec);
+        }
+        return { filtered, newWatermark: latest ? latest.toISOString() : null };
+    }
+    /** Returns the date field used for incremental filtering, if any. */
+    watermarkFieldFor(objLower) {
+        if (objLower === 'activityreport')
+            return 'completedAt';
+        if (objLower === 'users')
+            return 'lastActiveAt';
+        return null;
+    }
+    /**
+     * Converts a raw Reach 360 record into an ExternalRecord. ActivityReport
+     * uses a composite {courseId, userId} key.
+     */
+    toExternalRecord(raw, objectType) {
+        const externalID = this.extractExternalID(raw, objectType);
+        return { ExternalID: externalID, ObjectType: objectType, Fields: raw };
+    }
+    extractExternalID(raw, objectType) {
+        if (objectType.toLowerCase() === 'activityreport') {
+            const cid = raw['courseId'] != null ? String(raw['courseId']) : '';
+            const uid = raw['userId'] != null ? String(raw['userId']) : '';
+            return `${cid}|${uid}`;
+        }
+        return raw['id'] != null ? String(raw['id']) : '';
+    }
+    // ─── CRUD Operations ─────────────────────────────────────────────
+    /**
+     * Supported creates:
+     *   - Invitations → POST /invitations
+     *   - Completions → POST /courses/{courseId}/users/{userId}/completions
+     *                   (requires `courseId` + `userId` on Attributes)
+     *   - Group membership → POST /groups/{groupId}/users
+     *                         (requires `groupId` on Attributes)
+     */
+    async CreateRecord(ctx) {
+        const companyIntegration = ctx.CompanyIntegration;
+        const contextUser = ctx.ContextUser;
+        try {
+            const auth = await this.Authenticate(companyIntegration, contextUser);
+            const headers = this.BuildHeaders(auth);
+            const route = this.resolveCreateRoute(ctx.ObjectName, ctx.Attributes);
+            if (!route) {
+                return { Success: false, ErrorMessage: `Reach360 CreateRecord not supported for "${ctx.ObjectName}"`, StatusCode: 400 };
+            }
+            const url = `${REACH360_BASE_URL}${route.path}`;
+            const resp = await this.MakeHTTPRequest(auth, url, 'POST', headers, route.body);
+            if (resp.Status < 200 || resp.Status >= 300) {
+                return this.buildCRUDError(resp, 'CreateRecord', ctx.ObjectName);
+            }
+            const body = (resp.Body ?? {});
+            const id = body['id'] != null ? String(body['id']) : (route.fallbackID ?? '');
+            return { Success: true, ExternalID: id, StatusCode: resp.Status };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { Success: false, ErrorMessage: `Reach360 CreateRecord failed: ${message}`, StatusCode: 500 };
+        }
+    }
+    /**
+     * Resolves which REST route a CreateRecord call maps to. Drives the router
+     * from object name + payload fields so no hardcoded switch on individual
+     * object behavior leaks into the HTTP code.
+     */
+    resolveCreateRoute(objectName, attrs) {
+        const obj = objectName.toLowerCase();
+        if (obj === 'invitations') {
+            return { path: '/invitations', body: attrs };
+        }
+        if (obj === 'completions') {
+            const courseId = attrs['courseId'];
+            const userId = attrs['userId'];
+            if (typeof courseId !== 'string' || typeof userId !== 'string')
+                return null;
+            const { courseId: _c, userId: _u, ...body } = attrs;
+            return {
+                path: `/courses/${encodeURIComponent(courseId)}/users/${encodeURIComponent(userId)}/completions`,
+                body,
+                fallbackID: `${courseId}|${userId}`,
+            };
+        }
+        if (obj === 'groupmembers' || obj === 'groupmembership' || obj === 'groupusers') {
+            const groupId = attrs['groupId'];
+            if (typeof groupId !== 'string')
+                return null;
+            const { groupId: _g, ...body } = attrs;
+            return { path: `/groups/${encodeURIComponent(groupId)}/users`, body };
+        }
+        return null;
+    }
+    /**
+     * Reach 360 update endpoints (per vendor docs as of audit):
+     *   - Groups        → PUT /groups/{groupId}     — name, description, tag updates
+     *   - Users         → not supported (no PUT/PATCH on /users/{id})
+     *   - Courses       → not supported (no PUT/PATCH on /courses/{id})
+     *   - Learning Paths → not supported
+     *   - Reports       → not supported
+     */
+    async UpdateRecord(ctx) {
+        const objectLower = ctx.ObjectName.toLowerCase();
+        if (objectLower === 'groups') {
+            const companyIntegration = ctx.CompanyIntegration;
+            const contextUser = ctx.ContextUser;
+            try {
+                const auth = await this.Authenticate(companyIntegration, contextUser);
+                const headers = this.BuildHeaders(auth);
+                const url = `${REACH360_BASE_URL}/groups/${encodeURIComponent(ctx.ExternalID)}`;
+                const resp = await this.MakeHTTPRequest(auth, url, 'PUT', headers, ctx.Attributes);
+                if (resp.Status >= 200 && resp.Status < 300) {
+                    return { Success: true, ExternalID: ctx.ExternalID, StatusCode: resp.Status };
+                }
+                return this.buildCRUDError(resp, 'UpdateRecord', ctx.ObjectName);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                return { Success: false, ErrorMessage: `Reach360 UpdateRecord failed: ${message}`, StatusCode: 500 };
+            }
+        }
+        return {
+            Success: false,
+            ErrorMessage: `Reach360 UpdateRecord not supported for "${ctx.ObjectName}" — only Groups supports PUT in the vendor API.`,
+            StatusCode: 400,
+        };
+    }
+    /**
+     * Supported deletes:
+     *   - Users → DELETE /users/{userId}
+     *   - Group membership → DELETE /groups/{groupId}/users/{userId}
+     *                         (requires `groupId` to be supplied via ExternalID
+     *                          as `{groupId}|{userId}`)
+     */
+    async DeleteRecord(ctx) {
+        const companyIntegration = ctx.CompanyIntegration;
+        const contextUser = ctx.ContextUser;
+        try {
+            const auth = await this.Authenticate(companyIntegration, contextUser);
+            const headers = this.BuildHeaders(auth);
+            const path = this.resolveDeletePath(ctx.ObjectName, ctx.ExternalID);
+            if (!path) {
+                return { Success: false, ErrorMessage: `Reach360 DeleteRecord not supported for "${ctx.ObjectName}"`, StatusCode: 400 };
+            }
+            const url = `${REACH360_BASE_URL}${path}`;
+            const resp = await this.MakeHTTPRequest(auth, url, 'DELETE', headers);
+            if (resp.Status < 200 || resp.Status >= 300) {
+                return this.buildCRUDError(resp, 'DeleteRecord', ctx.ObjectName);
+            }
+            return { Success: true, ExternalID: ctx.ExternalID, StatusCode: resp.Status };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { Success: false, ErrorMessage: `Reach360 DeleteRecord failed: ${message}`, StatusCode: 500 };
+        }
+    }
+    resolveDeletePath(objectName, externalID) {
+        const obj = objectName.toLowerCase();
+        if (obj === 'users') {
+            return `/users/${encodeURIComponent(externalID)}`;
+        }
+        if (obj === 'groupmembers' || obj === 'groupmembership' || obj === 'groupusers') {
+            const [groupId, userId] = externalID.split('|');
+            if (!groupId || !userId)
+                return null;
+            return `/groups/${encodeURIComponent(groupId)}/users/${encodeURIComponent(userId)}`;
+        }
+        return null;
+    }
+    buildCRUDError(resp, op, objectName) {
+        const body = resp.Body;
+        const rawMessage = typeof body?.['message'] === 'string' ? body['message'] : undefined;
+        return {
+            Success: false,
+            ErrorMessage: rawMessage ?? `Reach360 ${op} on ${objectName} failed (HTTP ${resp.Status})`,
+            StatusCode: resp.Status,
+        };
+    }
+    // ─── Abstract REST hooks (BaseRESTIntegrationConnector) ───────────
+    async Authenticate(companyIntegration, contextUser) {
+        const config = await this.parseConfig(companyIntegration, contextUser);
+        return { Token: config.apiKey, Config: config };
+    }
+    BuildHeaders(auth) {
+        const token = auth.Token ?? '';
+        return {
+            'Authorization': `Bearer ${token}`,
+            'Accept': 'application/json',
+        };
+    }
+    /**
+     * Not used by this connector — FetchChanges walks `nextUrl` directly and
+     * bypasses the base pagination engine. Still required to satisfy the
+     * abstract contract.
+     */
+    NormalizeResponse(rawBody, responseDataKey) {
+        if (!responseDataKey)
+            return Array.isArray(rawBody) ? rawBody : [];
+        const body = rawBody;
+        const arr = body[responseDataKey];
+        return Array.isArray(arr) ? arr : [];
+    }
+    /**
+     * Pagination info is expressed through Reach 360's `nextUrl` pointer which
+     * the cursor path already consumes directly. This hook is retained for API
+     * compliance and simply reports "no more pages" to anyone calling through
+     * the base pipeline.
+     */
+    ExtractPaginationInfo(rawBody, _paginationType, _currentPage, _currentOffset, _pageSize) {
+        const body = rawBody;
+        const next = typeof body?.nextUrl === 'string' && body.nextUrl.length > 0 ? body.nextUrl : null;
+        return { HasMore: next != null, NextCursor: next ?? undefined };
+    }
+    GetBaseURL(_companyIntegration, _auth) {
+        return REACH360_BASE_URL;
+    }
+    // ─── HTTP transport with retry + throttling ───────────────────────
+    async MakeHTTPRequest(auth, url, method, headers, body) {
+        const r360 = auth;
+        const cfg = r360.Config;
+        const maxRetries = cfg.MaxRetries ?? DEFAULT_MAX_RETRIES;
+        const timeoutMs = cfg.RequestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+        const minInterval = cfg.MinRequestIntervalMs ?? DEFAULT_MIN_REQUEST_INTERVAL_MS;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            await this.throttle(minInterval);
+            try {
+                const resp = await this.doFetch(url, method, headers, body, timeoutMs);
+                this.lastRequestTime = Date.now();
+                if (resp.Status === 429 || resp.Status === 503) {
+                    if (attempt === maxRetries)
+                        return resp;
+                    await this.sleep(this.backoffMs(attempt));
+                    continue;
+                }
+                return resp;
+            }
+            catch (err) {
+                if (attempt === maxRetries)
+                    throw err;
+                const retryable = this.isRetryableError(err);
+                if (!retryable)
+                    throw err;
+                await this.sleep(this.backoffMs(attempt));
+            }
+        }
+        throw new Error(`Reach360 request to ${url} exhausted ${maxRetries + 1} attempts`);
+    }
+    /** Executes a single fetch() with an AbortController-backed timeout. */
+    async doFetch(url, method, headers, body, timeoutMs) {
+        const controller = new AbortController();
+        const handle = setTimeout(() => controller.abort(), timeoutMs);
+        const finalHeaders = { ...headers };
+        if (body !== undefined && !finalHeaders['Content-Type']) {
+            finalHeaders['Content-Type'] = 'application/json';
+        }
+        try {
+            const resp = await fetch(url, {
+                method,
+                headers: finalHeaders,
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+            const respHeaders = {};
+            resp.headers.forEach((value, key) => { respHeaders[key.toLowerCase()] = value; });
+            const text = await resp.text();
+            const parsed = text.length > 0 ? this.safeParseJSON(text) : null;
+            return { Status: resp.status, Body: parsed, Headers: respHeaders };
+        }
+        finally {
+            clearTimeout(handle);
+        }
+    }
+    safeParseJSON(text) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    isRetryableError(err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return /abort|timeout|ECONNRESET|ENOTFOUND|ETIMEDOUT|network/i.test(msg);
+    }
+    backoffMs(attempt) {
+        const base = Math.min(1000 * Math.pow(2, attempt), 15000);
+        const jitter = Math.floor(Math.random() * 250);
+        return base + jitter;
+    }
+    async throttle(minIntervalMs) {
+        const elapsed = Date.now() - this.lastRequestTime;
+        if (elapsed < minIntervalMs) {
+            await this.sleep(minIntervalMs - elapsed);
+        }
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    // ─── Cursor helpers ──────────────────────────────────────────────
+    /** Encodes a full `nextUrl` into an opaque cursor string. */
+    EncodeCursor(nextUrl) {
+        return Buffer.from(nextUrl, 'utf-8').toString('base64url');
+    }
+    /** Decodes a previously encoded cursor back to its `nextUrl`. */
+    DecodeCursor(cursor) {
+        return Buffer.from(cursor, 'base64url').toString('utf-8');
+    }
+    // ─── Config parsing ───────────────────────────────────────────────
+    async parseConfig(companyIntegration, contextUser) {
+        const credentialID = companyIntegration.CredentialID;
+        if (credentialID) {
+            const fromCred = await this.loadFromCredential(credentialID, contextUser);
+            if (fromCred)
+                return fromCred;
+        }
+        const raw = companyIntegration.Configuration;
+        if (!raw) {
+            throw new Error('Reach360Connector: No credential or Configuration JSON found on CompanyIntegration');
+        }
+        const parsed = JSON.parse(raw);
+        return this.validateConfig(parsed);
+    }
+    async loadFromCredential(credentialID, contextUser, provider) {
+        const md = provider ?? new Metadata();
+        const credential = await md.GetEntityObject('MJ: Credentials', contextUser);
+        const loaded = await credential.Load(credentialID);
+        if (!loaded || !credential.Values)
+            return null;
+        try {
+            const parsed = JSON.parse(credential.Values);
+            return this.validateConfig(parsed);
+        }
+        catch {
+            return null;
+        }
+    }
+    validateConfig(raw) {
+        if (!raw.apiKey || typeof raw.apiKey !== 'string') {
+            throw new Error('Reach360Connector: apiKey is required');
+        }
+        return {
+            apiKey: raw.apiKey,
+            MaxRetries: raw.MaxRetries ?? DEFAULT_MAX_RETRIES,
+            RequestTimeoutMs: raw.RequestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
+            MinRequestIntervalMs: raw.MinRequestIntervalMs ?? DEFAULT_MIN_REQUEST_INTERVAL_MS,
+        };
+    }
+};
+Reach360Connector = __decorate([
+    RegisterClass(BaseIntegrationConnector, 'Reach360Connector')
+], Reach360Connector);
+export { Reach360Connector };
+/** Tree-shaking prevention function — import and call from module entry point. */
+export function LoadReach360Connector() { }
+//# sourceMappingURL=Reach360Connector.js.map