express-project-builder 1.0.38 → 1.0.39

package/README.md

@@ -228,43 +228,165 @@ my-test-project/
 - /src/app/builder/**PrismaQueryBuilder.ts** <br/>
   A fluent API for building complex SQL queries with Prisma. Simplifies dynamic query construction for search, filtering, sorting, pagination, and field selection in a chainable interface.
 
-  ```typescript
-  // In your controller/service:
-  import PrismaQueryBuilder from "../../builder/PrismaQueryBuilder";
-
-  // Extract query parameters from request (e.g., ?search=keyword&page=1&limit=10)
-  const { page, limit, sort, search, fields, ...filters } = req.query;
-
-  // Create a new query builder instance
-  const docQuery = new PrismaQueryBuilder(YourModel.find(), req.query)
-
-    // Search in specified text fields (e.g., name, description, category)
-    .search(["name", "description", "category"])
-
-    // Apply filters dynamically (e.g., status=active, category=tech)
-    .filter()
-
-    // Sort results (e.g., ?sort=name asc,sort=-createdAt desc)
-    .sort()
-
-    // Paginate results (e.g., ?page=1&limit=10)
-    .paginate()
-
-    // Select specific fields (e.g., ?fields=name,price,description)
-    .fields();
-
-  // Execute the query and get results
-  const result = await docQuery.modelQuery;
-
-  // Get pagination metadata (total count, page, limit, total pages)
-  const meta = await docQuery.countTotal();
+```typescript
+// ===============================
+// Example Usage: PrismaQueryBuilder
+// ===============================
+
+import PrismaQueryBuilder from "../../builder/PrismaQueryBuilder";
+import { prisma } from "../../shared/prisma";
+
+// -------------------------------------------------
+// Controller / Service Layer Example
+// -------------------------------------------------
+
+// Extract query parameters from request
+// Example request:
+// /api/docs?search=node&page=1&limit=10&sort=-createdAt&fields=name,price
+const { page, limit, sort, search, fields, ...filters } = req.query;
+
+/**
+ * Initialize Query Builder
+ *
+ * Parameters:
+ * 1. prisma.youModel -> Prisma model instance (table)
+ * 2. filters -> dynamic filters from query params
+ */
+const docQuery = new PrismaQueryBuilder(prisma.youModel, filters)
+
+  /**
+   * setBaseQuery()
+   * ------------------------------------
+   * Adds default conditions that will always apply
+   * to the query.
+   *
+   * Example use cases:
+   * - Soft delete filtering
+   * - Tenant based filtering
+   * - Default status filtering
+   */
+  .setBaseQuery({
+    isDeleted: false,
+  })
+
+  /**
+   * setSecretFields()
+   * ------------------------------------
+   * Prevents sensitive fields from being returned
+   * in API responses.
+   *
+   * Example:
+   * password, tokens, internal flags etc.
+   */
+  .setSecretFields(["isDeleted", "password", "sensetiveFileds"])
+
+  /**
+   * search()
+   * ------------------------------------
+   * Enables text search across multiple fields.
+   *
+   * Example request:
+   * ?search=node
+   *
+   * This will search "node" in:
+   * name OR description OR category
+   */
+  .search(["name", "description", "category"])
+
+  /**
+   * filter()
+   * ------------------------------------
+   * Applies dynamic filters from query params.
+   *
+   * Example request:
+   * ?status=active&category=tech
+   *
+   * Automatically converts query params
+   * into Prisma "where" conditions.
+   */
+  .filter()
+
+  /**
+   * sort()
+   * ------------------------------------
+   * Enables sorting of results.
+   *
+   * Example requests:
+   * ?sort=name
+   * ?sort=-createdAt
+   *
+   * "-" indicates descending order.
+   */
+  .sort()
+
+  /**
+   * paginate()
+   * ------------------------------------
+   * Applies pagination.
+   *
+   * Example request:
+   * ?page=2&limit=10
+   *
+   * Converts into:
+   * skip + take (Prisma pagination)
+   */
+  .paginate()
+
+  /**
+   * fields()
+   * ------------------------------------
+   * Allows selecting specific fields.
+   *
+   * Example request:
+   * ?fields=name,price,description
+   *
+   * Only these fields will be returned
+   * in the response.
+   */
+  .fields()
+
+  /**
+   * include()
+   * ------------------------------------
+   * Allows joining related tables using
+   * Prisma's include/select functionality.
+   *
+   * Example:
+   * Including related user/profile data
+   */
+  .include({
+    table_name: {
+      select: {
+        row_1: true,
+        row_2: true,
+      },
+    },
+  });
 
-  // Return the results and metadata from service
-  return {
-    result,
-    meta,
-  };
-  ```
+/**
+ * Execute the final query
+ */
+const result = await docQuery.execute();
+
+/**
+ * Get pagination metadata
+ *
+ * Returns:
+ * total records
+ * current page
+ * limit
+ * total pages
+ */
+const meta = await docQuery.countTotal();
+
+/**
+ * Final response format
+ */
+return {
+  result,
+  meta,
+};
+```
 
 - /src/**config/index.ts** <br/> Central configuration file that manages environment variables and application settings. This file provides a structured way to access environment variables throughout the application.
 

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

@@ -1 +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"}
+{"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,CA6ed,CAAC"}

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

@@ -108,22 +108,54 @@ export default QueryBuilder;
         // 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 baseWhereClause: any = {} // Priority query - cannot be overridden
+  private whereClause: any = {} // User filters
   private orderBy: any[] = []
   private selectFields: any = null
+  private includeRelations: any = null
   private skipValue: number | undefined
   private takeValue: number | undefined
+  private secretFields: string[] = [] // Fields that can NEVER be shown
+
   constructor(prismaModel: any, query: Record<string, unknown>) {
     this.prismaModel = prismaModel
     this.query = query
   }
+
+  /**
+   * Set base WHERE conditions that have PRIORITY and cannot be overridden
+   * These conditions are always applied regardless of user input
+   *
+   * @param baseWhere - Base WHERE conditions with priority
+   * @returns PrismaQueryBuilder instance for chaining
+   *
+   * @example
+   * .setBaseQuery({ ownerId: user.id, isDeleted: false })
+   * // User cannot override these conditions
+   */
+  setBaseQuery(baseWhere: Record<string, any>): this {
+    this.baseWhereClause = baseWhere
+    return this
+  }
+
+  /**
+   * Set fields that are SECRET and can NEVER be shown in output
+   * Even if user explicitly requests them via ?fields=password
+   *
+   * @param secretFields - Array of field names that must always be hidden
+   * @returns PrismaQueryBuilder instance for chaining
+   *
+   * @example
+   * .setSecretFields(['password', 'refreshToken', 'isDeleted'])
+   */
+  setSecretFields(secretFields: string[]): this {
+    this.secretFields = secretFields
+    return this
+  }
+
   /**
    * Add search functionality to the query
    * @param searchableFields - Array of fields to search in
@@ -132,37 +164,74 @@ class PrismaQueryBuilder<T extends Record<string, any>> {
   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'
-          }
-        }))
+      const searchConditions = searchableFields.map(field => ({
+        [field]: {
+          contains: searchTerm,
+          mode: 'insensitive' as const
+        }
+      }))
+
+      if (Object.keys(this.whereClause).length > 0) {
+        this.whereClause = {
+          AND: [{ ...this.whereClause }, { OR: searchConditions }]
+        }
+      } else {
+        this.whereClause = {
+          OR: searchConditions
+        }
       }
     }
     return this
   }
+
   /**
-   * Add filtering to the query
+   * Add filtering to the query (exact field = value matching)
+   * User filters are applied AFTER base query
    * @returns PrismaQueryBuilder instance for chaining
    */
   filter(): this {
     const queryObj = { ...this.query }
-    const excludeFields = ['search', 'sort', 'page', 'limit', 'fields']
+
+    const excludeFields = [
+      'search',
+      'sort',
+      'page',
+      'limit',
+      'fields',
+      'field',
+      'filelds',
+      'include',
+      'populate',
+      'select'
+    ]
+
     excludeFields.forEach(el => delete queryObj[el])
-    // Add the remaining query parameters to the where clause
+
+    // Remove any keys that match base query (prevent override)
+    Object.keys(this.baseWhereClause).forEach(key => {
+      delete queryObj[key]
+    })
+
     Object.entries(queryObj).forEach(([key, value]) => {
       if (value !== undefined && value !== null) {
-        this.whereClause = {
-          ...this.whereClause,
-          [key]: value
+        let processedValue = value
+        if (value === 'true') processedValue = true
+        if (value === 'false') processedValue = false
+
+        if (this.whereClause.AND || this.whereClause.OR) {
+          const existingClause = { ...this.whereClause }
+          this.whereClause = {
+            AND: [existingClause, { [key]: processedValue }]
+          }
+        } else {
+          this.whereClause[key] = processedValue
         }
       }
     })
+
     return this
   }
+
   /**
    * Add sorting to the query
    * @returns PrismaQueryBuilder instance for chaining
@@ -179,11 +248,11 @@ class PrismaQueryBuilder<T extends Record<string, any>> {
         }
       })
     } else {
-      // Default sort by createdAt in descending order
       this.orderBy = [{ createdAt: 'desc' }]
     }
     return this
   }
+
   /**
    * Add pagination to the query
    * @returns PrismaQueryBuilder instance for chaining
@@ -195,67 +264,171 @@ class PrismaQueryBuilder<T extends Record<string, any>> {
     this.takeValue = limit
     return this
   }
+
   /**
    * Field selection to include specific fields
+   * Secret fields are ALWAYS removed even if user requests them
+   *
    * @returns PrismaQueryBuilder instance for chaining
    */
   fields(): this {
-    const fields = this.query.fields as string
+    const fields = (this.query.fields ||
+      this.query.field ||
+      this.query.filelds) 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') {
+      const fieldArray = fields.split(',').map(f => f.trim())
+
+      // Filter out secret fields - user cannot request them
+      const allowedFields = fieldArray.filter(
+        field =>
+          !this.secretFields.includes(field) && field !== '__v' && field !== ''
+      )
+
+      if (allowedFields.length > 0) {
+        this.selectFields = allowedFields.reduce((acc, field) => {
           acc[field] = true
-        }
-        return acc
-      }, {} as any)
+          return acc
+        }, {} as any)
+      }
+    }
+
+    return this
+  }
+
+  /**
+   * Add relations to include with automatic secret field removal
+   *
+   * @param relations - Object defining which relations to include
+   * @param nestedSecretFields - Secret fields for nested relations
+   * @returns PrismaQueryBuilder instance for chaining
+   *
+   * @example
+   * .include(
+   *   {
+   *     owner: { select: { id: true, name: true, phone: true } },
+   *     posts: true
+   *   },
+   *   {
+   *     owner: ['password', 'refreshToken'],
+   *     posts: ['isDeleted', 'internalNotes']
+   *   }
+   * )
+   */
+  include(relations: any, nestedSecretFields?: Record<string, string[]>): this {
+    if (typeof relations === 'object' && relations !== null) {
+      // Process relations and apply secret field filtering
+      const processedRelations = { ...relations }
+
+      if (nestedSecretFields) {
+        Object.keys(processedRelations).forEach(relationName => {
+          const relation = processedRelations[relationName]
+          const secretFieldsForRelation = nestedSecretFields[relationName]
+
+          if (secretFieldsForRelation && relation !== true) {
+            // If relation has select, filter out secret fields
+            if (relation.select) {
+              secretFieldsForRelation.forEach(field => {
+                delete relation.select[field]
+              })
+            }
+          }
+        })
+      }
+
+      this.includeRelations = processedRelations
     }
     return this
   }
+
   /**
-   * Execute the query and return results with metadata
-   * @returns Object with data and pagination metadata
+   * Execute the query and return data
+   * Combines base query with user filters
+   * Removes secret fields from output
+   *
+   * @returns Array of data
    */
-  async execute(): Promise<{
-    data: T[]
-    meta: {
-      page: number
-      limit: number
-      totalData: number
-      totalPage: number
+  async execute(): Promise<T[]> {
+    // Combine base query (priority) with user filters
+    let finalWhereClause: any = {}
+
+    if (
+      Object.keys(this.baseWhereClause).length > 0 &&
+      Object.keys(this.whereClause).length > 0
+    ) {
+      // Both base and user filters exist - combine with AND
+      finalWhereClause = {
+        AND: [this.baseWhereClause, this.whereClause]
+      }
+    } else if (Object.keys(this.baseWhereClause).length > 0) {
+      // Only base query
+      finalWhereClause = this.baseWhereClause
+    } else if (Object.keys(this.whereClause).length > 0) {
+      // Only user filters
+      finalWhereClause = this.whereClause
     }
-  }> {
-    const page = Number(this.query.page) || 1
-    const limit = Number(this.query.limit) || 10
-    // Build the query parameters
+
     const queryOptions: any = {
-      where: this.whereClause,
+      where:
+        Object.keys(finalWhereClause).length > 0 ? finalWhereClause : undefined,
       orderBy: this.orderBy.length > 0 ? this.orderBy : undefined,
       skip: this.skipValue,
       take: this.takeValue
     }
-    // Add select if specified
-    if (this.selectFields) {
+
+    if (this.selectFields && !this.includeRelations) {
       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
-      }
+
+    if (this.includeRelations) {
+      queryOptions.include = this.includeRelations
+    }
+
+    let data = await this.prismaModel.findMany(queryOptions)
+
+    // Remove secret fields from output (post-processing for security)
+    if (this.secretFields.length > 0) {
+      data = this.removeSecretFields(data, this.secretFields)
     }
+
+    return data
+  }
+
+  /**
+   * Remove secret fields from data recursively (handles nested objects)
+   * @param data - Data to process
+   * @param secretFields - Fields to remove
+   * @returns Cleaned data
+   */
+  private removeSecretFields(data: any, secretFields: string[]): any {
+    if (Array.isArray(data)) {
+      return data.map(item => this.removeSecretFields(item, secretFields))
+    }
+
+    // ✅ IMPORTANT: Preserve Date objects
+    if (data instanceof Date) {
+      return data
+    }
+
+    if (data && typeof data === 'object') {
+      const cleaned: any = {}
+
+      Object.keys(data).forEach(key => {
+        if (!secretFields.includes(key)) {
+          cleaned[key] = this.removeSecretFields(data[key], secretFields)
+        }
+      })
+
+      return cleaned
+    }
+
+    return data
   }
+
   /**
-   * Get total count and pagination metadata without fetching data
+   * Get pagination metadata
+   * Uses combined WHERE clause (base + user filters)
+   *
    * @returns Object with pagination metadata
    */
   async countTotal(): Promise<{
@@ -266,8 +439,29 @@ class PrismaQueryBuilder<T extends Record<string, any>> {
   }> {
     const page = Number(this.query.page) || 1
     const limit = Number(this.query.limit) || 10
-    const totalData = await this.prismaModel.count({ where: this.whereClause })
+
+    // Combine base query with user filters for counting
+    let finalWhereClause: any = {}
+
+    if (
+      Object.keys(this.baseWhereClause).length > 0 &&
+      Object.keys(this.whereClause).length > 0
+    ) {
+      finalWhereClause = {
+        AND: [this.baseWhereClause, this.whereClause]
+      }
+    } else if (Object.keys(this.baseWhereClause).length > 0) {
+      finalWhereClause = this.baseWhereClause
+    } else if (Object.keys(this.whereClause).length > 0) {
+      finalWhereClause = this.whereClause
+    }
+
+    const totalData = await this.prismaModel.count({
+      where:
+        Object.keys(finalWhereClause).length > 0 ? finalWhereClause : undefined
+    })
     const totalPage = Math.ceil(totalData / limit)
+
     return {
       page,
       limit,
@@ -276,6 +470,7 @@ class PrismaQueryBuilder<T extends Record<string, any>> {
     }
   }
 }
+
 export default PrismaQueryBuilder
 `;
             await createFile(path.join(projectPath, "src/app/builder", "PrismaQueryBuilder.ts"), prismaQueryBuilderTemplate);

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

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6WxC,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "express-project-builder",
-  "version": "1.0.38",
+  "version": "1.0.39",
   "description": "A powerful and professional Express.js project generator CLI that instantly scaffolds a production-ready backend with TypeScript, modular architecture, and built-in support for MongoDB (Mongoose) or PostgreSQL (Prisma). Includes authentication, error handling, rate limiting, file upload, caching, and utility functions—so you can focus on building features instead of boilerplate. Perfect for kickstarting your next Express.js API project with best practices and modern tools.",
   "type": "module",
   "main": "dist/bin/index.js",