@gnar-engine/cli 1.0.3 → 1.0.5

package/src/scaffolder/commands.js

@@ -48,9 +48,9 @@ export const registerScaffolderCommands = (program) => {
     create
         .command('service <service>')
         .description('📦 Create a new service: back-end|front-end')
-        .action(async (options) => {
+        .action(async (service) => {
             // validate
-            if (!options.service) {
+            if (!service) {
                 console.error('❌ Please specify a service name using gnar create service <serviceName>');
             }
 
@@ -95,10 +95,17 @@ export const registerScaffolderCommands = (program) => {
                 try {
                     console.log('Creating new service in... ' + activeProfile.profile.PROJECT_DIR);
 
+                    // add trailing slash to project dir if missing
+                    let projectDir = activeProfile.profile.PROJECT_DIR;
+
+                    if (!activeProfile.profile.PROJECT_DIR.endsWith(path.sep)) {
+                         projectDir += path.sep;
+                    }
+
                     scaffolder.createNewService({
-                        serviceName: options.service,
+                        serviceName: service,
                         database: backendAnswers.database,
-                        projectDir: activeProfile.profile.PROJECT_DIR
+                        projectDir: projectDir
                     });
 
                 } catch (error) {
@@ -112,7 +119,7 @@ export const registerScaffolderCommands = (program) => {
                     console.log('Creating new service in... ' + activeProfile.profile.PROJECT_DIR);
 
                     scaffolder.createNewFrontEndService({
-                        serviceName: options.service,
+                        serviceName: service,
                         projectDir: activeProfile.profile.PROJECT_DIR
                     });
                 } catch (error) {

package/src/scaffolder/scaffolder.handler.js

@@ -3,8 +3,11 @@ import fs from 'fs';
 import yaml from 'js-yaml';
 import { profiles } from '../profiles/profiles.client.js';
 import { helpers } from '../helpers/helpers.js';
+import { directories } from '../cli.js';
 import Handlebars from 'handlebars';
 
+
+
 /**
  * Gnar Engine Scaffolder
  */
@@ -32,53 +35,83 @@ export const scaffolder = {
         fs.mkdirSync(serviceDir, { recursive: true });
 
         // Get all files in the templates directory
-        const templatesDir = path.join(import.meta.dirname, '../../templates/service');
         const templateFiles = scaffolder.getAllTemplateFiles({
-            dir: templatesDir,
-            baseDir: templatesDir
+            dir: directories.scaffolderTemplates,
+            baseDir: directories.scaffolderTemplates
         }); 
 
-        console.log('Template files:', templateFiles);
-
         // Register Handlebars helpers
         Object.entries(helpers).forEach(([name, fn]) => {
             Handlebars.registerHelper(name, fn);
         });
 
-            // Write the files to the service directory
-            templateFiles.forEach(file => {
-                let sourcePath;
-                let targetPath;
-                const templateArgs = {
-                    serviceName,
-                    database
-                };
-
-                switch (file.extension) {
-                    case '.hbs':
-                        // Compile the Handlebars template for content
-                        const templateContent = fs.readFileSync(file.fullPath, 'utf8');
-                        const compiledTemplate = Handlebars.compile(templateContent);
-                        const renderedContent = compiledTemplate(templateArgs);
-
-                        // Compile the Handlebars template for the filename (excluding .hbs)
-                        const filenameTemplate = Handlebars.compile(file.relativePath.replace(/\.hbs$/, ''));
-                        const renderedFilename = filenameTemplate(templateArgs);
-                        targetPath = path.join(serviceDir, renderedFilename);
-
-                        // Ensure directory exists
-                        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-                        fs.writeFileSync(targetPath, renderedContent, 'utf8');
-                        break;
-                    default:
-                        // By default, copy the file to the service directory
-                        sourcePath = file.fullPath;
-                        targetPath = path.join(serviceDir, file.relativePath);
-                        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-                        fs.copyFileSync(sourcePath, targetPath);
-                        break;
+        // Write the files to the service directory
+        templateFiles.forEach(file => {
+            let sourcePath;
+            let targetPath;
+            const templateArgs = {
+                serviceName,
+                database
+            };
+
+            let fileRelativePath = file.relativePath;
+
+            // Database specific
+            if (fileRelativePath.includes('mongodb.')) {
+                if (database !== 'mongodb') {
+                    return;
+                } else {
+                    fileRelativePath = fileRelativePath.replace('mongodb.', '');
                 }
-            });
+            }
+
+            if (fileRelativePath.includes('mysql.')) {
+                if (database !== 'mysql') {
+                    return;
+                } else {
+                    fileRelativePath = fileRelativePath.replace('mysql.', '');
+                }
+            }
+
+            switch (file.extension) {
+                case '.hbs':
+                    // Compile the Handlebars template for content
+                    const templateContent = fs.readFileSync(file.fullPath, 'utf8');
+                    const compiledTemplate = Handlebars.compile(templateContent);
+                    const renderedContent = compiledTemplate(templateArgs);
+
+                    // Compile the Handlebars template for the filename (excluding .hbs)
+                    const filenameTemplate = Handlebars.compile(fileRelativePath.replace(/\.hbs$/, ''));
+                    const renderedFilename = filenameTemplate(templateArgs);
+                    targetPath = path.join(serviceDir, renderedFilename);
+
+                    // Ensure directory exists
+                    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+                    fs.writeFileSync(targetPath, renderedContent, 'utf8');
+                    break;
+                default:
+                    // By default, copy the file to the service directory
+                    sourcePath = file.fullPath;
+                    targetPath = path.join(serviceDir, fileRelativePath);
+                    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+                    fs.copyFileSync(sourcePath, targetPath);
+                    break;
+            }
+        });
+
+        // Scaffold deploy.yml
+        scaffolder.scaffoldServiceDeployYml({
+            deployPath: path.join(projectDir, 'deploy.localdev.yml'),
+            serviceName: serviceName,
+            database: database
+        });
+
+        // Scaffold secrets.yml
+        scaffolder.scaffoldServiceSecrets({
+            secretsPath: path.join(projectDir, 'secrets.localdev.yml'),
+            serviceName: serviceName,
+            database: database
+        });
 
         return {
             message: `Service "${serviceName}" created successfully at ${serviceDir}`,
@@ -105,6 +138,25 @@ export const scaffolder = {
 
         // Create the service directory
         fs.mkdirSync(serviceDir, { recursive: true });
+
+        // Add to deploy.yml
+        scaffolder.scaffoldServiceDeployYml({
+            deployPath: path.join(projectDir, 'deploy.localdev.yml'),
+            serviceName: serviceName,
+            database: null
+        });
+        
+        // Scaffold secrets
+        scaffolder.scaffoldServiceSecrets({
+            secretsPath: path.join(projectDir, 'secrets.localdev.yml'),
+            serviceName: serviceName,
+            database: null
+        });
+
+        return {
+            message: `Front-end service "${serviceName}" created successfully at ${serviceDir}`,
+            servicePath: serviceDir
+        };
     },
 
     /**
@@ -198,27 +250,15 @@ export const scaffolder = {
             // create random secrets
             if (file.relativePath === 'secrets.localdev.yml') {
                 console.log('Creating random secrets: secrets.localdev.yml');
-                const secretsPath = path.join(bootstrapDir, 'secrets.localdev.yml');
-                const rawSecrets = fs.readFileSync(secretsPath, 'utf8');
-                const parsedSecrets = yaml.load(rawSecrets);
-
-                // generate random passwords
-                Object.keys(parsedSecrets.services).forEach(serviceName => {
-                    Object.keys(parsedSecrets.services[serviceName]).forEach(key => {
-                        if (key.toLowerCase().includes('pass')) {
-                            parsedSecrets.services[serviceName][key] = helpers.generateRandomString(16);
-                        }
-                    });
-                });
 
-                // set random root api key
-                cliApiKey = helpers.generateRandomString(32);
-                parsedSecrets.services.user.ROOT_ADMIN_API_KEY = cliApiKey;
-                parsedSecrets.services.user.ROOT_ADMIN_EMAIL = rootAdminEmail || 'admin@' + projectName + '.local';
-
-                // save updated secrets file
-                const newSecretsContent = yaml.dump(parsedSecrets);
-                fs.writeFileSync(secretsPath, newSecretsContent, 'utf8');
+                const scaffoldedSecrets = scaffolder.scaffoldProjectSecrets({
+                    secretsPath: sourcePath,
+                    bootstrapDir: path.dirname(sourcePath),
+                    projectName: projectName,
+                    rootAdminEmail: rootAdminEmail
+                });
+                cliApiKey = scaffoldedSecrets.cliApiKey;
+                sourcePath = path.join(path.dirname(sourcePath), 'secrets.localdev.yml.temp');
             }
 
             fs.mkdirSync(path.dirname(targetPath), { recursive: true });
@@ -248,5 +288,163 @@ export const scaffolder = {
 
         console.log('g n a r  e n g i n e - Created new project: ' + projectName);
         console.log('Run `gnar dev up` to start the development server');
+    },
+
+    /**
+     * Scaffold secrets for a new project
+     *
+     * @param {object} param
+     * @param {string} param.bootstrapDir - The bootstrap directory path
+     * @param {string} param.projectName - The project name
+     * @param {string} param.rootAdminEmail - The root admin email
+     * @returns {object} - An object containing the CLI API key
+     */
+    scaffoldProjectSecrets: function ({bootstrapDir, projectName, rootAdminEmail}) {
+        const secretsPath = path.join(bootstrapDir, 'secrets.localdev.yml');
+        const rawSecrets = fs.readFileSync(secretsPath, 'utf8');
+        const parsedSecrets = yaml.load(rawSecrets);
+
+        // generate random passwords
+        try {
+            Object.keys(parsedSecrets.services).forEach(serviceName => {
+                Object.keys(parsedSecrets.services[serviceName]).forEach(key => {
+                    if (key.toLowerCase().includes('pass')) {
+                        parsedSecrets.services[serviceName][key] = helpers.generateRandomString(16);
+                    }
+                });
+            });
+        } catch (error) {
+            throw new Error('Error generating random passwords for project secrets: ' + error.message);
+        }
+
+        // set random root api key
+        const cliApiKey = helpers.generateRandomString(32);
+        parsedSecrets.services.user.ROOT_ADMIN_API_KEY = cliApiKey;
+        parsedSecrets.services.user.ROOT_ADMIN_EMAIL = rootAdminEmail || 'admin@' + projectName + '.local';
+
+        // save updated secrets file to a temp file version (so we don't overwrite the original in templates)
+        const newSecretsContent = yaml.dump(parsedSecrets);
+        fs.writeFileSync(secretsPath + '.temp', newSecretsContent, 'utf8');
+
+        return { cliApiKey };
+    },
+
+    /**
+     * Scaffold secrets for a new service
+     *
+     * @param {object} param
+     * @param {string} param.secretsPath - The path to the secrets file
+     * @param {string} param.serviceName - The service name
+     * @param {string} param.database - The database type
+     */
+    scaffoldServiceSecrets: function ({secretsPath, serviceName, database}) {
+        const rawSecrets = fs.readFileSync(secretsPath, 'utf8');
+        const parsedSecrets = yaml.load(rawSecrets);
+
+        if (!parsedSecrets.services) {
+            parsedSecrets.services = {};
+        }
+
+        parsedSecrets.services[serviceName] = {};
+
+        // generate random passwords
+        switch (database) {
+            case 'mysql':
+                parsedSecrets.services[serviceName]['MYSQL_USER'] = serviceName + '_user';
+                parsedSecrets.services[serviceName]['MYSQL_PASSWORD'] = helpers.generateRandomString(16);
+                parsedSecrets.services[serviceName]['MYSQL_DATABASE'] = serviceName + '_db';
+                parsedSecrets.services[serviceName]['MYSQL_HOST'] = 'db-mysql';
+                break;
+            case 'mongodb':
+                const mongoPassword = helpers.generateRandomString(16);
+                const mongoRootPassword = helpers.generateRandomString(16);
+                const mongoUser = serviceName + '_user';
+                const mongoDatabase = serviceName + '_db';
+                const mongoHost = 'db-mongo';
+                const mongoUrl = `mongodb://${mongoUser}:${mongoPassword}@${mongoHost}:27017/${mongoDatabase}`;
+
+                parsedSecrets.services[serviceName]['MONGO_URL'] = mongoUrl;
+                parsedSecrets.services[serviceName]['MONGO_USER'] = mongoUser;
+                parsedSecrets.services[serviceName]['MONGO_PASSWORD'] = mongoPassword;
+                parsedSecrets.services[serviceName]['MONGO_ROOT_PASSWORD'] = mongoRootPassword;
+                parsedSecrets.services[serviceName]['MONGO_DATABASE'] = mongoDatabase;
+                parsedSecrets.services[serviceName]['MONGO_HOST'] = mongoHost;
+                break;
+            default:
+                // no db
+                break;
+            }
+
+        // save updated secrets file
+        const newSecretsContent = yaml.dump(parsedSecrets);
+        fs.writeFileSync(secretsPath, newSecretsContent, 'utf8');
+    },
+
+    /**
+     * Scaffold deploy.yml for a new service
+     *
+     * @param {object} param
+     * @param {string} param.deployPath - The path to the deploy.yml file
+     * @param {string} param.serviceName - The service name
+     * @param {string} param.database - The database type
+     * @param {number} [param.hostPort=null] - The host port (optional)
+     */
+    scaffoldServiceDeployYml: function ({deployPath, serviceName, database, hostPort = null}) {
+        // parse existing deploy.yml
+        let deploy = yaml.load(fs.readFileSync(deployPath, 'utf8'));
+
+        // don't duplicate if service already exists
+        const existingService = deploy.config.services.find(svc => svc.name === serviceName);
+
+        if (existingService) {
+            return;
+        }
+
+        // get next available host port if not prescribed
+        if (!hostPort) {
+            const hostPorts = [];
+
+            deploy.config.services.forEach(svc => {
+                if (svc.ports && svc.ports.length > 0) {
+                    svc.ports.forEach(portMapping => {
+                        const [hostPort, containerPort] = portMapping.split(':').map(p => parseInt(p, 10));
+                        hostPorts.push(hostPort);
+                    });
+                }
+            });
+
+            hostPorts.sort((a, b) => a - b);
+            hostPort = hostPorts[hostPorts.length - 1] + 1;
+        }
+
+        // prepare new service config
+        const serviceConfig = {
+            name: serviceName,
+            listener_rules: {
+                paths: [
+                    `/${serviceName}`
+                ]
+            },
+            min_tasks: 1,
+            max_tasks: 1,
+            command: ["npm", "run", "start:dev"],
+            ports: [
+                `${hostPort}:3000`
+            ]
+        }
+
+        // add database service if required
+        if (database) {
+            serviceConfig.depends_on = [
+                `db-${database}`
+            ]
+        }
+
+        // add to deploy config
+        deploy.config.services.push(serviceConfig);
+
+        // write deploy.yml file
+        const deployYmlContent = yaml.dump(deploy);
+        fs.writeFileSync(deployPath, deployYmlContent, 'utf8');
     }
 }

package/templates/service/Dockerfile.hbs

@@ -1,9 +1,12 @@
 # Dockerfile for {{pascalCase serviceName}} Service
-FROM gnarengine/service-core:1.0.0
+FROM node:20-alpine 
 
 # Set the working directory
 WORKDIR /usr/gnar_engine/app
 
+# Define a global env var
+ENV GLOBAL_SERVICE_BASE_DIR=/usr/gnar_engine/app/src/
+
 # Copy package.json and package-lock.json
 COPY ./services/{{serviceName}}/package*.json ./
 

package/templates/service/package.json.hbs

@@ -1,18 +1,16 @@
 {
-  "name": "{{lowerCase serviceName}}-service",
-  "version": "1.0.0",
-  "description": "{{pascalCase serviceName}} microservice for Gnar Engine",
-  "main": "src/app.js",
-  "scripts": {
-    "start": "node src/app.js",
-    "dev": "nodemon src/app.js"
-  },
-  "dependencies": {
-    "@gnar-engine/core": "^1.0.1"
-  },
-  "devDependencies": {
-    "nodemon": "^3.0.0"
-  },
-  "author": "Gnar Software",
-  "license": "MIT"
+    "name": "{{lowerCase serviceName}}-service",
+    "version": "1.0.0",
+    "description": "{{pascalCase serviceName}} microservice for Gnar Engine",
+    "type": "module",
+    "scripts": {
+        "start": "node ./src/app.js",
+        "start:dev": "nodemon --watch ./src ./src/app.js",
+        "test": "jest --watchAll --verbose"
+    },
+    "author": "Gnar Software Ltd.",
+    "license": "ISC",
+    "dependencies": {
+        "@gnar-engine/core": "^1.0.1"
+    }
 }

package/templates/service/src/app.js.hbs

@@ -0,0 +1,53 @@
+import { message, http, logger, db, registerService, webSockets, test } from '@gnar-engine/core';
+import { config } from './config.js';
+import { messageHandlers } from './controllers/message.controller.js';
+import { httpController as {{lowerCase serviceName}}PlatformHttpController } from './controllers/http.controller.js';
+
+/**
+ * Initialise service
+ */
+export const initService = async () => {
+
+	// Run migrations
+    if (config.db.type == 'mysql') {
+	    db.migrations.runMigrations({config});
+    }
+
+    // Run seeders
+	db.seeders.runSeeders({config});
+
+	// Import command handlers after the command bus is initialised
+	await import('./commands/{{lowerCase serviceName}}.handler.js');
+	// Add more handlers as needed
+
+	// Initialise and register message handlers
+	await message.init({
+		config: config.message,
+		handlers: messageHandlers
+	});
+
+    // Initialise websocket client & server
+    await webSockets.init(config.webSockets, config.serviceName);
+
+	// Register http routes
+	await http.registerRoutes({
+		controllers: [
+			{{lowerCase serviceName}}PlatformHttpController,
+		]
+	});
+
+	// Start the HTTP server
+	await http.start();
+
+    // Register service with control service
+    await registerService();
+
+	logger.info('G n a r  E n g i n e | {{capitaliseFirstLetter serviceName}} Service initialised successfully.');
+
+    // Tests
+    if (config.environment === 'test' && config.runTests) {
+        test.runCommandTests({config});
+    }
+}
+
+initService();

package/templates/service/{commands → src/commands}/{{serviceName}}.handler.js.hbs

@@ -1,8 +1,7 @@
 import { commands, logger, error } from '@gnar-engine/core';
-import { auth } from '../services/authentication.service.js';
 import { {{serviceName}} } from '../services/{{serviceName}}.service.js';
 import { config } from '../config.js';
-import { validate{{pascalCase serviceName}}, validateServiceAdmin{{pascalCase serviceName}}, validate{{pascalCase serviceName}}Update, validateServiceAdmin{{pascalCase serviceName}}Update } from '../schema/{{serviceName}}.schema.js';
+import { validate{{pascalCase serviceName}} } from '../schema/{{serviceName}}.schema.js';
 
 
 /**
@@ -81,7 +80,7 @@ commands.register('{{serviceName}}Service.update{{pascalCase serviceName}}', asy
     
     return await {{serviceName}}.update({
         id: id,
-        ...new{{pascalCase serviceName}}Data
+        updatedData: new{{pascalCase serviceName}}Data
     });
 });
 

package/templates/service/src/mongodb.config.js.hbs

@@ -0,0 +1,49 @@
+/**
+ * Gnar Engine Service Config
+ */
+export const config = {
+    // service name
+    serviceName: '{{serviceName}}Service',
+
+    // microservice | modular-monolith
+    architecture: process.env.GLOBAL_ARCHITECTURE || 'microservice',
+
+    // web server
+    http: {
+        allowedOrigins: [],
+        allowedMethods: ['GET', 'POST', 'PUT', 'DELETE'],
+        allowedHeaders: ['Content-Type', 'Authorization'],
+        rateLimiting: {
+			max: 5,
+			timeWindow: '1 minute',
+		}
+    },
+
+    // database
+    db: {
+        // type: mongodb | mysql
+        type: 'mongodb',
+
+        // MongoDB
+        host: process.env.{{upperCase serviceName}}_MONGO_HOST,
+        database: process.env.{{upperCase serviceName}}_MONGO_DATABASE,
+        user: process.env.{{upperCase serviceName}}_MONGO_USER,
+        password: process.env.{{upperCase serviceName}}_MONGO_PASSWORD,
+        port: process.env.{{upperCase serviceName}}_MONGO_PORT || 27017,
+        connectionArgs: {},
+    },
+
+    // message broker
+    message: {
+        url: process.env.RABBITMQ_URL,
+        queueName: '{{serviceName}}ServiceQueue',
+        prefetch: 20
+    },
+
+    webSockets: {
+        reconnectInterval: 5000,
+        maxInitialConnectionAttempts: 5
+    },
+
+    hashNameSpace: '{{uuid}}',
+}

package/templates/service/{config.js.hbs → src/mysql.config.js.hbs}

@@ -5,6 +5,10 @@ export const config = {
     // service name
     serviceName: '{{serviceName}}Service',
 
+    // environment
+    environment: process.env.{{upperCase serviceName}}_NODE_ENV || 'dev',
+    runTests: process.env.{{upperCase serviceName}}_RUN_TESTS || false,
+
     // microservice | modular-monolith
     architecture: process.env.GLOBAL_ARCHITECTURE || 'microservice',
 
@@ -40,9 +44,15 @@ export const config = {
 
     // message broker
     message: {
+        url: process.env.RABBITMQ_URL,
         queueName: '{{serviceName}}ServiceQueue',
         prefetch: 20
     },
 
+    webSockets: {
+        reconnectInterval: 5000,
+        maxInitialConnectionAttempts: 5
+    },
+
     hashNameSpace: '{{uuid}}',
 }

package/{bootstrap/services/agent/src/schema/Agent.schema.js → templates/service/src/schema/{{serviceName}}.schema.js.hbs}

@@ -1,8 +1,8 @@
 import { schema } from '@gnar-engine/core';
 import { config } from '../config.js';
 
-export const AgentSchema = {
-    schemaName: 'agentService.AgentSchema',
+export const {{serviceName}}Schema = {
+    schemaName: '{{serviceName}}Service.{{serviceName}}Schema',
     schema: {
         type: 'object',
         properties: {
@@ -14,4 +14,4 @@ export const AgentSchema = {
     }
 };
 
-export const validateAgent = schema.compile(AgentSchema);
+export const validate{{pascalCase serviceName}} = schema.compile({{serviceName}}Schema);