@gnar-engine/cli 1.0.4 → 1.0.6

package/src/provisioner/src/app.js

@@ -0,0 +1,56 @@
+import { mysqlService } from './services/mysql.js';
+import { mongoService } from './services/mongodb.js';
+import { secrets } from './services/secrets.js';
+
+/**
+ * Initialise service
+ */
+export const initService = async () => {
+
+	console.log('G n a r  E n g i n e | Provisioner provisioning databases...');
+
+    let provisionerSecrets;
+
+    // get all secrets
+    try {
+        provisionerSecrets = JSON.parse(process.env.PROVISIONER_SECRETS);
+    } catch (error) {
+        console.error('Error parsing provisioner secrets', error);
+        return;
+    }
+
+    // collate databases to provision from secrets
+    const mysqlDatabases = secrets.collateMysqlDatabases(provisionerSecrets);
+    const mongoDatabases = secrets.collateMongoDatabases(provisionerSecrets);
+
+    // provision mysql databases
+    if (mysqlDatabases) {
+        for (const [key, value] of Object.entries(mysqlDatabases)) {
+            mysqlService.provisionDatabase({
+                host: value.host,
+                database: value.database,
+                user: value.user,
+                password: value.password,
+                rootPassword: provisionerSecrets.provision.MYSQL_ROOT_PASSWORD
+            });
+        }
+    } else {
+        console.log('No MySQL databases to provision.');
+    }
+
+    if (mongoDatabases) {
+        for (const [key, value] of Object.entries(mongoDatabases)) {
+            mongoService.provisionDatabase({
+                host: value.host,
+                database: value.database,
+                user: value.user,
+                password: value.password,
+                rootPassword: provisionerSecrets.provision.MONGO_ROOT_PASSWORD
+            })
+        }
+    } else {
+        console.log('No MongoDB databases to provision.');
+    }
+}
+
+initService();

package/src/provisioner/src/services/mongodb.js

@@ -0,0 +1,58 @@
+import { MongoClient } from 'mongodb';
+
+const retryInterval = 5000;
+const maxRetries = 5;
+
+let db;
+
+export const mongoService = {
+
+    /**
+     * Provision database and users
+     *
+     * @param {Object} params - The parameters object
+     * @param {string} host - The database host
+     * @param {string} database - The database name
+     * @param {string} user - The database user
+     * @param {string} password - The database user password
+     * @param {string} rootPassword - The root user password
+     * @param {number} [port=27017] - The database port
+     */
+    provisionDatabase: async ({host, database, user, password, rootPassword, port = 27017}) => {
+
+        const connectionUrl = `mongodb://root:${rootPassword}@${host}:${port}/admin`;
+        let retries = 0;
+
+        while (retries < maxRetries) {
+            try {
+                const dbClient = await MongoClient.connect(connectionUrl);
+                db = dbClient.db(database);
+
+                const existingUsers = await db.command({ usersInfo: 1 });
+
+                if (!existingUsers.users.some(u => u.user === user)) {
+                    await db.command({
+                        createUser: user,
+                        pwd: password,
+                        roles: [{ role: "readWrite", db: database }]
+                    });
+                }
+
+                console.log(`Successfully provisioned MongoDB database: ${database} and user: ${user}`);
+                await dbClient.close();
+                return;
+
+            } catch (error) {
+                console.error(`Failed provisioning Mongo database "${database}" for user "${user}" ": ${error.message}`);
+                retries++;
+
+                if (retries >= maxRetries) {
+                    console.error(`Max retries reached. Could not provision database "${database}".`);
+                    return;
+                }
+
+                await new Promise(resolve => setTimeout(resolve, retryInterval));
+            }
+        }
+    }
+}

package/src/provisioner/src/services/mysql.js

@@ -0,0 +1,51 @@
+import mysql from 'mysql2/promise';
+
+const retryInterval = 5000;
+const maxRetries = 5;
+
+export const mysqlService = {
+
+    /**
+     * Provision database and users
+     *
+     * @param {Object} params - The parameters object
+     * @param {string} host - The database host
+     * @param {string} database - The database name
+     * @param {string} user - The database user
+     * @param {string} password - The database user password
+     * @param {string} rootPassword - The root user password
+     */
+    provisionDatabase: async ({host, database, user, password, rootPassword}) => {
+        let retries = 0;
+
+        while (retries < maxRetries) {
+            try {
+                const conn = await mysql.createConnection({
+                    host: host || 'db-mysql',
+                    user: 'root',
+                    password: rootPassword
+                });
+
+                await conn.query(`CREATE DATABASE IF NOT EXISTS ${mysql.escapeId(database)};`);
+                await conn.query(`CREATE USER IF NOT EXISTS ${mysql.escape(user)}@'%' IDENTIFIED BY ${mysql.escape(password)};`);
+                await conn.query(`GRANT ALL PRIVILEGES ON ${mysql.escapeId(database)}.* TO ${mysql.escape(user)}@'%';`);
+                await conn.query(`FLUSH PRIVILEGES;`);
+
+                console.log(`Successfully provisioned MySQL database: ${database} and user: ${user}`);
+                await conn.end();
+                return;
+
+            } catch (error) {
+                console.error(`Failed provisioning MySQL database "${database}" for user "${user}" ": ${error.message}`);
+                retries++;
+
+                if (retries >= maxRetries) {
+                    console.error(`Max retries reached. Could not provision database "${database}".`);
+                    return;
+                }
+
+                await new Promise(resolve => setTimeout(resolve, retryInterval));
+            }
+        }
+    }
+}

package/src/provisioner/src/services/secrets.js

@@ -0,0 +1,84 @@
+
+
+export const secrets = {
+
+    /**
+     * Collate MySQL databases from provisioner secrets
+     *
+     * @param {Object} provisionerSecrets - The provisioner secrets object
+     * @returns {Object} - Collated MySQL databases
+     */
+    collateMysqlDatabases: (provisionerSecrets) => {
+
+        const mysqlDatabases = {};
+
+        for (const [serviceKey, service] of Object.entries(provisionerSecrets.services)) {
+            for (const key of Object.keys(service)) {
+                if (key.startsWith('MYSQL_')) {
+                    mysqlDatabases[serviceKey] = true;
+                    break;
+                }
+            }
+        }
+
+        for (const [key, value] of Object.entries(mysqlDatabases)) {
+            try {
+                mysqlDatabases[key] = {};
+                mysqlDatabases[key].host = provisionerSecrets.services[key].MYSQL_HOST;
+                mysqlDatabases[key].database = provisionerSecrets.services[key].MYSQL_DATABASE;
+                mysqlDatabases[key].user = provisionerSecrets.services[key].MYSQL_USER;
+                mysqlDatabases[key].password = provisionerSecrets.services[key].MYSQL_PASSWORD;
+            } catch (error) {
+                console.error(`Missing database credentials for ${key} service. Please include: MYSQL_DATABASE, MYSQL_USER, and MYSQL_PASSWORD.`);
+                return;
+            }
+        }
+
+        if (!provisionerSecrets.provision.MYSQL_ROOT_PASSWORD) {
+            console.error('Missing MYSQL_ROOT_PASSWORD in provisioner secrets. Cannot provision databases.');
+            return;
+        }
+
+        return mysqlDatabases;
+    },
+
+    /**
+     * Collate MongoDB databases from provisioner secrets
+     *
+     * @param {Object} provisionerSecrets - The provisioner secrets object
+     * @returns {Object} - Collated MongoDB databases
+     */
+    collateMongoDatabases: (provisionerSecrets) => {
+
+        const mongoDatabases = {};
+
+        for (const [serviceKey, service] of Object.entries(provisionerSecrets.services)) {
+            for (const key of Object.keys(service)) {
+                if (key.startsWith('MONGO_')) {
+                    mongoDatabases[serviceKey] = true;
+                    break;
+                }
+            }
+        }
+
+        for (const [key, value] of Object.entries(mongoDatabases)) {
+            try {
+                mongoDatabases[key] = {};
+                mongoDatabases[key].host = provisionerSecrets.services[key].MONGO_HOST;
+                mongoDatabases[key].database = provisionerSecrets.services[key].MONGO_DATABASE;
+                mongoDatabases[key].user = provisionerSecrets.services[key].MONGO_USER;
+                mongoDatabases[key].password = provisionerSecrets.services[key].MONGO_PASSWORD;
+            } catch (error) {
+                console.error(`Missing database credentials for ${key} service. Please include: MONGO_DATABASE, MONGO_USER, and MONGO_PASSWORD.`);
+                return;
+            }
+        }
+
+        if (!provisionerSecrets.provision.MONGO_ROOT_PASSWORD) {
+            console.error('Missing MONGO_ROOT_PASSWORD in provisioner secrets. Cannot provision databases.');
+            return;
+        }
+
+        return mongoDatabases;
+    }
+}

package/src/scaffolder/commands.js

@@ -1,6 +1,7 @@
 import inquirer from 'inquirer';
 import { profiles } from '../profiles/profiles.client.js';
 import { scaffolder } from './scaffolder.handler.js';
+import { helpers } from '../helpers/helpers.js';
 import path from 'path';
 
 export const registerScaffolderCommands = (program) => {
@@ -33,11 +34,16 @@ export const registerScaffolderCommands = (program) => {
                 }
             ]);
 
+            // validate absolute path, if it is not absolute, make it absolute
+            if (!path.isAbsolute(answers.projectDir)) {
+                answers.projectDir = path.join(process.cwd(), answers.projectDir);
+            }
+
             // create the project
             try {
                 scaffolder.createNewProject({
                     projectName: projectName,
-                    projectDir: answers.projectDir,
+                    projectDir: path.join('/', answers.projectDir),
                     rootAdminEmail: answers.rootAdminEmail
                 });
             } catch (error) {
@@ -119,7 +125,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) {
@@ -127,4 +133,54 @@ export const registerScaffolderCommands = (program) => {
                 }
             }
         });
+
+    create
+        .command('entity <entity>')
+        .description('📦 Create a new entity in an existing service')
+        .option('--in-service <serviceName>', 'The service in which to add the entity')
+        .action(async (entity, options) => {
+            // validate
+            if (!entity) {
+                console.error('❌ Please specify an entity name using gnar create entity <entityName> --in-service <serviceName>');
+            }
+            if (!options.inService) {
+                console.error('❌ Please specify the service using --in-service <serviceName>');
+            }
+
+            let activeProfile;
+            try {
+                activeProfile = profiles.getActiveProfile();
+            } catch (error) {
+                console.error('❌ No active profile found. Please create or set one using `gnar profile create` or `gnar profile set-active <profileName>`');
+                return;
+            }
+
+            // create the entity
+            try {
+                // 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;
+                }
+
+                const dbType = await helpers.getDbTypeFromSecrets(options.inService, projectDir);
+                const serviceDir = path.join(projectDir, 'services', options.inService.toLowerCase());
+
+                console.log('Creating new entity in... ' + serviceDir);
+
+                scaffolder.createNewEntity({
+                    entityName: entity,
+                    inService: options.inService,
+                    serviceDir: serviceDir,
+                    database: dbType
+                });
+
+                console.log('Created entity ' + entity + ' in service ' + options.inService);
+                console.log('👉 Remember to add the new entities handler and controllers to your service\'s app.js');
+
+            } catch (error) {
+                console.error('❌ Error creating entity:', error.message);
+            }
+        });
 }

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 '../config.js';
 import Handlebars from 'handlebars';
 
+
+
 /**
  * Gnar Engine Scaffolder
  */
@@ -32,69 +35,22 @@ 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.scaffolderServiceTemplates,
+            baseDir: directories.scaffolderServiceTemplates
         }); 
 
-        // 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
-            };
-
-            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.', '');
-                }
-            }
+        // scaffold the hbs templates
+        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(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;
-            }
+        scaffolder.scaffoldHandlebarTemplates({
+            templateFiles: templateFiles,
+            serviceDir: serviceDir,
+            database: database,
+            templateArgs: templateArgs
         });
 
         // Scaffold deploy.yml
@@ -136,6 +92,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
+        };
     },
 
     /**
@@ -152,8 +127,10 @@ export const scaffolder = {
 
         entries.forEach(entry => {
             const fullPath = path.join(dir, entry.name);
+            // if the full path contains src, the 'data' directory can be included
+            const includeDataDir = fullPath.includes(`${path.sep}src${path.sep}`) && fullPath.includes('data') ? true : false;
             if (entry.isDirectory()) {
-                if (entry.name !== 'node_modules' && entry.name !== 'data') {
+                if (entry.name !== 'node_modules' && (entry.name !== 'data' || includeDataDir)) {
                     if (!entry.name.startsWith('.') || entry.name == '.gnarengine') {
                         scaffolder.getAllTemplateFiles({
                             dir: fullPath,
@@ -284,13 +261,17 @@ export const scaffolder = {
         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);
-                }
+        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);
@@ -328,15 +309,14 @@ export const scaffolder = {
                 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'] = serviceName + '-db';
-                parsedSecrets.services[serviceName]['MYSQL_RANDOM_ROOT_PASSWORD'] = helpers.generateRandomString(16);
+                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 = serviceName + '-db';
+                const mongoHost = 'db-mongo';
                 const mongoUrl = `mongodb://${mongoUser}:${mongoPassword}@${mongoHost}:27017/${mongoDatabase}`;
 
                 parsedSecrets.services[serviceName]['MONGO_URL'] = mongoUrl;
@@ -347,8 +327,9 @@ export const scaffolder = {
                 parsedSecrets.services[serviceName]['MONGO_HOST'] = mongoHost;
                 break;
             default:
-                throw new Error(`Unsupported database type in secret scaffolder: ${database}`);
-        }
+                // no db
+                break;
+            }
 
         // save updated secrets file
         const newSecretsContent = yaml.dump(parsedSecrets);
@@ -411,7 +392,7 @@ export const scaffolder = {
         // add database service if required
         if (database) {
             serviceConfig.depends_on = [
-                `${serviceName}-db`
+                `db-${database}`
             ]
         }
 
@@ -421,5 +402,116 @@ export const scaffolder = {
         // write deploy.yml file
         const deployYmlContent = yaml.dump(deploy);
         fs.writeFileSync(deployPath, deployYmlContent, 'utf8');
+    },
+
+    /**
+     * Create new entity in existing service
+     * 
+     * @param {object} param
+     * @param {string} param.entityName - The name of the entity to create
+     * @param {string} param.inService - The service in which to add the entity
+     * @param {string} param.serviceDir - The service directory where the entity will be created
+     * @param {string} param.database - The database type (e.g., 'mysql', 'mongodb')
+     * @returns {object} - An object containing a success message
+     */
+    createNewEntity: ({ entityName, inService, serviceDir, database }) => {
+
+        entityName = entityName.toLowerCase();
+
+        // validate serviceDir exists
+        if (!fs.existsSync(serviceDir)) {
+            throw new Error(`Service directory "${serviceDir}" does not exist`);
+        }
+
+        // Get all files in the templates directory
+        const templateFiles = scaffolder.getAllTemplateFiles({
+            dir: directories.scaffolderEntityTemplates,
+            baseDir: directories.scaffolderEntityTemplates
+        });
+
+        // scaffold the hbs templates
+        const templateArgs = {
+            entityName: entityName,
+            serviceName: inService,
+            database: database
+        };
+
+        scaffolder.scaffoldHandlebarTemplates({
+            templateFiles: templateFiles,
+            serviceDir: serviceDir,
+            database: database,
+            templateArgs: templateArgs
+        });
+    },
+
+    /**
+     * Scaffold handlebar templates
+     *
+     * @param {object} param
+     * @param {string} param.templateFiles - The list of template files
+     * @param {string} param.serviceDir - The service directory
+     * @param {string} param.serviceName - The service name
+     * @param {string} param.database - The database type
+     * @param {object} param.templateArgs - The template arguments
+     */
+    scaffoldHandlebarTemplates: function ({ templateFiles, serviceDir, serviceName, database, templateArgs }) {
+        try {
+            // 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;
+
+                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;
+                }
+            });
+        } catch (error) {
+            throw new Error('Error scaffolding Handlebars templates: ' + error.message);
+        }
     }
 }