@digicroz/node-backend-kit 1.0.0

package/dist/cli/deleteAndCopy.js

@@ -0,0 +1,88 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { startProgress, successProgress, failProgress, updateProgress } from '../utils/progress.js';
+/**
+ * Deletes all files in the target directory and copies all files from source directory
+ * @param sourcePath - Source directory path
+ * @param targetPath - Target directory path
+ */
+export async function deleteAndCopy(sourcePath, targetPath) {
+    const spinner = startProgress(`Preparing to copy files from ${path.basename(sourcePath)} to ${path.basename(targetPath)}`);
+    try {
+        // Ensure target directory exists
+        if (!fs.existsSync(targetPath)) {
+            updateProgress(spinner, `Creating target directory: ${targetPath}`);
+            fs.mkdirSync(targetPath, { recursive: true });
+        }
+        else {
+            // Delete existing files and directories in target
+            updateProgress(spinner, `Cleaning target directory: ${targetPath}`);
+            const items = fs.readdirSync(targetPath);
+            for (const item of items) {
+                const itemPath = path.join(targetPath, item);
+                if (fs.lstatSync(itemPath).isDirectory()) {
+                    fs.rmSync(itemPath, { recursive: true, force: true });
+                }
+                else {
+                    fs.unlinkSync(itemPath);
+                }
+            }
+        }
+        // Copy all files from source to target
+        updateProgress(spinner, `Copying files from ${sourcePath} to ${targetPath}`);
+        await copyDirectoryRecursive(sourcePath, targetPath, spinner);
+        successProgress(spinner, `Successfully copied all files from ${path.basename(sourcePath)} to ${path.basename(targetPath)}`);
+    }
+    catch (error) {
+        failProgress(spinner, `Error during deleteAndCopy operation`);
+        console.error(`Error during deleteAndCopy operation:`, error);
+        throw error;
+    }
+}
+/**
+ * Counts the total number of files in a directory recursively
+ * @param directory - Directory to count files in
+ * @returns Total number of files
+ */
+function countFiles(directory) {
+    let count = 0;
+    const items = fs.readdirSync(directory);
+    for (const item of items) {
+        const itemPath = path.join(directory, item);
+        if (fs.lstatSync(itemPath).isDirectory()) {
+            count += countFiles(itemPath);
+        }
+        else {
+            count++;
+        }
+    }
+    return count;
+}
+/**
+ * Copies directory contents recursively
+ * @param source - Source directory
+ * @param target - Target directory
+ * @param spinner - Progress spinner
+ */
+async function copyDirectoryRecursive(source, target, spinner) {
+    // Create target directory if it doesn't exist
+    if (!fs.existsSync(target)) {
+        fs.mkdirSync(target, { recursive: true });
+    }
+    // Get all files and directories in the source
+    const items = fs.readdirSync(source);
+    for (const item of items) {
+        const sourcePath = path.join(source, item);
+        const targetPath = path.join(target, item);
+        if (fs.lstatSync(sourcePath).isDirectory()) {
+            // Update progress for directories
+            updateProgress(spinner, `Copying directory: ${item}`);
+            // Recursively copy subdirectories
+            await copyDirectoryRecursive(sourcePath, targetPath, spinner);
+        }
+        else {
+            // Copy files
+            fs.copyFileSync(sourcePath, targetPath);
+        }
+    }
+}

package/dist/cli/deployAllRepos.d.ts

@@ -0,0 +1 @@
+export declare const deployAllRepos: () => Promise<void>;

package/dist/cli/deployAllRepos.js

@@ -0,0 +1,202 @@
+import fs from "fs";
+import { join } from "path";
+import path from "path";
+import { execSync } from "child_process";
+import { clientRootDirPath } from "../utils/path.js";
+import { simpleGit } from "simple-git";
+import { loadConfig } from "../utils/loadConfig.js";
+import { createMultiProgress, startProgress, successProgress, failProgress, } from "../utils/progress.js";
+const getAllPaths = () => {
+    try {
+        // Load projects from the configuration file
+        const config = loadConfig();
+        // Export projects for use in CLI tools
+        let b2fPortalProjects = config.projects;
+        const allPaths = [];
+        allPaths.push(clientRootDirPath);
+        for (const project of b2fPortalProjects) {
+            if (project.sharedBackendPath) {
+                const sharedBackendPath = join(clientRootDirPath, project.sharedBackendPath);
+                if (!fs.existsSync(sharedBackendPath)) {
+                    console.log("sharedBackendPath does not exist");
+                    console.log({ sharedBackendPath });
+                    return [];
+                }
+                allPaths.push(sharedBackendPath);
+            }
+            for (const section of project.sections) {
+                if (section.repository.path) {
+                    const repositoryPath = join(clientRootDirPath, section.repository.path);
+                    if (!fs.existsSync(repositoryPath)) {
+                        console.log("repositoryPath does not exist");
+                        console.log({ repositoryPath });
+                        return [];
+                    }
+                    allPaths.push(repositoryPath);
+                }
+            }
+        }
+        return allPaths;
+    }
+    catch (error) {
+        console.log(error);
+        return [];
+    }
+};
+const checkRepo = async (repoPath) => {
+    try {
+        const repositoryPackageJsonPath = join(repoPath, "package.json");
+        if (!fs.existsSync(repositoryPackageJsonPath)) {
+            console.log("repositoryPackageJsonPath does not exist");
+            console.log({ repoPath });
+            return;
+        }
+        const repositoryPackageJson = JSON.parse(fs.readFileSync(repositoryPackageJsonPath, "utf8"));
+        if (!repositoryPackageJson.name) {
+            console.log("repositoryPackageJson.name does not exist");
+            console.log({ repoPath });
+            return;
+        }
+        if (!repositoryPackageJson.scripts?.deploy) {
+            console.log("deploy script does not exist, skipping....");
+            console.log({ repoPath });
+            return;
+        }
+        const spinner = startProgress(`Checking Repo: ${repositoryPackageJson.name}`);
+        const options = {
+            baseDir: path.resolve(repoPath),
+            binary: "git",
+            maxConcurrentProcesses: 6,
+        };
+        const git = simpleGit(options);
+        spinner.text = `${repositoryPackageJson.name}: fetching ...`;
+        await git.fetch();
+        spinner.text = `${repositoryPackageJson.name}: Checking status ...`;
+        let status = await git.status();
+        // Save the current branch name
+        const currentBranch = status.current;
+        // console.log(currentBranch);
+        if (currentBranch !== "main") {
+            failProgress(spinner, `Current branch is ${currentBranch}, but it should be main.`);
+            console.log(`Repo: ${repoPath}`);
+            process.exit(1);
+        }
+        if (status.files.length > 0) {
+            failProgress(spinner, "❌ Uncommitted changes detected");
+            console.log(`Repo: ${repoPath}`);
+            process.exit(1);
+        }
+        spinner.text = `${repositoryPackageJson.name}: pulling ...`;
+        await git.pull();
+        spinner.text = `${repositoryPackageJson.name}: Checking status ...`;
+        status = await git.status();
+        // Check for new uncommitted changes after pulling
+        if (status.files.length > 0) {
+            failProgress(spinner, "❌ Uncommitted changes detected after pull");
+            console.log(`Repo: ${repoPath}`);
+            process.exit(1);
+        }
+        else {
+            spinner.text = `${repositoryPackageJson.name}: pushing ...`;
+            await git.push();
+        }
+        spinner.text = `${repositoryPackageJson.name}: fetching branches...`;
+        const branches = await git.branch(["-r"]);
+        // Check if stable branch exists in remote
+        if (!branches.all.includes("origin/stable")) {
+            failProgress(spinner, "stable branch does not exist");
+            console.log(`Repo: ${repoPath}`);
+            process.exit(1);
+        }
+        successProgress(spinner, `Checking Repo: ${repositoryPackageJson.name} Finished`);
+    }
+    catch (error) {
+        console.error("Error while committing changes:", error.message);
+        // Handle edge case where the repository might have conflicting changes
+        if (error.message.includes("CONFLICT")) {
+            console.error("Merge conflict detected. Please resolve conflicts manually.");
+        }
+    }
+};
+const runDeployCommand = async (repoPath) => {
+    try {
+        const repositoryPackageJsonPath = join(repoPath, "package.json");
+        if (!fs.existsSync(repositoryPackageJsonPath)) {
+            console.log("repositoryPackageJsonPath does not exist");
+            console.log({ repoPath });
+            return;
+        }
+        const repositoryPackageJson = JSON.parse(fs.readFileSync(repositoryPackageJsonPath, "utf8"));
+        if (!repositoryPackageJson.name) {
+            console.log("repositoryPackageJson.name does not exist");
+            console.log({ repoPath });
+            return;
+        }
+        if (!repositoryPackageJson.scripts?.deploy) {
+            console.log("deploy script does not exist, skipping....");
+            console.log({ repoPath });
+            return;
+        }
+        const spinner = startProgress(`Deploying: ${repositoryPackageJson.name}`);
+        try {
+            execSync("npm run deploy", { cwd: repoPath, stdio: "pipe" });
+            successProgress(spinner, `Deployment successful: ${repositoryPackageJson.name}`);
+        }
+        catch (error) {
+            failProgress(spinner, `Deployment failed: ${repositoryPackageJson.name}`);
+            throw error;
+        }
+    }
+    catch (error) {
+        console.error(`Deployment failed for ${repoPath}`, error);
+    }
+};
+export const deployAllRepos = async () => {
+    console.log("------------deployAll Started-------------");
+    try {
+        const allPaths = getAllPaths();
+        if (allPaths.length === 0) {
+            console.log("No valid repositories found. Exiting.");
+            return;
+        }
+        const progress = createMultiProgress();
+        progress.start("Starting repository checks");
+        progress.setTotal(allPaths.length);
+        // First check all repos
+        for (const repoPath of allPaths) {
+            try {
+                await checkRepo(repoPath);
+                progress.incrementCompleted();
+            }
+            catch (error) {
+                progress.incrementFailed();
+                console.error(`Error checking repository: ${repoPath}`, error);
+            }
+        }
+        progress.complete("Repository checks completed");
+        // Then deploy all repos
+        const deployProgress = createMultiProgress();
+        deployProgress.start("Starting deployments");
+        deployProgress.setTotal(allPaths.length);
+        for (const repoPath of allPaths) {
+            try {
+                await runDeployCommand(repoPath);
+                deployProgress.incrementCompleted();
+            }
+            catch (error) {
+                deployProgress.incrementFailed();
+                console.error(`Error deploying repository: ${repoPath}`, error);
+            }
+        }
+        deployProgress.complete("Deployments completed");
+    }
+    catch (error) {
+        console.log(error);
+    }
+    console.log("------------deployAll Ended-------------");
+};
+// if (isDeveloperAdarsh) {
+//     deployAllRepos();
+// } else {
+//     console.log("This command can only be run by authorized developers.");
+// }

package/dist/cli/fixConfigFile.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Fixes JSON files by adding double quotes to keys and removing trailing commas
+ * @param filePath - Optional custom path to the JSON file to fix
+ */
+export declare function fixConfigFile(filePath?: string): Promise<void>;

package/dist/cli/fixConfigFile.js

@@ -0,0 +1,76 @@
+import fs from "fs";
+import path from "path";
+import { clientRootDirPath } from "../utils/path.js";
+import { cleanTrailingCommas } from "../utils/jsonFile.js";
+/**
+ * Fixes JSON files by adding double quotes to keys and removing trailing commas
+ * @param filePath - Optional custom path to the JSON file to fix
+ */
+export async function fixConfigFile(filePath) {
+    // Default to nbk.config.json if no path is provided
+    const configPath = filePath
+        ? path.resolve(filePath)
+        : path.join(clientRootDirPath, "nbk.config.json");
+    // Check if the JSON file exists
+    if (!fs.existsSync(configPath)) {
+        console.error(`File not found: ${configPath}`);
+        return;
+    }
+    try {
+        // Read the config file
+        const configContent = fs.readFileSync(configPath, "utf8");
+        // Fix unquoted keys and trailing commas
+        const fixedContent = fixJsonString(configContent);
+        // Write the fixed content back to the file
+        fs.writeFileSync(configPath, fixedContent);
+        // Verify the fixed JSON is valid
+        try {
+            JSON.parse(fixedContent);
+            console.log(`Successfully fixed: ${configPath}`);
+        }
+        catch (parseError) {
+            console.warn(`Warning: The fixed JSON might still have issues. Manual review recommended.`);
+            console.log(`Applied automatic fixes to: ${configPath}`);
+        }
+    }
+    catch (error) {
+        console.error(`Failed to fix ${configPath}:`, error);
+    }
+}
+/**
+ * Comprehensive fixing of JSON string issues
+ * @param jsonString - The potentially malformed JSON string
+ * @returns Fixed JSON string
+ */
+function fixJsonString(jsonString) {
+    // Step 1: Strip comments (using existing utility)
+    let fixedJson = jsonString;
+    // Step 2: Add double quotes to unquoted keys
+    // This regex handles various cases of unquoted keys
+    fixedJson = fixedJson.replace(/([{,]\s*)([a-zA-Z0-9_$]+)(\s*:)/g, '$1"$2"$3');
+    // Step 3: Fix single-quoted keys to double-quoted keys
+    fixedJson = fixedJson.replace(/([{,]\s*)'([^']+)'(\s*:)/g, '$1"$2"$3');
+    // Step 4: Remove trailing commas
+    fixedJson = cleanTrailingCommas(fixedJson);
+    // Step 5: Add missing commas between properties
+    fixedJson = fixedJson.replace(/("[^"]+"\s*:\s*[^,{[\s][^,{[}]*[^,\s])\s*("[^"]+"\s*:)/g, "$1,$2");
+    // Step 6: Ensure properly formatted JSON
+    fixedJson = formatJson(fixedJson);
+    return fixedJson;
+}
+/**
+ * Attempts to format the JSON string with proper indentation
+ * @param jsonString - The JSON string to format
+ * @returns Formatted JSON string
+ */
+function formatJson(jsonString) {
+    try {
+        // Try to parse and format the JSON
+        const parsed = JSON.parse(jsonString);
+        return JSON.stringify(parsed, null, 2);
+    }
+    catch (error) {
+        // If parsing fails, return the original string with basic fixes
+        return jsonString;
+    }
+}

package/dist/cli/gitAcpAllRepos.d.ts

@@ -0,0 +1 @@
+export declare const gitAcpAllRepos: () => Promise<void>;

package/dist/cli/gitAcpAllRepos.js

@@ -0,0 +1,156 @@
+import fs from "fs";
+import { join } from "path";
+import path from "path";
+import readline from "node:readline";
+import { clientRootDirPath } from "../utils/path.js";
+import { simpleGit } from "simple-git";
+import { loadConfig } from "../utils/loadConfig.js";
+import { createMultiProgress, failProgress, startProgress, successProgress, updateProgress, } from "../utils/progress.js";
+const getAllPaths = () => {
+    try {
+        // Load projects from the configuration file
+        const config = loadConfig();
+        // Export projects for use in CLI tools
+        let b2fPortalProjects = config.projects;
+        const allPaths = [];
+        allPaths.push(clientRootDirPath);
+        for (const project of b2fPortalProjects) {
+            if (project.sharedBackendPath) {
+                const sharedBackendPath = join(clientRootDirPath, project.sharedBackendPath);
+                if (!fs.existsSync(sharedBackendPath)) {
+                    console.log("sharedBackendPath does not exist");
+                    console.log({ sharedBackendPath });
+                    return [];
+                }
+                allPaths.push(sharedBackendPath);
+            }
+            for (const section of project.sections) {
+                if (section.repository.path) {
+                    const repositoryPath = join(clientRootDirPath, section.repository.path);
+                    if (!fs.existsSync(repositoryPath)) {
+                        console.log("repositoryPath does not exist");
+                        console.log({ repositoryPath });
+                        return [];
+                    }
+                    allPaths.push(repositoryPath);
+                }
+            }
+        }
+        return allPaths;
+    }
+    catch (error) {
+        console.log(error);
+        return [];
+    }
+};
+const runAcpCommands = async (repoPath, message) => {
+    try {
+        const repositoryPackageJsonPath = join(repoPath, "package.json");
+        if (!fs.existsSync(repositoryPackageJsonPath)) {
+            console.log("repositoryPackageJsonPath does not exist");
+            console.log({ repositoryPackageJsonPath });
+            return;
+        }
+        const repositoryPackageJson = JSON.parse(fs.readFileSync(repositoryPackageJsonPath, "utf8"));
+        if (!repositoryPackageJson.name) {
+            console.log("repositoryPackageJson.name does not exist");
+            console.log({ repositoryPackageJson });
+            return;
+        }
+        const spinner = startProgress(`Running ACP in ${repositoryPackageJson.name}`);
+        const options = {
+            baseDir: path.resolve(repoPath),
+            binary: "git",
+            maxConcurrentProcesses: 6,
+        };
+        const git = simpleGit(options);
+        updateProgress(spinner, `${repositoryPackageJson.name}: fetching ...`);
+        await git.fetch();
+        updateProgress(spinner, `${repositoryPackageJson.name}: Checking status ...`);
+        let status = await git.status();
+        // Save the current branch name
+        const currentBranch = status.current;
+        // console.log(currentBranch);
+        if (currentBranch !== "main") {
+            failProgress(spinner, `Current branch is ${currentBranch}, but it should be main.`);
+            console.log(`Repo: ${repoPath}`);
+            process.exit(1);
+        }
+        if (status.files.length > 0) {
+            updateProgress(spinner, `${repositoryPackageJson.name}: Adding files ...`);
+            await git.add(".");
+            updateProgress(spinner, `${repositoryPackageJson.name}: Committing changes ...`);
+            await git.commit(message);
+        }
+        updateProgress(spinner, `${repositoryPackageJson.name}: pulling ...`);
+        await git.pull();
+        updateProgress(spinner, `${repositoryPackageJson.name}: Checking status ...`);
+        status = await git.status();
+        // Check for new uncommitted changes after pulling
+        if (status.files.length > 0) {
+            updateProgress(spinner, `${repositoryPackageJson.name}: Adding files after pull ...`);
+            await git.add(".");
+            updateProgress(spinner, `${repositoryPackageJson.name}: Committing changes after pull ...`);
+            await git.commit(message);
+        }
+        updateProgress(spinner, `${repositoryPackageJson.name}: pushing ...`);
+        await git.push();
+        successProgress(spinner, `Running ACP in ${repositoryPackageJson.name} Finished`);
+    }
+    catch (error) {
+        console.error("Error while committing changes:", error.message);
+        // Handle edge case where the repository might have conflicting changes
+        if (error.message.includes("CONFLICT")) {
+            console.error("Merge conflict detected. Please resolve conflicts manually.");
+        }
+    }
+};
+export const gitAcpAllRepos = async () => {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    function askQuestion(query) {
+        return new Promise((resolve) => {
+            rl.question(query, (answer) => {
+                resolve(answer);
+            });
+        });
+    }
+    try {
+        let commitMessage = await askQuestion("Enter Commit Message: ");
+        rl.close();
+        if (commitMessage.trim() === "") {
+            commitMessage = "Git Acp All Repos";
+        }
+        console.log("------------gitAcpAllRepos Started-------------");
+        const allPaths = getAllPaths();
+        if (allPaths.length === 0) {
+            console.log("No valid repositories found. Exiting.");
+            return;
+        }
+        const progress = createMultiProgress();
+        progress.start("Processing repositories");
+        progress.setTotal(allPaths.length);
+        for (const repoPath of allPaths) {
+            try {
+                await runAcpCommands(repoPath, `${new Date().toLocaleString()} : ${commitMessage}`);
+                progress.incrementCompleted();
+            }
+            catch (error) {
+                progress.incrementFailed();
+                console.error(`Error processing repository: ${repoPath}`, error);
+            }
+        }
+        progress.complete();
+        console.log("------------gitAcpAllRepos Ended-------------");
+    }
+    catch (error) {
+        console.log(error);
+    }
+};
+// if (isDeveloperAdarsh) {
+//     gitAcpAllRepos();
+// } else {
+//     console.log("This command can only be run by authorized developers.");
+// }

package/dist/cli/gitPushAllRepos.d.ts

@@ -0,0 +1 @@
+export declare function gitPushAllRepos(): Promise<void>;

package/dist/cli/gitPushAllRepos.js

@@ -0,0 +1,70 @@
+import path from "path";
+import { join } from "path";
+import { simpleGit } from "simple-git";
+import { clientRootDirPath } from "../utils/path.js";
+import dotenv from "dotenv";
+import { isDeveloperAdarsh } from "../configs/environment.js";
+import { loadConfig } from "../utils/loadConfig.js";
+dotenv.config();
+async function commitB2fPortalChanges(repoPath) {
+    const options = {
+        baseDir: path.resolve(repoPath),
+        binary: "git",
+        maxConcurrentProcesses: 6,
+    };
+    const git = simpleGit(options);
+    try {
+        // Fetch the status of the repo
+        const status = await git.status();
+        const b2fPortalChanges = status.files.some((file) => file.path.startsWith("b2fPortal/"));
+        if (!b2fPortalChanges) {
+            console.log(`No changes detected in the b2fPortal directory. Skipping commit.`);
+            return;
+        }
+        // Save the current branch name
+        const currentBranch = status.current;
+        if (currentBranch !== "main") {
+            console.error(`Current branch is ${currentBranch}, but it should be main.`);
+            process.exit(1);
+        }
+        // Pull the latest changes
+        await git.pull();
+        // Add only the b2fPortal folder
+        await git.add("b2fPortal/*");
+        // Commit with the current date and time
+        const currentDate = new Date().toLocaleString();
+        const commitMessage = `${currentDate} backend portal updated`;
+        await git.commit(commitMessage);
+        // Push the commit to the main branch
+        await git.push("origin", "main");
+        console.log("Changes committed and pushed successfully");
+    }
+    catch (error) {
+        console.error("Error while committing changes:", error.message);
+        // Handle edge case where the repository might have conflicting changes
+        if (error.message.includes("CONFLICT")) {
+            console.error("Merge conflict detected. Please resolve conflicts manually.");
+        }
+    }
+}
+export async function gitPushAllRepos() {
+    // Load projects from the configuration file
+    const config = loadConfig();
+    // Export projects for use in CLI tools
+    let b2fPortalProjects = config.projects;
+    for (const project of b2fPortalProjects) {
+        for (const section of project.sections) {
+            if (isDeveloperAdarsh) {
+                const repositoryPath = join(clientRootDirPath, section.repository.path);
+                console.log(`\n----------------${section.repository.name} started----------------`);
+                await commitB2fPortalChanges(repositoryPath);
+                console.log(`----------------${section.repository.name} finished----------------\n`);
+            }
+        }
+    }
+}
+// if (isDeveloperAdarsh) {
+//     gitPushAllRepos();
+// } else {
+//     console.log("This command can only be run by authorized developers.");
+// }

package/dist/cli/initConfig.d.ts

@@ -0,0 +1 @@
+export declare function initConfig(): Promise<void>;

package/dist/cli/initConfig.js

@@ -0,0 +1,23 @@
+import fs from "fs";
+import path from "path";
+import { clientRootDirPath } from "../utils/path.js";
+import { updateVSCodeSettings } from "../utils/vscodeSettings.js";
+export async function initConfig() {
+    const configPath = path.join(clientRootDirPath, "nbk.config.json");
+    // Check if nbk.config.json already exists
+    if (fs.existsSync(configPath)) {
+        console.log("nbk.config.json already exists in the project root.");
+    }
+    else {
+        // Create nbk.config.json with default configuration
+        const defaultConfig = {
+            b2fPortal: true,
+            checkCrossProjectImports: true,
+            projects: [],
+        };
+        fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2));
+        console.log("Created nbk.config.json with default configuration in the project root.");
+    }
+    // Update VSCode settings
+    updateVSCodeSettings();
+}

package/dist/cli/transfer2Shared.d.ts

@@ -0,0 +1 @@
+export declare const transfer2Shared: () => Promise<void>;