@rapidd/build 1.0.0 → 1.0.2

package/README.md

@@ -11,6 +11,7 @@ Dynamic code generator that transforms Prisma schemas into complete Express.js C
 - 👥 **Role-Based Access Control** - Properly handles role checks in filters
 - 📊 **Model Generation** - Creates CRUD model classes with capitalized filenames
 - 🗺️ **Relationships JSON** - Generates complete relationship mappings with foreign keys
+- ⚡ **Selective Generation** - Update only specific models or components
 
 ## Installation
 
@@ -21,16 +22,77 @@ npm install @rapidd/build
 ## Quick Start
 
 ```bash
-# Generate in current directory (default)
+# Generate everything in current directory (default)
 npx rapidd build
 
 # Generate in specific directory
 npx rapidd build --output ./generated
 
+# Generate only specific model
+npx rapidd build --model user
+
+# Generate only specific component
+npx rapidd build --only model
+npx rapidd build --only route
+npx rapidd build --only rls
+npx rapidd build --only relationship
+
+# Combine model and component filters
+npx rapidd build --model account --only route
+
 # Specify custom user table
 npx rapidd build --user-table accounts
 ```
 
+## CLI Options
+
+- `-o, --output <path>` - Output directory (default: `./`)
+- `-s, --schema <path>` - Prisma schema file (default: `./prisma/schema.prisma`)
+- `-m, --model <name>` - Generate/update only specific model (e.g., "account", "user")
+- `--only <component>` - Generate only specific component: "model", "route", "rls", or "relationship"
+- `--user-table <name>` - User table name for RLS (default: auto-detected)
+
+## Selective Generation
+
+### Update Single Model
+
+```bash
+# Update only the account model across all components
+npx rapidd build --model account
+```
+
+This will:
+- Generate/update `src/Model/Account.js`
+- Generate/update `routes/api/v1/account.js`
+- Update the `account` entry in `rapidd/relationships.json`
+- Update the `account` entry in `rapidd/rls.js`
+
+### Update Single Component
+
+```bash
+# Regenerate all routes
+npx rapidd build --only route
+
+# Regenerate all RLS configs
+npx rapidd build --only rls
+
+# Regenerate all models
+npx rapidd build --only model
+
+# Regenerate relationships
+npx rapidd build --only relationship
+```
+
+### Combine Filters
+
+```bash
+# Update only the route for a specific model
+npx rapidd build --model user --only route
+
+# Update RLS for account model
+npx rapidd build --model account --only rls
+```
+
 ## Generated Structure
 
 ```
@@ -69,18 +131,39 @@ getAccessFilter: (user) => {
 }
 ```
 
-## CLI Options
-
-- `-o, --output <path>` - Output directory (default: `./`)
-- `-s, --schema <path>` - Prisma schema file (default: `./prisma/schema.prisma`)
-- `-u, --user-table <name>` - User table name for RLS (default: auto-detected)
-
 ## Usage with PostgreSQL RLS
 
 ```bash
 DATABASE_URL="postgresql://user:pass@localhost:5432/mydb" npx rapidd build
 ```
 
+## Use Cases
+
+### During Development
+```bash
+# After adding a new model to schema
+npx rapidd build --model newModel
+
+# After changing relationships
+npx rapidd build --only relationship
+
+# After updating RLS policies
+npx rapidd build --only rls
+```
+
+### Continuous Integration
+```bash
+# Full rebuild for CI/CD
+npx rapidd build --output ./generated
+```
+
+### Incremental Updates
+```bash
+# Update specific model after schema changes
+npx rapidd build --model user --only model
+npx rapidd build --model user --only rls
+```
+
 ## License
 
 MIT

package/bin/cli.js

@@ -16,7 +16,10 @@ program
   .description('Build model files from Prisma schema')
   .option('-s, --schema <path>', 'Path to Prisma schema file', process.env.PRISMA_SCHEMA_PATH || './prisma/schema.prisma')
   .option('-o, --output <path>', 'Output base directory', './')
+  .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.0",
+  "version": "1.0.2",
   "description": "Dynamic code generator that transforms Prisma schemas into Express.js CRUD APIs with PostgreSQL RLS-to-JavaScript translation",
   "main": "index.js",
   "bin": {
@@ -12,12 +12,12 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/rapidd/build"
+    "url": "https://github.com/MertDalbudak/rapidd-build"
   },
   "bugs": {
-    "url": "https://github.com/rapidd/build/issues"
+    "url": "https://github.com/MertDalbudak/rapidd-build/issues"
   },
-  "homepage": "https://github.com/rapidd/build#readme",
+  "homepage": "https://github.com/MertDalbudak/rapidd-build#readme",
   "keywords": [
     "rapidd",
     "prisma",

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');
 }
@@ -302,12 +312,175 @@ module.exports = {prisma, Prisma, rls};
   console.log('✓ Generated rapidd/rapidd.js');
 }
 
+/**
+ * Update relationships.json for a specific model
+ */
+async function updateRelationshipsForModel(filteredModels, relationshipsPath, prismaClientPath, schemaPath, usedDMMF) {
+  let existingRelationships = {};
+
+  // Load existing relationships if file exists
+  if (fs.existsSync(relationshipsPath)) {
+    try {
+      existingRelationships = JSON.parse(fs.readFileSync(relationshipsPath, 'utf8'));
+    } catch (error) {
+      console.warn('Could not parse existing relationships.json, will create new');
+    }
+  }
+
+  // Generate relationships for the filtered model(s)
+  let newRelationships = {};
+  if (usedDMMF) {
+    // Use DMMF to get relationships for specific model
+    const { generateRelationshipsFromDMMF } = require('../generators/relationshipsGenerator');
+    const tempPath = relationshipsPath + '.tmp';
+    await generateRelationshipsFromDMMF(prismaClientPath, tempPath);
+    const allRelationships = JSON.parse(fs.readFileSync(tempPath, 'utf8'));
+    fs.unlinkSync(tempPath);
+
+    // Extract only the filtered model's relationships
+    for (const modelName of Object.keys(filteredModels)) {
+      if (allRelationships[modelName]) {
+        newRelationships[modelName] = allRelationships[modelName];
+      }
+    }
+  } else {
+    // Use schema parser
+    const { generateRelationshipsFromSchema } = require('../generators/relationshipsGenerator');
+    const tempPath = relationshipsPath + '.tmp';
+    generateRelationshipsFromSchema(schemaPath, tempPath);
+    const allRelationships = JSON.parse(fs.readFileSync(tempPath, 'utf8'));
+    fs.unlinkSync(tempPath);
+
+    // Extract only the filtered model's relationships
+    for (const modelName of Object.keys(filteredModels)) {
+      if (allRelationships[modelName]) {
+        newRelationships[modelName] = allRelationships[modelName];
+      }
+    }
+  }
+
+  // Merge with existing relationships
+  const updatedRelationships = { ...existingRelationships, ...newRelationships };
+
+  // Write back to file
+  fs.writeFileSync(relationshipsPath, JSON.stringify(updatedRelationships, null, 2));
+}
+
+/**
+ * Update rls.js for a specific model
+ */
+async function updateRLSForModel(filteredModels, allModels, rlsPath, datasource, userTable, relationships, debug = false) {
+  const { generateRLS } = require('../generators/rlsGeneratorV2');
+
+  // Generate RLS for the filtered model (but pass all models for user table detection)
+  const tempPath = rlsPath + '.tmp';
+  await generateRLS(
+    filteredModels,
+    tempPath,
+    datasource.url,
+    datasource.isPostgreSQL,
+    userTable,
+    relationships,
+    debug,
+    allModels
+  );
+
+  // Read the generated RLS for the specific model
+  const tempContent = fs.readFileSync(tempPath, 'utf8');
+  fs.unlinkSync(tempPath);
+
+  // Extract the model's RLS configuration
+  const modelName = Object.keys(filteredModels)[0];
+
+  // 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`);
+  }
+
+  // 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)) {
+    let existingContent = fs.readFileSync(rlsPath, 'utf8');
+
+    // Check if model already exists in RLS
+    const existingModelPattern = new RegExp(`${modelName}:\\s*\\{[\\s\\S]*?\\n    \\}(?=,|\\n)`);
+
+    if (existingModelPattern.test(existingContent)) {
+      // Replace existing model RLS
+      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    \})\n(\};)/,
+        `$1,\n    ${modelRls}\n$2`
+      );
+    }
+
+    fs.writeFileSync(rlsPath, existingContent);
+    console.log(`✓ Updated RLS for model: ${modelName}`);
+  } else {
+    // If rls.js doesn't exist, create it with just this model
+    await generateRLS(
+      filteredModels,
+      rlsPath,
+      datasource.url,
+      datasource.isPostgreSQL,
+      userTable,
+      relationships,
+      debug,
+      allModels
+    );
+  }
+}
+
 /**
  * Build models from Prisma schema
  * @param {Object} options - Build options
  * @param {string} options.schema - Path to Prisma schema file
  * @param {string} options.output - Output directory for generated models
- * @param {string} options.relationships - Path to relationships.json file
+ * @param {string} options.model - Optional: specific model to generate
+ * @param {string} options.only - Optional: specific component to generate
  */
 async function buildModels(options) {
   const schemaPath = path.resolve(process.cwd(), options.schema);
@@ -378,67 +551,121 @@ async function buildModels(options) {
 
   const { models, enums } = parsedData;
 
-  console.log(`Found ${Object.keys(models).length} models`);
+  // Filter models if --model option is provided
+  let filteredModels = models;
+  if (options.model) {
+    const modelName = options.model.toLowerCase();
+    const matchedModel = Object.keys(models).find(m => m.toLowerCase() === modelName);
 
-  // Generate model files
-  generateAllModels(models, modelDir, modelJsPath);
+    if (!matchedModel) {
+      throw new Error(`Model "${options.model}" not found in schema. Available models: ${Object.keys(models).join(', ')}`);
+    }
 
-  // Generate src/Model.js (base Model class)
-  console.log('\nGenerating src/Model.js...');
-  generateBaseModelFile(modelJsPath);
+    filteredModels = { [matchedModel]: models[matchedModel] };
+    console.log(`Filtering to model: ${matchedModel}`);
+  }
 
-  // Generate rapidd/rapidd.js
-  console.log('Generating rapidd/rapidd.js...');
-  generateRapiddFile(rapiddJsPath);
+  console.log(`Found ${Object.keys(models).length} models${options.model ? ` (generating ${Object.keys(filteredModels).length})` : ''}`);
 
-  // Generate relationships.json
-  console.log(`\nGenerating relationships.json...`);
+  // Determine which components to generate
+  const shouldGenerate = {
+    model: !options.only || options.only === 'model',
+    route: !options.only || options.only === 'route',
+    rls: !options.only || options.only === 'rls',
+    relationship: !options.only || options.only === 'relationship'
+  };
 
-  try {
-    if (usedDMMF) {
-      await generateRelationshipsFromDMMF(prismaClientPath, relationshipsPath);
-    } else {
-      generateRelationshipsFromSchema(schemaPath, relationshipsPath);
-    }
-    console.log(`✓ Relationships file generated at: ${relationshipsPath}`);
-  } catch (error) {
-    console.error('Failed to generate relationships.json:', error.message);
-    console.log('Note: You may need to create relationships.json manually.');
+  // Validate --only option
+  if (options.only && !['model', 'route', 'rls', 'relationship'].includes(options.only)) {
+    throw new Error(`Invalid --only value "${options.only}". Must be one of: model, route, rls, relationship`);
   }
 
-  // Generate RLS configuration
-  console.log(`\nGenerating RLS configuration...`);
+  // Generate model files
+  if (shouldGenerate.model) {
+    generateAllModels(filteredModels, modelDir, modelJsPath);
+  }
 
-  // Load relationships for Prisma filter building
-  let relationships = {};
-  try {
-    if (fs.existsSync(relationshipsPath)) {
-      relationships = JSON.parse(fs.readFileSync(relationshipsPath, 'utf8'));
+  // 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 if it doesn't exist
+  if (!fs.existsSync(rapiddJsPath)) {
+    console.log('Generating rapidd/rapidd.js...');
+    generateRapiddFile(rapiddJsPath);
+  }
+
+  // Generate relationships.json
+  if (shouldGenerate.relationship) {
+    console.log(`\nGenerating relationships.json...`);
+
+    try {
+      if (options.model) {
+        // Update only specific model in relationships.json
+        await updateRelationshipsForModel(filteredModels, relationshipsPath, prismaClientPath, schemaPath, usedDMMF);
+      } else {
+        // Generate all relationships
+        if (usedDMMF) {
+          await generateRelationshipsFromDMMF(prismaClientPath, relationshipsPath);
+        } else {
+          generateRelationshipsFromSchema(schemaPath, relationshipsPath);
+        }
+      }
+      console.log(`✓ Relationships file generated at: ${relationshipsPath}`);
+    } catch (error) {
+      console.error('Failed to generate relationships.json:', error.message);
+      console.log('Note: You may need to create relationships.json manually.');
     }
-  } catch (error) {
-    console.warn('Could not load relationships.json:', error.message);
   }
 
-  try {
-    // Parse datasource from Prisma schema to get database URL
-    const datasource = parseDatasource(schemaPath);
+  // Generate RLS configuration
+  if (shouldGenerate.rls) {
+    console.log(`\nGenerating RLS configuration...`);
+
+    // Load relationships for Prisma filter building
+    let relationships = {};
+    try {
+      if (fs.existsSync(relationshipsPath)) {
+        relationships = JSON.parse(fs.readFileSync(relationshipsPath, 'utf8'));
+      }
+    } catch (error) {
+      console.warn('Could not load relationships.json:', error.message);
+    }
 
-    await generateRLS(
-      models,
-      rlsPath,
-      datasource.url,
-      datasource.isPostgreSQL,
-      options.userTable,
-      relationships
-    );
-  } catch (error) {
-    console.error('Failed to generate RLS:', error.message);
-    console.log('Generating permissive RLS fallback...');
-    await generateRLS(models, rlsPath, null, false, options.userTable, relationships);
+    try {
+      // Parse datasource from Prisma schema to get database URL
+      const datasource = parseDatasource(schemaPath);
+
+      if (options.model) {
+        // Update only specific model in rls.js
+        await updateRLSForModel(filteredModels, models, rlsPath, datasource, options.userTable, relationships, options.debug);
+      } else {
+        // Generate RLS for all models
+        await generateRLS(
+          models,
+          rlsPath,
+          datasource.url,
+          datasource.isPostgreSQL,
+          options.userTable,
+          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, options.debug);
+      }
+    }
   }
 
   // Generate routes
-  generateAllRoutes(models, routesDir);
+  if (shouldGenerate.route) {
+    generateAllRoutes(filteredModels, routesDir);
+  }
 
   return { models, enums };
 }

package/src/generators/rlsGenerator.js

@@ -259,7 +259,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,11 +277,13 @@ 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}`);
     }

package/src/generators/rlsGeneratorV2.js

@@ -285,8 +285,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 +315,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) {

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;