@servicenow/eslint-plugin-sdk-app-plugin 3.0.3 → 4.0.1

package/.eslintrc.js

@@ -1,16 +1,10 @@
-'use strict';
-
 module.exports = {
-  parserOptions: {
-    ecmaVersion: 'latest',
-  },
-  root: true,
-  extends: [
-    'eslint:recommended',
-    'plugin:eslint-plugin/recommended',
-    'plugin:n/recommended',
-  ],
-  env: {
-    node: true,
-  }
-};
+    parserOptions: {
+        ecmaVersion: 'latest',
+    },
+    root: true,
+    extends: ['eslint:recommended', 'plugin:eslint-plugin/recommended', 'plugin:n/recommended'],
+    env: {
+        node: true,
+    },
+}

package/lib/configs/recommended.js

@@ -2,13 +2,13 @@ const { getRestrictedGlobals } = require('../util/utility')
 const restrictedGlobals = getRestrictedGlobals()
 
 module.exports = {
-    plugins:['@servicenow/sdk-app-plugin'],
-    rules:{
-        '@servicenow/sdk-app-plugin/file-extension-in-import':['error','always'],
-        'no-restricted-globals':['error',...restrictedGlobals],
+    plugins: ['@servicenow/sdk-app-plugin'],
+    rules: {
+        '@servicenow/sdk-app-plugin/file-extension-in-import': ['error', 'always'],
+        'no-restricted-globals': ['error', ...restrictedGlobals],
         '@servicenow/sdk-app-plugin/no-dynamic-import': 'error',
         '@servicenow/sdk-app-plugin/no-regexp-lookbehind-assertions': 'error',
         '@servicenow/sdk-app-plugin/no-regexp-unicode-property-escapes': 'error',
-        '@servicenow/sdk-app-plugin/no-unsupported-node-builtins': 'error'
-    }
-}
+        '@servicenow/sdk-app-plugin/no-unsupported-node-builtins': 'error',
+    },
+}

package/lib/index.js

@@ -1,14 +1,14 @@
 module.exports = {
-    configs:{
-        'recommended':require('./configs/recommended')
+    configs: {
+        recommended: require('./configs/recommended'),
     },
-    rules:{
-        'file-extension-in-import':require('eslint-plugin-n/lib/rules/file-extension-in-import'),
-        'no-async-functions':require('eslint-plugin-es-x/lib/rules/no-async-functions'),
-        'no-promise':require('./rules/no-promise'),
+    rules: {
+        'file-extension-in-import': require('eslint-plugin-n/lib/rules/file-extension-in-import'),
+        'no-async-functions': require('eslint-plugin-es-x/lib/rules/no-async-functions'),
+        'no-promise': require('./rules/no-promise'),
         'no-dynamic-import': require('eslint-plugin-es-x/lib/rules/no-dynamic-import'),
         'no-regexp-lookbehind-assertions': require('eslint-plugin-es-x/lib/rules/no-regexp-lookbehind-assertions'),
         'no-regexp-unicode-property-escapes': require('eslint-plugin-es-x/lib/rules/no-regexp-unicode-property-escapes'),
-        'no-unsupported-node-builtins': require('./rules/no-unsupported-node-builtins')
-    }
-}
+        'no-unsupported-node-builtins': require('./rules/no-unsupported-node-builtins'),
+    },
+}

package/lib/rules/no-promise.js

@@ -13,31 +13,33 @@ module.exports = {
         docs: {
             description: 'disallow the `Promise` class.',
             category: 'ES2015',
-            recommended: false
+            recommended: false,
         },
         fixable: null,
         messages: {
-            forbidden: 'ES2015 Promise class is not supported in now platform.'
+            forbidden: 'ES2015 Promise class is not supported in now platform.',
         },
-        schema:[],
-        type:'problem',
+        schema: [],
+        type: 'problem',
     },
     create(context) {
         return {
             CallExpression(node) {
-                if(node.callee.type === 'MemberExpression' && 
+                if (
+                    node.callee.type === 'MemberExpression' &&
                     node.callee.object.name === 'Promise' &&
                     node.callee.object.type === 'Identifier' &&
-                    PROMISE_STATIC_METHODS[node.callee.property.name]) {
-                    context.report({context,node, messageId:'forbidden'})
+                    PROMISE_STATIC_METHODS[node.callee.property.name]
+                ) {
+                    context.report({ context, node, messageId: 'forbidden' })
                 }
             },
 
             NewExpression(node) {
-                if(node.callee.name === 'Promise') {
-                    context.report({context,node, messageId:'forbidden'})
+                if (node.callee.name === 'Promise') {
+                    context.report({ context, node, messageId: 'forbidden' })
                 }
-            }
+            },
         }
-    }
-}
+    },
+}

package/lib/util/utility.js

@@ -6,7 +6,7 @@ const BROWSER_API_WARNING = 'Web APIs are not supported by the now platform'
 const NO_GLOBAL_THIS = 'ES2020 `globalThis` variable is not supported by the now platform'
 
 const getRestrictedGlobals = () => {
-    const globalRules = [{name:'globalThis', message: NO_GLOBAL_THIS}]
+    const globalRules = [{ name: 'globalThis', message: NO_GLOBAL_THIS }]
     const browserRules = Object.keys(globals.browser)
         .filter((key) => !globalsAllowList.includes(key))
         .map((key) => {
@@ -18,19 +18,53 @@ const getRestrictedGlobals = () => {
     return globalRules.concat(browserRules)
 }
 
-const coreNodeModules = ["assert","buffer","child_process","cluster","crypto","dgram","dns","domain","events","freelist","fs","http","https","module","net","os","path","punycode","querystring","readline","repl","smalloc","stream","string_decoder","sys","timers","tls","tracing","tty","url","util","vm","zlib"]
+const coreNodeModules = [
+    'assert',
+    'buffer',
+    'child_process',
+    'cluster',
+    'crypto',
+    'dgram',
+    'dns',
+    'domain',
+    'events',
+    'freelist',
+    'fs',
+    'http',
+    'https',
+    'module',
+    'net',
+    'os',
+    'path',
+    'punycode',
+    'querystring',
+    'readline',
+    'repl',
+    'smalloc',
+    'stream',
+    'string_decoder',
+    'sys',
+    'timers',
+    'tls',
+    'tracing',
+    'tty',
+    'url',
+    'util',
+    'vm',
+    'zlib',
+]
 
 const getNodeGlobals = () => Object.keys(globals.nodeBuiltin).filter((key) => !globalsAllowList.includes(key))
 
 const createTrackMap = (isNodeGlobals) => {
     const trackMapItems = isNodeGlobals ? getNodeGlobals() : coreNodeModules
     const trackMap = {}
-    
-    for(const item of trackMapItems) {
+
+    for (const item of trackMapItems) {
         trackMap[item] = {
-            [READ] : {
-                name: item
-            }
+            [READ]: {
+                name: item,
+            },
         }
     }
 
@@ -41,5 +75,5 @@ module.exports = {
     getRestrictedGlobals,
     createTrackMap,
     coreNodeModules,
-    getNodeGlobals
-}
+    getNodeGlobals,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@servicenow/eslint-plugin-sdk-app-plugin",
-  "version": "3.0.3",
+  "version": "4.0.1",
   "description": "Plugin to disallow Browser and Node.js APIs not supported in rhino engine",
   "keywords": [
     "eslint",
@@ -26,12 +26,10 @@
   },
   "license": "MIT",
   "engines": {
-    "node": ">=18.16.1",
-    "pnpm": ">=9.4.0"
+    "node": ">=20.18.0",
+    "pnpm": ">=10.8.0"
   },
   "scripts": {
-    "lint": "npm-run-all \"lint:*\"",
-    "lint:js": "eslint .",
     "test": "mocha tests --recursive"
   }
 }

package/tests/rules/no-promise.test.js

@@ -1,26 +1,26 @@
-const { RuleTester } = require('eslint');
-const noPromise = require('../../lib/rules/no-promise');
+const { RuleTester } = require('eslint')
+const noPromise = require('../../lib/rules/no-promise')
 
 const ruleTester = new RuleTester({
-    parserOptions: { ecmaVersion: 2015 }
-});
+    parserOptions: { ecmaVersion: 2015 },
+})
 
 const errorMessages = [{ message: 'ES2015 Promise class is not supported in now platform.' }]
 
-ruleTester.run(
-    'no-promise',
-    noPromise,
-    {
-        valid: [{
+ruleTester.run('no-promise', noPromise, {
+    valid: [
+        {
             code: "const Promise = 'value';",
-        }],
-        invalid: [{
+        },
+    ],
+    invalid: [
+        {
             code: 'const p = new Promise()',
             errors: errorMessages,
         },
         {
             code: 'Promise.all()',
-            errors: errorMessages
-        }],
-    }
-);
+            errors: errorMessages,
+        },
+    ],
+})

package/tests/rules/no-unsupported-node-builtins.test.js

@@ -1,59 +1,60 @@
-const { RuleTester } = require('eslint');
-const noUnsupportedNodeBuiltins = require('../../lib/rules/no-unsupported-node-builtins');
-const { coreNodeModules, getNodeGlobals } = require('../../lib/util/utility');
+const { RuleTester } = require('eslint')
+const noUnsupportedNodeBuiltins = require('../../lib/rules/no-unsupported-node-builtins')
+const { coreNodeModules, getNodeGlobals } = require('../../lib/util/utility')
 
 const ruleTester = new RuleTester({
     parserOptions: { sourceType: 'module' },
-    env: {node: true, es6: true}
-});
+    env: { node: true, es6: true },
+})
 
 const getInvalidsForNoUnsupportedNodeBuiltsRule = () => {
     const invalids = []
     const nodeGlobals = getNodeGlobals()
 
-    for(const module of coreNodeModules) {
+    for (const module of coreNodeModules) {
         invalids.push({
             code: `const ${module} = require('${module}')`,
-            errors: [{ message: `The ${module} Node.js API is not supported in now platform.` }]
+            errors: [{ message: `The ${module} Node.js API is not supported in now platform.` }],
         })
     }
 
-    for(const module of coreNodeModules) {
+    for (const module of coreNodeModules) {
         invalids.push({
             code: `import ${module} from '${module}'`,
-            errors: [{ message: `The ${module} Node.js API is not supported in now platform.` }]
+            errors: [{ message: `The ${module} Node.js API is not supported in now platform.` }],
         })
     }
 
-    for(const global of nodeGlobals) {
+    for (const global of nodeGlobals) {
         invalids.push({
             code: `const x = ${global}`,
-            errors: [{ message: `The ${global} Node.js API is not supported in now platform.` }]
+            errors: [{ message: `The ${global} Node.js API is not supported in now platform.` }],
         })
     }
 
     return invalids
 }
 
-ruleTester.run(
-    'no-unsupported-node-builtins',
-    noUnsupportedNodeBuiltins,
-    {
-        valid: [{
+ruleTester.run('no-unsupported-node-builtins', noUnsupportedNodeBuiltins, {
+    valid: [
+        {
             code: "const fs = {'Dir':'cool'}; const x = fs.Dir",
-        },{
-            code: "const fs = {readFileSync: function(){}}; fs.readFileSync()"
-        },{
-            code: "const Buffer = {from: function(){}}; Buffer.from()"
-        },{
+        },
+        {
+            code: 'const fs = {readFileSync: function(){}}; fs.readFileSync()',
+        },
+        {
+            code: 'const Buffer = {from: function(){}}; Buffer.from()',
+        },
+        {
             code: `const validFunction = () => {
                     fetch("https://api.example.com/data")
                         .then(response => response.json())
                         .then(data => console.log(data))
                         .catch(error => console.error('Error:', error));
                 }; 
-                validFunction();`
-        }],
-        invalid: getInvalidsForNoUnsupportedNodeBuiltsRule()
-    }
-);
+                validFunction();`,
+        },
+    ],
+    invalid: getInvalidsForNoUnsupportedNodeBuiltsRule(),
+})