rad-api 1.0.0

package/README.md

@@ -0,0 +1,156 @@
+# KAPI - Rapid API Development Tool
+
+Un outil puissant pour générer rapidement des fichiers de routes, contrôleurs et modèles pour votre API.
+
+## Installation
+
+```bash
+npm install -g rad-api
+```
+
+Ou pour le développement local :
+
+```bash
+npm link
+```
+
+## Utilisation
+
+### Générer une route
+
+Générez un fichier de route complet pour une table spécifique :
+
+```bash
+kapi generate route <tableName>
+```
+
+#### Exemple :
+
+```bash
+kapi generate route citations
+```
+
+Cela créera un fichier `citations.routes.js` avec :
+- Configuration Prisma MariaDB
+- Fonction `all()` pour récupérer tous les enregistrements
+- Gestion des erreurs complète
+- Logs de requête
+
+#### Fichier généré (`citations.routes.js`) :
+
+```javascript
+import { PrismaMariaDb } from '@prisma/adapter-mariadb';
+import { PrismaClient } from '../../../generated/prisma/client.js';
+
+const maria = new PrismaMariaDb({
+  host: process.env.DATABASE_HOST,
+  port: process.env.DATABASE_PORT,
+  user: process.env.DATABASE_USER,
+  password: process.env.DATABASE_PASSWORD,
+  database: process.env.DATABASE_NAME
+});
+
+const prisma = new PrismaClient({ adapter: maria });
+
+export const all = async (req, res) => {
+  req.log?.info('all Citations endpoint');
+  try {
+    const allCitation = await main();
+    res.status(200);
+    res.json(allCitation);
+  } catch (error) {
+    req.log?.error('Error fetching Citations:', error);
+    return res.status(500).json({ msg: 'Internal Server Error' });
+  }
+};
+
+async function main() {
+  const allCitation = await prisma.Citations.findMany()
+  console.log('All Citations:', JSON.stringify(allCitation, null, 2))
+  return allCitation;
+}
+```
+
+## Fonctionnalités
+
+- ✅ Génération automatique de fichiers de routes
+- ✅ Conversion intelligente des noms (singulier/pluriel, PascalCase)
+- ✅ Intégration Prisma MariaDB préinstallée
+- ✅ Gestion des erreurs et logs
+- ✅ Protection contre les fichiers dupliqués
+- ✅ Messages de sortie détaillés et utiles
+
+## Structure du projet
+
+```
+RAD-api/
+├── index.js                    # Point d'entrée CLI
+├── package.json
+├── README.md
+└── src/
+    ├── commands/
+    │   └── generate.js        # Logique de génération
+    ├── templates/
+    │   └── route.template.js  # Template de route
+    └── utils/
+        ├── parser.js          # Parser d'arguments
+        ├── fileHelper.js      # Utilitaires de fichier
+        └── stringHelper.js    # Utilitaires de chaîne
+```
+
+## Options d'environnement
+
+Le fichier généré utilise les variables d'environnement suivantes :
+
+```
+DATABASE_HOST      = Adresse du serveur MariaDB
+DATABASE_PORT      = Port MariaDB (par défaut: 3306)
+DATABASE_USER      = Utilisateur MariaDB
+DATABASE_PASSWORD  = Mot de passe MariaDB
+DATABASE_NAME      = Nom de la base de données
+```
+
+## Exemples d'utilisation
+
+### Tables simples
+```bash
+kapi generate route products
+kapi generate route categories
+kapi generate route customers
+```
+
+### Tables plurielles
+```bash
+kapi generate route citations      # Génère handlers pour la table "Citations"
+kapi generate route users          # Génère handlers pour la table "Users"
+```
+
+## Gestion des erreurs
+
+L'outil gère automatiquement :
+- Les fichiers déjà existants ✓
+- Les noms de table vides ✓
+- Les répertoires manquants (création automatique) ✓
+
+## Développement
+
+Pour ajouter de nouvelles commandes :
+
+1. Créez un template dans `src/templates/`
+2. Créez un fichier de commande dans `src/commands/`
+3. Ajoutez la logique de parsing dans `index.js`
+
+## Améliorations futures
+
+- [ ] `kapi generate controller <tableName>` - Générer les contrôleurs
+- [ ] `kapi generate model <tableName>` - Générer les modèles Prisma
+- [ ] `kapi generate crud <tableName>` - Générer CRUD complet
+- [ ] `kapi config` - Configuration interactive
+
+## Licence
+
+ISC
+
+## Auteur
+
+kferrandon

package/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+import { parseArgs } from './src/utils/parser.js';
+import { generate } from './src/commands/generate.js';
+
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+console.log(args);
+    try {
+        if (args.command === 'generate') {
+            if (!args.table) {
+                console.error('❌ Error: Table name is required');
+                console.log('Usage: kapi generate route <tableName>');
+                process.exit(1);
+            }
+            if (args.type) {
+                await generate(args.type, args.table, args.path);
+            }
+
+        }
+        else {
+            console.log('🔧 KAPI - Rapid API Development');
+            console.log('\nUsage:');
+            console.log('  kapi generate route <tableName>  - Generate a route file for a table');
+            console.log('  kapi generate controller <tableName>  - Generate a controller file for a table');
+            console.log('\nExamples:');
+            console.log('  kapi generate route citations');
+            console.log('  kapi generate route users');
+        }
+    } catch (error) {
+        console.error('❌ Error:', error.message);
+        process.exit(1);
+    }
+}
+
+main();

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "rad-api",
+  "version": "1.0.0",
+  "description": "RAD pour créer des routes, controller, model ... etc",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "kapi": "index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kferrandonFulbert/rad-api.git"
+  },
+  "keywords": [
+    "RAD",
+    "API",
+    "automation"
+  ],
+  "author": "kferrandon",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/kferrandonFulbert/rad-api/issues"
+  },
+  "homepage": "https://github.com/kferrandonFulbert/rad-api#readme"
+}

package/src/commands/generate.js

@@ -0,0 +1,44 @@
+import { readTemplate, writeFile, getOutputPath, fileExists } from '../utils/fileHelper.js';
+import { formatTableName } from '../utils/stringHelper.js';
+
+export async function generate(type, tableName, pathOverride='output') {
+  try {
+    // Valider le nom de la table
+    if (!tableName || tableName.trim() === '') {
+      throw new Error('Table name cannot be empty');
+    }
+
+    // Formater les noms
+    const { tableSingular, tablePlural } = formatTableName(tableName);
+
+    // Récupérer le template
+    let content = readTemplate('route');
+
+    // Remplacer les placeholders
+    content = content.replace(/{{TABLE_SINGULAR}}/g, tableSingular);
+    content = content.replace(/{{TABLE_PLURAL}}/g, tablePlural);
+
+    // Déterminer le chemin de sortie
+    const outputPath = getOutputPath(tableName, type, pathOverride);
+
+    // Vérifier si le fichier existe déjà
+    if (fileExists(outputPath)) {
+      throw new Error(`File ${tableName}.${type}s.js already exists. Please choose a different name or remove the existing file.`);
+    }
+
+    // Écrire le fichier
+    writeFile(outputPath, content);
+
+    console.log(`✅ ${type} file created successfully!`);
+    console.log(`📁 Location: ${outputPath}`);
+    console.log(`\n📝 File content generated for table: ${tablePlural}`);
+    console.log(`   - Handler: all() - Get all ${tablePlural}`);
+    console.log(`\n🚀 Next steps:`);
+    console.log(`   1. Import this route in your main ${type}`);
+    console.log(`   2. Ensure your Prisma client is properly configured`);
+    console.log(`   3. Update the adapter path if needed: ../../../generated/prisma/client.js`);
+
+  } catch (error) {
+    throw error;
+  }
+}

package/src/templates/controller.template.js

@@ -0,0 +1,31 @@
+import { PrismaMariaDb } from '@prisma/adapter-mariadb';
+import { PrismaClient } from '../../../generated/prisma/client.js';
+
+const maria = new PrismaMariaDb({
+  host: process.env.DATABASE_HOST,
+  port: process.env.DATABASE_PORT,
+  user: process.env.DATABASE_USER,
+  password: process.env.DATABASE_PASSWORD,
+  database: process.env.DATABASE_NAME
+});
+
+const prisma = new PrismaClient({ adapter: maria });
+
+export const all = async (req, res) => {
+  req.log?.info('all {{TABLE_PLURAL}} endpoint');
+  try {
+    const all{{TABLE_SINGULAR}} = await main();
+
+    res.status(200);
+    res.json(all{{TABLE_SINGULAR}});
+  } catch (error) {
+    req.log?.error('Error fetching {{TABLE_PLURAL}}:', error);
+    return res.status(500).json({ msg: 'Internal Server Error' });
+  }
+};
+
+async function main() {
+  const all{{TABLE_SINGULAR}} = await prisma.{{TABLE_PLURAL}}.findMany()
+  console.log('All {{TABLE_PLURAL}}:', JSON.stringify(all{{TABLE_SINGULAR}}, null, 2))
+  return all{{TABLE_SINGULAR}};
+}

package/src/templates/route.template.js

@@ -0,0 +1,23 @@
+import { Router } from 'express';
+import { all } from '../controllers/citations.controller.js';
+import { authMiddleware } from '../middlewares/auth.middleware.js';
+
+const router = Router();
+
+/**
+ * @openapi
+ * /{TABLE_SINGULAR}/:
+ *   get:
+ *     summary: get all {TABLE_PLURAL}
+ *     responses:
+ *       200:
+ *         description: OK
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               
+ */
+router.get('/', all);
+
+export default router;

package/src/utils/fileHelper.js

@@ -0,0 +1,42 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export function getOutputPath(tableName, type = 'route', pathOverride = 'output') {
+    // Le fichier sera créé dans le répertoire output 
+    let cwd =null;
+    if (pathOverride === 'output') {
+        cwd = process.cwd() + "/" + pathOverride;
+    } else {
+        cwd = pathOverride;
+    }
+
+    return path.join(cwd, `${tableName}.${type}.js`);
+}
+
+export function fileExists(filePath) {
+    return fs.existsSync(filePath);
+}
+
+export function writeFile(filePath, content) {
+    const dir = path.dirname(filePath);
+
+    // Créer le répertoire s'il n'existe pas
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+
+    fs.writeFileSync(filePath, content, 'utf-8');
+}
+
+export function getTemplatePath(templateName) {
+    return path.join(__dirname, '..', 'templates', `${templateName}.template.js`);
+}
+
+export function readTemplate(templateName) {
+    const templatePath = getTemplatePath(templateName);
+    return fs.readFileSync(templatePath, 'utf-8');
+}

package/src/utils/parser.js

@@ -0,0 +1,24 @@
+export function parseArgs(args) {
+  const result = {
+    command: null,
+    type: null,
+    table: null,
+    path: 'output'
+  };
+
+  if (args.length === 0) return result;
+
+  result.command = args[0]; // 'generate'
+  
+  if (args.length > 1) {
+    result.type = args[1]; // 'route'
+  }
+  
+  if (args.length > 2) {
+    result.table = args[2]; // 'citations'
+  }
+  if (args.length > 3) {
+    result.path = args[3]; // 'path'
+  }
+  return result;
+}

package/src/utils/stringHelper.js

@@ -0,0 +1,36 @@
+export function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+export function singularize(word) {
+  // Règles simples de singularisation pour le français/anglais
+  if (word.endsWith('ies')) {
+    return word.slice(0, -3) + 'y';
+  }
+  if (word.endsWith('es')) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith('s')) {
+    return word.slice(0, -1);
+  }
+  return word;
+}
+
+export function toPascalCase(str) {
+  return str
+    .split(/[-_]/)
+    .map(word => capitalize(word))
+    .join('');
+}
+
+export function formatTableName(tableName) {
+  const plural = tableName.toLowerCase();
+  const singular = toPascalCase(singularize(tableName));
+  const pluralPascal = toPascalCase(tableName);
+
+  return {
+    tableName: plural,
+    tableSingular: singular,
+    tablePlural: pluralPascal
+  };
+}