@gnar-engine/cli 1.0.4 → 1.0.6

package/bootstrap/deploy.localdev.yml

@@ -13,7 +13,7 @@ config:
       min_tasks: 1
       max_tasks: 1
       depends_on:
-        - control-db
+        - db-mysql
       command:
         - npm
         - run
@@ -28,11 +28,52 @@ config:
       min_tasks: 1
       max_tasks: 1
       depends_on:
-        - user-db
+        - db-mysql
       command:
         - npm
         - run
         - start:dev
       ports:
         - '4002:3000'
-
+    - name: portal
+      listener_rules:
+        paths:
+          - /portal
+      min_tasks: 1
+      max_tasks: 1
+      command:
+        - npm
+        - run
+        - dev
+        - '-- --host'
+      ports:
+        - '4003:5173'
+    - name: page
+      listener_rules:
+        paths:
+          - /pages
+          - /blocks
+      min_tasks: 1
+      max_tasks: 1
+      command:
+        - npm
+        - run
+        - start:dev
+      ports:
+        - '4004:3000'
+      depends_on:
+        - db-mongo
+    - name: notification
+      listener_rules:
+        paths:
+          - /notification
+      min_tasks: 1
+      max_tasks: 1
+      command:
+        - npm
+        - run
+        - start:dev
+      ports:
+        - '4005:3000'
+      depends_on:
+        - db-mysql

package/bootstrap/secrets.localdev.yml

@@ -1,22 +1,37 @@
+provision:
+  MYSQL_ROOT_PASSWORD: GExtMVydbpIihS5f
+  MONGO_ROOT_PASSWORD: E7lVrilnp07gIxcX
 global:
   RABBITMQ_URL: amqp://gnar_engine_rabbit_user:gn4rlyRaB81Tw4sh@rabbitmq:5672
   RABBITMQ_USER: gnar_engine_rabbit_user
   RABBITMQ_PASS: gn4rlyRaB81Tw4sh
+  UPLOADS_URL: https://gnar-engine-test.s3.eu-west-2.amazonaws.com
+  S3_BUCKET: gnar-engine-test
+  AWS_REGION: eu-west-2
+  AWS_ACCESS_KEY_ID: null
+  AWS_SECRET_ACCESS_KEY: null
 services:
   control:
-    MYSQL_HOST: control-db
+    MYSQL_HOST: db-mysql
     MYSQL_DATABASE: ge_control_db
     MYSQL_USER: ge_control_db_user
     MYSQL_PASSWORD: bL6I1ABJFDPO3JAR
-    MYSQL_RANDOM_ROOT_PASSWORD: GExtMVydbpIihS5f
   user:
-    MYSQL_HOST: user-db
+    MYSQL_HOST: db-mysql
     MYSQL_DATABASE: ge_user_db
     MYSQL_USER: ge_user_db_user
     MYSQL_PASSWORD: 7cm0crGDTaJy9Sa2
-    MYSQL_RANDOM_ROOT_PASSWORD: APJW3b7teaRHTvcv
     ROOT_ADMIN_EMAIL: adam@gnar.co.uk
     ROOT_ADMIN_USERNAME: engineadmin
     ROOT_ADMIN_PASSWORD: MOF4TWiFh4TXOHcL
     ROOT_ADMIN_API_KEY: JPpmhQN0bs8f5x2jN5ypCU6Ww6VETrW2
-
+  page:
+    MONGO_HOST: db-mongo
+    MONGO_DATABASE: page_db
+    MONGO_USER: page_user
+    MONGO_PASSWORD: Q2atGxh21VqNIrZO
+  notification:
+    MYSQL_USER: notification_user
+    MYSQL_PASSWORD: hmubUB5FBVf4V7dF
+    MYSQL_DATABASE: notification_db
+    MYSQL_HOST: db-mysql

package/bootstrap/services/control/src/config.js

@@ -6,6 +6,10 @@ export const config = {
     // service name
     serviceName: 'controlService',
 
+    // environment
+    environment: process.env.CONTROL_NODE_ENV || 'dev',
+    runTests: process.env.CONTROL_RUN_TESTS || false,
+
     // microservice | modular-monolith
     architecture: process.env.GLOBAL_ARCHITECTURE || 'microservice',
 

package/bootstrap/services/notification/Dockerfile

@@ -1,5 +1,5 @@
 # Dockerfile for Notification Service
-FROM node:20-alpine
+FROM node:20-alpine 
 
 # Set the working directory
 WORKDIR /usr/gnar_engine/app
@@ -17,7 +17,7 @@ RUN npm install -g nodemon
 RUN npm install
 
 # Expose the port the service will run on
-EXPOSE 4000
+EXPOSE 3000
 
 # Start the application
 CMD ["nodemon", "--watch", "./gnar_engine", "./gnar_engine/app.js"]

package/bootstrap/services/notification/package.json

@@ -1,34 +1,16 @@
 {
-  "name": "gnar_engine_notification",
-  "version": "1.0.0",
-  "description": "Gnar Engine - Notification Service",
-  "type": "module",
-  "scripts": {
-    "start": "node ./src/app.js",
-    "start:dev": "nodemon --watch ./src ./src/app.js",
-    "test": "NODE_OPTIONS='--experimental-vm-modules' jest --watchAll --verbose"
-  },
-  "author": "Gnar Software Ltd.",
-  "license": "ISC",
-  "dependencies": {
-    "@aws-sdk/client-ses": "^3.806.0",
-    "ajv": "^8.17.1",
-    "ajv-formats": "^3.0.1",
-    "dotenv": "^16.4.7",
-    "nodemailer": "^7.0.3",
-    "path": "^0.12.7",
-    "pino": "^9.6.0",
-    "pino-pretty": "^13.0.0",
-    "uuid": "^11.1.0",
-    "handlebars": "^4.7.8"
-  },
-  "devDependencies": {
-    "@babel/preset-env": "^7.22.20",
-    "jest": "^29.7.0",
-    "nodemon": "^3.1.9",
-    "supertest": "^6.3.3"
-  },
-  "workspaces": [
-    "./Lib/*"
-  ]
+    "name": "notification-service",
+    "version": "1.0.0",
+    "description": "Notification 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/bootstrap/services/notification/src/app.js

@@ -1,51 +1,53 @@
-import dotenv from 'dotenv';
-import { logger } from './services/logger.service.js';
-import { commandBus } from './commands/command-bus.js';
-import { messageController } from './controllers/message.controller.js';
-import { messageAwaitResponse } from '@gnar-engine/message-client';
-import { internalHealthCheck } from './commands/handlers/control.handler.js';
-import { sendNotification } from './commands/handlers/notification.handler.js';
-
-dotenv.config({ path: '.env' });
-
-process.on('unhandledRejection', (reason, promise) => {
-	console.error('🚨 Unhandled Rejection at:', promise, '\nReason:', reason);
-	process.exit(1);
-});
-  
-process.on('uncaughtException', (err) => {
-	console.error('🚨 Uncaught Exception:', err);
-	process.exit(1);
-});
+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 notificationPlatformHttpController } from './controllers/http.controller.js';
 
 /**
- * @function startServer
- * @description Initializes and starts the Fastify server.
+ * Initialise service
  */
-const startService = async () => {
-
-	// Register commands
-	commandBus.register('internalHealthCheck', internalHealthCheck);
-	commandBus.register('sendNotification', sendNotification);
-
-	// Init controllers and error handlers
-	messageController.init();
-
-	// Register with control service
-	try {
-		await messageAwaitResponse('controlService', {
-			method: 'registerService',
-			data: {
-				service: {
-					name: 'notificationService'
-				}
-			}
-		});
-	} catch (error) {
-		logger.info('No response from the control service when registering as a service');
-	}
-
-};
-
-// Entry point
-startService();
+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/notification.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: [
+			notificationPlatformHttpController,
+		]
+	});
+
+	// 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 | Notification Service initialised successfully.');
+
+    // Tests
+    if (config.environment === 'test' && config.runTests) {
+        test.runCommandTests({config});
+    }
+}
+
+initService();

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

@@ -0,0 +1,96 @@
+import { commands, logger, error } from '@gnar-engine/core';
+import { notification } from '../services/notification.service.js';
+import { config } from '../config.js';
+import { validateNotification } from '../schema/notification.schema.js';
+
+
+/**
+ * Get single notification
+ */
+commands.register('notificationService.getSingleNotification', async ({id}) => {
+    if (id) {
+        return await notification.getById({id: id});
+    } else {
+        throw new error.badRequest('Notification email or id required');
+    }
+});
+
+/**
+ * Get many notifications
+ */
+commands.register('notificationService.getManyNotifications', async ({}) => {
+    return await notification.getAll();
+});
+
+/**
+ * Create notifications
+ */
+commands.register('notificationService.createNotifications', async ({ notifications }) => {
+    const validationErrors = [];
+    let createdNewNotifications = [];
+
+    for (const newData of notifications) {
+        const { errors } = validateNotification(newData);
+        if (errors?.length) {
+            validationErrors.push(errors);
+            continue;
+        }
+
+        const created = await notification.create(newData);
+        createdNewNotifications.push(created);
+    }
+
+    if (validationErrors.length) {
+        throw new error.badRequest(`Invalid notification data: ${validationErrors}`);
+    }
+
+    return createdNewNotifications;
+});
+
+/**
+ * Update notification
+ */
+commands.register('notificationService.updateNotification', async ({id, newNotificationData}) => {
+    
+    const validationErrors = [];
+    
+    if (!id) {
+        throw new error.badRequest('Notification ID required');
+    
+    }
+    
+    const obj = await notification.getById({id: id});
+    
+    if (!obj) {
+        throw new error.notFound('Notification not found');
+    
+    }
+    
+    delete newNotificationData.id;
+    
+    const { errors } = validateNotificationUpdate(newNotificationData);
+    
+    if (errors?.length) {
+        validationErrors.push(errors);
+    }
+    
+    if (validationErrors.length) {
+        throw new error.badRequest(`Invalid notification data: ${validationErrors}`);
+    }
+    
+    return await notification.update({
+        id: id,
+        updatedData: newNotificationData
+    });
+});
+
+/**
+ * Delete notification
+ */
+commands.register('notificationService.deleteNotification', async ({id}) => {
+    const obj = await notification.getById({id: id});
+    if (!obj) {
+        throw new error.notFound('Notification not found');
+    }
+    return await notification.delete({id: id});
+});

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

@@ -1,15 +1,58 @@
-
 /**
- * Email sending service
- * 
- * - Values:
- *   - SES (not implemented yet)
- *   - SMTP
- *   - Direct (not implemented yet)
+ * Gnar Engine Service Config
  */
-export const emailSendingService = 'SES';
+export const config = {
+    // service name
+    serviceName: 'notificationService',
 
-/**
- * Email header logo url
- */
-export const emailHeaderLogoUrl = 'https://admin.gnarengine.com/public/gnarengine-logo-black.png';
+    // environment
+    environment: process.env.NOTIFICATION_NODE_ENV || 'dev',
+    runTests: process.env.NOTIFICATION_RUN_TESTS || false,
+
+    // 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: 'mysql',
+
+        // MongoDB
+        connectionUrl: process.env.NOTIFICATION_MONGO_URL,
+        connectionArgs: {},
+
+        // MySQL
+        host: process.env.NOTIFICATION_MYSQL_HOST,
+        user: process.env.NOTIFICATION_MYSQL_USER,
+        password: process.env.NOTIFICATION_MYSQL_PASSWORD,
+        database: process.env.NOTIFICATION_MYSQL_DATABASE,
+        connectionLimit: 10,
+        queueLimit: 20,
+        maxRetries: 5
+    },
+
+    // message broker
+    message: {
+        url: process.env.RABBITMQ_URL,
+        queueName: 'notificationServiceQueue',
+        prefetch: 20
+    },
+
+    webSockets: {
+        reconnectInterval: 5000,
+        maxInitialConnectionAttempts: 5
+    },
+
+    hashNameSpace: '',
+}

package/bootstrap/services/notification/src/controllers/http.controller.js

@@ -0,0 +1,87 @@
+import { commands } from '@gnar-engine/core';
+import { authorise } from '../policies/notification.policy.js';
+
+/**
+ * HTTP controller
+ */
+export const httpController = {
+
+	/**
+	 * Get single notification
+	 */
+	getSingle: {
+		method: 'GET',
+		url: '/notifications/:id',
+		preHandler: async (request, reply) => authorise.getSingle(request, reply),
+		handler: async (request, reply) => {
+			const params = {
+				id: request.params.id
+			};
+			const result = await commands.execute('getSingleNotification', params);
+			reply.code(200).send({ notification: result });
+		}
+	},
+
+	/**
+	 * Get multiple notifications
+	 */
+	getMany: {
+		method: 'GET',
+		url: '/notifications/',
+		preHandler: async (request, reply) => authorise.getMany(request, reply),
+		handler: async (request, reply) => {
+			const params = {};
+			const results = await commands.execute('getManyNotifications', params);
+			reply.code(200).send({ notifications: results });
+		}
+	},
+
+	/**
+	 * Create new notification
+	 */
+	create: {
+		method: 'POST',
+		url: '/notifications/',
+		preHandler: async (request, reply) => authorise.create(request, reply),
+		handler: async (request, reply) => {
+			const params = {
+				notifications: [request.body.notification]
+			};
+			const results = await commands.execute('createNotifications', params);
+			reply.code(200).send({ notifications: results });
+		},
+	},
+
+	/**
+	 * Update notification
+	 */
+	update: {
+		method: 'POST',
+		url: '/notifications/:id',
+		preHandler: async (request, reply) => authorise.update(request, reply),
+		handler: async (request, reply) => {
+			const params = {
+				id: request.params.id,
+				newNotificationData: request.body
+			};
+			const result = await commands.execute('updateNotification', params);
+			reply.code(200).send({ notification: result });
+		},
+	},
+
+	/**
+	 * Delete notification
+	 */
+	delete: {
+		method: 'DELETE',
+		url: '/notifications/:id',
+		preHandler: async (request, reply) => authorise.delete(request, reply),
+		handler: async (request, reply) => {
+			const params = {
+				id: request.params.id
+			};
+			await commands.execute('deleteNotification', params);
+			reply.code(200).send({ message: 'Notification deleted' });
+		},
+	},
+}

package/bootstrap/services/notification/src/controllers/message.controller.js

@@ -1,82 +1,51 @@
-import { commandBus } from '../commands/command-bus.js';
-import { logger } from '../services/logger.service.js';
-import { initializeRabbitMQ } from '@gnar-engine/message-client';
+import { commands } from '@gnar-engine/core';
 
-// Configuration
-const queueName = 'notificationServiceQueue';
-const prefetch = 3;
+export const messageHandlers = {
 
-export const messageController = {
-    handleMessage: async function (msg, channel) {
-        if (!msg) return;
-
-        const payload = JSON.parse(msg.content.toString());
-
-        if (!payload.method) {
-            return channel.sendToQueue(msg.properties.replyTo, Buffer.from(JSON.stringify({ error: 'Method not found' })), {
-                correlationId: msg.properties.correlationId,
+    getNotification: async (payload) => {
+        let result;
+        if (payload.data?.id) {
+            result = await commands.execute('getSingleNotification', {
+                id: payload.data.id
             });
+        } else if (payload.data?.email) {
+            result = await commands.execute('getSingleNotification', {
+                email: payload.data.email
+            });
+        } else {
+            throw new Error('No notification ID or email provided');
         }
-
-        switch (payload.method) {
-            case 'sendNotification':
-                try {
-                    const { templateName, to, params, subject } = payload.data;
-                    await commandBus.execute('sendNotification', { templateName, to, params, subject });
-                    channel.sendToQueue(msg.properties.replyTo, Buffer.from(JSON.stringify({ status: 'ok' })), {
-                        correlationId: msg.properties.correlationId,
-                    });
-                } catch (error) {
-                    logger.error("Error sending notification: " + error);
-                    channel.sendToQueue(msg.properties.replyTo, Buffer.from(JSON.stringify({ error: 'Failed to send notification' })), {
-                        correlationId: msg.properties.correlationId,
-                    });
-                } finally {
-                    channel.ack(msg);
-                }
-                break;
-
-            case 'healthCheck':
-                await this.handleHealthCheck(msg, channel);
-                break;
-
-            default:
-                await this.handleMethodNotFound(msg, channel);
+        if (!result) {
+            throw new Error('Notification not found');
         }
+        return { notification: result };
     },
 
-    // Handler for the health check method
-    async handleHealthCheck(msg, channel) {
-        try {
-            channel.sendToQueue(msg.properties.replyTo, Buffer.from(JSON.stringify({ status: 'ok' })), {
-                correlationId: msg.properties.correlationId,
-            });
-        } catch (error) {
-            logger.error("Error running health check:", error);
-        } finally {
-            channel.ack(msg);
-        }
+    getManyNotifications: async (payload) => {
+        const results = await commands.execute('getManyNotifications', {});
+        return { notifications: results };
     },
 
-    // Handler for unknown methods
-    async handleMethodNotFound(msg, channel) {
-        try {
-            channel.sendToQueue(msg.properties.replyTo, Buffer.from(JSON.stringify({ error: 'Method not found' })), {
-                correlationId: msg.properties.correlationId,
-            });
-        } catch (error) {
-            logger.error("Error handling method not found:", error);
-        } finally {
-            channel.ack(msg);
-        }
+    createNotification: async (payload) => {
+        const results = await commands.execute('createNotifications', {
+            notifications: [payload.data.notification]
+        });
+        return { notifications: results };
     },
 
-    // Initialize RabbitMQ and consumers
-    init: async function () {
-        await initializeRabbitMQ(
-            queueName,
-            prefetch,
-            this.handleMessage.bind(this)
-        );
+    updateNotification: async (payload) => {
+        const result = await commands.execute('updateNotification', {
+            id: payload.data.id,
+            newNotificationData: payload.data
+        });
+        return { notification: result };
     },
-}
+
+    deleteNotification: async (payload) => {
+        await commands.execute('deleteNotification', {
+            id: payload.data.id
+        });
+        return { message: 'Notification deleted' };
+    },
+
+};