@rapidd/build 1.0.1 → 1.0.3

package/bin/cli.js

@@ -19,6 +19,7 @@ program
   .option('-m, --model <name>', 'Generate/update only specific model (e.g., "account", "user")')
   .option('--only <component>', 'Generate only specific component: "model", "route", "rls", or "relationship"')
   .option('--user-table <name>', 'Name of the user table for RLS (default: auto-detect from user/users)')
+  .option('--debug', 'Enable debug mode (generates rls-mappings.json)')
   .action(async (options) => {
     try {
       await buildModels(options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rapidd/build",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "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,7 @@ const { generateAllRoutes } = require('../generators/routeGenerator');
  */
 function generateBaseModelFile(modelJsPath) {
   const content = `const { QueryBuilder, prisma } = require("./QueryBuilder");
-const {ErrorResponse} = require('./Api');
+const {ErrorResponse, getTranslation} = require('./Api');
 
 class Model {
     /**
@@ -50,7 +50,8 @@ class Model {
         sortBy = sortBy.trim();
         sortOrder = sortOrder.trim();
         if (!sortBy.includes('.') && this.fields[sortBy] == undefined) {
-            throw new ErrorResponse(\`Parameter sortBy '\${sortBy}' is not a valid field of \${this.constructor.name}\`, 400);
+            const message = getTranslation("invalid_sort_field", {sortBy, modelName: this.constructor.name});
+            throw new ErrorResponse(message, 400);
         }
 
         // Query the database using Prisma with filters, pagination, and limits
@@ -71,37 +72,40 @@ class Model {
      */
     _get = async (id, include, options = {}) =>{
         const {omit, ..._options} = options;
-        id = Number(id)
+        id = Number(id);
         // 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.getAccessFilter()
+                'id': id
             },
             'include': this.include(include),
             'omit': {...this._omit(), ...omit},
             ..._options
         });
 
-        const _checkExistence = this.prisma.findUnique({
+        const _checkPermission = this.prisma.findUnique({
             'where': {
-                'id': id
+                'id': id,
+                ...this.getAccessFilter()
             },
             'select': {
                 'id': true
             }
         });
 
-        const [response, checkExistence] = await Promise.all([_response, _checkExistence]);
-
-        if(response == null){
-            if(checkExistence == null){
-                throw new ErrorResponse("Record not found", 404);
+        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);
+                }
+            }
+            else{
+                throw new ErrorResponse(getTranslation("no_permission"), 403);
             }
-            throw new ErrorResponse("No permission", 403);
         }
-        if(response.id != checkExistence?.id){   // IN CASE access_filter CONTAINS id FIELD
-            throw new ErrorResponse("No permission", 403);
+        else{
+            throw new ErrorResponse(getTranslation("record_not_found"), 404);
         }
         return response;
     }
@@ -276,6 +280,12 @@ class Model {
 module.exports = {Model, QueryBuilder, prisma};
 `;
 
+  // Ensure src directory exists
+  const srcDir = path.dirname(modelJsPath);
+  if (!fs.existsSync(srcDir)) {
+    fs.mkdirSync(srcDir, { recursive: true });
+  }
+
   fs.writeFileSync(modelJsPath, content);
   console.log('✓ Generated src/Model.js');
 }
@@ -359,10 +369,10 @@ async function updateRelationshipsForModel(filteredModels, relationshipsPath, pr
 /**
  * Update rls.js for a specific model
  */
-async function updateRLSForModel(filteredModels, rlsPath, datasource, userTable, relationships) {
+async function updateRLSForModel(filteredModels, allModels, rlsPath, datasource, userTable, relationships, debug = false) {
   const { generateRLS } = require('../generators/rlsGeneratorV2');
 
-  // Generate RLS for the filtered model
+  // Generate RLS for the filtered model (but pass all models for user table detection)
   const tempPath = rlsPath + '.tmp';
   await generateRLS(
     filteredModels,
@@ -370,7 +380,9 @@ async function updateRLSForModel(filteredModels, rlsPath, datasource, userTable,
     datasource.url,
     datasource.isPostgreSQL,
     userTable,
-    relationships
+    relationships,
+    debug,
+    allModels
   );
 
   // Read the generated RLS for the specific model
@@ -379,13 +391,52 @@ async function updateRLSForModel(filteredModels, rlsPath, datasource, userTable,
 
   // Extract the model's RLS configuration
   const modelName = Object.keys(filteredModels)[0];
-  const modelRlsMatch = tempContent.match(new RegExp(`${modelName}:\\s*\\{[\\s\\S]*?\\n    \\}(?=,|\\n)`));
 
-  if (!modelRlsMatch) {
-    throw new Error(`Could not extract RLS for model ${modelName}`);
+  // Find the start of the model definition
+  const modelStart = tempContent.indexOf(`${modelName}:`);
+  if (modelStart === -1) {
+    throw new Error(`Could not find model ${modelName} in generated RLS`);
   }
 
-  const modelRls = modelRlsMatch[0];
+  // Find the matching closing brace by counting braces
+  let braceCount = 0;
+  let inString = false;
+  let stringChar = null;
+  let i = tempContent.indexOf('{', modelStart);
+  const contentStart = i;
+
+  for (; i < tempContent.length; i++) {
+    const char = tempContent[i];
+    const prevChar = i > 0 ? tempContent[i - 1] : '';
+
+    // Handle string literals
+    if ((char === '"' || char === "'" || char === '`') && prevChar !== '\\') {
+      if (!inString) {
+        inString = true;
+        stringChar = char;
+      } else if (char === stringChar) {
+        inString = false;
+        stringChar = null;
+      }
+    }
+
+    if (!inString) {
+      if (char === '{') braceCount++;
+      if (char === '}') braceCount--;
+
+      if (braceCount === 0) {
+        // Found the closing brace
+        const modelRls = tempContent.substring(modelStart, i + 1);
+        break;
+      }
+    }
+  }
+
+  if (braceCount !== 0) {
+    throw new Error(`Could not extract RLS for model ${modelName} - unmatched braces`);
+  }
+
+  const modelRls = tempContent.substring(modelStart, i + 1);
 
   // Read existing rls.js
   if (fs.existsSync(rlsPath)) {
@@ -399,9 +450,10 @@ async function updateRLSForModel(filteredModels, rlsPath, datasource, userTable,
       existingContent = existingContent.replace(existingModelPattern, modelRls);
     } else {
       // Add new model RLS before the closing of rls.model
+      // Find the last closing brace of a model object and add comma after it
       existingContent = existingContent.replace(
-        /(\n};[\s]*\n[\s]*module\.exports)/,
-        `,\n    ${modelRls}\n};$1`
+        /(\n    \})\n(\};)/,
+        `$1,\n    ${modelRls}\n$2`
       );
     }
 
@@ -415,7 +467,9 @@ async function updateRLSForModel(filteredModels, rlsPath, datasource, userTable,
       datasource.url,
       datasource.isPostgreSQL,
       userTable,
-      relationships
+      relationships,
+      debug,
+      allModels
     );
   }
 }
@@ -529,16 +583,16 @@ async function buildModels(options) {
   // Generate model files
   if (shouldGenerate.model) {
     generateAllModels(filteredModels, modelDir, modelJsPath);
+  }
 
-    // Generate src/Model.js (base Model class) - only if not filtering by model
-    if (!options.model) {
-      console.log('\nGenerating src/Model.js...');
-      generateBaseModelFile(modelJsPath);
-    }
+  // Generate src/Model.js (base Model class) if it doesn't exist
+  if (!fs.existsSync(modelJsPath)) {
+    console.log('\nGenerating src/Model.js...');
+    generateBaseModelFile(modelJsPath);
   }
 
-  // Generate rapidd/rapidd.js - only if not filtering by model
-  if (!options.model && !options.only) {
+  // Generate rapidd/rapidd.js if it doesn't exist
+  if (!fs.existsSync(rapiddJsPath)) {
     console.log('Generating rapidd/rapidd.js...');
     generateRapiddFile(rapiddJsPath);
   }
@@ -586,7 +640,7 @@ async function buildModels(options) {
 
       if (options.model) {
         // Update only specific model in rls.js
-        await updateRLSForModel(filteredModels, rlsPath, datasource, options.userTable, relationships);
+        await updateRLSForModel(filteredModels, models, rlsPath, datasource, options.userTable, relationships, options.debug);
       } else {
         // Generate RLS for all models
         await generateRLS(
@@ -595,14 +649,15 @@ async function buildModels(options) {
           datasource.url,
           datasource.isPostgreSQL,
           options.userTable,
-          relationships
+          relationships,
+          options.debug
         );
       }
     } 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);
+        await generateRLS(models, rlsPath, null, false, options.userTable, relationships, options.debug);
       }
     }
   }

package/src/generators/modelGenerator.js

@@ -150,7 +150,7 @@ function generateAllModels(models, modelDir, modelJsPath) {
 
   // Copy rapidd.js to output if it exists
   const sourceRapiddJs = path.join(process.cwd(), 'rapidd', 'rapidd.js');
-  const outputRapiddDir = path.dirname(modelDir.replace(/src[\/\\]Model$/, 'rapidd'));
+  const outputRapiddDir = modelDir.replace(/src[\/\\]Model$/, 'rapidd');
   const outputRapiddJs = path.join(outputRapiddDir, 'rapidd.js');
 
   if (fs.existsSync(sourceRapiddJs)) {

package/src/generators/rlsGenerator.js

@@ -34,10 +34,10 @@ function detectUserTable(models, userTableOption) {
 /**
  * Extract RLS policies from PostgreSQL
  * @param {string} databaseUrl - PostgreSQL connection URL
- * @param {Array} modelNames - Array of model names
- * @returns {Object} - RLS policies for each table
+ * @param {Object} models - Models object with dbName mapping
+ * @returns {Object} - RLS policies for each model
  */
-async function extractPostgreSQLPolicies(databaseUrl, modelNames) {
+async function extractPostgreSQLPolicies(databaseUrl, models) {
   const client = new Client({ connectionString: databaseUrl });
 
   try {
@@ -45,8 +45,11 @@ async function extractPostgreSQLPolicies(databaseUrl, modelNames) {
 
     const policies = {};
 
-    // Initialize all models with empty policies
-    for (const modelName of modelNames) {
+    // Create mapping from database table name to model name
+    const tableToModelMap = {};
+    for (const [modelName, modelData] of Object.entries(models)) {
+      const dbName = modelData.dbName || modelName.toLowerCase();
+      tableToModelMap[dbName] = modelName;
       policies[modelName] = [];
     }
 
@@ -65,11 +68,13 @@ async function extractPostgreSQLPolicies(databaseUrl, modelNames) {
       ORDER BY tablename, policyname
     `);
 
-    // Group policies by table
+    // Group policies by model (using table to model mapping)
     for (const row of result.rows) {
       const tableName = row.tablename;
-      if (policies[tableName] !== undefined) {
-        policies[tableName].push({
+      const modelName = tableToModelMap[tableName];
+
+      if (modelName && policies[modelName] !== undefined) {
+        policies[modelName].push({
           name: row.policyname,
           permissive: row.permissive === 'PERMISSIVE',
           roles: row.roles,
@@ -259,7 +264,7 @@ function generateFilter(policies, expressionField) {
  * @param {boolean} isPostgreSQL - Whether database is PostgreSQL
  * @param {string} userTableOption - User-specified table name
  */
-async function generateRLS(models, outputPath, databaseUrl, isPostgreSQL, userTableOption) {
+async function generateRLS(models, outputPath, databaseUrl, isPostgreSQL, userTableOption, debug = false) {
   const userTable = detectUserTable(models, userTableOption);
   const modelNames = Object.keys(models);
 
@@ -277,18 +282,20 @@ async function generateRLS(models, outputPath, databaseUrl, isPostgreSQL, userTa
       functionAnalysis = await analyzeFunctions(databaseUrl);
       console.log(`✓ Analyzed ${Object.keys(functionAnalysis.functionMappings).length} PostgreSQL functions`);
 
-      // Save function analysis for debugging/manual adjustment
-      const configPath = path.join(path.dirname(outputPath), 'rls-mappings.json');
-      const mappingConfig = generateMappingConfig(functionAnalysis);
-      fs.writeFileSync(configPath, JSON.stringify(mappingConfig, null, 2));
-      console.log(`✓ Function mappings saved to ${configPath}`);
+      // Save function analysis for debugging/manual adjustment (only if --debug flag is set)
+      if (debug) {
+        const configPath = path.join(path.dirname(outputPath), 'rls-mappings.json');
+        const mappingConfig = generateMappingConfig(functionAnalysis);
+        fs.writeFileSync(configPath, JSON.stringify(mappingConfig, null, 2));
+        console.log(`✓ Function mappings saved to ${configPath}`);
+      }
     } catch (error) {
       console.warn(`⚠ Could not analyze functions: ${error.message}`);
     }
 
     console.log('Extracting RLS policies from database...');
     try {
-      policies = await extractPostgreSQLPolicies(databaseUrl, modelNames);
+      policies = await extractPostgreSQLPolicies(databaseUrl, models);
       const totalPolicies = Object.values(policies).reduce((sum, p) => sum + p.length, 0);
       console.log(`✓ Extracted ${totalPolicies} RLS policies from PostgreSQL`);
     } catch (error) {

package/src/generators/rlsGeneratorV2.js

@@ -32,7 +32,7 @@ function detectUserTable(models, userTableOption) {
 /**
  * Extract RLS policies from PostgreSQL
  */
-async function extractPostgreSQLPolicies(databaseUrl, modelNames) {
+async function extractPostgreSQLPolicies(databaseUrl, models) {
   const client = new Client({ connectionString: databaseUrl });
 
   try {
@@ -40,8 +40,11 @@ async function extractPostgreSQLPolicies(databaseUrl, modelNames) {
 
     const policies = {};
 
-    // Initialize all models with empty policies
-    for (const modelName of modelNames) {
+    // Create mapping from database table name to model name
+    const tableToModelMap = {};
+    for (const [modelName, modelData] of Object.entries(models)) {
+      const dbName = modelData.dbName || modelName.toLowerCase();
+      tableToModelMap[dbName] = modelName;
       policies[modelName] = [];
     }
 
@@ -60,11 +63,13 @@ async function extractPostgreSQLPolicies(databaseUrl, modelNames) {
       ORDER BY tablename, policyname
     `);
 
-    // Group policies by table
+    // Group policies by model (using table to model mapping)
     for (const row of result.rows) {
       const tableName = row.tablename;
-      if (policies[tableName] !== undefined) {
-        policies[tableName].push({
+      const modelName = tableToModelMap[tableName];
+
+      if (modelName && policies[modelName] !== undefined) {
+        policies[modelName].push({
           name: row.policyname,
           permissive: row.permissive === 'PERMISSIVE',
           roles: row.roles,
@@ -165,9 +170,12 @@ function generateFunction(policies, expressionField, converter, modelName) {
     if (expr) {
       try {
         const jsExpr = converter.convertToJavaScript(expr, 'data', 'user', modelName);
+        console.log(`✓ Policy '${policy.name}': ${expr.substring(0, 50)}... -> ${jsExpr.substring(0, 80)}`);
         conditions.push(jsExpr);
       } catch (e) {
-        conditions.push(`true /* Error: ${e.message} */`);
+        console.warn(`⚠ Failed to convert RLS policy '${policy.name}' for ${modelName}: ${e.message}`);
+        console.warn(`  SQL: ${expr}`);
+        conditions.push(`true /* TODO: Manual conversion needed for policy '${policy.name}' */`);
       }
     }
   }
@@ -176,6 +184,11 @@ function generateFunction(policies, expressionField, converter, modelName) {
     return 'return true;';
   }
 
+  // If any condition is 'true', the entire expression is true
+  if (conditions.some(c => c === 'true' || c.startsWith('true /*'))) {
+    return 'return true;';
+  }
+
   // Policies are OR'd together (any policy allows)
   return `return ${conditions.join(' || ')};`;
 }
@@ -208,7 +221,9 @@ function generateFilter(policies, expressionField, converter, modelName) {
           hasDataFilter: prismaFilter !== '{}'
         });
       } catch (e) {
-        // On error, skip filter
+        console.warn(`⚠ Failed to convert RLS filter policy '${policy.name}' for ${modelName}: ${e.message}`);
+        console.warn(`  SQL: ${expr}`);
+        // On error, skip filter (fail-safe - no access)
       }
     }
   }
@@ -285,8 +300,10 @@ function buildConditionalFilter(filtersWithRoles) {
 /**
  * Generate complete rls.js file
  */
-async function generateRLS(models, outputPath, databaseUrl, isPostgreSQL, userTableOption, relationships = {}) {
-  const userTable = detectUserTable(models, userTableOption);
+async function generateRLS(models, outputPath, databaseUrl, isPostgreSQL, userTableOption, relationships = {}, debug = false, allModels = null) {
+  // Use allModels for user table detection if provided (when filtering by model)
+  const modelsForUserDetection = allModels || models;
+  const userTable = detectUserTable(modelsForUserDetection, userTableOption);
   const modelNames = Object.keys(models);
 
   let policies = {};
@@ -313,11 +330,13 @@ async function generateRLS(models, outputPath, databaseUrl, isPostgreSQL, userTa
         relationships
       );
 
-      // Save function analysis for debugging
-      const configPath = path.join(path.dirname(outputPath), 'rls-mappings.json');
-      const mappingConfig = generateMappingConfig(functionAnalysis);
-      fs.writeFileSync(configPath, JSON.stringify(mappingConfig, null, 2));
-      console.log(`✓ Function mappings saved to ${configPath}`);
+      // Save function analysis for debugging (only if --debug flag is set)
+      if (debug) {
+        const configPath = path.join(path.dirname(outputPath), 'rls-mappings.json');
+        const mappingConfig = generateMappingConfig(functionAnalysis);
+        fs.writeFileSync(configPath, JSON.stringify(mappingConfig, null, 2));
+        console.log(`✓ Function mappings saved to ${configPath}`);
+      }
 
       // Also add user context requirements as a comment in rls.js
       if (Object.keys(functionAnalysis.userContextRequirements).length > 0) {
@@ -337,7 +356,7 @@ ${Object.entries(functionAnalysis.userContextRequirements)
 
     // Step 2: Extract policies
     try {
-      policies = await extractPostgreSQLPolicies(databaseUrl, modelNames);
+      policies = await extractPostgreSQLPolicies(databaseUrl, models);
       const totalPolicies = Object.values(policies).reduce((sum, p) => sum + p.length, 0);
       console.log(`✓ Extracted ${totalPolicies} RLS policies from PostgreSQL`);
     } catch (error) {

package/src/generators/routeGenerator.js

@@ -7,11 +7,9 @@ const path = require('path');
  * @returns {string} - Generated route code
  */
 function generateRouteFile(modelName) {
-  const modelNameLower = modelName.toLowerCase();
   const className = modelName.charAt(0).toUpperCase() + modelName.slice(1);
 
   return `const router = require('express').Router();
-const {Api, ErrorResponse} = require('../../../src/Api');
 const {${className}, QueryBuilder, prisma} = require('../../../src/Model/${className}');
 
 router.all('*', async (req, res, next) => {
@@ -20,13 +18,12 @@ router.all('*', async (req, res, next) => {
         next();
     }
     else{
-        res.status(401).send({'status_code': res.statusCode, 'message': "No valid session"});
+        return res.sendError(401, req.getTranslation("no_valid_session"));
     }
 });
 
 // GET ALL
 router.get('/', async function(req, res) {
-    let response, status_code = 200;
     try {
         const { q = {}, include = "", limit = 25, offset = 0, sortBy = "id", sortOrder = "asc" } = req.query;
 
@@ -34,67 +31,64 @@ router.get('/', async function(req, res) {
         const _count = req.${className}.count(q);
         const [data, count] = await Promise.all([_data, _count]);
 
-        response = Api.getListResponseBody(data, {'take': req.${className}.take(Number(limit)), 'skip': req.${className}.skip(Number(offset)), 'total': count});
+        return res.sendList(data, {'take': req.${className}.take(Number(limit)), 'skip': req.${className}.skip(Number(offset)), 'total': count});
     }
     catch(error){
-        response = QueryBuilder.errorHandler(error);
-        status_code = response.status_code;
+        const response = QueryBuilder.errorHandler(error);
+        return res.status(response.status_code).send(response);
     }
-    res.status(status_code).send(response);
 });
 
 // GET BY ID
 router.get('/:id', async function(req, res) {
-    let response, status_code = 200;
     try{
         const { include = ""} = req.query;
-        response = await req.${className}.get(req.params.id, include);
+        const response = await req.${className}.get(req.params.id, include);
+        return res.json(response);
     }
     catch(error){
-        response = QueryBuilder.errorHandler(error);
-        status_code = response.status_code;
+        const response = QueryBuilder.errorHandler(error);
+        return res.status(response.status_code).send(response);
     }
-    res.status(status_code).send(response);
 });
 
 // CREATE
 router.post('/', async function(req, res) {
-    let response, status_code = 201, payload = req.body;
+    const payload = req.body;
     try{
-        response = await req.${className}.create(payload);
+        const response = await req.${className}.create(payload);
+        return res.status(201).json(response);
     }
     catch(error){
-        response = QueryBuilder.errorHandler(error, payload);
-        status_code = response.status_code;
+        const response = QueryBuilder.errorHandler(error, payload);
+        return res.status(response.status_code).send(response);
     }
-    res.status(status_code).send(response);
 });
 
 // UPDATE
 router.patch('/:id', async function(req, res) {
-    let response, status_code = 200, payload = req.body;
+    const payload = req.body;
     try{
-        response = await req.${className}.update(req.params.id, payload);
+        const response = await req.${className}.update(req.params.id, payload);
+        return res.json(response);
     }
     catch(error){
-        response = QueryBuilder.errorHandler(error, payload);
-        status_code = response.status_code;
+        const response = QueryBuilder.errorHandler(error, payload);
+        return res.status(response.status_code).send(response);
     }
-    res.status(status_code).send(response);
 });
 
 // DELETE
 router.delete('/:id', async (req, res)=>{
-    let response, status_code = 200;
     try{
         await req.${className}.delete(req.params.id);
-        response = {'status_code': status_code, 'message': "${className} successfully deleted"}
+        const message = req.getTranslation("object_deleted_successfully", {modelName: "${className}"});
+        return res.sendResponse(200, message);
     }
     catch(error){
-        response = QueryBuilder.errorHandler(error);
-        status_code = response.status_code;
+        const response = QueryBuilder.errorHandler(error);
+        return res.status(response.status_code).send(response);
     }
-    res.status(status_code).send(response);
 });
 
 module.exports = router;

package/src/parsers/deepSQLAnalyzer.js

@@ -180,8 +180,8 @@ class DeepSQLAnalyzer {
    * Extract direct field comparisons
    */
   extractDirectComparisons(sql, analysis) {
-    // Pattern: field = 'value'
-    const stringPattern = /(\w+)\s*=\s*'([^']+)'/gi;
+    // Pattern: field = 'value' (with or without quotes on field name)
+    const stringPattern = /(?:"?(\w+)"?)\s*=\s*'([^']+)'/gi;
     let match;
     while ((match = stringPattern.exec(sql)) !== null) {
       const field = match[1];
@@ -200,8 +200,8 @@ class DeepSQLAnalyzer {
       });
     }
 
-    // Pattern: field = number
-    const numberPattern = /(\w+)\s*=\s*(\d+)(?!\s*\))/gi;
+    // Pattern: field = number (with or without quotes on field name)
+    const numberPattern = /(?:"?(\w+)"?)\s*=\s*(\d+)(?!\s*\))/gi;
     while ((match = numberPattern.exec(sql)) !== null) {
       const field = match[1];
       const value = match[2];
@@ -219,8 +219,22 @@ class DeepSQLAnalyzer {
       });
     }
 
+    // Pattern: field = true/false (with or without quotes on field name)
+    const booleanPattern = /(?:"?(\w+)"?)\s*=\s*(true|false)/gi;
+    while ((match = booleanPattern.exec(sql)) !== null) {
+      const field = match[1];
+      const value = match[2].toLowerCase();
+
+      analysis.filters.push({
+        type: 'equal',
+        field: field,
+        value: value,
+        prisma: `{ ${field}: ${value} }`
+      });
+    }
+
     // Pattern: field IS NULL
-    const isNullPattern = /(\w+)\s+IS\s+NULL/gi;
+    const isNullPattern = /(?:"?(\w+)"?)\s+IS\s+NULL/gi;
     while ((match = isNullPattern.exec(sql)) !== null) {
       analysis.filters.push({
         type: 'is_null',
@@ -244,10 +258,10 @@ class DeepSQLAnalyzer {
    * Extract function-based comparisons
    */
   extractFunctionComparisons(sql, analysis) {
-    // Pattern: field = function()
+    // Pattern: field = function() (with or without quotes on field name)
     const patterns = [
-      /(\w+)\s*=\s*([\w.]+)\s*\(\s*\)/gi,  // field = function()
-      /([\w.]+)\s*\(\s*\)\s*=\s*(\w+)/gi   // function() = field
+      /(?:"?(\w+)"?)\s*=\s*([\w.]+)\s*\(\s*\)/gi,  // field = function()
+      /([\w.]+)\s*\(\s*\)\s*=\s*(?:"?(\w+)"?)/gi   // function() = field
     ];
 
     // Normalize dots in function names for lookup

package/src/parsers/dynamicRLSConverter.js

@@ -13,6 +13,23 @@ function convertToJavaScript(sql, dataVar = 'data', userVar = 'user') {
 
   sql = sql.trim();
 
+  // Strip outer parentheses if they wrap the entire expression
+  if (sql.startsWith('(') && sql.endsWith(')')) {
+    let depth = 0;
+    let matchesOuter = true;
+    for (let i = 0; i < sql.length; i++) {
+      if (sql[i] === '(') depth++;
+      if (sql[i] === ')') depth--;
+      if (depth === 0 && i < sql.length - 1) {
+        matchesOuter = false;
+        break;
+      }
+    }
+    if (matchesOuter) {
+      sql = sql.substring(1, sql.length - 1).trim();
+    }
+  }
+
   // Normalize whitespace
   sql = sql.replace(/\s+/g, ' ').replace(/\n/g, ' ');
 
@@ -48,8 +65,8 @@ function convertToJavaScript(sql, dataVar = 'data', userVar = 'user') {
     return `[${arrayValues}].includes(${userVar}?.${userProperty})`;
   }
 
-  // Handle field = function() comparisons
-  const funcCompareMatch = sql.match(/(\w+)\s*=\s*(\w+)\s*\([^)]*\)/i);
+  // Handle field = function() comparisons (with or without quotes)
+  const funcCompareMatch = sql.match(/(?:"?(\w+)"?)\s*=\s*(\w+)\s*\([^)]*\)/i);
   if (funcCompareMatch) {
     const field = funcCompareMatch[1];
     const funcName = funcCompareMatch[2];
@@ -60,7 +77,7 @@ function convertToJavaScript(sql, dataVar = 'data', userVar = 'user') {
   }
 
   // Handle field = (current_setting(...))
-  const currentSettingMatch = sql.match(/(\w+)\s*=\s*\(\s*current_setting\s*\(\s*'([^']+)'/i);
+  const currentSettingMatch = sql.match(/(?:"?(\w+)"?)\s*=\s*\(\s*current_setting\s*\(\s*'([^']+)'/i);
   if (currentSettingMatch) {
     const field = currentSettingMatch[1];
     const setting = currentSettingMatch[2];
@@ -70,6 +87,14 @@ function convertToJavaScript(sql, dataVar = 'data', userVar = 'user') {
     return `${dataVar}?.${field} === ${userVar}?.${userProperty}`;
   }
 
+  // Handle field = literal value (true, false, numbers, strings)
+  const literalMatch = sql.match(/(?:"?(\w+)"?)\s*=\s*(true|false|\d+|'[^']+')/i);
+  if (literalMatch) {
+    const field = literalMatch[1];
+    const value = literalMatch[2];
+    return `${dataVar}?.${field} === ${value}`;
+  }
+
   // Handle EXISTS subqueries
   if (sql.includes('EXISTS')) {
     return handleExistsSubquery(sql, dataVar, userVar);
@@ -80,6 +105,7 @@ function convertToJavaScript(sql, dataVar = 'data', userVar = 'user') {
   if (sql.toLowerCase() === 'false') return 'false';
 
   // Unhandled pattern
+  console.warn(`⚠ Unhandled RLS pattern: ${sql}`);
   return `true /* Unhandled RLS pattern: ${sql.substring(0, 60)}... */`;
 }
 

package/src/parsers/prismaParser.js

@@ -46,6 +46,7 @@ function parsePrismaSchema(schemaPath) {
   for (const { name, body } of modelBlocks) {
     const fields = parseModelFields(body);
     const compositeKeyFields = parseCompositeKey(body);
+    const dbName = parseMapDirective(body);
 
     // Mark composite key fields with isId
     if (compositeKeyFields) {
@@ -60,7 +61,8 @@ function parsePrismaSchema(schemaPath) {
       name,
       fields,
       relations: parseModelRelations(body),
-      compositeKey: compositeKeyFields
+      compositeKey: compositeKeyFields,
+      dbName: dbName || name.toLowerCase() // Default to lowercase model name
     };
   }
 
@@ -94,6 +96,25 @@ function parseCompositeKey(modelBody) {
   return null;
 }
 
+/**
+ * Parse @@map directive to get database table name
+ * @param {string} modelBody - The content inside model braces
+ * @returns {string|null} - Database table name, or null if no @@map directive
+ */
+function parseMapDirective(modelBody) {
+  const lines = modelBody.split('\n').map(line => line.trim());
+
+  for (const line of lines) {
+    // Match @@map("table_name") or @@map('table_name')
+    const match = line.match(/^@@map\(["']([^"']+)["']\)/);
+    if (match) {
+      return match[1];
+    }
+  }
+
+  return null;
+}
+
 /**
  * Parse model fields from model body
  * @param {string} modelBody - The content inside model braces
@@ -206,7 +227,8 @@ async function parsePrismaDMMF(prismaClientPath) {
         name: model.name,
         fields: {},
         relations: [],
-        compositeKey
+        compositeKey,
+        dbName: model.dbName || model.name.toLowerCase() // Use dbName from DMMF or default to lowercase
       };
 
       for (const field of model.fields) {