fix eslint issues in CLI project (#7492)

lib/cli/.eslintrc.json

@@ -19,14 +19,14 @@
         "eslint-plugin-rxjs"
       ],
       "rules": {
-        "prefer-arrow/prefer-arrow-functions": "warn",
+        "prefer-arrow/prefer-arrow-functions": "off",
-        "@typescript-eslint/no-var-requires": "warn",
+        "@typescript-eslint/no-var-requires": "off",
         "@typescript-eslint/naming-convention": "warn",
         "quote-props": "warn",
         "no-shadow": "warn",
         "@typescript-eslint/consistent-type-assertions": "warn",
-        "@typescript-eslint/prefer-for-of": "warn",
+        "@typescript-eslint/prefer-for-of": "off",
-        "no-underscore-dangle": "warn",
+        "no-underscore-dangle": ["error", { "allowAfterThis": true }],
 
         "@angular-eslint/component-selector": [
           "error",

lib/cli/scripts/changelog.ts

@@ -17,6 +17,8 @@
  * limitations under the License.
  */
 
+/* eslint-disable @typescript-eslint/naming-convention */
+
 import * as shell from 'shelljs';
 import * as path from 'path';
 import * as program from 'commander';

lib/cli/scripts/check-cs-env.ts

@@ -70,19 +70,19 @@ async function checkDiskSpaceFullEnv() {
 
         try {
             folder = await alfrescoJsApi.nodes.addNode('-my-', {
-                'name': `try-env`,
+                name: `try-env`,
-                'relativePath': `Builds`,
+                relativePath: `Builds`,
-                'nodeType': 'cm:folder'
+                nodeType: 'cm:folder'
             }, {}, {
-                'overwrite': true
+                overwrite: true
             });
 
         } catch (error) {
             folder = await alfrescoJsApi.nodes.getNode('-my-', {
-                'relativePath': `Builds/try-env`,
+                relativePath: `Builds/try-env`,
-                'nodeType': 'cm:folder'
+                nodeType: 'cm:folder'
             }, {}, {
-                'overwrite': true
+                overwrite: true
             });
         }
         const pathFile = path.join(__dirname, '../', 'README.md');
@@ -95,9 +95,9 @@ async function checkDiskSpaceFullEnv() {
             folder.entry.id,
             null,
             {
-                'name': 'README.md',
+                name: 'README.md',
-                'nodeType': 'cm:content',
+                nodeType: 'cm:content',
-                'autoRename': true
+                autoRename: true
             }
         );
 

lib/cli/scripts/docker.ts

@@ -22,9 +22,10 @@ import * as program from 'commander';
 import { logger } from './logger';
 import { resolve } from 'path';
 
+// eslint-disable-next-line no-shadow
 enum TARGETS {
-    Publish = 'publish',
+    publish = 'publish',
-    Link = 'link'
+    link = 'link'
 }
 
 const DOCKER_FILENAME = 'Dockerfile';
@@ -105,7 +106,7 @@ function main(args) {
         .option('--sourceTag [type]', 'sourceTag')
         .option('--buildArgs [type...]', 'buildArgs')
         .option('--fileName [type...]', 'Docker file name', DOCKER_FILENAME)
-        .option('--target [type]', 'target: publish or link', TARGETS.Publish)
+        .option('--target [type]', 'target: publish or link', TARGETS.publish)
         .requiredOption('--dockerRepo [type]', 'docker repo')
         .requiredOption('--dockerTags [type]', ' tags')
         .parse(process.argv);
@@ -120,13 +121,13 @@ function main(args) {
         process.exit(1);
     }
 
-    if (program.opts().target === TARGETS.Publish && args.buildArgs === undefined) {
+    if (program.opts().target === TARGETS.publish && args.buildArgs === undefined) {
-        logger.error(`error: required option --buildArgs [type] in case the target is ${TARGETS.Publish}`);
+        logger.error(`error: required option --buildArgs [type] in case the target is ${TARGETS.publish}`);
         process.exit(1);
     }
 
-    if (program.opts().target === TARGETS.Link && args.sourceTag === undefined) {
+    if (program.opts().target === TARGETS.link && args.sourceTag === undefined) {
-        logger.error(`error: required option --sourceTag [type] in case the target is ${TARGETS.Link}`);
+        logger.error(`error: required option --sourceTag [type] in case the target is ${TARGETS.link}`);
         process.exit(1);
     }
 
@@ -147,7 +148,7 @@ function main(args) {
         args.dockerTags.split(',').forEach((tag, index) => {
             if (tag) {
                 logger.info(`Analyzing tag:${tag} ... for target ${program.opts().target}`);
-                if (program.opts().target === TARGETS.Publish) {
+                if (program.opts().target === TARGETS.publish) {
                     if (index === 0) {
                         logger.info(`Build only once`);
                         mainTag = tag;

lib/cli/scripts/init-aae-env.ts

@@ -18,14 +18,11 @@
  */
 
 import * as program from 'commander';
-
-/* eslint-disable */
 import request = require('request');
 import * as fs from 'fs';
 import { logger } from './logger';
 import { AlfrescoApi } from '@alfresco/js-api';
 const ACTIVITI_CLOUD_APPS = require('./resources').ACTIVITI_CLOUD_APPS;
-/* eslint-enable */
 
 let alfrescoJsApiModeler: any;
 let alfrescoJsApiDevops: any;
@@ -369,11 +366,11 @@ async function checkIfAppIsReleased(missingApps: any [], tag?: string) {
             await checkDescriptorExist(currentAbsentApp.name);
             await sleep(TIME);
             const deployPayload = {
-                'name': currentAbsentApp.name,
+                name: currentAbsentApp.name,
-                'releaseId': projectRelease.entry.id,
+                releaseId: projectRelease.entry.id,
-                'security': currentAbsentApp.security,
+                security: currentAbsentApp.security,
-                'infrastructure': currentAbsentApp.infrastructure,
+                infrastructure: currentAbsentApp.infrastructure,
-                'variables': currentAbsentApp.variables
+                variables: currentAbsentApp.variables
             };
             await deploy(deployPayload);
         }

lib/cli/scripts/init-acs-env.ts

@@ -1,15 +1,14 @@
-/* eslint-disable */
+const alfrescoApi = require('@alfresco/js-api');
-let alfrescoApi = require('@alfresco/js-api');
+const program = require('commander');
-let program = require('commander');
+const fs = require ('fs');
-let fs = require ('fs');
 const path = require('path');
 import { logger } from './logger';
+// eslint-disable-next-line @typescript-eslint/naming-convention
 const { SharedlinksApi, FavoritesApi, NodesApi } = require('@alfresco/js-api');
-let MAX_RETRY = 10;
+const MAX_RETRY = 10;
 let counter = 0;
-let TIMEOUT = 6000;
+const TIMEOUT = 6000;
 const ACS_DEFAULT = require('./resources').ACS_DEFAULT;
-/* eslint-enable */
 
 let alfrescoJsApi;
 

lib/cli/scripts/init-aps-env.ts

@@ -1,19 +1,18 @@
-/* eslint-disable */
+const alfrescoApi = require('@alfresco/js-api');
-let alfrescoApi = require('@alfresco/js-api');
+const program = require('commander');
-let program = require('commander');
+const fs = require ('fs');
-let fs = require ('fs');
 const path = require('path');
 import { logger } from './logger';
 const { throwError } = require('rxjs');
+// eslint-disable-next-line @typescript-eslint/naming-convention
 const { AppDefinitionsApi, RuntimeAppDefinitionsApi } = require('@alfresco/js-api');
-let MAX_RETRY = 10;
+const MAX_RETRY = 10;
 let counter = 0;
-let TIMEOUT = 6000;
+const TIMEOUT = 6000;
 const TENANT_DEFAULT_ID = 1;
 const TENANT_DEFAULT_NAME = 'default';
 const CONTENT_DEFAULT_NAME = 'adw-content';
 const ACTIVITI_APPS = require('./resources').ACTIVITI_APPS;
-/* eslint-enable */
 
 let alfrescoJsApi;
 let alfrescoJsApiRepo;
@@ -162,9 +161,9 @@ async function hasDefaultTenant(tenantId, tenantName) {
 
 async function createDefaultTenant(tenantName) {
     const tenantPost = {
-        'active': true,
+        active: true,
-        'maxUsers': 10000,
+        maxUsers: 10000,
-        'name' : tenantName
+        name : tenantName
     };
 
     try {
@@ -180,13 +179,13 @@ async function createUsers(tenandId, user) {
     logger.info(`Create user ${user.email} on tenant: ${tenandId}`);
     const passwordCamelCase = 'Password';
     const userJson = {
-        'email': user.email,
+        email: user.email,
-        'firstName': user.firstName,
+        firstName: user.firstName,
-        'lastName': user.lastName,
+        lastName: user.lastName,
-        'status': 'active',
+        status: 'active',
-        'type': 'enterprise',
+        type: 'enterprise',
-        'password': passwordCamelCase,
+        password: passwordCamelCase,
-        'tenantId': tenandId
+        tenantId: tenandId
     };
 
     try {

lib/cli/scripts/kube-utils.ts

@@ -0,0 +1,65 @@
+import { logger } from './logger';
+import { exec } from './exec';
+
+export interface KubeArgs {
+    tag?: string;
+    installCheck?: boolean;
+    username?: string;
+    token?: string;
+    clusterEnv?: string;
+    clusterUrl?: string;
+    dockerRepo?: string;
+    label?: string;
+    namespaces?: string;
+}
+
+export const setCluster = (clusterEnv: string, clusterUrl: string) => {
+    logger.info('Perform set-cluster...');
+    const response = exec('kubectl', [`config`, `set-cluster`, `${clusterEnv}`, `--server=${clusterUrl}`], {});
+    logger.info(response);
+};
+
+export const setCredentials = (username: string, token: string) => {
+    logger.info('Perform set-credentials...');
+    const response = exec('kubectl', [`config`, `set-credentials`, `${username}`, `--token=${token}`], {});
+    logger.info(response);
+};
+
+export const setContext = (clusterEnv: string, username: string) => {
+    logger.info('Perform set-context...');
+    const response = exec('kubectl', [`config`, `set-context`, `${clusterEnv}`, `--cluster=${clusterEnv}`, `--user=${username}`], {});
+    logger.info(response);
+};
+
+export const useContext = (clusterEnv: string) => {
+    logger.info('Perform use-context...');
+    const response = exec('kubectl', [`config`, `use-context`, `${clusterEnv}`], {});
+    logger.info(response);
+};
+
+export const deletePod = (args: KubeArgs) => {
+    logger.info('Perform delete pods...');
+    const response = exec('kubectl', [`delete`, `pods`, `--all-namespaces`, `-l`, `app=${args.label}`], {});
+    logger.info(response);
+};
+
+export const getNamespaces = (): string[] => {
+    logger.info('Perform get namespaces name...');
+    const result =  exec('kubectl', [`get`, `namespaces`, `-l`, `type=application`, `-o`, `name`], {});
+    const namespaces = result.replace(/namespace[\/]+/g, '').split(/\r?\n/);
+    logger.info(`namespaces found: ${namespaces}`);
+    return namespaces;
+};
+
+export const getDeploymentName = (args: KubeArgs, namespace: string): string => {
+    logger.info('Perform get deployment name...');
+    const result =  exec('kubectl', [`get`, `deployments`, `--namespace=${namespace}`, `-l`, `app=${args.label}`, `-o`, `name`], {});
+    logger.info(`deployment name: ${result}`);
+    return result;
+};
+
+export const setImage = (args: KubeArgs, deploymentName: string, serviceName: string, namespace: string) => {
+    logger.info('Perform set image...');
+    const response = exec('kubectl', [`set`, `image`, `--namespace=${namespace}`, `${deploymentName}`, `${serviceName}=${args.dockerRepo}:${args.tag}`], {});
+    logger.info(response);
+};

lib/cli/scripts/kubectl-clean-app.ts

@@ -19,13 +19,9 @@
 
 import * as program from 'commander';
 import moment from 'moment-es6';
-import { exec } from './exec';
-/* eslint-disable */
 import { AlfrescoApi } from '@alfresco/js-api';
-/* eslint-enable */
-
 import { logger } from './logger';
-
+import * as kube from './kube-utils';
 export interface ConfigArgs {
     rancherUsername?: string;
     rancherToken?: string;
@@ -42,7 +38,6 @@ export interface ConfigArgs {
     identityHost: boolean;
     enableLike: boolean;
     intervalTime: string;
-
 }
 
 function getAlfrescoJsApiInstance(args: ConfigArgs) {
@@ -185,36 +180,12 @@ async function undeployApplication(args: ConfigArgs, apiService: any, name: stri
     }
 }
 
-function setCluster(args: ConfigArgs) {
+// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
-    logger.info('Perform set-cluster...');
-    const response = exec('kubectl', [`config`, `set-cluster`, `${args.clusterEnv}`, `--server=${args.clusterUrl}`], {});
-    logger.info(response);
-}
-
-function setCredentials(args: ConfigArgs) {
-    logger.info('Perform set-credentials...');
-    const response = exec('kubectl', [`config`, `set-credentials`, `${args.rancherUsername}`, `--token=${args.rancherToken}`], {});
-    logger.info(response);
-}
-
-function setContext(args: ConfigArgs) {
-    logger.info('Perform set-context...');
-    const response = exec('kubectl', [`config`, `set-context`, `${args.clusterEnv}`, `--cluster=${args.clusterEnv}`, `--user=${args.rancherUsername}`], {});
-    logger.info(response);
-}
-
-function useContext(args: ConfigArgs) {
-    logger.info('Perform use-context...');
-    const response = exec('kubectl', [`config`, `use-context`, `${args.clusterEnv}`], {});
-    logger.info(response);
-}
-
 export default async function(args: ConfigArgs) {
     await main(args);
 }
 
-async function main(args) {
+const main = async (args: ConfigArgs) => {
-
     program
         .version('0.1.0')
         .description('The following command is in charge of cleaning the releases/application/descriptor related to an app passed as input' +
@@ -254,24 +225,27 @@ async function main(args) {
     });
 
     if (args.apps !== undefined) {
-        setCluster(args);
+        kube.setCluster(args.clusterEnv, args.clusterUrl);
-        setCredentials(args);
+        kube.setCredentials(args.rancherUsername, args.rancherToken);
-        setContext(args);
+        kube.setContext(args.clusterEnv, args.rancherUsername);
-        useContext(args);
+        kube.useContext(args.clusterEnv);
 
         const applications = args.apps.includes(',') ? args.apps.split(',') : [args.apps];
         const interval = args.intervalTime ? args.intervalTime : '30 min';
-        const extractTimeRange = interval.split(' ')[0];
+        const extractTimeRange = parseInt(interval.split(' ')[0], 10);
         logger.info(`Extract time ${extractTimeRange} from interval: ${interval}`);
+
         for (let i = 0; i < applications.length;  i++ ) {
             logger.info(`Perform action on app: ${applications[i]}`);
             if (args.enableLike) {
                 const applicationsByName = await getApplicationsByName(args, alfrescoJsApiDevops, applications[i]);
                 logger.info(`Found  ${applicationsByName.length} apps`);
+
                 for (let y = 0; y < applicationsByName.length;  y++ ) {
                     const application = applicationsByName[y].entry;
                     logger.info(`Analyze app:  ${application.name} `);
                     const diffAsMinutes = moment.duration(moment().diff(moment(application.createdAt))).asMinutes();
+
                     if (diffAsMinutes > extractTimeRange) {
                         logger.info(`The app: ${application} is older than ${interval}. Can delete it`);
                         await undeployApplication(args, alfrescoJsApiDevops, application.name);
@@ -288,5 +262,4 @@ async function main(args) {
             }
         }
     }
-
+};
-}

lib/cli/scripts/kubectl-delete.ts

@@ -17,54 +17,15 @@
  * limitations under the License.
  */
 
-import { exec } from './exec';
 import * as program from 'commander';
-import { logger } from './logger';
+import * as kube from './kube-utils';
 
-export interface KubeArgs {
+// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
-    username?: string;
+export default function(args: kube.KubeArgs) {
-    token?: string;
-    clusterEnv?: string;
-    clusterUrl?: string;
-    label?: string;
-}
-
-function setCluster(args: KubeArgs) {
-    logger.info('Perform set-cluster...');
-    const response = exec('kubectl', [`config`, `set-cluster`, `${args.clusterEnv}`, `--server=${args.clusterUrl}`], {});
-    logger.info(response);
-}
-
-function setCredentials(args: KubeArgs) {
-    logger.info('Perform set-credentials...');
-    const response = exec('kubectl', [`config`, `set-credentials`, `${args.username}`, `--token=${args.token}`], {});
-    logger.info(response);
-}
-
-function setContext(args: KubeArgs) {
-    logger.info('Perform set-context...');
-    const response = exec('kubectl', [`config`, `set-context`, `${args.clusterEnv}`, `--cluster=${args.clusterEnv}`, `--user=${args.username}`], {});
-    logger.info(response);
-}
-
-function useContext(args: KubeArgs) {
-    logger.info('Perform use-context...');
-    const response = exec('kubectl', [`config`, `use-context`, `${args.clusterEnv}`], {});
-    logger.info(response);
-}
-
-function deletePod(args: KubeArgs) {
-    logger.info('Perform delete pods...');
-    const response = exec('kubectl', [`delete`, `pods`, `--all-namespaces`, `-l`, `app=${args.label}`], {});
-    logger.info(response);
-}
-
-export default function(args: KubeArgs) {
     main(args);
 }
 
-function main(args) {
+const main = (args: kube.KubeArgs) => {
-
     program
         .version('0.1.0')
         .option('--username [type]', 'username')
@@ -81,10 +42,10 @@ function main(args) {
     }
 
     if (args.label !== undefined) {
-        setCluster(args);
+        kube.setCluster(args.clusterEnv, args.clusterUrl);
-        setCredentials(args);
+        kube.setCredentials(args.username, args.token);
-        setContext(args);
+        kube.setContext(args.clusterEnv, args.username);
-        useContext(args);
+        kube.useContext(args.clusterEnv);
-        deletePod(args);
+        kube.deletePod(args);
-    }
     }
+};

lib/cli/scripts/kubectl-image.ts

@@ -20,77 +20,21 @@
 import { exec } from './exec';
 import * as program from 'commander';
 import { logger } from './logger';
+import * as kube from './kube-utils';
 
-export interface KubeArgs {
+const installPerform = () => {
-    tag?: string;
-    installCheck?: boolean;
-    username?: string;
-    token?: string;
-    clusterEnv?: string;
-    clusterUrl?: string;
-    dockerRepo?: string;
-    label?: string;
-    namespaces?: string;
-}
-
-function setCluster(args: KubeArgs) {
-    logger.info('Perform set-cluster...');
-    const response = exec('kubectl', [`config`, `set-cluster`, `${args.clusterEnv}`, `--server=${args.clusterUrl}`], {});
-    logger.info(response);
-}
-
-function setCredentials(args: KubeArgs) {
-    logger.info('Perform set-credentials...');
-    const response = exec('kubectl', [`config`, `set-credentials`, `${args.username}`, `--token=${args.token}`], {});
-    logger.info(response);
-}
-
-function setContext(args: KubeArgs) {
-    logger.info('Perform set-context...');
-    const response = exec('kubectl', [`config`, `set-context`, `${args.clusterEnv}`, `--cluster=${args.clusterEnv}`, `--user=${args.username}`], {});
-    logger.info(response);
-}
-
-function useContext(args: KubeArgs) {
-    logger.info('Perform use-context...');
-    const response = exec('kubectl', [`config`, `use-context`, `${args.clusterEnv}`], {});
-    logger.info(response);
-}
-
-function getNamespaces(): string [] {
-    logger.info('Perform get namespaces name...');
-    const result =  exec('kubectl', [`get`, `namespaces`, `-l`, `type=application`, `-o`, `name`], {});
-    const namespaces = result.replace(/namespace[\/]+/g, '').split(/\r?\n/);
-    logger.info(`namespaces found: ${namespaces}`);
-    return namespaces;
-}
-
-function getDeploymentName(args: KubeArgs, namespace: string): string {
-    logger.info('Perform get deployment name...');
-    const result =  exec('kubectl', [`get`, `deployments`, `--namespace=${namespace}`, `-l`, `app=${args.label}`, `-o`, `name`], {});
-    logger.info(`deployment name: ${result}`);
-    return result;
-}
-
-function setImage(args: KubeArgs, deploymentName: string, serviceName: string, namespace: string) {
-    logger.info('Perform set image...');
-    const response = exec('kubectl', [`set`, `image`, `--namespace=${namespace}`, `${deploymentName}`, `${serviceName}=${args.dockerRepo}:${args.tag}`], {});
-    logger.info(response);
-}
-
-function installPerform() {
     logger.info('Perform install...');
     const responseK8sStable = exec('curl', [`-s`, `https://storage.googleapis.com/kubernetes-release/release/stable.txt`], {}).trim();
     const k8sRelease = `https://storage.googleapis.com/kubernetes-release/release/${responseK8sStable}/bin/linux/amd64/kubectl`;
     exec('curl', [`LO`, `${k8sRelease}`], {});
-}
+};
 
-export default function(args: KubeArgs) {
+// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+export default function(args: kube.KubeArgs) {
     main(args);
 }
 
-function main(args) {
+const main = (args: kube.KubeArgs) => {
-
     program
         .version('0.1.0')
         .description('his command allows you to update a specific service on the rancher env with a specific tag \n\n' +
@@ -115,27 +59,28 @@ function main(args) {
     }
 
     if (args.tag !== undefined) {
-        setCluster(args);
+        kube.setCluster(args.clusterEnv, args.clusterUrl);
-        setCredentials(args);
+        kube.setCredentials(args.username, args.token);
-        setContext(args);
+        kube.setContext(args.clusterEnv, args.username);
-        useContext(args);
+        kube.useContext(args.clusterEnv);
+
         let namespaces: string [];
         if (args.namespaces === null || args.namespaces === 'default') {
             logger.info(`No namespaces provided. Fetch all of them`);
-            namespaces = getNamespaces();
+            namespaces = kube.getNamespaces();
         } else {
             namespaces = args.namespaces.split(',');
         }
+
         namespaces.forEach((namespace) => {
             logger.info(`Find deployment name based on label ${args.label} and namespace ${namespace}`);
-            const deploymentName = getDeploymentName(args, namespace);
+            const deploymentName = kube.getDeploymentName(args, namespace);
             if (deploymentName) {
                 logger.info(`Found ${deploymentName}`);
-                setImage(args, deploymentName.trim(), '*', namespace);
+                kube.setImage(args, deploymentName.trim(), '*', namespace);
             } else {
                 logger.info(`No container with the label app=${args.label} found`);
             }
-
         });
     }
-}
+};

lib/cli/scripts/licenses.ts

@@ -32,8 +32,8 @@ interface PackageInfo {
 
 const nonStandardLicenses = {
     'public domain': 'PDDL-1.0',
-    'apache': 'Apache-2.0',
+    apache: 'Apache-2.0',
-    'bsd': 'BSD-2-Clause'
+    bsd: 'BSD-2-Clause'
 };
 
 const missingRepositories = {
@@ -44,7 +44,7 @@ const missingRepositories = {
     '@webassemblyjs/leb128': 'https://github.com/xtuc/webassemblyjs',
     'adf-tslint-rules': 'https://github.com/Alfresco/alfresco-ng2-components',
     'adf-monaco-extension': 'https://github.com/eromano/aca-monaco-extension',
-    'indexof': 'https://github.com/component/indexof',
+    indexof: 'https://github.com/component/indexof',
     'rxjs-compat': 'https://github.com/ReactiveX/rxjs/tree/master/compat'
 };
 

lib/cli/scripts/plugins/check-env.ts

@@ -1,10 +1,10 @@
 import { logger } from './../logger';
 import alfrescoApi = require('@alfresco/js-api');
 
+const TIMEOUT = 6000;
+const MAX_RETRY = 10;
 export class CheckEnv {
     _alfrescoJsApi: any;
-    TIMEOUT = 6000;
-    MAX_RETRY = 10;
     counter = 0;
 
     constructor(
@@ -15,7 +15,7 @@ export class CheckEnv {
 
     async checkEnv() {
         try {
-            this.alfrescoJsApi = new alfrescoApi.AlfrescoApiCompatibility(<any> {
+            this.alfrescoJsApi = new alfrescoApi.AlfrescoApiCompatibility({
                 provider: 'ALL',
                 hostBpm: this.host,
                 hostEcm: this.host,
@@ -25,7 +25,7 @@ export class CheckEnv {
                     clientId: 'alfresco',
                     scope: 'openid'
                 }
-            });
+            } as any);
             await this.alfrescoJsApi.login(this.username, this.password);
         } catch (e) {
             if (e.error.code === 'ETIMEDOUT') {
@@ -34,14 +34,14 @@ export class CheckEnv {
             }
             logger.error('Login error environment down or inaccessible');
             this.counter++;
-            if (this.MAX_RETRY === this.counter) {
+            if (MAX_RETRY === this.counter) {
                 logger.error('Give up');
                 process.exit(1);
             } else {
                 logger.error(
                     `Retry in 1 minute at main();tempt N ${this.counter}`
                 );
-                this.sleep(this.TIMEOUT);
+                this.sleep(TIMEOUT);
                 this.checkEnv();
             }
         }

lib/cli/scripts/plugins/governance-health.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+
 import { logger } from '../logger';
 import { PluginInterface } from './plugin-model';
 

lib/cli/scripts/plugins/plugin-model.ts

@@ -1,3 +1,4 @@
+// eslint-disable-next-line no-shadow
 export enum PluginTarget {
     processService = 'processService',
     processAutomation = 'processAutomation',

lib/cli/scripts/plugins/process-automation-check-plugin.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+
 import { PluginInterface } from './plugin-model';
 import { logger } from '../logger';
 import { ProcessAutomationHealth } from './process-automation-health';

lib/cli/scripts/plugins/process-service-check-plugin.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+
 import { PluginInterface } from './plugin-model';
 import { logger } from '../logger';
 import { ProcessServiceHealth } from './process-services-health';

lib/cli/scripts/resources.ts

@@ -16,6 +16,8 @@
  */
 
 /* cSpell:disable */
+/* eslint-disable @typescript-eslint/naming-convention */
+
 export const ACTIVITI_CLOUD_APPS: any = {
     SUB_PROCESS_APP: {
         name: 'subprocessapp',
@@ -25,8 +27,8 @@ export const ACTIVITI_CLOUD_APPS: any = {
             processparent: 'processparent'
         },
         security: [
-            { 'role': 'ACTIVITI_ADMIN', 'groups': [], 'users': ['superadminuser'] },
+            { role: 'ACTIVITI_ADMIN', groups: [], users: ['superadminuser'] },
-            { 'role': 'ACTIVITI_USER', 'groups': ['hr', 'testgroup'], 'users': ['hruser'] }
+            { role: 'ACTIVITI_USER', groups: ['hr', 'testgroup'], users: ['hruser'] }
         ]
     },
     CANDIDATE_BASE_APP: {
@@ -64,8 +66,8 @@ export const ACTIVITI_CLOUD_APPS: any = {
             outputform: 'outputform'
         },
         security: [
-            { 'role': 'ACTIVITI_ADMIN', 'groups': [], 'users': ['superadminuser', 'processadminuser'] },
+            { role: 'ACTIVITI_ADMIN', groups: [], users: ['superadminuser', 'processadminuser'] },
-            { 'role': 'ACTIVITI_USER', 'groups': ['hr', 'testgroup'], 'users': ['hruser', 'salesuser'] }
+            { role: 'ACTIVITI_USER', groups: ['hr', 'testgroup'], users: ['hruser', 'salesuser'] }
         ],
         tasks: {
             uploadFileTask: 'UploadFileTask',
@@ -195,8 +197,8 @@ export const ACTIVITI_CLOUD_APPS: any = {
             uploadSingleMultipleFiles: 'UploadSingleMultipleFiles'
         },
         security: [
-            { 'role': 'ACTIVITI_ADMIN', 'groups': [], 'users': ['superadminuser', 'processadminuser'] },
+            { role: 'ACTIVITI_ADMIN', groups: [], users: ['superadminuser', 'processadminuser'] },
-            { 'role': 'ACTIVITI_USER', 'groups': ['hr', 'sales', 'testgroup'], 'users': ['hruser'] }
+            { role: 'ACTIVITI_USER', groups: ['hr', 'sales', 'testgroup'], users: ['hruser'] }
         ],
         infrastructure: {connectors: {restconnector: {}}, bridges: {}}
     }

lib/cli/tooling/dotenv.ts

@@ -15,10 +15,10 @@
  * limitations under the License.
  */
 
-export function dotenv() {
+// eslint-disable-next-line @typescript-eslint/no-var-requires
-    return require('dotenv-expand')(require('dotenv'));
+const expand = require('dotenv-expand');
-}
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const nodeDotEnv = require('dotenv');
 
-export function dotenvConfig(params?: any) {
+export const dotenv = () => expand(nodeDotEnv);
-    return require('dotenv-expand')(require('dotenv').config(params));
+export const dotenvConfig = (params?: any) => expand(nodeDotEnv.config(params));
-}