From 6f11dafbea6244387541a3f689bd794ffca12eb6 Mon Sep 17 00:00:00 2001
From: Pranav C <pranavxc@gmail.com>
Date: Mon, 25 Apr 2022 20:34:56 +0530
Subject: [PATCH] feat: show schema name option for mssql and pg

Signed-off-by: Pranav C <pranavxc@gmail.com>
---
 .../nc-gui/components/createOrEditProject.vue | 1256 +++++++++--------
 packages/nc-gui/lang/en.json                  |    1 +
 2 files changed, 647 insertions(+), 610 deletions(-)

diff --git a/packages/nc-gui/components/createOrEditProject.vue b/packages/nc-gui/components/createOrEditProject.vue
index fd597d48b0..545f12c37f 100644
--- a/packages/nc-gui/components/createOrEditProject.vue
+++ b/packages/nc-gui/components/createOrEditProject.vue
@@ -207,7 +207,9 @@
                                 v-for="(db, dbIndex) in project.envs[envKey].db"
                                 :key="dbIndex"
                               >
-                                <v-icon small> mdi-database </v-icon> &nbsp;
+                                <v-icon small>
+                                  mdi-database
+                                </v-icon> &nbsp;
                                 <span class="text-capitalize caption">{{
                                   db.connection.database
                                 }}</span>
@@ -248,15 +250,13 @@
 
                                               <span
                                                 class="ml-2 caption grey--text"
-                                                >Refer knex documentation
+                                              >Refer knex documentation
                                                 <a
                                                   href="https://knexjs.org/#Installation-client"
                                                   target="_blank"
                                                   class="grey--text"
-                                                  >here</a
-                                                >
-                                                .</span
-                                              >
+                                                >here</a>
+                                                .</span>
 
                                               <monaco-json-object-editor
                                                 v-model="
@@ -298,7 +298,7 @@
                                                     Object.keys(
                                                       databaseNames
                                                     ).indexOf(item) %
-                                                      colors.length
+                                                    colors.length
                                                   ]
                                                 "
                                                 class=""
@@ -317,7 +317,7 @@
                                                     Object.keys(
                                                       databaseNames
                                                     ).indexOf(data.item) %
-                                                      colors.length
+                                                    colors.length
                                                   ]
                                                 "
                                                 class="caption"
@@ -453,9 +453,26 @@
                                             "
                                           />
                                         </v-col>
+                                        <!--  todo : Schema name -->
+                                        <v-col
+                                          v-if="db.client === 'mssql' || db.client === 'pg'"
+                                          cols="4"
+                                          class="py-0"
+                                        >
+                                          <v-text-field
+                                            v-model="schema"
+                                            :disabled="edit && enableDbEdit < 2"
+                                            class="body-2 database-field"
+                                            :rules="form.requiredRule"
+                                            :label="
+                                              $t('labels.schemaName')
+                                            "
+                                          />
+                                        </v-col>
                                         <!--  todo : ssl & inflection -->
                                         <v-col
                                           v-if="db.client !== 'sqlite3'"
+                                          cols="12"
                                           class=""
                                         >
                                           <v-expansion-panels>
@@ -466,12 +483,11 @@
                                                 <!-- SSL & Advanced parameters -->
                                                 <span
                                                   class="grey--text caption"
-                                                  >{{
-                                                    $t(
-                                                      "title.advancedParameters"
-                                                    )
-                                                  }}</span
-                                                >
+                                                >{{
+                                                  $t(
+                                                    "title.advancedParameters"
+                                                  )
+                                                }}</span>
                                               </v-expansion-panel-header>
                                               <v-expansion-panel-content>
                                                 <v-card class="elevation-0">
@@ -505,7 +521,7 @@
                                                             dbIndex
                                                           )
                                                         "
-                                                      />
+                                                      >
                                                       <!-- Select .cert file -->
                                                       <x-btn
                                                         v-ge="[
@@ -545,7 +561,7 @@
                                                             dbIndex
                                                           )
                                                         "
-                                                      />
+                                                      >
                                                       <x-btn
                                                         v-ge="[
                                                           'project',
@@ -584,7 +600,7 @@
                                                             dbIndex
                                                           )
                                                         "
-                                                      />
+                                                      >
                                                       <x-btn
                                                         v-ge="[
                                                           'project',
@@ -626,11 +642,11 @@
                                                           "
                                                           :items="
                                                             project.projectType ===
-                                                            'rest'
+                                                              'rest'
                                                               ? [
-                                                                  'camelize',
-                                                                  'none',
-                                                                ]
+                                                                'camelize',
+                                                                'none',
+                                                              ]
                                                               : ['camelize']
                                                           "
                                                         >
@@ -639,8 +655,7 @@
                                                           >
                                                             <span
                                                               class="caption"
-                                                              >{{ item }}</span
-                                                            >
+                                                            >{{ item }}</span>
                                                           </template>
                                                         </v-select>
                                                       </v-col>
@@ -660,11 +675,11 @@
                                                           "
                                                           :items="
                                                             project.projectType ===
-                                                            'rest'
+                                                              'rest'
                                                               ? [
-                                                                  'camelize',
-                                                                  'none',
-                                                                ]
+                                                                'camelize',
+                                                                'none',
+                                                              ]
                                                               : ['camelize']
                                                           "
                                                         >
@@ -673,8 +688,7 @@
                                                           >
                                                             <span
                                                               class="caption"
-                                                              >{{ item }}</span
-                                                            >
+                                                            >{{ item }}</span>
                                                           </template>
                                                         </v-select>
                                                       </v-col>
@@ -839,30 +853,30 @@
   </v-container>
 </template>
 <script>
-import JSON5 from "json5";
+import JSON5 from 'json5'
 
-import { mapGetters, mapActions } from "vuex";
-import Vue from "vue";
+import { mapGetters, mapActions } from 'vuex'
+import Vue from 'vue'
 
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv4 } from 'uuid'
 
-import XBtn from "./global/xBtn";
-import dlgOk from "./utils/dlgOk.vue";
-import textDlgSubmitCancel from "./utils/dlgTextSubmitCancel";
-import MonacoJsonObjectEditor from "@/components/monaco/MonacoJsonObjectEditor";
-import ApiOverlay from "@/components/apiOverlay";
-import colors from "@/mixins/colors";
-import DlgOkNew from "@/components/utils/dlgOkNew";
-import readFile from "@/helpers/fileReader";
+import XBtn from './global/xBtn'
+import dlgOk from './utils/dlgOk.vue'
+import textDlgSubmitCancel from './utils/dlgTextSubmitCancel'
+import MonacoJsonObjectEditor from '@/components/monaco/MonacoJsonObjectEditor'
+import ApiOverlay from '@/components/apiOverlay'
+import colors from '@/mixins/colors'
+import DlgOkNew from '@/components/utils/dlgOkNew'
+import readFile from '@/helpers/fileReader'
 
 const {
   uniqueNamesGenerator,
   starWars,
   adjectives,
-  animals,
-} = require("unique-names-generator");
+  animals
+} = require('unique-names-generator')
 
-const homeDir = "";
+const homeDir = ''
 
 export default {
   components: {
@@ -871,90 +885,91 @@ export default {
     MonacoJsonObjectEditor,
     XBtn,
     dlgOk,
-    textDlgSubmitCancel,
+    textDlgSubmitCancel
   },
   mixins: [colors],
-  layout: "empty",
+  layout: 'empty',
   data() {
     return {
+      schema: 'public',
       testSuccess: false,
       projectCreated: false,
       allSchemas: false,
       showMonaco: [],
       smtpConfiguration: {
-        from: "",
-        options: "",
+        from: '',
+        options: ''
       },
       showSecret: false,
       loaderMessages: [
-        "Setting up new database configs",
-        "Inferring database schema",
-        "Generating APIs.",
-        "Generating APIs..",
-        "Generating APIs...",
-        "Generating APIs....",
-        "Please wait",
-        "Please wait.",
-        "Please wait..",
-        "Please wait...",
-        "Please wait..",
-        "Please wait.",
-        "Please wait",
-        "Please wait.",
-        "Please wait..",
-        "Please wait...",
-        "Please wait..",
-        "Please wait.",
-        "Please wait..",
-        "Please wait...",
+        'Setting up new database configs',
+        'Inferring database schema',
+        'Generating APIs.',
+        'Generating APIs..',
+        'Generating APIs...',
+        'Generating APIs....',
+        'Please wait',
+        'Please wait.',
+        'Please wait..',
+        'Please wait...',
+        'Please wait..',
+        'Please wait.',
+        'Please wait',
+        'Please wait.',
+        'Please wait..',
+        'Please wait...',
+        'Please wait..',
+        'Please wait.',
+        'Please wait..',
+        'Please wait...'
       ],
-      loaderMessage: "",
+      loaderMessage: '',
       projectReloading: false,
       enableDbEdit: 0,
       authTypes: [
         {
-          text: "JWT",
-          value: "jwt",
+          text: 'JWT',
+          value: 'jwt'
         },
         {
-          text: "Master Key",
-          value: "masterKey",
+          text: 'Master Key',
+          value: 'masterKey'
         },
         {
-          text: "Middleware",
-          value: "middleware",
+          text: 'Middleware',
+          value: 'middleware'
         },
         {
-          text: "Disabled",
-          value: "none",
-        },
+          text: 'Disabled',
+          value: 'none'
+        }
       ],
       projectTypes: [
         {
-          text: "REST APIs",
-          value: "rest",
-          icon: "mdi-code-json",
-          iconColor: "green",
+          text: 'REST APIs',
+          value: 'rest',
+          icon: 'mdi-code-json',
+          iconColor: 'green'
         },
         {
-          text: "GRAPHQL APIs",
-          value: "graphql",
-          icon: "mdi-graphql",
-          iconColor: "pink",
-        },
+          text: 'GRAPHQL APIs',
+          value: 'graphql',
+          icon: 'mdi-graphql',
+          iconColor: 'pink'
+        }
       ],
 
       showPass: {},
       /** ************** START : form related ****************/
       form: {
-        portValidationRule: [(v) => /^\d+$/.test(v) || "Not a valid port"],
-        titleRequiredRule: [(v) => !!v || "Title is required"],
-        requiredRule: [(v) => !!v || "Field is required"],
-        folderRequiredRule: [(v) => !!v || "Folder path is required"],
+        portValidationRule: [v => /^\d+$/.test(v) || 'Not a valid port'],
+        titleRequiredRule: [v => !!v || 'Title is required'],
+        requiredRule: [v => !!v || 'Field is required'],
+        folderRequiredRule: [v => !!v || 'Folder path is required']
       },
       valid: null,
       panel: 0,
-      client: ["Sqlite"],
+      client: ['Sqlite'],
       baseFolder: homeDir,
 
       tab: null,
@@ -963,244 +978,245 @@ export default {
       /** ************** END : form related ****************/
       auth: {
         authSecret: uuidv4(),
-        authType: "jwt",
-        webhook: null,
+        authType: 'jwt',
+        webhook: null
       },
       project: {},
       defaultProject: {
-        title: "",
-        version: "0.6",
+        title: '',
+        version: '0.6',
         folder: homeDir,
         envs: {
           _noco: {
             db: [
               {
-                client: "pg",
+                client: 'pg',
                 connection: {
-                  host: "localhost",
-                  port: "5432",
-                  user: "postgres",
-                  password: "password",
-                  database: "_dev",
+                  host: 'localhost',
+                  port: '5432',
+                  user: 'postgres',
+                  password: 'password',
+                  database: '_dev',
                   ssl: {
-                    ca: "",
-                    key: "",
-                    cert: "",
-                  },
+                    ca: '',
+                    key: '',
+                    cert: ''
+                  }
                 },
+                searchPath: ['public'],
                 meta: {
-                  tn: "nc_evolutions",
-                  dbAlias: "db",
+                  tn: 'nc_evolutions',
+                  dbAlias: 'db',
                   api: {
-                    type: "rest",
-                    prefix: "",
-                    graphqlDepthLimit: 10,
+                    type: 'rest',
+                    prefix: '',
+                    graphqlDepthLimit: 10
                   },
                   inflection: {
-                    table_name: "camelize",
-                    column_name: "camelize",
-                  },
+                    table_name: 'camelize',
+                    column_name: 'camelize'
+                  }
                 },
                 ui: {
                   setup: -1,
                   ssl: {
-                    key: this.$t("labels.clientKey"), // Client Key
-                    cert: this.$t("labels.clientCert"), // Client Cert
-                    ca: this.$t("labels.serverCA"), // Server CA
+                    key: this.$t('labels.clientKey'), // Client Key
+                    cert: this.$t('labels.clientCert'), // Client Cert
+                    ca: this.$t('labels.serverCA') // Server CA
                   },
-                  sslUse: "Preferred",
-                },
-              },
+                  sslUse: 'Preferred'
+                }
+              }
             ],
             apiClient: {
-              data: [],
-            },
-          },
+              data: []
+            }
+          }
         },
-        workingEnv: "_noco",
+        workingEnv: '_noco',
         ui: {
           envs: {
-            _noco: {},
-          },
+            _noco: {}
+          }
         },
         meta: {
-          version: "0.6",
-          seedsFolder: "seeds",
-          queriesFolder: "queries",
-          apisFolder: "apis",
-          projectType: "rest",
-          type: "mvc",
-          language: "ts",
+          version: '0.6',
+          seedsFolder: 'seeds',
+          queriesFolder: 'queries',
+          apisFolder: 'apis',
+          projectType: 'rest',
+          type: 'mvc',
+          language: 'ts'
         },
-        seedsFolder: "seeds",
-        queriesFolder: "queries",
-        apisFolder: "apis",
-        projectType: "rest",
-        type: "mvc",
-        language: "ts",
+        seedsFolder: 'seeds',
+        queriesFolder: 'queries',
+        apisFolder: 'apis',
+        projectType: 'rest',
+        type: 'mvc',
+        language: 'ts',
         apiClient: {
-          data: [],
-        },
+          data: []
+        }
       },
 
       sampleConnectionData: {
         Postgres: {
-          host: "localhost",
-          port: "5432",
-          user: "postgres",
-          password: "password",
-          database: "_test",
+          host: 'localhost',
+          port: '5432',
+          user: 'postgres',
+          password: 'password',
+          database: '_test',
           ssl: {
-            ca: "",
-            key: "",
-            cert: "",
-          },
+            ca: '',
+            key: '',
+            cert: ''
+          }
         },
         MySQL: {
-          host: "localhost",
-          port: "3306",
-          user: "root",
-          password: "password",
-          database: "_test",
+          host: 'localhost',
+          port: '3306',
+          user: 'root',
+          password: 'password',
+          database: '_test',
           ssl: {
-            ca: "",
-            key: "",
-            cert: "",
-          },
+            ca: '',
+            key: '',
+            cert: ''
+          }
         },
         Vitess: {
-          host: "localhost",
-          port: "15306",
-          user: "root",
-          password: "password",
-          database: "_test",
+          host: 'localhost',
+          port: '15306',
+          user: 'root',
+          password: 'password',
+          database: '_test',
           ssl: {
-            ca: "",
-            key: "",
-            cert: "",
-          },
+            ca: '',
+            key: '',
+            cert: ''
+          }
         },
         TiDB: {
-          host: "localhost",
-          port: "4000",
-          user: "root",
-          password: "",
-          database: "_test",
+          host: 'localhost',
+          port: '4000',
+          user: 'root',
+          password: '',
+          database: '_test',
           ssl: {
-            ca: "",
-            key: "",
-            cert: "",
-          },
+            ca: '',
+            key: '',
+            cert: ''
+          }
         },
         Yugabyte: {
-          host: "localhost",
-          port: "5432",
-          user: "postgres",
-          password: "",
-          database: "_test",
+          host: 'localhost',
+          port: '5432',
+          user: 'postgres',
+          password: '',
+          database: '_test',
           ssl: {
-            ca: "",
-            key: "",
-            cert: "",
-          },
+            ca: '',
+            key: '',
+            cert: ''
+          }
         },
         CitusDB: {
-          host: "localhost",
-          port: "5432",
-          user: "postgres",
-          password: "",
-          database: "_test",
+          host: 'localhost',
+          port: '5432',
+          user: 'postgres',
+          password: '',
+          database: '_test',
           ssl: {
-            ca: "",
-            key: "",
-            cert: "",
-          },
+            ca: '',
+            key: '',
+            cert: ''
+          }
         },
         CockroachDB: {
-          host: "localhost",
-          port: "5432",
-          user: "postgres",
-          password: "",
-          database: "_test",
+          host: 'localhost',
+          port: '5432',
+          user: 'postgres',
+          password: '',
+          database: '_test',
           ssl: {
-            ca: "",
-            key: "",
-            cert: "",
-          },
+            ca: '',
+            key: '',
+            cert: ''
+          }
         },
         Greenplum: {
-          host: "localhost",
-          port: "5432",
-          user: "postgres",
-          password: "",
-          database: "_test",
+          host: 'localhost',
+          port: '5432',
+          user: 'postgres',
+          password: '',
+          database: '_test',
           ssl: {
-            ca: "",
-            key: "",
-            cert: "",
-          },
+            ca: '',
+            key: '',
+            cert: ''
+          }
         },
         MsSQL: {
-          host: "localhost",
+          host: 'localhost',
           port: 1433,
-          user: "sa",
-          password: "Password123.",
-          database: "_test",
+          user: 'sa',
+          password: 'Password123.',
+          database: '_test',
           ssl: {
-            ca: "",
-            key: "",
-            cert: "",
-          },
+            ca: '',
+            key: '',
+            cert: ''
+          }
         },
         Oracle: {
-          host: "localhost",
-          port: "1521",
-          user: "system",
-          password: "Oracle18",
-          database: "_test",
+          host: 'localhost',
+          port: '1521',
+          user: 'system',
+          password: 'Oracle18',
+          database: '_test',
           ssl: {
-            ca: "",
-            key: "",
-            cert: "",
-          },
+            ca: '',
+            key: '',
+            cert: ''
+          }
         },
         Sqlite: {
-          client: "sqlite3",
+          client: 'sqlite3',
           database: homeDir,
           connection: {
-            filename: homeDir,
+            filename: homeDir
           },
-          useNullAsDefault: true,
-        },
+          useNullAsDefault: true
+        }
       },
       dialog: {
         show: false,
-        title: "",
-        heading: "",
+        title: '',
+        heading: '',
         mtdOk: this.testConnectionMethodSubmit,
-        type: "primary",
+        type: 'primary'
       },
       // TODO: apply i18n for sslUsage
       // See general.no - 5 in en.json
       sslUsage: {
-        No: "No",
-        Preferred: "Preferred",
-        Required: "pg",
-        "Required-CA": "Required-CA",
-        "Required-IDENTITY": "Required-IDENTITY",
+        No: 'No',
+        Preferred: 'Preferred',
+        Required: 'pg',
+        'Required-CA': 'Required-CA',
+        'Required-IDENTITY': 'Required-IDENTITY'
       },
-      sslUse: this.$t("general.preferred"), // Preferred
+      sslUse: this.$t('general.preferred'), // Preferred
       ssl: {
-        key: this.$t("labels.clientKey"), // Client Key
-        cert: this.$t("labels.clientCert"), // Client Cert
-        ca: this.$t("labels.serverCA"), // Server CA
+        key: this.$t('labels.clientKey'), // Client Key
+        cert: this.$t('labels.clientCert'), // Client Cert
+        ca: this.$t('labels.serverCA') // Server CA
       },
       databaseNames: {
-        MySQL: "mysql2",
-        Postgres: "pg",
+        MySQL: 'mysql2',
+        Postgres: 'pg',
         // Oracle: "oracledb",
-        MsSQL: "mssql",
-        Sqlite: "sqlite3",
+        MsSQL: 'mssql',
+        Sqlite: 'sqlite3'
         // Vitess: "mysql2",
         // TiDB: "mysql2",
         // Yugabyte: "pg",
@@ -1211,40 +1227,40 @@ export default {
       testDatabaseNames: {
         mysql2: null,
         mysql: null,
-        pg: "postgres",
-        oracledb: "xe",
+        pg: 'postgres',
+        oracledb: 'xe',
         mssql: undefined,
-        sqlite3: "a.sqlite",
+        sqlite3: 'a.sqlite'
       },
       dbIcons: {
-        Oracle: "temp/db/oracle.png",
-        Postgres: "temp/db/postgre.png",
-        MySQL: "temp/db/mysql.png",
-        MsSQL: "temp/db/mssql.png",
-        Sqlite: "temp/db/sqlite.svg",
-        Salesforce: "temp/salesforce-3-569548.webp",
-        SAP: "temp/sap.png",
-        Stripe: "temp/stripe.svg",
+        Oracle: 'temp/db/oracle.png',
+        Postgres: 'temp/db/postgre.png',
+        MySQL: 'temp/db/mysql.png',
+        MsSQL: 'temp/db/mssql.png',
+        Sqlite: 'temp/db/sqlite.svg',
+        Salesforce: 'temp/salesforce-3-569548.webp',
+        SAP: 'temp/sap.png',
+        Stripe: 'temp/stripe.svg'
       },
       dialogGetEnvName: {
         dialogShow: false,
-        heading: "Enter New Environment Name",
-        field: "Environment Name",
+        heading: 'Enter New Environment Name',
+        field: 'Environment Name'
       },
 
       compErrorMessages: [
-        this.$t("msg.error.invalidChar"), // Invalid character in folder path
-        this.$t("msg.error.invalidDbCredentials"), // Invalid database credentials
-        this.$t("msg.error.unableToConnectToDb"), // Unable to connect to database, please check your database is up
-        this.$t("msg.error.userDoesntHaveSufficientPermission"), // User does not exist or have sufficient permission to create schema
+        this.$t('msg.error.invalidChar'), // Invalid character in folder path
+        this.$t('msg.error.invalidDbCredentials'), // Invalid database credentials
+        this.$t('msg.error.unableToConnectToDb'), // Unable to connect to database, please check your database is up
+        this.$t('msg.error.userDoesntHaveSufficientPermission') // User does not exist or have sufficient permission to create schema
       ],
-      compErrorMessage: "",
-    };
+      compErrorMessage: ''
+    }
   },
   computed: {
-    ...mapGetters({ sqlMgr: "sqlMgr/sqlMgr" }),
+    ...mapGetters({ sqlMgr: 'sqlMgr/sqlMgr' }),
     isTitle() {
-      return this.project.title && this.project.title.trim().length;
+      return this.project.title && this.project.title.trim().length
     },
     envStatusValid() {
       return (
@@ -1252,46 +1268,46 @@ export default {
         Object.values(this.project.envs).every(
           this.getEnvironmentStatusAggregatedNew
         )
-      );
+      )
     },
     typeIcon() {
       if (this.project.projectType) {
         return this.projectTypes.find(
           ({ value }) => value === this.project.projectType
-        );
+        )
       } else {
         return {
-          icon: "mdi-server",
-          iconColor: "primary",
-        };
+          icon: 'mdi-server',
+          iconColor: 'primary'
+        }
       }
     },
     databaseNamesReverse() {
       return Object.entries(this.databaseNames).reduce(
         (newObj, [value, key]) => {
-          newObj[key] = value;
-          return newObj;
+          newObj[key] = value
+          return newObj
         },
         {}
-      );
-    },
+      )
+    }
   },
   methods: {
     async enableAllSchemas() {
-      this.$toast.info("Enabled all schemas").goAway(3000);
-      this.allSchemas = true;
+      this.$toast.info('Enabled all schemas').goAway(3000)
+      this.allSchemas = true
       await this.$axios({
-        url: "demo",
-        baseURL: `${this.$axios.defaults.baseURL}/dashboard`,
-      });
+        url: 'demo',
+        baseURL: `${this.$axios.defaults.baseURL}/dashboard`
+      })
     },
 
     ...mapActions({
-      loadProjects: "project/loadProjects",
+      loadProjects: 'project/loadProjects'
     }),
     onAdvancePanelToggle() {
       if (this.$refs.monacoEditor) {
-        setTimeout(() => this.$refs.monacoEditor.resizeLayout(), 400);
+        setTimeout(() => this.$refs.monacoEditor.resizeLayout(), 400)
       }
     },
     getProjectEditTooltip() {
@@ -1302,17 +1318,17 @@ export default {
     },
     readFileContent(db, obj, key, index) {
       readFile(this.$refs[`${key}FilePath`][index], (data) => {
-        Vue.set(db.connection[obj], key, data);
-      });
+        Vue.set(db.connection[obj], key, data)
+      })
     },
     selectFile(db, obj, key, index) {
-      this.$refs[key][index].click();
+      this.$refs[key][index].click()
     },
     onPanelToggle(panelIndex, envKey) {
       this.$nextTick(() => {
         if (this.panel !== undefined) {
-          const panelContainer = this.$refs.panelContainer;
-          const panel = this.$refs[`panel${envKey}`][0].$el;
+          const panelContainer = this.$refs.panelContainer
+          const panel = this.$refs[`panel${envKey}`][0].$el
           setTimeout(
             () =>
               (panelContainer.scrollTop =
@@ -1321,100 +1337,100 @@ export default {
                 panelContainer.getBoundingClientRect().top -
                 50),
             500
-          );
-          setTimeout(() => this.$refs[`password${envKey}`][0].focus());
+          )
+          setTimeout(() => this.$refs[`password${envKey}`][0].focus())
         }
-      });
+      })
     },
     scrollToTop() {
-      document.querySelector("html").scrollTop = 0;
+      document.querySelector('html').scrollTop = 0
     },
     showDBTabInEnvPanel(panelIndex, tabIndex) {
-      this.panel = panelIndex;
-      Vue.set(this.databases, panelIndex, tabIndex);
+      this.panel = panelIndex
+      Vue.set(this.databases, panelIndex, tabIndex)
     },
     getProjectJson() {
       /**
        * remove UI keys within project
        */
-      const xcConfig = JSON.parse(JSON.stringify(this.project));
-      delete xcConfig.ui;
+      const xcConfig = JSON.parse(JSON.stringify(this.project))
+      delete xcConfig.ui
 
       for (const env in xcConfig.envs) {
         for (let i = 0; i < xcConfig.envs[env].db.length; ++i) {
-          xcConfig.envs[env].db[i].meta.api.type = this.project.projectType;
+          xcConfig.envs[env].db[i].meta.api.type = this.project.projectType
           if (
-            xcConfig.envs[env].db[i].client === "mysql" ||
-            xcConfig.envs[env].db[i].client === "mysql2"
+            xcConfig.envs[env].db[i].client === 'mysql' ||
+            xcConfig.envs[env].db[i].client === 'mysql2'
           ) {
-            xcConfig.envs[env].db[i].connection.multipleStatements = true;
+            xcConfig.envs[env].db[i].connection.multipleStatements = true
           }
-          this.handleSSL(xcConfig.envs[env].db[i], false);
-          delete xcConfig.envs[env].db[i].ui;
-          if (this.client[i] === "Vitess") {
-            xcConfig.envs[env].db[i].meta.dbtype = "vitess";
+          this.handleSSL(xcConfig.envs[env].db[i], false)
+          delete xcConfig.envs[env].db[i].ui
+          if (this.client[i] === 'Vitess') {
+            xcConfig.envs[env].db[i].meta.dbtype = 'vitess'
           }
-          if (this.client[i] === "TiDB") {
-            xcConfig.envs[env].db[i].meta.dbtype = "tidb";
+          if (this.client[i] === 'TiDB') {
+            xcConfig.envs[env].db[i].meta.dbtype = 'tidb'
           }
-          if (xcConfig.envs[env].db[i].client === "oracledb") {
+          if (xcConfig.envs[env].db[i].client === 'oracledb') {
             xcConfig.envs[env].db[i].pool = {
               min: 0,
-              max: 50,
-            };
+              max: 50
+            }
 
-            xcConfig.envs[env].db[i].acquireConnectionTimeout = 60000;
+            xcConfig.envs[env].db[i].acquireConnectionTimeout = 60000
           }
 
-          const inflectionObj = xcConfig.envs[env].db[i].meta.inflection;
+          const inflectionObj = xcConfig.envs[env].db[i].meta.inflection
 
           if (inflectionObj) {
             if (Array.isArray(inflectionObj.table_name)) {
-              inflectionObj.table_name = inflectionObj.table_name.join(",");
+              inflectionObj.table_name = inflectionObj.table_name.join(',')
             }
             if (Array.isArray(inflectionObj.column_name)) {
-              inflectionObj.column_name = inflectionObj.column_name.join(",");
+              inflectionObj.column_name = inflectionObj.column_name.join(',')
             }
 
-            inflectionObj.table_name = inflectionObj.table_name || "none";
-            inflectionObj.column_name = inflectionObj.column_name || "none";
+            inflectionObj.table_name = inflectionObj.table_name || 'none'
+            inflectionObj.column_name = inflectionObj.column_name || 'none'
           }
 
           if (this.allSchemas) {
-            delete xcConfig.envs[env].db[i].connection.database;
-            xcConfig.envs[env].db[i].meta.allSchemas = true;
+            delete xcConfig.envs[env].db[i].connection.database
+            xcConfig.envs[env].db[i].meta.allSchemas = true
           }
         }
       }
 
-      xcConfig.auth = {};
+      xcConfig.auth = {}
       switch (this.auth.authType) {
-        case "jwt":
+        case 'jwt':
           xcConfig.auth.jwt = {
             secret: this.auth.authSecret,
             dbAlias:
-              xcConfig.envs[Object.keys(xcConfig.envs)[0]].db[0].meta.dbAlias,
-          };
-          break;
-        case "masterKey":
+            xcConfig.envs[Object.keys(xcConfig.envs)[0]].db[0].meta.dbAlias
+          }
+          break
+        case 'masterKey':
           xcConfig.auth.masterKey = {
-            secret: this.auth.authSecret,
-          };
-          sessionStorage.setItem("masterKey", this.auth.authSecret);
-          break;
-        case "middleware":
+            secret: this.auth.authSecret
+          }
+          sessionStorage.setItem('masterKey', this.auth.authSecret)
+          break
+        case 'middleware':
           xcConfig.auth.masterKey = {
-            url: this.auth.webhook,
-          };
-          break;
+            url: this.auth.webhook
+          }
+          break
         default:
-          this.auth.disabled = true;
-          break;
+          this.auth.disabled = true
+          break
       }
 
       xcConfig.type = this.$store.state.project.projectInfo
         ? this.$store.state.project.projectInfo.type
-        : "docker";
+        : 'docker'
 
       if (
         this.smtpConfiguration &&
@@ -1424,105 +1440,110 @@ export default {
         try {
           xcConfig.mailer = {
             options: JSON5.parse(this.smtpConfiguration.options),
-            from: this.smtpConfiguration.from,
-          };
-        } catch (e) {}
+            from: this.smtpConfiguration.from
+          }
+        } catch (e) {
+        }
       }
 
-      xcConfig.meta = xcConfig.meta || {};
+      xcConfig.meta = xcConfig.meta || {}
       xcConfig.meta.db = {
-        client: "sqlite3",
+        client: 'sqlite3',
         connection: {
-          filename: "xc.db",
-        },
-      };
+          filename: 'xc.db'
+        }
+      }
 
-      return xcConfig;
+      return xcConfig
     },
 
     constructProjectJsonFromProject(project) {
-      const p = project; // JSON.parse(JSON.stringify(project.projectJson));
+      const p = project // JSON.parse(JSON.stringify(project.projectJson));
 
       p.ui = {
         envs: {
-          _noco: {},
-        },
-      };
+          _noco: {}
+        }
+      }
       for (const env in p.envs) {
-        let i = 0;
+        let i = 0
         for (const db of p.envs[env].db) {
-          Vue.set(this.client, i++, this.databaseNamesReverse[db.client]);
+          Vue.set(this.client, i++, this.databaseNamesReverse[db.client])
 
-          Vue.set(db, "ui", {
+          Vue.set(db, 'ui', {
             setup: 0,
             ssl: {
-              key: this.$t("labels.clientKey"), // Client Key
-              cert: this.$t("labels.clientCert"), // Client Cert
-              ca: this.$t("labels.serverCA"), // Server CA
+              key: this.$t('labels.clientKey'), // Client Key
+              cert: this.$t('labels.clientCert'), // Client Cert
+              ca: this.$t('labels.serverCA') // Server CA
             },
-            sslUse: this.$t("general.preferred"), // Preferred
-          });
+            sslUse: this.$t('general.preferred') // Preferred
+          })
         }
       }
       // delete p.projectJson;
 
       if (p.auth) {
         if (p.auth.jwt) {
-          this.auth.authType = "jwt";
-          this.auth.authSecret = p.auth.jwt.secret;
+          this.auth.authType = 'jwt'
+          this.auth.authSecret = p.auth.jwt.secret
         } else if (p.auth.masterKey) {
           if (p.auth.masterKey.secret) {
-            this.auth.authSecret = p.auth.masterKey.secret;
-            this.auth.authType = "masterKey";
+            this.auth.authSecret = p.auth.masterKey.secret
+            this.auth.authType = 'masterKey'
           } else if (p.auth.masterKey.url) {
-            this.auth.webhook = p.auth.masterKey.url;
-            this.auth.authType = "middleware";
+            this.auth.webhook = p.auth.masterKey.url
+            this.auth.authType = 'middleware'
           } else {
-            this.auth.authType = "none";
+            this.auth.authType = 'none'
           }
         } else {
-          this.auth.authType = "none";
+          this.auth.authType = 'none'
         }
       } else {
-        this.auth.authType = "none";
+        this.auth.authType = 'none'
       }
 
-      this.project = p;
+      this.project = p
       if (p.mailer) {
         this.smtpConfiguration = {
           from: p.mailer.from,
-          options: JSON.stringify(p.mailer.options, 0, 2),
-        };
+          options: JSON.stringify(p.mailer.options, 0, 2)
+        }
       }
-      delete p.mailer;
+      delete p.mailer
     },
 
     async createOrUpdateProject() {
-      const projectJson = this.getProjectJson();
-      delete projectJson.folder;
+      const projectJson = this.getProjectJson()
+      delete projectJson.folder
 
-      let i = 0;
-      const toast = this.$toast.info(this.loaderMessages[0]);
+      let i = 0
+      const toast = this.$toast.info(this.loaderMessages[0])
       const interv = setInterval(() => {
         if (this.edit) {
-          return;
+          return
         }
         if (i < this.loaderMessages.length - 1) {
-          i++;
+          i++
         }
         if (toast) {
           if (!this.allSchemas) {
-            toast.text(this.loaderMessages[i]);
+            toast.text(this.loaderMessages[i])
           } else {
-            toast.goAway(100);
+            toast.goAway(100)
           }
         }
-      }, 1000);
+      }, 1000)
 
-      this.projectReloading = true;
+      this.projectReloading = true
 
-      const con = projectJson.envs._noco.db[0];
-      const inflection = (con.meta && con.meta.inflection) || {};
+      const con = projectJson.envs._noco.db[0]
+      if (con.client === 'pg' || con.client === 'mssql') {
+        con.searchPath = [this.schema]
+      }
+
+      const inflection = (con.meta && con.meta.inflection) || {}
       try {
         const result = await this.$api.project.create({
           title: projectJson.title,
@@ -1531,204 +1552,206 @@ export default {
               type: con.client,
               config: con,
               inflection_column: inflection.column_name,
-              inflection_table: inflection.table_name,
-            },
+              inflection_table: inflection.table_name
+            }
           ],
-          external: true,
-        });
+          external: true
+        })
 
-        clearInterval(interv);
-        toast.goAway(100);
+        clearInterval(interv)
+        toast.goAway(100)
 
-        await this.$store.dispatch("project/ActLoadProjectInfo");
+        await this.$store.dispatch('project/ActLoadProjectInfo')
 
-        this.projectReloading = false;
+        this.projectReloading = false
 
         if (!this.edit && !this.allSchemas) {
           this.$router.push({
             path: `/nc/${result.id}`,
             query: {
-              new: 1,
-            },
-          });
+              new: 1
+            }
+          })
         }
 
-        this.projectCreated = true;
+        this.projectCreated = true
       } catch (e) {
         this.$toast
           .error(await this._extractSdkResponseErrorMsg(e))
-          .goAway(3000);
-        toast.goAway(0);
+          .goAway(3000)
+        toast.goAway(0)
       }
 
-      this.projectReloading = false;
-      this.$e("a:project:create:extdb");
+      this.projectReloading = false
+      this.$e('a:project:create:extdb')
     },
 
     mtdDialogGetEnvNameSubmit(envName, cookie) {
-      this.dialogGetEnvName.dialogShow = false;
+      this.dialogGetEnvName.dialogShow = false
       if (envName in this.project.envs) {
       } else {
         Vue.set(this.project.envs, envName, {
           db: [
             {
-              client: "pg",
+              client: 'pg',
               connection: {
-                host: "localhost",
-                port: "5432",
-                user: "postgres",
-                password: "password",
-                database: "new_database",
+                host: 'localhost',
+                port: '5432',
+                user: 'postgres',
+                password: 'password',
+                database: 'new_database'
               },
               meta: {
-                tn: "nc_evolutions",
-                dbAlias: "db",
+                tn: 'nc_evolutions',
+                dbAlias: 'db',
                 inflection: {
-                  table_name: "camelize",
-                  column_name: "camelize",
+                  table_name: 'camelize',
+                  column_name: 'camelize'
                 },
                 api: {
-                  type: "",
-                },
+                  type: ''
+                }
               },
               ui: {
                 setup: 0,
                 ssl: {
-                  key: this.$t("labels.clientKey"), // Client Key
-                  cert: this.$t("labels.clientCert"), // Client Cert
-                  ca: this.$t("labels.serverCA"), // Server CA
+                  key: this.$t('labels.clientKey'), // Client Key
+                  cert: this.$t('labels.clientCert'), // Client Cert
+                  ca: this.$t('labels.serverCA') // Server CA
                 },
-                sslUse: this.$t("general.preferred"), // Preferred
-              },
-            },
+                sslUse: this.$t('general.preferred') // Preferred
+              }
+            }
           ],
-          apiClient: { data: [] },
-        });
+          apiClient: { data: [] }
+        })
       }
     },
     mtdDialogGetEnvNameCancel() {
-      this.dialogGetEnvName.dialogShow = false;
+      this.dialogGetEnvName.dialogShow = false
     },
 
     addNewEnvironment() {
-      this.dialogGetEnvName.dialogShow = true;
+      this.dialogGetEnvName.dialogShow = true
     },
     addNewDB(envKey, panelIndex) {
-      const len = this.project.envs[envKey].db.length;
+      const len = this.project.envs[envKey].db.length
       // eslint-disable-next-line no-unused-vars
-      const lastDbName = `${this.project.title}_${envKey}_${len}`;
+      const lastDbName = `${this.project.title}_${envKey}_${len}`
       const dbType = (this.client[len] =
-        this.client[len] || this.client[len - 1]);
-      const newlyCreatedIndex = this.project.envs[envKey].db.length;
+        this.client[len] || this.client[len - 1])
+      const newlyCreatedIndex = this.project.envs[envKey].db.length
       const dbAlias =
         this.project.envs[envKey].db.length <= 0
-          ? "db"
-          : `db${this.project.envs[envKey].db.length + 1}`;
+          ? 'db'
+          : `db${this.project.envs[envKey].db.length + 1}`
       this.project.envs[envKey].db.push({
         client: this.databaseNames[dbType],
         connection: {
           ...this.sampleConnectionData[dbType],
-          database: `${this.project.title}_${envKey}_${newlyCreatedIndex + 1}`,
+          database: `${this.project.title}_${envKey}_${newlyCreatedIndex + 1}`
         },
         meta: {
-          tn: "nc_evolutions",
+          tn: 'nc_evolutions',
           dbAlias,
           inflection: {
-            table_name: "camelize",
-            column_name: "camelize",
+            table_name: 'camelize',
+            column_name: 'camelize'
           },
           api: {
-            type: "",
-          },
+            type: ''
+          }
         },
         ui: {
           setup: 0,
-          sslUse: this.$t("general.preferred"), // Preferred
+          sslUse: this.$t('general.preferred'), // Preferred
           ssl: {
-            key: this.$t("labels.clientKey"), // Client Key
-            cert: this.$t("labels.clientCert"), // Client Cert
-            ca: this.$t("labels.serverCA"), // Server CA
-          },
-        },
-      });
+            key: this.$t('labels.clientKey'), // Client Key
+            cert: this.$t('labels.clientCert'), // Client Cert
+            ca: this.$t('labels.serverCA') // Server CA
+          }
+        }
+      })
       // set active tab as newly created
-      this.databases[panelIndex] = newlyCreatedIndex;
+      this.databases[panelIndex] = newlyCreatedIndex
     },
 
     testConnectionMethodSubmit() {
-      this.dialog.show = false;
+      this.dialog.show = false
+    },
+    selectDir(ev) {
+    },
+    selectSqliteFile(db) {
     },
-    selectDir(ev) {},
-    selectSqliteFile(db) {},
 
     getDbStatusColor(db) {
       switch (db.ui.setup) {
         case -1:
-          return "red";
+          return 'red'
 
         case 0:
-          return "orange";
+          return 'orange'
 
         case 1:
-          return "green";
+          return 'green'
 
         default:
-          break;
+          break
       }
     },
 
     getDbStatusTooltip(db) {
       switch (db.ui.setup) {
         case -1:
-          return "DB Connection NOT successful";
+          return 'DB Connection NOT successful'
 
         case 0:
-          return "MySql Database Detected - Test your connection";
+          return 'MySql Database Detected - Test your connection'
 
         case 1:
-          return "DB Connection successful";
+          return 'DB Connection successful'
 
         default:
-          break;
+          break
       }
     },
     async newTestConnection(db, env, panelIndex) {
       if (
-        db.connection.host === "localhost" &&
+        db.connection.host === 'localhost' &&
         !this.edit &&
-        env === "_noco" &&
+        env === '_noco' &&
         this.project.envs[env].db.length === 1 &&
-        this.project.envs[env].db[0].connection.user === "postgres" &&
+        this.project.envs[env].db[0].connection.user === 'postgres' &&
         this.project.envs[env].db[0].connection.database ===
-          `${this.project.title}_${env}_${this.project.envs[env].length}`
+        `${this.project.title}_${env}_${this.project.envs[env].length}`
       ) {
-        this.handleSSL(db);
-        if (db.client === "sqlite3") {
-          db.ui.setup = 1;
+        this.handleSSL(db)
+        if (db.client === 'sqlite3') {
+          db.ui.setup = 1
         } else {
           const c1 = {
             connection: {
               ...db.connection,
-              ...(db.client !== "pg"
+              ...(db.client !== 'pg'
                 ? { database: this.testDatabaseNames[db.client] }
-                : {}),
+                : {})
             },
-            client: db.client,
-          };
+            client: db.client
+          }
 
-          const result = await this.$store.dispatch("sqlMgr/ActSqlOp", [
+          const result = await this.$store.dispatch('sqlMgr/ActSqlOp', [
             {
               query: {
-                skipProjectHasDb: 1,
-              },
+                skipProjectHasDb: 1
+              }
             },
-            "testConnection",
-            c1,
-          ]);
+            'testConnection',
+            c1
+          ])
 
           if (result.code === 0) {
-            db.ui.setup = 1;
-            let passed = true;
+            db.ui.setup = 1
+            let passed = true
             /**
              * get other environments
              * and if host is localhost - test and update connection status
@@ -1742,276 +1765,286 @@ export default {
                 const c2 = {
                   connection: {
                     ...this.project.envs[e].db[0].connection,
-                    database: undefined,
+                    database: undefined
                   },
-                  client: this.project.envs[e].db[0].client,
-                };
+                  client: this.project.envs[e].db[0].client
+                }
 
-                this.handleSSL(c2);
+                this.handleSSL(c2)
 
-                const result = await this.sqlMgr.testConnection(c2);
+                const result = await this.sqlMgr.testConnection(c2)
 
                 if (result.code === 0) {
-                  this.project.envs[e][0].ui.setup = 1;
+                  this.project.envs[e][0].ui.setup = 1
                 } else {
-                  this.project.envs[e][0].ui.setup = -1;
-                  passed = false;
-                  break;
+                  this.project.envs[e][0].ui.setup = -1
+                  passed = false
+                  break
                 }
               }
             }
 
             if (passed) {
-              this.panel = null;
+              this.panel = null
             } else {
               // Connection was successful
-              this.dialog.heading = this.$t("msg.info.dbConnected");
-              this.dialog.type = "success";
-              this.dialog.show = true;
+              this.dialog.heading = this.$t('msg.info.dbConnected')
+              this.dialog.type = 'success'
+              this.dialog.show = true
             }
           } else {
-            db.ui.setup = -1;
+            db.ui.setup = -1
             // Connection Failure:
             this.dialog.heading =
-              this.$t("msg.error.dbConnectionFailed") + result.message;
-            this.dialog.type = "error";
-            this.dialog.show = true;
+              this.$t('msg.error.dbConnectionFailed') + result.message
+            this.dialog.type = 'error'
+            this.dialog.show = true
           }
         }
 
-        return true;
+        return true
       } else {
-        return false;
+        return false
       }
     },
 
     sendAdvancedConfig(connection) {
       if (!connection.ssl) {
-        return false;
+        return false
       }
-      let sendAdvancedConfig = false;
-      const sslOptions = Object.values(connection.ssl).filter((el) => !!el);
+      let sendAdvancedConfig = false
+      const sslOptions = Object.values(connection.ssl).filter(el => !!el)
       if (sslOptions[0]) {
-        sendAdvancedConfig = true;
+        sendAdvancedConfig = true
       } else {
       }
-      return sendAdvancedConfig;
+      return sendAdvancedConfig
     },
 
     handleSSL(db, creating = true) {
-      const sendAdvancedConfig = this.sendAdvancedConfig(db.connection);
+      const sendAdvancedConfig = this.sendAdvancedConfig(db.connection)
       if (!sendAdvancedConfig) {
-        db.connection.ssl = undefined;
+        db.connection.ssl = undefined
       }
 
       if (db.connection.ssl) {
       }
     },
-    getDatabaseForTestConnection(dbType) {},
+    getDatabaseForTestConnection(dbType) {
+    },
     async testConnection(db, env, panelIndex) {
-      this.$e("a:project:create:extdb:test-connection");
-      this.$store.commit("notification/MutToggleProgressBar", true);
+      this.$e('a:project:create:extdb:test-connection')
+      this.$store.commit('notification/MutToggleProgressBar', true)
       try {
         if (!(await this.newTestConnection(db, env, panelIndex))) {
-          this.handleSSL(db);
+          this.handleSSL(db)
 
-          if (db.client === "sqlite3") {
-            db.ui.setup = 1;
+          if (db.client === 'sqlite3') {
+            db.ui.setup = 1
           } else {
             const c1 = {
               connection: {
                 ...db.connection,
-                ...(db.client !== "pg"
+                ...(db.client !== 'pg'
                   ? { database: this.testDatabaseNames[db.client] }
-                  : {}),
+                  : {})
               },
-              client: db.client,
-            };
+              client: db.client
+            }
 
-            const result = await this.$api.utils.testConnection(c1);
+            const result = await this.$api.utils.testConnection(c1)
 
             if (result.code === 0) {
-              db.ui.setup = 1;
+              db.ui.setup = 1
               // this.dialog.heading = "Connection was successful"
               // this.dialog.type = 'success';
               // this.dialog.show = true;
-              this.testSuccess = true;
+              this.testSuccess = true
             } else {
-              db.ui.setup = -1;
+              db.ui.setup = -1
               // this.activeDbNode.testConnectionStatus = false;
               this.dialog.heading =
-                this.$t("msg.error.dbConnectionFailed") + result.message;
-              this.dialog.type = "error";
-              this.dialog.show = true;
+                this.$t('msg.error.dbConnectionFailed') + result.message
+              this.dialog.type = 'error'
+              this.dialog.show = true
             }
           }
         }
       } catch (e) {
-        console.log(e);
+        console.log(e)
       } finally {
-        this.$store.commit("notification/MutToggleProgressBar", false);
+        this.$store.commit('notification/MutToggleProgressBar', false)
       }
     },
     getEnvironmentStatusAggregated(dbs) {
-      return dbs.every((db) => db.ui.setup === 1);
+      return dbs.every(db => db.ui.setup === 1)
     },
 
     getEnvironmentStatusAggregatedNew(dbs) {
-      return dbs.db.every((db) => db.ui.setup === 1);
+      return dbs.db.every(db => db.ui.setup === 1)
     },
     openFirstPanel() {
       if (!this.edit) {
-        this.panel = 0;
+        this.panel = 0
       }
     },
     onDatabaseTypeChanged(client, db1, index, env) {
+      if (this.databaseNames[client] === 'mssql') {
+        this.schema = 'dbo'
+      } else if (this.databaseNames[client] === 'pg') {
+        this.schema = 'public'
+      }
+
       for (const env in this.project.envs) {
         if (this.project.envs[env].db.length > index) {
-          const db = this.project.envs[env].db[index];
-          Vue.set(db, "client", this.databaseNames[client]);
-          if (client !== "Sqlite") {
-            const { ssl, ...connectionDet } = this.sampleConnectionData[client];
+          const db = this.project.envs[env].db[index]
+          Vue.set(db, 'client', this.databaseNames[client])
 
-            Vue.set(db, "connection", {
+          if (client !== 'Sqlite') {
+            const { ssl, ...connectionDet } = this.sampleConnectionData[client]
+
+            Vue.set(db, 'connection', {
               ...connectionDet,
               database: `${this.project.title}_${env}_${index + 1}`,
-              ssl: { ...ssl },
-            });
+              ssl: { ...ssl }
+            })
 
             for (const env in this.project.envs) {
               if (this.project.envs[env].length > index) {
-                this.setDBStatus(this.project.envs[env][index], 0);
+                this.setDBStatus(this.project.envs[env][index], 0)
               }
             }
           } else {
-            db.connection = {};
-            Vue.set(db, "connection", {
-              client: "sqlite3",
+            db.connection = {}
+            Vue.set(db, 'connection', {
+              client: 'sqlite3',
               // connection: {filename: path.join(this.project.folder, `${this.project.title}_${env}_${index + 1}`)},
               connection: {
                 filename: [
                   this.project.folder,
-                  `${this.project.title}_${env}_${index + 1}`,
-                ].join("/"),
+                  `${this.project.title}_${env}_${index + 1}`
+                ].join('/')
               },
               database: [
                 this.project.folder,
-                `${this.project.title}_${env}_${index + 1}`,
-              ].join("/"),
-              useNullAsDefault: true,
-            });
+                `${this.project.title}_${env}_${index + 1}`
+              ].join('/'),
+              useNullAsDefault: true
+            })
           }
         }
       }
     },
     selectDatabaseClient(database, index = 0) {
       if (this.client) {
-        this.client[index] = database;
+        this.client[index] = database
       }
     },
     setDBStatus(db, status) {
-      db.ui.setup = status;
+      db.ui.setup = status
     },
     removeDBFromEnv(db, env, panelIndex, dbIndex) {
       for (const env in this.project.envs) {
         if (this.project.envs[env].db.length > dbIndex) {
-          this.project.envs[env].db.splice(dbIndex, 1);
+          this.project.envs[env].db.splice(dbIndex, 1)
         }
       }
     },
     removeEnv(envKey) {
-      delete this.project.envs[envKey];
-      Vue.set(this.project, "envs", { ...this.project.envs });
-    },
+      delete this.project.envs[envKey]
+      Vue.set(this.project, 'envs', { ...this.project.envs })
+    }
+  },
+  fetch({ store, params }) {
+  },
+  beforeCreated() {
   },
-  fetch({ store, params }) {},
-  beforeCreated() {},
   watch: {
-    "project.title"(newValue, oldValue) {
+    'project.title'(newValue, oldValue) {
       if (!newValue) {
-        return;
+        return
       }
       if (!this.edit) {
         // Vue.set(this.project, 'folder', slash(path.join(this.baseFolder, newValue)))
-        Vue.set(this.project, "folder", [this.baseFolder, newValue].join("/"));
+        Vue.set(this.project, 'folder', [this.baseFolder, newValue].join('/'))
         // }//this.project.folder = `${this.baseFolder}/${newValue}`;
 
         for (const env in this.project.envs) {
           for (const [index, db] of this.project.envs[env].db.entries()) {
             // db.connection.database = `${this.project.title}_${env}_${index}`
-            if (db.client !== "sqlite3") {
+            if (db.client !== 'sqlite3') {
               Vue.set(
                 db.connection,
-                "database",
+                'database',
                 `${this.project.title}_${env}_${index + 1}`
-              );
+              )
             } else {
               Vue.set(
                 db.connection,
-                "database",
+                'database',
                 `${this.project.title}_${env}_${index + 1}`
-              );
+              )
             }
           }
         }
       }
     },
-    "project.envs": {
+    'project.envs': {
       deep: true,
       handler(envs) {
-        if (typeof envs === "object" && envs) {
+        if (typeof envs === 'object' && envs) {
           Object.entries(envs).forEach(([key, env]) => {
-            let res = 1;
-            const msg = {};
+            let res = 1
+            const msg = {}
             for (const db of env.db) {
-              res = db.ui.setup < res ? db.ui.setup : res;
+              res = db.ui.setup < res ? db.ui.setup : res
             }
             if (this.edit) {
-              Vue.set(this.project.ui, key, "");
+              Vue.set(this.project.ui, key, '')
             } else {
               switch (res) {
                 case -1:
-                  msg.color = "red";
+                  msg.color = 'red'
                   // msg.msg = ' ( Invalid database parameters )'
-                  msg.msg = `( ${this.$t("msg.error.dbConnectionStatus")} )`;
-                  break;
+                  msg.msg = `( ${this.$t('msg.error.dbConnectionStatus')} )`
+                  break
                 case 0:
-                  msg.color = "warning";
-                  msg.msg = " ( Click to validate database credentials )";
-                  break;
+                  msg.color = 'warning'
+                  msg.msg = ' ( Click to validate database credentials )'
+                  break
                 case 1:
-                  msg.color = "green";
+                  msg.color = 'green'
                   // msg.msg = ' ( Environment Validated )'
-                  msg.msg = `( ${this.$t("msg.info.dbConnectionStatus")} )`;
-                  break;
+                  msg.msg = `( ${this.$t('msg.info.dbConnectionStatus')} )`
+                  break
               }
-              Vue.set(this.project.ui, key, msg);
+              Vue.set(this.project.ui, key, msg)
             }
-          });
+          })
         }
-      },
-    },
+      }
+    }
   },
   async created() {
     this.compErrorMessage =
       this.compErrorMessages[
         Math.floor(Math.random() * this.compErrorMessages.length)
-      ];
+      ]
 
     if (this.edit) {
       try {
-        let data = await this.$store.dispatch("sqlMgr/ActSqlOp", [
+        let data = await this.$store.dispatch('sqlMgr/ActSqlOp', [
           null,
-          "xcProjectGetConfig",
-        ]);
-        data = JSON.parse(data.config);
-        this.constructProjectJsonFromProject(data);
-        this.$set(this.project, "folder", data.folder);
+          'xcProjectGetConfig'
+        ])
+        data = JSON.parse(data.config)
+        this.constructProjectJsonFromProject(data)
+        this.$set(this.project, 'folder', data.folder)
       } catch (e) {
-        this.$toast.error(e.message).goAway(3000);
+        this.$toast.error(e.message).goAway(3000)
       }
     } else {
-      this.project = JSON.parse(JSON.stringify(this.defaultProject));
+      this.project = JSON.parse(JSON.stringify(this.defaultProject))
       // this.edit = false;
 
       /**
@@ -2021,74 +2054,77 @@ export default {
        *
        *
        */
-      let dbsAvailable = []; // await PortScanner.getOpenDbPortsAsList();
+      let dbsAvailable = [] // await PortScanner.getOpenDbPortsAsList();
       // // setting MySQL as default value if no databases are available
       // if (!dbsAvailable || !dbsAvailable.length) {
-      dbsAvailable = ["MySQL"];
+      dbsAvailable = ['MySQL']
       // }
 
-      this.selectDatabaseClient(dbsAvailable[0], 0);
+      this.selectDatabaseClient(dbsAvailable[0], 0)
 
       // iterating over environment and setting default connection details based
       // on first available database
       for (const env in this.project.envs) {
         for (const db of this.project.envs[env].db) {
-          db.client = this.databaseNames[dbsAvailable[0]];
+          db.client = this.databaseNames[dbsAvailable[0]]
 
-          if (db.client === "sqlite3") {
+          if (db.client === 'sqlite3') {
             db.connection = {
-              ...this.sampleConnectionData[dbsAvailable[0]],
-            };
+              ...this.sampleConnectionData[dbsAvailable[0]]
+            }
 
-            db.ui.setup = 0;
+            db.ui.setup = 0
           } else {
             db.connection = {
               ...this.sampleConnectionData[dbsAvailable[0]],
-              ssl: { ...this.sampleConnectionData[dbsAvailable[0]].ssl },
-            };
+              ssl: { ...this.sampleConnectionData[dbsAvailable[0]].ssl }
+            }
           }
         }
       }
     }
   },
-  beforeMount() {},
+  beforeMount() {
+  },
   mounted() {
     this.$set(
       this.project,
-      "title",
+      'title',
       uniqueNamesGenerator({
         dictionaries: [[starWars], [adjectives, animals]][
           Math.floor(Math.random() * 2)
-        ],
+        ]
       })
         .toLowerCase()
-        .replace(/[ -]/g, "_")
-    );
+        .replace(/[ -]/g, '_')
+    )
 
     this.$nextTick(() => {
-      const input = this.$refs.name.$el.querySelector("input");
-      input.setSelectionRange(0, this.project.title.length);
-      input.focus();
-    });
+      const input = this.$refs.name.$el.querySelector('input')
+      input.setSelectionRange(0, this.project.title.length)
+      input.focus()
+    })
+  },
+  beforeDestroy() {
+  },
+  destroy() {
   },
-  beforeDestroy() {},
-  destroy() {},
   validate({ params }) {
-    return true;
+    return true
   },
   head() {
     return {
-      title: this.$t("title.headCreateProject"),
-    };
+      title: this.$t('title.headCreateProject')
+    }
   },
   props: {
     edit: {
       type: Boolean,
-      default: false,
-    },
+      default: false
+    }
   },
-  directives: {},
-};
+  directives: {}
+}
 </script>
 
 <style scoped>
diff --git a/packages/nc-gui/lang/en.json b/packages/nc-gui/lang/en.json
index 5ea5565085..a8f3073817 100644
--- a/packages/nc-gui/lang/en.json
+++ b/packages/nc-gui/lang/en.json
@@ -191,6 +191,7 @@
     "port": "Port Number",
     "username": "Username",
     "password": "Password",
+    "schemaName": "Schema name",
     "action": "Action",
     "actions": "Actions",
     "operation": "Operation",