eslint-plugin-sfmc 0.1.0

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

@@ -0,0 +1,112 @@
+/**
+ * Rule: require-platform-load-order
+ *
+ * Warns when Core library .Init() calls appear *before*
+ * Platform.Load("core", ...) in source order. Unlike require-platform-load
+ * which only checks existence, this rule checks ordering.
+ */
+
+import { coreObjectNames } from 'ssjs-data';
+
+const TOP_LEVEL_CORE_NAMES = new Set([...coreObjectNames].map((n) => n.split('.')[0]));
+
+export default {
+    meta: {
+        type: 'problem',
+        docs: {
+            description:
+                'Require Platform.Load() to appear before Core library usage in source order',
+        },
+        messages: {
+            loadAfterUse:
+                'Platform.Load("core", ...) must appear before "{{name}}" usage at line {{useLine}}. Move it earlier in the file.',
+        },
+        schema: [],
+    },
+
+    create(context) {
+        let platformLoadLine = null;
+        const coreUsages = [];
+
+        return {
+            CallExpression(node) {
+                if (isPlatformLoadCall(node)) {
+                    if (platformLoadLine === null) {
+                        platformLoadLine = node.loc.start.line;
+                    }
+                    return;
+                }
+
+                const coreName = getCoreObjectUsage(node);
+                if (coreName) {
+                    coreUsages.push({ node, name: coreName, line: node.loc.start.line });
+                }
+            },
+
+            'Program:exit'() {
+                if (platformLoadLine === null) return;
+
+                for (const usage of coreUsages) {
+                    if (usage.line < platformLoadLine) {
+                        context.report({
+                            node: usage.node,
+                            messageId: 'loadAfterUse',
+                            data: {
+                                name: usage.name,
+                                useLine: String(usage.line),
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+
+function isPlatformLoadCall(node) {
+    const callee = node.callee;
+    if (
+        callee.type === 'MemberExpression' &&
+        callee.object.type === 'Identifier' &&
+        callee.object.name === 'Platform' &&
+        callee.property.type === 'Identifier' &&
+        callee.property.name === 'Load'
+    ) {
+        const arguments_ = node.arguments;
+        if (
+            arguments_.length > 0 &&
+            arguments_[0].type === 'Literal' &&
+            typeof arguments_[0].value === 'string' &&
+            arguments_[0].value.toLowerCase() === 'core'
+        ) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function getCoreObjectUsage(node) {
+    const callee = node.callee;
+    if (callee.type !== 'MemberExpression') return null;
+
+    if (
+        callee.object.type === 'MemberExpression' &&
+        callee.object.object.type === 'Identifier' &&
+        TOP_LEVEL_CORE_NAMES.has(callee.object.object.name) &&
+        callee.object.property.type === 'Identifier' &&
+        callee.property.type === 'Identifier'
+    ) {
+        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' &&
+        callee.property.name === 'Init'
+    ) {
+        return callee.object.name;
+    }
+
+    return null;
+}

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

@@ -0,0 +1,124 @@
+/**
+ * Rule: require-platform-load
+ *
+ * Ensures Platform.Load("core", "1") is called before any Core library
+ * object constructors are used. Without this call, Core library objects
+ * like DataExtension.Init() crash at runtime.
+ *
+ * Auto-fix: inserts Platform.Load("core", "1.1.5") at the very top of the
+ * file when it is entirely absent. The fix is only attached to the first
+ * reported violation so ESLint does not duplicate the insertion.
+ */
+
+import { coreObjectNames } from 'ssjs-data';
+
+const TOP_LEVEL_CORE_NAMES = new Set([...coreObjectNames].map((n) => n.split('.')[0]));
+
+const PLATFORM_LOAD_STATEMENT = 'Platform.Load("core", "1.1.5");\n';
+
+export default {
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            description: 'Require Platform.Load() before using Core library objects',
+        },
+        messages: {
+            missingLoad:
+                'Platform.Load("core", "1") must be called before using Core library object "{{name}}". Without it, the call will fail at runtime.',
+        },
+        schema: [],
+    },
+
+    create(context) {
+        let hasPlatformLoad = false;
+        const pendingReports = [];
+
+        return {
+            CallExpression(node) {
+                if (isPlatformLoadCall(node)) {
+                    hasPlatformLoad = true;
+                    return;
+                }
+
+                const coreName = getCoreObjectUsage(node);
+                if (coreName && !hasPlatformLoad) {
+                    pendingReports.push({ node, name: coreName });
+                }
+            },
+
+            'Program:exit'() {
+                if (!hasPlatformLoad) {
+                    for (let i = 0; i < pendingReports.length; i++) {
+                        const { node, name } = pendingReports[i];
+                        context.report({
+                            node,
+                            messageId: 'missingLoad',
+                            data: { name },
+                            // Only attach the fix to the first violation to prevent
+                            // ESLint from inserting the statement multiple times.
+                            fix:
+                                i === 0
+                                    ? (fixer) =>
+                                          fixer.insertTextBeforeRange(
+                                              [0, 0],
+                                              PLATFORM_LOAD_STATEMENT,
+                                          )
+                                    : undefined,
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+
+function isPlatformLoadCall(node) {
+    const callee = node.callee;
+    if (
+        callee.type === 'MemberExpression' &&
+        callee.object.type === 'Identifier' &&
+        callee.object.name === 'Platform' &&
+        callee.property.type === 'Identifier' &&
+        callee.property.name === 'Load'
+    ) {
+        const arguments_ = node.arguments;
+        if (
+            arguments_.length > 0 &&
+            arguments_[0].type === 'Literal' &&
+            typeof arguments_[0].value === 'string' &&
+            arguments_[0].value.toLowerCase() === 'core'
+        ) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function getCoreObjectUsage(node) {
+    const callee = node.callee;
+    if (callee.type !== 'MemberExpression') return null;
+
+    if (
+        callee.object.type === 'MemberExpression' &&
+        callee.object.object.type === 'Identifier' &&
+        TOP_LEVEL_CORE_NAMES.has(callee.object.object.name) &&
+        callee.object.property.type === 'Identifier' &&
+        callee.property.type === 'Identifier'
+    ) {
+        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;
+        }
+    }
+
+    return null;
+}

package/src/ssjs-processor.js

@@ -0,0 +1,48 @@
+/**
+ * ESLint processor that extracts SSJS blocks from HTML/AMPscript files.
+ *
+ * Detects <script runat="server"> blocks (without language="ampscript")
+ * and returns them as JavaScript code blocks for ESLint to lint.
+ * Line offsets are preserved so ESLint reports errors at correct locations.
+ */
+
+const SCRIPT_OPEN_RE =
+    /<script\b(?=[^>]*\brunat\s*=\s*['"]server['"])(?![^>]*\blanguage\s*=\s*['"]ampscript['"])[^>]*>/gi;
+const SCRIPT_CLOSE_RE = /<\/script\s*>/gi;
+
+export function preprocess(text, filename) {
+    const blocks = [];
+    let match;
+
+    SCRIPT_OPEN_RE.lastIndex = 0;
+    while ((match = SCRIPT_OPEN_RE.exec(text)) !== null) {
+        const openEnd = match.index + match[0].length;
+
+        SCRIPT_CLOSE_RE.lastIndex = openEnd;
+        const closeMatch = SCRIPT_CLOSE_RE.exec(text);
+        if (!closeMatch) break;
+
+        const jsCode = text.slice(openEnd, closeMatch.index);
+
+        const linesBefore = text.slice(0, openEnd).split('\n');
+        const startLine = linesBefore.length - 1;
+        const padding = '\n'.repeat(startLine);
+
+        blocks.push({
+            text: padding + jsCode,
+            filename: `${filename}/ssjs-block-${blocks.length}.js`,
+        });
+    }
+
+    if (blocks.length === 0) {
+        return [text];
+    }
+
+    return blocks;
+}
+
+export function postprocess(messages, _filename) {
+    return messages.flat();
+}
+
+export default { preprocess, postprocess, supportsAutofix: false };