@sava-info-systems/api-maker-with-extensions 1.17.2 → 1.18.0

package/src/tools/local-client.js

@@ -0,0 +1,1215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EGitSyncType = exports.EAMModelNames = exports.EMongooseHookMethods = exports.EAPICategory = void 0;
+const fs = require("fs");
+const path = require("path");
+const child_process_1 = require("child_process");
+const https = require("node:https");
+const http = require("node:http");
+// $$$$_change
+class LocalClient {
+    constructor() {
+        this.EL = false; // enable logs // $$$$_change
+        this.projectDirectory = '';
+        this.C = {
+            localClientPath: './local-client.config',
+            src: 'src',
+            repo: 'repo',
+            types: 'types',
+            amTypes: 'am-types',
+            versions: 'versions',
+            apis: 'apis',
+            listeners: 'listeners',
+            postHooks: 'post-hooks',
+            preHooks: 'pre-hooks',
+            dbInterfacesFile: 'db-interfaces.d.ts',
+            // Read
+            UtilityClassesReadF: 'Utility classes',
+            CustomApiReadF: 'Custom APIs',
+            SchedulersReadF: 'Schedulers',
+            WebSocketEventsReadF: 'WebSocket events',
+            SchemaReadF: 'Schemas',
+            DBMigrationsReadF: 'Database migrations',
+            ProcessInitializersReadF: 'Process initializers',
+            ProcessI18NReadF: 'i18ns',
+            DBMastersReadF: 'DB masters',
+            DBMasterStylesReadF: 'UI maker styles',
+            DBMasterUtilsReadF: 'DB master utils',
+            TestCasesReadF: 'Test cases',
+            ThirdPartyApiReadF: 'Third party APIs',
+            EventsReadF: 'Events',
+            InstanceApiHooksReadF: 'Instance API hooks',
+            SystemApiHooksReadF: 'System API hooks',
+            CollectionHooksReadF: 'Collection hooks',
+            DatabaseHooksReadF: 'Database hooks',
+            InstanceHooksReadF: 'Instance hooks',
+            // Write
+            CustomApisWriteF: 'custom-apis',
+            SchedulersWriteF: 'schedulers',
+            WebSocketEventsWriteF: 'web-socket-events',
+            SchemaWriteF: 'schemas',
+            DBMigrationsWriteF: 'db-migrations',
+            ProcessInitializersWriteF: 'process-initializers',
+            ProcessI18NWriteF: 'i18ns',
+            DBMastersWriteF: 'ui-maker-pages',
+            DBMasterStylesWriteF: 'ui-maker-styles',
+            DBMasterUtilsWriteF: 'ui-maker-utils',
+            TestCasesWriteF: 'tests',
+            ThirdPartyApiWriteF: 'third-party-apis',
+            EventsWriteF: 'events',
+            InstanceApiHooksWriteF: 'instance-api-hooks',
+            SystemApiHooksWriteF: 'system-api-hooks',
+            CollectionHooksWriteF: 'collection-hooks',
+            DatabaseHooksWriteF: 'database-hooks',
+            InstanceHooksWriteF: 'instance-hooks',
+        };
+        this.globalObj = {};
+        this.skipWatchInputs = false;
+        this.skipFileWritingForLocal = {};
+        this.nodeModulesCopied = false;
+        this.spinner = null;
+        this.sendDeletedEventToServerDebounce = this.debounce(this.sendDeletedEventToServerInternal, 500);
+    }
+    async start() {
+        if (!fs.existsSync(this.C.localClientPath + '.js')) {
+            this.printNotesToProvideLocalClient();
+            process.exit(1);
+        }
+        this.spinner = this.createSpinner();
+        this.config = require(this.C.localClientPath)();
+        await this.printNotes();
+        this.removeEmptyDirsSync(path.join(__dirname, this.C.src));
+        await this.createLCProjectDirectory();
+        setTimeout(this.startWatch.bind(this), 100);
+        await this.connectToServerViaWS();
+        console.log(`Open in IDE : ${this.projectDirectory}`);
+    }
+    async printNotes() {
+        console.log('\x1b[38;2;255;165;0m');
+        console.log('—————————————————————————————— Note ——————————————————————————————');
+        console.log(' Local client will push your local changes to API Maker server.');
+        console.log(' If you have any changes on server, they will be overridden.');
+        console.log('——————————————————————————————————————————————————————————————————');
+        console.log('\x1b[0m');
+        console.log('');
+    }
+    printNotesToProvideLocalClient() {
+        console.log('\x1b[38;2;255;165;0m');
+        console.log(` Please provide settings in : ${this.C.localClientPath}.js`);
+        console.log('\x1b[0m');
+        console.log('');
+    }
+    createSpinner() {
+        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        let i = 0;
+        let timer = null;
+        const classThis = this;
+        return {
+            start(label = 'Syncing..') {
+                if (timer)
+                    return;
+                timer = setInterval(() => {
+                    process.stdout.write(`\r${frames[i++ % frames.length]} ${label}`);
+                }, 100);
+            },
+            stop(finalMessage = 'Sync') {
+                if (timer) {
+                    clearInterval(timer);
+                    timer = null;
+                    if (finalMessage)
+                        process.stdout.write(`\r[${classThis.getCurrentTime()}] : ${finalMessage}\n`);
+                }
+            },
+        };
+    }
+    async createLCProjectDirectory() {
+        const mainFolder = path.basename(__dirname);
+        const createFolder = path.join(__dirname, '..', `${mainFolder}-lc`);
+        this.projectDirectory = createFolder;
+        fs.rmSync(createFolder, {
+            recursive: true,
+            force: true,
+        });
+        await fs.promises.mkdir(createFolder, { recursive: true });
+    }
+    async copyFilesToProjectDir(performNpmInstall) {
+        await this.createLCProjectDirectory();
+        // Create src folder
+        fs.mkdirSync(path.join(this.projectDirectory, this.C.src), { recursive: true });
+        // Copy package.json file
+        fs.cpSync(path.join(__dirname, 'package.json'), path.join(this.projectDirectory, 'package.json'));
+        // Copy .gitignore file
+        fs.cpSync(path.join(__dirname, '.gitignore'), path.join(this.projectDirectory, '.gitignore'));
+        // Copy tsconfig.json file
+        const tsConfigReadPath = path.join(__dirname, 'tsconfig.json');
+        const tsConfigObj = JSON.parse(await fs.promises.readFile(tsConfigReadPath, { encoding: 'utf8' }));
+        tsConfigObj.compilerOptions.baseUrl = './src';
+        tsConfigObj.compilerOptions.paths['*'].push('*');
+        await fs.promises.writeFile(path.join(this.projectDirectory, 'tsconfig.json'), JSON.stringify(tsConfigObj, null, 4), { encoding: 'utf8' });
+        // Copy am-types
+        await fs.promises.cp(path.join(__dirname, this.C.amTypes), path.join(this.projectDirectory, this.C.src, this.C.amTypes), { recursive: true });
+        // Copy db-interfaces
+        await fs.promises.cp(path.join(__dirname, this.C.src, this.config.adminUserPath, this.C.types, this.C.dbInterfacesFile), path.join(this.projectDirectory, this.C.src, this.C.amTypes, this.C.dbInterfacesFile), { recursive: true });
+        await this.copyUtilityClassesToAnotherDir();
+        await this.copyCustomApisToAnotherDir();
+        await this.copySchedulersToAnotherDir();
+        await this.copySchemasToAnotherDir();
+        await this.copyDBMigrationsToAnotherDir();
+        await this.copyProcessInitializersToAnotherDir();
+        await this.copyI18NToAnotherDir();
+        await this.copyTestCasesToAnotherDir();
+        await this.copyThirdPartyApisToAnotherDir();
+        await this.copyEventsToAnotherDir();
+        await this.copyInstanceApiHooksToAnotherDir();
+        await this.copySystemApiHooksToAnotherDir();
+        await this.copyWebSocketEventsToAnotherDir();
+        await this.copyCollectionHooksToAnotherDir();
+        await this.copyDatabaseHooksToAnotherDir();
+        await this.copyInstanceHooksToAnotherDir();
+        await this.copyDBMastersToAnotherDir();
+        await this.copyDBMasterStylesToAnotherDir();
+        await this.copyDBMasterUtilsToAnotherDir();
+        if (performNpmInstall)
+            await this.executeNpmRun('npm', ['install', '--force']);
+        fs.symlinkSync(path.join(__dirname, 'node_modules'), path.join(this.projectDirectory, 'node_modules'), 'dir'); // link "node_modules" directory
+    }
+    /**
+     * src/admin/Utility classes/utils - aws-s3-bucket - 1.0.0 -  -- S3BucketUtility/utils - aws-s3-bucket - 1.0.0 -  -- S3BucketUtility.yaml
+     * src/admin/Utility classes/utils -  -- GeneralUtils/utils -  -- GeneralUtils.yaml
+     * src/admin/Utility classes/utils -  -- GeneralUtils/versions/-1/Original.ts
+     * src/admin/Utility classes/utils -  -- GeneralUtils/versions/1.0.0/Second Utils.ts
+     */
+    async copyUtilityClassesToAnotherDir() {
+        const readFolderName = this.C.UtilityClassesReadF;
+        const utilsBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const utils = await this.readDirCustom(utilsBasePath, null);
+        for (const utilName of utils) {
+            const utilConfigPath = path.join(utilsBasePath, utilName, `${utilName}.yaml`);
+            if (!fs.existsSync(utilConfigPath))
+                continue;
+            const utilConfigContent = await fs.promises.readFile(utilConfigPath, { encoding: 'utf8' });
+            const utilsConfig = await this.parseYaml(utilConfigContent);
+            for (const version of utilsConfig.versions || []) {
+                if (version.isActive === true) {
+                    const codeFilePath = path.join(utilsBasePath, utilName, this.C.versions, version.version, `${version.name}.ts`);
+                    const targetFilePath = path.join(this.projectDirectory, this.C.src, utilsConfig.folderPath, `${utilsConfig.name}.ts`);
+                    await fs.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                    await fs.promises.link(codeFilePath, targetFilePath);
+                }
+            }
+        }
+    }
+    /**
+     * src/admin/Custom APIs/Hello World/Hello World.yaml
+     * src/admin/Custom APIs/Hello World/Hello World.config.ts
+     * src/admin/Custom APIs/Hello World/versions/-1/Original.ts
+     * src/admin/Custom APIs/Hello World/versions/1.0.0/Second Version.ts
+     * src/admin/Custom APIs/Hello World/versions/1.0.0/pre-hooks/Hello world pre hook 1.ts
+     * src/admin/Custom APIs/Hello World/versions/1.0.0/post-hooks/Hello world post hook 1.ts
+     */
+    async copyCustomApisToAnotherDir() {
+        const readFolderName = this.C.CustomApiReadF;
+        const writeFolderName = this.C.CustomApisWriteF;
+        const itemBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const itemFolderNames = await this.readDirCustom(itemBasePath, null);
+        for (const itemFolderName of itemFolderNames) {
+            const itemConfigPath = path.join(itemBasePath, itemFolderName, `${itemFolderName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            for (const version of itemConfig.versions || []) {
+                if (version.isActive === true) {
+                    // Write code file
+                    const versionBasePath = path.join(itemBasePath, itemFolderName, this.C.versions, version.version);
+                    const codeFilePath = path.join(versionBasePath, `${version.name}.ts`);
+                    const targetFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, itemConfig.path, `${itemConfig.name}.ts`);
+                    await fs.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                    await fs.promises.link(codeFilePath, targetFilePath);
+                    // Write config file
+                    const configFilePath = path.join(itemBasePath, itemFolderName, `${itemFolderName}.config.ts`);
+                    const targetConfigFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, itemConfig.path, `${itemConfig.name}.config.ts`);
+                    await fs.promises.link(configFilePath, targetConfigFilePath);
+                    // Write pre hooks
+                    for (const hookObj of version.preHooks) {
+                        // Write code file
+                        const codeFilePathHook = path.join(versionBasePath, this.C.preHooks, `${hookObj.name}.ts`);
+                        const targetFilePathHook = path.join(this.projectDirectory, this.C.src, writeFolderName, itemConfig.path, this.C.preHooks, `${hookObj.name}.ts`);
+                        await fs.promises.mkdir(path.dirname(targetFilePathHook), { recursive: true });
+                        await fs.promises.link(codeFilePathHook, targetFilePathHook);
+                    }
+                    // Write post hooks
+                    for (const hookObj of version.postHooks) {
+                        // Write code file
+                        const codeFilePathHook = path.join(versionBasePath, this.C.postHooks, `${hookObj.name}.ts`);
+                        const targetFilePathHook = path.join(this.projectDirectory, this.C.src, writeFolderName, itemConfig.path, this.C.postHooks, `${hookObj.name}.ts`);
+                        await fs.promises.mkdir(path.dirname(targetFilePathHook), { recursive: true });
+                        await fs.promises.link(codeFilePathHook, targetFilePathHook);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * src/admin/Schedulers/Scheduler 1/Scheduler 1.yaml
+     * src/admin/Schedulers/Scheduler 1/versions/-1/Original.ts
+     */
+    async copySchedulersToAnotherDir() {
+        const readFolderName = this.C.SchedulersReadF;
+        const writeFolderName = this.C.SchedulersWriteF;
+        const itemBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const itemFolderNames = await this.readDirCustom(itemBasePath, null);
+        for (const itemFolderName of itemFolderNames) {
+            const itemConfigPath = path.join(itemBasePath, itemFolderName, `${itemFolderName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            for (const version of itemConfig.versions || []) {
+                if (version.isActive === true) {
+                    // Write code file
+                    const codeFilePath = path.join(itemBasePath, itemFolderName, this.C.versions, version.version, `${version.name}.ts`);
+                    const targetFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, `${itemConfig.name}.ts`);
+                    await fs.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                    await fs.promises.link(codeFilePath, targetFilePath);
+                }
+            }
+        }
+    }
+    /**
+     * src/admin/Schemas/mongodb -- test -- default/default.config.ts
+     * src/admin/Schemas/mongodb -- test -- default/mongodb -- test -- default.yaml
+     */
+    async copySchemasToAnotherDir() {
+        const readFolderName = this.C.SchemaReadF;
+        const writeFolderName = this.C.SchemaWriteF;
+        const schemaBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const itemFolderNames = await this.readDirCustom(schemaBasePath, null);
+        for (const itemFolderName of itemFolderNames) {
+            const itemConfigPath = path.join(schemaBasePath, itemFolderName, `${itemFolderName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            const insAndDBFolderPath = path.join(this.projectDirectory, this.C.src, writeFolderName, itemConfig.instanceName, itemConfig.databaseName);
+            await fs.promises.mkdir(insAndDBFolderPath, { recursive: true });
+            const collectionReadPath = path.join(schemaBasePath, itemFolderName, `${itemConfig.collectionName}.config.ts`);
+            const collectionWritePath = path.join(insAndDBFolderPath, `${itemConfig.collectionName}.config.ts`);
+            await fs.promises.link(collectionReadPath, collectionWritePath);
+        }
+    }
+    /**
+     * src/admin/Database migrations/Migration 1/Migration 1.ts
+     * src/admin/Database migrations/Migration 1/Migration 1.yaml
+     */
+    async copyDBMigrationsToAnotherDir() {
+        const readFolderName = this.C.DBMigrationsReadF;
+        const writeFolderName = this.C.DBMigrationsWriteF;
+        const schemaBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const itemFolderNames = await this.readDirCustom(schemaBasePath, null);
+        for (const itemFolderName of itemFolderNames) {
+            const itemConfigPath = path.join(schemaBasePath, itemFolderName, `${itemFolderName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            const migrationFolderPath = path.join(this.projectDirectory, this.C.src, writeFolderName);
+            await fs.promises.mkdir(migrationFolderPath, { recursive: true });
+            const migrationReadPath = path.join(schemaBasePath, itemFolderName, `${itemConfig.name}.ts`);
+            const migrationWritePath = path.join(migrationFolderPath, `${itemConfig.name}.ts`);
+            await fs.promises.link(migrationReadPath, migrationWritePath);
+        }
+    }
+    /**
+     * src/admin/Database migrations/Migration 1/Migration 1.ts
+     * src/admin/Database migrations/Migration 1/Migration 1.yaml
+     */
+    async copyProcessInitializersToAnotherDir() {
+        const readFolderName = this.C.ProcessInitializersReadF;
+        const writeFolderName = this.C.ProcessInitializersWriteF;
+        const schemaBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const itemFolderNames = await this.readDirCustom(schemaBasePath, null);
+        for (const itemFolderName of itemFolderNames) {
+            const itemConfigPath = path.join(schemaBasePath, itemFolderName, `${itemFolderName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            const piFolderPath = path.join(this.projectDirectory, this.C.src, writeFolderName);
+            await fs.promises.mkdir(piFolderPath, { recursive: true });
+            const piReadPath = path.join(schemaBasePath, itemFolderName, `${itemConfig.name}.ts`);
+            const piWritePath = path.join(piFolderPath, `${itemConfig.name}.ts`);
+            await fs.promises.link(piReadPath, piWritePath);
+        }
+    }
+    /**
+     * src/admin/Database migrations/Migration 1/Migration 1.ts
+     * src/admin/Database migrations/Migration 1/Migration 1.yaml
+     */
+    async copyI18NToAnotherDir() {
+        const readFolderName = this.C.ProcessI18NReadF;
+        const writeFolderName = this.C.ProcessI18NWriteF;
+        const schemaBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const itemFolderNames = await this.readDirCustom(schemaBasePath, null);
+        for (const itemFolderName of itemFolderNames) {
+            const itemConfigPath = path.join(schemaBasePath, itemFolderName, `${itemFolderName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            const piFolderPath = path.join(this.projectDirectory, this.C.src, writeFolderName);
+            await fs.promises.mkdir(piFolderPath, { recursive: true });
+            const piReadPath = path.join(schemaBasePath, itemFolderName, `${itemConfig.name}.ts`);
+            const piWritePath = path.join(piFolderPath, `${itemConfig.name}.ts`);
+            await fs.promises.link(piReadPath, piWritePath);
+        }
+    }
+    /**
+     * src/admin/DB masters/ui_page_1/ui_page_1.config.ts
+     * src/admin/DB masters/ui_page_1/ui_page_1.yaml
+     * src/admin/DB masters/ui_page_1/ui_page_1.ts
+     */
+    async copyDBMastersToAnotherDir() {
+        const readFolderName = this.C.DBMastersReadF;
+        const writeFolderName = this.C.DBMastersWriteF;
+        const schemaBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const itemFolderNames = await this.readDirCustom(schemaBasePath, null);
+        for (const itemFolderName of itemFolderNames) {
+            const itemConfigPath = path.join(schemaBasePath, itemFolderName, `${itemFolderName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            const dbMasterFolderPath = path.join(this.projectDirectory, this.C.src, writeFolderName, itemConfig.name);
+            await fs.promises.mkdir(dbMasterFolderPath, { recursive: true });
+            // Write code file
+            const dbMasterReadPath = path.join(schemaBasePath, itemFolderName, `${itemConfig.name}.ts`);
+            const dbMasterWritePath = path.join(dbMasterFolderPath, `${itemConfig.name}.ts`);
+            await fs.promises.link(dbMasterReadPath, dbMasterWritePath);
+            // Write config file
+            const dbMasterConfigReadPath = path.join(schemaBasePath, itemFolderName, `${itemConfig.name}.config.ts`);
+            const dbMasterConfigWritePath = path.join(dbMasterFolderPath, `${itemConfig.name}.config.ts`);
+            await fs.promises.link(dbMasterConfigReadPath, dbMasterConfigWritePath);
+        }
+    }
+    /**
+     * src/admin/UI maker styles/Style 1/Style 1.css
+     * src/admin/UI maker styles/Style 1/Style 1.yaml
+     */
+    async copyDBMasterStylesToAnotherDir() {
+        const readFolderName = this.C.DBMasterStylesReadF;
+        const writeFolderName = this.C.DBMasterStylesWriteF;
+        const schemaBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const itemFolderNames = await this.readDirCustom(schemaBasePath, null);
+        for (const itemFolderName of itemFolderNames) {
+            const itemConfigPath = path.join(schemaBasePath, itemFolderName, `${itemFolderName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            const dbMasterFolderPath = path.join(this.projectDirectory, this.C.src, writeFolderName);
+            await fs.promises.mkdir(dbMasterFolderPath, { recursive: true });
+            // Write code file
+            const dbMasterReadPath = path.join(schemaBasePath, itemFolderName, `${itemConfig.name}.css`);
+            const dbMasterWritePath = path.join(dbMasterFolderPath, `${itemConfig.name}.css`);
+            await fs.promises.link(dbMasterReadPath, dbMasterWritePath);
+        }
+    }
+    /**
+     * src/admin/DB master utils/Utility 1/Utility 1.ts
+     * src/admin/DB master utils/Utility 1/Utility 1.yaml
+     */
+    async copyDBMasterUtilsToAnotherDir() {
+        const readFolderName = this.C.DBMasterUtilsReadF;
+        const writeFolderName = this.C.DBMasterUtilsWriteF;
+        const schemaBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const itemFolderNames = await this.readDirCustom(schemaBasePath, null);
+        for (const itemFolderName of itemFolderNames) {
+            const itemConfigPath = path.join(schemaBasePath, itemFolderName, `${itemFolderName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            const dbMasterFolderPath = path.join(this.projectDirectory, this.C.src, writeFolderName);
+            await fs.promises.mkdir(dbMasterFolderPath, { recursive: true });
+            // Write code file
+            const dbMasterReadPath = path.join(schemaBasePath, itemFolderName, `${itemConfig.name}.ts`);
+            const dbMasterWritePath = path.join(dbMasterFolderPath, `${itemConfig.name}.ts`);
+            await fs.promises.link(dbMasterReadPath, dbMasterWritePath);
+        }
+    }
+    /**
+     * src/admin/Test cases/test1/test1.ts
+     * src/admin/Test cases/test1/test1.yaml
+     */
+    async copyTestCasesToAnotherDir() {
+        const readFolderName = this.C.TestCasesReadF;
+        const writeFolderName = this.C.TestCasesWriteF;
+        const schemaBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const itemFolderNames = await this.readDirCustom(schemaBasePath, null);
+        for (const itemFolderName of itemFolderNames) {
+            const itemConfigPath = path.join(schemaBasePath, itemFolderName, `${itemFolderName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            const piFolderPath = path.join(this.projectDirectory, this.C.src, writeFolderName);
+            await fs.promises.mkdir(piFolderPath, { recursive: true });
+            const piReadPath = path.join(schemaBasePath, itemFolderName, `${itemConfig.name}.ts`);
+            const piWritePath = path.join(piFolderPath, `${itemConfig.name}.ts`);
+            await fs.promises.link(piReadPath, piWritePath);
+        }
+    }
+    /**
+     * src/admin/Third party APIs/ftp-utility -- 1.0.0/apis/Append File/Append File.yaml
+     * src/admin/Third party APIs/ftp-utility -- 1.0.0/apis/Append File/Append File.config.ts
+     * src/admin/Third party APIs/ftp-utility -- 1.0.0/apis/Append File/versions/-1/Original.ts
+     *
+     * src/admin/Third party APIs/aws-s3-bucket -- 1.0.0/apis/Delete File/versions/-1/pre-hooks/delete file pre hook 1.ts
+     * src/admin/Third party APIs/aws-s3-bucket -- 1.0.0/apis/Delete File/versions/-1/post-hooks/delete file post hook 1.ts
+     */
+    async copyThirdPartyApisToAnotherDir() {
+        const readFolderName = this.C.ThirdPartyApiReadF;
+        const writeFolderName = this.C.ThirdPartyApiWriteF;
+        const itemBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        if (!fs.existsSync(itemBasePath))
+            return;
+        const bundleNames = await this.readDirCustom(itemBasePath, null);
+        for (const bundleName of bundleNames) {
+            const itemBasePathApis = path.join(itemBasePath, bundleName, this.C.apis);
+            const apiNames = await this.readDirCustom(itemBasePathApis, null);
+            for (const apiName of apiNames) {
+                const itemConfigPath = path.join(itemBasePathApis, apiName, `${apiName}.yaml`);
+                if (!fs.existsSync(itemConfigPath))
+                    continue;
+                const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+                const itemConfig = await this.parseYaml(itemConfigContent);
+                for (const version of itemConfig.versions || []) {
+                    if (version.isActive === true) {
+                        // Write code file
+                        const versionBasePath = path.join(itemBasePathApis, apiName, this.C.versions, version.version);
+                        const codeFilePath = path.join(versionBasePath, `${version.name}.ts`);
+                        const targetFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, bundleName, itemConfig.path, `${itemConfig.name}.ts`);
+                        await fs.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                        await fs.promises.link(codeFilePath, targetFilePath);
+                        // Write config file
+                        const configFilePath = path.join(itemBasePathApis, apiName, `${apiName}.config.ts`);
+                        const targetConfigFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, bundleName, itemConfig.path, `${itemConfig.name}.config.ts`);
+                        await fs.promises.link(configFilePath, targetConfigFilePath);
+                        // Write pre hooks
+                        for (const hookObj of version.preHooks) {
+                            // Write code file
+                            const codeFilePathHook = path.join(versionBasePath, this.C.preHooks, `${hookObj.name}.ts`);
+                            const targetFilePathHook = path.join(this.projectDirectory, this.C.src, writeFolderName, bundleName, itemConfig.path, this.C.preHooks, `${hookObj.name}.ts`);
+                            await fs.promises.mkdir(path.dirname(targetFilePathHook), { recursive: true });
+                            await fs.promises.link(codeFilePathHook, targetFilePathHook);
+                        }
+                        // Write post hooks
+                        for (const hookObj of version.postHooks) {
+                            // Write code file
+                            const codeFilePathHook = path.join(versionBasePath, this.C.postHooks, `${hookObj.name}.ts`);
+                            const targetFilePathHook = path.join(this.projectDirectory, this.C.src, writeFolderName, bundleName, itemConfig.path, this.C.postHooks, `${hookObj.name}.ts`);
+                            await fs.promises.mkdir(path.dirname(targetFilePathHook), { recursive: true });
+                            await fs.promises.link(codeFilePathHook, targetFilePathHook);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * src/admin/Events/test - event/test - event.yaml
+     * src/admin/Events/test - event/listeners/One/versions/1.0.0/1.0.0.ts
+     */
+    async copyEventsToAnotherDir() {
+        const readFolderName = this.C.EventsReadF;
+        const writeFolderName = this.C.EventsWriteF;
+        const itemBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const eventNames = await this.readDirCustom(itemBasePath, null);
+        for (const eventName of eventNames) {
+            const itemConfigPath = path.join(itemBasePath, eventName, `${eventName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            const eventListenersPath = path.join(itemBasePath, eventName, this.C.listeners);
+            for (const eventListenerObj of itemConfig.eventListeners) {
+                for (const version of eventListenerObj.versions || []) {
+                    if (version.isActive === true) {
+                        // Write code file
+                        const codeFilePath = path.join(eventListenersPath, eventListenerObj.name, this.C.versions, version.version, `${version.name}.ts`);
+                        const targetFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, itemConfig.name, `${eventListenerObj.name}.ts`);
+                        await fs.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                        await fs.promises.link(codeFilePath, targetFilePath);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * src/admin/Instance API hooks/mongodb -- test -- default -- GEN_GET_ALL/mongodb -- test -- default -- GEN_GET_ALL.yaml
+     * src/admin/Instance API hooks/mongodb -- test -- default -- GEN_GET_ALL/pre-hooks/Hook 1.ts
+     * src/admin/Instance API hooks/mongodb -- test -- default -- GEN_GET_ALL/post-hooks/Post hook 1.ts
+     */
+    async copyInstanceApiHooksToAnotherDir() {
+        const readFolderName = this.C.InstanceApiHooksReadF;
+        const writeFolderName = this.C.InstanceApiHooksWriteF;
+        const itemBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const hookNames = await this.readDirCustom(itemBasePath, null);
+        for (const hookName of hookNames) {
+            const itemConfigPath = path.join(itemBasePath, hookName, `${hookName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            const apiNamePath = path.join(itemBasePath, hookName);
+            const newFileName = `${itemConfig.instanceName}/${itemConfig.databaseName}/${itemConfig.collectionName}/${itemConfig.apiId.toLowerCase()}`;
+            for (const hookObj of itemConfig.preHooks) {
+                // Write code file
+                const codeFilePath = path.join(apiNamePath, this.C.preHooks, `${hookObj.name}.ts`);
+                const targetFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, newFileName, this.C.preHooks, `${hookObj.name}.ts`);
+                await fs.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                await fs.promises.link(codeFilePath, targetFilePath);
+            }
+            for (const hookObj of itemConfig.postHooks) {
+                // Write code file
+                const codeFilePath = path.join(apiNamePath, this.C.postHooks, `${hookObj.name}.ts`);
+                const targetFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, newFileName, this.C.postHooks, `${hookObj.name}.ts`);
+                await fs.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                await fs.promises.link(codeFilePath, targetFilePath);
+            }
+        }
+    }
+    /**
+     * src/admin/System API hooks/ENCRYPT_DATA/ENCRYPT_DATA.yaml
+     * src/admin/System API hooks/ENCRYPT_DATA/pre-hooks/System api pre hook 1.ts
+     * src/admin/System API hooks/ENCRYPT_DATA/post-hooks/System api post hook 1.ts
+     */
+    async copySystemApiHooksToAnotherDir() {
+        const readFolderName = this.C.SystemApiHooksReadF;
+        const writeFolderName = this.C.SystemApiHooksWriteF;
+        const itemBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const hookNames = await this.readDirCustom(itemBasePath, null);
+        for (const hookName of hookNames) {
+            const itemConfigPath = path.join(itemBasePath, hookName, `${hookName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            const apiNamePath = path.join(itemBasePath, hookName);
+            const newFileName = itemConfig.apiId.toLowerCase();
+            for (const hookObj of itemConfig.preHooks) {
+                // Write code file
+                const codeFilePath = path.join(apiNamePath, this.C.preHooks, `${hookObj.name}.ts`);
+                const targetFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, newFileName, this.C.preHooks, `${hookObj.name}.ts`);
+                await fs.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                await fs.promises.link(codeFilePath, targetFilePath);
+            }
+            for (const hookObj of itemConfig.postHooks) {
+                // Write code file
+                const codeFilePath = path.join(apiNamePath, this.C.postHooks, `${hookObj.name}.ts`);
+                const targetFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, newFileName, this.C.postHooks, `${hookObj.name}.ts`);
+                await fs.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                await fs.promises.link(codeFilePath, targetFilePath);
+            }
+        }
+    }
+    /**
+     * src/admin/WebSocket events/Custom APIs -- Hello World/versions/-1/Original.ts
+     * src/admin/WebSocket events/Custom APIs -- Hello World/Custom APIs -- Hello World.yaml
+     */
+    async copyWebSocketEventsToAnotherDir() {
+        const readFolderName = this.C.WebSocketEventsReadF;
+        const writeFolderName = this.C.WebSocketEventsWriteF;
+        const itemBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const itemFolderNames = await this.readDirCustom(itemBasePath, null);
+        for (const itemFolderName of itemFolderNames) {
+            const itemConfigPath = path.join(itemBasePath, itemFolderName, `${itemFolderName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            for (const version of itemConfig.versions || []) {
+                if (version.isActive === true) {
+                    const codeFilePath = path.join(itemBasePath, itemFolderName, this.C.versions, version.version, `${version.name}.ts`);
+                    let newFileName = '';
+                    let category = '';
+                    if (itemConfig.apiCategory === EAPICategory.INSTANCES) {
+                        category = 'instances';
+                        newFileName = `${itemConfig.instanceName}/${itemConfig.databaseName}/${itemConfig.collectionName}/${itemConfig.instanceApiName.toLowerCase()}`;
+                    }
+                    else if (itemConfig.apiCategory === EAPICategory.THIRD_PARTY_APIS) {
+                        category = 'third-party-apis';
+                        newFileName = `${itemConfig.tpInstalledApiBundleName}/${itemConfig.tpInstalledApiName}`;
+                    }
+                    else if (itemConfig.apiCategory === EAPICategory.CUSTOM_APIS) {
+                        category = 'custom-apis';
+                        newFileName = itemConfig.customApiName;
+                    }
+                    else if (itemConfig.apiCategory === EAPICategory.SYSTEM_APIS) {
+                        category = 'system-apis';
+                        newFileName = itemConfig.systemApiName.toLowerCase();
+                    }
+                    else if (itemConfig.apiCategory === EAPICategory.WEB_SOCKET_EVENT) {
+                        category = 'ws-events';
+                        newFileName = itemConfig.name;
+                    }
+                    const targetFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, category, `${newFileName}.ts`);
+                    await fs.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                    await fs.promises.link(codeFilePath, targetFilePath);
+                }
+            }
+        }
+    }
+    /**
+     * src/admin/Collection hooks/mongodb -- test -- default/mongodb -- test -- default.yaml
+     * src/admin/Collection hooks/mongodb -- test -- default/post-hooks/collection post hook 1.ts
+     * src/admin/Collection hooks/mongodb -- test -- default/pre-hooks/collection pre hook 1.ts
+     */
+    async copyCollectionHooksToAnotherDir() {
+        const readFolderName = this.C.CollectionHooksReadF;
+        const writeFolderName = this.C.CollectionHooksWriteF;
+        const itemBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const hookNames = await this.readDirCustom(itemBasePath, null);
+        for (const hookName of hookNames) {
+            const itemConfigPath = path.join(itemBasePath, hookName, `${hookName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            const apiNamePath = path.join(itemBasePath, hookName);
+            const newFileName = `${itemConfig.instanceName}/${itemConfig.databaseName}/${itemConfig.collectionName}`;
+            for (const hookObj of itemConfig.preHooks) {
+                // Write code file
+                const codeFilePath = path.join(apiNamePath, this.C.preHooks, `${hookObj.name}.ts`);
+                const targetFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, newFileName, this.C.preHooks, `${hookObj.name}.ts`);
+                await fs.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                await fs.promises.link(codeFilePath, targetFilePath);
+            }
+            for (const hookObj of itemConfig.postHooks) {
+                // Write code file
+                const codeFilePath = path.join(apiNamePath, this.C.postHooks, `${hookObj.name}.ts`);
+                const targetFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, newFileName, this.C.postHooks, `${hookObj.name}.ts`);
+                await fs.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                await fs.promises.link(codeFilePath, targetFilePath);
+            }
+        }
+    }
+    /**
+     * src/admin/Database hooks/mongodb -- test/mongodb -- test.yaml
+     * src/admin/Database hooks/mongodb -- test/pre-hooks/database pre hook 1.ts
+     * src/admin/Database hooks/mongodb -- test/post-hooks/database post hook 1.ts
+     */
+    async copyDatabaseHooksToAnotherDir() {
+        const readFolderName = this.C.DatabaseHooksReadF;
+        const writeFolderName = this.C.DatabaseHooksWriteF;
+        const itemBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const hookNames = await this.readDirCustom(itemBasePath, null);
+        for (const hookName of hookNames) {
+            const itemConfigPath = path.join(itemBasePath, hookName, `${hookName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            const apiNamePath = path.join(itemBasePath, hookName);
+            const newFileName = `${itemConfig.instanceName}/${itemConfig.databaseName}`;
+            for (const hookObj of itemConfig.preHooks) {
+                // Write code file
+                const codeFilePath = path.join(apiNamePath, this.C.preHooks, `${hookObj.name}.ts`);
+                const targetFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, newFileName, this.C.preHooks, `${hookObj.name}.ts`);
+                await fs.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                await fs.promises.link(codeFilePath, targetFilePath);
+            }
+            for (const hookObj of itemConfig.postHooks) {
+                // Write code file
+                const codeFilePath = path.join(apiNamePath, this.C.postHooks, `${hookObj.name}.ts`);
+                const targetFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, newFileName, this.C.postHooks, `${hookObj.name}.ts`);
+                await fs.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                await fs.promises.link(codeFilePath, targetFilePath);
+            }
+        }
+    }
+    /**
+     * src/admin/Instance hooks/mongodb/mongodb.yaml
+     * src/admin/Instance hooks/mongodb/pre-hooks/Mongodb instance pre hook.ts
+     * src/admin/Instance hooks/mongodb/post-hooks/Mongo instance post hook 1.ts
+     */
+    async copyInstanceHooksToAnotherDir() {
+        const readFolderName = this.C.InstanceHooksReadF;
+        const writeFolderName = this.C.InstanceHooksWriteF;
+        const itemBasePath = path.join(__dirname, this.C.src, this.config.adminUserPath, readFolderName);
+        const hookNames = await this.readDirCustom(itemBasePath, null);
+        for (const hookName of hookNames) {
+            const itemConfigPath = path.join(itemBasePath, hookName, `${hookName}.yaml`);
+            if (!fs.existsSync(itemConfigPath))
+                continue;
+            const itemConfigContent = await fs.promises.readFile(itemConfigPath, { encoding: 'utf8' });
+            const itemConfig = await this.parseYaml(itemConfigContent);
+            const apiNamePath = path.join(itemBasePath, hookName);
+            const newFileName = `${itemConfig.instanceName}`;
+            for (const hookObj of itemConfig.preHooks) {
+                // Write code file
+                const codeFilePath = path.join(apiNamePath, this.C.preHooks, `${hookObj.name}.ts`);
+                const targetFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, newFileName, this.C.preHooks, `${hookObj.name}.ts`);
+                await fs.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                await fs.promises.link(codeFilePath, targetFilePath);
+            }
+            for (const hookObj of itemConfig.postHooks) {
+                // Write code file
+                const codeFilePath = path.join(apiNamePath, this.C.postHooks, `${hookObj.name}.ts`);
+                const targetFilePath = path.join(this.projectDirectory, this.C.src, writeFolderName, newFileName, this.C.postHooks, `${hookObj.name}.ts`);
+                await fs.promises.mkdir(path.dirname(targetFilePath), { recursive: true });
+                await fs.promises.link(codeFilePath, targetFilePath);
+            }
+        }
+    }
+    async executeNpmRun(command, args) {
+        return new Promise((resolve, reject) => {
+            const childProcess = (0, child_process_1.spawn)(command, args, {
+                stdio: 'inherit',
+                shell: true, // Allows execution in the system shell, which helps locate 'npm'
+            });
+            childProcess.on('close', (code) => {
+                if (code === 0)
+                    resolve();
+                else {
+                    const errorMsg = `'${command} ${args.join(' ')}' exited with code ${code}.`;
+                    reject(new Error(errorMsg));
+                }
+            });
+            childProcess.on('error', (err) => {
+                console.error(`Failed to start the npm process: ${err.message}`);
+                reject(err);
+            });
+        });
+    }
+    async parseYaml(text) {
+        if (!this.globalObj.jsyaml) {
+            let cdnContent = await this.getContentFromWebURL('https://cdnjs.cloudflare.com/ajax/libs/js-yaml/4.1.0/js-yaml.js');
+            const globalObj = {};
+            cdnContent = cdnContent.replace(`Object.defineProperty(exports, '__esModule', { value: true });`, `Object.defineProperty(exports, '__esModule', { value: true }); globalObj.jsyaml = jsYaml;`);
+            // eslint-disable-next-line no-eval
+            eval(cdnContent);
+            this.globalObj.jsyaml = globalObj.jsyaml;
+        }
+        return this.globalObj.jsyaml.load(text);
+    }
+    getContentFromWebURL(fileUrl) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new URL(fileUrl);
+            const client = urlObj.protocol === 'https:' ? https : http;
+            client.get(fileUrl, (res) => {
+                let data = '';
+                res.on('data', chunk => {
+                    data += chunk;
+                });
+                res.on('end', () => {
+                    resolve(data);
+                });
+            }).on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+    startWatch() {
+        const basePath = __dirname;
+        fs.watch(basePath, { recursive: true }, async (eventType, filename) => {
+            if (this.skipWatchInputs)
+                return; // It will be true when we are writing all data to disk
+            if (!filename || filename.endsWith('~') || filename.startsWith('.'))
+                return;
+            if (!filename.startsWith(this.C.src))
+                return;
+            if (this.EL)
+                console.log(`✓ Send : [${this.getCurrentTime()}] : ${filename}`);
+            const category = this.getCategoryOfPath(filename);
+            const changedFolder = this.getChangedFolder(category, filename);
+            if (!changedFolder)
+                return;
+            let folderChangedObj;
+            let shouldReplaceAllItemsOfCategory = false;
+            if (fs.existsSync(changedFolder)) {
+                if (!fs.existsSync(filename)) { // some file removed.
+                    this.syncAllDataWithServer();
+                }
+                else {
+                    const keysPrefix = path.join('/' + this.C.repo, changedFolder);
+                    folderChangedObj = await this.serializeFolderWithBinary(changedFolder, keysPrefix);
+                    this.sendToServer({
+                        objType: EWSObjectType.LC_DATA_REQ_RES,
+                        localClientWSReqRes: {
+                            eventType: ELocalClientSubEventType.LC_FOLDER_CHANGED_ON_LOCAL_SYSTEM,
+                            folderChangedOnLocalSystem: folderChangedObj,
+                            category,
+                            shouldReplaceAllItemsOfCategory,
+                        },
+                    });
+                }
+            }
+            else {
+                const changedFolderDeleted = this.getChangedFolderForDeleted(category, filename);
+                const keysPrefix = path.join('/' + this.C.repo, changedFolderDeleted);
+                folderChangedObj = await this.serializeFolderWithBinary(changedFolderDeleted, keysPrefix);
+                shouldReplaceAllItemsOfCategory = true;
+                this.sendDeletedEventToServerDebounce(folderChangedObj, category, shouldReplaceAllItemsOfCategory);
+            }
+        });
+    }
+    getCurrentTime() {
+        const now = new Date();
+        const hours = String(now.getHours()).padStart(2, '0');
+        const minutes = String(now.getMinutes()).padStart(2, '0');
+        const seconds = String(now.getSeconds()).padStart(2, '0');
+        return `${hours}:${minutes}:${seconds}`;
+    }
+    sendDeletedEventToServerInternal(folderChangedObj, category, shouldReplaceAllItemsOfCategory) {
+        this.sendToServer({
+            objType: EWSObjectType.LC_DATA_REQ_RES,
+            localClientWSReqRes: {
+                eventType: ELocalClientSubEventType.LC_FOLDER_CHANGED_ON_LOCAL_SYSTEM,
+                folderChangedOnLocalSystem: folderChangedObj,
+                category,
+                shouldReplaceAllItemsOfCategory,
+            },
+        });
+    }
+    debounce(fn, delay) {
+        let timer = null;
+        return function (...args) {
+            clearTimeout(timer);
+            timer = setTimeout(() => {
+                fn.apply(this, args);
+            }, delay);
+        };
+    }
+    getCategoryOfPath(filename) {
+        const changeBase = path.join(this.C.src, this.config.adminUserPath);
+        if (!filename.startsWith(changeBase))
+            return; // ignore files outside of src folder.
+        const segments = filename.split(path.sep).filter(o => !!o);
+        const category = segments[2];
+        for (const key in EGitSyncType)
+            if (EGitSyncType[key] === category)
+                return category;
+    }
+    getChangedFolder(category, filename) {
+        const segments = filename.split(path.sep);
+        let changedFolderPath = '';
+        if (category === EGitSyncType.THIRD_PARTY_APIS)
+            changedFolderPath = segments.slice(0, 6).join(path.sep);
+        else
+            changedFolderPath = segments.slice(0, 4).join(path.sep);
+        return changedFolderPath;
+    }
+    getChangedFolderForDeleted(category, filename) {
+        const segments = filename.split(path.sep);
+        return segments.slice(0, 3).join(path.sep);
+    }
+    async serializeFolderWithBinary(dirPath, pathPrefix) {
+        const result = {};
+        const localClient = this;
+        async function walk(currentPath) {
+            const entries = await localClient.readDirCustom(currentPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(currentPath, entry.name);
+                if (entry.isDirectory())
+                    await walk(fullPath);
+                else { // Read as buffer and encode to base64
+                    const content = fs.readFileSync(fullPath);
+                    const relativePath = path.relative(dirPath, fullPath);
+                    const objectKey = path.join(pathPrefix, relativePath);
+                    result[objectKey] = {
+                        encoding: 'base64',
+                        content: content.toString('base64'),
+                    };
+                }
+            }
+        }
+        await walk(dirPath);
+        return result;
+    }
+    startWatch_bak() {
+        const basePath = this.projectDirectory;
+        fs.watch(basePath, { recursive: true }, async (eventType, filename) => {
+            if (!filename || filename.endsWith('~'))
+                return;
+            if (this.skipWatchInputs)
+                return; // It will be true when we are writing all data to disk
+            const fullPath = path.join(basePath, filename);
+            console.log(`Event Type: ${eventType}, File: ${fullPath}`);
+            try {
+                const stats = await fs.promises.stat(fullPath);
+                if (stats.isFile()) {
+                    if (eventType === 'rename') {
+                        console.log(`🧩 ${filename} file was added.`);
+                    }
+                    else if (eventType === 'change') {
+                        console.log(`✏️ ${filename} file was modified.`);
+                    }
+                }
+                else if (stats.isDirectory()) {
+                    if (eventType === 'rename') {
+                        console.log(`🧩 ${filename} directory was added.`);
+                    }
+                    else if (eventType === 'change') {
+                        console.log(`✏️ ${filename} directory was modified.`);
+                    }
+                }
+            }
+            catch (e) {
+                if (e.code === 'ENOENT') {
+                    if (fullPath.endsWith('~')) { // Do nothing as it is temporary file.
+                    }
+                    else {
+                        console.log(`❌ Deleted: ${fullPath}`);
+                    }
+                }
+            }
+        });
+    }
+    sendToServer(data) {
+        this.spinner.start();
+        try {
+            this.ws.send(JSON.stringify(data));
+        }
+        catch (e) {
+            console.log(e);
+        }
+        this.spinner.stop();
+    }
+    async connectToServerViaWS() {
+        console.log('Connecting to server...');
+        const authTokenInfo = 'ws-local-client-sync';
+        const am_authorization = this.config.syncToken;
+        const adminUserPath = this.config.adminUserPath;
+        const webSocketURL = this.config.webSocketURL;
+        this.ws = new WebSocket(`${webSocketURL}?authTokenInfo=${authTokenInfo}&authorization=${am_authorization}&user-path=${adminUserPath}`);
+        const registeredEvents = [];
+        const sendRegisterEvent = () => {
+            this.sendToServer({
+                objType: EWSObjectType.REGISTER,
+                onEvents: [{
+                        eventType: 'LOCAL_CLIENT_SYNC_EVENTS',
+                    }],
+            });
+        };
+        function cleanWS(wsTemp) {
+            wsTemp.onopen = null;
+            wsTemp.onmessage = null;
+            wsTemp.onerror = null;
+            wsTemp.onclose = null;
+            wsTemp.close();
+        }
+        this.ws.onmessage = async (event) => {
+            const serverResp = JSON.parse(event.data);
+            if (serverResp.type === EWSObjectType.CONNECTED && serverResp.response.connected)
+                sendRegisterEvent();
+            else if (serverResp.type === EWSObjectType.REGISTER) {
+                if (serverResp?.response?.validOnEvents?.length) {
+                    for (const validEvent of serverResp.response.validOnEvents)
+                        registeredEvents.push(validEvent);
+                    console.log(`✅ Connected to server via WS`);
+                    this.syncAllDataWithServer();
+                }
+            }
+            else
+                await this.processReceivedEvent(serverResp);
+        };
+        this.ws.onclose = (event) => {
+            console.log('Connection closed.');
+            cleanWS(this.ws);
+            setTimeout(this.connectToServerViaWS.bind(this), 3000);
+        };
+        this.ws.onerror = () => {
+            cleanWS(this.ws);
+            setTimeout(this.connectToServerViaWS.bind(this), 3000);
+        };
+    }
+    syncAllDataWithServer() {
+        this.sendToServer({
+            objType: EWSObjectType.LC_DATA_REQ_RES,
+            localClientWSReqRes: {
+                eventType: ELocalClientSubEventType.LC_SEND_ALL_DATA,
+            },
+        });
+    }
+    async processReceivedEvent(serverResp) {
+        if (this.EL)
+            console.log(serverResp);
+        if (serverResp.type === EWSObjectType.LC_DATA_REQ_RES) {
+            if (serverResp.errors?.length) {
+                console.error(serverResp.errors);
+                return;
+            }
+            this.spinner.start();
+            if (serverResp.response.eventType === ELocalClientSubEventType.LC_SEND_ALL_DATA) {
+                fs.rmSync(path.join(__dirname, this.C.src), {
+                    recursive: true,
+                    force: true,
+                });
+                fs.mkdirSync(path.join(__dirname, this.C.src), { recursive: true });
+                const resp = serverResp.response.eventData;
+                await this.writeMemfsJsonToDisk(resp, __dirname);
+            }
+            else if (serverResp.response.eventType === ELocalClientSubEventType.LC_DATA_MODIFIED_IN_DATABASE) {
+                const resp = serverResp.response.eventData;
+                await this.writeMemfsJsonToDisk(resp.data, __dirname);
+            }
+            if (this.nodeModulesCopied === true)
+                await this.copyFilesToProjectDir(false);
+            else {
+                await this.copyFilesToProjectDir(true);
+                this.nodeModulesCopied = true;
+            }
+            this.spinner.stop();
+        }
+    }
+    async writeMemfsJsonToDisk(jsonData, targetRoot) {
+        this.skipWatchInputs = true;
+        const BATCH_SIZE = 1000;
+        let batch = [];
+        const flushBatch = async () => {
+            if (batch.length > 0) {
+                await Promise.all(batch);
+                batch = [];
+            }
+        };
+        for (const [filePath, contentObjTemp] of Object.entries(jsonData)) {
+            if (!filePath.startsWith(`/${this.C.repo}/${this.C.src}`))
+                continue;
+            const contentObj = contentObjTemp;
+            const filePathRepoRemoved = filePath.replace(`/${this.C.repo}`, '');
+            if (this.skipFileWritingForLocal[filePathRepoRemoved])
+                continue;
+            const resolvedPath = path.join(targetRoot, filePathRepoRemoved.replace(/^\//, ''));
+            const dir = path.dirname(resolvedPath);
+            const task = async () => {
+                await fs.promises.mkdir(dir, { recursive: true });
+                await fs.promises.writeFile(resolvedPath, contentObj.content, { encoding: 'base64' });
+                if (this.EL)
+                    console.log(`✓ Receive : [${this.getCurrentTime()}] : ${resolvedPath.replace(targetRoot, '')}`);
+            };
+            batch.push(task());
+            if (batch.length >= BATCH_SIZE)
+                await flushBatch();
+        }
+        await flushBatch(); // Flush any remaining tasks
+        setTimeout(() => {
+            this.skipWatchInputs = false;
+        }, 1000);
+    }
+    removeEmptyDirsSync(dirPath) {
+        if (!fs.existsSync(dirPath))
+            return false;
+        const entries = fs.readdirSync(dirPath);
+        let isEmpty = true;
+        for (const entry of entries) {
+            const fullPath = path.join(dirPath, entry);
+            const stat = fs.statSync(fullPath);
+            if (stat.isDirectory()) {
+                const removed = this.removeEmptyDirsSync(fullPath);
+                if (!removed)
+                    isEmpty = false;
+            }
+            else
+                isEmpty = false;
+        }
+        if (isEmpty) {
+            fs.rmdirSync(dirPath);
+            return true;
+        }
+        return false;
+    }
+    async readDirCustom(dirPath, options) {
+        if (!fs.existsSync(dirPath))
+            return [];
+        return await fs.promises.readdir(dirPath, options);
+    }
+}
+new LocalClient().start().then();
+var EAPICategory;
+(function (EAPICategory) {
+    EAPICategory["INSTANCES"] = "INSTANCES";
+    EAPICategory["THIRD_PARTY_APIS"] = "THIRD_PARTY_APIS";
+    EAPICategory["CUSTOM_APIS"] = "CUSTOM_APIS";
+    EAPICategory["SYSTEM_APIS"] = "SYSTEM_APIS";
+    EAPICategory["WEB_SOCKET_EVENT"] = "WEB_SOCKET_EVENT";
+})(EAPICategory = exports.EAPICategory || (exports.EAPICategory = {}));
+var EWSObjectType;
+(function (EWSObjectType) {
+    EWSObjectType["REGISTER"] = "REGISTER";
+    EWSObjectType["UNREGISTER"] = "UNREGISTER";
+    EWSObjectType["CONNECTED"] = "CONNECTED";
+    EWSObjectType["UNKNOWN"] = "UNKNOWN";
+    EWSObjectType["TOKEN_VALIDATION"] = "TOKEN_VALIDATION";
+    EWSObjectType["NOTIFICATION"] = "NOTIFICATION";
+    // Below is only used for local client sync
+    EWSObjectType["LC_DATA_REQ_RES"] = "LC_DATA_REQ_RES";
+})(EWSObjectType || (EWSObjectType = {}));
+var ELocalClientSubEventType;
+(function (ELocalClientSubEventType) {
+    ELocalClientSubEventType["LC_SEND_ALL_DATA"] = "LC_SEND_ALL_DATA";
+    ELocalClientSubEventType["LC_DATA_MODIFIED_IN_DATABASE"] = "LC_DATA_MODIFIED_IN_DATABASE";
+    ELocalClientSubEventType["LC_FOLDER_CHANGED_ON_LOCAL_SYSTEM"] = "LC_FOLDER_CHANGED_ON_LOCAL_SYSTEM";
+})(ELocalClientSubEventType || (ELocalClientSubEventType = {}));
+var EMongooseHookMethods;
+(function (EMongooseHookMethods) {
+    EMongooseHookMethods["POST"] = "POST";
+    EMongooseHookMethods["PUT"] = "PUT";
+    EMongooseHookMethods["PUT_REPLACE"] = "PUT_REPLACE";
+    EMongooseHookMethods["DELETE"] = "DELETE";
+    EMongooseHookMethods["DELETE_ALL"] = "DELETE_ALL";
+})(EMongooseHookMethods = exports.EMongooseHookMethods || (exports.EMongooseHookMethods = {}));
+// It only includes required
+var EAMModelNames;
+(function (EAMModelNames) {
+    EAMModelNames["AmEvents"] = "am_events";
+    EAMModelNames["WebSocketEvents"] = "am_web_socket_events";
+    EAMModelNames["DBMasters"] = "am_db_masters";
+    EAMModelNames["CustomApis"] = "am_custom_apis";
+    EAMModelNames["InstanceApiSettings"] = "am_instance_api_settings";
+    EAMModelNames["InstanceApiHooks"] = "am_instance_api_hooks";
+    EAMModelNames["InstanceHooks"] = "am_instance_hooks";
+    EAMModelNames["DatabaseHooks"] = "am_database_hooks";
+    EAMModelNames["CollectionHooks"] = "am_collection_hooks";
+    EAMModelNames["Schedulers"] = "am_schedulers";
+    EAMModelNames["Schemas"] = "am_schemas";
+    EAMModelNames["I18Ns"] = "am_i18ns";
+    EAMModelNames["SystemApiSettings"] = "am_system_api_settings";
+    EAMModelNames["SystemApiHooks"] = "am_system_api_hooks";
+    EAMModelNames["am_tp_api_settings"] = "am_tp_api_settings";
+    EAMModelNames["am_tp_installed_apis"] = "am_tp_installed_apis";
+    EAMModelNames["am_tp_api_versions"] = "am_tp_api_versions";
+    EAMModelNames["UtilityClasses"] = "am_utility_classes";
+    EAMModelNames["DatabasesMigrations"] = "am_database_migrations";
+    EAMModelNames["ProcessInitializers"] = "am_process_initializers";
+    EAMModelNames["UIMakerUtils"] = "am_ui_maker_utils";
+    EAMModelNames["UIMakerStyles"] = "am_ui_maker_styles";
+    EAMModelNames["AmTestCases"] = "am_test_cases";
+})(EAMModelNames = exports.EAMModelNames || (exports.EAMModelNames = {}));
+// It includes required
+var EGitSyncType;
+(function (EGitSyncType) {
+    EGitSyncType["CUSTOM_APIS"] = "Custom APIs";
+    EGitSyncType["DB_MIGRATIONS"] = "Database migrations";
+    EGitSyncType["PROCESS_INITIALIZERS"] = "Process initializers";
+    EGitSyncType["EVENTS"] = "Events";
+    EGitSyncType["I18NS"] = "i18ns";
+    EGitSyncType["INSTANCE_API_HOOKS"] = "Instance API hooks";
+    EGitSyncType["INSTANCE_HOOKS"] = "Instance hooks";
+    EGitSyncType["DATABASE_HOOKS"] = "Database hooks";
+    EGitSyncType["COLLECTION_HOOKS"] = "Collection hooks";
+    EGitSyncType["INSTANCE_API_SETTINGS"] = "Instance API settings";
+    EGitSyncType["SCHEDULERS"] = "Schedulers";
+    EGitSyncType["SCHEMAS"] = "Schemas";
+    EGitSyncType["SYSTEM_API_HOOKS"] = "System API hooks";
+    EGitSyncType["SYSTEM_API_SETTINGS"] = "System API settings";
+    EGitSyncType["TEST_CASES"] = "Test cases";
+    EGitSyncType["THIRD_PARTY_APIS"] = "Third party APIs";
+    EGitSyncType["THIRD_PARTY_API_SETTINGS"] = "Third party API settings";
+    EGitSyncType["UTILITY_CLASSES"] = "Utility classes";
+    EGitSyncType["EVENTS_WS"] = "WebSocket events";
+    EGitSyncType["DB_MASTERS"] = "DB masters";
+    EGitSyncType["UI_MAKER_UTILITY_CLASS"] = "DB master utils";
+    EGitSyncType["UI_MAKER_STYLES"] = "UI maker styles";
+})(EGitSyncType = exports.EGitSyncType || (exports.EGitSyncType = {}));