@gnar-engine/cli 1.0.5 → 1.0.6

package/bootstrap/services/notification/src/policies/notification.policy.js

@@ -0,0 +1,49 @@
+import { config } from '../config.js';
+
+export const authorise = {
+
+    /**
+     * Authorise get single notification
+     */
+    getSingle: async (request, reply) => {
+        if (!request.user || request.user.role !== 'service_admin') {
+            reply.code(403).send({error: 'not authorised'});
+        }
+    },
+
+    /**
+     * Authorise get many notifications
+     */
+    getMany: async (request, reply) => {
+        if (!request.user || request.user.role !== 'service_admin') {
+            reply.code(403).send({error: 'not authorised'});
+        }
+    },
+
+    /**
+     * Authorise create notifications
+     */
+    create: async (request, reply) => {
+        if (!request.user || request.user.role !== 'service_admin') {
+            reply.code(403).send({error: 'not authorised'});
+        }
+    },
+
+    /**
+     * Authorise update notification
+     */
+    update: async (request, reply) => {
+        if (!request.user || request.user.role !== 'service_admin') {
+            reply.code(403).send({error: 'not authorised'});
+        }
+    },
+
+    /**
+     * Authorise delete notification
+     */
+    delete: async (request, reply) => {
+        if (!request.user || request.user.role !== 'service_admin') {
+            reply.code(403).send({error: 'not authorised'});
+        }
+    }
+}

package/bootstrap/services/notification/src/schema/notification.schema.js

@@ -0,0 +1,17 @@
+import { schema } from '@gnar-engine/core';
+import { config } from '../config.js';
+
+export const notificationSchema = {
+    schemaName: 'notificationService.notificationSchema',
+    schema: {
+        type: 'object',
+        properties: {
+            // Add your properties here
+            
+        },
+        required: [],
+        additionalProperties: false
+    }
+};
+
+export const validateNotification = schema.compile(notificationSchema);

package/bootstrap/services/notification/src/services/notification.service.js

@@ -0,0 +1,32 @@
+import { db } from '@gnar-engine/core';
+
+export const notification = {
+    async getById({ id }) {
+        const [result] = await db.query('SELECT * FROM notifications WHERE id = ?', [id]);
+        return result || null;
+    },
+
+    async getByEmail({ email }) {
+        // Placeholder: implement if your service uses email
+        return null;
+    },
+
+    async getAll() {
+        return await db.query('SELECT * FROM notifications');
+    },
+
+    async create(data) {
+        const { insertId } = await db.query('INSERT INTO notifications (created_at, updated_at) VALUES (CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)');
+        return await this.getById({ id: insertId });
+    },
+
+    async update({ id, ...data }) {
+        await db.query('UPDATE notifications SET updated_at = CURRENT_TIMESTAMP WHERE id = ?', [id]);
+        return await this.getById({ id });
+    },
+
+    async delete({ id }) {
+        await db.query('DELETE FROM notifications WHERE id = ?', [id]);
+        return true;
+    },
+};

package/bootstrap/services/portal/src/services/client.js

@@ -20,6 +20,9 @@ client.interceptors.request.use(
             config.headers['Authorization'] = `Bearer ${authToken}`;
         }
 
+        // add content-type application/json to config.headers
+        config.headers['Content-Type'] = 'application/json';
+
         return config;
     },
     (error) => {

package/bootstrap/services/user/src/commands/user.handler.js

@@ -121,31 +121,48 @@ commands.register('userService.getManyUsers', async ({}) => {
  * Creat users with random password
  * 
  * @param {Object} params
- * @param {Object} params.user - New user data
+ * @param {Array} params.users - New user data
  */
-commands.register('userService.createUserWithRandomPassword', async ({user}) => {
+commands.register('userService.createUserWithRandomPassword', async ({users}) => {
 
-    // create random password
-    const password = Math.random().toString(36);
-    const userData = {
-        ...user,
-        password: password
-    };
+    const validationErrors = [];
+    let createdNewUsers = [];
 
-    logger.info('creating new user : ' + JSON.stringify(userData));
+    // validate user data
+    for (const newUserData of users) {
 
-    // create user
-    try {
-        const newUsers = await createUsers({users: [userData]})
+        // create random password
+        const password = Math.random().toString(36);
+        newUserData.password = password;
 
-        if (!newUsers || newUsers.length === 0) {
-            throw new error.badRequest('User creation failed');
+        const { errors } = validateUser(newUserData);
+
+        if (errors?.length) {
+            validationErrors.push(errors);
+            continue;
+        }
+
+        if (!newUserData.role || newUserData.role !== 'service_admin') {
+            // ensure emails are unique
+            const existingUser = await user.getByEmail({email: newUserData.email});
+
+            if (existingUser) {
+                validationErrors.push(`User with email ${newUserData.email} already exists`);
+            }
         }
-    
-        return newUsers[0];
-    } catch (error) {
-        throw new error.badRequest('User creation failed: ' + error);
     }
+
+    if (validationErrors.length) {
+        throw new error.badRequest(`Invalid user data: ${validationErrors}`);
+    }
+
+    // add users
+    for (const newUserData of users) {
+        const newUser = await user.create(newUserData);
+        createdNewUsers.push(newUser);
+    }
+
+    return createdNewUsers;
 });
 
 /**

package/bootstrap/services/user/src/tests/commands/user.test.js

@@ -8,15 +8,24 @@ test.prep(async () => {
 })
 
 // Test create user command
-test.run('Create User Command', async () => {
-    const users = await commands.execute('createUsers', [
+test.run('Create user command', async () => {
+    const users = await commands.execute('createUsers', { users: [
         {
-            email: 'test@gnar.co.uk'
+            email: 'test@gnar.co.uk',
+            password: 'p4ssw0rd987'
         }
-    ]);
-
+    ]});
     test.assert(users.length === 1, 'User was not created successfully');
     test.assert(users[0].email === 'test@gnar.co.uk', 'User email does not match');
 });
 
-
+// Test create user with random password command
+test.run('Create user with random password command', async () => {
+    const users = await commands.execute('createUserWithRandomPassword', { users: [
+        {
+            email: 'test2@gnar.co.uk'
+        }
+    ]});
+    test.assert(users.length === 1, 'User was not created successfully');
+    test.assert(users[0].email === 'test3@gnar.co.uk', 'User email does not match');
+});

package/install-from-clone.sh

@@ -13,7 +13,7 @@ cd "$CLI_DIR"
 npm install
 
 # Link CLI to custom global folder
-npm link --prefix "$TARGET_DIR"
+npm link
 
 # Bin path for npm link
 BIN_PATH="$TARGET_DIR/bin"

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gnar-engine/cli",
-    "version": "1.0.5",
+    "version": "1.0.6",
     "description": "Gnar Engine Development Framework CLI: Project bootstrap, scaffolder & control plane.",
     "type": "module",
     "bin": {

package/src/cli.js

@@ -30,9 +30,3 @@ G n a r  E n g i n e -  A powerful, AI ready microservice framework for modern a
 // Parse CLI input
 program.parse(process.argv);
 
-// Consts
-export const directories = {
-    scaffolderTemplates: path.join(import.meta.dirname, '../templates/service'),
-    bootstrap: path.join(import.meta.dirname, '../bootstrap'),
-    provisioner: path.join(import.meta.dirname, './provisioner')
-}

package/src/config.js

@@ -1,3 +1,4 @@
+import path from 'path';
 
 export const gnarEngineCliConfig = {
 
@@ -7,3 +8,10 @@ export const gnarEngineCliConfig = {
     corePath: '/usr/gnar_engine/app/node_modules/@gnar-engine/core'
 
 }
+
+export const directories = {
+    scaffolderServiceTemplates: path.join(import.meta.dirname, '../templates/service'),
+    scaffolderEntityTemplates: path.join(import.meta.dirname, '../templates/entity'),
+    bootstrap: path.join(import.meta.dirname, '../bootstrap'),
+    provisioner: path.join(import.meta.dirname, './provisioner')
+};

package/src/dev/commands.js

@@ -10,10 +10,10 @@ export function registerDevCommands(program) {
 	devCmd
 		.command('up')
 		.description('🛠️  Up Development Containers')
-		.option('-b, --build', 'Ruild without cache')
+		.option('-b, --build', 'Build without cache')
         .option('-d, --detach', 'Run containers in background')
         .option('-t --test', 'Run the tests with ephemeral databases')
-        .option('--test-service <service>', 'Run the tests for the specified service with ephemeral databases')
+        .option('--test-service <service>', 'Run the tests for the specified service with ephemeral databases (e.g. --test-service user)')
         .addOption(new Option('--core-dev').hideHelp())
         .action(async (options) => {
 			let response = {};

package/src/dev/dev.service.js

@@ -5,7 +5,7 @@ import fs from "fs/promises";
 import path from "path";
 import yaml from "js-yaml";
 import { gnarEngineCliConfig } from "../config.js";
-import { directories } from "../cli.js";
+import { directories } from "../config.js";
 
 const docker = new Docker();
 
@@ -17,13 +17,13 @@ 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.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
  */
-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, test = false, testService = '', removeOrphans = true }) {
     
     // core dev
     if (coreDev) {
@@ -74,7 +74,7 @@ export async function up({ projectDir, build = false, detached = false, coreDev
         args.push("--build");
     }
 
-    if (detached) {
+    if (detach) {
         args.push("-d");
     }
 
@@ -111,11 +111,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 +137,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.');
 }
 
 /**
@@ -235,6 +247,7 @@ async function createDynamicDockerCompose({ config, secrets, gnarHiddenDir, proj
             if (secrets.services?.[svc.name]) {
                 secrets.services[svc.name].NODE_ENV = 'test';
 
+                console.log(testService, svc.name);
                 if (testService && svc.name === testService) {
                     secrets.services[svc.name].RUN_TESTS = 'true';
                 }

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