express-project-builder 1.0.0

package/dist/lib/config/createTsConfig.js

@@ -0,0 +1,133 @@
+import { createFile } from "../utils/helpers.js";
+import path from "path";
+import chalk from "chalk";
+// Type-safe TypeScript config creation function
+export const createTsConfig = async (projectPath) => {
+    try {
+        const tsConfigContent = `{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+    
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+    
+    /* Language and Environment */
+    "target": "es2016" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+    
+    /* Modules */
+    "module": "commonjs" /* Specify what module code is generated. */,
+    "rootDir": "./src" /* Specify the root folder within your source files. */,
+    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    "typeRoots": [
+      "src/app/types", // 👈  our custom types directory
+      "./node_modules/@types"
+    ] /* Specify multiple folders that act like './node_modules/@types'. */,
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "rewriteRelativeImportExtensions": true,          /* Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "noUncheckedSideEffectImports": true,             /* Check side effect imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+    
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+    
+    /* Emit */
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./dist" /* Specify an output folder for all emitted files. */,
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+    
+    /* Type Checking */
+    "strict": true /* Enable all strict type-checking options. */,
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "strictBuiltinIteratorReturn": true,              /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+    
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true /* Skip type checking all .d.ts files. */
+  },
+  "include": ["src", "src/app/**/*", "src/app/interfaces/index.d.ts"], // which files to compile
+  "exclude": ["node_modules"] // which files to skip
+}`;
+        await createFile(path.join(projectPath, "tsconfig.json"), tsConfigContent);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ tsconfig.json file created successfully"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating tsconfig.json file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=createTsConfig.js.map

package/dist/lib/config/createTsConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createTsConfig.js","sourceRoot":"","sources":["../../../src/lib/config/createTsConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,gDAAgD;AAChD,MAAM,CAAC,MAAM,cAAc,GAAG,KAAK,EAAE,WAAmB,EAAiB,EAAE;IACzE,IAAI,CAAC;QACH,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmH1B,CAAC;QAEC,MAAM,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,eAAe,CAAC,EAAE,eAAe,CAAC,CAAC;QAE3E,gDAAgD;QAChD,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,2CAA2C,CAAC,CAAC,CAAC;IACxE,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/prisma/create_Schema.Prisma.d.ts

@@ -0,0 +1,3 @@
+import { TAnswers } from "../utils/types.js";
+export declare const createSchemaPrisma: (projectPath: string, answers: TAnswers) => Promise<void>;
+//# sourceMappingURL=create_Schema.Prisma.d.ts.map

package/dist/lib/prisma/create_Schema.Prisma.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_Schema.Prisma.d.ts","sourceRoot":"","sources":["../../../src/lib/prisma/create_Schema.Prisma.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAG7C,eAAO,MAAM,kBAAkB,GAC7B,aAAa,MAAM,EACnB,SAAS,QAAQ,KAChB,OAAO,CAAC,IAAI,CAgCd,CAAC"}

package/dist/lib/prisma/create_Schema.Prisma.js

@@ -0,0 +1,36 @@
+import path from "path";
+import { createDirectory, createFile } from "../utils/helpers.js";
+import chalk from "chalk";
+// Type-safe Prisma schema creation function
+export const createSchemaPrisma = async (projectPath, answers) => {
+    try {
+        if (answers.database === "PostgreSQL with Prisma") {
+            const prismaPath = path.join(projectPath, "prisma");
+            await createDirectory(prismaPath);
+            const schemaPrisma = `// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+// Looking for ways to speed up your queries, or scale easily with your serverless or edge functions?
+// Try Prisma Accelerate: https://pris.ly/cli/accelerate-init
+generator client {
+  provider = "prisma-client-js"
+  output   = "../generated/prisma"
+}
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+model User {
+  id String @id @default(uuid())
+}`;
+            await createFile(path.join(prismaPath, "schema.prisma"), schemaPrisma);
+            // Success message with green checkmark and text
+            console.log(chalk.green("✅ Prisma schema file created successfully."));
+        }
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating Prisma schema file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_Schema.Prisma.js.map

package/dist/lib/prisma/create_Schema.Prisma.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_Schema.Prisma.js","sourceRoot":"","sources":["../../../src/lib/prisma/create_Schema.Prisma.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,4CAA4C;AAC5C,MAAM,CAAC,MAAM,kBAAkB,GAAG,KAAK,EACrC,WAAmB,EACnB,OAAiB,EACF,EAAE;IACjB,IAAI,CAAC;QACH,IAAI,OAAO,CAAC,QAAQ,KAAK,wBAAwB,EAAE,CAAC;YAClD,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;YACpD,MAAM,eAAe,CAAC,UAAU,CAAC,CAAC;YAElC,MAAM,YAAY,GAAG;;;;;;;;;;;;;;EAczB,CAAC;YAEG,MAAM,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,eAAe,CAAC,EAAE,YAAY,CAAC,CAAC;YAEvE,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/builders/create_QueryBuilder_Helpers.d.ts

@@ -0,0 +1,3 @@
+import { TAnswers } from "../../utils/types.js";
+export declare const create_QueryBuilder_Helpers: (projectPath: string, answers: TAnswers) => Promise<void>;
+//# sourceMappingURL=create_QueryBuilder_Helpers.d.ts.map

package/dist/lib/src/builders/create_QueryBuilder_Helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_QueryBuilder_Helpers.d.ts","sourceRoot":"","sources":["../../../../src/lib/src/builders/create_QueryBuilder_Helpers.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAGhD,eAAO,MAAM,2BAA2B,GACtC,aAAa,MAAM,EACnB,SAAS,QAAQ,KAChB,OAAO,CAAC,IAAI,CA0Sd,CAAC"}

package/dist/lib/src/builders/create_QueryBuilder_Helpers.js

@@ -0,0 +1,292 @@
+import path from "path";
+import { createFile } from "../../utils/helpers.js";
+import chalk from "chalk";
+// Type-safe QueryBuilder helpers creation function
+export const create_QueryBuilder_Helpers = async (projectPath, answers) => {
+    try {
+        // Create MongoDB QueryBuilder if MongoDB is selected
+        if (answers.database === "MongoDB with Mongoose") {
+            const mongoQueryBuilderTemplate = `import { FilterQuery, Query } from 'mongoose';
+/**
+ * MongoDB Query Builder class for building complex queries with chaining methods
+ */
+class QueryBuilder<T> {
+  public modelQuery: Query<T[], T>;
+  public query: Record<string, unknown>;
+  constructor(modelQuery: Query<T[], T>, query: Record<string, unknown>) {
+    this.modelQuery = modelQuery;
+    this.query = query;
+  }
+  /**
+   * Add search functionality to the query
+   * @param searchableFields - Array of fields to search in
+   * @returns QueryBuilder instance for chaining
+   */
+  search(searchableFields: string[]): this {
+    const searchTerm = this.query.search as string;
+    if (searchTerm) {
+      this.modelQuery = this.modelQuery.find({
+        $or: searchableFields.map(
+          field => ({
+            [field]: { $regex: searchTerm, $options: 'i' }
+          }) as FilterQuery<T>
+        )
+      });
+    }
+    return this;
+  }
+  /**
+   * Add filtering to the query
+   * @returns QueryBuilder instance for chaining
+   */
+  filter(): this {
+    const queryObj = { ...this.query };
+    const excludeFields = ['search', 'sort', 'page', 'limit', 'fields'];
+    excludeFields.forEach(el => delete queryObj[el]);
+    
+    this.modelQuery = this.modelQuery.find(queryObj as FilterQuery<T>);
+    return this;
+  }
+  /**
+   * Add sorting to the query
+   * @returns QueryBuilder instance for chaining
+   */
+  sort(): this {
+    const sortField = (this.query.sort as string)?.split(',')?.join(' ') || '-createdAt';
+    this.modelQuery = this.modelQuery.sort(sortField);
+    return this;
+  }
+  /**
+   * Add pagination to the query
+   * @returns QueryBuilder instance for chaining
+   */
+  paginate(): this {
+    const page = Number(this.query.page) || 1;
+    const limit = Number(this.query.limit) || 10;
+    const skip = (page - 1) * limit;
+    
+    this.modelQuery = this.modelQuery.skip(skip).limit(limit);
+    return this;
+  }
+  /**
+   * Field selection to include/exclude specific fields
+   * @returns QueryBuilder instance for chaining
+   */
+  fields(): this {
+    const fields = (this.query.fields as string)?.split(',')?.join(' ') || '-__v';
+    this.modelQuery = this.modelQuery.select(fields);
+    return this;
+  }
+  /**
+   * Get total count and pagination metadata
+   * @returns Object with pagination metadata
+   */
+  async countTotal(): Promise<{
+    page: number;
+    limit: number;
+    totalData: number;
+    totalPage: number;
+  }> {
+    const totalQueries = this.modelQuery.getFilter();
+    const totalData = await this.modelQuery.model.countDocuments(totalQueries);
+    const page = Number(this.query.page) || 1;
+    const limit = Number(this.query.limit) || 10;
+    const totalPage = Math.ceil(totalData / limit);
+    
+    return {
+      page,
+      limit,
+      totalData,
+      totalPage
+    };
+  }
+}
+export default QueryBuilder;
+`;
+            await createFile(path.join(projectPath, "src/app/builder", "MongooseQueryBuilder.ts"), mongoQueryBuilderTemplate);
+        }
+        // Create Prisma QueryBuilder if PostgreSQL with Prisma is selected
+        if (answers.database === "PostgreSQL with Prisma") {
+            const prismaQueryBuilderTemplate = `/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Prisma Query Builder class for building complex queries with chaining methods
+ * Similar pattern to the Mongoose QueryBuilder but adapted for Prisma
+ */
+class PrismaQueryBuilder<T extends Record<string, any>> {
+  private prismaModel: any
+  private query: Record<string, unknown>
+  private whereClause: any = {}
+  private orderBy: any[] = []
+  private selectFields: any = null
+  private skipValue: number | undefined
+  private takeValue: number | undefined
+  constructor(prismaModel: any, query: Record<string, unknown>) {
+    this.prismaModel = prismaModel
+    this.query = query
+  }
+  /**
+   * Add search functionality to the query
+   * @param searchableFields - Array of fields to search in
+   * @returns PrismaQueryBuilder instance for chaining
+   */
+  search(searchableFields: string[]): this {
+    const searchTerm = this.query.search as string
+    if (searchTerm) {
+      this.whereClause = {
+        ...this.whereClause,
+        OR: searchableFields.map(field => ({
+          [field]: {
+            contains: searchTerm,
+            mode: 'insensitive'
+          }
+        }))
+      }
+    }
+    return this
+  }
+  /**
+   * Add filtering to the query
+   * @returns PrismaQueryBuilder instance for chaining
+   */
+  filter(): this {
+    const queryObj = { ...this.query }
+    const excludeFields = ['search', 'sort', 'page', 'limit', 'fields']
+    excludeFields.forEach(el => delete queryObj[el])
+    // Add the remaining query parameters to the where clause
+    Object.entries(queryObj).forEach(([key, value]) => {
+      if (value !== undefined && value !== null) {
+        this.whereClause = {
+          ...this.whereClause,
+          [key]: value
+        }
+      }
+    })
+    return this
+  }
+  /**
+   * Add sorting to the query
+   * @returns PrismaQueryBuilder instance for chaining
+   */
+  sort(): this {
+    const sortField = this.query.sort as string
+    if (sortField) {
+      const sortFields = sortField.split(',')
+      this.orderBy = sortFields.map(field => {
+        const isDescending = field.startsWith('-')
+        const fieldName = isDescending ? field.substring(1) : field
+        return {
+          [fieldName]: isDescending ? 'desc' : 'asc'
+        }
+      })
+    } else {
+      // Default sort by createdAt in descending order
+      this.orderBy = [{ createdAt: 'desc' }]
+    }
+    return this
+  }
+  /**
+   * Add pagination to the query
+   * @returns PrismaQueryBuilder instance for chaining
+   */
+  paginate(): this {
+    const page = Number(this.query.page) || 1
+    const limit = Number(this.query.limit) || 10
+    this.skipValue = (page - 1) * limit
+    this.takeValue = limit
+    return this
+  }
+  /**
+   * Field selection to include specific fields
+   * @returns PrismaQueryBuilder instance for chaining
+   */
+  fields(): this {
+    const fields = this.query.fields as string
+    if (fields) {
+      const fieldArray = fields.split(',')
+      this.selectFields = fieldArray.reduce((acc, field) => {
+        // Skip the __v field which doesn't exist in Prisma
+        if (field !== '__v') {
+          acc[field] = true
+        }
+        return acc
+      }, {} as any)
+    }
+    return this
+  }
+  /**
+   * Execute the query and return results with metadata
+   * @returns Object with data and pagination metadata
+   */
+  async execute(): Promise<{
+    data: T[]
+    meta: {
+      page: number
+      limit: number
+      totalData: number
+      totalPage: number
+    }
+  }> {
+    const page = Number(this.query.page) || 1
+    const limit = Number(this.query.limit) || 10
+    // Build the query parameters
+    const queryOptions: any = {
+      where: this.whereClause,
+      orderBy: this.orderBy.length > 0 ? this.orderBy : undefined,
+      skip: this.skipValue,
+      take: this.takeValue
+    }
+    // Add select if specified
+    if (this.selectFields) {
+      queryOptions.select = this.selectFields
+    }
+    // Get total count
+    const totalData = await this.prismaModel.count({ where: this.whereClause })
+    const totalPage = Math.ceil(totalData / limit)
+    // Get data
+    const data = await this.prismaModel.findMany(queryOptions)
+    return {
+      data,
+      meta: {
+        page,
+        limit,
+        totalData,
+        totalPage
+      }
+    }
+  }
+  /**
+   * Get total count and pagination metadata without fetching data
+   * @returns Object with pagination metadata
+   */
+  async countTotal(): Promise<{
+    page: number
+    limit: number
+    totalData: number
+    totalPage: number
+  }> {
+    const page = Number(this.query.page) || 1
+    const limit = Number(this.query.limit) || 10
+    const totalData = await this.prismaModel.count({ where: this.whereClause })
+    const totalPage = Math.ceil(totalData / limit)
+    return {
+      page,
+      limit,
+      totalData,
+      totalPage
+    }
+  }
+}
+export default PrismaQueryBuilder
+`;
+            await createFile(path.join(projectPath, "src/app/builder", "PrismaQueryBuilder.ts"), prismaQueryBuilderTemplate);
+        }
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ QueryBuilder Helpers file created successfully"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating QueryBuilder Helpers file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_QueryBuilder_Helpers.js.map

package/dist/lib/src/builders/create_QueryBuilder_Helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_QueryBuilder_Helpers.js","sourceRoot":"","sources":["../../../../src/lib/src/builders/create_QueryBuilder_Helpers.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,mDAAmD;AACnD,MAAM,CAAC,MAAM,2BAA2B,GAAG,KAAK,EAC9C,WAAmB,EACnB,OAAiB,EACF,EAAE;IACjB,IAAI,CAAC;QACH,qDAAqD;QACrD,IAAI,OAAO,CAAC,QAAQ,KAAK,uBAAuB,EAAE,CAAC;YACjD,MAAM,yBAAyB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgGvC,CAAC;YACI,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,iBAAiB,EAAE,yBAAyB,CAAC,EACpE,yBAAyB,CAC1B,CAAC;QACJ,CAAC;QAED,mEAAmE;QACnE,IAAI,OAAO,CAAC,QAAQ,KAAK,wBAAwB,EAAE,CAAC;YAClD,MAAM,0BAA0B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0KxC,CAAC;YACI,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,iBAAiB,EAAE,uBAAuB,CAAC,EAClE,0BAA0B,CAC3B,CAAC;QACJ,CAAC;QAED,gDAAgD;QAChD,OAAO,CAAC,GAAG,CACT,KAAK,CAAC,KAAK,CAAC,kDAAkD,CAAC,CAChE,CAAC;IACJ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,wCAAwC;QACxC,OAAO,CAAC,KAAK,CACX,KAAK,CAAC,GAAG,CAAC,6CAA6C,CAAC,EACxD,GAAG,CACJ,CAAC;QACF,MAAM,GAAG,CAAC;IACZ,CAAC;AACH,CAAC,CAAC"}

package/dist/lib/src/config/create_Config_Index.d.ts

@@ -0,0 +1,9 @@
+import { TAnswers } from "../../utils/types.js";
+/**
+ * Creates a configuration index file with environment-based settings
+ * @param projectPath - Absolute path to the project root
+ * @param answers - User answers from CLI prompts
+ * @returns Promise that resolves when the config file is created
+ */
+export declare const create_Config_Configuration_Index_File: (projectPath: string, answers: TAnswers) => Promise<void>;
+//# sourceMappingURL=create_Config_Index.d.ts.map

package/dist/lib/src/config/create_Config_Index.d.ts.map

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

package/dist/lib/src/config/create_Config_Index.js

@@ -0,0 +1,92 @@
+import { createFile } from "../../utils/helpers.js";
+import path from "path";
+import chalk from "chalk";
+/**
+ * Creates a configuration index file with environment-based settings
+ * @param projectPath - Absolute path to the project root
+ * @param answers - User answers from CLI prompts
+ * @returns Promise that resolves when the config file is created
+ */
+export const create_Config_Configuration_Index_File = async (projectPath, answers) => {
+    try {
+        // Build configuration object conditionally based on user answers
+        let configContent = `import dotenv from 'dotenv';
+import path from 'path';
+
+// Load environment variables from .env file
+dotenv.config({ path: path.join(process.cwd(), '.env') });
+
+/**
+ * Ensure environment variable is set
+ * @param key - Environment variable key
+ * @returns Environment variable value
+ * @throws Error if environment variable is not set
+ */
+function ensureEnv(key: string): string {
+  const value = process.env[key];
+  if (!value) {
+    throw new Error(\`Environment variable \${key} is required but not set.\`);
+  }
+  return value;
+}
+
+/**
+ * Application configuration object
+ */
+const config = {
+  // Application settings
+  NODE_ENV: process.env.NODE_ENV || 'development',
+  port: Number(process.env.PORT) || 5000,
+  client_side_url: ensureEnv('CLIENT_SIDE_URL'),
+`;
+        // Add database configuration based on user selection
+        if (answers.database === "MongoDB with Mongoose") {
+            configContent += `
+  // MongoDB configuration
+  mongo_database_url: ensureEnv('MONGO_DATABASE_URL'),
+`;
+        }
+        else if (answers.database === "PostgreSQL with Prisma") {
+            configContent += `
+  // PostgreSQL configuration
+  database_url: ensureEnv('DATABASE_URL'),
+`;
+        }
+        // Add authentication configuration if selected
+        if (answers.includeAuth) {
+            configContent += `
+  // Authentication configuration
+  bcrypt_salt_rounds: Number(ensureEnv('BCRYPT_SALT_ROUNDS')),
+  jwt_access_token_secret: ensureEnv('JWT_ACCESS_TOKEN_SECRET'),
+  jwt_refresh_token_secret: ensureEnv('JWT_REFRESH_TOKEN_SECRET'),
+  jwt_access_token_expires_in: ensureEnv('JWT_ACCESS_TOKEN_EXPIRES_IN'),
+  jwt_refresh_token_expires_in: ensureEnv('JWT_REFRESH_TOKEN_EXPIRES_IN'),
+`;
+        }
+        // Always include email configuration
+        configContent += `
+  // Email configuration
+  email_host_provider_name: ensureEnv('EMAIL_HOST_PROVIDER_NAME'),
+  email_host_provider_port: Number(ensureEnv('EMAIL_HOST_PROVIDER_PORT')),
+  email_sender_email: ensureEnv('EMAIL_SENDER_EMAIL'),
+  email_sender_email_app_pass: ensureEnv('EMAIL_SENDER_EMAIL_APP_PASS'),
+  email_sender_name: process.env.EMAIL_SENDER_NAME || 'Your App Name',
+  email_reply_to: process.env.EMAIL_REPLY_TO,
+  email_test_recipient: process.env.EMAIL_TEST_RECIPIENT,
+`;
+        // Close the configuration object
+        configContent += `};
+
+export default config;
+`;
+        await createFile(path.join(projectPath, "src/app/config", "index.ts"), configContent);
+        // Success message with green checkmark and text
+        console.log(chalk.green("✅ Config index file created successfully"));
+    }
+    catch (err) {
+        // Error message with red cross and text
+        console.error(chalk.red("❌ Error creating config index file:"), err);
+        throw err;
+    }
+};
+//# sourceMappingURL=create_Config_Index.js.map

package/dist/lib/src/config/create_Config_Index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_Config_Index.js","sourceRoot":"","sources":["../../../../src/lib/src/config/create_Config_Index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B;;;;;GAKG;AACH,MAAM,CAAC,MAAM,sCAAsC,GAAG,KAAK,EACzD,WAAmB,EACnB,OAAiB,EACF,EAAE;IACjB,IAAI,CAAC;QACH,iEAAiE;QACjE,IAAI,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BvB,CAAC;QAEE,qDAAqD;QACrD,IAAI,OAAO,CAAC,QAAQ,KAAK,uBAAuB,EAAE,CAAC;YACjD,aAAa,IAAI;;;CAGtB,CAAC;QACE,CAAC;aAAM,IAAI,OAAO,CAAC,QAAQ,KAAK,wBAAwB,EAAE,CAAC;YACzD,aAAa,IAAI;;;CAGtB,CAAC;QACE,CAAC;QAED,+CAA+C;QAC/C,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;YACxB,aAAa,IAAI;;;;;;;CAOtB,CAAC;QACE,CAAC;QAED,qCAAqC;QACrC,aAAa,IAAI;;;;;;;;;CASpB,CAAC;QAEE,iCAAiC;QACjC,aAAa,IAAI;;;CAGpB,CAAC;QAEE,MAAM,UAAU,CACd,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,gBAAgB,EAAE,UAAU,CAAC,EACpD,aAAa,CACd,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/constants/create_UserRole_Constant.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates a user role constant file with predefined roles
+ * @param projectPath - Absolute path to the project root
+ * @returns Promise that resolves when the user role constant file is created
+ */
+export declare const create_UserRole_Constant: (projectPath: string) => Promise<void>;
+//# sourceMappingURL=create_UserRole_Constant.d.ts.map

package/dist/lib/src/constants/create_UserRole_Constant.d.ts.map

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