@rapidd/build 1.0.0

package/src/generators/modelGenerator.js

@@ -0,0 +1,168 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Generate a single model file
+ * @param {string} modelName - Name of the model
+ * @param {Object} modelInfo - Model information from parser
+ * @returns {string} - Generated model class code
+ */
+function generateModelFile(modelName, modelInfo) {
+  // Capitalize first letter for class name
+  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;
+    }
+
+    /**
+     * @param {string} q
+     * @property {string|Object} include
+     * @param {number} limit
+     * @param {number} offset
+     * @param {string} sortBy
+     * @param {'asc'|'desc'} sortOrder
+     * @returns {Object[]}
+     */
+    async getMany(q = {}, include = "", limit = 25, offset = 0, sortBy = "id", sortOrder = "asc"){
+        return await this._getMany(q, include, Number(limit), Number(offset), sortBy, sortOrder);
+    }
+
+    /**
+     * @param {number} id
+     * @param {string | Object} include
+     * @returns {{} | null}
+     */
+    async get(id, include){
+        return await this._get(Number(id), include);
+    }
+
+    /**
+     * @param {Object} data
+     * @returns  {Object}
+     */
+    async create(data){
+        return await this._create(data);
+    }
+
+    /**
+     * @param {number} id
+     * @param {{}} data
+     * @returns {Object}
+     */
+    async update(id, data){
+        return await this._update(Number(id), data);
+    }
+
+    /**
+     * @param {number} id
+     * @returns {Object}
+     */
+    async delete(id){
+        return await this._delete(Number(id));
+    }
+
+    /**
+     * @param {string | Object} include
+     * @returns {Object}
+     */
+    filter(include){
+        return {...this._filter(include), ...this.getAccessFilter()};
+    }
+
+    /**
+     * @param {string | Object} include
+     * @returns {Object}
+     */
+    include(include){
+        return this._include(include);
+    }
+}
+
+module.exports = {${className}, QueryBuilder, prisma};
+`;
+}
+
+/**
+ * Map Prisma types to JavaScript types
+ * @param {string} prismaType - Prisma field type
+ * @returns {string} - JavaScript type
+ */
+function mapPrismaTypeToJS(prismaType) {
+  const typeMap = {
+    'String': 'string',
+    'Int': 'number',
+    'Float': 'number',
+    'Decimal': 'number',
+    'Boolean': 'boolean',
+    'DateTime': 'Date',
+    'Json': 'object',
+    'Bytes': 'Buffer'
+  };
+
+  return typeMap[prismaType] || prismaType;
+}
+
+/**
+ * Generate all model files
+ * @param {Object} models - Models object from parser
+ * @param {string} modelDir - Directory to output model files
+ * @param {string} modelJsPath - Path to output Model.js
+ */
+function generateAllModels(models, modelDir, modelJsPath) {
+  // Create model directory if it doesn't exist
+  if (!fs.existsSync(modelDir)) {
+    fs.mkdirSync(modelDir, { recursive: true });
+  }
+
+  // Generate individual model files
+  for (const [modelName, modelInfo] of Object.entries(models)) {
+    const modelCode = generateModelFile(modelName, modelInfo);
+    // Capitalize first letter for filename
+    const className = modelName.charAt(0).toUpperCase() + modelName.slice(1);
+    const modelPath = path.join(modelDir, `${className}.js`);
+    fs.writeFileSync(modelPath, modelCode);
+    console.log(`Generated model: ${className}.js`);
+  }
+
+  // Copy Model.js to output if it exists in the project
+  const sourceModelJs = path.join(process.cwd(), 'Model.js');
+  if (fs.existsSync(sourceModelJs)) {
+    fs.copyFileSync(sourceModelJs, modelJsPath);
+    console.log('Copied Model.js to output');
+  } else {
+    console.warn('Warning: Model.js not found in project root');
+  }
+
+  // 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 outputRapiddJs = path.join(outputRapiddDir, 'rapidd.js');
+
+  if (fs.existsSync(sourceRapiddJs)) {
+    if (!fs.existsSync(outputRapiddDir)) {
+      fs.mkdirSync(outputRapiddDir, { recursive: true });
+    }
+    fs.copyFileSync(sourceRapiddJs, outputRapiddJs);
+    console.log('Copied rapidd.js to output');
+  }
+}
+
+module.exports = {
+  generateAllModels,
+  generateModelFile
+};

package/src/generators/relationshipsGenerator.js

@@ -0,0 +1,186 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Generate relationships.json from Prisma DMMF
+ * @param {Object} models - Models object from parser
+ * @param {string} outputPath - Path to output relationships.json
+ */
+function generateRelationships(models, outputPath) {
+  const relationships = {};
+
+  for (const [modelName, modelInfo] of Object.entries(models)) {
+    relationships[modelName] = {};
+
+    for (const relation of modelInfo.relations) {
+      const relatedModel = models[relation.type];
+
+      if (!relatedModel) {
+        console.warn(`Warning: Related model ${relation.type} not found for ${modelName}.${relation.name}`);
+        continue;
+      }
+
+      // Check if the related model has a composite primary key (many-to-many junction table)
+      const compositeKeyFields = getCompositeKeyFromModel(relatedModel);
+
+      // Only add field/fields if:
+      // 1. Related model has composite key (junction table)
+      // 2. It's a many relationship (array)
+      // 3. The composite key includes this model's foreign key (proving it's a junction for this model)
+      const currentModelFk = `${modelName.toLowerCase()}_id`;
+      const isJunctionTable = compositeKeyFields &&
+                             compositeKeyFields.length > 1 &&
+                             relation.isArray &&
+                             compositeKeyFields.includes(currentModelFk);
+
+      if (isJunctionTable) {
+        // Many-to-many relationship through junction table
+        // Reorder fields so current model's field comes first
+        const reorderedFields = reorderFieldsForModel(compositeKeyFields, modelName);
+
+        relationships[modelName][relation.name] = {
+          'object': relation.type,
+          'field': compositeKeyFields.join('_'), // e.g., "course_id_teacher_id"
+          'fields': reorderedFields
+        };
+      } else {
+        // Simple one-to-one or one-to-many relationship
+        // Find the foreign key field name
+        const foreignKeyField = findForeignKeyField(relation, modelInfo, relatedModel);
+
+        relationships[modelName][relation.name] = {
+          'object': relation.type,
+          'field': foreignKeyField || `${relation.type}_id` // Use actual FK or fallback to convention
+        };
+      }
+    }
+  }
+
+  // Ensure output directory exists
+  const outputDir = path.dirname(outputPath);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  fs.writeFileSync(outputPath, JSON.stringify(relationships, null, 4));
+  console.log('Generated relationships.json');
+}
+
+/**
+ * Find the foreign key field for a relation
+ * @param {Object} relation - Relation object
+ * @param {Object} currentModel - Current model info
+ * @param {Object} relatedModel - Related model info
+ * @returns {string|null} - Foreign key field name
+ */
+function findForeignKeyField(relation, currentModel, relatedModel) {
+  // If relation has relationFromFields, use it
+  if (relation.relationFromFields && relation.relationFromFields.length > 0) {
+    return relation.relationFromFields[0];
+  }
+
+  // For array relations (one-to-many from parent), look for the FK in the related model
+  if (relation.isArray) {
+    // Find which field in the related model points back to current model
+    for (const [fieldName, fieldInfo] of Object.entries(relatedModel.fields)) {
+      if (fieldInfo.relationName === relation.relationName &&
+          fieldInfo.relationFromFields &&
+          fieldInfo.relationFromFields.length > 0) {
+        // This is the FK field in the related model
+        return fieldInfo.relationFromFields[0];
+      }
+    }
+
+    // Fallback: convention-based
+    return `${relation.type}_id`;
+  }
+
+  // For singular relations (many-to-one), find the FK in current model
+  for (const [fieldName, fieldInfo] of Object.entries(currentModel.fields)) {
+    if (fieldInfo.relationName === relation.relationName &&
+        fieldInfo.relationToFields &&
+        fieldInfo.relationToFields.length > 0) {
+      // Found the matching relation field, return its FK
+      return fieldName;
+    }
+  }
+
+  // Final fallback
+  return `${relation.type}_id`;
+}
+
+/**
+ * Get composite key fields from a model
+ * @param {Object} modelInfo - Model information
+ * @returns {Array|null} - Array of composite key field names or null
+ */
+function getCompositeKeyFromModel(modelInfo) {
+  // First check if the model has a compositeKey property (from parser)
+  if (modelInfo.compositeKey && modelInfo.compositeKey.length > 1) {
+    return modelInfo.compositeKey;
+  }
+
+  // Fallback: check for fields marked with isId (for schema parser)
+  const compositeFields = [];
+  for (const [fieldName, fieldInfo] of Object.entries(modelInfo.fields)) {
+    if (fieldInfo.isId && !fieldInfo.isRelation) {
+      compositeFields.push(fieldName);
+    }
+  }
+
+  // If we found multiple ID fields, it's a composite key
+  if (compositeFields.length > 1) {
+    return compositeFields;
+  }
+
+  return null;
+}
+
+/**
+ * Reorder composite key fields so the current model's field comes first
+ * @param {Array} fields - Array of field names
+ * @param {String} currentModelName - Name of the current model
+ * @returns {Array} - Reordered array with current model's field first
+ */
+function reorderFieldsForModel(fields, currentModelName) {
+  const currentModelField = `${currentModelName.toLowerCase()}_id`;
+  const index = fields.indexOf(currentModelField);
+
+  if (index > 0) {
+    // Move current model's field to the front
+    const reordered = [...fields];
+    reordered.splice(index, 1);
+    reordered.unshift(currentModelField);
+    return reordered;
+  }
+
+  return fields;
+}
+
+/**
+ * Generate relationships.json from schema
+ * @param {string} schemaPath - Path to Prisma schema file
+ * @param {string} outputPath - Path to output relationships.json
+ */
+function generateRelationshipsFromSchema(schemaPath, outputPath) {
+  const { parsePrismaSchema } = require('../parsers/prismaParser');
+  const parsedData = parsePrismaSchema(schemaPath);
+  generateRelationships(parsedData.models, outputPath);
+}
+
+/**
+ * Generate relationships.json from DMMF
+ * @param {string} prismaClientPath - Path to Prisma client
+ * @param {string} outputPath - Path to output relationships.json
+ */
+async function generateRelationshipsFromDMMF(prismaClientPath, outputPath) {
+  const { parsePrismaDMMF } = require('../parsers/prismaParser');
+  const parsedData = await parsePrismaDMMF(prismaClientPath);
+  generateRelationships(parsedData.models, outputPath);
+}
+
+module.exports = {
+  generateRelationships,
+  generateRelationshipsFromSchema,
+  generateRelationshipsFromDMMF
+};

package/src/generators/rlsGenerator.js

@@ -0,0 +1,334 @@
+const fs = require('fs');
+const path = require('path');
+const { Client } = require('pg');
+const { createConverter } = require('../parsers/autoRLSConverter');
+const { analyzeFunctions, generateMappingConfig } = require('../parsers/functionAnalyzer');
+
+/**
+ * Auto-detect user table name (case-insensitive search for user/users)
+ * @param {Object} models - Models object from parser
+ * @param {string} userTableOption - User-specified table name (optional)
+ * @returns {string} - Name of the user table
+ */
+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
+ * @param {string} databaseUrl - PostgreSQL connection URL
+ * @param {Array} modelNames - Array of model names
+ * @returns {Object} - RLS policies for each table
+ */
+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, // SELECT, INSERT, UPDATE, DELETE, ALL
+          using: row.qual, // USING expression
+          withCheck: row.with_check // WITH CHECK expression
+        });
+      }
+    }
+
+    await client.end();
+    return policies;
+
+  } catch (error) {
+    try {
+      await client.end();
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+    throw error;
+  }
+}
+
+/**
+ * Generate RLS functions for a single model from PostgreSQL policies
+ * @param {string} modelName - Name of the model
+ * @param {Array} policies - Array of policy objects for this model
+ * @param {string} userTable - Name of the user table
+ * @returns {string} - JavaScript code for RLS functions
+ */
+function generateModelRLS(modelName, policies, userTable) {
+  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 canCreate (INSERT policies with WITH CHECK)
+  const canCreateCode = generateCanCreate(insertPolicies);
+
+  // Generate hasAccess (SELECT policies with USING)
+  const hasAccessCode = generateHasAccess(selectPolicies);
+
+  // Generate getAccessFilter (SELECT policies)
+  const accessFilterCode = generateFilter(selectPolicies, 'using');
+
+  // Generate getUpdateFilter (UPDATE policies)
+  const updateFilterCode = generateFilter(updatePolicies, 'using');
+
+  // Generate getDeleteFilter (DELETE policies)
+  const deleteFilterCode = generateFilter(deletePolicies, 'using');
+
+  return `    ${modelName}: {
+        canCreate: (user) => {
+            ${canCreateCode}
+        },
+        hasAccess: (data, user) => {
+            ${hasAccessCode}
+        },
+        getAccessFilter: (user) => {
+            ${accessFilterCode}
+        },
+        getUpdateFilter: (user) => {
+            ${updateFilterCode}
+        },
+        getDeleteFilter: (user) => {
+            ${deleteFilterCode}
+        },
+        getOmitFields: (user) => []
+    }`;
+}
+
+/**
+ * Generate canCreate function from INSERT policies
+ */
+function generateCanCreate(insertPolicies, converter) {
+  if (insertPolicies.length === 0) {
+    return 'return true;';
+  }
+
+  const conditions = [];
+
+  for (const policy of insertPolicies) {
+    const expr = policy.withCheck || policy.using;
+    if (expr) {
+      try {
+        const jsExpr = converter.convertToJavaScript(expr, 'data', 'user');
+        conditions.push(jsExpr);
+      } catch (e) {
+        conditions.push(`true /* Error parsing: ${expr.substring(0, 50)}... */`);
+      }
+    }
+  }
+
+  if (conditions.length === 0) {
+    return 'return true;';
+  }
+
+  // Policies are OR'd together (any policy allows)
+  return `return ${conditions.join(' || ')};`;
+}
+
+/**
+ * Generate hasAccess function from SELECT policies
+ */
+function generateHasAccess(selectPolicies) {
+  if (selectPolicies.length === 0) {
+    return 'return true;';
+  }
+
+  const conditions = [];
+
+  for (const policy of selectPolicies) {
+    if (policy.using) {
+      try {
+        const jsExpr = convertToJavaScript(policy.using, 'data', 'user');
+        conditions.push(jsExpr);
+      } catch (e) {
+        conditions.push(`true /* Error parsing: ${policy.using.substring(0, 50)}... */`);
+      }
+    }
+  }
+
+  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) {
+  if (policies.length === 0) {
+    return 'return {};';
+  }
+
+  const filters = [];
+
+  for (const policy of policies) {
+    const expr = policy[expressionField];
+    if (expr) {
+      try {
+        const prismaFilter = convertToPrismaFilter(expr, 'user');
+        if (prismaFilter !== '{}') {
+          filters.push(prismaFilter);
+        }
+      } catch (e) {
+        // On error, return empty filter (permissive)
+      }
+    }
+  }
+
+  if (filters.length === 0) {
+    return 'return {};';
+  }
+
+  if (filters.length === 1) {
+    return `return ${filters[0]};`;
+  }
+
+  // Multiple policies are OR'd together
+  return `return { OR: [${filters.join(', ')}] };`;
+}
+
+/**
+ * Generate complete rls.js file
+ * @param {Object} models - Models object
+ * @param {string} outputPath - Path to output rls.js
+ * @param {string} databaseUrl - Database connection URL
+ * @param {boolean} isPostgreSQL - Whether database is PostgreSQL
+ * @param {string} userTableOption - User-specified table name
+ */
+async function generateRLS(models, outputPath, databaseUrl, isPostgreSQL, userTableOption) {
+  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`;
+
+  // Analyze PostgreSQL functions if available
+  let functionAnalysis = null;
+
+  if (isPostgreSQL && databaseUrl) {
+    console.log('PostgreSQL detected - analyzing database functions...');
+    try {
+      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}`);
+    } catch (error) {
+      console.warn(`⚠ Could not analyze functions: ${error.message}`);
+    }
+
+    console.log('Extracting RLS policies from database...');
+    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...');
+      // Initialize empty policies for all models
+      for (const modelName of modelNames) {
+        policies[modelName] = [];
+      }
+    }
+  } else {
+    if (!isPostgreSQL) {
+      console.log('Non-PostgreSQL database detected (MySQL/SQLite/etc) - RLS not supported');
+    }
+    console.log('Generating permissive RLS for all models...');
+    // Initialize empty policies 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], userTable);
+  });
+  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');
+}
+
+module.exports = {
+  generateRLS
+};