feat: cli - unit test, npmp package and executable build

packages/nc-secret-cli/src/core/NcConfig.ts

@@ -1,14 +1,11 @@
 import * as path from 'path';
 import fs from 'fs';
 import { promisify } from 'util';
-import { getToolDir, metaUrlToDbConfig } from './helpers';
+const { DriverClient, getToolDir, metaUrlToDbConfig } = require( '../nocodb/cli');
-import { DriverClient } from './interfaces';
-import type { DbConfig } from './interfaces';
-import { SqlClientFactory } from 'nocodb';
 
 export class NcConfig {
   meta: {
-    db: DbConfig;
+    db: any;
   } = {
     db: {
       client: DriverClient.SQLITE,

packages/nc-secret-cli/src/core/NcError.ts

@@ -0,0 +1,3 @@
+export class NcError extends Error {
+
+}

packages/nc-secret-cli/src/core/NcLogger.ts

@@ -0,0 +1,27 @@
+// a class to log messages to the console with colors and styles
+export class NcLogger {
+  static log(message: string) {
+    console.log(message);
+  }
+
+  static error(message: string) {
+    console.error('\x1b[31m%s\x1b[0m', 'Error: ' + message);
+  }
+
+  static warn(message: string) {
+    console.warn('\x1b[33m%s\x1b[0m', 'Warning: ' + message);
+  }
+
+  static info(message: string) {
+    console.info('\x1b[32m%s\x1b[0m', 'Info: ' + message);
+  }
+
+  static success(message: string) {
+    console.log('\x1b[32m%s\x1b[0m', 'Success: ' + message);
+  }
+
+  static debug(message: string) {
+    console.debug('\x1b[34m%s\x1b[0m', 'Debug: ' + message);
+  }   
+  
+}

packages/nc-secret-cli/src/core/SecretManager.ts

@@ -1,4 +1,6 @@
-import { SqlClientFactory, MetaTable, decryptPropIfRequired, encryptPropIfRequired } from 'nocodb';
+import {NcError} from "./NcError";
+
+const { SqlClientFactory, MetaTable, decryptPropIfRequired, encryptPropIfRequired } =  require('../nocodb/cli')
 
 export class SecretManager {
 
@@ -14,19 +16,34 @@ export class SecretManager {
     // use the sqlClientFactory to create a new sql client and then use testConnection to test the connection
     const isValid = await this.sqlClient.testConnection();
     if (!isValid) {
-      throw new Error('Invalid database configuration');
+      throw new NcError('Invalid database configuration');
     }
   }
 
 
   async validateAndExtract() {
+    // check if tables are present in the database
+    if (!(await this.sqlClient.knex.schema.hasTable(MetaTable.SOURCES))) {
+      throw new NcError('Sources table not found');
+    }
+
+    if (!(await this.sqlClient.knex.schema.hasTable(MetaTable.INTEGRATIONS))) {
+      throw new NcError('Integrations table not found');
+    }
+
+    // if is_encrypted column is not present in the sources table then throw an error
+    if(
+      !(await this.sqlClient.knex.schema.hasColumn(MetaTable.SOURCES, 'is_encrypted')) ||
+      !(await this.sqlClient.knex.schema.hasColumn(MetaTable.INTEGRATIONS, 'is_encrypted'))){
+      throw new NcError('Looks like you are using an older version of NocoDB. Please upgrade to the latest version and try again.');
+    }
+
+
     const sources = await this.sqlClient.knex(MetaTable.SOURCES).where(qb => {
       qb.where('is_meta', false).orWhere('is_meta', null)
     });
 
-    const integrations = await this.sqlClient.knex(MetaTable.INTEGRATIONS).where(qb => {
+    const integrations = await this.sqlClient.knex(MetaTable.INTEGRATIONS);
-      qb.where('is_meta', false).orWhere('is_meta', null)
-    });
 
     const sourcesToUpdate: Record<string, any>[] = [];
     const integrationsToUpdate: Record<string, any>[] = [];
@@ -63,10 +80,11 @@ export class SecretManager {
 
     // if all of the decyptions are failed then throw an error
     if (!isValid) {
-      throw new Error('Invalid old secret or no sources/integrations found');
+      throw new NcError('Invalid old secret or no sources/integrations found');
     }
 
 
+
     return { sourcesToUpdate, integrationsToUpdate };
   }
 

packages/nc-secret-cli/src/core/index.ts

@@ -0,0 +1,4 @@
+export * from './NcConfig';
+export * from './NcError';
+export * from './NcLogger';
+export * from './SecretManager';   

packages/nc-secret-cli/src/index.spec.ts

@@ -0,0 +1,17 @@
+import { describe, it } from 'mocha';
+import { expect } from 'chai';
+import { program } from 'commander';
+
+describe('Index', () => {
+
+describe('index.ts', () => {
+  it('should parse the arguments and options correctly', () => {
+    const argv = ['node', 'index.ts', 'oldSecret', 'newSecret', '--nc-db','test_db_url', '--database-url', 'test_db_url', '-o', 'oldSecret', '-n', 'newSecret'];
+    program.parse(argv);
+    expect(program.opts().oldSecret).to.equal('oldSecret');
+    expect(program.opts().newSecret).to.equal('newSecret');
+    expect(program.opts().ncDb).to.equal('test_db_url');
+    expect(program.opts().databaseUrl).to.equal('test_db_url');
+  });
+});
+});

packages/nc-secret-cli/src/index.ts

@@ -1,39 +1,58 @@
 import figlet from "figlet";
-
-console.log(figlet.textSync("Nocodb Secret CLI"));
-
 import { Command } from 'commander';
-import { getNocoConfig } from "./nc-config";
+import { getNocoConfig } from "./core/NcConfig";
 import { SecretManager } from "./core/SecretManager";
+import { NcError } from "./core/NcError";
+import { NcLogger } from "./core/NcLogger";
+
+console.log(figlet.textSync("NocoDB Secret CLI"));
 
 const program = new Command();
 
 program
-    .version('1.0.0')
+  .version('1.0.0')
-    .description('NocoDB Secret CLI')
+  .description('NocoDB Secret CLI')
-    .arguments('<oldSecret> <newSecret>')
+  .arguments('<oldSecret> <newSecret>')
-    .action(async (key, value) => {
+  .option('--nc-db <nc-db>', 'NocoDB  connection database url, equivalent to NC_DB env variable')
+  .option('--nc-db-json <nc-db-json>', 'NocoDB connection database json, equivalent to NC_DB_JSON env variable')
+  .option('--nc-db-json-file <nc-db-json-file>', 'NocoDB connection database json file path, equivalent to NC_DB_JSON_FILE env variable')
+  .option('--database-url <database-url>', 'JDBC database url, equivalent to DATABASE_URL env variable')
+  .option('--database-url-file <database-url-file>', 'JDBC database url file path, equivalent to DATABASE_URL_FILE env variable')
+  .option('-o, --old-secret <old-secret>', 'old secret string to decrypt sources and integrations')
+  .option('-n, --new-secret <new-secret>', 'new secret string to encrypt sources and integrations')
+  .action(async (key, value, ...rest) => {
+
+    try {
+
+      const config = await getNocoConfig();
 
-        const config = await getNocoConfig();
+      if (!key || !value) {
+        console.error('Error: Both key and value are required.');
+        program.help();
+      } else {
+        const secretManager = new SecretManager(key, value, config);
 
-        if (!key || !value) {
+        // validate meta db config which is resolved from env variables
-            console.error('Error: Both key and value are required.');
+        await secretManager.validateConfig();
-            program.help();
-        } else {
-            const secretManager = new SecretManager(key, value, config);
 
-            // validate meta db config which is resolved from env variables
+        // validate old secret
-            await secretManager.validateConfig();
+        const { sourcesToUpdate, integrationsToUpdate } = await secretManager.validateAndExtract();
 
-            // validate old secret
-            const { sourcesToUpdate, integrationsToUpdate } = await secretManager.validateAndExtract();
 
+        // update sources and integrations
+        await secretManager.updateSecret(sourcesToUpdate, integrationsToUpdate);
 
-            // update sources and integrations
+      }
-            await secretManager.updateSecret(sourcesToUpdate, integrationsToUpdate);
+    } catch (e) {
+      if (e instanceof NcError) {
+        // print error message in a better way
+        NcLogger.error(e.message);
 
-        }
+        process.exit(1);
-    });
+      }
+      console.error(e);
+    }
+  });
 
 
 
@@ -41,3 +60,8 @@ program
 program.exitOverride();
 
 program.parse(process.argv);
+
+
+
+
+

packages/nc-secret-cli/src/nc-config/constants.ts

@@ -1,86 +0,0 @@
-export const driverClientMapping = {
-  mysql: 'mysql2',
-  mariadb: 'mysql2',
-  postgres: 'pg',
-  postgresql: 'pg',
-  sqlite: 'sqlite3',
-  mssql: 'mssql',
-};
-
-export const defaultClientPortMapping = {
-  mysql: 3306,
-  mysql2: 3306,
-  postgres: 5432,
-  pg: 5432,
-  mssql: 1433,
-};
-
-export const defaultConnectionConfig: any = {
-  // https://github.com/knex/knex/issues/97
-  // timezone: process.env.NC_TIMEZONE || 'UTC',
-  dateStrings: true,
-};
-
-// default knex options
-export const defaultConnectionOptions = {
-  pool: {
-    min: 0,
-    max: 10,
-  },
-};
-
-export const avoidSSL = [
-  'localhost',
-  '127.0.0.1',
-  'host.docker.internal',
-  '172.17.0.1',
-];
-
-export const knownQueryParams = [
-  {
-    parameter: 'database',
-    aliases: ['d', 'db'],
-  },
-  {
-    parameter: 'password',
-    aliases: ['p'],
-  },
-  {
-    parameter: 'user',
-    aliases: ['u'],
-  },
-  {
-    parameter: 'title',
-    aliases: ['t'],
-  },
-  {
-    parameter: 'keyFilePath',
-    aliases: [],
-  },
-  {
-    parameter: 'certFilePath',
-    aliases: [],
-  },
-  {
-    parameter: 'caFilePath',
-    aliases: [],
-  },
-  {
-    parameter: 'ssl',
-    aliases: [],
-  },
-  {
-    parameter: 'options',
-    aliases: ['opt', 'opts'],
-  },
-];
-
-export enum DriverClient {
-  MYSQL = 'mysql2',
-  MYSQL_LEGACY = 'mysql',
-  MSSQL = 'mssql',
-  PG = 'pg',
-  SQLITE = 'sqlite3',
-  SNOWFLAKE = 'snowflake',
-  DATABRICKS = 'databricks',
-}

packages/nc-secret-cli/src/nc-config/helpers.ts

@@ -1,326 +0,0 @@
-import fs from 'fs';
-import { URL } from 'url';
-import { promisify } from 'util';
-import parseDbUrl from 'parse-database-url';
-import {
-  avoidSSL,
-  defaultClientPortMapping,
-  defaultConnectionConfig,
-  defaultConnectionOptions,
-  driverClientMapping,
-  knownQueryParams,
-} from './constants';
-import { DriverClient } from './interfaces';
-import type { Connection, DbConfig } from './interfaces';
-
-export async function prepareEnv() {
-  if (process.env.NC_DATABASE_URL_FILE || process.env.DATABASE_URL_FILE) {
-    const database_url = await promisify(fs.readFile)(
-      (process.env.NC_DATABASE_URL_FILE || process.env.DATABASE_URL_FILE) as string,
-      'utf-8',
-    );
-    process.env.NC_DB = jdbcToXcUrl(database_url);
-  } else if (process.env.NC_DATABASE_URL || process.env.DATABASE_URL) {
-    process.env.NC_DB = jdbcToXcUrl(
-      (process.env.NC_DATABASE_URL || process.env.DATABASE_URL) as string,
-    );
-  }
-}
-
-export function getToolDir() {
-  return process.env.NC_TOOL_DIR || process.cwd();
-}
-
-export function jdbcToXcConfig(url: string): DbConfig {
-  // drop the jdbc prefix
-  url.replace(/^jdbc:/, '');
-
-  const config = parseDbUrl(url);
-
-  const parsedConfig: Connection = {};
-
-  for (const [key, value] of Object.entries(config)) {
-    const fnd = knownQueryParams.find(
-      (param) => param.parameter === key || param.aliases.includes(key),
-    );
-    if (fnd) {
-      parsedConfig[fnd.parameter] = value;
-    } else {
-      parsedConfig[key] = value;
-    }
-  }
-
-  if (!parsedConfig?.port) {
-    parsedConfig.port =
-      defaultClientPortMapping[
-        driverClientMapping[parsedConfig.driver as DriverClient] || parsedConfig.driver
-      ];
-  }
-
-  const { driver, ...connectionConfig } = parsedConfig;
-
-  const client = driverClientMapping[driver as DriverClient] || driver;
-
-  if (
-    client === 'pg' &&
-    !connectionConfig?.ssl &&
-    !avoidSSL.includes(connectionConfig.host as string)
-  ) {
-    connectionConfig.ssl = true;
-  }
-
-  return {
-    client: client,
-    connection: {
-      ...connectionConfig,
-    },
-  } as DbConfig;
-}
-
-export function jdbcToXcUrl(url: string): string {
-  // drop the jdbc prefix
-  url.replace(/^jdbc:/, '');
-
-  const config = parseDbUrl(url);
-
-  const parsedConfig: Connection = {};
-
-  for (const [key, value] of Object.entries(config)) {
-    const fnd = knownQueryParams.find(
-      (param) => param.parameter === key || param.aliases.includes(key),
-    );
-    if (fnd) {
-      parsedConfig[fnd.parameter] = value;
-    } else {
-      parsedConfig[key] = value;
-    }
-  }
-
-  if (!parsedConfig?.port) {
-    parsedConfig.port =
-      defaultClientPortMapping[
-        driverClientMapping[parsedConfig.driver as DriverClient] || parsedConfig.driver
-      ];
-  }
-
-  const { driver, host, port, database, user, password, ...extra } =
-    parsedConfig;
-
-  const extraParams: string[] = [];
-
-  for (const [key, value] of Object.entries(extra)) {
-    extraParams.push(`${key}=${encodeURIComponent(String(value))}`);
-  }
-
-  const res = `${driverClientMapping[driver as DriverClient] || driver}://${host}${
-    port ? `:${port}` : ''
-  }?${user ? `u=${encodeURIComponent(user)}&` : ''}${
-    password ? `p=${encodeURIComponent(password)}&` : ''
-  }${database ? `d=${encodeURIComponent(database)}&` : ''}${extraParams.join(
-    '&',
-  )}`;
-
-  return res;
-}
-
-export function xcUrlToDbConfig(
-  urlString: string,
-  key = '',
-  type?: string,
-): DbConfig {
-  const url = new URL(urlString);
-
-  let dbConfig: DbConfig;
-
-  if (url.protocol.startsWith('sqlite3')) {
-    dbConfig = {
-      client: 'sqlite3',
-      connection: {
-        client: 'sqlite3',
-        connection: {
-          filename:
-            url.searchParams.get('d') || url.searchParams.get('database'),
-        },
-        database: url.searchParams.get('d') || url.searchParams.get('database'),
-      },
-    } as any;
-  } else {
-    const parsedQuery = {};
-    for (const [key, value] of url.searchParams.entries()) {
-      const fnd = knownQueryParams.find(
-        (param) => param.parameter === key || param.aliases.includes(key),
-      );
-      if (fnd) {
-        parsedQuery[fnd.parameter] = value;
-      } else {
-        parsedQuery[key] = value;
-      }
-    }
-
-    dbConfig = {
-      client: url.protocol.replace(':', '') as DriverClient,
-      connection: {
-        ...parsedQuery,
-        host: url.hostname,
-        port: +url.port,
-      },
-      acquireConnectionTimeout: 600000,
-    };
-
-    if (process.env.NODE_TLS_REJECT_UNAUTHORIZED) {
-      dbConfig.connection.ssl = true;
-    }
-
-    if (
-      url.searchParams.get('keyFilePath') &&
-      url.searchParams.get('certFilePath') &&
-      url.searchParams.get('caFilePath')
-    ) {
-      dbConfig.connection.ssl = {
-        keyFilePath: url.searchParams.get('keyFilePath') as string,
-        certFilePath: url.searchParams.get('certFilePath') as string,
-        caFilePath: url.searchParams.get('caFilePath') as string,
-      };
-    }
-  }
-
-  /* TODO check if this is needed
-    if (config && !config.title) {
-      config.title =
-        url.searchParams.get('t') ||
-        url.searchParams.get('title') ||
-        this.generateRandomTitle();
-    }
-  */
-
-  Object.assign(dbConfig, {
-    meta: {
-      tn: 'nc_evolutions',
-      allSchemas:
-        !!url.searchParams.get('allSchemas') ||
-        !(url.searchParams.get('d') || url.searchParams.get('database')),
-      api: {
-        prefix: url.searchParams.get('apiPrefix') || '',
-        swagger: true,
-        type:
-          type ||
-          ((url.searchParams.get('api') || url.searchParams.get('a')) as any) ||
-          'rest',
-      },
-      dbAlias: url.searchParams.get('dbAlias') || `db${key}`,
-      metaTables: 'db',
-      migrations: {
-        disabled: false,
-        name: 'nc_evolutions',
-      },
-    },
-  });
-
-  return dbConfig;
-}
-
-export async function metaUrlToDbConfig(urlString): Promise<DbConfig> {
-  const url = new URL(urlString);
-
-  let dbConfig: DbConfig;
-
-  if (url.protocol.startsWith('sqlite3')) {
-    const db = url.searchParams.get('d') || url.searchParams.get('database');
-    dbConfig = {
-      client: DriverClient.SQLITE,
-      connection: {
-        filename: db as string,
-      },
-      ...(db === ':memory:'
-        ? {
-            pool: {
-              min: 1,
-              max: 1,
-              // disposeTimeout: 360000*1000,
-              idleTimeoutMillis: 360000 * 1000,
-            },
-          }
-        : {}),
-    };
-  } else {
-    const parsedQuery = {};
-    for (const [key, value] of url.searchParams.entries()) {
-      const fnd = knownQueryParams.find(
-        (param) => param.parameter === key || param.aliases.includes(key),
-      );
-      if (fnd) {
-        parsedQuery[fnd.parameter] = value;
-      } else {
-        parsedQuery[key] = value;
-      }
-    }
-
-    dbConfig = {
-      client: url.protocol.replace(':', '') as DriverClient,
-      connection: {
-        ...defaultConnectionConfig,
-        ...parsedQuery,
-        host: url.hostname,
-        port: +url.port,
-      },
-      acquireConnectionTimeout: 600000,
-      ...defaultConnectionOptions,
-      ...(url.searchParams.has('search_path')
-        ? {
-            searchPath: url.searchParams.get('search_path')?.split(','),
-          }
-        : {}),
-    };
-
-    if (process.env.NODE_TLS_REJECT_UNAUTHORIZED) {
-      dbConfig.connection.ssl = true;
-    }
-  }
-
-  url.searchParams.forEach((_value, key) => {
-    let value: any = _value;
-    if (value === 'true') {
-      value = true;
-    } else if (value === 'false') {
-      value = false;
-    } else if (/^\d+$/.test(value)) {
-      value = +value;
-    }
-    // todo: implement config read from JSON file or JSON env val read
-    if (
-      !['password', 'p', 'database', 'd', 'user', 'u', 'search_path'].includes(
-        key,
-      )
-    ) {
-      key.split('.').reduce((obj, k, i, arr) => {
-        return (obj[k] = i === arr.length - 1 ? value : obj[k] || {});
-      }, dbConfig);
-    }
-  });
-
-  if (
-    dbConfig?.connection?.ssl &&
-    typeof dbConfig?.connection?.ssl === 'object'
-  ) {
-    if (dbConfig.connection.ssl.caFilePath && !dbConfig.connection.ssl.ca) {
-      dbConfig.connection.ssl.ca = (
-        await promisify(fs.readFile)(dbConfig.connection.ssl.caFilePath)
-      ).toString();
-      delete dbConfig.connection.ssl.caFilePath;
-    }
-    if (dbConfig.connection.ssl.keyFilePath && !dbConfig.connection.ssl.key) {
-      dbConfig.connection.ssl.key = (
-        await promisify(fs.readFile)(dbConfig.connection.ssl.keyFilePath)
-      ).toString();
-      delete dbConfig.connection.ssl.keyFilePath;
-    }
-    if (dbConfig.connection.ssl.certFilePath && !dbConfig.connection.ssl.cert) {
-      dbConfig.connection.ssl.cert = (
-        await promisify(fs.readFile)(dbConfig.connection.ssl.certFilePath)
-      ).toString();
-      delete dbConfig.connection.ssl.certFilePath;
-    }
-  }
-
-  return dbConfig;
-}

packages/nc-secret-cli/src/nc-config/index.ts

@@ -1,4 +0,0 @@
-export * from './helpers';
-export * from './interfaces';
-export * from './constants';
-export * from './NcConfig';

packages/nc-secret-cli/src/nc-config/interfaces.ts

@@ -1,39 +0,0 @@
-import { DriverClient } from './constants';
-
-interface Connection {
-  driver?: DriverClient;
-  host?: string;
-  port?: number;
-  database?: string;
-  user?: string;
-  password?: string;
-  ssl?:
-    | boolean
-    | {
-        ca?: string;
-        cert?: string;
-        key?: string;
-        caFilePath?: string;
-        certFilePath?: string;
-        keyFilePath?: string;
-      };
-  filename?: string;
-}
-
-interface DbConfig {
-  client: DriverClient;
-  connection: Connection;
-  acquireConnectionTimeout?: number;
-  useNullAsDefault?: boolean;
-  pool?: {
-    min?: number;
-    max?: number;
-    idleTimeoutMillis?: number;
-  };
-  migrations?: {
-    directory?: string;
-    tableName?: string;
-  };
-}
-
-export { DriverClient, Connection, DbConfig };

packages/nc-secret-cli/tsconfig.json

@@ -9,6 +9,8 @@
       "esModuleInterop": true,
       "moduleResolution": "node",
       "skipLibCheck": true,
-      "noImplicitAny": false
+      "noImplicitAny": false,
+      "allowJs": true,
+      "experimentalDecorators": true
     }
-  }
+}

packages/nc-secret-cli/webpack.config.js

@@ -0,0 +1,46 @@
+const nodeExternals = require('webpack-node-externals');
+const TerserPlugin = require('terser-webpack-plugin');
+const webpack = require('webpack');
+const path = require('path');
+module.exports = {
+  entry: './src/index.ts',
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        exclude: /node_modules/,
+        use: {
+          loader: 'ts-loader',
+          options: {
+            transpileOnly: true
+          }
+        },
+      },
+    ],
+  },
+
+  optimization: {
+    minimize: true, //Update this to true or false
+    minimizer: [new TerserPlugin()],
+    nodeEnv: false
+  },
+  externals: [nodeExternals()],
+  resolve: {
+    extensions: ['.tsx', '.ts', '.js', '.json'],
+  },
+  output: {
+    filename: 'cli.js',
+    path: path.resolve(__dirname, 'dist'),
+    library: 'libs',
+    libraryTarget: 'umd',
+    globalObject: "typeof self !== 'undefined' ? self : this",
+  },
+  // node: {
+  //   fs: 'empty'
+  // },
+  plugins: [
+    new webpack.BannerPlugin({banner: "#! /usr/bin/env node", raw: true}),
+  ],
+
+  target: 'node',
+};

packages/nocodb/src/cli.ts

@@ -0,0 +1,5 @@
+export { SqlClientFactory } from '~/db/sql-client/lib/SqlClientFactory';
+export { MetaTable } from '~/utils/globals';
+export * from '~/utils/encryptDecrypt';
+export { getToolDir, metaUrlToDbConfig } from '~/utils/nc-config/helpers';
+export { DriverClient } from '~/utils/nc-config/constants';

packages/nocodb/src/index.ts

@@ -3,6 +3,3 @@ import Noco from './Noco';
 export default Noco;
 
 export { Noco };
-export { SqlClientFactory } from './db/sql-client/lib/SqlClientFactory';
-export { MetaTable } from '~/utils/globals'
-export * from '~/utils/encryptDecrypt'

packages/nocodb/src/utils/encryptDecrypt.ts

@@ -1,10 +1,12 @@
 import CryptoJS from 'crypto-js';
-import Noco from '~/Noco';
+
+
+export const credentialEncyptSecret = process.env.NC_KEY_CREDENTIAL_ENCRYPT;
 
 export const encryptPropIfRequired = ({
   data,
   prop = 'config',
-  secret = Noco.getConfig()?.credentialSecret,
+  secret = credentialEncyptSecret,
 }: {
   data: Record<string, any>;
   prop?: string;
@@ -20,14 +22,14 @@ export const encryptPropIfRequired = ({
 
   return CryptoJS.AES.encrypt(
     JSON.stringify(data[prop]),
-    Noco.getConfig()?.credentialSecret,
+    secret,
   ).toString();
 };
 
 export const decryptPropIfRequired = ({
   data,
   prop = 'config',
-  secret = Noco.getConfig()?.credentialSecret,
+  secret = credentialEncyptSecret,
 }: {
   data: Record<string, any>;
   prop?: string;

packages/nocodb/src/utils/globals.ts

@@ -1,6 +1,6 @@
 export enum MetaTable {
   PROJECT = 'nc_bases_v2',
-  SOURCES = 'nc_sources_v2',
+  SOURCES = 'nc_source_v2',
   MODELS = 'nc_models_v2',
   COLUMNS = 'nc_columns_v2',
   COLUMN_VALIDATIONS = 'nc_columns_validations_v2',

packages/nocodb/webpack.cli.config.js

@@ -0,0 +1,61 @@
+const path = require('path');
+const nodeExternals = require('webpack-node-externals');
+const webpack = require('webpack');
+const TerserPlugin = require('terser-webpack-plugin');
+const { resolveTsAliases } = require('./build-utils/resolveTsAliases');
+
+module.exports = {
+  entry: './src/cli.ts',
+  module: {
+    rules: [
+      {
+        test: /\.tsx?$/,
+        exclude: /node_modules/,
+        use: {
+          loader: 'ts-loader',
+          options: {
+            transpileOnly: true,
+          },
+        },
+      },
+    ],
+  },
+
+  optimization: {
+    minimize: true, //Update this to true or false
+    minimizer: [
+      new TerserPlugin({
+        extractComments: false,
+      }),
+    ],
+    nodeEnv: false,
+  },
+  externals: [
+    nodeExternals({
+      allowlist: ['nocodb-sdk'],
+    }),
+  ],
+  resolve: {
+    extensions: ['.tsx', '.ts', '.js', '.json'],
+    alias: resolveTsAliases(path.resolve('tsconfig.json')),
+  },
+  mode: 'production',
+  output: {
+    filename: 'cli.js',
+    path: path.resolve(__dirname, '..', 'nc-secret-cli', 'src/nocodb'),
+    library: 'libs',
+    libraryTarget: 'umd',
+    globalObject: "typeof self !== 'undefined' ? self : this",
+  },
+  node: {
+    __dirname: false,
+  },
+  plugins: [
+    new webpack.EnvironmentPlugin(['EE']),
+    new webpack.BannerPlugin({
+      banner: 'This is a generated file. Do not edit',
+      entryOnly:true
+    }),
+  ],
+  target: 'node',
+};

scripts/pkg-secret-cli-executable/index.js

@@ -0,0 +1,13 @@
+process.env.NC_BINARY_BUILD = 'true';
+(async () => {
+  try {
+    const app = require('express')();
+    const {Noco} = require("nocodb");
+    const port = process.env.PORT || 8080;
+    const httpServer = app.listen(port);
+    app.use(await Noco.init({}, httpServer, app));
+    console.log(`Visit : localhost:${port}/dashboard`)
+  } catch(e) {
+    console.log(e)
+  }
+})()