alexis-cli 1.0.0

package/commands/make-swagger.js

@@ -0,0 +1,439 @@
+const fs = require('fs');
+const path = require('path');
+
+/* ======================================================
+   Utils
+====================================================== */
+
+const mapSwaggerType = (column) => {
+    const type = column.type;
+
+    if (typeof type === 'string') {
+        switch (type) {
+            case 'varchar':
+            case 'text':
+            case 'uuid':
+                return { type: 'string' };
+
+            case 'int':
+            case 'integer':
+            case 'float':
+            case 'double':
+            case 'decimal':
+                return { type: 'number' };
+
+            case 'boolean':
+            case 'bool':
+                return { type: 'boolean' };
+
+            case 'timestamp':
+            case 'datetime':
+            case 'date':
+                return { type: 'string', format: 'date-time' };
+
+            default:
+                return { type: 'string' };
+        }
+    }
+
+    return { type: 'string' };
+};
+
+const mapExampleValue = (column) => {
+    const type = column.type;
+
+    if (typeof type === 'string') {
+        switch (type) {
+            case 'varchar':
+            case 'text':
+            case 'uuid':
+                return 'string';
+
+            case 'int':
+            case 'integer':
+            case 'float':
+            case 'double':
+            case 'decimal':
+                return 0;
+
+            case 'boolean':
+            case 'bool':
+                return true;
+
+            case 'timestamp':
+            case 'datetime':
+            case 'date':
+                return '2024-01-01T00:00:00Z';
+
+            default:
+                return 'string';
+        }
+    }
+
+    return null;
+};
+
+const buildSchemaFromEntity = (entity) => {
+    const properties = {};
+    const required = [];
+
+    for (const [field, column] of Object.entries(entity.options.columns)) {
+        if (
+            column.primary ||
+            column.generated ||
+            column.createDate ||
+            column.updateDate ||
+            field === 'password'
+        ) continue;
+
+        properties[field] = mapSwaggerType(column);
+
+        if (!column.nullable) {
+            required.push(field);
+        }
+    }
+
+    return {
+        type: 'object',
+        properties,
+        required: required.length ? required : undefined
+    };
+};
+
+const buildExampleFromEntity = (entity) => {
+    const example = {};
+
+    for (const [field, column] of Object.entries(entity.options.columns)) {
+        if (
+            column.primary ||
+            column.generated ||
+            column.createDate ||
+            column.updateDate ||
+            field === 'password'
+        ) continue;
+
+        example[field] = mapExampleValue(column);
+    }
+
+    return example;
+};
+
+/* ======================================================
+   Main
+====================================================== */
+
+module.exports = () => {
+    const projectRoot = path.join(__dirname, '../..');
+    const srcDir = path.join(projectRoot, 'src');
+    const swaggerDir = path.join(srcDir, 'swagger');
+
+    if (!fs.existsSync(swaggerDir)) {
+        fs.mkdirSync(swaggerDir, { recursive: true });
+    }
+
+    const swagger = {
+        openapi: '3.0.0',
+        info: {
+            title: 'Express API',
+            version: '1.0.0',
+            description: 'API générée automatiquement'
+        },
+        servers: [{ url: 'http://localhost:3000/api/v1' }],
+        paths: {},
+        components: {
+            securitySchemes: {
+                bearerAuth: {
+                    type: 'http',
+                    scheme: 'bearer',
+                    bearerFormat: 'JWT'
+                }
+            },
+            schemas: {}
+        }
+    };
+
+    /* ========= ENTITIES → SCHEMAS ========= */
+
+    const entitiesDir = path.join(srcDir, 'entities');
+
+    fs.readdirSync(entitiesDir).forEach((file) => {
+        if (!file.endsWith('.entity.js')) return;
+
+        let entity;
+        try {
+            entity = require(path.join(entitiesDir, file));
+        } catch {
+            console.warn(`⚠️ Cannot load entity ${file}`);
+            return;
+        }
+
+        if (entity.options?.swagger === false) return;
+
+        const entityName = entity.options.name;
+        swagger.components.schemas[entityName] = buildSchemaFromEntity(entity);
+    });
+
+    /* ========= MODULES / ROUTES ========= */
+
+    const generateAuthSwagger = (swagger) => {
+        swagger.paths['/auth/register'] = {
+            post: {
+                tags: ['Auth'],
+                summary: 'Register',
+                description: 'Create a new user account',
+                requestBody: {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object',
+                                required: ['email', 'password'],
+                                properties: {
+                                    email: { type: 'string', example: 'user@example.com' },
+                                    password: { type: 'string', example: 'password123' }
+                                }
+                            }
+                        }
+                    }
+                },
+                responses: {
+                    201: { description: 'User created' },
+                    400: { description: 'User already exists' }
+                }
+            }
+        };
+
+        swagger.paths['/auth/login'] = {
+            post: {
+                tags: ['Auth'],
+                summary: 'Login',
+                description: 'Authenticate user and return JWT token',
+                requestBody: {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object',
+                                required: ['email', 'password'],
+                                properties: {
+                                    email: { type: 'string', example: 'user@example.com' },
+                                    password: { type: 'string', example: 'password123' }
+                                }
+                            }
+                        }
+                    }
+                },
+                responses: {
+                    200: { description: 'JWT token returned' },
+                    401: { description: 'Invalid credentials' }
+                }
+            }
+        };
+
+        swagger.paths['/auth/profile'] = {
+            get: {
+                tags: ['Auth'],
+                summary: 'Profile',
+                description: 'Get current authenticated user',
+                security: [{ bearerAuth: [] }],
+                responses: {
+                    200: { description: 'User profile' },
+                    401: { description: 'Unauthorized' }
+                }
+            }
+        };
+    };
+    generateAuthSwagger(swagger);
+
+    const modulesDir = path.join(srcDir, 'modules/v1');
+
+    fs.readdirSync(modulesDir).forEach((moduleName) => {
+        if (moduleName === 'auth') return;
+        const modulePath = path.join(modulesDir, moduleName);
+        if (!fs.statSync(modulePath).isDirectory()) return;
+
+        /* ----- AUTH ----- */
+        if (moduleName === 'auth') {
+            swagger.paths['/auth/register'] = {
+                post: {
+                    tags: ['Auth'],
+                    summary: 'Register',
+                    description: 'Create a new user account',
+                    requestBody: {
+                        required: true,
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'object',
+                                    properties: {
+                                        email: { type: 'string' },
+                                        password: { type: 'string' }
+                                    }
+                                },
+                                example: {
+                                    email: 'user@example.com',
+                                    password: 'password123'
+                                }
+                            }
+                        }
+                    },
+                    responses: { 201: { description: 'User created' } }
+                }
+            };
+            return;
+        }
+
+        /* ----- CRUD ----- */
+
+        const entityName =
+            moduleName.charAt(0).toUpperCase() + moduleName.slice(1);
+
+        const schemaRef = {
+            $ref: `#/components/schemas/${entityName}`
+        };
+
+        const entityPath = path.join(srcDir, 'entities', `${entityName}.entity.js`);
+        const entity = fs.existsSync(entityPath)
+            ? require(entityPath)
+            : null;
+
+        const exampleBody = entity ? buildExampleFromEntity(entity) : {};
+
+
+        const basePath = `/${moduleName}`;
+
+        swagger.paths[basePath] = {
+            get: {
+                tags: [entityName],
+                summary: `List ${entityName}`,
+                description: `Retrieve all ${entityName}`,
+                security: [{ bearerAuth: [] }],
+                responses: {
+                    200: {
+                        description: 'List retrieved',
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    type: 'array',
+                                    items: schemaRef
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+
+            post: {
+                tags: [entityName],
+                summary: `Create ${entityName}`,
+                description: `Create a new ${entityName}`,
+                security: [{ bearerAuth: [] }],
+                requestBody: {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: schemaRef,
+                            example: exampleBody
+                        }
+                    }
+                },
+                responses: {
+                    201: {
+                        description: `${entityName} created`,
+                        content: {
+                            'application/json': {
+                                schema: schemaRef
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        swagger.paths[`${basePath}/{id}`] = {
+            get: {
+                tags: [entityName],
+                summary: `Get ${entityName}`,
+                description: `Retrieve a ${entityName} by ID`,
+                security: [{ bearerAuth: [] }],
+                parameters: [
+                    {
+                        name: 'id',
+                        in: 'path',
+                        required: true,
+                        schema: { type: 'number' }
+                    }
+                ],
+                responses: {
+                    200: {
+                        description: 'Entity found',
+                        content: {
+                            'application/json': {
+                                schema: schemaRef
+                            }
+                        }
+                    },
+                    404: { description: 'Not found' }
+                }
+            },
+
+            put: {
+                tags: [entityName],
+                summary: `Update ${entityName}`,
+                description: `Update an existing ${entityName}`,
+                security: [{ bearerAuth: [] }],
+                parameters: [
+                    {
+                        name: 'id',
+                        in: 'path',
+                        required: true,
+                        schema: { type: 'number' }
+                    }
+                ],
+                requestBody: {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: schemaRef,
+                            example: exampleBody
+                        }
+                    }
+                },
+                responses: {
+                    200: {
+                        description: `${entityName} updated`,
+                        content: {
+                            'application/json': {
+                                schema: schemaRef
+                            }
+                        }
+                    }
+                }
+            },
+
+            delete: {
+                tags: [entityName],
+                summary: `Delete ${entityName}`,
+                description: `Delete a ${entityName}`,
+                security: [{ bearerAuth: [] }],
+                parameters: [
+                    {
+                        name: 'id',
+                        in: 'path',
+                        required: true,
+                        schema: { type: 'number' }
+                    }
+                ],
+                responses: {
+                    204: { description: `${entityName} deleted` }
+                }
+            }
+        };
+    });
+
+    fs.writeFileSync(
+        path.join(swaggerDir, 'openapi.json'),
+        JSON.stringify(swagger, null, 2)
+    );
+
+    console.log('✅ Swagger generated at src/swagger/openapi.json');
+};

package/commands/migrate.js

@@ -0,0 +1,15 @@
+const { execSync } = require('child_process');
+
+exports.run = () => {
+    execSync(
+        `npx typeorm migration:run -d src/config/orm.js`,
+        { stdio: 'inherit' }
+    );
+};
+
+exports.rollback = () => {
+    execSync(
+        `npx typeorm migration:revert -d src/config/orm.js`,
+        { stdio: 'inherit' }
+    );
+};

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "alexis-cli",
+  "version": "1.0.0",
+  "main": "index.js",
+  "bin": {
+    "alexis-cli": "bin/alexis.js"
+  },
+  "keywords": ["express", "cli", "swagger", "crud", "typeorm"],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Alexis",
+  "license": "MIT",
+  "description": "CLI pour générer des APIs Express (modules, CRUD, auth, swagger)"
+}