n8n-nodes-mautic-advanced 1.3.2 → 1.3.9

package/README.md

@@ -193,6 +193,11 @@ npm install n8n-nodes-mautic-advanced
 3. Enter your Mautic URL
 4. Follow the OAuth2 authorization flow
 
+> **Auth method and Company Owner (v7 enrichment):** The Mautic version (v6 vs v7) is auto-detected by probing the v2 API (API Platform). Company **owner** is a v7-only field, populated by enriching Company *Get* / *Get Many* via the v2 API. The v2 API requires an auth method the server accepts:
+>
+> - **Basic auth** — confirmed working with the v2 API; owner enrichment populates `owner: { id }`.
+> - **OAuth2** — depends on the Mautic server allowing v2 access for the bearer token. Many Mautic installs reject v1-style OAuth2 tokens at the v2 API Platform firewall (HTTP 401), in which case the node falls back to the v1 API for all company operations and **owner cannot be enriched** (`owner: null`). When this happens, a warning is logged explaining the cause. Custom fields and all other company data are unaffected. To populate owner, switch the credential to Basic auth, or enable v2 API access for OAuth2 on the Mautic server.
+
 ## Advanced Features
 
 ### Where Filters

package/dist/nodes/MauticAdvanced/ContactDescription.js

@@ -1561,7 +1561,7 @@ exports.contactFields = [
                     },
                 },
                 default: [],
-                description: 'Filter contacts by owner (assigned user). Uses Mautic search syntax (owner:id) under the hood.',
+                description: 'Filter contacts by owner (assigned user). Matched on the returned owner ID. Note: Mautic has no server-side owner-by-ID search, so this is applied client-side over the result set — combine with other filters (e.g. segment/tag/DNC) to narrow the set first.',
             },
             {
                 displayName: 'Published Only',

package/dist/nodes/MauticAdvanced/GenericFunctions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateJSON = exports.serialiseMauticWhere = exports.mauticApiRequestAllItems = exports.DEFAULT_MAUTIC_PAGE_SIZE = exports.mauticApiRequest = exports.getMauticVersion = void 0;
+exports.validateJSON = exports.serialiseMauticWhere = exports.mauticApiRequestAllItems = exports.DEFAULT_MAUTIC_PAGE_SIZE = exports.mauticApiRequest = exports.getMauticV2Status = exports.getMauticVersion = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
 const authenticatedRequest_1 = require("./utils/authenticatedRequest");
 const versionCache = new Map();
@@ -22,7 +22,7 @@ function normalizeInstanceUrl(raw) {
         return trimmed.replace(/\/+$/, '');
     }
 }
-async function getMauticVersion(context) {
+async function detectMauticV2(context) {
     const authMethod = context.getNodeParameter('authentication', 0, 'credentials');
     const credentialType = authMethod === 'credentials' ? 'mauticAdvancedApi' : 'mauticAdvancedOAuth2Api';
     const credentials = await context.getCredentials(credentialType);
@@ -30,23 +30,43 @@ async function getMauticVersion(context) {
     const cacheKey = `${credentialType}:${baseUrl}`;
     const cached = versionCache.get(cacheKey);
     if (cached && Date.now() < cached.expiresAt) {
-        return cached.version;
+        return { version: cached.version, v2Status: cached.v2Status };
     }
-    let version;
+    let v2Status;
     try {
         await mauticApiRequest.call(context, 'GET', '/v2/companies', {}, { page: 1 }, undefined, {
             Accept: 'application/json',
         });
-        version = 'v7';
+        v2Status = 'usable';
     }
     catch (error) {
-        // 403 = v2 route exists but no permission → still v7; 404 = route absent → v6
-        version = error?.httpCode === '403' ? 'v7' : 'v6';
+        const httpCode = String(error?.httpCode ?? '');
+        // 401/403 = v2 route exists but the credential is rejected/forbidden there. Mautic's v2 API
+        // Platform firewall commonly rejects v1-style OAuth2 bearer tokens (Basic auth works). The
+        // route exists, but this credential cannot use it — fall back to v1 for routing.
+        // 404 / parse errors / network = v2 route absent → genuine v6 instance.
+        v2Status = httpCode === '401' || httpCode === '403' ? 'unauthorized' : 'absent';
     }
-    versionCache.set(cacheKey, { version, expiresAt: Date.now() + VERSION_CACHE_TTL_MS });
-    return version;
+    // Routing version: only treat as v7 when v2 is actually usable, so that operations route to the
+    // v1 endpoints (which work under this credential) whenever v2 is unreachable. Owner enrichment,
+    // a v7-only feature, is gated separately on `v2Status === 'usable'`.
+    const version = v2Status === 'usable' ? 'v7' : 'v6';
+    versionCache.set(cacheKey, { version, v2Status, expiresAt: Date.now() + VERSION_CACHE_TTL_MS });
+    return { version, v2Status };
+}
+async function getMauticVersion(context) {
+    return (await detectMauticV2(context)).version;
 }
 exports.getMauticVersion = getMauticVersion;
+/**
+ * Returns whether the Mautic v2 (API Platform) endpoints are usable with the active credential.
+ * Callers use this to decide whether v7-only enrichment is possible and to warn actionably when a
+ * v2 route exists but the credential is rejected there (`unauthorized`).
+ */
+async function getMauticV2Status(context) {
+    return (await detectMauticV2(context)).v2Status;
+}
+exports.getMauticV2Status = getMauticV2Status;
 async function mauticApiRequest(method, endpoint, body = {}, query, uri, headers) {
     const authenticationMethod = this.getNodeParameter('authentication', 0, 'credentials');
     const options = {

package/dist/nodes/MauticAdvanced/ai-tools/runtime.js

@@ -3,6 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runtimeZod = exports.RuntimeDynamicStructuredTool = void 0;
 // nodes/MauticAdvanced/ai-tools/runtime.ts
 const module_1 = require("module");
+/**
+ * Anchor candidates — packages in n8n's dependency tree that can serve as a
+ * createRequire() anchor to resolve @langchain/core/tools and zod from n8n's
+ * own module tree (not this package's bundled devDependency copies).
+ *
+ * IMPORTANT: resolution must NEVER run at module-import time. n8n's
+ * node-directory-loader requires every node file in this package (including
+ * this one) purely to register node metadata, long before any workflow
+ * executes — and it aborts loading the ENTIRE package if any one file throws
+ * while being required. That used to be exactly what happened here: under
+ * pnpm-strict-isolated n8n installs (v2.29.x+) this package is installed
+ * outside n8n's own node_modules tree (e.g. ~/.n8n/nodes/), so neither
+ * anchor below resolves at all — @langchain/classic/@langchain/core are only
+ * reachable from inside @n8n/n8n-nodes-langchain's own isolated pnpm
+ * subtree, which no filesystem-based require.resolve() from here can walk
+ * into. The resulting throw took down the plain, non-AI `mauticAdvanced`
+ * node and its trigger too, not just this AI-tools node.
+ *
+ * Resolution is therefore deferred to first actual use, inside the Proxy
+ * traps below (which only fire when a connected AI tool is invoked at
+ * workflow-execution time via supplyData()). By then, n8n's own Agent/MCP
+ * Trigger machinery has already loaded @langchain/core/tools itself (to run
+ * its own tool-calling logic), so if the anchors still don't resolve, a
+ * require.cache scan finds the exact module instance n8n itself loaded —
+ * which works regardless of install layout.
+ */
 const ANCHOR_CANDIDATES = [
     // primary: @langchain/classic is a direct dep of @n8n/nodes-langchain, stable since n8n 2.4.x.
     // Its @langchain/core peerDep resolves to n8n's hoisted @langchain/core.
@@ -10,25 +36,224 @@ const ANCHOR_CANDIDATES = [
     // secondary: langchain package is in the n8n catalog and also has @langchain/core as peerDep.
     'langchain/agents',
 ];
-// require.resolve() works because n8n loads community nodes within its own module resolution
-// context. If future n8n isolates community node resolution, use
-// require.resolve(candidate, {paths: [n8nPackagePath]}) option.
-let runtimeRequire = null;
-const errors = [];
-for (const candidate of ANCHOR_CANDIDATES) {
+// Memoized ONLY on success — a failed attempt must not permanently disable
+// retries (e.g. the require.cache scan fallback below may only succeed on a
+// later call, once n8n has finished loading its own langchain-dependent
+// nodes).
+let _runtimeReq;
+let _anchorDiagnostic = null;
+function getRuntimeRequire() {
+    if (_runtimeReq)
+        return _runtimeReq;
+    const tried = [];
+    for (const candidate of ANCHOR_CANDIDATES) {
+        try {
+            const resolved = require.resolve(candidate);
+            _runtimeReq = (0, module_1.createRequire)(resolved);
+            _anchorDiagnostic = `resolved via anchor: ${candidate}`;
+            return _runtimeReq;
+        }
+        catch (e) {
+            tried.push(`${candidate}: ${e.message}`);
+        }
+    }
+    _anchorDiagnostic = `Could not resolve LangChain anchor. Tried:\n${tried.join('\n')}`;
+    return undefined;
+}
+/**
+ * Scans Node's process-global module cache (shared across every node_modules
+ * tree in this process, regardless of who loaded what) for an already-loaded
+ * module whose resolved path matches `pathPattern`, returning the first
+ * match whose exports satisfy `validate`. Must be called lazily (not at
+ * module load) — n8n requires node files for registration before any
+ * workflow runs, i.e. before langchain/zod are necessarily loaded into cache.
+ */
+function findCachedExports(pathPattern, validate, excludeKey) {
     try {
-        const resolved = require.resolve(candidate);
-        runtimeRequire = (0, module_1.createRequire)(resolved);
-        break;
+        // require.cache is the public, documented CommonJS alias that points at the exact
+        // same underlying object as the internal Module._cache. It is available directly in
+        // CJS module scope (this file compiles to CJS via tsc), so no require('module') needed.
+        const cache = require.cache;
+        if (!cache)
+            return undefined;
+        for (const key of Object.keys(cache)) {
+            if (!pathPattern.test(key))
+                continue;
+            if (excludeKey && excludeKey(key))
+                continue;
+            const entry = cache[key];
+            if (!entry)
+                continue;
+            const result = validate(entry.exports);
+            if (result !== undefined)
+                return result;
+        }
+    }
+    catch (_e) {
+        // best-effort — require.cache introspection is not guaranteed across Node versions
+    }
+    return undefined;
+}
+let _RuntimeDynamicStructuredTool;
+let _runtimeZod;
+let _langchainLoadError = null;
+let _zodLoadError = null;
+let _zodDiagnostic = null;
+function resolveDynamicStructuredTool() {
+    if (_RuntimeDynamicStructuredTool)
+        return _RuntimeDynamicStructuredTool;
+    const runtimeReq = getRuntimeRequire();
+    if (runtimeReq) {
+        try {
+            const coreTools = runtimeReq('@langchain/core/tools');
+            if (typeof coreTools?.['DynamicStructuredTool'] === 'function') {
+                _RuntimeDynamicStructuredTool = coreTools['DynamicStructuredTool'];
+                return _RuntimeDynamicStructuredTool;
+            }
+        }
+        catch (e) {
+            _langchainLoadError = e.message;
+        }
     }
-    catch (e) {
-        errors.push(`${candidate}: ${e.message}`);
+    // Fallback for pnpm-isolated installs where no filesystem anchor reaches
+    // @langchain/core at all: it is loaded by n8n's own Agent/MCP Trigger
+    // machinery before our supplyData() ever runs, so grab it straight out of
+    // require.cache once it is resident.
+    const cached = findCachedExports(/[\\/]@langchain[\\/]core[\\/]/, (exports) => typeof exports['DynamicStructuredTool'] === 'function'
+        ? exports['DynamicStructuredTool']
+        : undefined);
+    if (cached) {
+        _RuntimeDynamicStructuredTool = cached;
+        _langchainLoadError = null;
     }
+    return _RuntimeDynamicStructuredTool;
 }
-if (!runtimeRequire) {
-    throw new Error(`[runtime.ts] Could not resolve LangChain anchor. Tried:\n${errors.join('\n')}\n` +
-        `Ensure @n8n/nodes-langchain is installed in n8n's node_modules.`);
+function resolveZod() {
+    if (_runtimeZod)
+        return _runtimeZod;
+    // Three-step resolution, in priority order: require.main → anchor → require.cache scan.
+    //
+    // Primary path: resolve zod starting from n8n's own main entry point's module tree
+    // (require.main). For a correctly-installed (non-isolated) setup this lands on n8n's
+    // top-level zod — the exact copy n8n's own normalizeToolSchema does `instanceof ZodType`
+    // against. Even under pnpm-strict isolation this is a DIFFERENT resolution path than this
+    // package's own local require('zod'), so it is far more likely to reach n8n's real copy
+    // (or fail cleanly) than to silently return this package's OWN bundled zod. Resolved
+    // lazily here (NOT at module top level) so node registration never triggers it — that
+    // laziness is the entire point of this fix (#2).
+    //
+    // Only anchor at require.main when it is actually defined. When it is undefined (ESM-
+    // launched n8n, worker_threads / queue-mode workers — exactly the deployment mode #2 was
+    // filed against), there is NO useful main to anchor at: falling back to `__filename` would
+    // anchor at THIS file (mautic's own runtime.js), whose `require.resolve('zod')` lands on
+    // this package's OWN bundled zod — the copy that fails n8n's `instanceof ZodType` check.
+    // So resolve-then-check the path and skip it if it points into this package's own tree,
+    // reusing the same exclusion substring as the cache-scan path below.
+    if (require.main?.filename) {
+        try {
+            const mainReq = (0, module_1.createRequire)(require.main.filename);
+            const resolvedPath = mainReq.resolve('zod');
+            if (!resolvedPath.includes('n8n-nodes-mautic-advanced')) {
+                _runtimeZod = mainReq('zod');
+                if (_runtimeZod) {
+                    _zodDiagnostic = 'resolved zod via require.main';
+                    _zodLoadError = null;
+                    return _runtimeZod;
+                }
+            }
+        }
+        catch (e) {
+            _zodLoadError = e.message;
+        }
+    }
+    // Secondary path: the existing @langchain/classic / langchain anchor. Same resolve-then-
+    // check exclusion for defense-in-depth consistency — very unlikely to ever resolve into
+    // this package's own tree, but structurally guarded identically to the other two paths.
+    const runtimeReq = getRuntimeRequire();
+    if (runtimeReq) {
+        try {
+            const resolvedPath = runtimeReq.resolve('zod');
+            if (!resolvedPath.includes('n8n-nodes-mautic-advanced')) {
+                _runtimeZod = runtimeReq('zod');
+                if (_runtimeZod) {
+                    _zodDiagnostic = 'resolved zod via anchor';
+                    _zodLoadError = null;
+                    return _runtimeZod;
+                }
+            }
+        }
+        catch (e) {
+            _zodLoadError = e.message;
+        }
+    }
+    // Tertiary path: scan require.cache for an already-resident zod once neither
+    // filesystem resolution reaches it (pnpm-strict-isolated installs). The path regex is
+    // narrowed to zod's own entry-point directories (lib/dist/index/v3/v4) so it never
+    // matches zod-adjacent package names (e.g. zod-to-json-schema). Validate the exports
+    // look like zod via `ZodType` (the class n8n's normalizeToolSchema does `instanceof`
+    // against — the meaningful correctness signal) plus the `object` factory our
+    // schema-generator calls.
+    //
+    // Exclusion guard: this package declares zod as a REAL dependency and imports it at
+    // node-registration time (schema-generator.ts), so this package's OWN bundled zod is
+    // ALWAYS resident in require.cache — potentially earlier in iteration order than n8n's.
+    // We specifically want a DIFFERENT copy (n8n's), because a self-bundled copy would fail
+    // n8n's `instanceof ZodType` class-identity check. So skip any cache key belonging to
+    // this package's own bundled zod. (The pathPattern has already matched the zod segment,
+    // so a package-name match on the key is sufficient and robust to both nested
+    // `.../n8n-nodes-mautic-advanced/node_modules/zod/...` and flatter install layouts.)
+    const cached = findCachedExports(/[\\/]zod[\\/](lib|dist|index|v3|v4)/, (exports) => typeof exports['ZodType'] === 'function' && typeof exports['object'] === 'function'
+        ? exports
+        : undefined, (key) => key.includes('n8n-nodes-mautic-advanced'));
+    if (cached) {
+        _runtimeZod = cached;
+        _zodLoadError = null;
+        _zodDiagnostic = 'resolved zod via require.cache scan (pnpm-isolated install)';
+    }
+    return _runtimeZod;
 }
-const coreTools = runtimeRequire('@langchain/core/tools');
-exports.RuntimeDynamicStructuredTool = coreTools['DynamicStructuredTool'];
-exports.runtimeZod = runtimeRequire('zod');
+// IMPORTANT: Proxy target MUST be `function () {}`, not `{}`.
+// ECMAScript spec §10.5.13: a Proxy only has [[Construct]] if its target does.
+// Plain objects lack [[Construct]], so `new Proxy({}, ...)` throws
+// "is not a constructor" before the construct trap ever fires.
+exports.RuntimeDynamicStructuredTool = new Proxy(function () { }, {
+    construct(_target, args) {
+        const ctor = resolveDynamicStructuredTool();
+        if (!ctor) {
+            throw new Error(`[MauticAdvancedAiTools] Could not resolve LangChain's DynamicStructuredTool. ` +
+                `Ensure @n8n/nodes-langchain is installed in n8n's node_modules.` +
+                (_anchorDiagnostic ? ` Diagnostic: ${_anchorDiagnostic}` : '') +
+                (_langchainLoadError ? ` Load error: ${_langchainLoadError}` : ''));
+        }
+        return new ctor(...args);
+    },
+    get(_target, prop) {
+        const ctor = resolveDynamicStructuredTool();
+        if (ctor) {
+            return ctor[prop];
+        }
+        return undefined;
+    },
+});
+exports.runtimeZod = new Proxy({}, {
+    get(_target, prop) {
+        // Guard: frameworks probe Symbol.toPrimitive, Symbol.toStringTag, .then
+        // (Promise thenable), and .constructor. Throwing on these causes
+        // misleading errors during structural inspection.
+        if (typeof prop === 'symbol' || prop === 'then' || prop === 'constructor')
+            return undefined;
+        const z = resolveZod();
+        if (!z) {
+            throw new Error(`[MauticAdvancedAiTools] Could not resolve zod (accessing .${String(prop)}) ` +
+                `via require.main, LangChain anchor, or require.cache scan. ` +
+                `Ensure @n8n/nodes-langchain is installed in n8n's node_modules.` +
+                (_zodDiagnostic
+                    ? ` Diagnostic: ${_zodDiagnostic}`
+                    : _anchorDiagnostic
+                        ? ` Diagnostic: ${_anchorDiagnostic}`
+                        : '') +
+                (_zodLoadError ? ` Load error: ${_zodLoadError}` : ''));
+        }
+        return z[prop];
+    },
+});

package/dist/nodes/MauticAdvanced/operations/CompanyOperations.js

@@ -223,40 +223,86 @@ async function updateCompany(context, itemIndex) {
     }
     return result;
 }
-// Extract owner from a v7 company object. Requests without Accept: application/json
-// return JSON-LD where the owner IRI (/api/v2/users/{id}) lets us resolve the user ID.
+// Logged once per Get/Get Many call when the v2 API exists but rejected the credential, so the
+// reason owner is null is visible in the n8n logs instead of failing silently.
+const V2_UNAUTHORIZED_OWNER_WARNING = 'Mautic company owner enrichment skipped: the v2 API (API Platform) rejected this credential (401/403). ' +
+    'Owner is a v7-only field that requires an auth method the v2 API accepts — Basic auth is confirmed working; ' +
+    'OAuth2 depends on the Mautic server allowing v2 access for the token. Returning owner: null. ' +
+    'Switch the credential to Basic auth (or enable v2 access for OAuth2 on the Mautic server) to populate owner.';
+// Force API Platform to return JSON-LD/Hydra so the owner is serialised with its `@id` IRI
+// (/api/v2/users/{id}). The default `application/json` representation omits the IRI, leaving only
+// FormEntity fields (isPublished/dateAdded/dateModified) with no way to resolve the owner's user ID.
+const LD_JSON_HEADERS = { Accept: 'application/ld+json' };
+// Extract the owner's user ID from a v7 (JSON-LD) company object.
+// JSON-LD embeds the owner with `@id: "/api/v2/users/{id}"`; some shapes also expose a plain `id`.
 function extractOwnerFromV7(v7Item) {
-    if (!v7Item || v7Item.owner === null || v7Item.owner === undefined)
+    const owner = v7Item?.owner;
+    if (owner === null || owner === undefined)
         return null;
-    const iri = v7Item.owner?.['@id'];
+    // Owner may be embedded as an object (with @id), or serialised as a bare IRI string.
+    const iri = typeof owner === 'string' ? owner : owner['@id'];
     if (iri) {
         const match = /\/(\d+)$/.exec(iri);
         if (match)
             return { id: Number(match[1]) };
     }
-    // No @id (non-Hydra response) — return partial FormEntity data as-is
-    return v7Item.owner;
+    if (typeof owner === 'object' && owner.id !== undefined && owner.id !== null) {
+        return { id: Number(owner.id) };
+    }
+    // No IRI and no id (plain-JSON owner) — return the partial FormEntity data as-is
+    return owner;
+}
+// Requested page size. NOTE: stock Mautic disables client control of page size
+// (pagination_client_items_per_page = false) and hard-caps at 30, so this is currently a no-op on
+// default installs — the server returns 30/page regardless. Kept because it is harmless and engages
+// automatically if an instance enables client page size; termination does not rely on it (we count
+// actual items returned, see the loop below).
+const V7_OWNER_PAGE_SIZE = 100;
+// Backstop only — the loop normally exits when every needed owner is found or the collection ends.
+const V7_OWNER_MAX_PAGES = 1000;
+// Read the collection members from a v2 list response, tolerating both the legacy Hydra key
+// (`hydra:member`) and the newer API Platform 4.x form (`member`), plus a bare JSON array.
+function getV2CollectionItems(response) {
+    if (Array.isArray(response))
+        return response;
+    return response?.['hydra:member'] ?? response?.member ?? [];
+}
+function getV2TotalItems(response) {
+    const total = response?.['hydra:totalItems'] ?? response?.totalItems;
+    return typeof total === 'number' ? total : undefined;
 }
-// Fetch all companies from v7 and return a map of companyId → owner.
-// Called without Accept: application/json so the response includes JSON-LD @id on the owner.
-async function buildV7OwnerMap(context) {
+// Build a map of companyId → owner for ONLY the given company IDs, by paging the v2 collection
+// (JSON-LD, so the owner `@id` IRI is present) and stopping as soon as every needed owner is
+// resolved. Mautic's v2 collection defaults to ORDER BY id ASC, so a limited Get Many (whose v1
+// result is the lowest ids, also id ASC) resolves its owners in the first page(s) rather than
+// scanning the whole instance. Returns an empty map when no IDs are needed.
+async function buildV7OwnerMap(context, neededIds) {
     const ownerMap = new Map();
+    if (neededIds.size === 0)
+        return ownerMap;
     let page = 1;
-    const MAX_PAGES = 100;
-    while (page <= MAX_PAGES) {
-        const response = await (0, ApiHelpers_1.makeApiRequest)(context, 'GET', '/v2/companies', {}, { page });
-        const items = Array.isArray(response)
-            ? response
-            : (response?.['hydra:member'] ?? []);
+    let itemsSeen = 0;
+    while (page <= V7_OWNER_MAX_PAGES) {
+        const response = await (0, ApiHelpers_1.makeApiRequest)(context, 'GET', '/v2/companies', {}, 
+        // order[id]=asc is a no-op on stock Mautic (no OrderFilter on Company), but the v2 collection
+        // already defaults to ORDER BY id ASC, so this just makes the relied-on ordering explicit.
+        { page, itemsPerPage: V7_OWNER_PAGE_SIZE, 'order[id]': 'asc' }, undefined, LD_JSON_HEADERS);
+        const items = getV2CollectionItems(response);
         if (!items.length)
             break;
+        itemsSeen += items.length;
         for (const item of items) {
             const id = Number(item.id);
-            if (id)
+            if (id && neededIds.has(id))
                 ownerMap.set(id, extractOwnerFromV7(item));
         }
-        const total = response?.['hydra:totalItems'];
-        if (typeof total === 'number' && ownerMap.size >= total)
+        // Stop once every needed owner is resolved.
+        if (ownerMap.size >= neededIds.size)
+            break;
+        // Stop at the end of the collection (covers needed IDs that no longer exist). Compare against
+        // the actual number of items seen, not an assumed page size — the server may cap itemsPerPage.
+        const total = getV2TotalItems(response);
+        if (total !== undefined && itemsSeen >= total)
             break;
         page++;
     }
@@ -265,20 +311,26 @@ async function buildV7OwnerMap(context) {
 async function getCompany(context, itemIndex) {
     const companyId = (0, ApiHelpers_1.getRequiredParam)(context, 'companyId', itemIndex);
     const simple = (0, ApiHelpers_1.getOptionalParam)(context, 'simple', itemIndex, false);
-    const mauticVersion = await (0, GenericFunctions_1.getMauticVersion)(context);
+    const v2Status = await (0, GenericFunctions_1.getMauticV2Status)(context);
     // v1: custom fields via fields.all
     const v1Response = await (0, ApiHelpers_1.makeApiRequest)(context, 'GET', `/companies/${companyId}`);
     let result = v1Response.company;
-    if (mauticVersion === 'v7') {
+    if (v2Status === 'usable') {
         try {
-            // No Accept: application/json — JSON-LD response includes owner @id for user ID extraction
-            const v7Company = await (0, ApiHelpers_1.makeApiRequest)(context, 'GET', `/v2/companies/${companyId}`);
+            // JSON-LD response includes the owner @id IRI for user-ID extraction
+            const v7Company = await (0, ApiHelpers_1.makeApiRequest)(context, 'GET', `/v2/companies/${companyId}`, {}, {}, undefined, LD_JSON_HEADERS);
             result = { ...result, owner: extractOwnerFromV7(v7Company) };
         }
-        catch {
-            // enrichment failed — proceed with v1 data (owner: null)
+        catch (error) {
+            // Enrichment failed unexpectedly (v2 was usable at probe time). Surface it instead of
+            // silently degrading to owner: null, so the cause is visible in the logs.
+            context.logger.warn(`Mautic company owner enrichment failed for company ${companyId}: ${error?.message ?? error}. Returning owner: null.`);
         }
     }
+    else if (v2Status === 'unauthorized') {
+        // v2 route exists but the credential is rejected there — owner cannot be enriched. Warn once.
+        context.logger.warn(V2_UNAUTHORIZED_OWNER_WARNING);
+    }
     if (simple)
         result = toSimpleCompany(result);
     return (0, DataHelpers_1.convertNumericStrings)(result);
@@ -286,7 +338,7 @@ async function getCompany(context, itemIndex) {
 async function getAllCompanies(context, itemIndex) {
     const returnAll = (0, ApiHelpers_1.getOptionalParam)(context, 'returnAll', itemIndex, false);
     const simple = (0, ApiHelpers_1.getOptionalParam)(context, 'simple', itemIndex, false);
-    const mauticVersion = await (0, GenericFunctions_1.getMauticVersion)(context);
+    const v2Status = await (0, GenericFunctions_1.getMauticV2Status)(context);
     const additionalFields = (0, ApiHelpers_1.getOptionalParam)(context, 'additionalFields', itemIndex, {});
     const qs = (0, DataHelpers_1.buildQueryFromOptions)(additionalFields);
     if (!qs.orderBy)
@@ -305,19 +357,26 @@ async function getAllCompanies(context, itemIndex) {
         const response = await (0, ApiHelpers_1.makeApiRequest)(context, 'GET', '/companies', {}, qs);
         responseData = (response.companies ? Object.values(response.companies) : []);
     }
-    if (mauticVersion === 'v7') {
+    if (v2Status === 'usable' && responseData.length > 0) {
         try {
-            // v7 enrichment: overlay owner on each v1 result using a single paginated v7 fetch
-            const ownerMap = await buildV7OwnerMap(context);
+            // v7 enrichment: resolve owners for ONLY the companies v1 returned, then overlay them.
+            const neededIds = new Set(responseData.map((company) => Number(company.id)).filter((id) => Number.isFinite(id)));
+            const ownerMap = await buildV7OwnerMap(context, neededIds);
             responseData = responseData.map((company) => ({
                 ...company,
                 owner: ownerMap.get(Number(company.id)) ?? null,
             }));
         }
-        catch {
-            // enrichment failed — proceed with v1 data (owner: null)
+        catch (error) {
+            // Enrichment failed unexpectedly (v2 was usable at probe time). Surface it instead of
+            // silently degrading to owner: null, so the cause is visible in the logs.
+            context.logger.warn(`Mautic company owner enrichment failed for Get Many: ${error?.message ?? error}. Returning owner: null for all rows.`);
         }
     }
+    else if (v2Status === 'unauthorized') {
+        // v2 route exists but the credential is rejected there — owner cannot be enriched. Warn once.
+        context.logger.warn(V2_UNAUTHORIZED_OWNER_WARNING);
+    }
     if (simple) {
         responseData = responseData.map((item) => toSimpleCompany(item));
     }

package/dist/nodes/MauticAdvanced/operations/ContactOperations.js

@@ -191,12 +191,34 @@ async function getAllContacts(context, itemIndex) {
         if (filterExpr)
             searchParts.push(filterExpr);
     }
-    // Owner filter (always OR for multiple owners - a contact can only have one owner)
+    // Owner filter — applied CLIENT-SIDE on the contact's owner.id.
+    // Mautic's `owner:` search command matches the owner's first/last NAME (LIKE), not the user id,
+    // so sending `owner:<id>` (what the Owner(s) dropdown provides) silently returns nothing. The v1
+    // contact body already includes `owner.id`, so we filter on that instead.
     const owners = options.owners;
-    if (Array.isArray(owners) && owners.length > 0) {
-        const filterExpr = buildSearchFilterExpression(owners, 'owner', 'any');
-        if (filterExpr)
-            searchParts.push(filterExpr);
+    const ownerIdFilter = Array.isArray(owners) && owners.length > 0
+        ? new Set(owners.map((o) => Number(o)).filter((n) => Number.isFinite(n)))
+        : undefined;
+    // Do-Not-Contact filter — applied SERVER-SIDE via Mautic's `dnc:` search command, so only
+    // matching contacts are fetched (replaces the previous client-side page-and-discard scan).
+    // `dnc:<channel>` = IS on DNC for that channel; `dnc:any` = on any channel.
+    const emailDncOnly = options.emailDncOnly === true;
+    const smsDncOnly = options.smsDncOnly === true;
+    const anyDncOnly = options.anyDncOnly === true;
+    if (anyDncOnly) {
+        searchParts.push('dnc:any');
+    }
+    else {
+        const dncTokens = [];
+        if (emailDncOnly)
+            dncTokens.push('dnc:email');
+        if (smsDncOnly)
+            dncTokens.push('dnc:sms');
+        // Multiple specific channels = union (on email OR sms DNC); one token if only one is set.
+        if (dncTokens.length === 1)
+            searchParts.push(dncTokens[0]);
+        else if (dncTokens.length > 1)
+            searchParts.push(dncTokens.join(' OR '));
     }
     // Stage filter (always OR for multiple stages - a contact can only be in one stage)
     const stages = options.stages;
@@ -241,23 +263,19 @@ async function getAllContacts(context, itemIndex) {
         }
     }
     let responseData;
-    const emailDncOnly = options.emailDncOnly === true;
-    const smsDncOnly = options.smsDncOnly === true;
-    const anyDncOnly = options.anyDncOnly === true;
-    const useDncPostFilter = emailDncOnly || smsDncOnly || anyDncOnly;
-    if (useDncPostFilter) {
+    if (ownerIdFilter) {
+        // Owner filter has no server-side equivalent, so page through the (already server-filtered)
+        // results and keep only those whose owner.id matches, until the limit is met or results run out.
         const limit = returnAll ? undefined : (0, ApiHelpers_1.getOptionalParam)(context, 'limit', itemIndex, 30);
-        responseData = await getContactsWithDncFilter(context, qs, options, limit);
+        responseData = await getContactsWithClientFilter(context, qs, (contact) => ownerIdFilter.has(Number(contact?.owner?.id)), limit);
+    }
+    else if (returnAll) {
+        responseData = await (0, ApiHelpers_1.makePaginatedRequest)(context, 'contacts', 'GET', '/contacts', {}, qs);
     }
     else {
-        if (returnAll) {
-            responseData = await (0, ApiHelpers_1.makePaginatedRequest)(context, 'contacts', 'GET', '/contacts', {}, qs);
-        }
-        else {
-            qs.limit = (0, ApiHelpers_1.getOptionalParam)(context, 'limit', itemIndex, 30);
-            const response = await (0, ApiHelpers_1.makeApiRequest)(context, 'GET', '/contacts', {}, qs);
-            responseData = response.contacts ? Object.values(response.contacts) : [];
-        }
+        qs.limit = (0, ApiHelpers_1.getOptionalParam)(context, 'limit', itemIndex, 30);
+        const response = await (0, ApiHelpers_1.makeApiRequest)(context, 'GET', '/contacts', {}, qs);
+        responseData = response.contacts ? Object.values(response.contacts) : [];
     }
     const processedData = (0, DataHelpers_1.processContactFields)(responseData, options, options.fieldsToReturn);
     return (0, DataHelpers_1.convertNumericStrings)(processedData);
@@ -620,34 +638,22 @@ function addContactFields(body, fields) {
         Object.assign(body, data);
     }
 }
-async function getContactsWithDncFilter(context, qs, options, limit) {
-    const emailDncOnly = options.emailDncOnly === true;
-    const smsDncOnly = options.smsDncOnly === true;
-    const anyDncOnly = options.anyDncOnly === true;
+// Page through /contacts (already narrowed by any server-side search in `qs`) and keep only the
+// contacts that satisfy `predicate`, stopping once `limit` matches are collected or results run out.
+// Used for filters that have no server-side equivalent (e.g. owner-by-id).
+async function getContactsWithClientFilter(context, qs, predicate, limit) {
     const requestedStart = Number(qs.start ?? 0);
     const maxResults = typeof limit === 'number' && limit > 0 ? Math.floor(limit) : undefined;
     const contacts = [];
     let remaining = maxResults;
     let currentStart = Number.isFinite(requestedStart) && requestedStart > 0 ? requestedStart : 0;
     while (remaining === undefined || remaining > 0) {
-        const pageLimit = remaining === undefined
-            ? GenericFunctions_1.DEFAULT_MAUTIC_PAGE_SIZE
-            : Math.min(remaining, GenericFunctions_1.DEFAULT_MAUTIC_PAGE_SIZE);
+        // Always fetch full pages so the scan terminates promptly; `remaining` only caps what we keep.
+        const pageLimit = GenericFunctions_1.DEFAULT_MAUTIC_PAGE_SIZE;
         const pageQs = { ...qs, start: currentStart, limit: pageLimit };
         const pageResponse = await (0, ApiHelpers_1.makeApiRequest)(context, 'GET', '/contacts', {}, pageQs);
         const pageContacts = pageResponse.contacts ? Object.values(pageResponse.contacts) : [];
-        const filtered = pageContacts.filter((contact) => {
-            const dnc = contact.doNotContact || [];
-            const hasEmailDnc = dnc.some((d) => d.channel === 'email');
-            const hasSmsDnc = dnc.some((d) => d.channel === 'sms');
-            if (emailDncOnly)
-                return hasEmailDnc;
-            if (smsDncOnly)
-                return hasSmsDnc;
-            if (anyDncOnly)
-                return hasEmailDnc || hasSmsDnc;
-            return true;
-        });
+        const filtered = pageContacts.filter(predicate);
         const toAdd = remaining === undefined ? filtered : filtered.slice(0, remaining);
         contacts.push(...toAdd);
         if (remaining !== undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-mautic-advanced",
-  "version": "1.3.2",
+  "version": "1.3.9",
   "description": "Enhanced n8n node for Mautic with comprehensive API coverage including tags, campaigns, categories, and advanced contact management",
   "keywords": [
     "n8n",
@@ -72,5 +72,13 @@
     "@types/change-case": "^0.0.30",
     "change-case": "^5.4.4",
     "zod": "^3.22.0"
+  },
+  "peerDependencies": {
+    "@langchain/core": "*"
+  },
+  "peerDependenciesMeta": {
+    "@langchain/core": {
+      "optional": true
+    }
   }
 }