@servicenow/eslint-plugin-sdk-app-plugin 1.0.1

package/.eslintrc.js

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

package/README.md

@@ -0,0 +1,22 @@
+# @servicenow/eslint-plugin-sdk-app-plugin
+
+Plugin to disallow Browser and Node.js APIs not supported in rhino engine
+
+## Installation
+
+```bash
+npm install && npm i -g .
+```
+
+## Usage
+
+Add `@servicenow/sdk-app-plugin` to the plugins section and update the extends array with "plugin:sdk-app-plugin/recommended" as shown below in your `.eslintrc` configuration file. 
+
+```json
+{
+    "plugins": ["@servicenow/sdk-app-plugin"],
+    "extends": ["plugin:@servicenow/sdk-app-plugin/recommended"]
+}
+```
+
+Refer to [ServiceNow ](https://docs.servicenow.com/bundle/washingtondc-api-reference/page/script/sdk/concept/servicenow-sdk.html) docs for more information

package/lib/configs/recommended.js

@@ -0,0 +1,17 @@
+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],
+        '@servicenow/sdk-app-plugin/no-promise':'error',
+        '@servicenow/sdk-app-plugin/no-async-functions': 'error',
+        '@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',
+        'no-console': 'error',
+        '@servicenow/sdk-app-plugin/no-unsupported-node-builtins': 'error'
+    }
+}

package/lib/index.js

@@ -0,0 +1,14 @@
+module.exports = {
+    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'),
+        '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')
+    }
+}

package/lib/rules/no-promise.js

@@ -0,0 +1,43 @@
+const PROMISE_STATIC_METHODS = {
+    all: true,
+    allSettled: true,
+    any: true,
+    race: true,
+    reject: true,
+    resolve: true,
+    withResolvers: true,
+}
+
+module.exports = {
+    meta: {
+        docs: {
+            description: 'disallow the `Promise` class.',
+            category: 'ES2015',
+            recommended: false
+        },
+        fixable: null,
+        messages: {
+            forbidden: 'ES2015 Promise class is not supported in now platform.'
+        },
+        schema:[],
+        type:'problem',
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                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'})
+                }
+            },
+
+            NewExpression(node) {
+                if(node.callee.name === 'Promise') {
+                    context.report({context,node, messageId:'forbidden'})
+                }
+            }
+        }
+    }
+}

package/lib/rules/no-unsupported-node-builtins.js

@@ -0,0 +1,37 @@
+const { createTrackMap } = require('../util/utility')
+const { ReferenceTracker } = require('@eslint-community/eslint-utils')
+
+module.exports = {
+    meta: {
+        docs: {
+            description: 'disallow unsupported Node.js built-in APIs',
+            recommended: true
+        },
+        fixable: null,
+        messages: {
+            forbidden: 'The {{name}} Node.js API is not supported in now platform.'
+        },
+        schema:[],
+        type:'problem',
+    },
+    create(context) {
+        return {
+            "Program:exit"(node){
+                const sourceCode = context.sourceCode
+                const tracker = new ReferenceTracker(sourceCode.getScope(node), { mode: 'legacy' })
+                const trackMap = createTrackMap(false)
+                const globalsTrackMap = createTrackMap(true)
+                
+                const references = [
+                    ...tracker.iterateCjsReferences(trackMap),
+                    ...tracker.iterateEsmReferences(trackMap),
+                    ...tracker.iterateGlobalReferences(globalsTrackMap)
+                ]
+
+                for(const { node, info } of references) {
+                    context.report({ node, messageId: 'forbidden', data: info })
+                }
+            }
+        }
+    }
+}

package/lib/util/utility.js

@@ -0,0 +1,45 @@
+const globals = require('globals')
+const { READ } = require('@eslint-community/eslint-utils')
+
+const globalsAllowList = []
+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 browserRules = Object.keys(globals.browser)
+        .filter((key) => !globalsAllowList.includes(key))
+        .map((key) => {
+            return {
+                name: key,
+                message: BROWSER_API_WARNING,
+            }
+        })
+    return globalRules.concat(browserRules)
+}
+
+const getCoreNodeModules = () =>  ["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)
+
+const createTrackMap = (isNodeGlobals) => {
+    const trackMapItems = isNodeGlobals ? getNodeGlobals() : getCoreNodeModules()
+    const trackMap = {}
+    
+    for(const item of trackMapItems) {
+        trackMap[item] = {
+            [READ] : {
+                name: item
+            }
+        }
+    }
+
+    return trackMap
+}
+
+module.exports = {
+    getRestrictedGlobals,
+    createTrackMap,
+    getCoreNodeModules,
+    getNodeGlobals
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@servicenow/eslint-plugin-sdk-app-plugin",
+  "version": "1.0.1",
+  "description": "Plugin to disallow Browser and Node.js APIs not supported in rhino engine",
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin"
+  ],
+  "author": "",
+  "main": "./lib/index.js",
+  "exports": "./lib/index.js",
+  "scripts": {
+    "lint": "npm-run-all \"lint:*\"",
+    "lint:js": "eslint .",
+    "test": "mocha tests --recursive"
+  },
+  "dependencies": {
+    "@eslint-community/eslint-utils": "4.4.0",
+    "eslint": "8.50.0",
+    "eslint-plugin-n": "16.3.1",
+    "eslint-plugin-es-x": "7.2.0",
+    "eslint-plugin-eslint-plugin": "5.0.0",
+    "globals": "13.23.0"
+  },
+  "devDependencies": {
+    "mocha": "10.0.0",
+    "npm-run-all": "4.1.5"
+  },
+  "engines": {
+    "node": "^14.17.0 || ^16.0.0 || >= 18.0.0"
+  },
+  "peerDependencies": {
+    "eslint": ">=8"
+  },
+  "license": "ISC"
+}

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

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

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

@@ -0,0 +1,52 @@
+const { RuleTester } = require('eslint');
+const noUnsupportedNodeBuiltins = require('../../lib/rules/no-unsupported-node-builtins');
+const { getCoreNodeModules, getNodeGlobals } = require('../../lib/util/utility');
+
+const ruleTester = new RuleTester({
+    parserOptions: { sourceType: 'module' },
+    env: {node: true, es6: true}
+});
+
+const getInvalidsForNoUnsupportedNodeBuiltsRule = () => {
+    const invalids = []
+    const nodeModules = getCoreNodeModules()
+    const nodeGlobals = getNodeGlobals()
+
+    for(const module of nodeModules) {
+        invalids.push({
+            code: `const ${module} = require('${module}')`,
+            errors: [{ message: `The ${module} Node.js API is not supported in now platform.` }]
+        })
+    }
+
+    for(const module of nodeModules) {
+        invalids.push({
+            code: `import ${module} from '${module}'`,
+            errors: [{ message: `The ${module} Node.js API is not supported in now platform.` }]
+        })
+    }
+
+    for(const global of nodeGlobals) {
+        invalids.push({
+            code: `const x = ${global}`,
+            errors: [{ message: `The ${global} Node.js API is not supported in now platform.` }]
+        })
+    }
+
+    return invalids
+}
+
+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()"
+        }],
+        invalid: getInvalidsForNoUnsupportedNodeBuiltsRule()
+    }
+);