@rapidd/build 1.1.2 → 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.2",
+  "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

@@ -29,9 +29,20 @@ class Model {
         this.user_id = this.user ? this.user.id : null;
     }
 
+    get primaryKey(){
+        const pkey = this.queryBuilder.getPrimaryKey();
+        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);
+    _queryCreate = (data) => this.queryBuilder.create(data, this.user);
+    _queryUpdate = (id, data) => this.queryBuilder.update(id, data, this.user);
     // ACL METHODS
     _canCreate = () => this.acl.canCreate(this.user);
     _getAccessFilter = () => this.acl.getAccessFilter?.(this.user);
@@ -47,18 +58,19 @@ 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 = "id", sortOrder = "asc", options = {})=>{
+    _getMany = async (q = {}, include = "", limit = 25, offset = 0, sortBy = this.primaryKey, sortOrder = "asc", options = {})=>{
         const take = this.take(Number(limit));
         const skip = this.skip(Number(offset));
 
-        sortBy = sortBy.trim();
-        sortOrder = sortOrder.trim();
+        sortBy = sortBy?.trim();
+        sortOrder = sortOrder?.trim();
         if (!sortBy.includes('.') && this.fields[sortBy] == undefined) {
             throw new ErrorResponse(400, "invalid_sort_field", {sortBy, modelName: this.constructor.name});
         }
-
+        
         // Query the database using Prisma with filters, pagination, and limits
         const [data, total] = await prismaTransaction([
             (tx) => tx[this.name].findMany({
@@ -79,15 +91,16 @@ class Model {
     /**
      * @param {number} id
      * @param {string | Object} include
+     * @param {{}} [options={}]
      * @returns {Promise<{} | null>}
      */
     _get = async (id, include, options = {}) =>{
         const {omit, ..._options} = options;
-        id = Number(id);
+        console.log(JSON.stringify(this.include(include)));
         // To determine if the record is inaccessible, either due to non-existence or insufficient permissions, two simultaneous queries are performed.
         const _response = this.prisma.findUnique({
             'where': {
-                'id': id
+                [this.primaryKey]: id,
             },
             'include': this.include(include),
             'omit': {...this._omit(), ...omit},
@@ -96,7 +109,7 @@ class Model {
 
         const _checkPermission = this.prisma.findUnique({
             'where': {
-                'id': id,
+                [this.primaryKey]: id,
                 ...this.getAccessFilter()
             },
             'select': {
@@ -107,21 +120,22 @@ class Model {
         const [response, checkPermission] = await Promise.all([_response, _checkPermission]);
         if(response){
             if(checkPermission){
-                if(response.id != checkExistence?.id){   // IN CASE access_filter CONTAINS id FIELD
-                    throw new ErrorResponse(getTranslation("no_permission"), 403);
+                if(response.id != checkPermission?.id){   // IN CASE access_filter CONTAINS id FIELD
+                    throw new ErrorResponse(403, "no_permission");
                 }
             }
             else{
-                throw new ErrorResponse(getTranslation("no_permission"), 403);
+                throw new ErrorResponse(403, "no_permission");
             }
         }
         else{
-            throw new ErrorResponse(getTranslation("record_not_found"), 404);
+            throw new ErrorResponse(404, "record_not_found");
         }
         return response;
     }
     /**
      * @param {{}} data
+     * @param {{}} [options={}]
      * @returns {Promise<Object>}
      */
     _create = async (data, options = {}) => {
@@ -131,7 +145,7 @@ class Model {
         }
 
         // VALIDATE PASSED FIELDS AND RELATIONSHIPS
-        this.queryBuilder.create(data, this.user_id);
+        this._queryCreate(data);
 
         // CREATE
         return await this.prisma.create({
@@ -144,11 +158,12 @@ class Model {
     /**
      * @param {number} id
      * @param {{}} data
+     * @param {{}} [options={}]
      * @returns {Promise<Object>}
      */
     _update = async (id, data, options = {}) => {
-        id = Number(id);
-
+        delete data.createdAt;
+        delete data.createdBy;
         // CHECK UPDATE PERMISSION
         const updateFilter = this.getUpdateFilter();
         if (updateFilter === false) {
@@ -156,10 +171,10 @@ class Model {
         }
 
         // VALIDATE PASSED FIELDS AND RELATIONSHIPS
-        this.queryBuilder.update(id, data, this.user_id);
+        this._queryUpdate(id, data);
         const response = await this.prisma.update({
             'where': {
-                'id': id,
+                [this.primaryKey]: id,
                 ...updateFilter
             },
             'data': data,
@@ -172,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
@@ -185,11 +222,10 @@ class Model {
 
     /**
      * @param {number} id
+     * @param {{}} [options={}]
      * @returns {Promise<Object>}
      */
     _delete = async (id, options = {}) => {
-        id = Number(id);
-
         // CHECK DELETE PERMISSION
         const deleteFilter = this.getDeleteFilter();
         if (deleteFilter === false) {
@@ -198,7 +234,7 @@ class Model {
 
         const response = await this.prisma.delete({
             'where': {
-                id: parseInt(id),
+                [this.primaryKey]: id,
                 ...deleteFilter
             },
             'select': this.select(),
@@ -226,19 +262,31 @@ class Model {
     /**
      * @param {number} id
      * @param {string | Object} include
+     * @param {{}} [options={}]
      * @returns {Promise<{} | null>}
      */
     async get(id, include, options = {}){
-        return await this._get(Number(id), include, options);
+        return await this._get(id, include, options);
     }
 
     /**
      * @param {number} id
      * @param {{}} data
+     * @param {{}} [options={}]
      * @returns {Promise<Object>}
      */
     async update(id, data, options = {}){
-        return await this._update(Number(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);
     }
 
     /**
@@ -255,7 +303,7 @@ class Model {
      * @returns {Promise<Object>}
      */
     async delete(id, data, options = {}){
-        return await this._delete(Number(id), data, options);
+        return await this._delete(id, data, options);
     }
 
     select(fields){
@@ -329,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);
@@ -359,7 +405,7 @@ function generateRapiddFile(rapiddJsPath, isPostgreSQL = true) {
 
   if (isPostgreSQL) {
     // PostgreSQL version with RLS support
-    content = `const { PrismaClient } = require('../prisma/client');
+    content = `const { PrismaClient, Prisma } = require('../prisma/client');
 const { AsyncLocalStorage } = require('async_hooks');
 const acl = require('./acl');
 
@@ -373,13 +419,49 @@ const RLS_CONFIG = {
     userRole: process.env.RLS_USER_ROLE || 'current_user_role',
 };
 
-// Basis Prisma Client
+// =====================================================
+// BASE PRISMA CLIENTS
+// =====================================================
+
+/**
+ * ADMIN CLIENT - Bypasses ALL RLS
+ * Uses DATABASE_URL_ADMIN connection (e.g., app_auth_proxy user)
+ * Use ONLY for authentication operations:
+ * - Login
+ * - Register
+ * - Email Verification
+ * - Password Reset
+ * - OAuth operations
+ */
+const authPrisma = new PrismaClient({
+    datasources: {
+        db: {
+            url: process.env.DATABASE_URL_ADMIN
+        }
+    },
+    log: process.env.NODE_ENV === 'development' ? ['query', 'error', 'warn'] : ['error'],
+});
+
+/**
+ * BASE CLIENT - Regular user with RLS
+ * Uses DATABASE_URL connection
+ * Use for all business operations
+ */
 const basePrisma = new PrismaClient({
+    datasources: {
+        db: {
+            url: process.env.DATABASE_URL
+        }
+    },
     log: process.env.NODE_ENV === 'development' ? ['query', 'error', 'warn'] : ['error'],
 });
 
+// =====================================================
+// RLS HELPER FUNCTIONS
+// =====================================================
+
 /**
- * FIXED: Setze RLS Session Variables in PostgreSQL
+ * Set RLS Session Variables in PostgreSQL
  * Execute each SET command separately to avoid prepared statement error
  */
 async function setRLSVariables(tx, userId, userRole) {
@@ -387,27 +469,48 @@ async function setRLSVariables(tx, userId, userRole) {
     const userIdVar = RLS_CONFIG.userId;
     const userRoleVar = RLS_CONFIG.userRole;
 
-    // Execute SET commands separately (PostgreSQL doesn't allow multiple commands in prepared statements)
-    await tx.$executeRawUnsafe(\`SET LOCAL "\${namespace}"."\${userIdVar}" = '\${userId}'\`);
-    await tx.$executeRawUnsafe(\`SET LOCAL "\${namespace}"."\${userRoleVar}" = '\${userRole}'\`);
+    // Execute SET commands separately
+    await tx.$executeRawUnsafe(\`SET LOCAL \${namespace}.\${userIdVar} = '\${userId}'\`);
+    await tx.$executeRawUnsafe(\`SET LOCAL \${namespace}.\${userRoleVar} = '\${userRole}'\`);
 }
 
-// FIXED: Erweiterter Prisma mit automatischer RLS
+/**
+ * Reset RLS Session Variables
+ */
+async function resetRLSVariables(tx) {
+    const namespace = RLS_CONFIG.namespace;
+    const userIdVar = RLS_CONFIG.userId;
+    const userRoleVar = RLS_CONFIG.userRole;
+
+    try {
+        await tx.$executeRawUnsafe(\`RESET \${namespace}.\${userIdVar}\`);
+        await tx.$executeRawUnsafe(\`RESET \${namespace}.\${userRoleVar}\`);
+    } catch (e) {
+        // Ignore errors on reset
+        console.error('Failed to reset RLS variables:', e);
+    }
+}
+
+// =====================================================
+// EXTENDED PRISMA WITH AUTOMATIC RLS
+// =====================================================
+
+/**
+ * Extended Prisma Client with automatic RLS context
+ * Automatically wraps all operations in RLS context from AsyncLocalStorage
+ */
 const prisma = basePrisma.$extends({
     query: {
         async $allOperations({ operation, args, query, model }) {
             const context = requestContext.getStore();
 
-            // Kein Context = keine RLS (z.B. System-Operationen)
+            // No context = no RLS (e.g., system operations)
             if (!context?.userId || !context?.userRole) {
                 return query(args);
             }
 
             const { userId, userRole } = context;
 
-            // IMPORTANT: The entire operation must happen in ONE transaction
-            // We need to wrap the ENTIRE query execution in a single transaction
-
             // For operations that are already transactions, just set the variables
             if (operation === '$transaction') {
                 return basePrisma.$transaction(async (tx) => {
@@ -422,7 +525,6 @@ const prisma = basePrisma.$extends({
                 await setRLSVariables(tx, userId, userRole);
 
                 // Execute the original query using the transaction client
-                // This is the key: we need to use the transaction client for the query
                 if (model) {
                     // Model query (e.g., user.findMany())
                     return tx[model][operation](args);
@@ -435,70 +537,31 @@ const prisma = basePrisma.$extends({
     },
 });
 
-// Helper for batch operations in single transaction
+// =====================================================
+// TRANSACTION HELPERS
+// =====================================================
+
+/**
+ * Helper for batch operations in single transaction
+ */
 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)));
     });
 }
 
-// Alternative approach: Manual transaction wrapper
-class PrismaWithRLS {
-    constructor() {
-        this.client = basePrisma;
-    }
-
-    /**
-     * Execute any Prisma operation with RLS context
-     */
-    async withRLS(userId, userRole, callback) {
-        return this.client.$transaction(async (tx) => {
-            // Execute SET commands separately to avoid prepared statement error
-            await tx.$executeRawUnsafe(\`SET LOCAL app.current_user_id = '\${userId}'\`);
-            await tx.$executeRawUnsafe(\`SET LOCAL app.current_user_role = '\${userRole}'\`);
-
-            // Execute callback with transaction client
-            return callback(tx);
-        });
-    }
-
-    /**
-     * Get a proxy client for a specific user
-     * This wraps ALL operations in RLS context
-     */
-    forUser(userId, userRole) {
-        const withRLS = this.withRLS.bind(this);
-        const client = this.client;
-
-        return new Proxy({}, {
-            get(target, model) {
-                // Return a proxy for the model
-                return new Proxy({}, {
-                    get(modelTarget, operation) {
-                        // Return a function that wraps the operation
-                        return async (args) => {
-                            return withRLS(userId, userRole, async (tx) => {
-                                return tx[model][operation](args);
-                            });
-                        };
-                    }
-                });
-            }
-        });
-    }
-}
-
-const prismaWithRLS = new PrismaWithRLS();
+// =====================================================
+// CONTEXT HELPERS
+// =====================================================
 
 /**
  * Express Middleware: Set RLS context from authenticated user
+ * Use this AFTER your authentication middleware
  */
 function setRLSContext(req, res, next) {
     if (req.user) {
@@ -516,74 +579,50 @@ function setRLSContext(req, res, next) {
 }
 
 /**
- * Helper: System-Operationen ohne RLS (für Cron-Jobs, etc.)
- */
-async function withSystemAccess(callback) {
-    // For system access, we might not want RLS at all
-    // So we use the base client directly
-    return callback(basePrisma);
-}
-
-/**
- * Helper: Als bestimmter User ausführen (für Tests)
- */
-async function withUser(userId, userRole, callback) {
-    return requestContext.run({ userId, userRole }, () => callback());
-}
-
-/**
- * Helper: Direct transaction with RLS for complex operations
- */
-async function transactionWithRLS(userId, userRole, callback) {
-    return basePrisma.$transaction(async (tx) => {
-        // Set RLS context for this transaction - execute separately
-        await tx.$executeRawUnsafe(\`SET LOCAL app.current_user_id = '\${userId}'\`);
-        await tx.$executeRawUnsafe(\`SET LOCAL app.current_user_role = '\${userRole}'\`);
-
-        // Execute callback with transaction client
-        return callback(tx);
-    });
-}
-
-/**
- * Helper: Hole RLS Config (für SQL Generation)
+ * Get RLS Config (for SQL generation)
  */
 function getRLSConfig() {
     return RLS_CONFIG;
 }
 
-// Example usage in route
-/*
-app.get('/api/users', authenticateUser, setRLSContext, async (req, res) => {
-    // Option 1: Using extended prisma (automatic RLS)
-    const users = await prisma.user.findMany();
-
-    // Option 2: Using manual transaction
-    const users = await transactionWithRLS(req.user.id, req.user.role, async (tx) => {
-        return tx.user.findMany();
-    });
+// =====================================================
+// GRACEFUL SHUTDOWN
+// =====================================================
 
-    // Option 3: Using forUser helper
-    const userPrisma = prismaWithRLS.forUser(req.user.id, req.user.role);
-    const users = await userPrisma.user.findMany();
+async function disconnectAll() {
+    await authPrisma.$disconnect();
+    await basePrisma.$disconnect();
+}
 
-    res.json(users);
+process.on('beforeExit', async () => {
+    await disconnectAll();
 });
-*/
+
+// =====================================================
+// EXPORTS
+// =====================================================
 
 module.exports = {
-    prisma,
+    // Main clients
+    prisma,              // Use for regular operations with automatic RLS from context
+    authPrisma,          // Use ONLY for auth operations (login, register, etc.)
+
+    // Transaction helpers
     prismaTransaction,
-    basePrisma, // Export base for auth operations that don't need RLS
-    PrismaClient,
+
+    // Context helpers
     requestContext,
     setRLSContext,
-    withSystemAccess,
-    withUser,
-    transactionWithRLS,
-    prismaWithRLS,
-    getRLSConfig,
+
+    // RLS utilities
     setRLSVariables,
+    resetRLSVariables,
+    getRLSConfig,
+
+    // Utilities
+    disconnectAll,
+    PrismaClient,
+    Prisma,
     acl
 };
 `;
@@ -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/modelGenerator.js

@@ -37,7 +37,7 @@ class ${className} extends Model {
      * @returns {{} | null}
      */
     async get(id, include){
-        return await this._get(Number(id), include);
+        return await this._get(id, include);
     }
 
     /**
@@ -54,7 +54,7 @@ class ${className} extends Model {
      * @returns {Object}
      */
     async update(id, data){
-        return await this._update(Number(id), data);
+        return await this._update(id, data);
     }
 
     /**
@@ -62,7 +62,7 @@ class ${className} extends Model {
      * @returns {Object}
      */
     async delete(id){
-        return await this._delete(Number(id));
+        return await this._delete(id);
     }
 
     /**

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;
   }
 }