@rapidd/build 1.2.3 → 2.0.1

package/src/generators/relationshipsGenerator.js

@@ -1,200 +0,0 @@
-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);
-
-        if (!foreignKeyField) {
-          // Skip this relationship if we can't find the FK field
-          // This usually means the FK is on the other side of the relation
-          continue;
-        }
-
-        relationships[modelName][relation.name] = {
-          'object': relation.type,
-          'field': foreignKeyField
-        };
-      }
-    }
-  }
-
-  // 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) {
-  // IMPORTANT: The foreign key field is where the @relation(fields: [...]) is defined
-
-  // For array relations (one-to-many), the FK is in the related model (child)
-  if (relation.isArray) {
-    // Find the corresponding relation in the related model that points back
-    for (const relField of Object.values(relatedModel.fields)) {
-      if (relField.kind === 'object' &&
-          relField.relationName === relation.relationName &&
-          relField.relationFromFields &&
-          relField.relationFromFields.length > 0) {
-        // This is the FK field in the child (related) model
-        return relField.relationFromFields[0];
-      }
-    }
-    // Fallback
-    return null;
-  }
-
-  // For singular relations (many-to-one or one-to-one), check if THIS relation has fields defined
-  if (relation.relationFromFields && relation.relationFromFields.length > 0) {
-    // The FK is in the current model
-    return relation.relationFromFields[0];
-  }
-
-  // For optional one-to-one relations where FK is on the other side
-  // (e.g., users -> student_profiles? where userId is in student_profiles)
-  if (!relation.isArray) {
-    // Find the corresponding relation in the related model that points back
-    for (const relField of Object.values(relatedModel.fields)) {
-      if (relField.kind === 'object' &&
-          relField.relationName === relation.relationName &&
-          relField.relationFromFields &&
-          relField.relationFromFields.length > 0) {
-        // This is the FK field in the related model (pointing back to us)
-        return relField.relationFromFields[0];
-      }
-    }
-  }
-
-  // If no fields on this side, the FK must be on the other side (shouldn't use this relation for filtering)
-  return null;
-}
-
-/**
- * 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} schemaPath - Path to Prisma schema file
- * @param {string} outputPath - Path to output relationships.json
- */
-async function generateRelationshipsFromDMMF(schemaPath, outputPath) {
-  const { parsePrismaDMMF } = require('../parsers/prismaParser');
-  const parsedData = await parsePrismaDMMF(schemaPath);
-  generateRelationships(parsedData.models, outputPath);
-}
-
-module.exports = {
-  generateRelationships,
-  generateRelationshipsFromSchema,
-  generateRelationshipsFromDMMF
-};

package/src/generators/routeGenerator.js

@@ -1,119 +0,0 @@
-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 className = modelName.split(/[^a-zA-Z0-9]+/)        // split on any non-alphanumeric char
-    .filter(Boolean)               // remove empty parts
-    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-    .join('');
-
-  return `const router = require('express').Router();
-const {${className}, QueryBuilder, prisma} = require('../../../src/Model/${className}');
-
-router.all('*', async (req, res, next) => {
-    if(req.user){
-        req.${className} = new ${className}({'user': req.user});
-        next();
-    }
-    else{
-        return res.sendError(401, "no_valid_session");
-    }
-});
-
-// GET ALL
-router.get('/', async function(req, res) {
-    try {
-        const { q = {}, include = "", limit = 25, offset = 0, sortBy = "id", sortOrder = "asc" } = req.query;
-        const results = await req.${className}.getMany(q, include, limit, offset, sortBy, sortOrder);
-        return res.sendList(results.data, results.meta);
-    }
-    catch(error){
-        const response = QueryBuilder.errorHandler(error);
-        return res.status(response.status_code).send(response);
-    }
-});
-
-// GET BY ID
-router.get('/:id', async function(req, res) {
-    try{
-        const { include = ""} = req.query;
-        const response = await req.${className}.get(req.params.id, include);
-        return res.json(response);
-    }
-    catch(error){
-        const response = QueryBuilder.errorHandler(error);
-        return res.status(response.status_code).send(response);
-    }
-});
-
-// CREATE
-router.post('/', async function(req, res) {
-    const payload = req.body;
-    try{
-        const response = await req.${className}.create(payload);
-        return res.status(201).json(response);
-    }
-    catch(error){
-        const response = QueryBuilder.errorHandler(error, payload);
-        return res.status(response.status_code).send(response);
-    }
-});
-
-// UPDATE
-router.patch('/:id', async function(req, res) {
-    const payload = req.body;
-    try{
-        const response = await req.${className}.update(req.params.id, payload);
-        return res.json(response);
-    }
-    catch(error){
-        const response = QueryBuilder.errorHandler(error, payload);
-        return res.status(response.status_code).send(response);
-    }
-});
-
-// DELETE
-router.delete('/:id', async (req, res)=>{
-    try{
-        await req.${className}.delete(req.params.id);
-        return res.sendResponse(200, "object_deleted_successfully", {modelName: "${className}"});
-    }
-    catch(error){
-        const response = QueryBuilder.errorHandler(error);
-        return res.status(response.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}.js`);
-    fs.writeFileSync(routePath, routeCode);
-    console.log(`Generated route: ${modelName}.js`);
-  }
-}
-
-module.exports = {
-  generateAllRoutes,
-  generateRouteFile
-};

package/src/parsers/datasourceParser.js

@@ -1,121 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-// Load .env file if it exists
-try {
-  require('dotenv').config({ path: path.join(process.cwd(), '.env') });
-} catch (e) {
-  // 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
- * @returns {Object} - Datasource configuration with resolved URL
- */
-function parseDatasource(schemaPath) {
-  const schemaContent = fs.readFileSync(schemaPath, 'utf-8');
-
-  // Extract datasource block
-  const datasourceRegex = /datasource\s+\w+\s*{([^}]*)}/;
-  const match = schemaContent.match(datasourceRegex);
-
-  if (!match) {
-    throw new Error('No datasource block found in Prisma schema');
-  }
-
-  const datasourceBlock = match[1];
-
-  // Extract provider
-  const providerMatch = datasourceBlock.match(/provider\s*=\s*"([^"]+)"/);
-  const provider = providerMatch ? providerMatch[1] : null;
-
-  // Try to extract url from schema first
-  let url = null;
-  const urlMatch = datasourceBlock.match(/url\s*=\s*(.+)/);
-
-  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, '');
-    }
-  }
-
-  // If no URL in schema, try prisma.config.ts (Prisma 7)
-  if (!url) {
-    url = loadUrlFromPrismaConfig();
-  }
-
-  // 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
-  // This is important because the schema might say "mysql" but DATABASE_URL could be postgresql://
-  let isPostgreSQL = provider === 'postgresql' || provider === 'postgres';
-
-  if (!isPostgreSQL && url) {
-    // Check if URL starts with postgresql:// or postgres://
-    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,
-    isMySQL
-  };
-}
-
-module.exports = {
-  parseDatasource
-};