eslint-plugin-sfmc 0.1.3 → 1.0.0

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

@@ -1,50 +0,0 @@
-/**
- * Rule: no-unknown-platform-client-browser
- *
- * Flags calls to Platform.ClientBrowser.* where the method name does not
- * exist in the known SFMC Platform.ClientBrowser catalog.
- */
-
-import { PLATFORM_CLIENT_BROWSER_METHODS } from 'ssjs-data';
-
-const knownMethods = new Set(PLATFORM_CLIENT_BROWSER_METHODS.map((m) => m.name.toLowerCase()));
-
-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,49 +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,50 +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,50 +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,50 +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,71 +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 &&
-                        decl.init.type === 'NewExpression' &&
-                        decl.init.callee.type === 'Identifier' &&
-                        decl.init.callee.name === 'WSProxy'
-                    ) {
-                        wsproxyVariables.add(decl.id.name);
-                    }
-                }
-            },
-
-            AssignmentExpression(node) {
-                if (
-                    node.left.type === 'Identifier' &&
-                    node.right.type === 'NewExpression' &&
-                    node.right.callee.type === 'Identifier' &&
-                    node.right.callee.name === 'WSProxy'
-                ) {
-                    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 },
-                    });
-                }
-            },
-        };
-    },
-};