@digicroz/node-backend-kit 1.0.0

package/README.md

@@ -0,0 +1,255 @@
+# Primexop Backend Kit (NBK) 🚀
+
+[![npm version](https://badge.fury.io/js/%40primexop%2Fnbk.svg)](https://badge.fury.io/js/%40primexop%2Fnbk)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.8.3-blue.svg)](https://www.typescriptlang.org/)
+[![Node.js](https://img.shields.io/badge/Node.js-%3E%3D16.0.0-green.svg)](https://nodejs.org/)
+
+> A powerful TypeScript utility for managing backend projects with features like B2F Portal integration, cross-project validation, and Next.js support.
+
+## 📦 Features
+
+- 🔧 Project configuration management with TypeScript support
+- 🌐 B2F Portal integration support
+- 🔍 Cross-project import validation
+- 💻 VSCode integration with JSON schema validation
+- 🛠️ CLI tools for project management
+- ⚡ Next.js patch support for specific sections
+- 🔄 Shared backend path configuration
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+npm install @digicroz/node-backend-kit --save-dev
+```
+
+### Basic Usage
+
+```typescript
+import { nbkInit } from "@digicroz/node-backend-kit"
+
+// Initialize with default config path (nbk.config.json in current directory)
+const config = nbkInit()
+
+// Or specify a custom config path
+const config = nbkInit({ configPath: "./custom/path/config.json" })
+```
+
+## 📋 Requirements
+
+- Node.js >= 16.0.0
+- TypeScript >= 5.8.3
+
+## ⚙️ Configuration
+
+Create a `nbk.config.json` file in your project root:
+
+```json
+{
+  "projects": [
+    {
+      "projectName": "My Project",
+      "projectBaseDirPath": "/path/to/project",
+      "sharedBackendPath": "/path/to/shared-backend",
+      "sections": [
+        {
+          "sectionName": "API",
+          "repository": {
+            "name": "my-api",
+            "path": "https://github.com/organization/my-api"
+          },
+          "localPath": "/path/to/api",
+          "isZodCreator": true,
+          "needNextJsPatch": false
+        }
+      ]
+    }
+  ],
+  "b2fPortal": false,
+  "checkCrossProjectImports": true
+}
+```
+
+### 📝 Configuration Options
+
+#### Project Configuration
+
+- `projectName`: Name of your project
+- `projectBaseDirPath`: Base directory path for the project
+- `sharedBackendPath`: (Optional) Path to shared backend code
+- `sections`: Array of project sections
+
+#### Section Configuration
+
+- `sectionName`: Name of the section
+- `repository`: Repository information
+  - `name`: Repository name
+  - `path`: Repository URL
+- `localPath`: Local path where the section code resides
+- `isZodCreator`: Whether the section uses Zod for validation
+- `needNextJsPatch`: (Optional) Whether the section needs Next.js patch
+
+#### Global Configuration
+
+- `b2fPortal`: Enable/disable B2F Portal integration
+- `checkCrossProjectImports`: Enable/disable cross-project import validation
+
+## 🔧 VSCode Integration
+
+This package includes JSON schema validation for your configuration file. To enable auto-completion and validation in VSCode:
+
+1. Install the "JSON Language Support" extension in VSCode
+2. Add this to your VSCode settings.json:
+
+```json
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["nbk.config.json"],
+      "url": "./node_modules/@digicroz/node-backend-kit/nbk.schema.json"
+    }
+  ],
+  "files.associations": {
+    "nbk.config.json": "jsonc"
+  }
+}
+```
+
+### 💡 Benefits
+
+- ✨ Auto-completion for all available options
+- ✅ Validation to ensure your configuration is correct
+- 📚 Hover documentation for each field
+- ⚠️ Error highlighting for invalid configurations
+
+## 🚀 Features in Detail
+
+### B2F Portal Integration
+
+When `b2fPortal` is set to `true` in the configuration, the kit will initialize B2F Portal specific features.
+
+### Cross-Project Import Validation
+
+When `checkCrossProjectImports` is enabled, the kit will validate imports between different projects to ensure proper dependency management.
+
+### Next.js Patch Support
+
+Sections can be configured with `needNextJsPatch: true` to apply Next.js specific patches.
+
+## 🛠️ CLI Commands
+
+NBK comes with several CLI commands to help you manage your projects:
+
+```bash
+# Initialize a nbk.config.json file
+npx @digicroz/node-backend-kit init
+
+# Fix JSON file formatting
+npx @digicroz/node-backend-kit fix-config-file
+
+# Delete b2fPortal directory in all repositories
+npx @digicroz/node-backend-kit delete-all-repos
+
+# Deploy all repositories
+npx @digicroz/node-backend-kit deploy-all-repos
+
+# Add, commit, and push changes in all repositories
+npx @digicroz/node-backend-kit git-acp-all-repos
+
+# Push b2fPortal changes in all repositories
+npx @digicroz/node-backend-kit git-push-all-repos
+
+# Transfer project files to shared backend repositories
+npx @digicroz/node-backend-kit transfer-2-shared
+
+# Create a shell script to initialize workspaces
+npx @digicroz/node-backend-kit create-init-workspace-shell-file
+
+# Update package.json to use local development version
+npx @digicroz/node-backend-kit add-dev-version
+
+# Update package.json to use published production version
+npx @digicroz/node-backend-kit add-prod-version
+```
+
+### Development and Production Versioning
+
+NBK provides commands to easily switch between development and production versions:
+
+- `add-dev-version` updates your project to use the local development version from `C:/primexopRepos/nbk`
+- `add-prod-version` reverts back to using the published npm version (latest by default)
+
+Examples:
+
+```bash
+# Switch to local development version
+npx @digicroz/node-backend-kit add-dev-version
+
+# Switch back to latest published version
+npx @digicroz/node-backend-kit add-prod-version
+
+# Switch to a specific published version
+npx @digicroz/node-backend-kit add-prod-version --version "1.0.7"
+
+# Apply to a different directory
+npx @digicroz/node-backend-kit add-prod-version --dir ../other-project
+```
+
+### Workspace Initialization Script
+
+The `create-init-workspace-shell-file` command generates a shell script (`initWorkspace.sh`) that helps you:
+
+- Select your preferred editor (VSCode, Cursor, or Trae)
+- Open all your project directories in the selected editor
+- Navigate between project sections easily
+
+After generating the script, make it executable:
+
+```bash
+chmod +x initWorkspace.sh
+```
+
+Then run it:
+
+```bash
+./initWorkspace.sh
+```
+
+## 👩‍💻 Development
+
+### Available Scripts
+
+- `npm run dev` - Start development mode with watch
+- `npm run build` - Build the project
+- `npm test` - Run tests
+- `npm run test:watch` - Run tests in watch mode
+- `npm run lint` - Run TypeScript type checking
+- `npm run clean` - Clean build artifacts
+- `npm run release:patch` - Release a patch version
+
+### Project Structure
+
+```
+src/
+├── bin/           # CLI entry points
+├── cli/           # CLI command implementations
+├── configs/       # Configuration related code
+├── helpers/       # Helper functions
+├── utils/         # Utility functions
+├── b2fPortalV3/   # B2F Portal specific implementations
+└── types.ts       # TypeScript type definitions
+```
+
+## 📄 License
+
+ISC
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 📞 Support
+
+For support, please open an issue in the [GitHub repository](https://github.com/AdarshHatkar/nbk/issues).

package/dist/b2fPortalV3/b2fPortal.d.ts

@@ -0,0 +1,2 @@
+import { TNbkProject } from "../types.js";
+export declare const b2fPortalInit: (b2fPortalProjects: TNbkProject[]) => Promise<void>;

package/dist/b2fPortalV3/b2fPortal.js

@@ -0,0 +1,199 @@
+import fs from "fs";
+import { join } from "path";
+import { createZodFiles } from "./moduleZodCreator.js";
+import { syncFilesAndFolders } from "./syncProjectCommons.js";
+import { createModuleFiles } from "./moduleFileCreator.js";
+import { checkModuleRecords } from "./checkModuleRecords.js";
+import { checkModuleZodRecords } from "./checkModuleZodRecords.js";
+import { getTsFiles, updateImports } from "./stripExtensions.js";
+export const b2fPortalInit = async (b2fPortalProjects) => {
+    console.log("------------nbk Started-------------");
+    let clientRootDirPath = process.cwd();
+    //    console.log({clientRootDirPath});
+    const srcDirPath = join(clientRootDirPath, "src");
+    const distDirPath = join(clientRootDirPath, "dist");
+    for (const project of b2fPortalProjects) {
+        const serverB2fPath = join(srcDirPath, "serverB2f");
+        // console.log('serverB2fPath', serverB2fPath);
+        if (!fs.existsSync(serverB2fPath)) {
+            console.log("serverB2fPath does not exist");
+            console.log({ serverB2fPath });
+            return;
+        }
+        const projectSrcPath = join(srcDirPath, project.projectBaseDirPath);
+        // console.log('projectSrcpath', projectSrcPath);
+        if (!fs.existsSync(projectSrcPath)) {
+            console.log("projectSrcPath does not exist");
+            console.log({ projectSrcPath });
+            return;
+        }
+        const projectDistPath = join(distDirPath, project.projectBaseDirPath);
+        // console.log('projectDistPath', projectDistPath);
+        if (!fs.existsSync(projectDistPath)) {
+            console.log("projectDistPath does not exist");
+            console.log({ projectDistPath });
+            return;
+        }
+        const projectPrismaClientPath = join(clientRootDirPath, "prisma", project.projectName, "generatedClient");
+        if (!fs.existsSync(projectPrismaClientPath)) {
+            console.log("projectPrismaClientPath does not exist");
+            console.log({ projectPrismaClientPath });
+            return;
+        }
+        const projectB2fPath = join(projectSrcPath, "projectB2f");
+        if (!fs.existsSync(projectB2fPath)) {
+            console.log("projectB2fPath does not exist");
+            console.log({ projectB2fPath });
+            return;
+        }
+        if (project.sections.length === 0) {
+            console.log("no sections in " + project.projectName);
+            return;
+        }
+        for (const section of project.sections) {
+            const sectionSrcPath = join(projectSrcPath, section.localPath);
+            const sectionDistPath = join(projectDistPath, section.localPath);
+            if (!fs.existsSync(sectionSrcPath)) {
+                console.log("sectionSrcPath does not exist");
+                console.log({ sectionSrcPath });
+                return;
+            }
+            if (!fs.existsSync(sectionDistPath)) {
+                console.log("sectionDistPath does not exist");
+                console.log({ sectionDistPath });
+                return;
+            }
+            const sectionB2fPath = join(sectionSrcPath, "sectionB2f");
+            if (!fs.existsSync(sectionB2fPath)) {
+                console.log("sectionB2fPath does not exist");
+                console.log({ sectionB2fPath });
+                return;
+            }
+            const sectionSrcTrpcApiPath = join(sectionSrcPath, "trpcApi");
+            if (!fs.existsSync(sectionSrcTrpcApiPath)) {
+                console.log("sectionSrcTrpcApiPath does not exist");
+                console.log({ sectionSrcTrpcApiPath });
+                return;
+            }
+            const sectionSrcTrpcApiModulePath = join(sectionSrcTrpcApiPath, "modules");
+            if (!fs.existsSync(sectionSrcTrpcApiModulePath)) {
+                console.log("sectionSrcTrpcApiModulePath does not exist");
+                console.log({ sectionSrcTrpcApiModulePath });
+                return;
+            }
+            const sectionDistTrpcApiPath = join(sectionDistPath, "trpcApi");
+            // console.log('sectionDistTrpcApiPath', sectionDistTrpcApiPath);
+            if (!fs.existsSync(sectionDistTrpcApiPath)) {
+                console.log("sectionDistTrpcApiPath does not exist");
+                console.log({ sectionDistTrpcApiPath });
+                return;
+            }
+            const sectionTrpcRouterTypesDeclarationPath = join(sectionDistPath, "trpcApi", "trpcRouter.d.ts");
+            if (!fs.existsSync(sectionTrpcRouterTypesDeclarationPath)) {
+                console.log("sectionTrpcRouterTypesDeclarationPath does not exist");
+                console.log({ sectionTrpcRouterTypesDeclarationPath });
+                return;
+            }
+            const repositoryPath = join(clientRootDirPath, section.repository.path);
+            if (!fs.existsSync(repositoryPath)) {
+                console.log("repositoryPath does not exist");
+                console.log({ repositoryPath });
+                return;
+            }
+            if (!fs.existsSync(join(repositoryPath, ".git"))) {
+                console.log("repositoryPath does not have .git");
+                console.log({ repositoryPath });
+                return;
+            }
+            const repositoryPackageJsonPath = join(repositoryPath, "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;
+            }
+            if (repositoryPackageJson.name !== section.repository.name) {
+                console.log("repositoryPackageJson.name does not match ");
+                console.log({
+                    requiredName: section.repository.name,
+                    repositoryName: repositoryPackageJson.name,
+                });
+                return;
+            }
+            const repositoryBackedPortalPath = join(repositoryPath, "b2fPortal");
+            if (!fs.existsSync(repositoryBackedPortalPath)) {
+                console.log("repositoryBackedPortalPath does not exist");
+                console.log({ repositoryBackedPortalPath });
+                return;
+            }
+            const repositoryDistTrpcApiPath = join(repositoryBackedPortalPath, sectionDistTrpcApiPath.replace(clientRootDirPath, ""));
+            const repositoryPrismaClientPath = join(repositoryBackedPortalPath, projectPrismaClientPath.replace(clientRootDirPath, ""));
+            createModuleFiles(sectionSrcTrpcApiModulePath);
+            // create zod files
+            createZodFiles(sectionSrcTrpcApiModulePath);
+            // check trpcRouterRecords and zodSchemas
+            try {
+                checkModuleRecords(sectionSrcTrpcApiPath);
+                checkModuleZodRecords(sectionSrcTrpcApiPath);
+            }
+            catch (error) {
+                console.warn(error);
+            }
+            // sync serverB2f
+            const repositoryServerB2fPath = join(repositoryBackedPortalPath, "serverB2f");
+            await syncFilesAndFolders({
+                sourceDirPath: serverB2fPath,
+                targetDirPath: repositoryServerB2fPath,
+            });
+            // sync projectB2f
+            const repositoryProjectB2fPath = join(repositoryBackedPortalPath, "projectB2f");
+            await syncFilesAndFolders({
+                sourceDirPath: projectB2fPath,
+                targetDirPath: repositoryProjectB2fPath,
+            });
+            // sync section common
+            const repositorySectionB2fPath = join(repositoryBackedPortalPath, section.sectionName, "sectionB2f");
+            await syncFilesAndFolders({
+                sourceDirPath: sectionB2fPath,
+                targetDirPath: repositorySectionB2fPath,
+            });
+            // sync zod schemas
+            const repositoryTrpcApiPath = join(repositoryBackedPortalPath, section.sectionName, "trpcApi");
+            await syncFilesAndFolders({
+                sourceDirPath: sectionSrcTrpcApiPath,
+                targetDirPath: repositoryTrpcApiPath,
+                fileNamePatterns: ["Zod", "zodSchemas"],
+            });
+            await syncFilesAndFolders({
+                sourceDirPath: sectionDistTrpcApiPath,
+                targetDirPath: repositoryDistTrpcApiPath,
+                fileNamePatterns: ["trpcRouter.d.ts"],
+            });
+            await syncFilesAndFolders({
+                sourceDirPath: projectPrismaClientPath,
+                targetDirPath: repositoryPrismaClientPath,
+                fileNamePatterns: [
+                    // "index.js",
+                    // "index.d.ts",
+                    // "library.js",
+                    // "library.d.ts",
+                    ".d.ts",
+                ],
+            });
+            if (section.needNextJsPatch) {
+                // console.log("Next Js Patch started");
+                const tsFiles = getTsFiles(repositoryBackedPortalPath);
+                tsFiles.forEach((filePath) => {
+                    updateImports(filePath);
+                });
+                // console.log("Next Js Patch completed");
+            }
+        }
+    }
+    console.log("------------nbk  finished-------------");
+};

package/dist/b2fPortalV3/checkModuleRecords.d.ts

@@ -0,0 +1 @@
+export declare const checkModuleRecords: (baseDir: string) => void;

package/dist/b2fPortalV3/checkModuleRecords.js

@@ -0,0 +1,60 @@
+import fs from "fs";
+import path from "path";
+// Recursively checks if all internal modules have correct entries in their parent router file
+const checkSubModules = (parentModuleDir, parentRouterFile) => {
+    const subItems = fs.readdirSync(parentModuleDir);
+    subItems.forEach((item) => {
+        const itemPath = path.join(parentModuleDir, item);
+        if (fs.lstatSync(itemPath).isDirectory()) {
+            // If it's a directory, expect that it has a corresponding .ts file
+            const subModuleRouter = path.join(itemPath, `${item}.ts`);
+            if (fs.existsSync(subModuleRouter)) {
+                // Check that the submodule is included in the parent router file
+                const parentRouterContent = fs.readFileSync(parentRouterFile, "utf-8");
+                const expectedRouteEntry = `${item}: ${item}Routes`;
+                if (!parentRouterContent.includes(expectedRouteEntry)) {
+                    throw new Error(`\n\n ${expectedRouteEntry}, \n\nis missing in ${path.basename(parentRouterFile)}, \n\nPath:${parentRouterFile}\n\n`);
+                }
+                // Recursively check subdirectories
+                checkSubModules(itemPath, subModuleRouter);
+            }
+            else {
+                console.log(`Warning: Expected ${subModuleRouter} not found in ${itemPath}`);
+            }
+        }
+    });
+};
+// Main function to check the first level in trpcRouter.ts and recurse for internal levels
+export const checkModuleRecords = (baseDir) => {
+    const trpcRouterPath = path.join(baseDir, "trpcRouter.ts");
+    // Check if trpcRouter.ts file exists
+    if (!fs.existsSync(trpcRouterPath)) {
+        throw new Error(`Error: trpcRouter.ts file not found in ${baseDir}`);
+    }
+    // Read trpcRouter.ts content
+    const trpcRouterContent = fs.readFileSync(trpcRouterPath, "utf-8");
+    // List of first-level directories inside /modules
+    const modulesPath = path.join(baseDir, "modules");
+    const modules = fs.readdirSync(modulesPath).filter((file) => {
+        const moduleDir = path.join(modulesPath, file);
+        return fs.lstatSync(moduleDir).isDirectory();
+    });
+    // Iterate over first-level modules to check for corresponding entries in trpcRouter.ts
+    for (const moduleName of modules) {
+        const moduleDir = path.join(modulesPath, moduleName);
+        const moduleRouterFile = path.join(moduleDir, `${moduleName}.ts`);
+        // Ensure the first-level module .ts file exists and is in trpcRouter.ts
+        if (fs.existsSync(moduleRouterFile)) {
+            const routeName = `${moduleName}: ${moduleName}Routes`;
+            if (!trpcRouterContent.includes(routeName)) {
+                throw new Error(`\n\n ${routeName}, \n\n is missing in trpcRouter.ts \n\nPath:${trpcRouterPath}\n\n`);
+            }
+            // Recursively check submodules for this first-level module
+            checkSubModules(moduleDir, moduleRouterFile);
+        }
+        else {
+            console.log(`Warning: ${moduleRouterFile} does not exist, skipping check for ${moduleName}`);
+        }
+    }
+    // console.log("All module and sub-module routes are correctly defined.");
+};

package/dist/b2fPortalV3/checkModuleZodRecords.d.ts

@@ -0,0 +1 @@
+export declare const checkModuleZodRecords: (baseDir: string) => void;

package/dist/b2fPortalV3/checkModuleZodRecords.js

@@ -0,0 +1,60 @@
+import fs from "fs";
+import path from "path";
+// Recursively checks if all internal Zod schemas have correct entries in their parent Zod schema file
+const checkSubZodSchemas = (parentModuleDir, parentZodFile) => {
+    const subItems = fs.readdirSync(parentModuleDir);
+    subItems.forEach((item) => {
+        const itemPath = path.join(parentModuleDir, item);
+        if (fs.lstatSync(itemPath).isDirectory()) {
+            // If it's a directory, expect that it has a corresponding Zod schema file
+            const subZodFile = path.join(itemPath, `${item}Zod.ts`);
+            if (fs.existsSync(subZodFile)) {
+                // Check that the submodule's Zod schema is included in the parent Zod file
+                const parentZodContent = fs.readFileSync(parentZodFile, "utf-8");
+                const expectedSchemaEntry = `${item}: ${item}ZodSchema`;
+                if (!parentZodContent.includes(expectedSchemaEntry)) {
+                    throw new Error(`\n\n ${expectedSchemaEntry},\n\nis missing in ${path.basename(parentZodFile)},\n\nPath:${parentZodFile}\n\n`);
+                }
+                // Recursively check subdirectories for further internal schemas
+                checkSubZodSchemas(itemPath, subZodFile);
+            }
+            else {
+                console.log(`Warning: Expected ${subZodFile} not found in ${itemPath}`);
+            }
+        }
+    });
+};
+// Main function to check first-level Zod schemas in zodSchemas.ts and recurse for internal levels
+export const checkModuleZodRecords = (baseDir) => {
+    const zodSchemasPath = path.join(baseDir, "zodSchemas.ts");
+    // Check if zodSchemas.ts file exists
+    if (!fs.existsSync(zodSchemasPath)) {
+        throw new Error(`Error: zodSchemas.ts file not found in ${baseDir}`);
+    }
+    // Read zodSchemas.ts content
+    const zodSchemasContent = fs.readFileSync(zodSchemasPath, "utf-8");
+    // List of first-level directories inside /modules
+    const modulesPath = path.join(baseDir, "modules");
+    const modules = fs.readdirSync(modulesPath).filter((file) => {
+        const moduleDir = path.join(modulesPath, file);
+        return fs.lstatSync(moduleDir).isDirectory();
+    });
+    // Iterate over first-level modules to check for corresponding Zod schemas in zodSchemas.ts
+    for (const moduleName of modules) {
+        const moduleDir = path.join(modulesPath, moduleName);
+        const moduleZodFile = path.join(moduleDir, `${moduleName}Zod.ts`);
+        // Ensure the first-level Zod schema file exists and is in zodSchemas.ts
+        if (fs.existsSync(moduleZodFile)) {
+            const schemaName = `${moduleName}: ${moduleName}ZodSchema`;
+            if (!zodSchemasContent.includes(schemaName)) {
+                throw new Error(`\n\n ${schemaName},\n\n is missing in zodSchemas.ts,\n\nPath:${zodSchemasPath}\n\n`);
+            }
+            // Recursively check submodules for this first-level module
+            checkSubZodSchemas(moduleDir, moduleZodFile);
+        }
+        else {
+            console.log(`Warning: ${moduleZodFile} does not exist, skipping check for ${moduleName}`);
+        }
+    }
+    // console.log("All Zod schema entries are correctly defined.");
+};

package/dist/b2fPortalV3/moduleFileCreator.d.ts

@@ -0,0 +1 @@
+export declare function createModuleFiles(baseDir: string): void;

package/dist/b2fPortalV3/moduleFileCreator.js

@@ -0,0 +1,42 @@
+import * as fs from "fs";
+import * as path from "path";
+// Function to check if a directory contains a .ts file and create it if necessary
+export function createModuleFiles(baseDir) {
+    // Read the contents of the base directory
+    const items = fs.readdirSync(baseDir);
+    // Iterate through each item in the base directory
+    items.forEach((item) => {
+        const itemPath = path.join(baseDir, item);
+        // Check if the item is a directory
+        if (fs.statSync(itemPath).isDirectory()) {
+            const tsFilePath = path.join(itemPath, `${item}.ts`);
+            // Prepare the content
+            const importStatement = ` import { trpcRouter } from` + ` "@global/trpc/trpc.js";`;
+            const fileContent = `\n\n export const ${item}Routes = trpcRouter({});\n`;
+            // Ensure that the directory contains a .ts file with the same name as the directory
+            if (!fs.existsSync(tsFilePath)) {
+                // If the file does not exist, create it with the import and content
+                fs.writeFileSync(tsFilePath, importStatement + fileContent);
+                console.log(`File ${tsFilePath} created with import and default content.`);
+            }
+            else {
+                // Check if the .ts file is empty
+                const fileStats = fs.statSync(tsFilePath);
+                if (fileStats.size === 0) {
+                    // Add the import statement and export function only if the file is empty
+                    fs.writeFileSync(tsFilePath, importStatement + fileContent);
+                    // console.log(
+                    //     `File ${tsFilePath} was empty and import and default content were added.`
+                    // );
+                }
+                else {
+                    // console.log(
+                    //     `File ${tsFilePath} already exists and is not empty. No changes made.`
+                    // );
+                }
+            }
+            // Recursively call the function to check subdirectories
+            createModuleFiles(itemPath);
+        }
+    });
+}

package/dist/b2fPortalV3/moduleZodCreator.d.ts

@@ -0,0 +1 @@
+export declare function createZodFiles(directoryPath: string): void;

package/dist/b2fPortalV3/moduleZodCreator.js

@@ -0,0 +1,41 @@
+import fs from "fs";
+import path from "path";
+export function createZodFiles(directoryPath) {
+    fs.readdir(directoryPath, (err, files) => {
+        if (err) {
+            console.error("Error reading directory:", err);
+            return;
+        }
+        files.forEach((file) => {
+            const filePath = path.join(directoryPath, file);
+            fs.stat(filePath, (err, stats) => {
+                if (err) {
+                    console.error("Error accessing file:", err);
+                    return;
+                }
+                if (stats.isDirectory()) {
+                    // Recursively call for subdirectories
+                    createZodFiles(filePath);
+                }
+                else if (file.endsWith(".ts") && !file.endsWith("Zod.ts")) {
+                    const newFileName = `${path.parse(file).name}Zod.ts`;
+                    const newFilePath = path.join(directoryPath, newFileName);
+                    if (!fs.existsSync(newFilePath)) {
+                        const newData = `export const ${path.parse(file).name}ZodSchema = {\n\t\n};\n`;
+                        fs.writeFile(newFilePath, newData, (err) => {
+                            if (err) {
+                                console.error("Error creating new file:", err);
+                            }
+                            else {
+                                console.log(`Created ${newFileName}`);
+                            }
+                        });
+                    }
+                    else {
+                        // console.log(`${newFileName} already exists, skipping...`);
+                    }
+                }
+            });
+        });
+    });
+}