alexis-cli 1.0.0

package/commands/make-entity.js

@@ -0,0 +1,97 @@
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const entityTypes = require('../cli/entity-types');
+
+module.exports = async (name) => {
+    if (!name) {
+        console.error('❌ Usage: alexis make entity <Name>');
+        process.exit(1);
+    }
+
+    const entityName = name.charAt(0).toUpperCase() + name.slice(1);
+    const tableName = name.toLowerCase() + 's';
+
+    const entityDir = path.join(__dirname, '../../src/entities');
+    const entityPath = path.join(entityDir, `${entityName}.entity.js`);
+
+    if (!fs.existsSync(entityDir)) {
+        fs.mkdirSync(entityDir, { recursive: true });
+    }
+
+    if (fs.existsSync(entityPath)) {
+        console.error(`❌ Entity "${entityName}" already exists`);
+        process.exit(1);
+    }
+
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    const ask = (q) =>
+        new Promise((resolve) => rl.question(q, resolve));
+
+    const columns = {
+        id: {
+            type: Number,
+            primary: true,
+            generated: true
+        }
+    };
+
+    console.log(`\n🧱 Creating entity ${entityName}`);
+    console.log(`Available types: ${Object.keys(entityTypes).join(', ')}`);
+
+    while (true) {
+        const field = await ask('\n➤ New field name (leave empty to finish): ');
+        if (!field) break;
+
+        if (columns[field]) {
+            console.log('❌ Field already exists');
+            continue;
+        }
+
+        const type = await ask(
+            `➤ Field type (${Object.keys(entityTypes).join(', ')}): `
+        );
+
+        if (!entityTypes[type]) {
+            console.log('❌ Invalid type');
+            continue;
+        }
+
+        const nullable =
+            (await ask('➤ Is nullable? (y/N): ')).toLowerCase() === 'y';
+
+        const unique =
+            (await ask('➤ Is unique? (y/N): ')).toLowerCase() === 'y';
+
+        columns[field] = {
+            ...entityTypes[type],
+            nullable,
+            unique
+        };
+    }
+
+    rl.close();
+
+    // timestamps auto (Symfony-like)
+    columns.createdAt = { type: 'timestamp', createDate: true };
+    columns.updatedAt = { type: 'timestamp', updateDate: true };
+
+    const entityTemplate = `
+const { EntitySchema } = require('typeorm');
+
+module.exports = new EntitySchema({
+  name: '${entityName}',
+  tableName: '${tableName}',
+  columns: ${JSON.stringify(columns, null, 2)}
+});
+`.trim();
+
+    fs.writeFileSync(entityPath, entityTemplate + '\n');
+
+    console.log(`\n✅ Entity "${entityName}" created`);
+    console.log(`➡️ Next: alexis make migration create-${tableName}`);
+};

package/commands/make-migration.js

@@ -0,0 +1,13 @@
+const { execSync } = require('child_process');
+
+module.exports = (name) => {
+    if (!name) {
+        console.error('❌ Usage: alexis make migration <name>');
+        process.exit(1);
+    }
+
+    execSync(
+        `npx typeorm migration:generate src/migrations/${name} -d src/config/orm.js --outputJs`,
+        { stdio: 'inherit' }
+    );
+};

package/commands/make-module.js

@@ -0,0 +1,174 @@
+const fs = require('fs');
+const path = require('path');
+
+module.exports = (moduleName) => {
+    if (!moduleName) {
+        console.error('❌ Usage: alexis make module <name>');
+        process.exit(1);
+    }
+
+    const entityName =
+        moduleName.charAt(0).toUpperCase() + moduleName.slice(1);
+
+    // 🔎 Vérifier que l'Entity existe
+    const entityPath = path.join(
+        __dirname,
+        '../../src/entities',
+        `${entityName}.entity.js`
+    );
+
+    if (!fs.existsSync(entityPath)) {
+        console.error(
+            `❌ Entity "${entityName}" not found.\n➡️ Create it first with: alexis make entity ${entityName}`
+        );
+        process.exit(1);
+    }
+
+    // 📁 Création du module
+    const basePath = path.join(
+        __dirname,
+        '../../src/modules/v1',
+        moduleName
+    );
+
+    if (fs.existsSync(basePath)) {
+        console.error(`❌ Module "${moduleName}" already exists`);
+        process.exit(1);
+    }
+
+    fs.mkdirSync(basePath, { recursive: true });
+
+    // 📄 Templates des fichiers
+    const files = {
+        [`${moduleName}.controller.js`]: `
+const ${moduleName}Service = require('./${moduleName}.service');
+
+exports.getAll = async (req, res, next) => {
+  try {
+    const data = await ${moduleName}Service.findAll();
+    res.json(data);
+  } catch (err) {
+    next(err);
+  }
+};
+
+exports.create = async (req, res, next) => {
+  try {
+    const entity = await ${moduleName}Service.create(req.body);
+    res.status(201).json(entity);
+  } catch (err) {
+    next(err);
+  }
+};
+`.trim(),
+
+        [`${moduleName}.service.js`]: `
+const AppDataSource = require('../../../config/orm');
+const ${entityName} = require('../../../entities/${entityName}.entity');
+
+exports.findAll = async () => {
+  return AppDataSource.getRepository(${entityName}).find();
+};
+
+exports.create = async (data) => {
+  const repo = AppDataSource.getRepository(${entityName});
+  const entity = repo.create(data);
+  return repo.save(entity);
+};
+`.trim(),
+
+        [`${moduleName}.routes.js`]: `
+/**
+ * @swagger
+ * tags:
+ *   name: ${entityName}
+ *   description: ${entityName} endpoints
+ */
+
+const express = require('express');
+const router = express.Router();
+const controller = require('./${moduleName}.controller');
+
+/**
+ * @swagger
+ * /${moduleName}:
+ *   get:
+ *     summary: Get all ${entityName}
+ *     tags: [${entityName}]
+ *     security:
+ *       - bearerAuth: []
+ *     responses:
+ *       200:
+ *         description: List of ${entityName}
+ */
+router.get('/', controller.getAll);
+
+/**
+ * @swagger
+ * /${moduleName}:
+ *   post:
+ *     summary: Create a ${entityName}
+ *     tags: [${entityName}]
+ *     security:
+ *       - bearerAuth: []
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             example: {}
+ *     responses:
+ *       201:
+ *         description: ${entityName} created
+ */
+router.post('/', controller.create);
+
+module.exports = router;
+`.trim()
+    };
+
+    // ✍️ Écriture des fichiers
+    for (const [file, content] of Object.entries(files)) {
+        fs.writeFileSync(
+            path.join(basePath, file),
+            content + '\n'
+        );
+    }
+
+    console.log(`✅ Module v1 "${moduleName}" created and linked to entity "${entityName}"`);
+
+    // 🔗 Auto-register route
+    const routesIndexPath = path.join(
+        __dirname,
+        '../../src/routes/v1/index.js'
+    );
+
+    if (!fs.existsSync(routesIndexPath)) {
+        console.warn('⚠️ routes/v1/index.js not found, skipping auto-route registration');
+        return;
+    }
+
+    let indexContent = fs.readFileSync(routesIndexPath, 'utf8');
+
+    const importLine = `const ${moduleName}Routes = require('../../../src/modules/v1/${moduleName}/${moduleName}.routes');`;
+    const routeLine = `router.use('/${moduleName}', ${moduleName}Routes);`;
+
+    if (!indexContent.includes(importLine)) {
+        indexContent = indexContent.replace(
+            '// AUTO-IMPORTS (do not remove)',
+            `// AUTO-IMPORTS (do not remove)\n${importLine}`
+        );
+    }
+
+    if (!indexContent.includes(routeLine)) {
+        indexContent = indexContent.replace(
+            '// AUTO-ROUTES (do not remove)',
+            `// AUTO-ROUTES (do not remove)\n${routeLine}`
+        );
+    }
+
+    fs.writeFileSync(routesIndexPath, indexContent);
+
+    console.log(`🔗 Route "/${moduleName}" registered in routes/v1/index.js`);
+};