updated eslintrc and linted accordingly

Author: naman-contentstack

.eslintrc

@@ -6,6 +6,7 @@
     "rules": {
       "unicorn/prefer-module": "off",
       "unicorn/no-abusive-eslint-disable": "off",
-      "@typescript-eslint/no-use-before-define": "off"
+      "@typescript-eslint/no-use-before-define": "off",
+      "node/no-missing-import": "off"
     }
   }

src/commands/tsgen.ts

@@ -1,25 +1,25 @@
-import { Command } from "@contentstack/cli-command";
-import { flags } from "@contentstack/cli-utilities";
-import * as path from "path";
-import * as fs from "fs";
-import { sanitizePath } from "../lib/helper";
-import { generateTS, graphqlTS } from "@contentstack/types-generator";
-import { StackConnectionConfig } from "../types";
+import {Command} from '@contentstack/cli-command'
+import {flags} from '@contentstack/cli-utilities'
+import * as path from 'path'
+import * as fs from 'fs'
+import {generateTS, graphqlTS} from '@contentstack/types-generator'
+import {sanitizePath} from '../lib/helper'
+import {StackConnectionConfig} from '../types'
 
 function createOutputPath(outputFile: string) {
   const outputPath = path.resolve(
     sanitizePath(process.cwd()),
     sanitizePath(outputFile),
-  );
-  const dirName = path.dirname(outputPath);
+  )
+  const dirName = path.dirname(outputPath)
 
-  fs.mkdirSync(dirName, { recursive: true });
+  fs.mkdirSync(dirName, {recursive: true})
 
-  return outputPath;
+  return outputPath
 }
 
 export default class TypeScriptCodeGeneratorCommand extends Command {
-  static description = "Generate TypeScript typings from a Stack";
+  static description = 'Generate TypeScript typings from a Stack';
 
   static examples = [
     '$ csdx tsgen -a "delivery token alias" -o "contentstack/generated.d.ts"',
@@ -30,135 +30,135 @@ export default class TypeScriptCodeGeneratorCommand extends Command {
   ];
 
   static flags: any = {
-    "token-alias": flags.string({
-      char: "a",
-      description: "delivery token alias",
+    'token-alias': flags.string({
+      char: 'a',
+      description: 'delivery token alias',
       hidden: false,
       multiple: false,
       required: true,
     }),
 
     output: flags.string({
-      char: "o",
-      description: "full path to output",
+      char: 'o',
+      description: 'full path to output',
       hidden: false,
       multiple: false,
       required: true,
     }),
 
     prefix: flags.string({
-      char: "p",
+      char: 'p',
       description: 'interface prefix, e.g. "I"',
       hidden: false,
       multiple: false,
-      default: "",
+      default: '',
       required: false,
     }),
 
     doc: flags.boolean({
-      char: "d",
-      description: "include documentation comments",
+      char: 'd',
+      description: 'include documentation comments',
       default: true,
       allowNo: true,
     }),
 
     branch: flags.string({
-      description: "branch",
+      description: 'branch',
       hidden: false,
       multiple: false,
     }),
 
-    "include-system-fields": flags.boolean({
-      description: "include system fields in generated types",
+    'include-system-fields': flags.boolean({
+      description: 'include system fields in generated types',
       default: false,
     }),
 
-    "api-type": flags.string({
-      default: "rest",
+    'api-type': flags.string({
+      default: 'rest',
       multiple: false,
-      options: ["rest", "graphql"],
+      options: ['rest', 'graphql'],
       description:
-        "[Optional] Please enter an API type to generate the type definitions.",
+        '[Optional] Please enter an API type to generate the type definitions.',
     }),
 
     namespace: flags.string({
       description:
-        "[Optional]Please enter a namespace for the GraphQL API type to organize the generated types.",
+        '[Optional]Please enter a namespace for the GraphQL API type to organize the generated types.',
     }),
   };
 
   async run() {
     try {
-      const { flags } = await this.parse(TypeScriptCodeGeneratorCommand);
+      const {flags} = await this.parse(TypeScriptCodeGeneratorCommand)
 
-      const token = this.getToken(flags["token-alias"]);
-      const prefix = flags.prefix;
-      const includeDocumentation = flags.doc;
-      const filePath = flags.output;
-      const branch = flags.branch;
-      const includeSystemFields = flags["include-system-fields"];
-      const namespace = flags.namespace;
+      const token = this.getToken(flags['token-alias'])
+      const prefix = flags.prefix
+      const includeDocumentation = flags.doc
+      const filePath = flags.output
+      const branch = flags.branch
+      const includeSystemFields = flags['include-system-fields']
+      const namespace = flags.namespace
 
-      const outputPath = createOutputPath(filePath);
+      const outputPath = createOutputPath(filePath)
 
-      if (token.type !== "delivery") {
+      if (token.type !== 'delivery') {
         this.warn(
-          "Possibly using a management token. You may not be able to connect to your Stack. Please use a delivery token.",
-        );
+          'Possibly using a management token. You may not be able to connect to your Stack. Please use a delivery token.',
+        )
       }
 
       if (!outputPath || !outputPath.trim()) {
-        this.error("Please provide an output path.", { exit: 2 });
+        this.error('Please provide an output path.', {exit: 2})
       }
 
       const config: StackConnectionConfig = {
         apiKey: token.apiKey,
         token: token.token,
         region:
-          this.region.name === "NA" ? "us" : this.region.name.toLowerCase(),
-        environment: token.environment || "",
+          this.region.name === 'NA' ? 'us' : this.region.name.toLowerCase(),
+        environment: token.environment || '',
         branch: branch || undefined,
         host: this.cdaHost,
-      };
+      }
 
       // Generate the GraphQL schema TypeScript definitions
-      if (flags["api-type"] === "graphql") {
+      if (flags['api-type'] === 'graphql') {
         try {
-          if (config.region === "us") {
-            config.region = "US";
+          if (config.region === 'us') {
+            config.region = 'US'
           }
-          const result = await graphqlTS({ ...config, namespace: namespace });
+          const result = await graphqlTS({...config, namespace: namespace})
 
-          fs.writeFileSync(outputPath, result);
+          fs.writeFileSync(outputPath, result)
           this.log(
             `Successfully added the GraphQL schema type definitions to '${outputPath}'.`,
-          );
+          )
         } catch (error: any) {
-          this.error(error.error_message, { exit: 1 });
+          this.error(error.error_message, {exit: 1})
         }
       } else {
         // Generate the Content Types TypeScript definitions
         try {
           const result = await generateTS({
             ...config,
-            tokenType: "delivery",
+            tokenType: 'delivery',
             includeDocumentation: includeDocumentation,
             prefix,
             systemFields: includeSystemFields,
-          });
+          })
 
-          fs.writeFileSync(outputPath, result);
+          fs.writeFileSync(outputPath, result)
 
           // -- TODO : Add count support for the number of Content Types generated
-          this.log(`Successfully added the Content Types to '${outputPath}'.`);
+          this.log(`Successfully added the Content Types to '${outputPath}'.`)
 
           // this.log(`Wrote ${outputPath} Content Types to '${result.outputPath}'.`)
         } catch (error: any) {
-          this.error(error.error_message, { exit: 1 });
+          this.error(error.error_message, {exit: 1})
         }
       }
     } catch (error: any) {
-      this.error(error as any, { exit: 1 });
+      this.error(error as any, {exit: 1})
     }
   }
 }