@memberjunction/integration-connectors 5.50.0 → 6.1.0-edge.0

package/dist/IMISConnector.js

@@ -1,695 +0,0 @@
-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;
-};
-/**
- * IMISConnector — Integration connector for iMIS EMS (Advanced Solutions International)
- * REST API.
- *
- * ── Auth: OAuth 2.0 PASSWORD grant (resource-owner) ─────────────────────────
- *   Mints/refreshes a bearer ACCESS TOKEN via the shared {@link OAuth2TokenManager}
- *   (no inlined token/crypto logic). iMIS issues tokens via the resource-owner
- *   `grant_type=password` flow — username + password POSTed to the token endpoint:
- *     - default  = `{BaseURL}/token`
- *     - override  = the credential's `TokenURL` (when supplied)
- *     - fallback  = the legacy `{BaseURL}/asiScheduler/token` path (older iMIS builds)
- *   iMIS does NOT require client_id/client_secret for the password grant, so the
- *   OAuth2TokenManager request is configured with empty client credentials in the
- *   body. Every API request sends `Authorization: Bearer {accessToken}`.
- *
- * ── Base URL ────────────────────────────────────────────────────────────────
- *   Comes from the credential's `BaseURL` (the tenant's iMIS API endpoint) — never
- *   a hardcoded host. Credential bytes are resolved at runtime, never at build.
- *
- * ── Catalog (metadata-driven, NOT hardcoded) ───────────────────────────────
- *   The Declared core object/field set comes from the seeded metadata loaded into
- *   the IntegrationEngineBase cache. The connector NEVER bakes an object/field catalog
- *   into code. DiscoverObjects/DiscoverFields express only the MECHANISM: they call the
- *   auth-gated /EntityDefinition + /{entity}/metadata endpoints at runtime to enumerate
- *   the tenant's Business-Object catalog + per-object fields, ADDITIVE to the Declared
- *   baseline. DiscoveryIsAuthoritative stays false (default) — these scoped enumerations
- *   never deactivate Declared metadata on absence.
- *
- * ── Pagination & incremental ───────────────────────────────────────────────
- *   iMIS uses the PagedResult envelope (`{ Items, Offset, Limit, Count, HasNext }`) with
- *   capitalized `Offset`/`Limit` query params; ExtractPaginationInfo reads HasNext/Offset/Limit
- *   and advances Offset by the returned count until HasNext is false. NormalizeResponse
- *   unwraps the Items collection. Incremental sync is metadata-driven: an IO with
- *   SupportsIncrementalSync=true emits its `IncrementalWatermarkField` as a `gt:` filter.
- *
- * ── Write ───────────────────────────────────────────────────────────────────
- *   CRUD rides the generic BaseRESTIntegrationConnector per-operation path: Create/Update/Delete
- *   read the per-operation IO columns (CreateAPIPath/Method/BodyShape/BodyKey/IDLocation, Update*,
- *   Delete*), creates route through BuildCreatedResult (fail loudly on empty ID), and DeleteMethod
- *   is metadata-driven (not assumed DELETE). Capability flags follow the per-operation columns the
- *   metadata declares — no hardcoded `true`, no 501 stubs. Full-record pass-through (Fields=raw).
- *
- * Reference: https://developer.imis.com/docs/imis-rest-api-data-models-and-swagger-json-files
- */
-import { RegisterClass } from '@memberjunction/global';
-import { Metadata } from '@memberjunction/core';
-import { BaseIntegrationConnector, BaseRESTIntegrationConnector, OAuth2TokenManager, } from '@memberjunction/integration-engine';
-import { IntegrationEngineBase } from '@memberjunction/integration-engine-base';
-// ─── Constants ───────────────────────────────────────────────────────
-/** The canonical MJ: Integrations.Name — part of the three-way invariant. */
-const INTEGRATION_NAME = 'iMIS';
-/** Default token endpoint path appended to the base when no TokenURL override is supplied. */
-const DEFAULT_TOKEN_PATH = '/token';
-/** Legacy token endpoint path for older iMIS deployments (documented fallback). */
-const LEGACY_TOKEN_PATH = '/asiScheduler/token';
-const DEFAULT_MAX_RETRIES = 3;
-const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
-const DEFAULT_MIN_REQUEST_INTERVAL_MS = 200;
-const DEFAULT_PAGE_SIZE = 100;
-/** iMIS-to-generic type mapping used when merging live-discovered field metadata. */
-const IMIS_TYPE_MAP = {
-    'string': 'string',
-    'datetime': 'datetime',
-    'date': 'date',
-    'boolean': 'boolean',
-    'int32': 'integer',
-    'int64': 'integer',
-    'integer': 'integer',
-    'long': 'integer',
-    'decimal': 'decimal',
-    'double': 'decimal',
-    'float': 'decimal',
-    'guid': 'uuid',
-    'uuid': 'uuid',
-    'monetaryamountdata': 'decimal',
-};
-// ─── Connector Implementation ────────────────────────────────────────
-let IMISConnector = class IMISConnector extends BaseRESTIntegrationConnector {
-    constructor() {
-        super(...arguments);
-        /** Cached auth context for the current sync run. */
-        this.authCache = null;
-        /** Shared OAuth2 token manager — owns the token round-trip + cache. */
-        this.tokenManager = new OAuth2TokenManager();
-        /** Timestamp of the last API request, for client-side throttling. */
-        this.lastRequestTime = 0;
-    }
-    // Returns the EXACT MJ: Integrations.Name string LITERAL so the T1 ThreeWayName invariant can
-    // statically parse the getter's returned value from connector source.
-    get IntegrationName() { return 'iMIS'; }
-    // ── Capability getters: METADATA-DRIVEN (no hardcoded answer) ─────
-    //
-    // Write capability FOLLOWS the per-operation CRUD columns on the cached IntegrationObjects
-    // (Declared metadata). An object is create-capable when it declares both CreateAPIPath +
-    // CreateMethod; same for update/delete. With no write metadata authored the surface is
-    // read-only (returns false) — but the moment a writable object's per-operation columns are
-    // populated, the capability flips on and the base generic CRUD path executes it.
-    get SupportsCreate() {
-        return this.anyObjectDeclares(o => !!o.CreateAPIPath && !!o.CreateMethod);
-    }
-    get SupportsUpdate() {
-        return this.anyObjectDeclares(o => !!o.UpdateAPIPath && !!o.UpdateMethod);
-    }
-    get SupportsDelete() {
-        return this.anyObjectDeclares(o => !!o.DeleteAPIPath && !!o.DeleteMethod);
-    }
-    get SupportsSearch() { return false; }
-    get SupportsListing() { return false; }
-    /** True when any cached IntegrationObject satisfies the predicate. []→false when the engine
-     *  cache is unavailable (e.g. capability probed before configuration) — fail-safe read-only. */
-    anyObjectDeclares(pred) {
-        const integration = IntegrationEngineBase.Instance.GetIntegrationByName(INTEGRATION_NAME);
-        if (!integration)
-            return false;
-        return IntegrationEngineBase.Instance.GetActiveIntegrationObjects(integration.ID).some(pred);
-    }
-    // ─── BaseRESTIntegrationConnector abstract methods ──────────────
-    /**
-     * OAuth 2.0 password-grant authentication. Mints/refreshes the access token via the shared
-     * {@link OAuth2TokenManager} (no inlined token/crypto logic). One token exchange per run is
-     * cached and reused across every request.
-     */
-    async Authenticate(companyIntegration, contextUser) {
-        if (this.authCache)
-            return this.authCache;
-        const config = await this.ParseConfig(companyIntegration, contextUser);
-        const baseUrl = this.ResolveBaseUrl(config);
-        const token = await this.MintToken(config, baseUrl);
-        const auth = { Token: token, BaseUrl: baseUrl, Config: config };
-        this.authCache = auth;
-        return auth;
-    }
-    /**
-     * Runs the password-grant token round-trip through OAuth2TokenManager. Tries the resolved
-     * token endpoint first, then the legacy `/asiScheduler/token` path on failure (older iMIS).
-     */
-    async MintToken(config, baseUrl) {
-        const primaryURL = this.ResolveTokenURL(config, baseUrl);
-        const req = this.BuildTokenRequest(config, primaryURL);
-        try {
-            const token = await this.tokenManager.GetAccessToken(req, 'password');
-            return token.AccessToken;
-        }
-        catch (primaryErr) {
-            // Legacy fallback only when no explicit override was given and the legacy path differs.
-            const legacyURL = `${baseUrl}${LEGACY_TOKEN_PATH}`;
-            if (config.TokenURL || legacyURL === primaryURL)
-                throw primaryErr;
-            this.tokenManager.Reset();
-            const token = await this.tokenManager.GetAccessToken({ ...req, TokenURL: legacyURL }, 'password');
-            return token.AccessToken;
-        }
-    }
-    /** Builds the OAuth2 password-grant request. iMIS does not require client credentials. */
-    BuildTokenRequest(config, tokenURL) {
-        return {
-            TokenURL: tokenURL,
-            ClientId: config.ClientId ?? '',
-            ClientSecret: config.ClientSecret ?? '',
-            Username: config.Username,
-            Password: config.Password,
-            TimeoutMs: config.RequestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
-        };
-    }
-    /**
-     * Extracts the new record's external ID from a create response. iMIS returns the created
-     * object with a vendor-specific ID field (Id / PartyId / EventId / InvoiceId / …); the base
-     * scanner only knows the generic `id` family, so widen it for iMIS's `{Object}Id` convention.
-     * The empty-ID case still routes through BuildCreatedResult, which fails loudly.
-     */
-    ExtractIDFromResponse(response, idLocation) {
-        if ((!idLocation || idLocation === 'body') && response.Body && typeof response.Body === 'object') {
-            const b = response.Body;
-            const candidates = ['Id', 'ID', 'PartyId', 'UniformId', 'EventId', 'InvoiceId', 'PaymentId', 'id', 'externalID', 'ExternalID'];
-            for (const k of candidates) {
-                const v = b[k];
-                if (typeof v === 'string' || typeof v === 'number') {
-                    const s = String(v).trim();
-                    if (s.length > 0)
-                        return s;
-                }
-            }
-            return undefined;
-        }
-        return super.ExtractIDFromResponse(response, idLocation);
-    }
-    /** Sends the OAuth2 bearer token on every request. */
-    BuildHeaders(auth) {
-        const token = auth.Token ?? auth.Token ?? '';
-        return {
-            'Authorization': `Bearer ${token}`,
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-        };
-    }
-    GetBaseURL(_companyIntegration, auth) {
-        return auth.BaseUrl;
-    }
-    /**
-     * Unwraps the iMIS PagedResult envelope to the Items collection. Handles the envelope,
-     * an explicit responseDataKey, a raw array, and a single-object detail response. The FULL
-     * source record passes through (no field filtering) so the framework's custom-column capture
-     * sees everything the source returned.
-     */
-    NormalizeResponse(rawBody, responseDataKey) {
-        if (rawBody == null)
-            return [];
-        // PagedResult envelope → Items (ResponseDataKey is typically "Items")
-        if (this.IsPagedResult(rawBody)) {
-            return rawBody.Items ?? [];
-        }
-        if (responseDataKey) {
-            const record = rawBody;
-            const data = record[responseDataKey];
-            if (Array.isArray(data))
-                return data;
-        }
-        if (Array.isArray(rawBody))
-            return rawBody;
-        // Single-object detail response (GET /{Entity}/{id}).
-        return [rawBody];
-    }
-    /**
-     * Derives Offset/Limit pagination state from the iMIS PagedResult envelope: advance Offset by
-     * the number of Items returned and continue while HasNext is true (terminate when HasNext is false).
-     */
-    ExtractPaginationInfo(rawBody, paginationType, currentPage, currentOffset, _pageSize) {
-        if (paginationType === 'None')
-            return { HasMore: false };
-        const envelope = this.IsPagedResult(rawBody) ? rawBody : null;
-        if (!envelope) {
-            // No PagedResult envelope → cannot advance → no more pages.
-            return { HasMore: false };
-        }
-        const returnedCount = envelope.Items?.length ?? 0;
-        const hasMore = (envelope.HasNext ?? false) && returnedCount > 0;
-        const nextOffset = (envelope.Offset ?? currentOffset) + returnedCount;
-        return {
-            HasMore: hasMore,
-            NextOffset: paginationType === 'Offset' ? nextOffset : undefined,
-            NextPage: paginationType === 'PageNumber' ? currentPage + 1 : undefined,
-            TotalRecords: envelope.Count,
-        };
-    }
-    /**
-     * iMIS pagination uses capitalized `Offset` / `Limit` query parameters. Override the base
-     * helper to match iMIS's param names.
-     */
-    BuildPaginatedURL(basePath, obj, page, offset, cursor, effectivePageSize) {
-        const pageSize = effectivePageSize ?? obj.DefaultPageSize ?? DEFAULT_PAGE_SIZE;
-        const separator = basePath.includes('?') ? '&' : '?';
-        switch (obj.PaginationType) {
-            case 'PageNumber':
-                return `${basePath}${separator}Page=${page}&Limit=${pageSize}`;
-            case 'Offset':
-                return `${basePath}${separator}Offset=${offset}&Limit=${pageSize}`;
-            case 'Cursor':
-                return cursor
-                    ? `${basePath}${separator}cursor=${encodeURIComponent(cursor)}&Limit=${pageSize}`
-                    : `${basePath}${separator}Limit=${pageSize}`;
-            default:
-                return basePath;
-        }
-    }
-    /**
-     * Injects the incremental watermark filter when a sync is active. The param NAME is fully
-     * METADATA-DRIVEN: it comes from the IO's `IncrementalWatermarkField` and is emitted only when
-     * SupportsIncrementalSync=true AND a watermark value is in context. iMIS accepts operator-prefixed
-     * filter values (`gt:`) on list endpoints.
-     */
-    AppendDefaultQueryParams(url, obj) {
-        let result = super.AppendDefaultQueryParams(url, obj);
-        const watermarkField = obj.IncrementalWatermarkField;
-        if (obj.SupportsIncrementalSync && watermarkField && this.currentWatermark) {
-            const separator = result.includes('?') ? '&' : '?';
-            const param = `${encodeURIComponent(watermarkField)}=${encodeURIComponent('gt:' + this.currentWatermark)}`;
-            result = `${result}${separator}${param}`;
-        }
-        return result;
-    }
-    /** Executes an HTTP request with client-side throttling + retry for 401/429/5xx. */
-    async MakeHTTPRequest(auth, url, method, headers, body) {
-        const imisAuth = auth;
-        const maxRetries = imisAuth.Config.MaxRetries ?? DEFAULT_MAX_RETRIES;
-        const timeoutMs = imisAuth.Config.RequestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-        const minInterval = imisAuth.Config.MinRequestIntervalMs ?? DEFAULT_MIN_REQUEST_INTERVAL_MS;
-        const effectiveHeaders = { ...headers };
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            await this.ThrottleIfNeeded(minInterval);
-            const fetchOptions = {
-                method,
-                headers: effectiveHeaders,
-                signal: AbortSignal.timeout(timeoutMs),
-            };
-            if (body !== undefined && method !== 'GET') {
-                fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
-            }
-            let response;
-            try {
-                response = await fetch(url, fetchOptions);
-            }
-            catch (err) {
-                if (attempt < maxRetries && this.IsTransientNetworkError(err)) {
-                    await this.Sleep(this.BackoffDelay(attempt));
-                    continue;
-                }
-                throw err;
-            }
-            this.lastRequestTime = Date.now();
-            // Token expired mid-run — force a fresh mint and retry once with the new bearer.
-            if (response.status === 401 && attempt < maxRetries) {
-                this.tokenManager.Reset();
-                this.authCache = null;
-                const fresh = await this.MintToken(imisAuth.Config, imisAuth.BaseUrl);
-                imisAuth.Token = fresh;
-                this.authCache = imisAuth;
-                effectiveHeaders['Authorization'] = `Bearer ${fresh}`;
-                continue;
-            }
-            if ((response.status === 429 || response.status >= 500) && attempt < maxRetries) {
-                console.warn(`[iMIS] HTTP ${response.status} from ${url} — backing off`);
-                await this.Sleep(this.RetryAfterMs(response) ?? this.BackoffDelay(attempt));
-                continue;
-            }
-            return this.BuildRESTResponse(response);
-        }
-        throw new Error(`iMIS request failed after ${maxRetries + 1} attempts: ${url}`);
-    }
-    // ─── TestConnection ──────────────────────────────────────────────
-    /**
-     * Tests connectivity by minting a password-grant token and listing one Party record. A 2xx
-     * confirms the OAuth2 credentials + base URL are valid against the live API.
-     */
-    async TestConnection(companyIntegration, contextUser) {
-        try {
-            const auth = (await this.Authenticate(companyIntegration, contextUser));
-            const headers = this.BuildHeaders(auth);
-            const url = `${auth.BaseUrl}/Party?Limit=1`;
-            const response = await this.MakeHTTPRequest(auth, url, 'GET', headers);
-            if (response.Status < 200 || response.Status >= 300) {
-                return { Success: false, Message: `iMIS returned HTTP ${response.Status} from ${url}` };
-            }
-            return {
-                Success: true,
-                Message: `Connected to iMIS EMS at ${auth.BaseUrl}`,
-                ServerVersion: this.ExtractServerVersion(response.Headers),
-            };
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            return { Success: false, Message: `Connection failed: ${message}` };
-        }
-    }
-    // ─── Discovery (metadata-driven baseline + runtime mechanism) ────
-    /**
-     * Discovers objects: the Declared core baseline from the IntegrationEngineBase cache, ADDITIVELY
-     * extended at runtime via the auth-gated /EntityDefinition endpoint (the tenant's customer
-     * Business-Object catalog). The catalog is NEVER baked into code — DiscoverObjects expresses only
-     * the discovery MECHANISM. Failures degrade gracefully to the Declared baseline.
-     */
-    async DiscoverObjects(companyIntegration, contextUser) {
-        const declared = await super.DiscoverObjects(companyIntegration, contextUser);
-        const declaredNames = new Set(declared.map(o => o.Name.toLowerCase()));
-        try {
-            const discovered = await this.DiscoverEntityDefinitions(companyIntegration, contextUser);
-            const additive = discovered.filter(d => !declaredNames.has(d.Name.toLowerCase()));
-            return [...declared, ...additive];
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.warn(`[iMIS] EntityDefinition discovery failed, returning declared objects only: ${message}`);
-            return declared;
-        }
-    }
-    /**
-     * Discovers fields: the Declared baseline from the cache, ADDITIVELY extended at runtime via the
-     * auth-gated /{entity}/metadata endpoint (the tenant's PropertyDefinitions). The field set is
-     * NEVER baked in code. Failures degrade gracefully to the Declared baseline.
-     */
-    async DiscoverFields(companyIntegration, objectName, contextUser) {
-        const declared = await super.DiscoverFields(companyIntegration, objectName, contextUser);
-        try {
-            const live = await this.DiscoverFieldsFromLiveAPI(companyIntegration, objectName, contextUser);
-            return this.MergeFieldSchemas(declared, live);
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.warn(`[iMIS] Live field discovery failed for "${objectName}", returning declared fields: ${message}`);
-            return declared;
-        }
-    }
-    // ─── FetchChanges override (watermark wiring) ────────────────────
-    /**
-     * Sets the watermark context the URL builder needs, delegates the walk to the base (which handles
-     * pagination + nested template-var paths), then advances the watermark from the returned records
-     * on the FINAL batch only (partial-failure-safe — a mid-stream failure leaves the watermark unchanged).
-     */
-    async FetchChanges(ctx) {
-        this.currentWatermark = ctx.WatermarkValue ?? undefined;
-        try {
-            const result = await super.FetchChanges(ctx);
-            const isFinal = !result.HasMore;
-            result.NewWatermarkValue = isFinal
-                ? this.ComputeNewWatermark(result.Records, ctx.WatermarkValue)
-                : undefined;
-            return result;
-        }
-        finally {
-            this.currentWatermark = undefined;
-        }
-    }
-    // ── Default configuration / field mappings ──────────────────────
-    GetDefaultConfiguration() {
-        return {
-            DefaultSchemaName: 'iMIS',
-            DefaultObjects: [],
-        };
-    }
-    GetDefaultFieldMappings(objectName, _entityName) {
-        switch (objectName) {
-            case 'Party':
-            case 'Person':
-                return [
-                    { SourceFieldName: 'PartyId', DestinationFieldName: 'ExternalID', IsKeyField: true },
-                    { SourceFieldName: 'FullName', DestinationFieldName: 'Name' },
-                    { SourceFieldName: 'PrimaryEmail', DestinationFieldName: 'Email' },
-                    { SourceFieldName: 'PrimaryPhone', DestinationFieldName: 'Phone' },
-                ];
-            case 'Event':
-                return [
-                    { SourceFieldName: 'EventId', DestinationFieldName: 'ExternalID', IsKeyField: true },
-                    { SourceFieldName: 'Name', DestinationFieldName: 'Name' },
-                    { SourceFieldName: 'StartDate', DestinationFieldName: 'StartDate' },
-                    { SourceFieldName: 'EndDate', DestinationFieldName: 'EndDate' },
-                ];
-            default:
-                return [];
-        }
-    }
-    // ─────────────────────────────────────────────────────────────────
-    //                         Private helpers
-    // ─────────────────────────────────────────────────────────────────
-    // ── Runtime discovery (Business Objects + field metadata) ───────
-    async DiscoverEntityDefinitions(companyIntegration, contextUser) {
-        const auth = (await this.Authenticate(companyIntegration, contextUser));
-        const url = `${auth.BaseUrl}/EntityDefinition?Limit=500`;
-        const headers = this.BuildHeaders(auth);
-        const response = await this.MakeHTTPRequest(auth, url, 'GET', headers);
-        if (response.Status < 200 || response.Status >= 300)
-            return [];
-        const records = this.NormalizeResponse(response.Body, 'Items');
-        return records
-            .filter(d => !!d.Name)
-            .map(d => ({
-            Name: String(d.Name),
-            Label: d.DisplayName ?? String(d.Name),
-            Description: d.Description ?? 'Tenant-defined Business Object (runtime-discovered)',
-            SupportsIncrementalSync: true,
-            SupportsWrite: false,
-        }));
-    }
-    async DiscoverFieldsFromLiveAPI(companyIntegration, objectName, contextUser) {
-        const auth = (await this.Authenticate(companyIntegration, contextUser));
-        const path = this.ResolveObjectPath(companyIntegration.IntegrationID, objectName);
-        const url = `${auth.BaseUrl}${path}/metadata`;
-        const headers = this.BuildHeaders(auth);
-        const response = await this.MakeHTTPRequest(auth, url, 'GET', headers);
-        if (response.Status < 200 || response.Status >= 300)
-            return [];
-        const meta = response.Body;
-        const propDefs = meta?.PropertyDefinitions ?? [];
-        return propDefs
-            .filter(p => !!p.Name)
-            .map(p => this.PropertyDefinitionToFieldSchema(p));
-    }
-    PropertyDefinitionToFieldSchema(prop) {
-        const rawType = (prop.PropertyType ?? prop.PropertyTypeData?.Name ?? 'string').toLowerCase();
-        const genericType = IMIS_TYPE_MAP[rawType] ?? 'string';
-        return {
-            Name: String(prop.Name),
-            Label: prop.DisplayName ?? String(prop.Name),
-            Description: prop.Description,
-            DataType: genericType,
-            IsRequired: !!prop.IsRequired,
-            // Provable-only: the source explicitly distinguishes PK; only set PK when stated.
-            IsPrimaryKey: prop.IsPrimaryKey === true ? true : undefined,
-            IsUniqueKey: !!prop.IsPrimaryKey,
-            IsReadOnly: !!prop.IsReadOnly,
-            MaxLength: prop.MaxLength ?? undefined,
-        };
-    }
-    /**
-     * Merge live-discovered fields with the Declared baseline. Live-only fields are appended;
-     * Declared fields win on matching names (the curated MJ schema is authoritative for the baseline).
-     */
-    MergeFieldSchemas(declared, live) {
-        const declaredNames = new Set(declared.map(f => f.Name.toLowerCase()));
-        const liveOnly = live.filter(f => !declaredNames.has(f.Name.toLowerCase()));
-        return [...declared, ...liveOnly];
-    }
-    /**
-     * Resolve an object name to its API path. Prefers the configured APIPath from IntegrationObject
-     * metadata; falls back to `/{ObjectName}` for runtime-discovered Business Objects.
-     */
-    ResolveObjectPath(integrationID, objectName) {
-        try {
-            const obj = this.GetCachedObject(integrationID, objectName);
-            if (obj.APIPath) {
-                return obj.APIPath.startsWith('/') ? obj.APIPath : `/${obj.APIPath}`;
-            }
-        }
-        catch {
-            // Not in Declared metadata — a runtime-discovered Business Object.
-        }
-        return `/${objectName}`;
-    }
-    // ── Config parsing ──────────────────────────────────────────────
-    /**
-     * Parses the connection config, preferring the attached MJ Credential over the raw Configuration
-     * JSON. Credential bytes are resolved at runtime — never at build.
-     */
-    async ParseConfig(companyIntegration, contextUser) {
-        if (companyIntegration.CredentialID) {
-            return this.ParseConfigFromCredential(companyIntegration.CredentialID, contextUser);
-        }
-        if (companyIntegration.Configuration) {
-            return this.ValidateConfig(JSON.parse(companyIntegration.Configuration));
-        }
-        throw new Error('iMIS connector requires either CredentialID or Configuration JSON');
-    }
-    /** Loads the config from the MJ: Credentials entity Values JSON. */
-    async ParseConfigFromCredential(credentialID, contextUser, provider) {
-        const md = provider ?? new Metadata();
-        const cred = await md.GetEntityObject('MJ: Credentials', contextUser);
-        const loaded = await cred.Load(credentialID);
-        if (!loaded || !cred.Values) {
-            throw new Error('iMIS credential could not be loaded or has no Values JSON');
-        }
-        return this.ValidateConfig(JSON.parse(cred.Values));
-    }
-    /** Validates the parsed config + applies defaults. Field names are case-insensitive. */
-    ValidateConfig(raw) {
-        if (!raw || typeof raw !== 'object') {
-            throw new Error('iMIS configuration is not a valid object');
-        }
-        const obj = raw;
-        const getStr = (...keys) => {
-            for (const key of keys) {
-                const lower = key.toLowerCase();
-                for (const [k, v] of Object.entries(obj)) {
-                    if (k.toLowerCase() === lower && typeof v === 'string' && v.length > 0)
-                        return v;
-                }
-            }
-            return undefined;
-        };
-        const getNum = (...keys) => {
-            for (const key of keys) {
-                const lower = key.toLowerCase();
-                for (const [k, v] of Object.entries(obj)) {
-                    if (k.toLowerCase() === lower && typeof v === 'number')
-                        return v;
-                }
-            }
-            return undefined;
-        };
-        const baseURL = getStr('baseurl', 'base_url');
-        if (!baseURL)
-            throw new Error('iMIS configuration missing required field: BaseURL');
-        const username = getStr('username', 'user');
-        const password = getStr('password', 'pass');
-        if (!username)
-            throw new Error('iMIS configuration missing required field: Username');
-        if (!password)
-            throw new Error('iMIS configuration missing required field: Password');
-        return {
-            BaseURL: baseURL,
-            Username: username,
-            Password: password,
-            TokenURL: getStr('tokenurl', 'token_url'),
-            ClientId: getStr('clientid', 'client_id'),
-            ClientSecret: getStr('clientsecret', 'client_secret'),
-            MaxRetries: getNum('maxretries') ?? DEFAULT_MAX_RETRIES,
-            RequestTimeoutMs: getNum('requesttimeoutms') ?? DEFAULT_REQUEST_TIMEOUT_MS,
-            MinRequestIntervalMs: getNum('minrequestintervalms') ?? DEFAULT_MIN_REQUEST_INTERVAL_MS,
-        };
-    }
-    /** Resolves the API base URL from the credential's BaseURL (never a hardcoded host). */
-    ResolveBaseUrl(config) {
-        return config.BaseURL.replace(/\/+$/, '');
-    }
-    /**
-     * Resolves the token endpoint: credential TokenURL override, else `{base}/token`. iMIS issues
-     * tokens at the host root (not under /api/), so a trailing /api segment is stripped.
-     */
-    ResolveTokenURL(config, baseUrl) {
-        if (config.TokenURL && config.TokenURL.length > 0)
-            return config.TokenURL;
-        const root = baseUrl.replace(/\/api$/i, '');
-        return `${root}${DEFAULT_TOKEN_PATH}`;
-    }
-    // ── Watermark helper ────────────────────────────────────────────
-    ComputeNewWatermark(records, current) {
-        const candidateKeys = ['UpdatedOn', 'UpdateDate', 'ModifiedOn', 'LastUpdatedAt'];
-        let latest;
-        for (const record of records) {
-            for (const key of candidateKeys) {
-                const value = record.Fields[key];
-                if (typeof value === 'string' && (!latest || value > latest))
-                    latest = value;
-            }
-        }
-        if (!latest)
-            return current ?? undefined;
-        if (current && latest <= current)
-            return current;
-        return latest;
-    }
-    // ── HTTP helpers ────────────────────────────────────────────────
-    /** Throttle to respect the configured minimum request interval. */
-    async ThrottleIfNeeded(minIntervalMs) {
-        const elapsed = Date.now() - this.lastRequestTime;
-        if (elapsed < minIntervalMs)
-            await this.Sleep(minIntervalMs - elapsed);
-    }
-    /** Parses a Retry-After header (seconds or http-date) into ms, if present. */
-    RetryAfterMs(response) {
-        const header = response.headers.get('retry-after');
-        if (!header)
-            return undefined;
-        const asSeconds = Number(header);
-        if (!isNaN(asSeconds))
-            return Math.max(0, asSeconds * 1_000);
-        const asDate = new Date(header).getTime();
-        if (!isNaN(asDate))
-            return Math.max(0, asDate - Date.now());
-        return undefined;
-    }
-    /** Exponential backoff delay for retry attempts (capped at 15s). */
-    BackoffDelay(attempt) {
-        return Math.min(1_000 * Math.pow(2, attempt), 15_000);
-    }
-    /** Checks whether an error is transient (network/timeout). */
-    IsTransientNetworkError(err) {
-        if (!(err instanceof Error))
-            return false;
-        const msg = err.message.toLowerCase();
-        return msg.includes('timeout') || msg.includes('abort') ||
-            msg.includes('econnreset') || msg.includes('econnrefused') ||
-            msg.includes('fetch failed');
-    }
-    /** Builds the normalized RESTResponse from a fetch Response. */
-    async BuildRESTResponse(response) {
-        const headers = {};
-        response.headers.forEach((v, k) => { headers[k.toLowerCase()] = v; });
-        const text = await response.text();
-        let body = null;
-        if (text.length > 0) {
-            try {
-                body = JSON.parse(text);
-            }
-            catch {
-                body = text;
-            }
-        }
-        return { Status: response.status, Body: body, Headers: headers };
-    }
-    ExtractServerVersion(headers) {
-        return headers['x-imis-version'] ?? headers['server'] ?? 'iMIS REST API';
-    }
-    /** True when a body is the iMIS PagedResult envelope (Items[] + Offset/Limit/HasNext). */
-    IsPagedResult(body) {
-        if (body == null || typeof body !== 'object' || Array.isArray(body))
-            return false;
-        const record = body;
-        return Array.isArray(record['Items']) && ('Offset' in record || 'Limit' in record || 'HasNext' in record);
-    }
-    /** Promise-wrapped setTimeout. */
-    Sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-};
-IMISConnector = __decorate([
-    RegisterClass(BaseIntegrationConnector, 'IMISConnector')
-], IMISConnector);
-export { IMISConnector };
-/** Tree-shaking prevention — import and call from the package entry point. */
-export function LoadIMISConnector() { }
-//# sourceMappingURL=IMISConnector.js.map