@rapidd/build 1.1.3 → 1.2.0

package/README.md

@@ -13,6 +13,11 @@ Dynamic code generator that transforms Prisma schemas into complete Express.js C
 - 🗺️ **Relationships JSON** - Generates complete relationship mappings with foreign keys
 - ⚡ **Selective Generation** - Update only specific models or components
 
+## Requirements
+
+- **Prisma 7+** (recommended) - Full support for Prisma 7's new architecture
+- Node.js 14.0.0 or higher
+
 ## Installation
 
 ```bash
@@ -155,6 +160,27 @@ npx rapidd build --model user --only model
 npx rapidd build --model user --only acl
 ```
 
+## Migration from Prisma 6 to 7
+
+If you're upgrading from Prisma 6, this package now automatically:
+
+1. **Uses `@prisma/internals`** for DMMF access (no longer relies on generated client)
+2. **Reads database URL** from multiple sources in order:
+   - `prisma.config.ts` (Prisma 7 default)
+   - Schema file `datasource.url` (Prisma 5/6 style)
+   - `DATABASE_URL` environment variable
+3. **Maintains full compatibility** - no changes needed to your workflow
+
+Simply update your dependencies and rebuild:
+
+```bash
+npm install @rapidd/build@latest
+npm install prisma@^7.0.0 @prisma/client@^7.0.0
+npx rapidd build
+```
+
+For more details on Prisma 7 migration, see the [official Prisma upgrade guide](https://www.prisma.io/docs/orm/more/upgrade-guides/upgrading-versions/upgrading-to-prisma-7).
+
 ## License
 
 MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rapidd/build",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "description": "Dynamic code generator that transforms Prisma schemas into Express.js CRUD APIs with PostgreSQL RLS-to-JavaScript translation",
   "main": "index.js",
   "bin": {
@@ -49,15 +49,18 @@
     "README.md"
   ],
   "dependencies": {
-    "@prisma/client": "^5.0.0",
+    "@prisma/adapter-planetscale": "^7.0.1",
+    "@prisma/client": "^7.0.0",
+    "@prisma/internals": "^7.0.0",
     "commander": "^11.0.0",
     "dotenv": "^16.0.0",
-    "pg": "^8.16.3"
+    "pg": "^8.16.3",
+    "undici": "^7.16.0"
   },
   "devDependencies": {
-    "prisma": "^5.0.0"
+    "prisma": "^7.0.0"
   },
   "peerDependencies": {
-    "@prisma/client": "^5.0.0"
+    "@prisma/client": "^7.0.0"
   }
 }

package/src/commands/build.js

@@ -34,6 +34,10 @@ class Model {
         return Array.isArray(pkey) ? pkey.join('_') : pkey;
     }
 
+    get fields(){
+        return this.queryBuilder.fields;
+    }
+
     _select = (fields) => this.queryBuilder.select(fields);
     _filter = (q) => this.queryBuilder.filter(q);
     _include = (include) => this.queryBuilder.include(include, this.user);
@@ -54,6 +58,7 @@ class Model {
      * @param {number} offset
      * @param {string} sortBy
      * @param {'asc'|'desc'} sortOrder
+     * @param {{}} [options={}]
      * @returns {Promise<Object[]>}
      */
     _getMany = async (q = {}, include = "", limit = 25, offset = 0, sortBy = this.primaryKey, sortOrder = "asc", options = {})=>{
@@ -86,6 +91,7 @@ class Model {
     /**
      * @param {number} id
      * @param {string | Object} include
+     * @param {{}} [options={}]
      * @returns {Promise<{} | null>}
      */
     _get = async (id, include, options = {}) =>{
@@ -129,6 +135,7 @@ class Model {
     }
     /**
      * @param {{}} data
+     * @param {{}} [options={}]
      * @returns {Promise<Object>}
      */
     _create = async (data, options = {}) => {
@@ -151,6 +158,7 @@ class Model {
     /**
      * @param {number} id
      * @param {{}} data
+     * @param {{}} [options={}]
      * @returns {Promise<Object>}
      */
     _update = async (id, data, options = {}) => {
@@ -179,6 +187,28 @@ class Model {
         throw new ErrorResponse(403, "no_permission");
     }
 
+    /**
+     * @param {{}} data
+     * @param {string} [unique_key=this.primaryKey]
+     * @param {{}} [options={}]
+     * @returns {Promise<Object>}
+     */
+    async _upsert(data, unique_key = this.primaryKey, options = {}){
+        const createData = data;
+        const updateData = JSON.parse(JSON.stringify(data));
+        this.queryBuilder.create(createData, this.user);
+        this.queryBuilder.update(updateData, this.user);
+        return await this.prisma.upsert({
+            'where': {
+                [unique_key]: data[unique_key]
+            },
+            'create': createData,
+            'update': updateData,
+            'include': this.include('ALL'),
+            ...options
+        });
+    }
+
     /**
      *
      * @param {string} q
@@ -192,6 +222,7 @@ class Model {
 
     /**
      * @param {number} id
+     * @param {{}} [options={}]
      * @returns {Promise<Object>}
      */
     _delete = async (id, options = {}) => {
@@ -231,6 +262,7 @@ class Model {
     /**
      * @param {number} id
      * @param {string | Object} include
+     * @param {{}} [options={}]
      * @returns {Promise<{} | null>}
      */
     async get(id, include, options = {}){
@@ -240,12 +272,23 @@ class Model {
     /**
      * @param {number} id
      * @param {{}} data
+     * @param {{}} [options={}]
      * @returns {Promise<Object>}
      */
     async update(id, data, options = {}){
         return await this._update(id, data, options);
     }
 
+    /**
+     * @param {{}} data
+     * @param {string} [unique_key=this.primaryKey]
+     * @param {{}} [options={}]
+     * @returns {Promise<Object>}
+     */
+    async upsert(data, unique_key = this.primaryKey, options = {}){
+        return await this._upsert(data, unique_key, options);
+    }
+
     /**
      *
      * @param {string} q
@@ -334,15 +377,13 @@ class Model {
     set modelName (name){
         this.name = name;
         this.prisma = prisma[name];
-        this.fields = this.prisma.fields;
     }
 
     static relatedObjects = [];
     static Error = ErrorResponse;
 }
 
-module.exports = {Model, QueryBuilder, prisma};
-`;
+module.exports = {Model, QueryBuilder, prisma};`;
 
   // Ensure src directory exists
   const srcDir = path.dirname(modelJsPath);
@@ -506,12 +547,10 @@ const prisma = basePrisma.$extends({
 async function prismaTransaction(operations) {
     const context = requestContext.getStore();
 
-    if (!context?.userId || !context?.userRole) {
-        return Promise.all(operations);
-    }
-
     return basePrisma.$transaction(async (tx) => {
-        await setRLSVariables(tx, context.userId, context.userRole);
+        if (context?.userId && context?.userRole) {
+            await setRLSVariables(tx, context.userId, context.userRole);
+        }
         return Promise.all(operations.map(op => op(tx)));
     });
 }
@@ -623,7 +662,7 @@ module.exports = {
 /**
  * Update relationships.json for a specific model
  */
-async function updateRelationshipsForModel(filteredModels, relationshipsPath, prismaClientPath, schemaPath, usedDMMF) {
+async function updateRelationshipsForModel(filteredModels, relationshipsPath, schemaPath, usedDMMF) {
   let existingRelationships = {};
 
   // Load existing relationships if file exists
@@ -641,7 +680,7 @@ async function updateRelationshipsForModel(filteredModels, relationshipsPath, pr
     // Use DMMF to get relationships for specific model
     const { generateRelationshipsFromDMMF } = require('../generators/relationshipsGenerator');
     const tempPath = relationshipsPath + '.tmp';
-    await generateRelationshipsFromDMMF(prismaClientPath, tempPath);
+    await generateRelationshipsFromDMMF(schemaPath, tempPath);
     const allRelationships = JSON.parse(fs.readFileSync(tempPath, 'utf8'));
     fs.unlinkSync(tempPath);
 
@@ -835,15 +874,14 @@ async function buildModels(options) {
     console.warn('Continuing with schema parsing fallback...\n');
   }
 
-  // Try to use Prisma DMMF first (if prisma generate has been run)
+  // Try to use Prisma DMMF first (using @prisma/internals getDMMF)
   let parsedData = null;
-  const prismaClientPath = path.join(process.cwd(), 'prisma', 'client');
   let usedDMMF = false;
 
   try {
-    parsedData = await parsePrismaDMMF(prismaClientPath);
+    parsedData = await parsePrismaDMMF(schemaPath);
     if (parsedData) {
-      console.log('Using Prisma generated client (DMMF)');
+      console.log('Using Prisma DMMF (via @prisma/internals)');
       usedDMMF = true;
     }
   } catch (error) {
@@ -899,11 +937,14 @@ async function buildModels(options) {
   }
 
   // Parse datasource to determine database type
-  let datasource = { isPostgreSQL: true };  // Default to PostgreSQL
+  let datasource = { isPostgreSQL: true, url: null };  // Default to PostgreSQL
   try {
     datasource = parseDatasource(schemaPath);
   } catch (error) {
-    console.warn('Could not parse datasource, assuming PostgreSQL:', error.message);
+    // Only warn if it's not the expected "No url found" error in Prisma 7
+    if (!error.message.includes('No url found')) {
+      console.warn('Could not parse datasource, assuming PostgreSQL:', error.message);
+    }
   }
 
   // Generate rapidd/rapidd.js if it doesn't exist
@@ -919,11 +960,11 @@ async function buildModels(options) {
     try {
       if (options.model) {
         // Update only specific model in relationships.json
-        await updateRelationshipsForModel(filteredModels, relationshipsPath, prismaClientPath, schemaPath, usedDMMF);
+        await updateRelationshipsForModel(filteredModels, relationshipsPath, schemaPath, usedDMMF);
       } else {
         // Generate all relationships
         if (usedDMMF) {
-          await generateRelationshipsFromDMMF(prismaClientPath, relationshipsPath);
+          await generateRelationshipsFromDMMF(schemaPath, relationshipsPath);
         } else {
           generateRelationshipsFromSchema(schemaPath, relationshipsPath);
         }

package/src/generators/relationshipsGenerator.js

@@ -184,12 +184,12 @@ function generateRelationshipsFromSchema(schemaPath, outputPath) {
 
 /**
  * Generate relationships.json from DMMF
- * @param {string} prismaClientPath - Path to Prisma client
+ * @param {string} schemaPath - Path to Prisma schema file
  * @param {string} outputPath - Path to output relationships.json
  */
-async function generateRelationshipsFromDMMF(prismaClientPath, outputPath) {
+async function generateRelationshipsFromDMMF(schemaPath, outputPath) {
   const { parsePrismaDMMF } = require('../parsers/prismaParser');
-  const parsedData = await parsePrismaDMMF(prismaClientPath);
+  const parsedData = await parsePrismaDMMF(schemaPath);
   generateRelationships(parsedData.models, outputPath);
 }
 

package/src/parsers/datasourceParser.js

@@ -8,6 +8,39 @@ try {
   // dotenv not available, skip
 }
 
+/**
+ * Try to load DATABASE_URL from prisma.config.ts (Prisma 7)
+ * @returns {string|null} - Database URL or null if not found
+ */
+function loadUrlFromPrismaConfig() {
+  const configPath = path.join(process.cwd(), 'prisma.config.ts');
+
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    const configContent = fs.readFileSync(configPath, 'utf-8');
+
+    // Look for env('DATABASE_URL') or similar patterns
+    const envMatch = configContent.match(/env\(['"]([^'"]+)['"]\)/);
+    if (envMatch) {
+      const envVar = envMatch[1];
+      return process.env[envVar] || null;
+    }
+
+    // Look for direct URL assignment
+    const urlMatch = configContent.match(/url:\s*['"]([^'"]+)['"]/);
+    if (urlMatch) {
+      return urlMatch[1];
+    }
+  } catch (e) {
+    // Failed to read config, return null
+  }
+
+  return null;
+}
+
 /**
  * Parse datasource configuration from Prisma schema
  * @param {string} schemaPath - Path to Prisma schema file
@@ -30,26 +63,32 @@ function parseDatasource(schemaPath) {
   const providerMatch = datasourceBlock.match(/provider\s*=\s*"([^"]+)"/);
   const provider = providerMatch ? providerMatch[1] : null;
 
-  // Extract url
+  // Try to extract url from schema first
+  let url = null;
   const urlMatch = datasourceBlock.match(/url\s*=\s*(.+)/);
-  if (!urlMatch) {
-    throw new Error('No url found in datasource block');
-  }
 
-  let url = urlMatch[1].trim();
+  if (urlMatch) {
+    url = urlMatch[1].trim();
+
+    // Handle env() function
+    const envMatch = url.match(/env\(["']([^"']+)["']\)/);
+    if (envMatch) {
+      const envVar = envMatch[1];
+      url = process.env[envVar];
+    } else {
+      // Remove quotes if present
+      url = url.replace(/^["']|["']$/g, '');
+    }
+  }
 
-  // Handle env() function
-  const envMatch = url.match(/env\(["']([^"']+)["']\)/);
-  if (envMatch) {
-    const envVar = envMatch[1];
-    url = process.env[envVar];
+  // If no URL in schema, try prisma.config.ts (Prisma 7)
+  if (!url) {
+    url = loadUrlFromPrismaConfig();
+  }
 
-    if (!url) {
-      throw new Error(`Environment variable ${envVar} is not defined`);
-    }
-  } else {
-    // Remove quotes if present
-    url = url.replace(/^["']|["']$/g, '');
+  // If still no URL, check DATABASE_URL environment variable directly
+  if (!url) {
+    url = process.env.DATABASE_URL || null;
   }
 
   // Detect PostgreSQL from provider OR from the actual connection URL

package/src/parsers/prismaParser.js

@@ -1,5 +1,4 @@
 const fs = require('fs');
-const path = require('path');
 
 /**
  * Extract blocks (model or enum) with proper brace matching
@@ -204,16 +203,26 @@ function parseEnumValues(enumBody) {
 }
 
 /**
- * Use Prisma's generated DMMF (Data Model Meta Format) to get model information
+ * Use Prisma's DMMF (Data Model Meta Format) to get model information
  * This is an alternative approach that uses Prisma's own abstraction
- * @param {string} prismaClientPath - Path to generated Prisma Client
+ * In Prisma 7, we use getDMMF from @prisma/internals instead of accessing it from the client
+ * @param {string} schemaPath - Path to Prisma schema file
  * @returns {Object} - Models extracted from DMMF
  */
-async function parsePrismaDMMF(prismaClientPath) {
+async function parsePrismaDMMF(schemaPath) {
   try {
-    // Try to load the generated Prisma Client
-    const prismaClient = require(prismaClientPath);
-    const dmmf = prismaClient.Prisma.dmmf;
+    // In Prisma 7, DMMF is no longer exposed on the client
+    // We need to use getDMMF from @prisma/internals instead
+    const { getDMMF } = require('@prisma/internals');
+    const fs = require('fs');
+
+    // Read the schema file
+    const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
+
+    // Get DMMF from the schema
+    const dmmf = await getDMMF({
+      datamodel: schemaContent
+    });
 
     const models = {};
 
@@ -266,7 +275,8 @@ async function parsePrismaDMMF(prismaClientPath) {
 
     return { models, enums: dmmf.datamodel.enums };
   } catch (error) {
-    console.warn('Could not load Prisma Client DMMF, falling back to schema parsing');
+    console.warn('Could not use getDMMF from @prisma/internals, falling back to schema parsing');
+    console.warn('Error:', error.message);
     return null;
   }
 }