express-project-builder 1.0.0

package/dist/lib/src/middlewares/create_ValidateRequest_Guard.js

@@ -0,0 +1,104 @@
+import path from "path";
+import { createFile } from "../../utils/helpers.js";
+import chalk from "chalk";
+/**
+ * Creates a request validation middleware file using Zod schemas
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the validate request middleware file is created
+ */
+export const create_ValidateRequest_Guard = async (projectPath) => {
+    try {
+        const validateRequestMiddlewareTemplate = `/* eslint-disable @typescript-eslint/no-explicit-any */
+import { AnyZodObject, ZodError, ZodIssue } from 'zod'
+import { Request, Response, NextFunction } from 'express'
+import catchAsync from '../utils/catchAsync'
+import AppError from '../errors/AppError'
+
+/**
+ * Request validation middleware using Zod schemas
+ * Creates a middleware function that validates the request against the provided Zod schema
+ *
+ * @param schema - Zod schema object to validate against
+ * @returns Express middleware function
+ *
+ * @example
+ * // Define a schema for user registration
+ * const userSchema = z.object({
+ *   body: z.object({
+ *     email: z.string().email(),
+ *     password: z.string().min(8)
+ *   }),
+ *   params: z.object({
+ *     id: z.string().uuid()
+ *   })
+ * });
+ *
+ * // Use the middleware
+ * app.post('/users/:id', validateRequest(userSchema), userController.createUser);
+ */
+const validateRequest = (schema: AnyZodObject) => {
+  return catchAsync(async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      // Prepare the data to validate (body, cookies, and params)
+      const dataToValidate = {
+        body: req.body,
+        cookies: req.cookies,
+        params: req.params
+      }
+      
+      // Validate the data against the schema
+      await schema.parseAsync(dataToValidate)
+      
+      // If validation passes, proceed to the next middleware
+      next()
+    } catch (error) {
+      // Handle Zod validation errors
+      if (error instanceof ZodError) {
+        // Format the Zod error into a more readable format
+        const formattedErrors = error.errors.map((err: ZodIssue) => {
+          // Base error object
+          const errorObj: any = {
+            path: err.path.join('.'),
+            message: err.message,
+            code: err.code
+          }
+          
+          // Add expected and received only if they exist
+          if ('expected' in err) {
+            errorObj.expected = (err as any).expected
+          }
+          if ('received' in err) {
+            errorObj.received = (err as any).received
+          }
+          
+          return errorObj
+        })
+        
+        // Throw an AppError with the validation details
+        throw new AppError(
+          400,
+          'validation',
+          'Request validation failed',
+          JSON.stringify(formattedErrors)
+        )
+      }
+      
+      // For other types of errors, rethrow them
+      next(error)
+    }
+  })
+}
+
+export default validateRequest
+`;
+        await createFile(path.join(projectPath, "src/app/middlewares", "validateRequest.ts"), validateRequestMiddlewareTemplate);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ Successfully created Validate Request Middleware file"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating Validate Request Middleware file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_ValidateRequest_Guard.js.map

package/dist/lib/src/middlewares/create_ValidateRequest_Guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_ValidateRequest_Guard.js","sourceRoot":"","sources":["../../../../src/lib/src/middlewares/create_ValidateRequest_Guard.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B;;;;GAIG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,KAAK,EAC/C,WAAmB,EACJ,EAAE;IACjB,IAAI,CAAC;QACH,MAAM,iCAAiC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkF7C,CAAC;QAEE,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,qBAAqB,EAAE,oBAAoB,CAAC,EACnE,iCAAiC,CAClC,CAAC;QAEF,gDAAgD;QAChD,OAAO,CAAC,GAAG,CACT,KAAK,CAAC,KAAK,CAAC,yDAAyD,CAAC,CACvE,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wCAAwC;QACxC,OAAO,CAAC,KAAK,CACX,KAAK,CAAC,GAAG,CAAC,oDAAoD,CAAC,EAC/D,GAAG,CACJ,CAAC;QACF,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC,CAAC"}

package/dist/lib/src/modules/create_DemoModules_SrcStructure.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates a demo module structure with sample files
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the demo module structure is created
+ */
+export declare const createDemoModules_SrcStructure: (projectPath: string) => Promise<void>;
+//# sourceMappingURL=create_DemoModules_SrcStructure.d.ts.map

package/dist/lib/src/modules/create_DemoModules_SrcStructure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_DemoModules_SrcStructure.d.ts","sourceRoot":"","sources":["../../../../src/lib/src/modules/create_DemoModules_SrcStructure.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,GACzC,aAAa,MAAM,KAClB,OAAO,CAAC,IAAI,CA4Wd,CAAC"}

package/dist/lib/src/modules/create_DemoModules_SrcStructure.js

@@ -0,0 +1,367 @@
+import path from "path";
+import { createDirectory, createFile } from "../../utils/helpers.js";
+import chalk from "chalk";
+/**
+ * Creates a demo module structure with sample files
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the demo module structure is created
+ */
+export const createDemoModules_SrcStructure = async (projectPath) => {
+    try {
+        // Create src/app/modules directory if it doesn't exist
+        const modulesPath = path.join(projectPath, "src/app/modules");
+        await createDirectory(modulesPath);
+        // Create demo_modules directory
+        const demoModulePath = path.join(modulesPath, "demo_modules");
+        await createDirectory(demoModulePath);
+        // Define files to create with their basic content
+        const files = [
+            {
+                name: "demo_modules_interface.ts",
+                content: `/**
+ * Demo Module Interfaces
+ * Defines TypeScript interfaces for the demo module
+ */
+export type TDemoModule = {
+  id: string;
+  name: string;
+  description?: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+`,
+            },
+            {
+                name: "demo_modules_model.ts",
+                content: `/**
+ * Demo Module Model
+ * Mongoose model for demo modules
+ */
+/**
+import { Schema, model } from 'mongoose';
+import { TDemoModule } from './demo_modules_interface';
+
+const demoModuleSchema = new Schema<TDemoModule>({
+  name: {
+    type: String,
+    required: [true, 'Name is required'],
+    trim: true,
+    maxlength: 100
+  },
+  description: {
+    type: String,
+    trim: true,
+    maxlength: 500
+  }
+}, {
+  timestamps: true
+});
+
+export const DemoModuleModel = model<TDemoModule>('DemoModule', demoModuleSchema);
+*/
+`,
+            },
+            {
+                name: "demo_modules_validationZodSchema.ts",
+                content: `/**
+ * Demo Module Validation Schemas
+ * Zod schemas for validating demo module data
+ */
+import { z } from 'zod';
+
+export const createDemoModuleSchema = z.object({
+  body : z.object({
+    name: z.string({required_error: 'Name is required'})
+      .min(1, 'Name is required')
+      .max(100, 'Name cannot exceed 100 characters'),
+    description: z.string()
+      .max(500, 'Description cannot exceed 500 characters')
+      .optional()
+  })
+});
+
+export const updateDemoModuleSchema = z.object({
+  body : z.object({
+    name: z.string()
+      .max(100, 'Name cannot exceed 100 characters')
+      .optional(),
+    description: z.string()
+      .max(500, 'Description cannot exceed 500 characters')
+      .optional()
+  })
+});
+
+export type TCreateDemoModule = z.infer<typeof createDemoModuleSchema>;
+export type TUpdateDemoModule = z.infer<typeof updateDemoModuleSchema>;
+`,
+            },
+            {
+                name: "demo_modules_service.ts",
+                content: `/**
+ * Demo Module Service
+ * Business logic for demo modules
+ */
+import AppError from '../../errors/AppError';
+
+// fetche demo data from database 
+const fetch_DemoData_fromDB = async () => {
+    console.log('Fetching demo data from your database...');
+    const data = "Sample Demo Data from DB";
+    const meta = {
+      page : 1,
+      limit : 10,
+      totalPage : 3,
+      totalData : 30
+    }
+    return {data, meta};
+}
+
+export const DemoModuleServices = {
+  fetch_DemoData_fromDB  
+}
+`,
+            },
+            {
+                name: "demo_modules_controller.ts",
+                content: `/**
+ * Demo Module Controller
+ * Handles HTTP requests for demo modules
+ */
+import { Request, Response } from 'express'
+import { DemoModuleServices } from './demo_modules_service'
+import catchAsync from '../../utils/catchAsync'
+import sendResponse from '../../utils/sendResponse'
+
+// fetch demo data
+const fetch_DemoData = catchAsync(async (req: Request, res: Response) => {
+  const { data, meta } = await DemoModuleServices.fetch_DemoData_fromDB()
+  sendResponse(res, {
+    status: 200,
+    success: true,
+    message: 'Demo data fetched successfully',
+    data: data,
+    meta: meta
+  })
+})
+
+export const DemoModuleControllers = {
+  fetch_DemoData
+}
+`,
+            },
+            {
+                name: "demo_modules_route.ts",
+                content: `/**
+ * Demo Module Routes
+ * Defines routes for demo modules
+ */
+import { Router } from 'express';
+import { DemoModuleControllers } from './demo_modules_controller';
+// import { validateRequest } from '../../middlewares/validateRequest';
+// import { createDemoModuleSchema, updateDemoModuleSchema } from './demo_modules_validationZodSchema';
+
+const router: Router = Router();
+
+// Create demo module
+/**
+router.post(
+  '/create',
+  validateRequest(createDemoModuleSchema),
+  DemoModuleControllers.createDemoModule
+);
+*/
+
+// Get all demo modules
+router.get(
+  '/',
+  DemoModuleControllers.fetch_DemoData
+);
+
+// Get demo module by ID
+/**
+router.get(
+  '/:id',
+  DemoModuleControllers.getDemoModuleById
+);
+*/
+
+// Update demo module
+/**
+router.patch(
+  '/:id/update',
+  validateRequest(updateDemoModuleSchema),
+  DemoModuleControllers.updateDemoModule
+);
+*/
+
+// Delete demo module
+/**
+router.delete(
+  '/:id/delete',
+  DemoModuleControllers.deleteDemoModule
+);
+*/
+
+export const DemoModuleRoutes = router;
+`,
+            },
+            {
+                name: "demo_modules_constant.ts",
+                content: `/**
+ * Demo Module Constants
+ * Defines constants used throughout the demo module
+ */
+export const DEMO_MODULE_CONSTANTS = {
+  // Error messages
+  ERROR_MESSAGES: {
+    NOT_FOUND: 'Demo module not found',
+    CREATE_FAILED: 'Failed to create demo module',
+    UPDATE_FAILED: 'Failed to update demo module',
+    DELETE_FAILED: 'Failed to delete demo module'
+  },
+  
+  // Success messages
+  SUCCESS_MESSAGES: {
+    CREATED: 'Demo module created successfully',
+    UPDATED: 'Demo module updated successfully',
+    DELETED: 'Demo module deleted successfully',
+    RETRIEVED: 'Demo module retrieved successfully'
+  },
+  
+  // Validation limits
+  VALIDATION_LIMITS: {
+    NAME_MIN_LENGTH: 1,
+    NAME_MAX_LENGTH: 100,
+    DESCRIPTION_MAX_LENGTH: 500
+  }
+};
+`,
+            },
+            {
+                name: "demo_modules_lib.ts",
+                content: `/**
+ * Demo Module Library
+ * Contains library functions for demo modules
+ */
+import { TDemoModule } from './demo_modules_interface';
+
+/**
+ * Format demo module for response
+ * @param demoModule - The demo module to format
+ * @returns Formatted demo module
+ */
+export const formatDemoModule = (demoModule: TDemoModule) => {
+  return {
+    id: demoModule.id,
+    name: demoModule.name,
+    description: demoModule.description || '',
+    createdAt: demoModule.createdAt,
+    updatedAt: demoModule.updatedAt
+  };
+};
+
+/**
+ * Format multiple demo modules for response
+ * @param demoModules - Array of demo modules to format
+ * @returns Array of formatted demo modules
+ */
+export const formatDemoModules = (demoModules: TDemoModule[]) => {
+  return demoModules.map(formatDemoModule);
+};
+`,
+            },
+            {
+                name: "demo_modules_utils.ts",
+                content: `/**
+ * Demo Module Utilities
+ * Contains utility functions for demo modules
+ */
+`,
+            },
+            {
+                name: "demo_modules_helpers.ts",
+                content: `/**
+ * Demo Module Helpers
+ * Contains helper functions for demo modules
+ */
+import { TDemoModule } from './demo_modules_interface';
+
+/**
+ * Generate a unique name for demo module
+ * @param baseName - Base name for the module
+ * @param existingNames - Array of existing names
+ * @returns Unique name
+ */
+export const generateUniqueName = (
+  baseName: string,
+  existingNames: string[]
+): string => {
+  let counter = 1;
+  let uniqueName = baseName;
+  
+  while (existingNames.includes(uniqueName)) {
+    uniqueName = \`\${baseName} \${counter}\`;
+    counter++;
+  }
+  
+  return uniqueName;
+};
+
+/**
+ * Calculate similarity between two strings
+ * @param str1 - First string
+ * @param str2 - Second string
+ * @returns Similarity score (0-1)
+ */
+export const calculateStringSimilarity = (str1: string, str2: string): number => {
+  const longer = str1.length > str2.length ? str1 : str2;
+  const shorter = str1.length > str2.length ? str2 : str1;
+  
+  if (longer.length === 0) return 1;
+  
+  const editDistance = levenshteinDistance(longer, shorter);
+  return (longer.length - editDistance) / longer.length;
+};
+
+/**
+ * Calculate Levenshtein distance between two strings
+ * @param str1 - First string
+ * @param str2 - Second string
+ * @returns Edit distance
+ */
+const levenshteinDistance = (str1: string, str2: string): number => {
+  const matrix = Array(str2.length + 1).fill(null).map(() => Array(str1.length + 1).fill(null));
+  
+  for (let i = 0; i <= str1.length; i++) matrix[0][i] = i;
+  for (let j = 0; j <= str2.length; j++) matrix[j][0] = j;
+  
+  for (let j = 1; j <= str2.length; j++) {
+    for (let i = 1; i <= str1.length; i++) {
+      const indicator = str1[i - 1] === str2[j - 1] ? 0 : 1;
+      matrix[j][i] = Math.min(
+        matrix[j][i - 1] + 1, // deletion
+        matrix[j - 1][i] + 1, // insertion
+        matrix[j - 1][i - 1] + indicator // substitution
+      );
+    }
+  }
+  
+  return matrix[str2.length][str1.length];
+};
+`,
+            },
+        ];
+        // Create each file
+        for (const file of files) {
+            await createFile(path.join(demoModulePath, file.name), file.content);
+        }
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ Demo module files created successfully. Delete them if not needed."));
+    }
+    catch (error) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating demo module files:"), error);
+        throw error;
+    }
+};
+//# sourceMappingURL=create_DemoModules_SrcStructure.js.map

package/dist/lib/src/modules/create_DemoModules_SrcStructure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_DemoModules_SrcStructure.js","sourceRoot":"","sources":["../../../../src/lib/src/modules/create_DemoModules_SrcStructure.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACrE,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B;;;;GAIG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,KAAK,EACjD,WAAmB,EACJ,EAAE;IACjB,IAAI,CAAC;QACH,uDAAuD;QACvD,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,iBAAiB,CAAC,CAAC;QAC9D,MAAM,eAAe,CAAC,WAAW,CAAC,CAAC;QAEnC,gCAAgC;QAChC,MAAM,cAAc,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,CAAC;QAC9D,MAAM,eAAe,CAAC,cAAc,CAAC,CAAC;QAEtC,kDAAkD;QAClD,MAAM,KAAK,GAAG;YACZ;gBACE,IAAI,EAAE,2BAA2B;gBACjC,OAAO,EAAE;;;;;;;;;;;CAWhB;aACM;YACD;gBACE,IAAI,EAAE,uBAAuB;gBAC7B,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BhB;aACM;YACD;gBACE,IAAI,EAAE,qCAAqC;gBAC3C,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BhB;aACM;YACD;gBACE,IAAI,EAAE,yBAAyB;gBAC/B,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;CAsBhB;aACM;YACD;gBACE,IAAI,EAAE,4BAA4B;gBAClC,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;CAwBhB;aACM;YACD;gBACE,IAAI,EAAE,uBAAuB;gBAC7B,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDhB;aACM;YACD;gBACE,IAAI,EAAE,0BAA0B;gBAChC,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BhB;aACM;YACD;gBACE,IAAI,EAAE,qBAAqB;gBAC3B,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BhB;aACM;YACD;gBACE,IAAI,EAAE,uBAAuB;gBAC7B,OAAO,EAAE;;;;CAIhB;aACM;YACD;gBACE,IAAI,EAAE,yBAAyB;gBAC/B,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoEhB;aACM;SACF,CAAC;QAEF,mBAAmB;QACnB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,MAAM,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACvE,CAAC;QAED,gDAAgD;QAChD,OAAO,CAAC,GAAG,CACT,KAAK,CAAC,KAAK,CACT,sEAAsE,CACvE,CACF,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,wCAAwC;QACxC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,qCAAqC,CAAC,EAAE,KAAK,CAAC,CAAC;QACvE,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC,CAAC"}

package/dist/lib/src/routers/create_Router_Index_Path.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates a router index file that serves as the central point for registering all module routes
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the router index file is created
+ */
+export declare const create_Router_index_Path: (projectPath: string) => Promise<void>;
+//# sourceMappingURL=create_Router_Index_Path.d.ts.map

package/dist/lib/src/routers/create_Router_Index_Path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_Router_Index_Path.d.ts","sourceRoot":"","sources":["../../../../src/lib/src/routers/create_Router_Index_Path.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GACnC,aAAa,MAAM,KAClB,OAAO,CAAC,IAAI,CAgDd,CAAC"}

package/dist/lib/src/routers/create_Router_Index_Path.js

@@ -0,0 +1,54 @@
+import path from "path";
+import { createFile } from "../../utils/helpers.js";
+import chalk from "chalk";
+/**
+ * Creates a router index file that serves as the central point for registering all module routes
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the router index file is created
+ */
+export const create_Router_index_Path = async (projectPath) => {
+    try {
+        const routerIndexTemplate = `import express, { Router } from 'express';
+import { DemoModuleRoutes } from '../modules/demo_modules/demo_modules_route';
+
+/**
+ * Main router configuration
+ * This file serves as the central point for registering all module routes
+ */
+const routers: Router = express.Router();
+
+/**
+ * Array of module routes to be registered
+ * Each object contains:
+ * - path: The base path for the module (e.g., '/auth')
+ * - route: The router instance for the module
+ */
+const moduleRoutes = [
+  {
+    path: '/demo-modules',
+    route: DemoModuleRoutes
+  }
+];
+
+/**
+ * Register all module routes
+ * This loop iterates through the moduleRoutes array and registers each route
+ * with its corresponding path
+ */
+moduleRoutes.forEach(route => {
+  routers.use(route.path, route.route);
+});
+
+export default routers;
+`;
+        await createFile(path.join(projectPath, "src/app/routers", "index.ts"), routerIndexTemplate);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ Router index file created successfully"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating Router index file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_Router_Index_Path.js.map

package/dist/lib/src/routers/create_Router_Index_Path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_Router_Index_Path.js","sourceRoot":"","sources":["../../../../src/lib/src/routers/create_Router_Index_Path.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,KAAK,EAC3C,WAAmB,EACJ,EAAE;IACjB,IAAI,CAAC;QACH,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgC/B,CAAC;QAEE,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,iBAAiB,EAAE,UAAU,CAAC,EACrD,mBAAmB,CACpB,CAAC;QAEF,gDAAgD;QAChD,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,0CAA0C,CAAC,CAAC,CAAC;IACvE,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wCAAwC;QACxC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,qCAAqC,CAAC,EAAE,GAAG,CAAC,CAAC;QACrE,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC,CAAC"}

package/dist/lib/src/shared/create_Prisma_Shated.d.ts

@@ -0,0 +1,9 @@
+import { TAnswers } from "../../utils/types.js";
+/**
+ * Creates a Prisma shared file for PostgreSQL with Prisma database option
+ * @param projectPath - Absolute path to the project root
+ * @param answers - User answers from CLI prompts
+ * @returns Promise that resolves when the Prisma shared file is created (if applicable)
+ */
+export declare const create_prisma_shared_file: (projectPath: string, answers: TAnswers) => Promise<void>;
+//# sourceMappingURL=create_Prisma_Shated.d.ts.map

package/dist/lib/src/shared/create_Prisma_Shated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_Prisma_Shated.d.ts","sourceRoot":"","sources":["../../../../src/lib/src/shared/create_Prisma_Shated.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,GACpC,aAAa,MAAM,EACnB,SAAS,QAAQ,KAChB,OAAO,CAAC,IAAI,CA2Bd,CAAC"}

package/dist/lib/src/shared/create_Prisma_Shated.js

@@ -0,0 +1,34 @@
+import path from "path";
+import { createFile } from "../../utils/helpers.js";
+import chalk from "chalk";
+/**
+ * Creates a Prisma shared file for PostgreSQL with Prisma database option
+ * @param projectPath - Absolute path to the project root
+ * @param answers - User answers from CLI prompts
+ * @returns Promise that resolves when the Prisma shared file is created (if applicable)
+ */
+export const create_prisma_shared_file = async (projectPath, answers) => {
+    try {
+        // Check if PostgreSQL with Prisma is selected
+        if (answers.database === "PostgreSQL with Prisma") {
+            const prismaSharedTemplate = `
+import { PrismaClient } from '../../../generated/prisma'
+
+const prisma = new PrismaClient({
+  log: ['query', 'info', 'warn', 'error'],
+});
+
+export default prisma;
+`;
+            await createFile(path.join(projectPath, "src/app/shared", "prisma.ts"), prismaSharedTemplate);
+            // Success message with green checkmark and text
+            console.log(chalk.green("✅ Prisma shared file created successfully."));
+        }
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating Prisma shared file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_Prisma_Shated.js.map

package/dist/lib/src/shared/create_Prisma_Shated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_Prisma_Shated.js","sourceRoot":"","sources":["../../../../src/lib/src/shared/create_Prisma_Shated.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B;;;;;GAKG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,KAAK,EAC5C,WAAmB,EACnB,OAAiB,EACF,EAAE;IACjB,IAAI,CAAC;QACH,8CAA8C;QAC9C,IAAI,OAAO,CAAC,QAAQ,KAAK,wBAAwB,EAAE,CAAC;YAClD,MAAM,oBAAoB,GAAG;;;;;;;;CAQlC,CAAC;YAEI,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,gBAAgB,EAAE,WAAW,CAAC,EACrD,oBAAoB,CACrB,CAAC;YAEF,gDAAgD;YAChD,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,4CAA4C,CAAC,CAAC,CAAC;QACzE,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wCAAwC;QACxC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,sCAAsC,CAAC,EAAE,GAAG,CAAC,CAAC;QACtE,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC,CAAC"}

package/dist/lib/src/utils/createCatchAsync_Utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates a catch async utilities file for handling asynchronous errors in Express route handlers
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the catch async utils file is created
+ */
+export declare const createCatchAsync_Utils: (projectPath: string) => Promise<void>;
+//# sourceMappingURL=createCatchAsync_Utils.d.ts.map

package/dist/lib/src/utils/createCatchAsync_Utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createCatchAsync_Utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/src/utils/createCatchAsync_Utils.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,GACjC,aAAa,MAAM,KAClB,OAAO,CAAC,IAAI,CAqDd,CAAC"}