@rapidd/core 2.1.1 → 2.1.2

package/main.ts

@@ -16,6 +16,12 @@ export async function start(): Promise<void> {
         await app.listen({ port, host });
         console.log(`[Rapidd] Server running at http://${host}:${port}`);
         console.log(`[Rapidd] Environment: ${getEnv('NODE_ENV')}`);
+
+        // Warn if running compiled build with development NODE_ENV
+        if (process.argv[1]?.includes('/dist/') && getEnv('NODE_ENV') === 'development') {
+            console.warn('[Rapidd] Warning: Running compiled build with NODE_ENV=development.');
+            console.warn('[Rapidd] Set NODE_ENV=production in your .env for production use.');
+        }
     } catch (err) {
         console.error('[Startup Error]', (err as Error).message);
         process.exit(1);

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "Code-first REST API framework for TypeScript. Database in, API out.",
   "main": "dist/main.js",
   "bin": {
@@ -83,7 +83,7 @@
     "pg": "^8.16.3"
   },
   "devDependencies": {
-    "@rapidd/build": "^2.1.3",
+    "@rapidd/build": "^2.1.5",
     "@types/bcrypt": "^6.0.0",
     "@types/ejs": "^3.1.5",
     "@types/jest": "^30.0.0",

package/src/app.ts

@@ -22,6 +22,13 @@ import rlsPlugin from './plugins/rls';
 
 import type { RapiddOptions } from './types';
 
+// ─── BigInt Serialization ────────────────────────────
+// Prisma returns BigInt values that JSON.stringify cannot handle natively.
+// This polyfill converts them to strings during serialization.
+(BigInt.prototype as any).toJSON = function () {
+    return this.toString();
+};
+
 // ─── Path Setup ─────────────────────────────────────
 // Use process.cwd() as the project root — works from both source (tsx) and compiled (dist/) contexts.
 

package/src/orm/Model.ts

@@ -177,6 +177,7 @@ class Model {
         const field = this.fields[fieldName];
         if (!field) return value;
         if (field.type === 'Int') return parseInt(value, 10);
+        if (field.type === 'BigInt') return BigInt(value);
         if (field.type === 'Float' || field.type === 'Decimal') return parseFloat(value);
         if (field.type === 'Boolean') return value === 'true';
         return value;
@@ -239,10 +240,13 @@ class Model {
         sortBy = sortBy?.trim();
         sortOrder = sortOrder?.trim();
 
-        // Validate sort field - fall back to default for composite PK names
+        // Validate sort field - fall back to default for composite PK names or missing 'id'
         if (!sortBy.includes('.') && this.fields[sortBy] == undefined) {
-            // If the sortBy is a composite key name (e.g., "email_companyId"), use first PK field
             if (sortBy === this.primaryKey && this.isCompositePK) {
+                // Composite key name (e.g., "email_companyId") → use first PK field
+                sortBy = this.defaultSortField;
+            } else if (sortBy === 'id') {
+                // Model doesn't have an 'id' field → fall back to actual primary key
                 sortBy = this.defaultSortField;
             } else {
                 throw new ErrorResponse(400, "invalid_sort_field", { sortBy, modelName: this.constructor.name });

package/src/orm/QueryBuilder.ts

@@ -501,10 +501,10 @@ class QueryBuilder {
     /**
      * Parse numeric filter operators
      */
-    #filterNumber(value: string): Record<string, number> | null {
+    #filterNumber(value: string): Record<string, number | bigint> | null {
         const numOperators = ['lt:', 'lte:', 'gt:', 'gte:', 'eq:', 'ne:', 'between:'];
         const foundOperator = numOperators.find((op: string) => value.startsWith(op));
-        let numValue: string | number = value;
+        let numValue: string = value;
         let prismaOp = 'equals';
 
         if (foundOperator) {
@@ -517,19 +517,36 @@ class QueryBuilder {
                 case 'eq:': prismaOp = 'equals'; break;
                 case 'ne:': prismaOp = 'not'; break;
                 case 'between:': {
-                    // Support between for decimals: between:1.5;3.7
-                    const [start, end] = (numValue as string).split(';').map((v: string) => parseFloat(v.trim()));
-                    if (isNaN(start) || isNaN(end)) return null;
+                    const parts = numValue.split(';').map((v: string) => v.trim());
+                    const [startStr, endStr] = parts;
+                    const start = this.#parseNumericValue(startStr);
+                    const end = this.#parseNumericValue(endStr);
+                    if (start == null || end == null) return null;
                     return { gte: start, lte: end };
                 }
             }
         }
 
-        // Support decimal numbers
-        numValue = parseFloat(numValue as string);
-        if (isNaN(numValue)) return null;
+        const parsed = this.#parseNumericValue(numValue);
+        if (parsed == null) return null;
 
-        return { [prismaOp]: numValue };
+        return { [prismaOp]: parsed };
+    }
+
+    /**
+     * Parse a numeric string, returning BigInt for integers beyond safe range
+     */
+    #parseNumericValue(value: string): number | bigint | null {
+        if (value.includes('.')) {
+            const num = parseFloat(value);
+            return isNaN(num) ? null : num;
+        }
+        const num = Number(value);
+        if (isNaN(num)) return null;
+        if (!Number.isSafeInteger(num)) {
+            try { return BigInt(value); } catch { return null; }
+        }
+        return num;
     }
 
     /**