@digicroz/node-backend-kit 1.0.0

package/dist/cli/transfer2Shared.js

@@ -0,0 +1,180 @@
+import fs from "fs";
+import path from "path";
+import { join } from "path";
+import { clientRootDirPath, clientSrcDirPath } from "../utils/path.js";
+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 () => {
+    // Load projects from the configuration file
+    const config = loadConfig();
+    // Export projects for use in CLI tools
+    let b2fPortalProjects = config.projects;
+    console.log("------------transfer2Shared Started-------------");
+    try {
+        const mainSpinner = startProgress("Checking main repository status");
+        const myGit = simpleGit();
+        const status = await myGit.status();
+        // Save the current branch name
+        const currentBranch = status.current;
+        // console.log(currentBranch);
+        if (currentBranch !== "main") {
+            failProgress(mainSpinner, `Current branch is ${currentBranch}, but it should be main.`);
+            throw new Error(`Current branch is ${currentBranch}, but it should be main.`);
+        }
+        if (status.files.length > 0) {
+            failProgress(mainSpinner, "❌ Uncommitted changes detected");
+            console.log("Commit or stash your changes before proceeding.");
+            process.exit(1);
+        }
+        // Pull the latest changes
+        mainSpinner.text = "Pulling latest changes from main repository";
+        await myGit.pull();
+        successProgress(mainSpinner, "Main repository checked successfully");
+        const repositoryPackageJsonPath = join(clientRootDirPath, "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 (b2fPortalProjects.length === 0) {
+            console.log("No projects found in configuration");
+            return;
+        }
+        const projectProgress = createMultiProgress();
+        projectProgress.start("Processing projects");
+        projectProgress.setTotal(b2fPortalProjects.length);
+        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 });
+                    projectProgress.incrementFailed(`Failed: ${project.projectName}`);
+                    continue;
+                }
+                const projectSrcPath = join(clientSrcDirPath, project.projectBaseDirPath);
+                // console.log("projectSrcpath", projectSrcPath);
+                if (!fs.existsSync(projectSrcPath)) {
+                    failProgress(projectSpinner, "projectSrcPath does not exist");
+                    console.log({ projectSrcPath });
+                    projectProgress.incrementFailed(`Failed: ${project.projectName}`);
+                    continue;
+                }
+                if (project.sharedBackendPath) {
+                    projectSpinner.text = `Checking shared backend path for project: ${project.projectName}`;
+                    const sharedBackendPath = join(clientRootDirPath, project.sharedBackendPath);
+                    // console.log("sharedBackendPath", sharedBackendPath);
+                    if (!fs.existsSync(sharedBackendPath)) {
+                        failProgress(projectSpinner, "sharedBackendPath does not exist");
+                        console.log({ sharedBackendPath });
+                        projectProgress.incrementFailed(`Failed: ${project.projectName}`);
+                        continue;
+                    }
+                    const options = {
+                        baseDir: path.resolve(sharedBackendPath),
+                        binary: "git",
+                        maxConcurrentProcesses: 6,
+                    };
+                    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 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 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");
+                    projectProgress.incrementFailed(`Failed: ${project.projectName}`);
+                    console.error("sharedBackendPath is not defined");
+                    process.exit(1);
+                }
+                if (project.sections.length === 0) {
+                    console.log("no sections in " + project.projectName);
+                }
+            }
+            catch (error) {
+                failProgress(projectSpinner, `Error processing project: ${project.projectName}`);
+                projectProgress.incrementFailed(`Failed: ${project.projectName}`);
+                console.error(`Error processing project ${project.projectName}:`, error);
+            }
+        }
+        projectProgress.complete();
+    }
+    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.");
+        }
+    }
+    console.log("------------transfer2Shared finished-------------");
+};
+// if (isDeveloperAdarsh) {
+//     transfer2Shared();
+// } else {
+//     console.log("This command can only be run by authorized developers.");
+// }

package/dist/configs/environment.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Environment configuration for nbk
+ */
+export declare const isDeveloperAdarsh: boolean;

package/dist/configs/environment.js

@@ -0,0 +1,7 @@
+import dotenv from "dotenv";
+dotenv.config();
+/**
+ * Environment configuration for nbk
+ */
+// Flag to determine if the current user is Adarsh (for restricted operations)
+export const isDeveloperAdarsh = process.env.DEVELOPER_NAME === "adarsh";

package/dist/helpers/checkCrossProjectImports.d.ts

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

package/dist/helpers/checkCrossProjectImports.js

@@ -0,0 +1,73 @@
+import * as fs from "fs";
+import * as path from "path";
+// Helper function to find all .ts files in a directory (including subdirectories)
+async function findTsFilesInDir(directoryPath) {
+    const files = [];
+    const direntArr = await fs.promises.readdir(directoryPath, {
+        withFileTypes: true,
+    });
+    for (const dirent of direntArr) {
+        const fullPath = path.join(directoryPath, dirent.name);
+        if (dirent.isDirectory()) {
+            // Recursively search in subdirectories
+            files.push(...(await findTsFilesInDir(fullPath)));
+        }
+        else if (dirent.isFile() && dirent.name.endsWith(".ts")) {
+            // Add .ts files to the result
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+// Main function to validate project imports
+export async function checkCrossProjectImportsFun(b2fPortalProjects) {
+    console.log("------------checkCrossProjectImports Started-------------");
+    let clientRootDirPath = process.cwd();
+    // Track number of cross-project import violations
+    let crossProjectImportCount = 0;
+    //    console.log({clientRootDirPath});
+    const srcDirPath = path.join(clientRootDirPath, "src");
+    const distDirPath = path.join(clientRootDirPath, "dist");
+    // Collect all project names
+    const projectNames = b2fPortalProjects.map((project) => project.projectName);
+    // Process each project
+    for (const project of b2fPortalProjects) {
+        const projectDir = path.resolve(srcDirPath, project.projectBaseDirPath);
+        // console.log("Project directory:", projectDir);
+        // Find all .ts files in the project directory (including subdirectories)
+        const tsFiles = await findTsFilesInDir(projectDir);
+        // console.log("Found .ts files:", tsFiles);
+        // Process each TypeScript file
+        for (const filePath of tsFiles) {
+            // // console.log("Found file:", filePath); // Log the file being processed
+            const content = await fs.promises.readFile(filePath, "utf-8");
+            // // console.log("File content:", content); // Log the content of the file
+            const importRegex = /import\s+.*?from\s+['"]([^'"]+)['"]/g;
+            let match;
+            while ((match = importRegex.exec(content)) !== null) {
+                const importPath = match[1];
+                // console.log("Import path:", importPath); // Log the import path found
+                // Skip relative imports and external modules
+                if (importPath.startsWith(".") || !importPath.includes("/")) {
+                    continue;
+                }
+                // Check if the import path includes another project's name
+                const isCrossProjectImport = projectNames.some((otherProjectName) => otherProjectName !== project.projectName &&
+                    importPath.includes(otherProjectName));
+                if (isCrossProjectImport) {
+                    crossProjectImportCount++;
+                    console.error(`\n[ERROR] Invalid import detected in project "${project.projectName}":\n` +
+                        `  - File: "${filePath}"\n` +
+                        `  - Import Path: "${importPath}"\n`);
+                }
+            }
+        }
+    }
+    console.log(`------------checkCrossProjectImports Finished-------------`);
+    if (crossProjectImportCount > 0) {
+        console.log(`Found ${crossProjectImportCount} cross-project import violations.`);
+    }
+    else {
+        console.log("No cross-project import violations detected.");
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Main entry point for the package
+ */
+import { TNbkConfig } from "./types.js";
+export declare function greet(name: string): string;
+/**
+ * Initializes the nbk by loading configuration from a JSON file.
+ * This is the primary initialization method for the library.
+ *
+ * @param {Object} options - Initialization options
+ * @param {string} [options.configPath] - Path to the JSON config file (defaults to nbk.config.json in current directory)
+ * @returns {TNbkConfig} The loaded and validated configuration
+ * @throws {Error} If the configuration is invalid or file doesn't exist
+ */
+export declare function nbkInit(options?: {
+    configPath?: string;
+}): Promise<TNbkConfig>;
+export * from "./types.js";

package/dist/index.js

@@ -0,0 +1,47 @@
+/**
+ * Main entry point for the package
+ */
+import * as path from "path";
+import { b2fPortalInit } from "./b2fPortalV3/b2fPortal.js";
+import { checkCrossProjectImportsFun } from "./helpers/checkCrossProjectImports.js";
+import { loadConfig } from "./utils/loadConfig.js";
+export function greet(name) {
+    return `Hello, ${name}!`;
+}
+/**
+ * Initializes the nbk by loading configuration from a JSON file.
+ * This is the primary initialization method for the library.
+ *
+ * @param {Object} options - Initialization options
+ * @param {string} [options.configPath] - Path to the JSON config file (defaults to nbk.config.json in current directory)
+ * @returns {TNbkConfig} The loaded and validated configuration
+ * @throws {Error} If the configuration is invalid or file doesn't exist
+ */
+export async function nbkInit(options = {}) {
+    // Set default options
+    const { configPath = path.join(process.cwd(), "nbk.config.json") } = options;
+    try {
+        // Load and validate config
+        const config = loadConfig(configPath);
+        if (!config) {
+            return {};
+        }
+        console.log(`Successfully loaded configuration with ${config.projects.length} projects`);
+        // Initialize features based on config flags
+        if (config.b2fPortal) {
+            await b2fPortalInit(config.projects);
+        }
+        if (config.checkCrossProjectImports) {
+            await checkCrossProjectImportsFun(config.projects);
+        }
+        return config;
+    }
+    catch (error) {
+        console.error("Failed to initialize nbk:", error);
+        throw error;
+    }
+}
+// When using ES modules with TypeScript, you need to include the .js extension
+// in import statements, even though the source file has a .ts extension
+// This is because Node.js will look for .js files at runtime
+export * from "./types.js";

package/dist/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Type definitions for nbk
+ */
+/**
+ * Represents a section within a project
+ */
+export type TNbkProjectSection = {
+    sectionName: string;
+    repository: {
+        name: string;
+        path: string;
+    };
+    localPath: string;
+    isZodCreator: boolean;
+    needNextJsPatch?: boolean;
+};
+/**
+ * Represents a project in the configuration
+ */
+export type TNbkProject = {
+    projectName: string;
+    projectBaseDirPath: string;
+    sharedBackendPath?: string;
+    sections: TNbkProjectSection[];
+};
+/**
+ * Type for nbk.config.ts file's default export,
+ * which is an array of projects
+ */
+export type TNbkConfig = {
+    projects: TNbkProject[];
+    b2fPortal: boolean;
+    checkCrossProjectImports: boolean;
+};

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for nbk
+ */
+export {};

package/dist/utils/jsonFile.d.ts

@@ -0,0 +1,7 @@
+export declare function cleanTrailingCommas(jsonString: string): string;
+/**
+ * Strips comments from a JSON string
+ * @param jsonString - The JSON string that may contain comments
+ * @returns JSON string with comments removed
+ */
+export declare function stripComments(jsonString: string): string;

package/dist/utils/jsonFile.js

@@ -0,0 +1,24 @@
+export function cleanTrailingCommas(jsonString) {
+    // Remove trailing commas in objects and arrays
+    return jsonString
+        // Remove trailing commas in objects
+        .replace(/,(\s*[}\]])/g, '$1')
+        // Remove trailing commas in arrays
+        .replace(/,(\s*])/g, '$1')
+        // Remove trailing commas after property values
+        .replace(/,(\s*})/g, '$1');
+}
+/**
+ * Strips comments from a JSON string
+ * @param jsonString - The JSON string that may contain comments
+ * @returns JSON string with comments removed
+ */
+export function stripComments(jsonString) {
+    // Remove single line comments
+    let stripped = jsonString.replace(/\/\/.*$/gm, '');
+    // Remove multi-line comments
+    stripped = stripped.replace(/\/\*[\s\S]*?\*\//g, '');
+    // Remove trailing commas before closing braces/brackets
+    stripped = stripped.replace(/,(\s*[}\]])/g, '$1');
+    return stripped;
+}

package/dist/utils/loadConfig.d.ts

@@ -0,0 +1,8 @@
+import { TNbkConfig } from "../types.js";
+/**
+ * Loads and validates the NBK configuration from a JSON file
+ * @param configPath - Path to the config file (optional, defaults to nbk.config.json in current directory)
+ * @returns Validated TNbkConfig object
+ * @throws Error if the configuration is invalid or file doesn't exist
+ */
+export declare function loadConfig(configPath?: string): TNbkConfig;

package/dist/utils/loadConfig.js

@@ -0,0 +1,203 @@
+import path from "path";
+import fs from "fs";
+import { stripComments } from "./jsonFile.js";
+/**
+ * Creates a visually distinct, colorful error message for config file not found errors
+ * @param configPath - Path to the config file that was not found
+ * @returns Formatted error message string
+ */
+function createConfigNotFoundErrorMessage(configPath) {
+    const separator = "=".repeat(80);
+    const title = "CONFIG FILE NOT FOUND ERROR";
+    // Color codes for terminal
+    const red = "\x1b[31m";
+    const yellow = "\x1b[33m";
+    const cyan = "\x1b[36m";
+    const reset = "\x1b[0m";
+    const bold = "\x1b[1m";
+    // Create suggested config example
+    const configExample = JSON.stringify({
+        projects: [
+            {
+                projectName: "Your Project",
+                projectBaseDirPath: "C:/path/to/your/project",
+                sections: [
+                    {
+                        sectionName: "Backend",
+                        repository: {
+                            name: "your-backend-repo",
+                            path: "https://github.com/your-org/your-repo",
+                        },
+                        localPath: "C:/path/to/your/backend",
+                        isZodCreator: true,
+                    },
+                ],
+            },
+        ],
+        b2fPortal: false,
+        checkCrossProjectImports: true,
+    }, null, 2);
+    return `
+${red}${separator}${reset}
+${red}${bold} ${title} ${reset}
+${red}${separator}${reset}
+
+${yellow}The configuration file could not be found at:${reset}
+${cyan}${configPath}${reset}
+
+${yellow}Please create a nbk.config.json file at the root of your project with the following structure:${reset}
+
+${configExample}
+
+${yellow}To specify a different config location, provide the path when calling nbkInit():${reset}
+${cyan}nbkInit({ configPath: './path/to/your/config.json' })${reset}
+
+${red}${separator}${reset}
+`;
+}
+/**
+ * Creates a visually distinct, colorful error message for validation errors
+ * @param message - The error message content
+ * @returns Formatted error message string
+ */
+function createValidationErrorMessage(message) {
+    const separator = "=".repeat(80);
+    const title = "CONFIG VALIDATION ERROR";
+    // Color codes for terminal
+    const red = "\x1b[31m";
+    const yellow = "\x1b[33m";
+    const green = "\x1b[32m";
+    const reset = "\x1b[0m";
+    const bold = "\x1b[1m";
+    return `
+${red}${separator}${reset}
+${red}${bold} ${title} ${reset}
+${red}${separator}${reset}
+
+${yellow}${message}${reset}
+
+${green}Please review your configuration file and fix the validation issue.${reset}
+
+${red}${separator}${reset}
+`;
+}
+/**
+ * Loads and validates the NBK configuration from a JSON file
+ * @param configPath - Path to the config file (optional, defaults to nbk.config.json in current directory)
+ * @returns Validated TNbkConfig object
+ * @throws Error if the configuration is invalid or file doesn't exist
+ */
+export function loadConfig(configPath = path.join(process.cwd(), "nbk.config.json")) {
+    try {
+        // Check if file exists
+        if (!fs.existsSync(configPath)) {
+            const errorMessage = createConfigNotFoundErrorMessage(configPath);
+            console.error(errorMessage);
+            throw new Error(`Configuration file not found: ${configPath}`);
+        }
+        // Read file and strip comments
+        const configString = fs.readFileSync(configPath, "utf8");
+        const strippedConfig = stripComments(configString);
+        // Parse JSON file
+        const config = JSON.parse(strippedConfig);
+        // Validate the entire config structure
+        try {
+            validateConfig(config);
+        }
+        catch (validationError) {
+            if (validationError instanceof Error) {
+                const errorMessage = createValidationErrorMessage(validationError.message);
+                console.error(errorMessage);
+            }
+            throw validationError;
+        }
+        return config;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            const errorMessage = createValidationErrorMessage(`Invalid JSON in configuration file: ${error.message}`);
+            console.error(errorMessage);
+            throw new Error(`Invalid JSON in configuration file: ${error.message}`);
+        }
+        throw error;
+    }
+}
+/**
+ * Validates the configuration object
+ * @param config - The configuration object to validate
+ * @throws Error with detailed message if validation fails
+ */
+function validateConfig(config) {
+    // Check if config has projects array
+    if (!config || !Array.isArray(config.projects)) {
+        throw new Error('Configuration must contain a "projects" array');
+    }
+    // Check for b2fPortal and checkCrossProjectImports fields
+    if (typeof config.b2fPortal !== "boolean") {
+        throw new Error('Configuration must contain a "b2fPortal" boolean field');
+    }
+    if (typeof config.checkCrossProjectImports !== "boolean") {
+        throw new Error('Configuration must contain a "checkCrossProjectImports" boolean field');
+    }
+    // Validate each project
+    for (let i = 0; i < config.projects.length; i++) {
+        const project = config.projects[i];
+        validateProject(project, i);
+    }
+}
+/**
+ * Validates a project configuration
+ * @param project - The project to validate
+ * @param index - Index in projects array for error messages
+ */
+function validateProject(project, index) {
+    // Required fields
+    if (!project.projectName) {
+        throw new Error(`Project at index ${index} is missing "projectName"`);
+    }
+    if (!project.projectBaseDirPath) {
+        throw new Error(`Project "${project.projectName}" is missing "projectBaseDirPath"`);
+    }
+    if (!Array.isArray(project.sections)) {
+        throw new Error(`Project "${project.projectName}" must contain a "sections" array`);
+    }
+    // Validate each section
+    for (let j = 0; j < project.sections.length; j++) {
+        validateSection(project.sections[j], project.projectName, j);
+    }
+}
+/**
+ * Validates a project section configuration
+ * @param section - The section to validate
+ * @param projectName - Parent project name for error messages
+ * @param index - Index in sections array for error messages
+ */
+function validateSection(section, projectName, index) {
+    // Required fields
+    if (!section.sectionName) {
+        throw new Error(`Section at index ${index} in project "${projectName}" is missing "sectionName"`);
+    }
+    if (!section.repository) {
+        throw new Error(`Section "${section.sectionName}" in project "${projectName}" is missing "repository"`);
+    }
+    if (!section.repository.name) {
+        throw new Error(`Section "${section.sectionName}" in project "${projectName}" has repository missing "name"`);
+    }
+    if (!section.repository.path) {
+        throw new Error(`Section "${section.sectionName}" in project "${projectName}" has repository missing "path"`);
+    }
+    if (!section.localPath) {
+        throw new Error(`Section "${section.sectionName}" in project "${projectName}" is missing "localPath"`);
+    }
+    if (section.isZodCreator === undefined) {
+        throw new Error(`Section "${section.sectionName}" in project "${projectName}" is missing "isZodCreator"`);
+    }
+    // Type checks
+    if (typeof section.isZodCreator !== "boolean") {
+        throw new Error(`Section "${section.sectionName}" in project "${projectName}": "isZodCreator" must be a boolean`);
+    }
+    if (section.needNextJsPatch !== undefined &&
+        typeof section.needNextJsPatch !== "boolean") {
+        throw new Error(`Section "${section.sectionName}" in project "${projectName}": "needNextJsPatch" must be a boolean if provided`);
+    }
+}

package/dist/utils/path.d.ts

@@ -0,0 +1,6 @@
+export declare const packageRootDirPath: string;
+export declare const packageSrcDirPath: string;
+export declare const packageDistDirPath: string;
+export declare const clientRootDirPath: string;
+export declare const clientSrcDirPath: string;
+export declare const clientDistDirPath: string;

package/dist/utils/path.js

@@ -0,0 +1,16 @@
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+/**
+ * Utility functions for working with paths in the backend kit
+ */
+// Get the current file's directory
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Calculate common paths
+export const packageRootDirPath = join(__dirname, '..', '..');
+export const packageSrcDirPath = join(packageRootDirPath, 'src');
+export const packageDistDirPath = join(packageRootDirPath, 'dist');
+export const clientRootDirPath = process.cwd();
+export const clientSrcDirPath = join(clientRootDirPath, 'src');
+export const clientDistDirPath = join(clientRootDirPath, 'dist');