eslint-plugin-sfmc 0.1.3 → 1.0.0

package/src/rules/ssjs/require-hasownproperty.js

@@ -31,7 +31,9 @@ export default {
 
                 const stmts = body.type === 'BlockStatement' ? body.body : [body];
 
-                if (stmts.length === 0) return;
+                if (stmts.length === 0) {
+                    return;
+                }
 
                 const hasGuard = stmts.some((stmt) => containsHasOwnProperty(stmt));
 
@@ -42,34 +44,32 @@ export default {
                     context.report({
                         node,
                         messageId: 'missingGuard',
-                        suggest:
-                            keyName
-                                ? [
-                                      {
-                                          messageId: 'suggestAddGuard',
-                                          data: { obj: objText, key: keyName },
-                                          fix(fixer) {
-                                              if (body.type === 'BlockStatement') {
-                                                  // Wrap the inner content of the existing block.
-                                                  const inner = context.sourceCode
-                                                      .getText(body)
-                                                      .slice(1, -1);
-                                                  return fixer.replaceText(
-                                                      body,
-                                                      `{ if (${objText}.hasOwnProperty(${keyName})) {${inner}} }`,
-                                                  );
-                                              }
-                                              // Single-statement body — create a new block with guard.
-                                              const stmtText =
-                                                  context.sourceCode.getText(body);
+                        suggest: keyName
+                            ? [
+                                  {
+                                      messageId: 'suggestAddGuard',
+                                      data: { obj: objText, key: keyName },
+                                      fix(fixer) {
+                                          if (body.type === 'BlockStatement') {
+                                              // Wrap the inner content of the existing block.
+                                              const inner = context.sourceCode
+                                                  .getText(body)
+                                                  .slice(1, -1);
                                               return fixer.replaceText(
                                                   body,
-                                                  `{ if (${objText}.hasOwnProperty(${keyName})) { ${stmtText} } }`,
+                                                  `{ if (${objText}.hasOwnProperty(${keyName})) {${inner}} }`,
                                               );
-                                          },
+                                          }
+                                          // Single-statement body — create a new block with guard.
+                                          const stmtText = context.sourceCode.getText(body);
+                                          return fixer.replaceText(
+                                              body,
+                                              `{ if (${objText}.hasOwnProperty(${keyName})) { ${stmtText} } }`,
+                                          );
                                       },
-                                  ]
-                                : [],
+                                  },
+                              ]
+                            : [],
                     });
                 }
             },
@@ -78,7 +78,9 @@ export default {
 };
 
 function containsHasOwnProperty(node) {
-    if (!node) return false;
+    if (!node) {
+        return false;
+    }
 
     if (node.type === 'IfStatement' && node.test && hasOwnPropertyTest(node.test)) {
         return true;
@@ -104,7 +106,9 @@ function containsHasOwnProperty(node) {
 }
 
 function hasOwnPropertyTest(node) {
-    if (!node) return false;
+    if (!node) {
+        return false;
+    }
 
     if (
         node.type === 'CallExpression' &&
@@ -129,6 +133,9 @@ function hasOwnPropertyTest(node) {
 /**
  * Extracts the loop key variable name from a for-in left-hand side.
  * Handles both `for (var k in obj)` and `for (k in obj)`.
+ *
+ * @param left - The left-hand side node of a ForInStatement.
+ * @returns The key variable name, or null if it cannot be determined.
  */
 function getKeyName(left) {
     if (left.type === 'VariableDeclaration' && left.declarations.length > 0) {

package/src/rules/ssjs/require-platform-load-order.js

@@ -44,7 +44,9 @@ export default {
             },
 
             'Program:exit'() {
-                if (platformLoadLine === null) return;
+                if (platformLoadLine === null) {
+                    return;
+                }
 
                 for (const usage of coreUsages) {
                     if (usage.line < platformLoadLine) {
@@ -87,7 +89,9 @@ function isPlatformLoadCall(node) {
 
 function getCoreObjectUsage(node) {
     const callee = node.callee;
-    if (callee.type !== 'MemberExpression') return null;
+    if (callee.type !== 'MemberExpression') {
+        return null;
+    }
 
     if (
         callee.object.type === 'MemberExpression' &&

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 {
@@ -49,8 +55,7 @@ export default {
 
             'Program:exit'() {
                 if (!hasPlatformLoad) {
-                    for (let i = 0; i < pendingReports.length; i++) {
-                        const { node, name } = pendingReports[i];
+                    for (const [i, { node, name }] of pendingReports.entries()) {
                         context.report({
                             node,
                             messageId: 'missingLoad',
@@ -97,8 +102,20 @@ function isPlatformLoadCall(node) {
 
 function getCoreObjectUsage(node) {
     const callee = node.callee;
-    if (callee.type !== 'MemberExpression') return null;
 
+    // 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' &&
@@ -109,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/src/rules/ssjs/ssjs-arg-types.js

@@ -0,0 +1,345 @@
+/**
+ * Rule: ssjs-arg-types
+ *
+ * Checks that literal arguments match the expected parameter types for known
+ * SSJS functions and methods. Only literal values are checked — variable
+ * arguments are skipped because their type cannot be determined statically.
+ *
+ * Covers:
+ *   - Platform.Function.*, Platform.Variable.*, Platform.Response.*,
+ *     Platform.Request.*, Platform.Recipient.*
+ *   - HTTP.*, HTTPHeader.*, Attribute.*
+ *   - WSProxy instance methods
+ *   - Core Library static calls (DataExtension.Init, BounceEvent.Retrieve, …)
+ *   - Core Library instance methods (var de = DataExtension.Init(…); de.Add(…))
+ *   - Global functions (Format, String, Error)
+ */
+
+import {
+    platformFunctionLookup,
+    platformResponseLookup,
+    platformVariableLookup,
+    platformRequestLookup,
+    platformRecipientLookup,
+    httpMethodLookup,
+    httpHeaderMethodLookup,
+    wsproxyMethodLookup,
+    attributeMethodLookup,
+    ssjsGlobalsLookup,
+    coreMethodArityLookup,
+    coreObjectNames,
+} from 'ssjs-data';
+
+// Platform.SubNS → lookup Map
+const PLATFORM_SUBNS_LOOKUPS = new Map([
+    ['function', platformFunctionLookup],
+    ['variable', platformVariableLookup],
+    ['response', platformResponseLookup],
+    ['request', platformRequestLookup],
+    ['recipient', platformRecipientLookup],
+]);
+
+// Top-level non-Platform objects with static method lookups
+const TOPLEVEL_LOOKUPS = new Map([
+    ['http', httpMethodLookup],
+    ['httpheader', httpHeaderMethodLookup],
+    ['attribute', attributeMethodLookup],
+]);
+
+export default {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description:
+                'Check that literal arguments match expected parameter types for SSJS functions',
+        },
+        messages: {
+            typeMismatch:
+                "Argument {{pos}} ('{{param}}') of '{{call}}' expects type '{{expected}}' but received '{{actual}}'.",
+        },
+        schema: [],
+    },
+
+    create(context) {
+        const coreVars = new Map(); // varName → className (Core Library instances)
+        const wsproxyVars = new Set(); // varNames assigned new WSProxy()
+
+        function checkArgs(entry, args, callName) {
+            if (!entry || !entry.params || entry.params.length === 0) {
+                return;
+            }
+            for (const [i, arg] of args.entries()) {
+                const param = entry.params[i];
+                if (!param) {
+                    break;
+                } // beyond declared params — arity rule handles this
+                if (!param.type || param.type === 'any') {
+                    continue;
+                }
+                const actual = inferArgType(arg);
+                if (actual === null) {
+                    continue;
+                } // unknown type (variable/call) — skip
+                if (!isTypeCompatible(actual, param.type)) {
+                    context.report({
+                        node: arg,
+                        messageId: 'typeMismatch',
+                        data: {
+                            pos: String(i + 1),
+                            param: param.name,
+                            call: callName,
+                            expected: param.type,
+                            actual,
+                        },
+                    });
+                }
+            }
+        }
+
+        return {
+            VariableDeclaration(node) {
+                for (const decl of node.declarations) {
+                    if (!decl.init || !decl.id || decl.id.type !== 'Identifier') {
+                        continue;
+                    }
+                    if (isWSProxyConstructor(decl.init)) {
+                        wsproxyVars.add(decl.id.name);
+                        continue;
+                    }
+                    const coreType = getCoreInitType(decl.init);
+                    if (coreType) {
+                        coreVars.set(decl.id.name, coreType);
+                    }
+                }
+            },
+
+            AssignmentExpression(node) {
+                if (node.left.type !== 'Identifier') {
+                    return;
+                }
+                if (isWSProxyConstructor(node.right)) {
+                    wsproxyVars.add(node.left.name);
+                    return;
+                }
+                const coreType = getCoreInitType(node.right);
+                if (coreType) {
+                    coreVars.set(node.left.name, coreType);
+                }
+            },
+
+            CallExpression(node) {
+                const callee = node.callee;
+
+                // Global function: Format(...), String(...), Error(...)
+                if (callee.type === 'Identifier') {
+                    const entry = ssjsGlobalsLookup.get(callee.name.toLowerCase());
+                    if (entry) {
+                        checkArgs(entry, node.arguments, callee.name);
+                    }
+                    return;
+                }
+
+                if (callee.type !== 'MemberExpression') {
+                    return;
+                }
+                if (callee.property.type !== 'Identifier') {
+                    return;
+                }
+                const methodName = callee.property.name;
+
+                // Platform.SubNS.Method(...): Platform.Function.X, Platform.Response.X, …
+                if (
+                    callee.object.type === 'MemberExpression' &&
+                    callee.object.object.type === 'Identifier' &&
+                    callee.object.object.name === 'Platform' &&
+                    callee.object.property.type === 'Identifier'
+                ) {
+                    const subNs = callee.object.property.name.toLowerCase();
+                    const lookup = PLATFORM_SUBNS_LOOKUPS.get(subNs);
+                    if (lookup) {
+                        const entry = lookup.get(methodName.toLowerCase());
+                        if (entry) {
+                            checkArgs(
+                                entry,
+                                node.arguments,
+                                `Platform.${callee.object.property.name}.${methodName}`,
+                            );
+                        }
+                    }
+                    return;
+                }
+
+                if (callee.object.type === 'Identifier') {
+                    const objName = callee.object.name;
+                    const objLower = objName.toLowerCase();
+
+                    // Static top-level: HTTP.Post(...), HTTPHeader.SetValue(...), Attribute.GetValue(...)
+                    const topLookup = TOPLEVEL_LOOKUPS.get(objLower);
+                    if (topLookup) {
+                        const entry = topLookup.get(methodName.toLowerCase());
+                        if (entry) {
+                            checkArgs(entry, node.arguments, `${objName}.${methodName}`);
+                        }
+                        return;
+                    }
+
+                    // WSProxy instance method: proxy.Retrieve(...)
+                    if (wsproxyVars.has(objName)) {
+                        const entry = wsproxyMethodLookup.get(methodName.toLowerCase());
+                        if (entry) {
+                            checkArgs(entry, node.arguments, `WSProxy.${methodName}`);
+                        }
+                        return;
+                    }
+
+                    // 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());
+                            if (entry) {
+                                checkArgs(entry, node.arguments, `${coreType}.${methodName}`);
+                            }
+                        }
+                        return;
+                    }
+
+                    // Static Core Library single-name: DataExtension.Init(...), BounceEvent.Retrieve(...)
+                    if (coreObjectNames.has(objName)) {
+                        const classLookup = coreMethodArityLookup.get(objLower);
+                        if (classLookup) {
+                            const entry = classLookup.get(methodName.toLowerCase());
+                            if (entry) {
+                                checkArgs(entry, node.arguments, `${objName}.${methodName}`);
+                            }
+                        }
+                    }
+                    return;
+                }
+
+                // Multi-part static: 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());
+                        if (entry) {
+                            checkArgs(entry, node.arguments, `${objectPath}.${methodName}`);
+                        }
+                    }
+                }
+            },
+        };
+    },
+};
+
+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;
+}
+
+function inferArgType(node) {
+    if (!node || node.type === 'SpreadElement') {
+        return null;
+    }
+    if (node.type === 'Literal') {
+        if (typeof node.value === 'string') {
+            return 'string';
+        }
+        if (typeof node.value === 'number') {
+            return 'number';
+        }
+        if (typeof node.value === 'boolean') {
+            return 'boolean';
+        }
+        if (node.value === null) {
+            return 'null';
+        }
+    }
+    if (node.type === 'TemplateLiteral' && !node.tag) {
+        return 'string';
+    }
+    if (node.type === 'ArrayExpression') {
+        const elems = node.elements.filter(Boolean);
+        if (elems.length === 0) {
+            return 'array';
+        }
+        if (elems.every((e) => e.type === 'Literal' && typeof e.value === 'string')) {
+            return 'string[]';
+        }
+        if (elems.every((e) => e.type === 'Literal' && typeof e.value === 'number')) {
+            return 'number[]';
+        }
+        return 'array';
+    }
+    if (node.type === 'ObjectExpression') {
+        return 'object';
+    }
+    return null;
+}
+
+function isTypeCompatible(actual, expected) {
+    if (!expected || expected === 'any') {
+        return true;
+    }
+    const allowed = expected.split('|').map((t) => t.trim());
+    if (allowed.includes(actual)) {
+        return true;
+    }
+    // 'array' is compatible with typed array variants
+    if (allowed.includes('array') && (actual === 'string[]' || actual === 'number[]')) {
+        return true;
+    }
+    return false;
+}
+
+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'
+    );
+}