@bigtyphoon/melo 1.7.6 → 1.8.1

package/bin/commands/add-server.ts

@@ -0,0 +1,288 @@
+#!/usr/bin/env node
+
+/**
+ * Add a new server type to the project
+ * Creates templates and updates all necessary configuration files
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { Command } from 'commander';
+import { ADD_SERVER_TYPE_INFO, ADD_SERVER_TYPE_EXISTS, DEFAULT_USERNAME, DEFAULT_PWD } from '../utils/constants';
+
+interface ServerOptions {
+    username?: string;
+    password?: string;
+    frontend?: boolean;
+    args?: string[];
+}
+
+export default function (program: Command) {
+    program.command('add-server <server-name>')
+        .description('Add a new server type with templates and configurations')
+        .option('-f, --frontend', 'mark as frontend server', false)
+        .option('-p, --port <port>', 'default port number', '3050')
+        .option('-c, --client-port <port>', 'client port (for frontend)', '3010')
+        .action(function (serverName: string, opts: ServerOptions) {
+            addServerType(serverName, opts);
+        });
+}
+
+function addServerType(serverName: string, opts: ServerOptions) {
+    const cwd = process.cwd();
+    
+    // Check if we're in a valid melo project
+    if (!isMeloProject(cwd)) {
+        console.error('Error: Not a valid melo project directory.');
+        console.info('Please run this command in a melo project root directory.');
+        process.exit(1);
+    }
+
+    // Check if server type already exists
+    if (serverTypeExists(cwd, serverName)) {
+        console.warn(`Server type '${serverName}' already exists.`);
+        console.info(ADD_SERVER_TYPE_EXISTS);
+        
+        // Ask if user wants to overwrite or update
+        const readline = require('readline');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        
+        rl.question(`Do you want to update existing '${serverName}' configuration? (y/N): `, (answer: string) => {
+            if (answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+                updateServerType(cwd, serverName, opts);
+            } else {
+                console.info('Operation cancelled.');
+            }
+            rl.close();
+        });
+        return;
+    }
+
+    // Create new server type
+    createServerType(cwd, serverName, opts);
+    console.info(ADD_SERVER_TYPE_INFO.replace('${serverName}', serverName));
+}
+
+function isMeloProject(cwd: string): boolean {
+    // Check for key files/directories that indicate a melo project
+    const requiredPaths = [
+        'app.ts',
+        'config',
+        'app/servers'
+    ];
+    
+    return requiredPaths.every(p => fs.existsSync(path.join(cwd, p)));
+}
+
+function serverTypeExists(cwd: string, serverName: string): boolean {
+    const serverDir = path.join(cwd, 'app', 'servers', serverName);
+    return fs.existsSync(serverDir);
+}
+
+function createServerType(cwd: string, serverName: string, opts: ServerOptions) {
+    // 1. Create directory structure
+    const serverDir = path.join(cwd, 'app', 'servers', serverName);
+    const handlerDir = path.join(serverDir, 'handler');
+    const remoteDir = path.join(serverDir, 'remote');
+    
+    fs.mkdirSync(handlerDir, { recursive: true });
+    fs.mkdirSync(remoteDir, { recursive: true });
+
+    // 2. Create handler template
+    createHandlerTemplate(handlerDir, serverName);
+
+    // 3. Create remote template
+    createRemoteTemplate(remoteDir, serverName);
+
+    // 4. Update adminServer.json
+    updateAdminServerJson(cwd, serverName);
+
+    // 5. Update servers.json
+    updateServersJson(cwd, serverName, opts);
+
+    // 6. Update app.ts (add configuration block if it doesn't exist)
+    updateAppTs(cwd, serverName, opts);
+}
+
+function updateServerType(cwd: string, serverName: string, opts: ServerOptions) {
+    // Only update configuration files, don't overwrite handler/remote files
+    updateServersJson(cwd, serverName, opts);
+    updateAppTs(cwd, serverName, opts);
+    console.info(`Updated '${serverName}' configuration.`);
+}
+
+function createHandlerTemplate(handlerDir: string, serverName: string) {
+    const content = `import { Application, BackendSession, FrontendSession } from '@bigtyphoon/melo';
+
+export default function (app: Application) {
+    return new Handler(app);
+}
+
+export class Handler {
+    constructor(private app: Application) {
+
+    }
+
+    /**
+     * Example handler method
+     *
+     * @param  {Object}   msg     request message
+     * @param  {Object}   session current session object
+     */
+    async example(msg: any, session: BackendSession | FrontendSession) {
+        return { code: 200, msg: '${serverName} handler is working.' };
+    }
+}
+`;
+    fs.writeFileSync(path.join(handlerDir, `${serverName}Handler.ts`), content);
+}
+
+function createRemoteTemplate(remoteDir: string, serverName: string) {
+    const content = `import { Application, BackendSession, RemoterClass } from '@bigtyphoon/melo';
+
+export default function (app: Application) {
+    return new Remoter(app);
+}
+
+export class Remoter implements RemoterClass {
+    constructor(private app: Application) {
+
+    }
+
+    /**
+     * Example remote method
+     *
+     * @param  {Object}   msg     request message
+     * @param  {Object}   session current session object
+     */
+    async example(msg: any, session: BackendSession): Promise<any> {
+        return { code: 200, msg: '${serverName} remote is working.' };
+    }
+}
+`;
+    fs.writeFileSync(path.join(remoteDir, `${serverName}Remote.ts`), content);
+}
+
+function updateAdminServerJson(cwd: string, serverName: string) {
+    const adminServerPath = path.join(cwd, 'config', 'adminServer.json');
+    
+    let adminServers: any[] = [];
+    if (fs.existsSync(adminServerPath)) {
+        try {
+            adminServers = JSON.parse(fs.readFileSync(adminServerPath, 'utf8'));
+        } catch (e) {
+            adminServers = [];
+        }
+    }
+
+    // Check if server type already exists
+    const exists = adminServers.some(s => s.type === serverName);
+    if (!exists) {
+        adminServers.push({
+            type: serverName,
+            token: generateToken()
+        });
+        fs.writeFileSync(adminServerPath, JSON.stringify(adminServers, null, 2));
+    }
+}
+
+function updateServersJson(cwd: string, serverName: string, opts: ServerOptions) {
+    const serversPath = path.join(cwd, 'config', 'servers.json');
+    
+    let servers: any = {};
+    if (fs.existsSync(serversPath)) {
+        try {
+            servers = JSON.parse(fs.readFileSync(serversPath, 'utf8'));
+        } catch (e) {
+            servers = {};
+        }
+    }
+
+    // Ensure development and production exist
+    if (!servers.development) servers.development = {};
+    if (!servers.production) servers.production = {};
+
+    const port = parseInt(opts.args?.find(a => a.startsWith('--port'))?.split('=')[1] || '3050');
+    const clientPort = parseInt(opts.args?.find(a => a.startsWith('--client-port'))?.split('=')[1] || '3010');
+
+    const serverConfig = {
+        id: `${serverName}-server-1`,
+        host: '127.0.0.1',
+        port: port,
+        frontend: opts.frontend || false,
+        args: ' --inspect=10003'
+    };
+
+    if (opts.frontend) {
+        (serverConfig as any).clientHost = '127.0.0.1';
+        (serverConfig as any).clientPort = clientPort;
+    }
+
+    // Add to both environments
+    servers.development[serverName] = [serverConfig];
+    
+    // Production uses slightly different inspect port
+    const prodConfig = { ...serverConfig };
+    prodConfig.args = ' --inspect=10004';
+    servers.production[serverName] = [prodConfig];
+
+    fs.writeFileSync(serversPath, JSON.stringify(servers, null, 2));
+}
+
+function updateAppTs(cwd: string, serverName: string, opts: ServerOptions) {
+    const appTsPath = path.join(cwd, 'app.ts');
+    
+    if (!fs.existsSync(appTsPath)) {
+        console.warn('Warning: app.ts not found, skipping app.ts update.');
+        return;
+    }
+
+    let content = fs.readFileSync(appTsPath, 'utf8');
+
+    // Check if configuration block already exists
+    const configPattern = new RegExp(`app\\.configure\\(['"].*['"],\\s*['"]${serverName}['"]`);
+    if (configPattern.test(content)) {
+        console.info(`Configuration for '${serverName}' already exists in app.ts`);
+        return;
+    }
+
+    // Find the last app.configure block and add after it
+    const configurePattern = /app\.configure\(['"].*['"],\s*['"].*['"],\s*function\s*\(\)\s*\{[\s\S]*?\}\);/g;
+    const matches = content.match(configurePattern);
+    
+    let insertPosition = content.length;
+    if (matches && matches.length > 0) {
+        const lastMatch = matches[matches.length - 1];
+        insertPosition = content.lastIndexOf(lastMatch) + lastMatch.length;
+    } else {
+        // Find position before // start app comment
+        const startAppMatch = content.match(/\/\/\s*start app/);
+        if (startAppMatch) {
+            insertPosition = content.indexOf(startAppMatch[0]);
+        }
+    }
+
+    const newConfig = `
+
+// ${serverName} server configuration
+app.configure('production|development', '${serverName}', function () {
+    // Add ${serverName} specific configuration here
+    // Example: app.set('${serverName}Config', { /* config */ });
+});
+`;
+
+    content = content.slice(0, insertPosition) + newConfig + content.slice(insertPosition);
+    fs.writeFileSync(appTsPath, content);
+}
+
+function generateToken(): string {
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    let token = '';
+    for (let i = 0; i < 40; i++) {
+        token += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return token;
+}