eslint-plugin-sfmc 0.2.0 → 1.0.0

package/README.md

@@ -65,19 +65,14 @@ export default [
 
 | Rule                                                                                                    | Default | Description                                                          |
 | ------------------------------------------------------------------------------------------------------- | ------- | -------------------------------------------------------------------- |
-| [`sfmc/ssjs-require-platform-load`](docs/rules/ssjs/require-platform-load.md)                           | `error` | Require `Platform.Load("core")` before Core usage                    |
+| [`sfmc/ssjs-require-platform-load`](docs/rules/ssjs/require-platform-load.md)                           | `error` | Require `Platform.Load("core")` before Core or requiresCoreLoad globals |
 | [`sfmc/ssjs-no-unsupported-syntax`](docs/rules/ssjs/no-unsupported-syntax.md)                           | `error` | Flag ES6+ syntax not supported by SFMC                               |
-| [`sfmc/ssjs-no-unknown-platform-function`](docs/rules/ssjs/no-unknown-platform-function.md)             | `error` | Disallow unknown `Platform.Function.*` methods                       |
+| [`sfmc/ssjs-no-unknown-function`](docs/rules/ssjs/no-unknown-function.md)                               | `error` | Disallow unknown methods on Platform.*, HTTP, Core Library, and WSProxy |
+| [`sfmc/ssjs-no-deprecated-function`](docs/rules/ssjs/no-deprecated-function.md)                         | `error` | Flag use of deprecated SFMC SSJS APIs (e.g. ContentArea, ContentAreaObj) |
+| [`sfmc/ssjs-no-property-call`](docs/rules/ssjs/no-property-call.md)                                     | `error` | Disallow calling Platform.Request/Response properties as functions   |
 | [`sfmc/ssjs-platform-function-arity`](docs/rules/ssjs/platform-function-arity.md)                       | `error` | Enforce correct arity for `Platform.Function.*`                      |
-| [`sfmc/ssjs-no-unknown-http-method`](docs/rules/ssjs/no-unknown-http-method.md)                         | `error` | Disallow unknown `HTTP.*` methods                                    |
-| [`sfmc/ssjs-no-unknown-platform-variable`](docs/rules/ssjs/no-unknown-platform-variable.md)             | `error` | Disallow unknown `Platform.Variable.*` methods                       |
-| [`sfmc/ssjs-no-unknown-platform-response`](docs/rules/ssjs/no-unknown-platform-response.md)             | `error` | Disallow unknown `Platform.Response.*` methods                       |
-| [`sfmc/ssjs-no-unknown-platform-request`](docs/rules/ssjs/no-unknown-platform-request.md)               | `error` | Disallow unknown `Platform.Request.*` methods                        |
 | [`sfmc/ssjs-require-platform-load-order`](docs/rules/ssjs/require-platform-load-order.md)               | `error` | Require `Platform.Load()` before Core usage in order                 |
 | [`sfmc/ssjs-no-hardcoded-credentials`](docs/rules/ssjs/no-hardcoded-credentials.md)                     | `error` | Flag hardcoded keys in encryption calls                              |
-| [`sfmc/ssjs-no-unknown-platform-client-browser`](docs/rules/ssjs/no-unknown-platform-client-browser.md) | `error` | Disallow unknown `Platform.ClientBrowser.*` methods                  |
-| [`sfmc/ssjs-no-unknown-core-method`](docs/rules/ssjs/no-unknown-core-method.md)                         | `warn`  | Disallow unknown methods on Core library objects                     |
-| [`sfmc/ssjs-no-unknown-wsproxy-method`](docs/rules/ssjs/no-unknown-wsproxy-method.md)                   | `warn`  | Disallow unknown WSProxy methods                                     |
 | [`sfmc/ssjs-cache-loop-length`](docs/rules/ssjs/cache-loop-length.md)                                   | `warn`  | Require caching `.length` in for-loops                               |
 | [`sfmc/ssjs-require-hasownproperty`](docs/rules/ssjs/require-hasownproperty.md)                         | `warn`  | Require `hasOwnProperty` guard in for-in loops                       |
 | [`sfmc/ssjs-prefer-platform-load-version`](docs/rules/ssjs/prefer-platform-load-version.md)             | `warn`  | Enforce a minimum `Platform.Load` version string                     |

package/docs/rules/ssjs/no-deprecated-function.md

@@ -0,0 +1,56 @@
+# ssjs-no-deprecated-function
+
+Flags calls to deprecated SFMC SSJS APIs. Currently focuses on the **Content Areas** feature,
+which has been retired and no longer allows creating or updating content.
+
+## What is flagged
+
+| API | Reason |
+|---|---|
+| `ContentArea(…)` | Global alias; Content Areas are deprecated |
+| `ContentAreaByName(…)` | Global alias; Content Areas are deprecated |
+| `Platform.Function.ContentArea(…)` | Content Areas are deprecated |
+| `Platform.Function.ContentAreaByName(…)` | Content Areas are deprecated |
+| `ContentAreaObj.Init(…)` | ContentAreaObj class is deprecated |
+| `ContentAreaObj.Add(…)` | ContentAreaObj class is deprecated |
+| `ContentAreaObj.Retrieve(…)` | ContentAreaObj class is deprecated |
+| `<contentAreaVar>.Update(…)` | Instance method on a deprecated ContentAreaObj variable |
+| `<contentAreaVar>.Remove()` | Instance method on a deprecated ContentAreaObj variable |
+
+## Examples
+
+### ❌ Incorrect
+
+```js
+// Global alias — deprecated
+var html = ContentAreaByName('Public Content/MyBlock');
+
+// Platform.Function — deprecated
+var content = Platform.Function.ContentArea(12345);
+
+// ContentAreaObj static method — deprecated
+var results = ContentAreaObj.Retrieve({
+    Property: 'CustomerKey',
+    SimpleOperator: 'equals',
+    Value: 'myCA',
+});
+
+// ContentAreaObj instance — deprecated
+var area = ContentAreaObj.Init('myCA');
+var status = area.Update({ Name: 'Updated Name' });
+```
+
+### ✅ Correct
+
+```js
+// Use Content Builder blocks via Platform.Function.ContentBlockByKey / ContentBlockById
+var html = Platform.Function.ContentBlockByKey('Public Content/MyBlock');
+var content = Platform.Function.ContentBlockById(12345);
+```
+
+## Rule details
+
+- **Type:** `suggestion`
+- **Fixable:** No
+- **Recommended:** Yes
+- **Strict:** Yes

package/docs/rules/ssjs/no-property-call.md

@@ -0,0 +1,95 @@
+# ssjs-no-property-call
+
+Flags `Platform.Request` and `Platform.Response` members that are **properties**, not functions.
+Calling them with parentheses `()` is a runtime error — they must be accessed without parentheses.
+
+The rule is fixable:
+
+- **No-arg calls** (`Property()`) → removes the `()` on both `Request` and `Response` properties.
+- **Single-arg calls on `Platform.Response.*`** (`ContentType("text/html")`) → rewrites to an assignment (`= value`), because those two properties are read/write.
+- **Any-arg calls on `Platform.Request.*`** → reported as an error with no auto-fix, because `Request` properties are read-only.
+
+## Properties affected
+
+### `Platform.Request` — read-only
+
+| Property |
+|---|
+| `Browser` |
+| `ClientIP` |
+| `HasSSL` |
+| `IsSSL` |
+| `Method` |
+| `QueryString` |
+| `ReferrerURL` |
+| `RequestURL` |
+| `UserAgent` |
+
+### `Platform.Response` — read/write
+
+| Property |
+|---|
+| `ContentType` |
+| `CharacterSet` |
+
+## Examples
+
+### ❌ Incorrect — reading a property with `()`
+
+```js
+var method = Platform.Request.Method();   // ← runtime error
+var ip     = Platform.Request.ClientIP(); // ← runtime error
+var ct     = Platform.Response.ContentType(); // ← runtime error
+```
+
+Auto-fix removes the parentheses:
+
+```js
+var method = Platform.Request.Method;
+var ip     = Platform.Request.ClientIP;
+var ct     = Platform.Response.ContentType;
+```
+
+### ❌ Incorrect — setting a `Platform.Response` property via function call
+
+```js
+Platform.Response.ContentType("application/json"); // ← should be an assignment
+Platform.Response.CharacterSet("UTF-8");           // ← should be an assignment
+```
+
+Auto-fix converts to an assignment statement:
+
+```js
+Platform.Response.ContentType = "application/json";
+Platform.Response.CharacterSet = "UTF-8";
+```
+
+### ❌ Incorrect — attempting to set a read-only `Platform.Request` property (no fix)
+
+```js
+Platform.Request.Method("POST"); // ← read-only, cannot be set
+```
+
+### ✅ Correct
+
+```js
+// Reading properties — no parentheses
+var method = Platform.Request.Method;
+var ip     = Platform.Request.ClientIP;
+var ct     = Platform.Response.ContentType;
+
+// Setting writable Response properties — use assignment
+Platform.Response.ContentType = "application/json";
+Platform.Response.CharacterSet = "UTF-8";
+
+// Calling real methods — parentheses are correct
+Platform.Request.GetQueryStringParameter("id");
+Platform.Response.Write("<p>Hello</p>");
+```
+
+## Rule details
+
+- **Type:** `problem`
+- **Fixable:** Yes (`code`)
+- **Recommended:** Yes
+- **Strict:** Yes

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

@@ -0,0 +1,57 @@
+# ssjs-no-unknown-function
+
+Flags calls to SFMC API methods that do not exist in the catalog. This single rule replaces the seven narrow `no-unknown-*` rules from earlier versions of the plugin.
+
+## Covered namespaces
+
+| Namespace | Example |
+|---|---|
+| `Platform.Function` | `Platform.Function.LookupRows(…)` |
+| `Platform.Variable` | `Platform.Variable.GetValue(…)` |
+| `Platform.Request` | `Platform.Request.GetQueryStringParameter(…)` |
+| `Platform.Response` | `Platform.Response.Write(…)` |
+| `Platform.Recipient` | `Platform.Recipient.GetAttributeValue(…)` |
+| `HTTP` | `HTTP.Get(…)` |
+| Core Library instance methods | `de.Rows.Retrieve()` (tracked from `DataExtension.Init(…)`) |
+| WSProxy instance methods | `api.retrieve(…)` (tracked from `new Script.Util.WSProxy()`) |
+
+## Examples
+
+### ❌ Incorrect
+
+```js
+// Typo in Platform.Function method name
+Platform.Function.FetchRows('MyDE', 'Status', 'Active');
+
+// Non-existent WSProxy method
+var api = new Script.Util.WSProxy();
+api.getAllResults({ ObjectType: 'DataExtension' });
+
+// Unknown Core Library method on a DataExtension instance
+var de = DataExtension.Init('CustomerData');
+de.ExportRows();
+```
+
+### ✅ Correct
+
+```js
+Platform.Function.LookupRows('MyDE', 'Status', 'Active');
+
+var api = new Script.Util.WSProxy();
+api.retrieve({ ObjectType: 'DataExtension' }, ['CustomerKey', 'Name'], {});
+
+var de = DataExtension.Init('CustomerData');
+de.Rows.Retrieve();
+```
+
+## When to use
+
+Enable this rule to catch typos, outdated method names, and unsupported API calls before
+they cause runtime failures.
+
+## Rule details
+
+- **Type:** `problem`
+- **Fixable:** No
+- **Recommended:** Yes
+- **Strict:** Yes

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "eslint-plugin-sfmc",
-    "version": "0.2.0",
+    "version": "1.0.0",
     "description": "ESLint plugin for Salesforce Marketing Cloud — AMPscript and Server-Side JavaScript (SSJS)",
     "type": "module",
     "main": "src/index.js",

package/src/index.js

@@ -9,7 +9,6 @@
  *   - vscode-sfmc-language (IntelliSense, diagnostics)
  */
 
-import { SSJS_GLOBALS_MAP } from 'ssjs-data';
 import * as ampscriptParser from './ampscript-parser.js';
 
 // ── AMPscript rules ───────────────────────────────────────────────────────────
@@ -38,15 +37,10 @@ import ampNoNestedAmpscriptDelimiter from './rules/amp/no-nested-ampscript-delim
 
 import ssjsRequirePlatformLoad from './rules/ssjs/require-platform-load.js';
 import ssjsNoUnsupportedSyntax from './rules/ssjs/no-unsupported-syntax.js';
-import ssjsNoUnknownPlatformFunction from './rules/ssjs/no-unknown-platform-function.js';
-import ssjsNoUnknownCoreMethod from './rules/ssjs/no-unknown-core-method.js';
+import ssjsNoUnknownFunction from './rules/ssjs/no-unknown-function.js';
+import ssjsNoDeprecatedFunction from './rules/ssjs/no-deprecated-function.js';
+import ssjsNoPropertyCall from './rules/ssjs/no-property-call.js';
 import ssjsPlatformFunctionArity from './rules/ssjs/platform-function-arity.js';
-import ssjsNoUnknownHttpMethod from './rules/ssjs/no-unknown-http-method.js';
-import ssjsNoUnknownWsproxyMethod from './rules/ssjs/no-unknown-wsproxy-method.js';
-import ssjsNoUnknownPlatformVariable from './rules/ssjs/no-unknown-platform-variable.js';
-import ssjsNoUnknownPlatformResponse from './rules/ssjs/no-unknown-platform-response.js';
-import ssjsNoUnknownPlatformRequest from './rules/ssjs/no-unknown-platform-request.js';
-import ssjsNoUnknownPlatformClientBrowser from './rules/ssjs/no-unknown-platform-client-browser.js';
 import ssjsCacheLoopLength from './rules/ssjs/cache-loop-length.js';
 import ssjsRequireHasownproperty from './rules/ssjs/require-hasownproperty.js';
 import ssjsRequirePlatformLoadOrder from './rules/ssjs/require-platform-load-order.js';
@@ -65,6 +59,9 @@ import ampscriptProcessor from './ampscript-processor.js';
 import ssjsProcessor from './ssjs-processor.js';
 import combinedProcessor from './processor.js';
 
+// ── Data imports ──────────────────────────────────────────────────────────────
+import { SSJS_GLOBALS_MAP } from 'ssjs-data';
+
 // ── Plugin definition ─────────────────────────────────────────────────────────
 
 const plugin = {
@@ -98,15 +95,10 @@ const plugin = {
         // SSJS rules (ssjs- prefix)
         'ssjs-require-platform-load': ssjsRequirePlatformLoad,
         'ssjs-no-unsupported-syntax': ssjsNoUnsupportedSyntax,
-        'ssjs-no-unknown-platform-function': ssjsNoUnknownPlatformFunction,
-        'ssjs-no-unknown-core-method': ssjsNoUnknownCoreMethod,
+        'ssjs-no-unknown-function': ssjsNoUnknownFunction,
+        'ssjs-no-deprecated-function': ssjsNoDeprecatedFunction,
+        'ssjs-no-property-call': ssjsNoPropertyCall,
         'ssjs-platform-function-arity': ssjsPlatformFunctionArity,
-        'ssjs-no-unknown-http-method': ssjsNoUnknownHttpMethod,
-        'ssjs-no-unknown-wsproxy-method': ssjsNoUnknownWsproxyMethod,
-        'ssjs-no-unknown-platform-variable': ssjsNoUnknownPlatformVariable,
-        'ssjs-no-unknown-platform-response': ssjsNoUnknownPlatformResponse,
-        'ssjs-no-unknown-platform-request': ssjsNoUnknownPlatformRequest,
-        'ssjs-no-unknown-platform-client-browser': ssjsNoUnknownPlatformClientBrowser,
         'ssjs-cache-loop-length': ssjsCacheLoopLength,
         'ssjs-require-hasownproperty': ssjsRequireHasownproperty,
         'ssjs-require-platform-load-order': ssjsRequirePlatformLoadOrder,
@@ -177,15 +169,10 @@ const ampStrictRules = {
 const ssjsRecommendedRules = {
     'sfmc/ssjs-require-platform-load': 'error',
     'sfmc/ssjs-no-unsupported-syntax': 'error',
-    'sfmc/ssjs-no-unknown-platform-function': 'error',
-    'sfmc/ssjs-no-unknown-core-method': 'warn',
+    'sfmc/ssjs-no-unknown-function': 'error',
+    'sfmc/ssjs-no-deprecated-function': 'error',
+    'sfmc/ssjs-no-property-call': 'error',
     'sfmc/ssjs-platform-function-arity': 'error',
-    'sfmc/ssjs-no-unknown-http-method': 'error',
-    'sfmc/ssjs-no-unknown-wsproxy-method': 'warn',
-    'sfmc/ssjs-no-unknown-platform-variable': 'error',
-    'sfmc/ssjs-no-unknown-platform-response': 'error',
-    'sfmc/ssjs-no-unknown-platform-request': 'error',
-    'sfmc/ssjs-no-unknown-platform-client-browser': 'error',
     'sfmc/ssjs-cache-loop-length': 'warn',
     'sfmc/ssjs-require-hasownproperty': 'warn',
     'sfmc/ssjs-require-platform-load-order': 'error',
@@ -203,15 +190,10 @@ const ssjsRecommendedRules = {
 const ssjsStrictRules = {
     'sfmc/ssjs-require-platform-load': 'error',
     'sfmc/ssjs-no-unsupported-syntax': 'error',
-    'sfmc/ssjs-no-unknown-platform-function': 'error',
-    'sfmc/ssjs-no-unknown-core-method': 'error',
+    'sfmc/ssjs-no-unknown-function': 'error',
+    'sfmc/ssjs-no-deprecated-function': 'error',
+    'sfmc/ssjs-no-property-call': 'error',
     'sfmc/ssjs-platform-function-arity': 'error',
-    'sfmc/ssjs-no-unknown-http-method': 'error',
-    'sfmc/ssjs-no-unknown-wsproxy-method': 'error',
-    'sfmc/ssjs-no-unknown-platform-variable': 'error',
-    'sfmc/ssjs-no-unknown-platform-response': 'error',
-    'sfmc/ssjs-no-unknown-platform-request': 'error',
-    'sfmc/ssjs-no-unknown-platform-client-browser': 'error',
     'sfmc/ssjs-cache-loop-length': 'error',
     'sfmc/ssjs-require-hasownproperty': 'error',
     'sfmc/ssjs-require-platform-load-order': 'error',

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

@@ -0,0 +1,181 @@
+/**
+ * Rule: ssjs-no-deprecated-function
+ *
+ * Flags use of deprecated SFMC SSJS APIs. Currently covers:
+ *
+ *   - ContentArea(...)             — bare alias (use Platform.Function.ContentAreaByName instead)
+ *   - ContentAreaByName(...)       — bare alias (use Platform.Function.ContentAreaByName instead)
+ *   - Platform.Function.ContentArea(...)
+ *   - Platform.Function.ContentAreaByName(...)
+ *   - ContentAreaObj.Init(...)     — static method (class is deprecated)
+ *   - ContentAreaObj.Add(...)      — static method
+ *   - ContentAreaObj.Retrieve(...) — static method
+ *   - <contentAreaObjVar>.Update(...) — instance method on a tracked ContentAreaObj variable
+ *   - <contentAreaObjVar>.Remove()    — instance method on a tracked ContentAreaObj variable
+ */
+
+import { platformFunctionLookup, SSJS_GLOBALS, CONTENT_AREA_OBJ_METHODS } from 'ssjs-data';
+
+// Lookup Map: lowercase name → entry, for SSJS_GLOBALS entries that are deprecated.
+// Used to flag bare calls like ContentArea(...) and ContentAreaByName(...).
+const DEPRECATED_GLOBALS = new Map(
+    SSJS_GLOBALS.filter((g) => g.deprecated).map((g) => [g.name.toLowerCase(), g]),
+);
+
+// Build sets of deprecated static and instance methods from ssjs-data.
+// Exclude 'Init' — that call is already implicitly covered when we track the
+// returned instance and flag its instance methods. Reporting it here as well
+// would produce a duplicate error on the same statement.
+const CONTENT_AREA_STATIC_DEPRECATED = new Set(
+    CONTENT_AREA_OBJ_METHODS.filter(
+        (m) => m.deprecated && m.isStatic && m.name.toLowerCase() !== 'init',
+    ).map((m) => m.name.toLowerCase()),
+);
+
+const CONTENT_AREA_INSTANCE_DEPRECATED = new Set(
+    CONTENT_AREA_OBJ_METHODS.filter((m) => m.deprecated && !m.isStatic).map((m) =>
+        m.name.toLowerCase(),
+    ),
+);
+
+export default {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow use of deprecated SFMC SSJS APIs',
+        },
+        messages: {
+            deprecatedGlobal: "'{{name}}' is deprecated. {{replacement}}",
+            deprecatedPlatformFunction:
+                "'Platform.Function.{{name}}' is deprecated. Use a supported alternative.",
+            deprecatedCoreStatic:
+                "'ContentAreaObj.{{name}}' is deprecated. Content Areas are no longer supported.",
+            deprecatedCoreInstance:
+                "'{{method}}' called on a ContentAreaObj variable is deprecated. Content Areas are no longer supported.",
+        },
+        schema: [],
+    },
+
+    create(context) {
+        // Track variable names assigned via ContentAreaObj.Init()
+        const contentAreaVariables = new Set();
+
+        return {
+            VariableDeclaration(node) {
+                for (const decl of node.declarations) {
+                    if (
+                        decl.init &&
+                        decl.id &&
+                        decl.id.type === 'Identifier' &&
+                        isContentAreaObjInit(decl.init)
+                    ) {
+                        contentAreaVariables.add(decl.id.name);
+                    }
+                }
+            },
+
+            AssignmentExpression(node) {
+                if (node.left.type === 'Identifier' && isContentAreaObjInit(node.right)) {
+                    contentAreaVariables.add(node.left.name);
+                }
+            },
+
+            CallExpression(node) {
+                const callee = node.callee;
+
+                // ── Bare globals: ContentArea(…) and ContentAreaByName(…) ──────
+                if (callee.type === 'Identifier') {
+                    const entry = DEPRECATED_GLOBALS.get(callee.name.toLowerCase());
+                    if (entry && entry.deprecated) {
+                        const replacement = entry.aliasOf
+                            ? `Use '${entry.aliasOf}' instead.`
+                            : 'Use a supported alternative.';
+                        context.report({
+                            node: callee,
+                            messageId: 'deprecatedGlobal',
+                            data: { name: callee.name, replacement },
+                        });
+                    }
+                    return;
+                }
+
+                if (callee.type !== 'MemberExpression') {
+                    return;
+                }
+
+                const property = callee.property;
+                if (property.type !== 'Identifier') {
+                    return;
+                }
+
+                const methodName = property.name;
+
+                // ── Platform.Function.ContentArea(…) / ContentAreaByName(…) ───
+                if (
+                    callee.object.type === 'MemberExpression' &&
+                    callee.object.object.type === 'Identifier' &&
+                    callee.object.object.name === 'Platform' &&
+                    callee.object.property.type === 'Identifier' &&
+                    callee.object.property.name === 'Function'
+                ) {
+                    const entry = platformFunctionLookup.get(methodName.toLowerCase());
+                    if (entry && entry.deprecated) {
+                        context.report({
+                            node: property,
+                            messageId: 'deprecatedPlatformFunction',
+                            data: { name: methodName },
+                        });
+                    }
+                    return;
+                }
+
+                // ── ContentAreaObj.Init/Add/Retrieve(…) — static deprecated ───
+                if (
+                    callee.object.type === 'Identifier' &&
+                    callee.object.name === 'ContentAreaObj' &&
+                    CONTENT_AREA_STATIC_DEPRECATED.has(methodName.toLowerCase())
+                ) {
+                    context.report({
+                        node: property,
+                        messageId: 'deprecatedCoreStatic',
+                        data: { name: methodName },
+                    });
+                    return;
+                }
+
+                // ── <contentAreaVar>.Update/Remove() — instance deprecated ─────
+                if (
+                    callee.object.type === 'Identifier' &&
+                    contentAreaVariables.has(callee.object.name) &&
+                    CONTENT_AREA_INSTANCE_DEPRECATED.has(methodName.toLowerCase())
+                ) {
+                    context.report({
+                        node: property,
+                        messageId: 'deprecatedCoreInstance',
+                        data: { method: methodName },
+                    });
+                }
+            },
+        };
+    },
+};
+
+/**
+ * Returns true if `node` is a `ContentAreaObj.Init(…)` call.
+ *
+ * @param {import('eslint').Rule.Node} node
+ * @returns {boolean}
+ */
+function isContentAreaObjInit(node) {
+    if (!node || node.type !== 'CallExpression') {
+        return false;
+    }
+    const callee = node.callee;
+    return (
+        callee.type === 'MemberExpression' &&
+        callee.object.type === 'Identifier' &&
+        callee.object.name === 'ContentAreaObj' &&
+        callee.property.type === 'Identifier' &&
+        callee.property.name === 'Init'
+    );
+}

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 },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};