rad-api 1.0.0 → 1.0.3

package/index.js

@@ -1,11 +1,11 @@
-#!/usr/bin/env node
+#!/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);
+ //   console.log(args);
     try {
         if (args.command === 'generate') {
             if (!args.table) {
@@ -14,6 +14,7 @@ console.log(args);
                 process.exit(1);
             }
             if (args.type) {
+                console.log(`Generating ${args.type} for table: ${args.table}`);
                 await generate(args.type, args.table, args.path);
             }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rad-api",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "RAD pour créer des routes, controller, model ... etc",
   "main": "index.js",
   "type": "module",

package/src/commands/generate.js

@@ -2,6 +2,7 @@ import { readTemplate, writeFile, getOutputPath, fileExists } from '../utils/fil
 import { formatTableName } from '../utils/stringHelper.js';
 
 export async function generate(type, tableName, pathOverride='output') {
+  console.log("Generating...", type, tableName, pathOverride);
   try {
     // Valider le nom de la table
     if (!tableName || tableName.trim() === '') {
@@ -12,7 +13,7 @@ export async function generate(type, tableName, pathOverride='output') {
     const { tableSingular, tablePlural } = formatTableName(tableName);
 
     // Récupérer le template
-    let content = readTemplate('route');
+    let content = readTemplate(type);
 
     // Remplacer les placeholders
     content = content.replace(/{{TABLE_SINGULAR}}/g, tableSingular);

package/src/templates/controller.template.js

@@ -1,31 +1,86 @@
-import { PrismaMariaDb } from '@prisma/adapter-mariadb';
-import { PrismaClient } from '../../../generated/prisma/client.js';
+import { getPrisma } from '../../services/prisma.service.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 = getPrisma();
 
-const prisma = new PrismaClient({ adapter: maria });
+export const findAll = async (req, res) => {
+  req.log?.info('findAll {{TABLE_PLURAL}} endpoint');
+  try {
+    const all{{TABLE_SINGULAR}} = await prisma.{{TABLE_PLURAL}}.findMany();
+    console.log('All {{TABLE_PLURAL}}:', JSON.stringify(all{{TABLE_SINGULAR}}, null, 2));
+    res.status(200).json(all{{TABLE_SINGULAR}});
+  } catch (error) {
+    req.log?.error('Error fetching {{TABLE_PLURAL}}:', error);
+    return res.status(500).json({ msg: 'Internal Server Error' });
+  }
+};
 
-export const all = async (req, res) => {
-  req.log?.info('all {{TABLE_PLURAL}} endpoint');
+export const findById = async (req, res) => {
+  req.log?.info('findById {{TABLE_SINGULAR}} endpoint');
   try {
-    const all{{TABLE_SINGULAR}} = await main();
+    const {{TABLE_SINGULAR}} = await prisma.{{TABLE_PLURAL}}.findUnique({
+      where: { id: parseInt(req.params.id) }
+    });
+    res.status(200).json({{TABLE_SINGULAR}});
+  } catch (error) {
+    req.log?.error('Error fetching {{TABLE_SINGULAR}}:', error);
+    return res.status(500).json({ msg: 'Internal Server Error' });
+  }
+};
 
-    res.status(200);
-    res.json(all{{TABLE_SINGULAR}});
+export const search = async (req, res) => {
+  req.log?.info('search {{TABLE_PLURAL}} endpoint');
+  try {
+    const {{TABLE_PLURAL}} = await prisma.{{TABLE_PLURAL}}.findMany({
+      where: {
+        OR: [
+          { field1: { contains: req.query.q } },
+          { field2: { contains: req.query.q } }
+        ]
+      }
+    });
+    res.status(200).json({{TABLE_PLURAL}});
   } catch (error) {
-    req.log?.error('Error fetching {{TABLE_PLURAL}}:', error);
+    req.log?.error('Error searching {{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}};
-}
+export const create = async (req, res) => {
+  req.log?.info('create {{TABLE_SINGULAR}} endpoint');
+  try {
+    const {{TABLE_SINGULAR}} = await prisma.{{TABLE_PLURAL}}.create({
+      data: req.body
+    });
+    res.status(201).json({{TABLE_SINGULAR}});
+  } catch (error) {
+    req.log?.error('Error creating {{TABLE_SINGULAR}}:', error);
+    return res.status(500).json({ msg: 'Internal Server Error' });
+  }
+};
+
+export const update = async (req, res) => {
+  req.log?.info('update {{TABLE_SINGULAR}} endpoint');
+  try {
+    const {{TABLE_SINGULAR}} = await prisma.{{TABLE_PLURAL}}.update({
+      where: { id: parseInt(req.params.id) },
+      data: req.body
+    });
+    res.status(200).json({{TABLE_SINGULAR}});
+  } catch (error) {
+    req.log?.error('Error updating {{TABLE_SINGULAR}}:', error);
+    return res.status(500).json({ msg: 'Internal Server Error' });
+  }
+};
+
+export const remove = async (req, res) => {
+  req.log?.info('remove {{TABLE_SINGULAR}} endpoint');
+  try {
+    const {{TABLE_SINGULAR}} = await prisma.{{TABLE_PLURAL}}.delete({
+      where: { id: parseInt(req.params.id) }
+    });
+    res.status(200).json({{TABLE_SINGULAR}});
+  } catch (error) {
+    req.log?.error('Error deleting {{TABLE_SINGULAR}}:', error);
+    return res.status(500).json({ msg: 'Internal Server Error' });
+  }
+};

package/src/templates/model.template.js

@@ -0,0 +1,56 @@
+import { getPrisma } from '../../services/prisma.service.js';
+
+const prisma = getPrisma();
+
+export const findAll = async () => {
+  const all = await prisma.{{TABLE_PLURAL}}.findMany()
+  console.log('All {{TABLE_PLURAL}}:', JSON.stringify(all, null, 2))
+  return all;
+}
+
+export const findById = async (id) => {
+  const {{TABLE_SINGULAR}} = await prisma.{{TABLE_PLURAL}}.findUnique({
+    where: { id: parseInt(id) }
+  })
+  return {{TABLE_SINGULAR}};
+}
+
+export const search = async (query) => {
+  const {{TABLE_PLURAL}} = await prisma.{{TABLE_PLURAL}}.findMany({
+    where: {
+      OR: [
+        { Texte: { contains: query } },
+        { Auteur: { contains: query } }
+      ]
+    }
+  })
+  return citations;
+}
+
+export const create = async (data) => {
+  const {{TABLE_SINGULAR}} = await prisma.{{TABLE_PLURAL}}.create({
+    data: {
+      Texte: data.Texte,
+      Auteur: data.Auteur
+    }
+  })
+  return {{TABLE_SINGULAR}};
+}
+
+export const update = async (id, data) => {
+  const {{TABLE_SINGULAR}} = await prisma.{{TABLE_PLURAL}}.update({
+    where: { id: parseInt(id) },
+    data: {
+      Texte: data.Texte,
+      Auteur: data.Auteur
+    }
+  })
+  return {{TABLE_SINGULAR}};
+}
+
+export const remove = async (id) => {
+  const {{TABLE_SINGULAR}} = await prisma.{{TABLE_PLURAL}}.delete({
+    where: { id: parseInt(id) }
+  })
+  return {{TABLE_SINGULAR}};
+}

package/src/templates/route.template.js

@@ -1,23 +1,105 @@
 import { Router } from 'express';
-import { all } from '../controllers/citations.controller.js';
+import {
+    all,
+    getById,
+    search,
+    create,
+    update,
+    deleteItem
+} from '../controllers/{{TABLE_SINGULAR}}.controller.js';
 import { authMiddleware } from '../middlewares/auth.middleware.js';
 
 const router = Router();
 
 /**
  * @openapi
- * /{TABLE_SINGULAR}/:
+ * /{{TABLE_PLURAL}}:
  *   get:
- *     summary: get all {TABLE_PLURAL}
+ *     summary: Get all {{TABLE_PLURAL}}
  *     responses:
  *       200:
  *         description: OK
  *         content:
  *           application/json:
  *             schema:
- *               type: object
- *               
+ *               type: array
+ *   post:
+ *     summary: Create a new {{TABLE_SINGULAR}}
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *     responses:
+ *       201:
+ *         description: {{TABLE_SINGULAR}} created
  */
 router.get('/', all);
+router.post('/', create);
+
+/**
+ * @openapi
+ * /{{TABLE_PLURAL}}/search:
+ *   get:
+ *     summary: Search {{TABLE_PLURAL}}
+ *     parameters:
+ *       - name: q
+ *         in: query
+ *         required: true
+ *         schema:
+ *           type: string
+ *     responses:
+ *       200:
+ *         description: OK
+ */
+router.get('/search', search);
+
+/**
+ * @openapi
+ * /{{TABLE_PLURAL}}/{id}:
+ *   get:
+ *     summary: Get {{TABLE_SINGULAR}} by ID
+ *     parameters:
+ *       - name: id
+ *         in: path
+ *         required: true
+ *         schema:
+ *           type: integer
+ *     responses:
+ *       200:
+ *         description: OK
+ *       404:
+ *         description: {{TABLE_SINGULAR}} not found
+ *   put:
+ *     summary: Update a {{TABLE_SINGULAR}}
+ *     parameters:
+ *       - name: id
+ *         in: path
+ *         required: true
+ *         schema:
+ *           type: integer
+ *     responses:
+ *       200:
+ *         description: {{TABLE_SINGULAR}} updated
+ *       404:
+ *         description: {{TABLE_SINGULAR}} not found
+ *   delete:
+ *     summary: Delete a {{TABLE_SINGULAR}}
+ *     parameters:
+ *       - name: id
+ *         in: path
+ *         required: true
+ *         schema:
+ *           type: integer
+ *     responses:
+ *       200:
+ *         description: {{TABLE_SINGULAR}} deleted
+ *       404:
+ *         description: {{TABLE_SINGULAR}} not found
+ */
+router.get('/:id', getById);
+router.put('/:id', update);
+router.delete('/:id', deleteItem);
 
 export default router;