eslint-plugin-sfmc 2.6.1 → 4.0.0

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-property-call.js

@@ -38,10 +38,7 @@ function canReplaceCallWithAssignment(node) {
     if (parent.type === 'ExpressionStatement' && parent.expression === node) {
         return true;
     }
-    if (parent.type === 'SequenceExpression' && parent.expressions.includes(node)) {
-        return true;
-    }
-    return false;
+    return Boolean(parent.type === 'SequenceExpression' && parent.expressions.includes(node));
 }
 
 export default {
@@ -83,11 +80,11 @@ export default {
                 }
 
                 const ns = callee.object.property.name.toLowerCase();
-                const propName = callee.property.name.toLowerCase();
+                const propertyName = callee.property.name.toLowerCase();
                 const displayNs = callee.object.property.name;
                 const displayName = callee.property.name;
 
-                if (ns === 'response' && RESPONSE_PROPERTIES.has(propName)) {
+                if (ns === 'response' && RESPONSE_PROPERTIES.has(propertyName)) {
                     if (node.arguments.length === 0) {
                         context.report({
                             node,
@@ -106,10 +103,10 @@ export default {
                                 if (!canReplaceCallWithAssignment(node)) {
                                     return null;
                                 }
-                                const argText = sourceCode.getText(node.arguments[0]);
+                                const argumentText = sourceCode.getText(node.arguments[0]);
                                 return fixer.replaceText(
                                     node,
-                                    `${sourceCode.getText(callee)} = ${argText}`,
+                                    `${sourceCode.getText(callee)} = ${argumentText}`,
                                 );
                             },
                         });
@@ -120,7 +117,7 @@ export default {
                             data: { ns: displayNs, name: displayName },
                         });
                     }
-                } else if (ns === 'request' && REQUEST_PROPERTIES.has(propName)) {
+                } else if (ns === 'request' && REQUEST_PROPERTIES.has(propertyName)) {
                     if (node.arguments.length === 0) {
                         context.report({
                             node,

package/src/rules/ssjs/no-treatascontent-injection.js

@@ -35,9 +35,9 @@ export default {
                     return;
                 }
 
-                const arg = node.arguments[0];
-                if (containsConcatenation(arg)) {
-                    context.report({ node: arg, messageId: 'injection' });
+                const argument = node.arguments[0];
+                if (containsConcatenation(argument)) {
+                    context.report({ node: argument, messageId: 'injection' });
                 }
             },
         };
@@ -53,7 +53,7 @@ function isTreatAsContentCall(node) {
     }
 
     // Platform.Function.TreatAsContent(...)
-    if (
+    return (
         callee.type === 'MemberExpression' &&
         callee.property.type === 'Identifier' &&
         callee.property.name === 'TreatAsContent' &&
@@ -62,19 +62,12 @@ function isTreatAsContentCall(node) {
         callee.object.property.name === 'Function' &&
         callee.object.object.type === 'Identifier' &&
         callee.object.object.name === 'Platform'
-    ) {
-        return true;
-    }
-
-    return false;
+    );
 }
 
 function containsConcatenation(node) {
     if (node.type === 'BinaryExpression' && node.operator === '+') {
         return true;
     }
-    if (node.type === 'TemplateLiteral' && node.expressions.length > 0) {
-        return true;
-    }
-    return false;
+    return node.type === 'TemplateLiteral' && node.expressions.length > 0;
 }

package/src/rules/ssjs/no-unavailable-method.js

@@ -98,8 +98,8 @@ export default {
 
         function buildSuggestFix(entry) {
             return function fix(fixer) {
-                const src = context.sourceCode;
-                const end = src.ast.range[1];
+                const source = context.sourceCode;
+                const end = source.ast.range[1];
                 return fixer.insertTextAfterRange([end, end], '\n\n' + entry.polyfill);
             };
         }
@@ -113,27 +113,27 @@ export default {
                     return;
                 }
 
-                const obj = left.object;
-                const prop = left.property;
-                if (prop.type !== 'Identifier') {
+                const object = left.object;
+                const property = left.property;
+                if (property.type !== 'Identifier') {
                     return;
                 }
 
                 // Array.X = ...
-                if (obj.type === 'Identifier' && obj.name === 'Array') {
-                    alreadyPolyfilled.add(prop.name);
+                if (object.type === 'Identifier' && object.name === 'Array') {
+                    alreadyPolyfilled.add(property.name);
                     return;
                 }
 
                 // Array.prototype.X = ...  or  String.prototype.X = ...
                 if (
-                    obj.type === 'MemberExpression' &&
-                    obj.object.type === 'Identifier' &&
-                    (obj.object.name === 'Array' || obj.object.name === 'String') &&
-                    obj.property.type === 'Identifier' &&
-                    obj.property.name === 'prototype'
+                    object.type === 'MemberExpression' &&
+                    object.object.type === 'Identifier' &&
+                    (object.object.name === 'Array' || object.object.name === 'String') &&
+                    object.property.type === 'Identifier' &&
+                    object.property.name === 'prototype'
                 ) {
-                    alreadyPolyfilled.add(prop.name);
+                    alreadyPolyfilled.add(property.name);
                 }
             },
 
@@ -143,12 +143,12 @@ export default {
                     return;
                 }
 
-                const prop = callee.property;
-                if (prop.type !== 'Identifier') {
+                const property = callee.property;
+                if (property.type !== 'Identifier') {
                     return;
                 }
 
-                const methodName = prop.name;
+                const methodName = property.name;
                 const receiver = callee.object;
 
                 const lowerMethod = methodName.toLowerCase();
@@ -163,7 +163,7 @@ export default {
                         return;
                     }
                     const entry = polyfillByStaticName.get(methodName);
-                    pendingReports.push({ node: prop, entry });
+                    pendingReports.push({ node: property, entry });
                     return;
                 }
 
@@ -176,7 +176,7 @@ export default {
                     const entry = knownUnsupportedByStaticName.get(lowerMethod);
                     const ownerBase = entry.owner.replace(/\.prototype$/, '');
                     if (receiver.name === ownerBase && !ignored.has(methodName)) {
-                        pendingReports.push({ node: prop, entry, noPolyfill: true });
+                        pendingReports.push({ node: property, entry, noPolyfill: true });
                         return;
                     }
                 }
@@ -187,13 +187,13 @@ export default {
                         return;
                     }
 
-                    const entry = polyfillByPrototypeName.get(methodName);
-
                     // Skip known SFMC top-level objects to avoid false positives.
                     if (receiver.type === 'Identifier' && SFMC_RECEIVERS.has(receiver.name)) {
                         return;
                     }
 
+                    const entry = polyfillByPrototypeName.get(methodName);
+
                     // For methods that also exist on String.prototype in ES3
                     // (indexOf, lastIndexOf), only flag when the receiver is
                     // a literal array or the call is chained from an array method
@@ -211,7 +211,7 @@ export default {
                         }
                     }
 
-                    pendingReports.push({ node: prop, entry });
+                    pendingReports.push({ node: property, entry });
                     return;
                 }
 
@@ -225,7 +225,7 @@ export default {
                         return;
                     }
                     const entry = knownUnsupportedByPrototypeName.get(lowerMethod);
-                    pendingReports.push({ node: prop, entry, noPolyfill: true });
+                    pendingReports.push({ node: property, entry, noPolyfill: true });
                 }
             },
 

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 targetNext = 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()
@@ -79,16 +61,20 @@ export default {
 
         return {
             VariableDeclaration(node) {
-                for (const decl of node.declarations) {
-                    if (!decl.init || !decl.id || decl.id.type !== 'Identifier') {
+                for (const declaration of node.declarations) {
+                    if (
+                        !declaration.init ||
+                        !declaration.id ||
+                        declaration.id.type !== 'Identifier'
+                    ) {
                         continue;
                     }
-                    const coreType = getCoreInitType(decl.init);
+                    const coreType = getCoreInitType(declaration.init);
                     if (coreType) {
-                        coreVariables.set(decl.id.name, coreType);
+                        coreVariables.set(declaration.id.name, coreType);
                     }
-                    if (isWSProxyConstructor(decl.init)) {
-                        wsproxyVariables.add(decl.id.name);
+                    if (isWSProxyConstructor(declaration.init)) {
+                        wsproxyVariables.add(declaration.id.name);
                     }
                 }
             },
@@ -118,36 +104,6 @@ export default {
 
                 const methodName = property.name;
 
-                // ── MCN target: flag all SSJS API calls as unsupported ────────
-                if (targetNext) {
-                    // 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' &&
@@ -189,10 +145,10 @@ export default {
                     // Core library: var de = DataExtension.Init("key"); de.Foo();
                     const coreType = coreVariables.get(objectName);
                     if (coreType) {
-                        const objectDef = coreObjectLookup.get(coreType);
-                        if (objectDef) {
+                        const objectDefinition = coreObjectLookup.get(coreType);
+                        if (objectDefinition) {
                             const knownMethods = new Set(
-                                objectDef.methods.map((m) => m.toLowerCase()),
+                                objectDefinition.methods.map((m) => m.toLowerCase()),
                             );
                             if (!knownMethods.has(methodName.toLowerCase())) {
                                 context.report({
@@ -201,7 +157,7 @@ export default {
                                     data: {
                                         method: methodName,
                                         objectType: coreType,
-                                        available: objectDef.methods.join(', '),
+                                        available: objectDefinition.methods.join(', '),
                                     },
                                 });
                             }

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

@@ -21,8 +21,8 @@ const AUTO_FIX = {
 
 function nullishCoalescingFix(context, node) {
     return (fixer) => {
-        const src = context.sourceCode.getText();
-        const between = src.slice(node.left.range[1], node.right.range[0]);
+        const source = context.sourceCode.getText();
+        const between = source.slice(node.left.range[1], node.right.range[0]);
         const offset = between.indexOf('??');
         if (offset === -1) {
             return null;
@@ -34,9 +34,9 @@ function nullishCoalescingFix(context, node) {
 
 function directObjectReturnFix(context, node) {
     return (fixer) => {
-        const objText = context.sourceCode.getText(node.argument);
+        const objectText = context.sourceCode.getText(node.argument);
         const indent = ' '.repeat(node.loc.start.column);
-        return fixer.replaceText(node, `var _result = ${objText};\n${indent}return _result;`);
+        return fixer.replaceText(node, `var _result = ${objectText};\n${indent}return _result;`);
     };
 }
 
@@ -92,7 +92,7 @@ export default {
                         },
                     };
 
-                    if (entry.feature in AUTO_FIX) {
+                    if (Object.hasOwn(AUTO_FIX, entry.feature)) {
                         report.fix = AUTO_FIX[entry.feature](node);
                     } else if (entry.feature === 'NullishCoalescing') {
                         report.fix = nullishCoalescingFix(context, node);

package/src/rules/ssjs/{prefer-parsejson-safe-arg.js → prefer-parsejson-safe-argument.js}

@@ -34,19 +34,19 @@ export default {
                     return;
                 }
 
-                const arg = node.arguments[0];
+                const argument = node.arguments[0];
 
-                if (isAlreadySafe(arg)) {
+                if (isAlreadySafe(argument)) {
                     return;
                 }
 
                 context.report({
-                    node: arg,
+                    node: argument,
                     messageId: 'unsafeArg',
-                    data: { argText: context.sourceCode.getText(arg) },
+                    data: { argText: context.sourceCode.getText(argument) },
                     fix(fixer) {
-                        const argText = context.sourceCode.getText(arg);
-                        return fixer.replaceText(arg, `${argText} + ''`);
+                        const argumentText = context.sourceCode.getText(argument);
+                        return fixer.replaceText(argument, `${argumentText} + ''`);
                     },
                 });
             },
@@ -63,7 +63,7 @@ function isParseJSONCall(node) {
     }
 
     // Platform.Function.ParseJSON(...)
-    if (
+    return (
         callee.type === 'MemberExpression' &&
         callee.property.type === 'Identifier' &&
         callee.property.name === 'ParseJSON' &&
@@ -72,29 +72,21 @@ function isParseJSONCall(node) {
         callee.object.property.name === 'Function' &&
         callee.object.object.type === 'Identifier' &&
         callee.object.object.name === 'Platform'
-    ) {
-        return true;
-    }
-
-    return false;
+    );
 }
 
-function isAlreadySafe(arg) {
+function isAlreadySafe(argument) {
     // arg + ''  or  '' + arg
     if (
-        arg.type === 'BinaryExpression' &&
-        arg.operator === '+' &&
-        (isEmptyString(arg.left) || isEmptyString(arg.right))
+        argument.type === 'BinaryExpression' &&
+        argument.operator === '+' &&
+        (isEmptyString(argument.left) || isEmptyString(argument.right))
     ) {
         return true;
     }
 
     // String literal passed directly — already a string
-    if (arg.type === 'Literal' && typeof arg.value === 'string') {
-        return true;
-    }
-
-    return false;
+    return argument.type === 'Literal' && typeof argument.value === 'string';
 }
 
 function isEmptyString(node) {