eslint-plugin-sfmc 0.1.3 → 1.0.0

package/src/rules/ssjs/no-property-call.js

@@ -0,0 +1,136 @@
+/**
+ * Rule: ssjs-no-property-call
+ *
+ * Flags Platform.Request and Platform.Response members that are properties,
+ * not methods. Calling them with `()` is a runtime error.
+ *
+ * Three cases are handled:
+ *
+ *   1. Read with parens (both namespaces, no args):
+ *        Platform.Request.Method()  →  Platform.Request.Method
+ *
+ *   2. Write via function call (Platform.Response.* only, single arg):
+ *        Platform.Response.ContentType("text/html")
+ *        →  Platform.Response.ContentType = "text/html"
+ *
+ *   3. Attempt to set a read-only property (Platform.Request.*, with args):
+ *        Platform.Request.Method("POST")  →  no auto-fix (read-only)
+ */
+
+import { PLATFORM_RESPONSE_METHODS, PLATFORM_REQUEST_METHODS } from 'ssjs-data';
+
+// Platform.Response properties — readable AND writable
+const RESPONSE_PROPERTIES = new Set(
+    PLATFORM_RESPONSE_METHODS.filter((m) => m.isProperty).map((m) => m.name.toLowerCase()),
+);
+
+// Platform.Request properties — read-only
+const REQUEST_PROPERTIES = new Set(
+    PLATFORM_REQUEST_METHODS.filter((m) => m.isProperty).map((m) => m.name.toLowerCase()),
+);
+
+export default {
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            description: 'Disallow calling Platform.Request/Response properties as functions',
+        },
+        messages: {
+            propertyReadWithCall:
+                "'Platform.{{ns}}.{{name}}' is a property, not a function. " +
+                "Remove the '()' to read its value.",
+            readOnlyPropertySet:
+                "'Platform.Request.{{name}}' is a read-only property. It cannot be assigned a value.",
+            writablePropertySet:
+                "'Platform.Response.{{name}}' is a property. " +
+                'Use `Platform.Response.{{name}} = value` to assign instead of calling it as a function.',
+        },
+        schema: [],
+    },
+
+    create(context) {
+        const sourceCode = context.sourceCode;
+
+        return {
+            CallExpression(node) {
+                const callee = node.callee;
+
+                // Must be Platform.<NS>.<property>()
+                if (
+                    callee.type !== 'MemberExpression' ||
+                    callee.object.type !== 'MemberExpression' ||
+                    callee.object.object.type !== 'Identifier' ||
+                    callee.object.object.name !== 'Platform' ||
+                    callee.object.property.type !== 'Identifier' ||
+                    callee.property.type !== 'Identifier'
+                ) {
+                    return;
+                }
+
+                const ns = callee.object.property.name.toLowerCase();
+                const propName = callee.property.name.toLowerCase();
+                const displayNs = callee.object.property.name;
+                const displayName = callee.property.name;
+
+                if (ns === 'response' && RESPONSE_PROPERTIES.has(propName)) {
+                    if (node.arguments.length === 0) {
+                        // Reading with parens — remove ()
+                        context.report({
+                            node,
+                            messageId: 'propertyReadWithCall',
+                            data: { ns: displayNs, name: displayName },
+                            fix(fixer) {
+                                return fixer.replaceText(node, sourceCode.getText(callee));
+                            },
+                        });
+                    } else if (node.arguments.length === 1) {
+                        // Setting via function call — convert to assignment
+                        context.report({
+                            node,
+                            messageId: 'writablePropertySet',
+                            data: { ns: displayNs, name: displayName },
+                            fix(fixer) {
+                                // Only safe when the call is a standalone expression statement
+                                if (node.parent.type !== 'ExpressionStatement') {
+                                    return null;
+                                }
+                                const argText = sourceCode.getText(node.arguments[0]);
+                                return fixer.replaceText(
+                                    node,
+                                    `${sourceCode.getText(callee)} = ${argText}`,
+                                );
+                            },
+                        });
+                    } else {
+                        // >1 args — unusual, flag without a fix
+                        context.report({
+                            node,
+                            messageId: 'writablePropertySet',
+                            data: { ns: displayNs, name: displayName },
+                        });
+                    }
+                } else if (ns === 'request' && REQUEST_PROPERTIES.has(propName)) {
+                    if (node.arguments.length === 0) {
+                        // Reading with parens — remove ()
+                        context.report({
+                            node,
+                            messageId: 'propertyReadWithCall',
+                            data: { ns: displayNs, name: displayName },
+                            fix(fixer) {
+                                return fixer.replaceText(node, sourceCode.getText(callee));
+                            },
+                        });
+                    } else {
+                        // Attempting to set a read-only property — no fix
+                        context.report({
+                            node,
+                            messageId: 'readOnlyPropertySet',
+                            data: { name: displayName },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};

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

@@ -19,8 +19,8 @@ export default {
         messages: {
             injection:
                 'Concatenating dynamic values into TreatAsContent() risks AMPscript injection. ' +
-                "Use Variable.SetValue() to pass values into AMPscript variables, then reference " +
-                "them with @varName inside the TreatAsContent string.",
+                'Use Variable.SetValue() to pass values into AMPscript variables, then reference ' +
+                'them with @varName inside the TreatAsContent string.',
         },
         schema: [],
     },
@@ -28,8 +28,12 @@ export default {
     create(context) {
         return {
             CallExpression(node) {
-                if (!isTreatAsContentCall(node)) return;
-                if (node.arguments.length === 0) return;
+                if (!isTreatAsContentCall(node)) {
+                    return;
+                }
+                if (node.arguments.length === 0) {
+                    return;
+                }
 
                 const arg = node.arguments[0];
                 if (containsConcatenation(arg)) {

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

@@ -94,11 +94,15 @@ export default {
             // Array.prototype.map = ...  /  Array.isArray = ...  /  String.prototype.trim = ...
             AssignmentExpression(node) {
                 const left = node.left;
-                if (left.type !== 'MemberExpression') return;
+                if (left.type !== 'MemberExpression') {
+                    return;
+                }
 
                 const obj = left.object;
                 const prop = left.property;
-                if (prop.type !== 'Identifier') return;
+                if (prop.type !== 'Identifier') {
+                    return;
+                }
 
                 // Array.X = ...
                 if (obj.type === 'Identifier' && obj.name === 'Array') {
@@ -120,10 +124,14 @@ export default {
 
             CallExpression(node) {
                 const callee = node.callee;
-                if (callee.type !== 'MemberExpression') return;
+                if (callee.type !== 'MemberExpression') {
+                    return;
+                }
 
                 const prop = callee.property;
-                if (prop.type !== 'Identifier') return;
+                if (prop.type !== 'Identifier') {
+                    return;
+                }
 
                 const methodName = prop.name;
                 const receiver = callee.object;
@@ -134,20 +142,28 @@ export default {
                     receiver.name === 'Array' &&
                     polyfillByStaticName.has(methodName)
                 ) {
-                    if (ignored.has(methodName)) return;
+                    if (ignored.has(methodName)) {
+                        return;
+                    }
                     const entry = polyfillByStaticName.get(methodName);
                     pendingReports.push({ node: prop, entry });
                     return;
                 }
 
                 // ── Prototype methods ─────────────────────────────────────────
-                if (!polyfillByPrototypeName.has(methodName)) return;
-                if (ignored.has(methodName)) return;
+                if (!polyfillByPrototypeName.has(methodName)) {
+                    return;
+                }
+                if (ignored.has(methodName)) {
+                    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;
+                if (receiver.type === 'Identifier' && SFMC_RECEIVERS.has(receiver.name)) {
+                    return;
+                }
 
                 // For methods that also exist on String.prototype in ES3
                 // (indexOf, lastIndexOf), only flag when the receiver is
@@ -161,7 +177,9 @@ export default {
                         (receiver.type === 'CallExpression' &&
                             receiver.callee.type === 'MemberExpression' &&
                             polyfillByPrototypeName.has(receiver.callee.property.name));
-                    if (!isDefinitelyArray) return;
+                    if (!isDefinitelyArray) {
+                        return;
+                    }
                 }
 
                 pendingReports.push({ node: prop, entry });
@@ -169,7 +187,9 @@ export default {
 
             'Program:exit'() {
                 for (const { node, entry } of pendingReports) {
-                    if (isAlreadyPolyfilled(entry.method)) continue;
+                    if (isAlreadyPolyfilled(entry.method)) {
+                        continue;
+                    }
 
                     context.report({
                         node,

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

@@ -0,0 +1,236 @@
+/**
+ * Rule: ssjs-no-unknown-function
+ *
+ * Unified rule that replaces the seven narrow no-unknown-* rules.
+ * Flags calls to API methods that do not exist in the SFMC catalog:
+ *
+ *   - Platform.Function.<method>()  — unknown Platform.Function method
+ *   - Platform.Variable.<method>()  — unknown Platform.Variable method
+ *   - Platform.Request.<method>()   — unknown Platform.Request method
+ *   - Platform.Response.<method>()  — unknown Platform.Response method
+ *   - Platform.Recipient.<method>() — unknown Platform.Recipient method
+ *   - HTTP.<method>()               — unknown HTTP method
+ *   - <wsproxyVar>.<method>()       — unknown WSProxy method on a tracked variable
+ *   - <coreVar>.<method>()          — unknown method on a tracked Core Library object
+ */
+
+import {
+    platformFunctionNames,
+    PLATFORM_VARIABLE_METHODS,
+    PLATFORM_REQUEST_METHODS,
+    PLATFORM_RESPONSE_METHODS,
+    platformRecipientMethodNames,
+    httpMethodNames,
+    coreObjectLookup,
+    coreObjectNames,
+    wsproxyMethodNames,
+} from 'ssjs-data';
+
+// Map of lowercase Platform namespace → Set of known lowercase method names
+const PLATFORM_NS = new Map([
+    ['function', platformFunctionNames],
+    ['variable', new Set(PLATFORM_VARIABLE_METHODS.map((m) => m.name.toLowerCase()))],
+    ['request', new Set(PLATFORM_REQUEST_METHODS.map((m) => m.name.toLowerCase()))],
+    ['response', new Set(PLATFORM_RESPONSE_METHODS.map((m) => m.name.toLowerCase()))],
+    ['recipient', platformRecipientMethodNames],
+]);
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description:
+                'Disallow calls to unknown SFMC API methods (Platform.*, HTTP.*, Core library, WSProxy)',
+        },
+        messages: {
+            unknownPlatformMethod:
+                "'Platform.{{ns}}.{{name}}' is not a recognized SFMC Platform.{{ns}} method.",
+            unknownHttpMethod: "'HTTP.{{name}}' is not a recognized SFMC HTTP method.",
+            unknownCoreMethod:
+                "'{{method}}' is not a known method of {{objectType}}. Available methods: {{available}}.",
+            unknownWsproxyMethod: "'{{name}}' is not a recognized WSProxy method.",
+        },
+        schema: [],
+    },
+
+    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 decl of node.declarations) {
+                    if (!decl.init || !decl.id || decl.id.type !== 'Identifier') {
+                        continue;
+                    }
+                    const coreType = getCoreInitType(decl.init);
+                    if (coreType) {
+                        coreVariables.set(decl.id.name, coreType);
+                    }
+                    if (isWSProxyConstructor(decl.init)) {
+                        wsproxyVariables.add(decl.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);
+                }
+            },
+
+            CallExpression(node) {
+                const callee = node.callee;
+                if (callee.type !== 'MemberExpression') {
+                    return;
+                }
+                const property = callee.property;
+                if (property.type !== 'Identifier') {
+                    return;
+                }
+
+                const methodName = property.name;
+
+                // ── Platform.<NS>.<method>() ──────────────────────────────────
+                if (
+                    callee.object.type === 'MemberExpression' &&
+                    callee.object.object.type === 'Identifier' &&
+                    callee.object.object.name === 'Platform' &&
+                    callee.object.property.type === 'Identifier'
+                ) {
+                    const ns = callee.object.property.name.toLowerCase();
+                    const knownNames = PLATFORM_NS.get(ns);
+                    // Only report if we know this namespace; unknown namespaces are ignored.
+                    if (knownNames && !knownNames.has(methodName.toLowerCase())) {
+                        context.report({
+                            node: property,
+                            messageId: 'unknownPlatformMethod',
+                            data: { ns: callee.object.property.name, name: methodName },
+                        });
+                    }
+                    return;
+                }
+
+                // ── HTTP.<method>() ───────────────────────────────────────────
+                if (
+                    callee.object.type === 'Identifier' &&
+                    callee.object.name === 'HTTP' &&
+                    !httpMethodNames.has(methodName.toLowerCase())
+                ) {
+                    context.report({
+                        node: property,
+                        messageId: 'unknownHttpMethod',
+                        data: { name: methodName },
+                    });
+                    return;
+                }
+
+                // ── Instance method calls (Core Library / WSProxy) ────────────
+                if (callee.object.type === 'Identifier') {
+                    const objectName = callee.object.name;
+
+                    // Core library: var de = DataExtension.Init("key"); de.Foo();
+                    const coreType = coreVariables.get(objectName);
+                    if (coreType) {
+                        const objectDef = coreObjectLookup.get(coreType);
+                        if (objectDef) {
+                            const knownMethods = new Set(
+                                objectDef.methods.map((m) => m.toLowerCase()),
+                            );
+                            if (!knownMethods.has(methodName.toLowerCase())) {
+                                context.report({
+                                    node: property,
+                                    messageId: 'unknownCoreMethod',
+                                    data: {
+                                        method: methodName,
+                                        objectType: coreType,
+                                        available: objectDef.methods.join(', '),
+                                    },
+                                });
+                            }
+                        }
+                        return;
+                    }
+
+                    // WSProxy: var api = new Script.Util.WSProxy(); api.Foo();
+                    if (
+                        wsproxyVariables.has(objectName) &&
+                        !wsproxyMethodNames.has(methodName.toLowerCase())
+                    ) {
+                        context.report({
+                            node: property,
+                            messageId: 'unknownWsproxyMethod',
+                            data: { name: methodName },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+
+/**
+ * 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
+ * @returns {string | null}
+ */
+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
+ * @returns {boolean}
+ */
+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-unsupported-syntax.js

@@ -36,8 +36,7 @@ export default {
             unsupported: '{{label}} are not supported in SFMC SSJS. {{suggestion}}',
             suggestLogicalOr:
                 "Replace ?? with || (note: semantics differ for falsy values like 0, '', and false)",
-            suggestVarReturn:
-                'Assign the object to a variable, then return the variable',
+            suggestVarReturn: 'Assign the object to a variable, then return the variable',
         },
         schema: [
             {
@@ -65,8 +64,12 @@ export default {
         for (const [nodeType, entries] of unsupportedByNodeType) {
             listeners[nodeType] = function (node) {
                 for (const entry of entries) {
-                    if (allowed.has(entry.feature)) continue;
-                    if (entry.test && !entry.test(node)) continue;
+                    if (allowed.has(entry.feature)) {
+                        continue;
+                    }
+                    if (entry.test && !entry.test(node)) {
+                        continue;
+                    }
 
                     const report = {
                         node,
@@ -90,7 +93,9 @@ export default {
                                         node.right.range[0],
                                     );
                                     const offset = between.indexOf('??');
-                                    if (offset === -1) return null;
+                                    if (offset === -1) {
+                                        return null;
+                                    }
                                     const start = node.left.range[1] + offset;
                                     return fixer.replaceTextRange([start, start + 2], '||');
                                 },

package/src/rules/ssjs/platform-function-arity.js

@@ -26,7 +26,9 @@ export default {
         return {
             CallExpression(node) {
                 const callee = node.callee;
-                if (callee.type !== 'MemberExpression') return;
+                if (callee.type !== 'MemberExpression') {
+                    return;
+                }
 
                 if (
                     callee.object.type === 'MemberExpression' &&
@@ -38,7 +40,9 @@ export default {
                 ) {
                     const methodName = callee.property.name;
                     const entry = platformFunctionLookup.get(methodName.toLowerCase());
-                    if (!entry) return;
+                    if (!entry) {
+                        return;
+                    }
 
                     const actual = node.arguments.length;
 

package/src/rules/ssjs/prefer-parsejson-safe-arg.js

@@ -14,11 +14,11 @@ export default {
         fixable: 'code',
         docs: {
             description:
-                "Require concatenating an empty string to Platform.Function.ParseJSON() arguments to prevent 500 errors",
+                'Require concatenating an empty string to Platform.Function.ParseJSON() arguments to prevent 500 errors',
         },
         messages: {
             unsafeArg:
-                "Platform.Function.ParseJSON() may throw a 500 if the argument is undefined. " +
+                'Platform.Function.ParseJSON() may throw a 500 if the argument is undefined. ' +
                 "Concatenate an empty string to be safe: ParseJSON({{argText}} + '').",
         },
         schema: [],
@@ -27,12 +27,18 @@ export default {
     create(context) {
         return {
             CallExpression(node) {
-                if (!isParseJSONCall(node)) return;
-                if (node.arguments.length === 0) return;
+                if (!isParseJSONCall(node)) {
+                    return;
+                }
+                if (node.arguments.length === 0) {
+                    return;
+                }
 
                 const arg = node.arguments[0];
 
-                if (isAlreadySafe(arg)) return;
+                if (isAlreadySafe(arg)) {
+                    return;
+                }
 
                 context.report({
                     node: arg,
@@ -75,10 +81,12 @@ function isParseJSONCall(node) {
 
 function isAlreadySafe(arg) {
     // arg + ''  or  '' + arg
-    if (arg.type === 'BinaryExpression' && arg.operator === '+') {
-        if (isEmptyString(arg.left) || isEmptyString(arg.right)) {
-            return true;
-        }
+    if (
+        arg.type === 'BinaryExpression' &&
+        arg.operator === '+' &&
+        (isEmptyString(arg.left) || isEmptyString(arg.right))
+    ) {
+        return true;
     }
 
     // String literal passed directly — already a string

package/src/rules/ssjs/prefer-platform-load-version.js

@@ -66,10 +66,7 @@ export default {
                         messageId: 'outdatedVersion',
                         data: { actual: '(none)', expected: expectedVersion },
                         fix(fixer) {
-                            return fixer.insertTextAfter(
-                                arguments_[0],
-                                `, "${expectedVersion}"`,
-                            );
+                            return fixer.insertTextAfter(arguments_[0], `, "${expectedVersion}"`);
                         },
                     });
                     return;