eslint-plugin-sfmc 0.1.3 → 1.0.0

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

@@ -0,0 +1,176 @@
+/**
+ * Rule: ssjs-core-method-arity
+ *
+ * Enforces correct argument counts for Core Library object method calls.
+ * Covers both instance methods and static calls:
+ *
+ *   var de = DataExtension.Init("MyDE");
+ *   de.Add(rowObj);                    // instance
+ *   BounceEvent.Retrieve(filter);      // static single-name
+ *   DataExtension.Rows.Add(rowObj);    // static multi-part
+ */
+
+import { coreObjectNames, coreMethodArityLookup } from 'ssjs-data';
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce correct argument counts for Core Library object methods',
+        },
+        messages: {
+            tooFewArgs:
+                "'{{call}}' requires at least {{min}} argument(s) but was called with {{actual}}.",
+            tooManyArgs:
+                "'{{call}}' accepts at most {{max}} argument(s) but was called with {{actual}}.",
+        },
+        schema: [],
+    },
+
+    create(context) {
+        const coreVars = new Map(); // varName → className
+
+        function checkArity(entry, args, callName, reportNode) {
+            if (!entry) {
+                return;
+            }
+            const actual = args.length;
+            if (actual < entry.minArgs) {
+                context.report({
+                    node: reportNode,
+                    messageId: 'tooFewArgs',
+                    data: { call: callName, min: String(entry.minArgs), actual: String(actual) },
+                });
+            } else if (actual > entry.maxArgs) {
+                context.report({
+                    node: reportNode,
+                    messageId: 'tooManyArgs',
+                    data: { call: callName, max: String(entry.maxArgs), actual: String(actual) },
+                });
+            }
+        }
+
+        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) {
+                        coreVars.set(decl.id.name, coreType);
+                    }
+                }
+            },
+
+            AssignmentExpression(node) {
+                if (node.left.type !== 'Identifier') {
+                    return;
+                }
+                const coreType = getCoreInitType(node.right);
+                if (coreType) {
+                    coreVars.set(node.left.name, coreType);
+                }
+            },
+
+            CallExpression(node) {
+                const callee = node.callee;
+                if (callee.type !== 'MemberExpression') {
+                    return;
+                }
+                if (callee.property.type !== 'Identifier') {
+                    return;
+                }
+                const methodName = callee.property.name;
+
+                if (callee.object.type === 'Identifier') {
+                    const objName = callee.object.name;
+
+                    // Core Library instance method: de.Add(...)
+                    const coreType = coreVars.get(objName);
+                    if (coreType) {
+                        const classLookup = coreMethodArityLookup.get(coreType.toLowerCase());
+                        if (classLookup) {
+                            const entry = classLookup.get(methodName.toLowerCase());
+                            checkArity(
+                                entry,
+                                node.arguments,
+                                `${coreType}.${methodName}`,
+                                callee.property,
+                            );
+                        }
+                        return;
+                    }
+
+                    // Static single-name: DataExtension.Init(...), BounceEvent.Retrieve(...)
+                    if (coreObjectNames.has(objName)) {
+                        const classLookup = coreMethodArityLookup.get(objName.toLowerCase());
+                        if (classLookup) {
+                            const entry = classLookup.get(methodName.toLowerCase());
+                            checkArity(
+                                entry,
+                                node.arguments,
+                                `${objName}.${methodName}`,
+                                callee.property,
+                            );
+                        }
+                        return;
+                    }
+                }
+
+                // Static multi-part: DataExtension.Rows.Add(...), TriggeredSend.Tracking.Clicks.Retrieve(...)
+                const objectPath = getMemberPath(callee.object);
+                if (objectPath && coreObjectNames.has(objectPath)) {
+                    const classLookup = coreMethodArityLookup.get(objectPath.toLowerCase());
+                    if (classLookup) {
+                        const entry = classLookup.get(methodName.toLowerCase());
+                        checkArity(
+                            entry,
+                            node.arguments,
+                            `${objectPath}.${methodName}`,
+                            callee.property,
+                        );
+                    }
+                }
+            },
+        };
+    },
+};
+
+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;
+}
+
+function getMemberPath(node) {
+    if (node.type === 'Identifier') {
+        return node.name;
+    }
+    if (node.type === 'MemberExpression' && node.property.type === 'Identifier') {
+        const obj = getMemberPath(node.object);
+        return obj ? `${obj}.${node.property.name}` : null;
+    }
+    return null;
+}

package/src/ssjs-processor.js

@@ -20,7 +20,9 @@ export function preprocess(text, filename) {
 
         SCRIPT_CLOSE_RE.lastIndex = openEnd;
         const closeMatch = SCRIPT_CLOSE_RE.exec(text);
-        if (!closeMatch) break;
+        if (!closeMatch) {
+            break;
+        }
 
         const jsCode = text.slice(openEnd, closeMatch.index);
 

package/docs/rules/ssjs/no-unknown-core-method.md

@@ -1,46 +0,0 @@
-# `sfmc/ssjs-no-unknown-core-method`
-
-> Disallow calls to methods that don't exist on a Core library object.
-
-| | |
-|---|---|
-| **Type** | `problem` |
-| **Default severity** | `warn` in `recommended`; `error` in `strict` |
-| **Fixable** | — |
-
-## Why This Rule Exists
-
-When a variable is initialised with a known Core library constructor (e.g. `var de = DataExtension.Init("MyDE")`), only the methods documented for that Core object type should be called on it. Calling an undocumented or misspelled method causes a runtime error. This rule infers the object type from the `.Init()` call and validates subsequent method calls.
-
-## Settings
-
-| Setting | Values | Default |
-|---------|--------|---------|
-| severity | `"error"` \| `"warn"` \| `"off"` | `"warn"` |
-
-This rule has no configuration options.
-
-### Examples
-
-**Not allowed:**
-
-```js
-Platform.Load("core", "1.1.5");
-var de = DataExtension.Init("MyDE");
-de.Execute();  /* 'Execute' is not a method of DataExtension */
-```
-
-**Allowed:**
-
-```js
-Platform.Load("core", "1.1.5");
-var de = DataExtension.Init("MyDE");
-var rows = de.Rows.Retrieve();
-```
-
-## When to Disable
-
-```js
-// eslint.config.js
-rules: { 'sfmc/ssjs-no-unknown-core-method': 'off' }
-```

package/docs/rules/ssjs/no-unknown-http-method.md

@@ -1,44 +0,0 @@
-# `sfmc/ssjs-no-unknown-http-method`
-
-> Disallow unknown `HTTP.*` method calls.
-
-| | |
-|---|---|
-| **Type** | `problem` |
-| **Default severity** | `error` in `recommended` and `strict` |
-| **Fixable** | — |
-
-## Why This Rule Exists
-
-SFMC's SSJS runtime exposes only four `HTTP` methods: `HTTP.Get`, `HTTP.Post`, `HTTP.GetRequest`, and `HTTP.PostRequest`. Calling any other `HTTP.*` method causes a runtime error. This rule validates every `HTTP.*` call against that fixed list.
-
-## Settings
-
-| Setting | Values | Default |
-|---------|--------|---------|
-| severity | `"error"` \| `"warn"` \| `"off"` | `"error"` |
-
-This rule has no configuration options.
-
-### Examples
-
-**Not allowed:**
-
-```js
-var response = HTTP.Delete("https://api.example.com/resource/1");
-var response = HTTP.Patch("https://api.example.com/resource/1", payload);
-```
-
-**Allowed:**
-
-```js
-var getResponse  = HTTP.Get("https://api.example.com/resource/1");
-var postResponse = HTTP.Post("https://api.example.com/resource", payload, contentType);
-```
-
-## When to Disable
-
-```js
-// eslint.config.js
-rules: { 'sfmc/ssjs-no-unknown-http-method': 'off' }
-```

package/docs/rules/ssjs/no-unknown-platform-client-browser.md

@@ -1,44 +0,0 @@
-# `sfmc/ssjs-no-unknown-platform-client-browser`
-
-> Disallow unknown `Platform.ClientBrowser.*` method calls.
-
-| | |
-|---|---|
-| **Type** | `problem` |
-| **Default severity** | `error` in `recommended` and `strict` |
-| **Fixable** | — |
-
-## Why This Rule Exists
-
-`Platform.ClientBrowser` exposes a small, fixed set of methods for writing to and redirecting the HTTP response on CloudPages and landing pages. Calling a method that does not exist in this catalog causes a runtime error. This rule validates every `Platform.ClientBrowser.*` call against the known list.
-
-## Settings
-
-| Setting | Values | Default |
-|---------|--------|---------|
-| severity | `"error"` \| `"warn"` \| `"off"` | `"error"` |
-
-This rule has no configuration options.
-
-### Examples
-
-**Not allowed:**
-
-```js
-Platform.ClientBrowser.Send("data");
-```
-
-**Allowed:**
-
-```js
-Platform.ClientBrowser.Redirect("https://example.com");
-Platform.ClientBrowser.Write("<p>Hello</p>");
-Platform.ClientBrowser.SetCookie("session", "abc123");
-```
-
-## When to Disable
-
-```js
-// eslint.config.js
-rules: { 'sfmc/ssjs-no-unknown-platform-client-browser': 'off' }
-```

package/docs/rules/ssjs/no-unknown-platform-function.md

@@ -1,44 +0,0 @@
-# `sfmc/ssjs-no-unknown-platform-function`
-
-> Disallow calls to unknown `Platform.Function.*` methods.
-
-| | |
-|---|---|
-| **Type** | `problem` |
-| **Default severity** | `error` in `recommended` and `strict` |
-| **Fixable** | — |
-
-## Why This Rule Exists
-
-`Platform.Function` exposes a fixed set of SFMC server-side utility functions (e.g. `Platform.Function.Lookup`, `Platform.Function.InsertData`). Calling a method that does not exist in the catalog causes a runtime error. This rule validates every `Platform.Function.*` call against the known list.
-
-## Settings
-
-| Setting | Values | Default |
-|---------|--------|---------|
-| severity | `"error"` \| `"warn"` \| `"off"` | `"error"` |
-
-This rule has no configuration options.
-
-### Examples
-
-**Not allowed:**
-
-```js
-Platform.Load("core", "1.1.5");
-var result = Platform.Function.CustomQuery("MyDE");
-```
-
-**Allowed:**
-
-```js
-Platform.Load("core", "1.1.5");
-var result = Platform.Function.Lookup("MyDE", "Value", "Key", keyValue);
-```
-
-## When to Disable
-
-```js
-// eslint.config.js
-rules: { 'sfmc/ssjs-no-unknown-platform-function': 'off' }
-```

package/docs/rules/ssjs/no-unknown-platform-request.md

@@ -1,43 +0,0 @@
-# `sfmc/ssjs-no-unknown-platform-request`
-
-> Disallow unknown `Platform.Request.*` method calls.
-
-| | |
-|---|---|
-| **Type** | `problem` |
-| **Default severity** | `error` in `recommended` and `strict` |
-| **Fixable** | — |
-
-## Why This Rule Exists
-
-`Platform.Request` exposes a fixed set of methods for reading incoming HTTP request data on CloudPages and landing pages (e.g. `Platform.Request.GetQueryStringParameter`, `Platform.Request.GetFormField`). Calling an unknown method causes a runtime error. This rule validates every `Platform.Request.*` call against the known list.
-
-## Settings
-
-| Setting | Values | Default |
-|---------|--------|---------|
-| severity | `"error"` \| `"warn"` \| `"off"` | `"error"` |
-
-This rule has no configuration options.
-
-### Examples
-
-**Not allowed:**
-
-```js
-var val = Platform.Request.ReadParam("myParam");
-```
-
-**Allowed:**
-
-```js
-var val = Platform.Request.GetQueryStringParameter("myParam");
-var field = Platform.Request.GetFormField("email");
-```
-
-## When to Disable
-
-```js
-// eslint.config.js
-rules: { 'sfmc/ssjs-no-unknown-platform-request': 'off' }
-```

package/docs/rules/ssjs/no-unknown-platform-response.md

@@ -1,43 +0,0 @@
-# `sfmc/ssjs-no-unknown-platform-response`
-
-> Disallow unknown `Platform.Response.*` method calls.
-
-| | |
-|---|---|
-| **Type** | `problem` |
-| **Default severity** | `error` in `recommended` and `strict` |
-| **Fixable** | — |
-
-## Why This Rule Exists
-
-`Platform.Response` exposes a fixed set of methods for controlling HTTP responses from CloudPages and landing pages (e.g. `Platform.Response.Write`, `Platform.Response.Redirect`). Calling an unknown method causes a runtime error. This rule validates every `Platform.Response.*` call against the known list.
-
-## Settings
-
-| Setting | Values | Default |
-|---------|--------|---------|
-| severity | `"error"` \| `"warn"` \| `"off"` | `"error"` |
-
-This rule has no configuration options.
-
-### Examples
-
-**Not allowed:**
-
-```js
-Platform.Response.Send("text/html", "<p>Hello</p>");
-```
-
-**Allowed:**
-
-```js
-Platform.Response.Write("<p>Hello</p>");
-Platform.Response.Redirect("https://example.com");
-```
-
-## When to Disable
-
-```js
-// eslint.config.js
-rules: { 'sfmc/ssjs-no-unknown-platform-response': 'off' }
-```

package/docs/rules/ssjs/no-unknown-platform-variable.md

@@ -1,43 +0,0 @@
-# `sfmc/ssjs-no-unknown-platform-variable`
-
-> Disallow unknown `Platform.Variable.*` method calls.
-
-| | |
-|---|---|
-| **Type** | `problem` |
-| **Default severity** | `error` in `recommended` and `strict` |
-| **Fixable** | — |
-
-## Why This Rule Exists
-
-`Platform.Variable` exposes a fixed set of methods for interacting with AMPscript variables from SSJS (e.g. `Platform.Variable.GetValue`, `Platform.Variable.SetValue`). Calling an unknown method causes a runtime error. This rule validates every `Platform.Variable.*` call against the known list.
-
-## Settings
-
-| Setting | Values | Default |
-|---------|--------|---------|
-| severity | `"error"` \| `"warn"` \| `"off"` | `"error"` |
-
-This rule has no configuration options.
-
-### Examples
-
-**Not allowed:**
-
-```js
-var val = Platform.Variable.ReadValue("@myVar");
-```
-
-**Allowed:**
-
-```js
-var val = Platform.Variable.GetValue("@myVar");
-Platform.Variable.SetValue("@myVar", "Hello");
-```
-
-## When to Disable
-
-```js
-// eslint.config.js
-rules: { 'sfmc/ssjs-no-unknown-platform-variable': 'off' }
-```

package/docs/rules/ssjs/no-unknown-wsproxy-method.md

@@ -1,46 +0,0 @@
-# `sfmc/ssjs-no-unknown-wsproxy-method`
-
-> Disallow unknown method calls on a `WSProxy` instance.
-
-| | |
-|---|---|
-| **Type** | `problem` |
-| **Default severity** | `warn` in `recommended`; `error` in `strict` |
-| **Fixable** | — |
-
-## Why This Rule Exists
-
-`WSProxy` is SFMC's SSJS wrapper around the SOAP API. It exposes a specific set of methods (`retrieve`, `retrieveAll`, `create`, `update`, `delete`, `execute`, `perform`). Calling an unknown method on a `WSProxy` instance causes a runtime error. This rule infers `WSProxy` variable usage and validates method calls against the known list.
-
-## Settings
-
-| Setting | Values | Default |
-|---------|--------|---------|
-| severity | `"error"` \| `"warn"` \| `"off"` | `"warn"` |
-
-This rule has no configuration options.
-
-### Examples
-
-**Not allowed:**
-
-```js
-Platform.Load("core", "1.1.5");
-var proxy = new Script.Util.WSProxy();
-var result = proxy.query({ ObjectType: "Subscriber" });
-```
-
-**Allowed:**
-
-```js
-Platform.Load("core", "1.1.5");
-var proxy = new Script.Util.WSProxy();
-var result = proxy.retrieve({ ObjectType: "Subscriber", Properties: ["SubscriberKey"] }, []);
-```
-
-## When to Disable
-
-```js
-// eslint.config.js
-rules: { 'sfmc/ssjs-no-unknown-wsproxy-method': 'off' }
-```

package/src/rules/ssjs/no-unknown-core-method.js

@@ -1,103 +0,0 @@
-/**
- * Rule: no-unknown-core-method
- *
- * Flags calls to Core library object methods that don't exist on that
- * object type, when the object type can be inferred from an Init call.
- *
- * Example:
- *   var de = DataExtension.Init("MyDE");
- *   de.Foo();  // error: 'Foo' is not a method of DataExtension
- */
-
-import { coreObjectLookup, coreObjectNames } from 'ssjs-data';
-
-export default {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: "Disallow calls to methods that don't exist on a Core library object",
-        },
-        messages: {
-            unknownMethod:
-                "'{{method}}' is not a known method of {{objectType}}. Available methods: {{available}}.",
-        },
-        schema: [],
-    },
-
-    create(context) {
-        const variableTypes = new Map();
-
-        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) {
-                        variableTypes.set(decl.id.name, coreType);
-                    }
-                }
-            },
-
-            AssignmentExpression(node) {
-                if (node.left.type !== 'Identifier') return;
-                const coreType = getCoreInitType(node.right);
-                if (coreType) {
-                    variableTypes.set(node.left.name, coreType);
-                }
-            },
-
-            CallExpression(node) {
-                const callee = node.callee;
-                if (callee.type !== 'MemberExpression') return;
-                if (callee.object.type !== 'Identifier') return;
-                if (callee.property.type !== 'Identifier') return;
-
-                const objectName = callee.object.name;
-                const method = callee.property.name;
-
-                const coreType = variableTypes.get(objectName);
-                if (!coreType) return;
-
-                const objectDef = coreObjectLookup.get(coreType);
-                if (!objectDef) return;
-
-                const knownMethods = new Set(objectDef.methods.map((m) => m.toLowerCase()));
-                if (!knownMethods.has(method.toLowerCase())) {
-                    context.report({
-                        node: callee.property,
-                        messageId: 'unknownMethod',
-                        data: {
-                            method,
-                            objectType: coreType,
-                            available: objectDef.methods.join(', '),
-                        },
-                    });
-                }
-            },
-        };
-    },
-};
-
-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') {
-        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;
-}

package/src/rules/ssjs/no-unknown-http-method.js

@@ -1,41 +0,0 @@
-/**
- * Rule: no-unknown-http-method
- *
- * Flags calls to HTTP.* where the method name does not exist
- * in the known SFMC HTTP method catalog.
- */
-
-import { httpMethodNames } from 'ssjs-data';
-
-export default {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Disallow calls to unknown HTTP object methods',
-        },
-        messages: {
-            unknownMethod: "'HTTP.{{name}}' is not a recognized SFMC HTTP method.",
-        },
-        schema: [],
-    },
-
-    create(context) {
-        return {
-            CallExpression(node) {
-                const callee = node.callee;
-                if (callee.type !== 'MemberExpression') return;
-                if (callee.object.type !== 'Identifier' || callee.object.name !== 'HTTP') return;
-                if (callee.property.type !== 'Identifier') return;
-
-                const methodName = callee.property.name;
-                if (!httpMethodNames.has(methodName.toLowerCase())) {
-                    context.report({
-                        node: callee.property,
-                        messageId: 'unknownMethod',
-                        data: { name: methodName },
-                    });
-                }
-            },
-        };
-    },
-};