@gnar-engine/cli 1.0.5 → 1.0.7

package/src/dev/dev.service.js

@@ -3,9 +3,12 @@ import Docker from "dockerode";
 import process from "process";
 import fs from "fs/promises";
 import path from "path";
+import { fileURLToPath } from 'url';
 import yaml from "js-yaml";
 import { gnarEngineCliConfig } from "../config.js";
-import { directories } from "../cli.js";
+import { buildImage, createContainer, createBridgeNetwork } from "../services/docker.js";
+import { directories } from "../config.js";
+
 
 const docker = new Docker();
 
@@ -17,16 +20,18 @@ const docker = new Docker();
  * @param {object} options
  * @param {string} options.projectDir - The project directory
  * @param {boolean} [options.build=false] - Whether to re-build images
- * @param {boolean} [options.detached=false] - Whether to run containers in background
+ * @param {boolean} [options.detach=false] - Whether to run containers in background
  * @param {boolean} [options.coreDev=false] - Whether to run in core development mode (requires access to core source)
+ * @param {boolean} [options.bootstrapDev=false] - Whether to set the cli/src/bootstrap directory as the project directory
  * @param {boolean} [options.test=false] - Whether to run tests with ephemeral databases
  * @param {string} [options.testService=''] - The service to run tests for (only applicable if test=true)
  * @param {boolean} [options.removeOrphans=true] - Whether to remove orphaned containers
+ * @param {boolean} [options.attachAll=false] - Attach all services including database and message queues for debugging
  */
-export async function up({ projectDir, build = false, detached = false, coreDev = false, test = false, testService = '', removeOrphans = true }) {
+export async function up({ projectDir, build = false, detach = false, coreDev = false, bootstrapDev = false, test = false, testService = '', removeOrphans = true, attachAll = false}) {
     
-    // core dev
-    if (coreDev) {
+    // bootstrap dev
+    if (bootstrapDev) {
         const fileDir = path.dirname(new URL(import.meta.url).pathname);
         projectDir = path.resolve(fileDir, "../../bootstrap/");
     }
@@ -56,50 +61,51 @@ export async function up({ projectDir, build = false, detached = false, coreDev
 
     // create docker-compose.yml dynamically from parsed config and secrets
     const dockerComposePath = path.join(gnarHiddenDir, "docker-compose.dev.yml");
-    const dockerCompose = await createDynamicDockerCompose({
+    const dockerCompose = await buildAndUpContainers({
         config: parsedConfig.config,
         secrets: parsedSecrets,
         gnarHiddenDir: gnarHiddenDir,
         projectDir: projectDir,
         coreDev: coreDev,
+        bootstrapDev: bootstrapDev,
         test: test,
-        testService: testService
+        testService: testService,
+        attachAll: attachAll
     });
-    await fs.writeFile(dockerComposePath, yaml.dump(dockerCompose));
-
-    // up docker-compose
-    const args = ["-f", dockerComposePath, "up"];
-
-    if (build) {
-        args.push("--build");
-    }
-
-    if (detached) {
-        args.push("-d");
-    }
-
-    if (removeOrphans) {
-        args.push("--remove-orphans")
-    }
 
-    const processRef = spawn(
-        "docker-compose",
-        args,
-        {
-            cwd: projectDir,
-            stdio: "inherit",
-            shell: "/bin/sh"
-        }
-    );
-
-    // handle exit
-    const exitCode = await new Promise((resolve) => {
-        processRef.on("close", resolve);
-    });
-
-    if (exitCode !== 0) {
-        throw new Error(`docker-compose up exited with code ${exitCode}`);
-    }
+    // // up docker-compose
+    // const args = ["-f", dockerComposePath, "up"];
+    //
+    // if (build) {
+    //     args.push("--build");
+    // }
+    //
+    // if (detach) {
+    //     args.push("-d");
+    // }
+    //
+    // if (removeOrphans) {
+    //     args.push("--remove-orphans")
+    // }
+
+    // const processRef = spawn(
+    //     "docker-compose",
+    //     args,
+    //     {
+    //         cwd: projectDir,
+    //         stdio: "inherit",
+    //         shell: "/bin/sh"
+    //     }
+    // );
+    //
+    // // handle exit
+    // const exitCode = await new Promise((resolve) => {
+    //     processRef.on("close", resolve);
+    // });
+    //
+    // if (exitCode !== 0) {
+    //     throw new Error(`docker-compose up exited with code ${exitCode}`);
+    // }
 }
 
 /**
@@ -111,11 +117,11 @@ export async function up({ projectDir, build = false, detached = false, coreDev
  */
 export async function down({ projectDir, allContainers = false }) {
     // list all containers
-    const containers = await docker.listContainers();
+    let containers = await docker.listContainers();
 
     // filter containers by image name
     if (!allContainers) {
-        const containers = containers.filter(c => c.Image.includes("ge-dev"));
+        containers = containers.filter(c => c.Image.includes("ge-localdev"));
     }
 
     if (containers.length === 0) {
@@ -137,6 +143,18 @@ export async function down({ projectDir, allContainers = false }) {
             });
         })
     );
+
+    // remove each container
+    await Promise.all(
+        containers.map(c => {
+            const container = docker.getContainer(c.Id);
+            return container.remove({ force: true }).catch(err => {
+                console.error(`Failed to remove ${c.Names[0]}: ${err.message}`);
+            });
+        })
+    );
+
+    console.log('Containers stopped and removed.');
 }
 
 /**
@@ -214,17 +232,23 @@ export async function createDynamicNginxConf({ config, serviceConfDir, projectDi
  * @param {string} gnarHiddenDir
  * @param {string} projectDir
  * @param {boolean} coreDev - Whether to volume mount the core source code
+ * @param {boolean} bootstrapDev - Whether to set the cli/src/bootstrap directory as the project directory
+ * @param {boolean} build - Whether to re-build images
  * @param {boolean} test - Whether to run tests with ephemeral databases
  * @param {string} testService - The service to run tests for (only applicable if test=true)
  * @param {boolean} attachAll - Whether to attach to all containers' stdio (otherwise databases and message queue are detached)
  */
-async function createDynamicDockerCompose({ config, secrets, gnarHiddenDir, projectDir, coreDev = false, test = false, testService, attachAll = false }) {
+async function buildAndUpContainers({ config, secrets, gnarHiddenDir, projectDir, coreDev = false, bootstrapDev = false, build = false, test = false, testService, attachAll = false }) {
+    
     let mysqlPortsCounter = 3306;
     let mongoPortsCounter = 27017;
     let mysqlHostsRequired = [];
     let mongoHostsRequired = [];
     const services = {};
 
+    console.log('========   g n a r   e n g i n e   ========');
+    console.log('⛏️  Starting development environment...');
+    
     // test mode env var adjustments
     for (const svc of config.services) {
         if (test) {
@@ -242,63 +266,92 @@ async function createDynamicDockerCompose({ config, secrets, gnarHiddenDir, proj
         }
     }
 
+    // create bridge network
+    const networkName = `ge-${config.environment}-${config.namespace}`;
+    createBridgeNetwork({
+        name: networkName
+    })
+
     // provision the provisioner service
-    services['provisioner'] = {
-        container_name: `ge-${config.environment}-${config.namespace}-provisioner`,
-        image: `ge-${config.environment}-${config.namespace}-provisioner`,
-        build: {
+    const provisionerTag = `ge-${config.environment}-${config.namespace}-provisioner`;
+    
+    if (build) {
+        await buildImage({
             context: directories.provisioner,
-            dockerfile: `./Dockerfile`
-        },
-        environment: {
-            PROVISIONER_SECRETS: JSON.stringify(secrets)
-        },
-        volumes: [
-            `${directories.provisioner}/src:/usr/gnar_engine/app/src`
-        ],
-        restart: 'no',
-        attach: attachAll
+            dockerfile: 'Dockerfile',
+            imageTag: provisionerTag
+        });
     }
 
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+
+    const provisionerBinds = [
+        `${path.resolve(__dirname, '../provisioner', 'src')}:/usr/gnar_engine/app/src`
+    ];
+
     if (coreDev) {
-        services['provisioner'].volumes.push(`../../../core/:${gnarEngineCliConfig.corePath}`);
+        provisionerBinds.push(`${gnarEngineCliConfig.coreDevPath}:${gnarEngineCliConfig.corePath}`);
     }
 
-    // nginx
-    services['nginx'] = {
+    const provisioner = await createContainer({
+        name: provisionerTag,
+        image: provisionerTag,
+        env: {
+            PROVISIONER_SECRETS: JSON.stringify(secrets)
+        },
+        ports: {},
+        binds: provisionerBinds,
+        restart: 'no',
+        attach: attachAll,
+        network: networkName
+    });
+    services[provisionerTag] = provisioner;
+
+    // Nginx
+    const nginxName = `ge-${config.environment}-${config.namespace}-nginx`;
+    services[nginxName] = await createContainer({
+        name: nginxName,
         image: 'nginx:latest',
-        container_name: `ge-${config.environment}-${config.namespace}-nginx`,
-        ports: [
-            "80:80",
-            "443:443"
-        ],
-        volumes: [
+        ports: { 80: 80, 443: 443 },
+        binds: [
             `${gnarHiddenDir}/nginx/nginx.conf:/etc/nginx/nginx.conf`,
             `${gnarHiddenDir}/nginx/service_conf:/etc/nginx/service_conf`
         ],
-        restart: 'always',
-        attach: attachAll
-    }
+        attach: attachAll,
+        network: networkName
+    });
 
-    // rabbit
-    services['rabbitmq'] = {
+    // Rabbit MQ 
+    const rabbitMqName = `ge-${config.environment}-${config.namespace}-rabbitmq`;
+    services[rabbitMqName] = await createContainer({
+        name: rabbitMqName,
         image: 'rabbitmq:management',
-        container_name: `ge-${config.environment}-${config.namespace}-rabbitmq`,
-        ports: [
-            "5672:5672",
-            "15672:15672"
-        ],
-        environment: {
+        env: {
             RABBITMQ_DEFAULT_USER: secrets.global.RABBITMQ_USER || '',
             RABBITMQ_DEFAULT_PASS: secrets.global.RABBITMQ_PASS || ''
         },
-        restart: 'always',
-        attach: attachAll
-    }
+        ports: { 5672: 5672, 15672: 15672 },
+        binds: [],
+        attach: attachAll,
+        network: networkName,
+        aliases: ['rabbitmq']
+    });
 
     // services
     for (const svc of config.services) {
 
+        // build service image
+        const svcTag = `ge-${config.environment}-${config.namespace}-${svc.name}`;
+
+        if (build) {
+            await buildImage({
+                context: path.resolve(projectDir, 'services', svc.name),
+                dockerfile: 'Dockerfile',
+                imageTag: svcTag
+            });
+        }
+
         // env variables
         const serviceEnvVars = secrets.services?.[svc.name] || {};
         const localisedServiceEnvVars = {};
@@ -320,29 +373,35 @@ async function createDynamicDockerCompose({ config, secrets, gnarHiddenDir, proj
             }
         }
 
-        // service block
-        services[`${svc.name}-service`] = {
-            container_name: `ge-${config.environment}-${config.namespace}-${svc.name}`,
-            image: `ge-${config.environment}-${config.namespace}-${svc.name}`,
-            build: {
-                context: projectDir,
-                dockerfile: `./services/${svc.name}/Dockerfile`
-            },
-            command: svc.command || [],
-            environment: env,
-            ports: svc.ports || [],
-            depends_on: svc.depends_on || [],
-            volumes: [
-                `${projectDir}/services/${svc.name}/src:/usr/gnar_engine/app/src`
-            ],
-            restart: 'always'
-        };
-
         // add the core source code mount if in coreDev mode
+        const serviceVolumes = [
+            `${path.resolve(projectDir, 'services', svc.name, 'src')}:/usr/gnar_engine/app/src`
+        ];
+
         if (coreDev) {
-            services[`${svc.name}-service`].volumes.push(`../../../core/:${gnarEngineCliConfig.corePath}`);
+            serviceVolumes.push(`${gnarEngineCliConfig.coreDevPath}:${gnarEngineCliConfig.corePath}`);
         }
 
+        // split from "port:port" to { port: port }
+        const ports = {};
+        for (const portMapping of svc.ports || []) {
+            const [hostPort, containerPort] = portMapping.split(':').map(p => parseInt(p, 10));
+            ports[containerPort] = hostPort;
+        }
+
+        services[svcTag] = await createContainer({
+            name: svcTag,
+            image: svcTag,
+            command: svc.command || [],
+            env: env,
+            ports: ports,
+            binds: serviceVolumes,
+            restart: 'always',
+            attach: true,
+            network: networkName,
+            aliases: [`${svc.name}-service`]
+        });
+
         // check if mysql service required
         if (
             serviceEnvVars.MYSQL_HOST &&
@@ -367,29 +426,30 @@ async function createDynamicDockerCompose({ config, secrets, gnarHiddenDir, proj
                 continue;
             }
 
-            services[host] = {
-                container_name: `ge-${config.environment}-${config.namespace}-${host}`,
+            const mysqlContainerName = `ge-${config.environment}-${config.namespace}-${host}`;
+            services[mysqlContainerName] = await createContainer({
+                name: `ge-${config.environment}-${config.namespace}-${host}`,
                 image: 'mysql',
-                ports: [
-                    `${mysqlPortsCounter}:${mysqlPortsCounter}`
-                ],
-                restart: 'always',
-                environment: {
+                env: {
                     MYSQL_HOST: host,
                     MYSQL_ROOT_PASSWORD: secrets.provision.MYSQL_ROOT_PASSWORD
                 },
-                volumes: [
+                ports: {
+                    [mysqlPortsCounter]: mysqlPortsCounter
+                },
+                binds: [
                     `${gnarHiddenDir}/data/${host}-data:/var/lib/mysql`
                 ],
-                attach: attachAll
-            };
+                restart: 'always',
+                attach: attachAll,
+                network: networkName,
+                aliases: [host]
+            });
 
             mysqlPortsCounter++;
         }
-
-        services['provisioner'].depends_on = [...new Set(mysqlHostsRequired)];
     }
-    
+
     // add mongo hosts if required
     if (mongoHostsRequired.length > 0) {
         for (const host of mongoHostsRequired) {
@@ -397,33 +457,37 @@ async function createDynamicDockerCompose({ config, secrets, gnarHiddenDir, proj
                 continue;
             }
 
-            services[host] = {
-                container_name: `ge-${config.environment}-${config.namespace}-${host}`,
+            const mongoContainerName = `ge-${config.environment}-${config.namespace}-${host}`;
+            services[mongoContainerName] = await createContainer({
+                name: `ge-${config.environment}-${config.namespace}-${host}`,
                 image: 'mongo:latest',
-                ports: [
-                    `${mongoPortsCounter}:27017`
-                ],
-                restart: 'always',
-                environment: {
+                env: {
                     MONGO_INITDB_ROOT_USERNAME: 'root',
                     MONGO_INITDB_ROOT_PASSWORD: secrets.provision.MONGO_ROOT_PASSWORD
                 },
-                volumes: [
+                ports: {
+                    [mongoPortsCounter]: 27017
+                },
+                binds: [
                     `${gnarHiddenDir}/data/${host}-data:/data/db`,
-                    './mongo-init-scripts:/docker-entrypoint-initdb.d'
+                    //'./mongo-init-scripts:/docker-entrypoint-initdb.d'
                 ],
-                attach: attachAll
-            };
+                restart: 'always',
+                attach: attachAll,
+                network: networkName,
+                aliases: [host]
+            });
 
             // increment mongo port for next service as required
             mongoPortsCounter++;
         }
     }
 
-    return {
-        version: "3.9",
-        services
-    }
+    // start the containers
+    Object.keys(services).forEach(async (key) => {
+        const container = services[key];
+        container.start();
+    });
 }
 
 /**

package/src/helpers/helpers.js

@@ -1,3 +1,6 @@
+import fs from 'fs/promises';
+import path from 'path';
+import yaml from 'js-yaml';
 
 /**
  * CLI helper functions
@@ -59,5 +62,26 @@ export const helpers = {
             result += chars.charAt(Math.floor(Math.random() * chars.length));
         }
         return result;
+    },
+
+    getDbTypeFromSecrets: async (serviceName, projectDir) => {
+        let dbType;
+        const secretsPath = path.join(projectDir, "secrets.localdev.yml");
+        const parsedSecrets = yaml.load(await fs.readFile(secretsPath, "utf8"));
+        const serviceSecrets = parsedSecrets.services[serviceName.toLowerCase()];
+
+        Object.keys(serviceSecrets).forEach(key => {
+            if (key.toLowerCase().includes('host')) {
+                const host = serviceSecrets[key].toLowerCase();
+
+                if (host.includes('mongo')) {
+                    dbType = 'mongodb';
+                } else if (host.includes('mysql')) {
+                    dbType = 'mysql';
+                }
+            }
+        });
+
+        return dbType;
     }
 }

package/src/profiles/command.js

@@ -166,5 +166,46 @@ export function registerProfileCommand(program) {
             });
         });
 
+    // delete profile
+    profile
+        .command('delete <profileName>')
+        .description('Delete an existing profile')
+        .action(async (profileName) => {
+            const config = profiles.getAllProfiles();
+            const activeProfileName = config.activeProfile;
+
+            if (activeProfileName === profileName) {
+                console.error(`Cannot delete active profile "${profileName}". Please set another profile as active first.`);
+                return;
+            }
+
+            if (!config.profiles[profileName]) {
+                console.error(`Profile "${profileName}" not found.`);
+                return;
+            }
+
+            try {
+                // confirm deletion with user
+                const confirmation = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirmDelete',
+                        message: `Are you sure you want to delete profile "${profileName}"?`,
+                        default: false,
+                    },
+                ]);
+
+                if (!confirmation.confirmDelete) {
+                    console.log('❌ Deletion cancelled.');
+                    return;
+                }
+
+                profiles.deleteProfile({ profileName });
+                console.log(`✅ Profile "${profileName}" deleted successfully.`);
+            } catch (error) {
+                console.error(error.message);
+            }
+        });
+
     program.addCommand(profile);
 }

package/src/profiles/profiles.client.js

@@ -90,6 +90,29 @@ export const profiles = {
         this.saveProfiles(allProfiles);
     },
 
+    deleteProfile: function ({ profileName }) {
+        if (!profileName) {
+            throw new Error('Invalid profile name');
+        }
+
+        const allProfiles = this.getAllProfiles().profiles || {};
+
+        if (!allProfiles[profileName]) {
+            throw new Error(`Profile "${profileName}" not found`);
+        }
+
+        const activeProfileName = this.getActiveProfile()?.name;
+
+        if (activeProfileName === profileName) {
+            throw new Error(`Cannot delete active profile "${profileName}". Please set another profile as active first.`);
+        }
+
+        // Prompt user to confirm deletion in the console
+        delete allProfiles[profileName];
+
+        this.saveProfiles(allProfiles);
+    },
+
     saveProfiles: function (profilesObj) {
         const dir = path.dirname(this.configPath);
         if (!fs.existsSync(dir)) {

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) {
@@ -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);
+            }
+        });
 }