@rapidd/build 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rapidd/build",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Dynamic code generator that transforms Prisma schemas into Express.js CRUD APIs with PostgreSQL RLS-to-JavaScript translation",
   "main": "index.js",
   "bin": {

package/src/commands/build.js

@@ -12,7 +12,8 @@ const { generateAllRoutes } = require('../generators/routeGenerator');
  */
 function generateBaseModelFile(modelJsPath) {
   const content = `const { QueryBuilder, prisma } = require("./QueryBuilder");
-const {ErrorResponse, getTranslation} = require('./Api');
+const {rls} = require('../../rapidd/rapidd');
+const {ErrorResponse} = require('./Api');
 
 class Model {
     /**
@@ -21,17 +22,23 @@ class Model {
          */
     constructor(name, options){
         this.modelName = name;
+        this.queryBuilder = new QueryBuilder(name);
+        this.rls = rls.model[name] || {};
         this.options = options || {}
         this.user = this.options.user || {'id': 1, 'role': 'application'};
         this.user_id = this.user ? this.user.id : null;
     }
 
-    _select = (fields) => this.constructor.queryBuilder.select(fields);
-    _filter = (q) => this.constructor.queryBuilder.filter(q);
-    _include = (include) => this.constructor.queryBuilder.include(include, this.user);
-    _getAccessFilter = () => this.constructor.getAccessFilter(this.user);
-    _hasAccess = (data) => this.constructor.hasAccess(data, this.user) || false;
-    _omit = () => this.constructor.queryBuilder.omit(this.user);
+    _select = (fields) => this.queryBuilder.select(fields);
+    _filter = (q) => this.queryBuilder.filter(q);
+    _include = (include) => this.queryBuilder.include(include, this.user);
+    // RLS METHODS
+    _canCreate = () => this.rls?.canCreate?.(this.user);
+    _hasAccess = (data) => this.rls?.hasAccess?.(data, this.user) || false;
+    _getAccessFilter = () => this.rls?.getAccessFilter?.(this.user);
+    _getUpdateFilter = () => this.rls?.getUpdateFilter?.(this.user);
+    _getDeleteFilter = () => this.rls?.getDeleteFilter?.(this.user);
+    _omit = () => this.queryBuilder.omit(this.user);
 
     /**
      *
@@ -50,8 +57,7 @@ class Model {
         sortBy = sortBy.trim();
         sortOrder = sortOrder.trim();
         if (!sortBy.includes('.') && this.fields[sortBy] == undefined) {
-            const message = getTranslation("invalid_sort_field", {sortBy, modelName: this.constructor.name});
-            throw new ErrorResponse(message, 400);
+            throw new ErrorResponse(400, "invalid_sort_field", {sortBy, modelName: this.constructor.name});
         }
 
         // Query the database using Prisma with filters, pagination, and limits
@@ -114,8 +120,13 @@ class Model {
      * @returns {Promise<Object>}
      */
     _create = async (data, options = {}) => {
+        // CHECK CREATE PERMISSION
+        if (!this.canCreate()) {
+            throw new ErrorResponse(403, "no_permission_to_create");
+        }
+
         // VALIDATE PASSED FIELDS AND RELATIONSHIPS
-        this.constructor.queryBuilder.create(data, this.user_id);
+        this.queryBuilder.create(data, this.user_id);
 
         // CREATE
         return await this.prisma.create({
@@ -132,19 +143,28 @@ class Model {
      */
     _update = async (id, data, options = {}) => {
         id = Number(id);
-        // GET DATA FIRST
-        const current_data = await this._get(id, "ALL");
+
+        // CHECK UPDATE PERMISSION
+        const updateFilter = this.getUpdateFilter();
+        if (updateFilter === false) {
+            throw new ErrorResponse(403, "no_permission_to_update");
+        }
 
         // VALIDATE PASSED FIELDS AND RELATIONSHIPS
-        this.constructor.queryBuilder.update(id, data, this.user_id);
-        return await this.prisma.update({
+        this.queryBuilder.update(id, data, this.user_id);
+        const response = await this.prisma.update({
             'where': {
-                'id': id
+                'id': id,
+                ...updateFilter
             },
             'data': data,
             'include': this.include('ALL'),
             ...options
         });
+        if(response){
+            return response;
+        }
+        throw new ErrorResponse(403, "no_permission");
     }
 
     /**
@@ -163,16 +183,26 @@ class Model {
      * @returns {Promise<Object>}
      */
     _delete = async (id, options = {}) => {
-        // GET DATA FIRST
-        const current_data = await this._get(id);
+        id = Number(id);
+
+        // CHECK DELETE PERMISSION
+        const deleteFilter = this.getDeleteFilter();
+        if (deleteFilter === false) {
+            throw new ErrorResponse(403, "no_permission_to_delete");
+        }
 
-        return await this.prisma.delete({
+        const response = await this.prisma.delete({
             'where': {
-                id: parseInt(id)
+                id: parseInt(id),
+                ...deleteFilter
             },
             'select': this.select(),
             ...options
         });
+        if(response){
+            return response;
+        }
+        throw new ErrorResponse(403, "no_permission");
     }
 
     /**
@@ -233,10 +263,10 @@ class Model {
         return this._include(include);
     }
     sort(sortBy, sortOrder) {
-        return this.constructor.queryBuilder.sort(sortBy, sortOrder);
+        return this.queryBuilder.sort(sortBy, sortOrder);
     }
     take(limit){
-        return this.constructor.queryBuilder.take(Number(limit));
+        return this.queryBuilder.take(Number(limit));
     }
     skip(offset){
         const parsed = parseInt(offset);
@@ -252,7 +282,7 @@ class Model {
      */
     getAccessFilter(){
         const filter = this._getAccessFilter()
-        if(this.user.role == "application" || filter == true){
+        if(this.user.role == "application" || filter === true){
             return {};
         }
         return this._getAccessFilter();
@@ -267,6 +297,39 @@ class Model {
         return this.user.role == "application" ? true : this._hasAccess(data, this.user);
     }
 
+    /**
+     * Check if user can create records
+     * @returns {boolean}
+     */
+    canCreate() {
+        if(this.user.role == "application") return true;
+        return this._canCreate();
+    }
+
+    /**
+     * Get update filter for RLS
+     * @returns {Object|false}
+     */
+    getUpdateFilter(){
+        const filter = this._getUpdateFilter();
+        if(this.user.role == "application" || filter === true){
+            return {};
+        }
+        return filter;
+    }
+
+    /**
+     * Get delete filter for RLS
+     * @returns {Object|false}
+     */
+    getDeleteFilter(){
+        const filter = this._getDeleteFilter();
+        if(this.user.role == "application" || filter === true){
+            return {};
+        }
+        return filter;
+    }
+
     set modelName (name){
         this.name = name;
         this.prisma = prisma[name];
@@ -294,12 +357,96 @@ module.exports = {Model, QueryBuilder, prisma};
  * Generate rapidd/rapidd.js file
  */
 function generateRapiddFile(rapiddJsPath) {
-  const content = `const { PrismaClient, Prisma } = require('../prisma/client');
+  const content = `const { PrismaClient } = require('../prisma/client');
+const { AsyncLocalStorage } = require('async_hooks');
 const rls = require('./rls');
 
-const prisma = new PrismaClient();
+// Request Context Storage
+const requestContext = new AsyncLocalStorage();
+
+// RLS Configuration aus Environment Variables
+const RLS_CONFIG = {
+  namespace: process.env.RLS_NAMESPACE || 'app',
+  userId: process.env.RLS_USER_ID || 'current_user_id',
+  userRole: process.env.RLS_USER_ROLE || 'current_user_role',
+};
 
-module.exports = {prisma, Prisma, rls};
+// Basis Prisma Client
+const basePrisma = new PrismaClient({
+  log: process.env.NODE_ENV === 'development' ? ['query', 'error', 'warn'] : ['error'],
+});
+
+/**
+ * Setze RLS Session Variables in PostgreSQL
+ */
+async function setRLSVariables(tx, userId, userRole) {
+    const namespace = RLS_CONFIG.namespace;
+    const userIdVar = RLS_CONFIG.userId;
+    const userRoleVar = RLS_CONFIG.userRole;
+
+    await tx.$executeRawUnsafe(\`SET LOCAL \${namespace}.\${userIdVar} = '\${userId}'\`);
+    await tx.$executeRawUnsafe(\`SET LOCAL \${namespace}.\${userRoleVar} = '\${userRole}'\`);
+}
+
+// Erweiterter Prisma mit automatischer RLS
+const prisma = basePrisma.$extends({
+  query: {
+    async $allOperations({ args, query }) {
+      const context = requestContext.getStore();
+
+      // Kein Context = keine RLS (z.B. System-Operationen)
+      if (!context?.userId || !context?.userRole) {
+        return query(args);
+      }
+
+      const { userId, userRole } = context;
+
+      // Query in Transaction mit RLS ausführen
+      return basePrisma.$transaction(async (tx) => {
+        // Session-Variablen setzen
+        await setRLSVariables(tx, userId, userRole);
+
+        // Original Query ausführen
+        return query(args);
+      });
+    },
+  },
+});
+
+/**
+ * Helper: System-Operationen ohne RLS (für Cron-Jobs, etc.)
+ */
+async function withSystemAccess(callback) {
+  return requestContext.run(
+    { userId: 'system', userRole: 'ADMIN' },
+    callback
+  );
+}
+
+/**
+ * Helper: Als bestimmter User ausführen (für Tests)
+ */
+async function withUser(userId, userRole, callback) {
+  return requestContext.run({ userId, userRole }, callback);
+}
+
+/**
+ * Helper: Hole RLS Config (für SQL Generation)
+ */
+function getRLSConfig() {
+  return RLS_CONFIG;
+}
+
+module.exports = {
+  prisma,
+  PrismaClient,
+  requestContext,
+  withSystemAccess,
+  withUser,
+  getRLSConfig,
+  setRLSVariables,
+  rls
+};
 `;
 
   // Ensure rapidd directory exists
@@ -638,7 +785,11 @@ async function buildModels(options) {
       // Parse datasource from Prisma schema to get database URL
       const datasource = parseDatasource(schemaPath);
 
-      if (options.model) {
+      // For non-PostgreSQL databases (MySQL, SQLite, etc.), generate permissive RLS
+      if (!datasource.isPostgreSQL) {
+        console.log(`${datasource.provider || 'Non-PostgreSQL'} database detected - generating permissive RLS...`);
+        await generateRLS(models, rlsPath, null, false, options.userTable, relationships, options.debug);
+      } else if (options.model) {
         // Update only specific model in rls.js
         await updateRLSForModel(filteredModels, models, rlsPath, datasource, options.userTable, relationships, options.debug);
       } else {
@@ -655,10 +806,9 @@ async function buildModels(options) {
       }
     } catch (error) {
       console.error('Failed to generate RLS:', error.message);
-      if (!options.model) {
-        console.log('Generating permissive RLS fallback...');
-        await generateRLS(models, rlsPath, null, false, options.userTable, relationships, options.debug);
-      }
+      console.log('Generating permissive RLS fallback...');
+      // Pass null for URL and false for isPostgreSQL to skip database connection
+      await generateRLS(models, rlsPath, null, false, options.userTable, relationships, options.debug);
     }
   }
 

package/src/generators/modelGenerator.js

@@ -12,21 +12,10 @@ function generateModelFile(modelName, modelInfo) {
   const className = modelName.charAt(0).toUpperCase() + modelName.slice(1);
 
   return `const {Model, QueryBuilder, prisma} = require('../Model');
-const {rls} = require('../../rapidd/rapidd');
 
 class ${className} extends Model {
     constructor(options){
-        super('${modelName}', options);
-    }
-
-    static queryBuilder = new QueryBuilder('${modelName}', rls.model.${modelName} || {});
-
-    static getAccessFilter(user) {
-        return rls.model.${modelName}?.getAccessFilter?.(user) || {};
-    }
-
-    static hasAccess(data, user) {
-        return rls.model.${modelName}?.hasAccess?.(data, user) || true;
+        super('${className}', options);
     }
 
     /**

package/src/parsers/datasourceParser.js

@@ -61,10 +61,19 @@ function parseDatasource(schemaPath) {
     isPostgreSQL = url.startsWith('postgresql://') || url.startsWith('postgres://');
   }
 
+  // Explicitly detect MySQL to avoid false PostgreSQL detection
+  const isMySQL = provider === 'mysql' || (url && url.startsWith('mysql://'));
+
+  // If it's MySQL, ensure isPostgreSQL is false
+  if (isMySQL) {
+    isPostgreSQL = false;
+  }
+
   return {
     provider,
     url,
-    isPostgreSQL
+    isPostgreSQL,
+    isMySQL
   };
 }