eslint-plugin-sfmc 0.2.0 → 1.0.0

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

@@ -1,121 +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,47 +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 },
-                    });
-                }
-            },
-        };
-    },
-};

package/src/rules/ssjs/no-unknown-platform-client-browser.js

@@ -1,53 +0,0 @@
-/**
- * Rule: no-unknown-platform-client-browser
- *
- * Flags calls to Platform.ClientBrowser.* — this namespace is deprecated.
- * The methods previously under Platform.ClientBrowser.* are now available
- * under Platform.Response.* (e.g. Platform.Response.Redirect,
- * Platform.Response.SetCookie, Platform.Response.RemoveCookie).
- * All Platform.ClientBrowser.* calls are flagged as unknown.
- */
-
-const knownMethods = new Set();
-
-export default {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Disallow calls to unknown Platform.ClientBrowser methods',
-        },
-        messages: {
-            unknownMethod: "'Platform.ClientBrowser.{{name}}' is not a recognized method.",
-        },
-        schema: [],
-    },
-
-    create(context) {
-        return {
-            CallExpression(node) {
-                const callee = node.callee;
-                if (callee.type !== 'MemberExpression') {
-                    return;
-                }
-
-                if (
-                    callee.object.type === 'MemberExpression' &&
-                    callee.object.object.type === 'Identifier' &&
-                    callee.object.object.name === 'Platform' &&
-                    callee.object.property.type === 'Identifier' &&
-                    callee.object.property.name === 'ClientBrowser' &&
-                    callee.property.type === 'Identifier'
-                ) {
-                    const methodName = callee.property.name;
-                    if (!knownMethods.has(methodName.toLowerCase())) {
-                        context.report({
-                            node: callee.property,
-                            messageId: 'unknownMethod',
-                            data: { name: methodName },
-                        });
-                    }
-                }
-            },
-        };
-    },
-};

package/src/rules/ssjs/no-unknown-platform-function.js

@@ -1,51 +0,0 @@
-/**
- * Rule: no-unknown-platform-function
- *
- * Flags calls to Platform.Function.* where the method name does not
- * exist in the known SFMC Platform.Function catalog.
- */
-
-import { platformFunctionNames } from 'ssjs-data';
-
-export default {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Disallow calls to unknown Platform.Function methods',
-        },
-        messages: {
-            unknownFunction:
-                "'Platform.Function.{{name}}' is not a recognized SFMC Platform function.",
-        },
-        schema: [],
-    },
-
-    create(context) {
-        return {
-            CallExpression(node) {
-                const callee = node.callee;
-                if (callee.type !== 'MemberExpression') {
-                    return;
-                }
-
-                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' &&
-                    callee.property.type === 'Identifier'
-                ) {
-                    const methodName = callee.property.name;
-                    if (!platformFunctionNames.has(methodName.toLowerCase())) {
-                        context.report({
-                            node: callee.property,
-                            messageId: 'unknownFunction',
-                            data: { name: methodName },
-                        });
-                    }
-                }
-            },
-        };
-    },
-};

package/src/rules/ssjs/no-unknown-platform-request.js

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

package/src/rules/ssjs/no-unknown-platform-response.js

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

package/src/rules/ssjs/no-unknown-platform-variable.js

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

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

@@ -1,88 +0,0 @@
-/**
- * Rule: no-unknown-wsproxy-method
- *
- * Flags calls to WSProxy instances where the method name does not
- * exist in the known SFMC WSProxy method catalog.
- */
-
-import { wsproxyMethodNames } from 'ssjs-data';
-
-export default {
-    meta: {
-        type: 'problem',
-        docs: {
-            description: 'Disallow calls to unknown WSProxy methods',
-        },
-        messages: {
-            unknownMethod: "'{{name}}' is not a recognized WSProxy method.",
-        },
-        schema: [],
-    },
-
-    create(context) {
-        const wsproxyVariables = new Set();
-
-        return {
-            VariableDeclaration(node) {
-                for (const decl of node.declarations) {
-                    if (
-                        decl.id &&
-                        decl.id.type === 'Identifier' &&
-                        decl.init &&
-                        isWSProxyConstructor(decl.init)
-                    ) {
-                        wsproxyVariables.add(decl.id.name);
-                    }
-                }
-            },
-
-            AssignmentExpression(node) {
-                if (node.left.type === 'Identifier' && isWSProxyConstructor(node.right)) {
-                    wsproxyVariables.add(node.left.name);
-                }
-            },
-
-            CallExpression(node) {
-                const callee = node.callee;
-                if (callee.type !== 'MemberExpression') {
-                    return;
-                }
-                if (callee.object.type !== 'Identifier') {
-                    return;
-                }
-                if (callee.property.type !== 'Identifier') {
-                    return;
-                }
-
-                if (!wsproxyVariables.has(callee.object.name)) {
-                    return;
-                }
-
-                const methodName = callee.property.name;
-                if (!wsproxyMethodNames.has(methodName.toLowerCase())) {
-                    context.report({
-                        node: callee.property,
-                        messageId: 'unknownMethod',
-                        data: { name: methodName },
-                    });
-                }
-            },
-        };
-    },
-};
-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'
-    );
-}