eslint-plugin-sfmc 0.2.0 → 1.0.1

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-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 - 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/require-platform-load.js

@@ -10,10 +10,16 @@
  * reported violation so ESLint does not duplicate the insertion.
  */
 
-import { coreObjectNames } from 'ssjs-data';
+import { coreObjectNames, SSJS_GLOBALS } from 'ssjs-data';
 
 const TOP_LEVEL_CORE_NAMES = new Set([...coreObjectNames].map((n) => n.split('.')[0]));
 
+// Globals that resolve at runtime only after Platform.Load("core", ...) has been called.
+// E.g. Now(), Write(), GUID(), Base64Encode(), Attribute.GetValue(), DateTime.Parse(), …
+const REQUIRES_CORE_LOAD_GLOBALS = new Set(
+    SSJS_GLOBALS.filter((g) => g.requiresCoreLoad).map((g) => g.name.toLowerCase()),
+);
+
 const PLATFORM_LOAD_STATEMENT = 'Platform.Load("core", "1.1.5");\n';
 
 export default {
@@ -96,10 +102,20 @@ function isPlatformLoadCall(node) {
 
 function getCoreObjectUsage(node) {
     const callee = node.callee;
+
+    // Bare call: Now(), Write(), GUID(), Base64Encode(), Redirect(), …
+    if (callee.type === 'Identifier') {
+        if (REQUIRES_CORE_LOAD_GLOBALS.has(callee.name.toLowerCase())) {
+            return callee.name;
+        }
+        return null;
+    }
+
     if (callee.type !== 'MemberExpression') {
         return null;
     }
 
+    // Nested Core Library call: DataExtension.Rows.Init(…)
     if (
         callee.object.type === 'MemberExpression' &&
         callee.object.object.type === 'Identifier' &&
@@ -110,14 +126,17 @@ function getCoreObjectUsage(node) {
         return `${callee.object.object.name}.${callee.object.property.name}`;
     }
 
-    if (
-        callee.object.type === 'Identifier' &&
-        TOP_LEVEL_CORE_NAMES.has(callee.object.name) &&
-        callee.property.type === 'Identifier'
-    ) {
-        const method = callee.property.name;
-        if (method === 'Init') {
-            return callee.object.name;
+    if (callee.object.type === 'Identifier' && callee.property.type === 'Identifier') {
+        const objectName = callee.object.name;
+
+        // Core Library static Init: DataExtension.Init(…), Subscriber.Init(…), …
+        if (TOP_LEVEL_CORE_NAMES.has(objectName) && callee.property.name === 'Init') {
+            return objectName;
+        }
+
+        // requiresCoreLoad globals used as object: Attribute.GetValue(…), DateTime.Parse(…), …
+        if (REQUIRES_CORE_LOAD_GLOBALS.has(objectName.toLowerCase())) {
+            return `${objectName}.${callee.property.name}`;
         }
     }
 

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' }
-```