@rapidd/build 1.0.0

package/src/generators/rlsGeneratorV2.js

@@ -0,0 +1,381 @@
+const fs = require('fs');
+const path = require('path');
+const { Client } = require('pg');
+const { createConverter } = require('../parsers/autoRLSConverter');
+const { createEnhancedConverter } = require('../parsers/enhancedRLSConverter');
+const { analyzeFunctions, generateMappingConfig } = require('../parsers/functionAnalyzer');
+
+/**
+ * Auto-detect user table name (case-insensitive search for user/users)
+ */
+function detectUserTable(models, userTableOption) {
+  if (userTableOption) {
+    return userTableOption;
+  }
+
+  const modelNames = Object.keys(models);
+  const userTables = modelNames.filter(name =>
+    name.toLowerCase() === 'user' || name.toLowerCase() === 'users'
+  );
+
+  if (userTables.length === 0) {
+    throw new Error('No user table found (user/users). Please specify --user-table option.');
+  }
+
+  if (userTables.length > 1) {
+    throw new Error(`Multiple user tables found: ${userTables.join(', ')}. Please specify --user-table option.`);
+  }
+
+  return userTables[0];
+}
+
+/**
+ * Extract RLS policies from PostgreSQL
+ */
+async function extractPostgreSQLPolicies(databaseUrl, modelNames) {
+  const client = new Client({ connectionString: databaseUrl });
+
+  try {
+    await client.connect();
+
+    const policies = {};
+
+    // Initialize all models with empty policies
+    for (const modelName of modelNames) {
+      policies[modelName] = [];
+    }
+
+    // Query all RLS policies from pg_policies
+    const result = await client.query(`
+      SELECT
+        tablename,
+        policyname,
+        permissive,
+        roles,
+        cmd,
+        qual,
+        with_check
+      FROM pg_policies
+      WHERE schemaname = 'public'
+      ORDER BY tablename, policyname
+    `);
+
+    // Group policies by table
+    for (const row of result.rows) {
+      const tableName = row.tablename;
+      if (policies[tableName] !== undefined) {
+        policies[tableName].push({
+          name: row.policyname,
+          permissive: row.permissive === 'PERMISSIVE',
+          roles: row.roles,
+          command: row.cmd,
+          using: row.qual,
+          withCheck: row.with_check
+        });
+      }
+    }
+
+    await client.end();
+    return policies;
+
+  } catch (error) {
+    try {
+      await client.end();
+    } catch (e) {}
+    throw error;
+  }
+}
+
+/**
+ * Generate RLS functions for a single model from PostgreSQL policies
+ */
+function generateModelRLS(modelName, policies, converter) {
+  const hasPolicies = policies && policies.length > 0;
+
+  if (!hasPolicies) {
+    // No RLS policies - generate permissive access
+    return `    ${modelName}: {
+        canCreate: (user) => true,
+        hasAccess: (data, user) => true,
+        getAccessFilter: (user) => ({}),
+        getUpdateFilter: (user) => ({}),
+        getDeleteFilter: (user) => ({}),
+        getOmitFields: (user) => []
+    }`;
+  }
+
+  // Find policies by command type
+  const selectPolicies = policies.filter(p => p.command === 'SELECT' || p.command === 'ALL');
+  const insertPolicies = policies.filter(p => p.command === 'INSERT' || p.command === 'ALL');
+  const updatePolicies = policies.filter(p => p.command === 'UPDATE' || p.command === 'ALL');
+  const deletePolicies = policies.filter(p => p.command === 'DELETE' || p.command === 'ALL');
+
+  // Generate each function
+  const canCreateCode = generateFunction(insertPolicies, 'withCheck', converter, modelName);
+  const hasAccessCode = generateFunction(selectPolicies, 'using', converter, modelName);
+  const accessFilterCode = generateFilter(selectPolicies, 'using', converter, modelName);
+  let updateFilterCode = generateFilter(updatePolicies, 'using', converter, modelName);
+  let deleteFilterCode = generateFilter(deletePolicies, 'using', converter, modelName);
+
+  // If update/delete filters are empty/false but access filter is not, copy access filter
+  if ((updateFilterCode === 'return false;' || updateFilterCode === 'return {};') &&
+      accessFilterCode !== 'return false;' && accessFilterCode !== 'return {};') {
+    updateFilterCode = accessFilterCode;
+  }
+  if ((deleteFilterCode === 'return false;' || deleteFilterCode === 'return {};') &&
+      accessFilterCode !== 'return false;' && accessFilterCode !== 'return {};') {
+    deleteFilterCode = accessFilterCode;
+  }
+
+  return `    ${modelName}: {
+        canCreate: (user) => {
+            ${canCreateCode}
+        },
+        hasAccess: (data, user) => {
+            ${hasAccessCode}
+        },
+        getAccessFilter: (user) => {
+            ${accessFilterCode}
+        },
+        getUpdateFilter: (user) => {
+            ${updateFilterCode}
+        },
+        getDeleteFilter: (user) => {
+            ${deleteFilterCode}
+        },
+        getOmitFields: (user) => []
+    }`;
+}
+
+/**
+ * Generate JavaScript function from policies
+ */
+function generateFunction(policies, expressionField, converter, modelName) {
+  if (policies.length === 0) {
+    return 'return true;';
+  }
+
+  const conditions = [];
+
+  for (const policy of policies) {
+    const expr = expressionField === 'withCheck'
+      ? (policy.withCheck || policy.using)
+      : policy[expressionField];
+
+    if (expr) {
+      try {
+        const jsExpr = converter.convertToJavaScript(expr, 'data', 'user', modelName);
+        conditions.push(jsExpr);
+      } catch (e) {
+        conditions.push(`true /* Error: ${e.message} */`);
+      }
+    }
+  }
+
+  if (conditions.length === 0) {
+    return 'return true;';
+  }
+
+  // Policies are OR'd together (any policy allows)
+  return `return ${conditions.join(' || ')};`;
+}
+
+/**
+ * Generate Prisma filter function
+ */
+function generateFilter(policies, expressionField, converter, modelName) {
+  if (policies.length === 0) {
+    return 'return false;';
+  }
+
+  const filtersWithRoles = [];
+
+  for (const policy of policies) {
+    const expr = policy[expressionField];
+    if (expr) {
+      try {
+        const prismaFilter = converter.convertToPrismaFilter(expr, 'user', modelName);
+        const analysis = converter.analyzer ? converter.analyzer.analyzeSQLForFilters(expr) : null;
+
+        // Track role conditions and data filters separately
+        const roleConditions = analysis?.conditions?.filter(c =>
+          c.type === 'role_any' || c.type === 'role_equal'
+        ) || [];
+
+        filtersWithRoles.push({
+          filter: prismaFilter,
+          roleConditions,
+          hasDataFilter: prismaFilter !== '{}'
+        });
+      } catch (e) {
+        // On error, skip filter
+      }
+    }
+  }
+
+  if (filtersWithRoles.length === 0) {
+    return 'return false;';
+  }
+
+  // Build conditional filter logic
+  return buildConditionalFilter(filtersWithRoles);
+}
+
+/**
+ * Build conditional filter with role checks
+ */
+function buildConditionalFilter(filtersWithRoles) {
+  const roleOnlyFilters = [];
+  const dataFilters = [];
+
+  for (const item of filtersWithRoles) {
+    if (item.roleConditions.length > 0 && !item.hasDataFilter) {
+      // Pure role check - return {} if role matches
+      roleOnlyFilters.push(...item.roleConditions);
+    } else if (item.roleConditions.length > 0 && item.hasDataFilter) {
+      // Has both role and data filter - already handled with if statement
+      if (item.filter.includes('if (')) {
+        return item.filter;
+      }
+      dataFilters.push(item.filter);
+    } else if (item.hasDataFilter) {
+      // Data filter only
+      dataFilters.push(item.filter);
+    }
+  }
+
+  // Generate conditional code
+  const conditions = [];
+
+  // Collect all roles that grant full access
+  const rolesWithFullAccess = new Set();
+  for (const roleCond of roleOnlyFilters) {
+    if (roleCond.type === 'role_any') {
+      roleCond.roles.forEach(r => rolesWithFullAccess.add(r));
+    } else if (roleCond.type === 'role_equal') {
+      rolesWithFullAccess.add(roleCond.role);
+    }
+  }
+
+  // Add single consolidated role check if needed
+  if (rolesWithFullAccess.size > 0) {
+    const roleArray = Array.from(rolesWithFullAccess);
+    if (roleArray.length === 1) {
+      conditions.push(`if (user?.role === '${roleArray[0]}') { return {}; }`);
+    } else {
+      conditions.push(`if ([${roleArray.map(r => `'${r}'`).join(', ')}].includes(user?.role)) { return {}; }`);
+    }
+  }
+
+  // Deduplicate data filters
+  const uniqueDataFilters = [...new Set(dataFilters)];
+
+  // Add final return with data filters
+  if (uniqueDataFilters.length === 0) {
+    conditions.push('return false;');
+  } else if (uniqueDataFilters.length === 1) {
+    conditions.push(`return ${uniqueDataFilters[0]};`);
+  } else {
+    conditions.push(`return { OR: [${uniqueDataFilters.join(', ')}] };`);
+  }
+
+  return conditions.join(' ');
+}
+
+/**
+ * Generate complete rls.js file
+ */
+async function generateRLS(models, outputPath, databaseUrl, isPostgreSQL, userTableOption, relationships = {}) {
+  const userTable = detectUserTable(models, userTableOption);
+  const modelNames = Object.keys(models);
+
+  let policies = {};
+  const timestamp = new Date().toISOString();
+
+  let rlsCode = `const rls = {\n    model: {},\n    lastUpdateDate: '${timestamp}'\n};\n\n`;
+
+  // Create enhanced converter with analyzed functions, models, and relationships
+  let converter = createEnhancedConverter({}, {}, models, relationships);
+
+  if (isPostgreSQL && databaseUrl) {
+    console.log('PostgreSQL detected - analyzing database...');
+
+    // Step 1: Analyze functions
+    try {
+      const functionAnalysis = await analyzeFunctions(databaseUrl);
+      console.log(`✓ Analyzed ${Object.keys(functionAnalysis.functionMappings).length} PostgreSQL functions`);
+
+      // Create enhanced converter with analyzed mappings, models, and relationships
+      converter = createEnhancedConverter(
+        functionAnalysis.functionMappings,
+        functionAnalysis.sessionVariables,
+        models,
+        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}`);
+
+      // Also add user context requirements as a comment in rls.js
+      if (Object.keys(functionAnalysis.userContextRequirements).length > 0) {
+        rlsCode = `/**
+ * User Context Requirements:
+ * The user object should contain:
+${Object.entries(functionAnalysis.userContextRequirements)
+  .map(([field, req]) => ` * - ${field}: ${typeof req === 'object' ? req.description : 'required'}`)
+  .join('\n')}
+ */
+
+` + rlsCode;
+      }
+    } catch (error) {
+      console.warn(`⚠ Could not analyze functions: ${error.message}`);
+    }
+
+    // Step 2: Extract policies
+    try {
+      policies = await extractPostgreSQLPolicies(databaseUrl, modelNames);
+      const totalPolicies = Object.values(policies).reduce((sum, p) => sum + p.length, 0);
+      console.log(`✓ Extracted ${totalPolicies} RLS policies from PostgreSQL`);
+    } catch (error) {
+      console.warn(`⚠ Failed to extract PostgreSQL RLS: ${error.message}`);
+      console.log('Generating permissive RLS for all models...');
+      for (const modelName of modelNames) {
+        policies[modelName] = [];
+      }
+    }
+  } else {
+    if (!isPostgreSQL) {
+      console.log('Non-PostgreSQL database detected - RLS not supported');
+    }
+    console.log('Generating permissive RLS for all models...');
+    for (const modelName of modelNames) {
+      policies[modelName] = [];
+    }
+  }
+
+  // Generate RLS for each model
+  rlsCode += 'rls.model = {\n';
+  const modelRLSCode = modelNames.map(modelName => {
+    return generateModelRLS(modelName, policies[modelName], converter);
+  });
+  rlsCode += modelRLSCode.join(',\n');
+  rlsCode += '\n};\n\n';
+  rlsCode += 'module.exports = rls;\n';
+
+  // Ensure output directory exists
+  const outputDir = path.dirname(outputPath);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  fs.writeFileSync(outputPath, rlsCode);
+  console.log('✓ Generated rls.js with dynamic function mappings');
+}
+
+module.exports = {
+  generateRLS
+};

package/src/generators/routeGenerator.js

@@ -0,0 +1,127 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Generate Express route for a single model
+ * @param {string} modelName - Name of the model
+ * @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) => {
+    if(req.session && req.user){
+        req.${className} = new ${className}({'user': req.user});
+        next();
+    }
+    else{
+        res.status(401).send({'status_code': res.statusCode, 'message': "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;
+
+        const _data = req.${className}.getMany(q, include, limit, offset, sortBy, sortOrder);
+        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});
+    }
+    catch(error){
+        response = QueryBuilder.errorHandler(error);
+        status_code = response.status_code;
+    }
+    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);
+    }
+    catch(error){
+        response = QueryBuilder.errorHandler(error);
+        status_code = response.status_code;
+    }
+    res.status(status_code).send(response);
+});
+
+// CREATE
+router.post('/', async function(req, res) {
+    let response, status_code = 201, payload = req.body;
+    try{
+        response = await req.${className}.create(payload);
+    }
+    catch(error){
+        response = QueryBuilder.errorHandler(error, payload);
+        status_code = response.status_code;
+    }
+    res.status(status_code).send(response);
+});
+
+// UPDATE
+router.patch('/:id', async function(req, res) {
+    let response, status_code = 200, payload = req.body;
+    try{
+        response = await req.${className}.update(req.params.id, payload);
+    }
+    catch(error){
+        response = QueryBuilder.errorHandler(error, payload);
+        status_code = response.status_code;
+    }
+    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"}
+    }
+    catch(error){
+        response = QueryBuilder.errorHandler(error);
+        status_code = response.status_code;
+    }
+    res.status(status_code).send(response);
+});
+
+module.exports = router;
+`;
+}
+
+/**
+ * Generate all route files
+ * @param {Object} models - Models object from parser
+ * @param {string} routesDir - Directory to output route files
+ */
+function generateAllRoutes(models, routesDir) {
+  // Create routes directory if it doesn't exist
+  if (!fs.existsSync(routesDir)) {
+    fs.mkdirSync(routesDir, { recursive: true });
+  }
+
+  // Generate individual route files
+  for (const modelName of Object.keys(models)) {
+    const routeCode = generateRouteFile(modelName);
+    const routePath = path.join(routesDir, `${modelName.toLowerCase()}.js`);
+    fs.writeFileSync(routePath, routeCode);
+    console.log(`Generated route: ${modelName.toLowerCase()}.js`);
+  }
+}
+
+module.exports = {
+  generateAllRoutes,
+  generateRouteFile
+};