eslint-plugin-sfmc 3.0.0 → 4.0.0

package/src/rules/hbs/no-mcn-unsupported.js

@@ -0,0 +1,164 @@
+import { getHelper, bindingLookup } from 'handlebars-data';
+
+import { simpleHelperName, isInvocation, BINDING_PATTERN } from './_shared.js';
+
+/**
+ * Flags Handlebars helpers and `{!$...}` data bindings that are not available in
+ * the targeted Marketing Cloud Next API version.
+ *
+ * Each helper/binding carries an `mcnSince` value = the MCN API version it first
+ * became available in, or `null`/unset when it was never supported in MCN.
+ *
+ * `apiVersion` semantics (shared with the AMPscript and SSJS MCN rules):
+ *   - Not set / null: flag every helper/binding whose `mcnSince` is null/unset.
+ *     Any item supported at some point in MCN (numeric `mcnSince`) passes.
+ *   - Set to N: flag everything the null case flags, PLUS everything whose
+ *     `mcnSince` is greater than N (too new for the target). Pass iff
+ *     `mcnSince != null && mcnSince <= N`.
+ *
+ * The MCN Handlebars catalog currently has no null-`mcnSince` items, so with no
+ * `apiVersion` set nothing is flagged; e.g. `apiVersion: 65` flags the helpers
+ * introduced in 67, and `apiVersion: 40` flags every helper and binding.
+ */
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description:
+                'Disallow Handlebars helpers and bindings not available in the targeted Marketing Cloud Next API version',
+            recommended: true,
+        },
+        messages: {
+            helperNotSupported: "'{{name}}' is not supported in Marketing Cloud Next Handlebars.",
+            helperTooNew:
+                "'{{name}}' was introduced in Marketing Cloud Next API version {{since}}, which is newer than the targeted version {{target}}.",
+            bindingNotSupported: "'{{token}}' is not supported in Marketing Cloud Next Handlebars.",
+            bindingTooNew:
+                "'{{token}}' was introduced in Marketing Cloud Next API version {{since}}, which is newer than the targeted version {{target}}.",
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    apiVersion: {
+                        type: 'number',
+                        description:
+                            'The targeted Marketing Cloud Next API version (e.g. 65 = Winter \u{2019}26, 67 = Summer \u{2019}26). Helpers and bindings newer than this are flagged.',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+
+    create(context) {
+        const options = context.options[0] ?? {};
+        const apiVersion = typeof options.apiVersion === 'number' ? options.apiVersion : null;
+
+        /**
+         * Returns true when an item's `mcnSince` fails the target: it is null
+         * (never supported) or newer than the targeted API version.
+         *
+         * @param {number | null | undefined} since - The item's `mcnSince`.
+         * @returns {boolean} True when the item must be flagged.
+         */
+        function isUnsupported(since) {
+            if (since === null || since === undefined) {
+                return true;
+            }
+            return apiVersion !== null && since > apiVersion;
+        }
+
+        /**
+         * Reports a helper when it is unavailable for the target.
+         *
+         * @param {object} node - The AST node.
+         * @param {string | null} helperName - The simple helper name, when any.
+         * @returns {void}
+         */
+        function checkHelper(node, helperName) {
+            if (!helperName) {
+                return;
+            }
+            const helper = getHelper(helperName);
+            if (!helper) {
+                return;
+            }
+            const since = helper.mcnSince ?? null;
+            if (!isUnsupported(since)) {
+                return;
+            }
+            if (since === null) {
+                context.report({
+                    node,
+                    messageId: 'helperNotSupported',
+                    data: { name: helper.name },
+                });
+            } else {
+                context.report({
+                    node,
+                    messageId: 'helperTooNew',
+                    data: {
+                        name: helper.name,
+                        since: String(since),
+                        target: String(apiVersion),
+                    },
+                });
+            }
+        }
+
+        /**
+         * Checks an inline mustache or subexpression helper invocation.
+         *
+         * @param {object} node - The AST node.
+         * @returns {void}
+         */
+        function checkInline(node) {
+            if (isInvocation(node)) {
+                checkHelper(node, simpleHelperName(node.path));
+            }
+        }
+
+        return {
+            MustacheStatement: checkInline,
+            SubExpression: checkInline,
+            HbsBlockStatement(node) {
+                checkHelper(node, simpleHelperName(node.path));
+            },
+            'Program:exit'() {
+                const sourceCode = context.sourceCode ?? context.getSourceCode();
+                const text = sourceCode.getText();
+                BINDING_PATTERN.lastIndex = 0;
+                let match;
+                while ((match = BINDING_PATTERN.exec(text)) !== null) {
+                    const bindingName = match[1];
+                    const binding = bindingLookup.get(bindingName.toLowerCase());
+                    // Unknown bindings are handled by hbs-no-unknown-binding.
+                    if (!binding) {
+                        continue;
+                    }
+                    const since = binding.mcnSince ?? null;
+                    if (!isUnsupported(since)) {
+                        continue;
+                    }
+                    const token = match[0];
+                    const start = match.index;
+                    const end = start + token.length;
+                    const loc = {
+                        start: sourceCode.getLocFromIndex(start),
+                        end: sourceCode.getLocFromIndex(end),
+                    };
+                    if (since === null) {
+                        context.report({ loc, messageId: 'bindingNotSupported', data: { token } });
+                    } else {
+                        context.report({
+                            loc,
+                            messageId: 'bindingTooNew',
+                            data: { token, since: String(since), target: String(apiVersion) },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};

package/src/rules/ssjs/no-mcn-unsupported.js

@@ -0,0 +1,182 @@
+/**
+ * Rule: ssjs-no-mcn-unsupported
+ *
+ * Server-Side JavaScript as a whole is not available in Marketing Cloud Next.
+ * When targeting MCN, every SSJS API usage must be rewritten in AMPscript or
+ * Handlebars. This rule flags all SSJS API surface usage:
+ *
+ *   - Platform.<...>()              — any Platform namespace call (incl. Platform.Load)
+ *   - HTTP.<method>()               — any HTTP call
+ *   - <coreVar>.<method>()          — Core Library instance calls
+ *   - <wsproxyVar>.<method>()       — WSProxy instance calls
+ *   - new Script.Util.WSProxy()     — WSProxy construction
+ *
+ * The `apiVersion` option is accepted for parity with the AMPscript and
+ * Handlebars MCN rules, but currently has no effect: no MCN API version
+ * supports SSJS, so it always flags all SSJS usage.
+ */
+
+import { coreObjectNames } from 'ssjs-data';
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description:
+                'Disallow all Server-Side JavaScript API usage, which is unavailable in Marketing Cloud Next',
+        },
+        messages: {
+            ssjsNotSupportedInMcn:
+                'SSJS is not supported in Marketing Cloud Next. Rewrite this code in AMPscript or Handlebars.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    apiVersion: {
+                        type: 'number',
+                        description:
+                            'Targeted Marketing Cloud Next API version. Accepted for parity with the other MCN rules; currently has no effect because no version supports SSJS.',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+
+    create(context) {
+        // Track variable name → Core Library type name (assigned via TypeName.Init())
+        const coreVariables = new Map();
+        // Track variable names assigned via new Script.Util.WSProxy()
+        const wsproxyVariables = new Set();
+
+        return {
+            VariableDeclaration(node) {
+                for (const declaration of node.declarations) {
+                    if (
+                        !declaration.init ||
+                        !declaration.id ||
+                        declaration.id.type !== 'Identifier'
+                    ) {
+                        continue;
+                    }
+                    const coreType = getCoreInitType(declaration.init);
+                    if (coreType) {
+                        coreVariables.set(declaration.id.name, coreType);
+                    }
+                    if (isWSProxyConstructor(declaration.init)) {
+                        wsproxyVariables.add(declaration.id.name);
+                    }
+                }
+            },
+
+            AssignmentExpression(node) {
+                if (node.left.type !== 'Identifier') {
+                    return;
+                }
+                const coreType = getCoreInitType(node.right);
+                if (coreType) {
+                    coreVariables.set(node.left.name, coreType);
+                }
+                if (isWSProxyConstructor(node.right)) {
+                    wsproxyVariables.add(node.left.name);
+                }
+            },
+
+            NewExpression(node) {
+                if (isWSProxyConstructor(node)) {
+                    context.report({ node: node.callee, messageId: 'ssjsNotSupportedInMcn' });
+                }
+            },
+
+            CallExpression(node) {
+                const callee = node.callee;
+                if (callee.type !== 'MemberExpression' || callee.property.type !== 'Identifier') {
+                    return;
+                }
+
+                // Traverse the object chain to find the root identifier
+                // (handles de.Rows.Retrieve() where root is `de`,
+                //  and Platform.Function.X() where root is `Platform`).
+                let rootNode = callee.object;
+                while (rootNode.type === 'MemberExpression') {
+                    rootNode = rootNode.object;
+                }
+                if (rootNode.type !== 'Identifier') {
+                    return;
+                }
+                const rootName = rootNode.name;
+
+                const isSfmcApiCall =
+                    rootName === 'Platform' ||
+                    rootName === 'HTTP' ||
+                    coreVariables.has(rootName) ||
+                    wsproxyVariables.has(rootName);
+
+                if (isSfmcApiCall) {
+                    context.report({
+                        node: callee.property,
+                        messageId: 'ssjsNotSupportedInMcn',
+                    });
+                }
+            },
+        };
+    },
+};
+
+/**
+ * If `node` is a Core Library Init call (e.g. `DataExtension.Init("key")`),
+ * return the Core Library type name; otherwise return null.
+ *
+ * @param {import('eslint').Rule.Node} node - AST node to inspect
+ * @returns {string | null} Core Library type name, or null when not a Core Library Init call
+ */
+function getCoreInitType(node) {
+    if (!node || node.type !== 'CallExpression') {
+        return null;
+    }
+    const callee = node.callee;
+    if (callee.type !== 'MemberExpression') {
+        return null;
+    }
+    if (callee.property.type !== 'Identifier' || callee.property.name !== 'Init') {
+        return null;
+    }
+    if (callee.object.type === 'Identifier' && coreObjectNames.has(callee.object.name)) {
+        return callee.object.name;
+    }
+    if (
+        callee.object.type === 'MemberExpression' &&
+        callee.object.object.type === 'Identifier' &&
+        callee.object.property.type === 'Identifier'
+    ) {
+        const fullName = `${callee.object.object.name}.${callee.object.property.name}`;
+        if (coreObjectNames.has(fullName)) {
+            return fullName;
+        }
+    }
+    return null;
+}
+
+/**
+ * Returns true if `node` is `new Script.Util.WSProxy()`.
+ *
+ * @param {import('eslint').Rule.Node} node - AST node to inspect
+ * @returns {boolean} true when the node is a WSProxy constructor call
+ */
+function isWSProxyConstructor(node) {
+    if (!node || node.type !== 'NewExpression') {
+        return false;
+    }
+    const c = node.callee;
+    return (
+        c.type === 'MemberExpression' &&
+        c.property.type === 'Identifier' &&
+        c.property.name === 'WSProxy' &&
+        c.object.type === 'MemberExpression' &&
+        c.object.property.type === 'Identifier' &&
+        c.object.property.name === 'Util' &&
+        c.object.object.type === 'Identifier' &&
+        c.object.object.name === 'Script'
+    );
+}

package/src/rules/ssjs/no-unknown-function.js

@@ -49,29 +49,11 @@ export default {
             unknownCoreMethod:
                 "'{{method}}' is not a known method of {{objectType}}. Available methods: {{available}}.",
             unknownWsproxyMethod: "'{{name}}' is not a recognized WSProxy method.",
-            ssjsNotSupportedInMcn:
-                'SSJS is not supported in Marketing Cloud Next. Use AMPscript instead.',
         },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    target: {
-                        type: 'string',
-                        enum: ['engagement', 'next'],
-                        description:
-                            "Target platform. Set to 'next' to flag all SSJS API calls as unsupported in Marketing Cloud Next.",
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
+        schema: [],
     },
 
     create(context) {
-        const options = context.options[0] ?? {};
-        const isTargetNext = options.target === 'next';
-
         // Track variable name → Core Library type name (assigned via TypeName.Init())
         const coreVariables = new Map();
         // Track variable names assigned via new Script.Util.WSProxy()
@@ -122,36 +104,6 @@ export default {
 
                 const methodName = property.name;
 
-                // ── MCN target: flag all SSJS API calls as unsupported ────────
-                if (isTargetNext) {
-                    // Only report on Platform.<NS>.<method>(), HTTP.<method>(),
-                    // Core Library instance calls, or WSProxy calls — not bare JS.
-                    const isPlatformCall =
-                        callee.object.type === 'MemberExpression' &&
-                        callee.object.object.type === 'Identifier' &&
-                        callee.object.object.name === 'Platform';
-                    const isHttpCall =
-                        callee.object.type === 'Identifier' && callee.object.name === 'HTTP';
-
-                    // Traverse the object chain to find the root identifier
-                    // (handles de.Rows.Retrieve() where root is `de`)
-                    let rootNode = callee.object;
-                    while (rootNode.type === 'MemberExpression') {
-                        rootNode = rootNode.object;
-                    }
-                    const isInstanceCall =
-                        rootNode.type === 'Identifier' &&
-                        (coreVariables.has(rootNode.name) || wsproxyVariables.has(rootNode.name));
-
-                    if (isPlatformCall || isHttpCall || isInstanceCall) {
-                        context.report({
-                            node: property,
-                            messageId: 'ssjsNotSupportedInMcn',
-                        });
-                        return;
-                    }
-                }
-
                 // ── Platform.<NS>.<method>() ──────────────────────────────────
                 if (
                     callee.object.type === 'MemberExpression' &&

package/src/rules/ssjs/ssjs-core-method-arity.js

@@ -135,6 +135,28 @@ export default {
                             callee.property,
                         );
                     }
+                    return;
+                }
+
+                // Instance sub-path: de.Rows.Add(...) where `de` is a tracked
+                // DataExtension.Init(...) instance. Substitute the instance's
+                // core type for the leftmost identifier and resolve the class key.
+                if (objectPath) {
+                    const segments = objectPath.split('.');
+                    const rootCoreType = coreVariables.get(segments[0]);
+                    if (rootCoreType) {
+                        const resolvedPath = [rootCoreType, ...segments.slice(1)].join('.');
+                        const classLookup = coreMethodArityLookup.get(resolvedPath.toLowerCase());
+                        if (classLookup) {
+                            const entry = classLookup.get(methodName.toLowerCase());
+                            checkArity(
+                                entry,
+                                node.arguments,
+                                `${resolvedPath}.${methodName}`,
+                                callee.property,
+                            );
+                        }
+                    }
                 }
             },
         };

package/docs/rules/hbs/helper-too-new-for-target.md

@@ -1,62 +0,0 @@
-# `sfmc/hbs-helper-too-new-for-target`
-
-> Disallow Handlebars helpers newer than the targeted Marketing Cloud Next API version.
-
-| | |
-|---|---|
-| **Type** | `problem` |
-| **Default severity** | `off` (opt-in — requires the `apiVersion` option) |
-| **Fixable** | — |
-
-## Why This Rule Exists
-
-Marketing Cloud Next ships new Handlebars helpers over time. Each helper in the catalog records the API version that introduced it (`mcnSince`). If your account targets an older API version, a newer helper is not yet available and fails at render time.
-
-This rule flags any known helper whose introducing version (`mcnSince`) is greater than the API version you target. For example, `dateAdd` first shipped in MCN API version 67 (Summer '26); using it while targeting API version 65 (Winter '26) is reported.
-
-The rule does nothing until you tell it which API version you target via the `apiVersion` option, which is why it defaults to `off` even in the `-next` configs. Set the option to opt in.
-
-## Settings
-
-| Setting | Values | Default |
-|---------|--------|---------|
-| severity | `"error"` \| `"warn"` \| `"off"` | `"off"` |
-
-### Options
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `apiVersion` | `number` | — | The targeted Marketing Cloud Next API version (e.g. `65` = Winter '26, `67` = Summer '26). Helpers introduced after this version are flagged. When omitted, no helper is flagged. |
-
-## Examples
-
-Configure the rule with the API version you target:
-
-```js
-// eslint.config.js
-rules: {
-  'sfmc/hbs-helper-too-new-for-target': ['error', { apiVersion: 65 }]
-}
-```
-
-**Not allowed (with `apiVersion: 65`):**
-
-```handlebars
-{{! dateAdd was introduced in API version 67 }}
-{{dateAdd order.createdAt 7 "days"}}
-```
-
-**Allowed (with `apiVersion: 65`):**
-
-```handlebars
-{{formatDate order.createdAt "yyyy-MM-dd"}}
-```
-
-## When to Disable
-
-Leave this rule `off` (its default) if you always target the latest MCN API version, or if you do not need to guard against version drift.
-
-```js
-// eslint.config.js
-rules: { 'sfmc/hbs-helper-too-new-for-target': 'off' }
-```

package/src/rules/hbs/helper-too-new-for-target.js

@@ -1,94 +0,0 @@
-import { getHelper } from 'handlebars-data';
-
-import { simpleHelperName, isInvocation } from './_shared.js';
-
-/**
- * Flags known Handlebars helpers whose introducing Marketing Cloud Next API
- * version (`mcnSince`) is newer than the API version the template targets.
- *
- * For example, `dateAdd` first shipped in MCN API version 67 (Summer '26); using
- * it while targeting API version 65 (Winter '26) is reported.
- *
- * The target API version is configured via the `apiVersion` option. When it is
- * omitted, no helper is flagged (all helpers are considered available).
- */
-export default {
-    meta: {
-        type: 'problem',
-        docs: {
-            description:
-                'Disallow Handlebars helpers newer than the targeted Marketing Cloud Next API version',
-            recommended: true,
-        },
-        messages: {
-            helperTooNew:
-                "'{{name}}' was introduced in Marketing Cloud Next API version {{since}}, which is newer than the targeted version {{target}}.",
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    apiVersion: {
-                        type: 'number',
-                        description:
-                            'The targeted Marketing Cloud Next API version (e.g. 65 = Winter \u{2019}26, 67 = Summer \u{2019}26). Helpers newer than this are flagged.',
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-    },
-
-    create(context) {
-        const options = context.options[0] ?? {};
-        const apiVersion = typeof options.apiVersion === 'number' ? options.apiVersion : null;
-        if (apiVersion === null) {
-            return {};
-        }
-
-        /**
-         * Reports a helper when its introducing version exceeds the target.
-         *
-         * @param {object} node - The AST node.
-         * @param {string | null} helperName - The simple helper name, when any.
-         * @returns {void}
-         */
-        function check(node, helperName) {
-            if (!helperName) {
-                return;
-            }
-            const helper = getHelper(helperName);
-            if (helper && helper.mcnSince > apiVersion) {
-                context.report({
-                    node,
-                    messageId: 'helperTooNew',
-                    data: {
-                        name: helper.name,
-                        since: String(helper.mcnSince),
-                        target: String(apiVersion),
-                    },
-                });
-            }
-        }
-
-        /**
-         * Checks an inline mustache or subexpression invocation.
-         *
-         * @param {object} node - The AST node.
-         * @returns {void}
-         */
-        function checkInline(node) {
-            if (isInvocation(node)) {
-                check(node, simpleHelperName(node.path));
-            }
-        }
-
-        return {
-            MustacheStatement: checkInline,
-            SubExpression: checkInline,
-            HbsBlockStatement(node) {
-                check(node, simpleHelperName(node.path));
-            },
-        };
-    },
-};