@diagramers/cli 1.0.22 → 1.0.24

package/src/commands/init.ts

@@ -1,32 +0,0 @@
-import { Command } from 'commander';
-import { ProjectInitializer } from '../services/project-initializer';
-import chalk from 'chalk';
-
-export function initCommand(program: Command) {
-  program
-    .command('init <template-type> <project-name>')
-    .description('Initialize a new project from the template')
-    .option('-t, --template <template>', 'Template version to use', 'latest')
-    .option('-y, --yes', 'Skip prompts and use defaults')
-    .action(async (templateType: string, projectName: string, options: any) => {
-      try {
-        console.log(chalk.blue(`🚀 Initializing new ${templateType} project: ${projectName}`));
-        
-        // Validate template type
-        if (templateType !== 'api' && templateType !== 'admin') {
-          throw new Error(`Unsupported template type: ${templateType}. Supported types: api, admin`);
-        }
-        
-        const initializer = new ProjectInitializer();
-        await initializer.initialize(projectName, { ...options, template: templateType });
-        
-        console.log(chalk.green(`✅ Project ${projectName} initialized successfully!`));
-        console.log(chalk.yellow(`📁 Navigate to the project: cd ${projectName}`));
-        console.log(chalk.yellow(`🔧 Install dependencies: npm install`));
-        console.log(chalk.yellow(`🚀 Start development: npm run serve`));
-      } catch (error: any) {
-        console.error(chalk.red(`❌ Failed to initialize project: ${error.message}`));
-        process.exit(1);
-      }
-    });
-} 

package/src/commands/update.ts

@@ -1,25 +0,0 @@
-import { Command } from 'commander';
-import { TemplateUpdater } from '../services/template-updater';
-import chalk from 'chalk';
-
-export function updateCommand(program: Command) {
-  program
-    .command('update')
-    .description('Update existing project with latest template features')
-    .option('-f, --force', 'Force update even if conflicts detected')
-    .option('-b, --backup', 'Create backup before updating')
-    .action(async (options: any) => {
-      try {
-        console.log(chalk.blue('🔄 Checking for template updates...'));
-        
-        const updater = new TemplateUpdater();
-        await updater.update(options);
-        
-        console.log(chalk.green('✅ Project updated successfully!'));
-        console.log(chalk.yellow('📝 Review the changes and test your application'));
-      } catch (error: any) {
-        console.error(chalk.red(`❌ Failed to update project: ${error.message}`));
-        process.exit(1);
-      }
-    });
-} 

package/src/config/template-config.ts

@@ -1,111 +0,0 @@
-export interface TemplateConfig {
-  name: string;
-  version: string;
-  description: string;
-  files: {
-    include: string[];
-    exclude: string[];
-    updateable: string[];
-    customizable: string[];
-  };
-  features: {
-    [key: string]: {
-      name: string;
-      description: string;
-      dependencies: string[];
-      files: string[];
-    };
-  };
-}
-
-export const templateConfig: TemplateConfig = {
-  name: 'diagramers-api-template',
-  version: '1.0.0',
-  description: 'Node.js API template with TypeScript, Firebase Functions, and Socket.io',
-  
-  files: {
-    include: [
-      'src/**/*',
-      'package.json',
-      'tsconfig.json',
-      'webpack.config.js',
-      'main.ts',
-      'certs/**/*'
-    ],
-    exclude: [
-      'node_modules/**',
-      'dist/**',
-      'cli/**',
-      '.git/**',
-      'backup-*/**',
-      '*.log',
-      '.env*'
-    ],
-    updateable: [
-      'src/helpers/**/*',
-      'src/config/**/*',
-      'src/server/**/*',
-      'webpack.config.js',
-      'tsconfig.json'
-    ],
-    customizable: [
-      'src/controllers/**/*',
-      'src/entities/**/*',
-      'src/routes/**/*',
-      'src/services/**/*',
-      'src/schemas/**/*',
-      'main.ts'
-    ]
-  },
-  
-  features: {
-    auth: {
-      name: 'Authentication',
-      description: 'JWT-based authentication system',
-      dependencies: ['jsonwebtoken', 'bcryptjs', '@types/jsonwebtoken', '@types/bcryptjs'],
-      files: [
-        'src/features/auth/**/*',
-        'src/helpers/auth.ts'
-      ]
-    },
-    email: {
-      name: 'Email System',
-      description: 'Email notification system with templates',
-      dependencies: ['nodemailer', 'handlebars', '@types/nodemailer'],
-      files: [
-        'src/features/email/**/*',
-        'src/helpers/mailer.ts',
-        'src/assets/css/email-template.css'
-      ]
-    },
-    socket: {
-      name: 'WebSocket',
-      description: 'Real-time communication with Socket.io',
-      dependencies: ['socket.io', '@types/socket.io'],
-      files: [
-        'src/features/socket/**/*',
-        'src/server/socket-server-provider.ts'
-      ]
-    },
-    cron: {
-      name: 'Scheduled Tasks',
-      description: 'Cron job system for scheduled tasks',
-      dependencies: ['node-cron', '@types/node-cron'],
-      files: [
-        'src/features/cron/**/*',
-        'src/helpers/cronHelper.ts'
-      ]
-    },
-    audit: {
-      name: 'Audit Logging',
-      description: 'Comprehensive audit logging system',
-      dependencies: [],
-      files: [
-        'src/features/audit/**/*',
-        'src/entities/audit.ts',
-        'src/schemas/audit.ts',
-        'src/services/audit-service.ts'
-      ]
-    }
-  }
-}; 

package/src/index.ts

@@ -1,41 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import { initCommand } from './commands/init';
-import { updateCommand } from './commands/update';
-import { extendCommand } from './commands/extend';
-import { apiCommand } from './commands/api';
-import chalk from 'chalk';
-
-const program = new Command();
-
-program
-  .name('diagramers')
-  .description('CLI tool for managing diagramers projects')
-  .version('1.0.0');
-
-// Add commands
-initCommand(program);
-updateCommand(program);
-extendCommand(program);
-apiCommand(program);
-
-// Add help text
-program.addHelpText('after', `
-Examples:
-  $ diagramers init api my-new-project
-  $ diagramers init admin my-admin-dashboard
-  $ diagramers update
-  $ diagramers extend --feature auth
-  $ diagramers api generate:module product
-  $ diagramers api generate:table category
-  $ diagramers api generate:relation product category one-to-many
-  $ diagramers api process:template my-api-project
-`);
-
-program.parse();
-
-// If no command is provided, show help
-if (!process.argv.slice(2).length) {
-  program.outputHelp();
-} 

package/src/services/api-generator.ts

@@ -1,378 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-export async function generateModule(moduleName: string): Promise<void> {
-  // Validate module name
-  if (!moduleName || !/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(moduleName)) {
-    throw new Error('Invalid module name. Use only letters, numbers, hyphens, and underscores. Must start with a letter.');
-  }
-
-  const moduleNameCapitalized = moduleName.charAt(0).toUpperCase() + moduleName.slice(1);
-  const currentDir = process.cwd();
-
-  // Check for required API project structure
-  const requiredDirs = [
-    'src/entities',
-    'src/schemas',
-    'src/services',
-    'src/controllers',
-    'src/routes'
-  ];
-  const missingDirs = requiredDirs.filter(dir => !fs.existsSync(path.join(currentDir, dir)));
-  if (missingDirs.length > 0) {
-    throw new Error(`This command should be run from a diagramers API project. Missing directories: ${missingDirs.join(', ')}`);
-  }
-
-  console.log('📝 Creating entity...');
-  const entityContent = generateEntityContent(moduleName, moduleNameCapitalized);
-  fs.writeFileSync(path.join(currentDir, 'src/entities', `${moduleName}.ts`), entityContent);
-
-  console.log('📋 Creating schema...');
-  const schemaContent = generateSchemaContent(moduleName, moduleNameCapitalized);
-  fs.writeFileSync(path.join(currentDir, 'src/schemas', `${moduleName}.ts`), schemaContent);
-
-  console.log('🔧 Creating service...');
-  const serviceContent = generateServiceContent(moduleName, moduleNameCapitalized);
-  fs.writeFileSync(path.join(currentDir, 'src/services', `${moduleName}-service.ts`), serviceContent);
-
-  console.log('🎮 Creating controller...');
-  const controllerContent = generateControllerContent(moduleName, moduleNameCapitalized);
-  fs.writeFileSync(path.join(currentDir, 'src/controllers', `${moduleName}-controller.ts`), controllerContent);
-
-  console.log('🛣️ Creating routes...');
-  const routesContent = generateRoutesContent(moduleName, moduleNameCapitalized);
-  fs.writeFileSync(path.join(currentDir, 'src/routes', `${moduleName}-routes.ts`), routesContent);
-
-  // Update dbcontext to include the new entity
-  updateDbContext(currentDir, moduleName, moduleNameCapitalized);
-
-  // Update routes index to include the new routes
-  updateRoutesIndex(currentDir, moduleName);
-}
-
-function generateEntityContent(moduleName: string, moduleNameCapitalized: string): string {
-  return `import * as mongoose from 'mongoose';
-import { ObjectId } from "bson";
-
-export interface I${moduleNameCapitalized} extends mongoose.Document {
-    _id: ObjectId,
-    name: string,
-    description?: string,
-    status: number,
-    createdAt: Date,
-    updatedAt: Date
-}`;
-}
-
-function generateSchemaContent(moduleName: string, moduleNameCapitalized: string): string {
-  return `import * as mongoose from 'mongoose';
-import { I${moduleNameCapitalized} } from '../entities/${moduleName}';
-
-export const ${moduleName}Schema = new mongoose.Schema(
-    {
-        name: {
-            type: mongoose.SchemaTypes.String,
-            required: true,
-        },
-        description: {
-            type: mongoose.SchemaTypes.String,
-            required: false,
-        },
-        status: {
-            type: mongoose.SchemaTypes.Number,
-            default: 1,
-        }
-    },
-    { timestamps: true, suppressReservedKeysWarning: true },
-);
-
-export const ${moduleNameCapitalized}Entity = mongoose.model<I${moduleNameCapitalized}>('${moduleName}', ${moduleName}Schema);`;
-}
-
-function generateServiceContent(moduleName: string, moduleNameCapitalized: string): string {
-  return `import { ObjectId } from "bson";
-import dbcontext from "../helpers/dbcontext";
-import { ResponseCode } from "../helpers/enums";
-import { Result } from "../helpers/result";
-import { ${moduleNameCapitalized}Entity } from "../schemas/${moduleName}";
-
-export class ${moduleNameCapitalized}Service {
-    result: Result;
-    className = '${moduleNameCapitalized}Service';
-
-    constructor(result: Result) {
-        this.result = result;
-    }
-
-    async getAll(): Promise<Result> {
-        try {
-            const ${moduleName}s = await dbcontext.${moduleNameCapitalized}Entity.find({ status: 1 });
-            this.result.Data = ${moduleName}s;
-            this.result.Status = ResponseCode.Ok;
-            return this.result;
-        } catch (ex) {
-            this.result.addException(this.className, 'GetAll', ex);
-            return this.result;
-        }
-    }
-
-    async getById(id: string): Promise<Result> {
-        try {
-            const ${moduleName} = await dbcontext.${moduleNameCapitalized}Entity.findById(id);
-            if (${moduleName}) {
-                this.result.Data = ${moduleName};
-                this.result.Status = ResponseCode.Ok;
-            } else {
-                this.result.Status = ResponseCode.NotExist;
-            }
-            return this.result;
-        } catch (ex) {
-            this.result.addException(this.className, 'GetById', ex);
-            return this.result;
-        }
-    }
-
-    async create(${moduleName}Data: any): Promise<Result> {
-        try {
-            const ${moduleName}Entity = new ${moduleNameCapitalized}Entity({
-                _id: new ObjectId(),
-                ...${moduleName}Data,
-                status: 1
-            });
-            const created${moduleNameCapitalized} = await dbcontext.${moduleNameCapitalized}Entity.create(${moduleName}Entity);
-            if (created${moduleNameCapitalized}) {
-                this.result.Data = created${moduleNameCapitalized};
-                this.result.Status = ResponseCode.Ok;
-            } else {
-                this.result.Status = ResponseCode.Error;
-                this.result.Errors.push('Failed to create ${moduleName}');
-            }
-            return this.result;
-        } catch (ex) {
-            this.result.addException(this.className, 'Create', ex);
-            return this.result;
-        }
-    }
-
-    async update(id: string, ${moduleName}Data: any): Promise<Result> {
-        try {
-            const updated${moduleNameCapitalized} = await dbcontext.${moduleNameCapitalized}Entity.findByIdAndUpdate(
-                id,
-                { ...${moduleName}Data },
-                { new: true }
-            );
-            if (updated${moduleNameCapitalized}) {
-                this.result.Data = updated${moduleNameCapitalized};
-                this.result.Status = ResponseCode.Ok;
-            } else {
-                this.result.Status = ResponseCode.NotExist;
-            }
-            return this.result;
-        } catch (ex) {
-            this.result.addException(this.className, 'Update', ex);
-            return this.result;
-        }
-    }
-
-    async delete(id: string): Promise<Result> {
-        try {
-            const deleted${moduleNameCapitalized} = await dbcontext.${moduleNameCapitalized}Entity.findByIdAndUpdate(
-                id,
-                { status: 0 },
-                { new: true }
-            );
-            if (deleted${moduleNameCapitalized}) {
-                this.result.Data = deleted${moduleNameCapitalized};
-                this.result.Status = ResponseCode.Ok;
-            } else {
-                this.result.Status = ResponseCode.NotExist;
-            }
-            return this.result;
-        } catch (ex) {
-            this.result.addException(this.className, 'Delete', ex);
-            return this.result;
-        }
-    }
-}`;
-}
-
-function generateControllerContent(moduleName: string, moduleNameCapitalized: string): string {
-  return `import { AuditMessageType, ResponseCode } from "../helpers/enums";
-import handleResponse from "../helpers/handle-response";
-import { Result } from "../helpers/result";
-import { ${moduleNameCapitalized}Service } from "../services/${moduleName}-service";
-
-export default class ${moduleNameCapitalized}Controller {
-
-    async getAll(req, res) {
-        const result = res.locals.result;
-        try {
-            result.addMessage(AuditMessageType.info, req.baseUrl, 'getAll', 'Started');
-            const ${moduleName}Service = new ${moduleNameCapitalized}Service(result);
-            const serviceResult = await ${moduleName}Service.getAll();
-            result.addMessage(AuditMessageType.info, req.baseUrl, 'getAll', 'Finished');
-            return handleResponse(req, res, serviceResult);
-        } catch (ex) {
-            result.addException(req.baseUrl, 'getAll', ex);
-            return handleResponse(req, res, result);
-        }
-    }
-
-    async getById(req, res) {
-        const result = res.locals.result;
-        try {
-            result.addMessage(AuditMessageType.info, req.baseUrl, 'getById', 'Started');
-            const ${moduleName}Service = new ${moduleNameCapitalized}Service(result);
-            const serviceResult = await ${moduleName}Service.getById(req.params.id);
-            result.addMessage(AuditMessageType.info, req.baseUrl, 'getById', 'Finished');
-            return handleResponse(req, res, serviceResult);
-        } catch (ex) {
-            result.addException(req.baseUrl, 'getById', ex);
-            return handleResponse(req, res, result);
-        }
-    }
-
-    async create(req, res) {
-        const result = res.locals.result;
-        try {
-            result.addMessage(AuditMessageType.info, req.baseUrl, 'create', 'Started');
-            const ${moduleName}Service = new ${moduleNameCapitalized}Service(result);
-            const serviceResult = await ${moduleName}Service.create(req.body);
-            result.addMessage(AuditMessageType.info, req.baseUrl, 'create', 'Finished');
-            return handleResponse(req, res, serviceResult);
-        } catch (ex) {
-            result.addException(req.baseUrl, 'create', ex);
-            return handleResponse(req, res, result);
-        }
-    }
-
-    async update(req, res) {
-        const result = res.locals.result;
-        try {
-            result.addMessage(AuditMessageType.info, req.baseUrl, 'update', 'Started');
-            const ${moduleName}Service = new ${moduleNameCapitalized}Service(result);
-            const serviceResult = await ${moduleName}Service.update(req.params.id, req.body);
-            result.addMessage(AuditMessageType.info, req.baseUrl, 'update', 'Finished');
-            return handleResponse(req, res, serviceResult);
-        } catch (ex) {
-            result.addException(req.baseUrl, 'update', ex);
-            return handleResponse(req, res, result);
-        }
-    }
-
-    async delete(req, res) {
-        const result = res.locals.result;
-        try {
-            result.addMessage(AuditMessageType.info, req.baseUrl, 'delete', 'Started');
-            const ${moduleName}Service = new ${moduleNameCapitalized}Service(result);
-            const serviceResult = await ${moduleName}Service.delete(req.params.id);
-            result.addMessage(AuditMessageType.info, req.baseUrl, 'delete', 'Finished');
-            return handleResponse(req, res, serviceResult);
-        } catch (ex) {
-            result.addException(req.baseUrl, 'delete', ex);
-            return handleResponse(req, res, result);
-        }
-    }
-}`;
-}
-
-function generateRoutesContent(moduleName: string, moduleNameCapitalized: string): string {
-  return `import express from 'express';
-import ${moduleNameCapitalized}Controller from '../controllers/${moduleName}-controller';
-
-const router = express.Router();
-const ${moduleName}Controller = new ${moduleNameCapitalized}Controller();
-
-// GET /api/${moduleName}s
-router.get('/', ${moduleName}Controller.getAll.bind(${moduleName}Controller));
-
-// GET /api/${moduleName}s/:id
-router.get('/:id', ${moduleName}Controller.getById.bind(${moduleName}Controller));
-
-// POST /api/${moduleName}s
-router.post('/', ${moduleName}Controller.create.bind(${moduleName}Controller));
-
-// PUT /api/${moduleName}s/:id
-router.put('/:id', ${moduleName}Controller.update.bind(${moduleName}Controller));
-
-// DELETE /api/${moduleName}s/:id
-router.delete('/:id', ${moduleName}Controller.delete.bind(${moduleName}Controller));
-
-export default router;`;
-}
-
-function updateDbContext(currentDir: string, moduleName: string, moduleNameCapitalized: string): void {
-  const dbcontextPath = path.join(currentDir, 'src/helpers/dbcontext.ts');
-  if (!fs.existsSync(dbcontextPath)) {
-    console.log('⚠️ dbcontext.ts not found, skipping dbcontext update');
-    return;
-  }
-
-  let dbcontextContent = fs.readFileSync(dbcontextPath, 'utf8');
-  
-  // Add import
-  const importStatement = `import { ${moduleNameCapitalized}Entity } from '../schemas/${moduleName}';`;
-  if (!dbcontextContent.includes(importStatement)) {
-    // Find the last import statement and add after it
-    const importRegex = /import.*from.*['"];?\s*$/gm;
-    const matches = [...dbcontextContent.matchAll(importRegex)];
-    if (matches.length > 0) {
-      const lastImport = matches[matches.length - 1];
-      const insertIndex = lastImport.index! + lastImport[0].length;
-      dbcontextContent = dbcontextContent.slice(0, insertIndex) + '\n' + importStatement + dbcontextContent.slice(insertIndex);
-    }
-  }
-
-  // Add to dbcontext object
-  const dbcontextObjectRegex = /export\s+default\s*\{([^}]*)\}/s;
-  const match = dbcontextContent.match(dbcontextObjectRegex);
-  if (match) {
-    const objectContent = match[1];
-    if (!objectContent.includes(`${moduleNameCapitalized}Entity`)) {
-      const newObjectContent = objectContent.trim() + `,\n    ${moduleNameCapitalized}Entity`;
-      dbcontextContent = dbcontextContent.replace(dbcontextObjectRegex, `export default {$1${newObjectContent}\n}`);
-    }
-  }
-
-  fs.writeFileSync(dbcontextPath, dbcontextContent);
-  console.log('📊 Updated dbcontext.ts');
-}
-
-function updateRoutesIndex(currentDir: string, moduleName: string): void {
-  const routesIndexPath = path.join(currentDir, 'src/routes/index.ts');
-  if (!fs.existsSync(routesIndexPath)) {
-    console.log('⚠️ routes/index.ts not found, skipping routes index update');
-    return;
-  }
-
-  let routesContent = fs.readFileSync(routesIndexPath, 'utf8');
-  
-  // Add import
-  const importStatement = `import ${moduleName}Routes from './${moduleName}-routes';`;
-  if (!routesContent.includes(importStatement)) {
-    // Find the last import statement and add after it
-    const importRegex = /import.*from.*['"];?\s*$/gm;
-    const matches = [...routesContent.matchAll(importRegex)];
-    if (matches.length > 0) {
-      const lastImport = matches[matches.length - 1];
-      const insertIndex = lastImport.index! + lastImport[0].length;
-      routesContent = routesContent.slice(0, insertIndex) + '\n' + importStatement + routesContent.slice(insertIndex);
-    }
-  }
-
-  // Add route registration
-  const routeRegistration = `app.use('/api/${moduleName}s', ${moduleName}Routes);`;
-  if (!routesContent.includes(routeRegistration)) {
-    // Find where routes are registered (usually after imports)
-    const routeRegex = /app\.use\('\/api\/.*',.*\);?\s*$/gm;
-    const matches = [...routesContent.matchAll(routeRegex)];
-    if (matches.length > 0) {
-      const lastRoute = matches[matches.length - 1];
-      const insertIndex = lastRoute.index! + lastRoute[0].length;
-      routesContent = routesContent.slice(0, insertIndex) + '\n' + routeRegistration + routesContent.slice(insertIndex);
-    }
-  }
-
-  fs.writeFileSync(routesIndexPath, routesContent);
-  console.log('🛣️ Updated routes/index.ts');
-}