@digicroz/node-server-kit 1.0.0 → 1.0.3

package/README.md

@@ -162,7 +162,7 @@ npx @digicroz/node-server-kit git-acp-all-repos
 npx @digicroz/node-server-kit git-push-all-repos
 
 # Transfer project files to shared backend repositories
-npx @digicroz/node-server-kit transfer-2-shared
+npx @digicroz/node-server-kit transfer-2-shared [branch]
 
 # Create a shell script to initialize workspaces
 npx @digicroz/node-server-kit create-init-workspace-shell-file

package/dist/b2fPortalV3/b2fPortal.js

@@ -138,7 +138,8 @@ export const b2fPortalInit = async (b2fPortalProjects) => {
                 return;
             }
             const repositoryDistTrpcApiPath = join(repositoryBackedPortalDirPath, sectionDistTrpcApiPath.replace(clientRootDirPath, ""));
-            const repositoryPrismaClientPath = join(repositoryBackedPortalDirPath, projectPrismaClientPath.replace(clientRootDirPath, ""));
+            const repositoryPrismaClientPath = join(repositoryBackedPortalDirPath, "_prisma", "generated-client");
+            // console.log({ repositoryBackedPortalDirPath, repositoryPrismaClientPath })
             // createModuleFiles(sectionSrcTrpcApiRoutesPath)
             // create zod files
             // createZodFiles(sectionSrcTrpcApiRoutesPath)
@@ -194,7 +195,7 @@ export const b2fPortalInit = async (b2fPortalProjects) => {
                     // "index.d.ts",
                     // "library.js",
                     // "library.d.ts",
-                    ".d.ts",
+                    ".ts",
                 ],
             });
             if (section.needNextJsPatch) {

package/dist/b2fPortalV3/syncProjectCommons.js

@@ -6,9 +6,9 @@ import crypto from "node:crypto"; // Added crypto for file hashing
 async function getFileHash(filePath) {
     try {
         const fileBuffer = await fsPromises.readFile(filePath);
-        const hashSum = crypto.createHash('sha1');
+        const hashSum = crypto.createHash("sha1");
         hashSum.update(fileBuffer);
-        return hashSum.digest('hex');
+        return hashSum.digest("hex");
     }
     catch (error) {
         console.error(`Error calculating hash for file ${filePath}:`, error);
@@ -33,7 +33,7 @@ export async function syncFilesAndFolders({ sourceDirPath, targetDirPath, fileNa
         try {
             const fileContent = await fsPromises.readFile(jsonFilePath, "utf8");
             // Handle empty file case
-            if (fileContent.trim() === '') {
+            if (fileContent.trim() === "") {
                 fileDetails = {};
             }
             else {
@@ -53,7 +53,7 @@ export async function syncFilesAndFolders({ sourceDirPath, targetDirPath, fileNa
     else {
         await fsPromises.writeFile(jsonFilePath, "{}");
     }
-    async function updateFileDetails({ fileName, sourceFilePath, mtime, hash }) {
+    async function updateFileDetails({ fileName, sourceFilePath, mtime, hash, }) {
         // const stats = await fsPromises.stat(sourceFilePath);
         fileDetails[fileName] = {
             sourceFilePath,
@@ -102,7 +102,8 @@ export async function syncFilesAndFolders({ sourceDirPath, targetDirPath, fileNa
         else {
             // Check if file matches patterns
             if (fileNamePatterns.length === 0 ||
-                fileNamePatterns.some((pattern) => fileName.includes(pattern))) { // Get source file hash and modified time
+                fileNamePatterns.some((pattern) => fileName.includes(pattern))) {
+                // Get source file hash and modified time
                 let sourceStats;
                 let sourceFileModifiedTime;
                 let sourceFileHash;
@@ -121,10 +122,11 @@ export async function syncFilesAndFolders({ sourceDirPath, targetDirPath, fileNa
                     !fileDetails[fileName] ||
                     !fileDetails[fileName]?.hash || // If hash doesn't exist (backwards compatibility)
                     fileDetails[fileName]?.hash !== sourceFileHash // Primary check: compare file hashes
-                ) { // Copy or replace the file in the target directory
+                ) {
+                    // Copy or replace the file in the target directory
                     try {
                         await fsPromises.copyFile(sourcePath, targetPath);
-                        console.log(`Copied file: ${path.relative(sourceDirPath, sourcePath)}`);
+                        console.log(`Synced file: ${path.relative(sourceDirPath, sourcePath)}`);
                     }
                     catch (error) {
                         console.error(`Error copying file from ${sourcePath} to ${targetPath}:`, error);
@@ -148,7 +150,8 @@ export async function syncFilesAndFolders({ sourceDirPath, targetDirPath, fileNa
             const targetFilePath = path.join(targetDir, fileName);
             // Check if the source file exists
             const sourceExists = fs.existsSync(sourceFilePath);
-            if (!sourceExists) { // Delete the file from the target directory
+            if (!sourceExists) {
+                // Delete the file from the target directory
                 if (fs.existsSync(targetFilePath)) {
                     try {
                         await fsPromises.unlink(targetFilePath);

package/dist/bin/{nbk.js → nsk.js}

@@ -56,8 +56,9 @@ program
 program
     .command("transfer-2-shared")
     .description("Transfer project files to shared backend repositories")
-    .action(async () => {
-    await transfer2Shared();
+    .argument("[branch]", "Shared backend branch name", "main")
+    .action(async (branch) => {
+    await transfer2Shared(branch);
 });
 program
     .command("create-init-workspace-shell-file")

package/dist/cli/deleteAndCopy.js

@@ -1,6 +1,6 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { startProgress, successProgress, failProgress, updateProgress } from '../utils/progress.js';
+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
@@ -31,7 +31,7 @@ export async function deleteAndCopy(sourcePath, targetPath) {
         // 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)}`);
+        successProgress(spinner, `Successfully synced all files from ${path.basename(sourcePath)} to ${path.basename(targetPath)}`);
     }
     catch (error) {
         failProgress(spinner, `Error during deleteAndCopy operation`);

package/dist/cli/transfer2Shared.d.ts

@@ -1 +1 @@
-export declare const transfer2Shared: () => Promise<void>;
+export declare const transfer2Shared: (branchName?: string) => Promise<void>;

package/dist/cli/transfer2Shared.js

@@ -6,7 +6,7 @@ import { simpleGit } from "simple-git";
 import { deleteAndCopy } from "./deleteAndCopy.js";
 import { loadConfig } from "../utils/loadConfig.js";
 import { createMultiProgress, failProgress, startProgress, successProgress, } from "../utils/progress.js";
-export const transfer2Shared = async () => {
+export const transfer2Shared = async (branchName = "main") => {
     // Load projects from the configuration file
     const config = loadConfig();
     // Export projects for use in CLI tools
@@ -32,6 +32,7 @@ export const transfer2Shared = async () => {
         mainSpinner.text = "Pulling latest changes from main repository";
         await myGit.pull();
         successProgress(mainSpinner, "Main repository checked successfully");
+        console.log(`Using shared backend branch: ${branchName}`);
         const repositoryPackageJsonPath = join(clientRootDirPath, "package.json");
         if (!fs.existsSync(repositoryPackageJsonPath)) {
             console.log("repositoryPackageJsonPath does not exist");
@@ -54,11 +55,11 @@ export const transfer2Shared = async () => {
         for (const project of b2fPortalProjects) {
             const projectSpinner = startProgress(`Processing project: ${project.projectName}`);
             try {
-                const serverB2fPath = join(clientSrcDirPath, "serverB2f");
-                // console.log('serverB2fPath', serverB2fPath);
-                if (!fs.existsSync(serverB2fPath)) {
-                    failProgress(projectSpinner, "serverB2fPath does not exist");
-                    console.log({ serverB2fPath });
+                const serverS2cPath = join(clientSrcDirPath, "_server-s2c");
+                // console.log('serverS2cPath', serverS2cPath);
+                if (!fs.existsSync(serverS2cPath)) {
+                    failProgress(projectSpinner, "serverS2cPath does not exist");
+                    console.log({ serverS2cPath: serverS2cPath });
                     projectProgress.incrementFailed(`Failed: ${project.projectName}`);
                     continue;
                 }
@@ -88,63 +89,91 @@ export const transfer2Shared = async () => {
                     projectSpinner.text = `Checking shared backend repository status for project: ${project.projectName}`;
                     const sharedBackendGit = simpleGit(options);
                     let sharedBackendGitStatus = await sharedBackendGit.status();
-                    // Save the current branch name
-                    const currentBranch = sharedBackendGitStatus.current;
-                    // console.log(currentBranch);
-                    if (currentBranch !== "main") {
-                        failProgress(projectSpinner, `Shared backend branch is ${currentBranch}, but it should be main.`);
-                        projectProgress.incrementFailed(`Failed: ${project.projectName}`);
-                        throw new Error(` Shared backend branch is ${currentBranch}, but it should be main.`);
-                    }
-                    projectSpinner.text = `Pulling latest changes from shared backend repository for project: ${project.projectName}`;
-                    await sharedBackendGit.pull();
-                    const sharedProjectSrcPath = join(sharedBackendPath, "src", project.projectBaseDirPath);
-                    // console.log("sharedProjectSrcPath", sharedProjectSrcPath);
-                    if (!fs.existsSync(sharedProjectSrcPath)) {
-                        failProgress(projectSpinner, "sharedProjectSrcPath does not exist");
-                        console.log({ sharedProjectSrcPath });
-                        projectProgress.incrementFailed(`Failed: ${project.projectName}`);
-                        continue;
-                    }
-                    projectSpinner.text = `Copying files for project: ${project.projectName}`;
-                    await deleteAndCopy(projectSrcPath, sharedProjectSrcPath);
-                    projectSpinner.text = `Checking for changes in shared backend repository for project: ${project.projectName}`;
-                    sharedBackendGitStatus = await sharedBackendGit.status();
-                    const sharedBackendChanges = sharedBackendGitStatus.files.some((file) => file.path.startsWith(`src/${project.projectBaseDirPath}/`));
-                    if (!sharedBackendChanges) {
-                        successProgress(projectSpinner, `No changes detected in the sharedBackend directory for project: ${project.projectName}`);
-                        projectProgress.incrementCompleted(`Completed: ${project.projectName} - No changes`);
-                        continue;
-                    }
-                    const repositoryCommitJsonPath = join(sharedBackendPath, "commit.json");
-                    if (!fs.existsSync(repositoryCommitJsonPath)) {
-                        failProgress(projectSpinner, "repositoryCommitJsonPath does not exist");
-                        console.log({ sharedBackendPath });
-                        projectProgress.incrementFailed(`Failed: ${project.projectName}`);
-                        return;
+                    const originalSharedBranch = sharedBackendGitStatus.current;
+                    let branchSwitched = false;
+                    try {
+                        if (branchName !== originalSharedBranch) {
+                            projectSpinner.text = `Checking out branch ${branchName} in shared backend repository for project: ${project.projectName}`;
+                            await sharedBackendGit.fetch();
+                            const branchSummary = await sharedBackendGit.branch(["-a"]);
+                            const branchExistsLocally = Boolean(branchSummary.branches[branchName]);
+                            const branchExistsRemotely = branchSummary.all.includes(`remotes/origin/${branchName}`);
+                            if (branchExistsLocally) {
+                                await sharedBackendGit.checkout(branchName);
+                                branchSwitched = true;
+                            }
+                            else if (branchExistsRemotely) {
+                                await sharedBackendGit.checkoutBranch(branchName, `origin/${branchName}`);
+                                branchSwitched = true;
+                            }
+                            else if (branchName === "main") {
+                                await sharedBackendGit.checkout("main");
+                                branchSwitched = originalSharedBranch !== "main";
+                            }
+                            else {
+                                failProgress(projectSpinner, `Shared backend branch ${branchName} does not exist locally or on origin.`);
+                                projectProgress.incrementFailed(`Failed: ${project.projectName}`);
+                                continue;
+                            }
+                        }
+                        projectSpinner.text = `Pulling latest changes from shared backend repository for project: ${project.projectName}`;
+                        await sharedBackendGit.pull("origin", branchName);
+                        const sharedProjectSrcPath = join(sharedBackendPath, "src", project.projectBaseDirPath);
+                        // console.log("sharedProjectSrcPath", sharedProjectSrcPath);
+                        if (!fs.existsSync(sharedProjectSrcPath)) {
+                            failProgress(projectSpinner, "sharedProjectSrcPath does not exist");
+                            console.log({ sharedProjectSrcPath });
+                            projectProgress.incrementFailed(`Failed: ${project.projectName}`);
+                            continue;
+                        }
+                        projectSpinner.text = `Copying files for project: ${project.projectName}`;
+                        await deleteAndCopy(projectSrcPath, sharedProjectSrcPath);
+                        projectSpinner.text = `Checking for changes in shared backend repository for project: ${project.projectName}`;
+                        sharedBackendGitStatus = await sharedBackendGit.status();
+                        const sharedBackendChanges = sharedBackendGitStatus.files.some((file) => file.path.startsWith(`src/${project.projectBaseDirPath}/`));
+                        if (!sharedBackendChanges) {
+                            successProgress(projectSpinner, `No changes detected in the sharedBackend directory for project: ${project.projectName}`);
+                            projectProgress.incrementCompleted(`Completed: ${project.projectName} - No changes`);
+                            continue;
+                        }
+                        const repositoryCommitJsonPath = join(sharedBackendPath, "commit.json");
+                        if (!fs.existsSync(repositoryCommitJsonPath)) {
+                            failProgress(projectSpinner, "repositoryCommitJsonPath does not exist");
+                            console.log({ sharedBackendPath });
+                            projectProgress.incrementFailed(`Failed: ${project.projectName}`);
+                            return;
+                        }
+                        const repositoryCommitJson = JSON.parse(fs.readFileSync(repositoryCommitJsonPath, "utf8"));
+                        if (!repositoryCommitJson.last_commit) {
+                            console.log("repositoryCommitJson.last_commit does not exist");
+                            console.log({ clientRootDirPath });
+                        }
+                        const currentDate = new Date().toLocaleString();
+                        // Update last_commit
+                        repositoryCommitJson.last_commit = currentDate;
+                        // Write the updated JSON back to the file
+                        fs.writeFileSync(repositoryCommitJsonPath, JSON.stringify(repositoryCommitJson, null, 4), "utf8");
+                        projectSpinner.text = `Committing changes to shared backend repository for project: ${project.projectName}`;
+                        await sharedBackendGit.add(`commit.json`);
+                        // Add only the b2fPortal folder
+                        await sharedBackendGit.add(`src/${project.projectBaseDirPath}/*`);
+                        // Commit with the current date and time
+                        const commitMessage = `${currentDate} transfer2Shared from ${repositoryPackageJson.name}`;
+                        await sharedBackendGit.commit(commitMessage);
+                        // Push the commit to the branch
+                        projectSpinner.text = `Pushing changes to shared backend repository for project: ${project.projectName}`;
+                        await sharedBackendGit.push("origin", branchName);
+                        successProgress(projectSpinner, `Changes committed and pushed successfully for project: ${project.projectName}`);
+                        projectProgress.incrementCompleted(`Completed: ${project.projectName}`);
                     }
-                    const repositoryCommitJson = JSON.parse(fs.readFileSync(repositoryCommitJsonPath, "utf8"));
-                    if (!repositoryCommitJson.last_commit) {
-                        console.log("repositoryCommitJson.last_commit does not exist");
-                        console.log({ clientRootDirPath });
+                    finally {
+                        if (branchSwitched &&
+                            originalSharedBranch &&
+                            originalSharedBranch !== branchName) {
+                            projectSpinner.text = `Restoring shared backend repository branch to ${originalSharedBranch}`;
+                            await sharedBackendGit.checkout(originalSharedBranch);
+                        }
                     }
-                    const currentDate = new Date().toLocaleString();
-                    // Update last_commit
-                    repositoryCommitJson.last_commit = currentDate;
-                    // Write the updated JSON back to the file
-                    fs.writeFileSync(repositoryCommitJsonPath, JSON.stringify(repositoryCommitJson, null, 4), "utf8");
-                    projectSpinner.text = `Committing changes to shared backend repository for project: ${project.projectName}`;
-                    await sharedBackendGit.add(`commit.json`);
-                    // Add only the b2fPortal folder
-                    await sharedBackendGit.add(`src/${project.projectBaseDirPath}/*`);
-                    // Commit with the current date and time
-                    const commitMessage = `${currentDate} transfer2Shared from ${repositoryPackageJson.name}`;
-                    await sharedBackendGit.commit(commitMessage);
-                    // Push the commit to the main branch
-                    projectSpinner.text = `Pushing changes to shared backend repository for project: ${project.projectName}`;
-                    await sharedBackendGit.push("origin", "main");
-                    successProgress(projectSpinner, `Changes committed and pushed successfully for project: ${project.projectName}`);
-                    projectProgress.incrementCompleted(`Completed: ${project.projectName}`);
                 }
                 else {
                     failProgress(projectSpinner, "sharedBackendPath is not defined");

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@digicroz/node-server-kit",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "NodeJS Backend Kit - A powerful TypeScript utility for managing backend projects with features like B2F Portal integration, cross-project validation, and Next.js support",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "prepare": "husky install",
     "dev": "npm run clean && tsc -w",
     "clean": "rimraf dist && tsc",
     "release:patch": "npm version patch",
@@ -15,7 +14,8 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "tsc --noEmit",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "prepare": "husky"
   },
   "files": [
     "dist",
@@ -77,4 +77,4 @@
     "rimraf": "^6.0.1",
     "simple-git": "^3.27.0"
   }
-}
+}