@gnar-engine/cli 1.0.0 → 1.0.1

package/bootstrap/services/control/src/services/task.service.js

@@ -0,0 +1,153 @@
+import { logger, utils, db } from '@gnar-engine/core';
+
+
+/**
+ * Task Service
+ */
+export const task = {
+
+    // schedule a task
+    scheduleTask: async ({name, payload, scheduled, recurringInterval, recurringIntervalCount, rescheduleCentrallyOnSuccess = false, rescheduleCentrallyOnFailure = false, handlerServiceName, handlerName, idempotencyKey = ''}) => {
+        try {
+            const [result] = await db.execute(
+                'INSERT INTO `tasks` (`id`, `name`, `payload`, `status`, `scheduled`, `recurring_interval`, `recurring_interval_count`, `reschedule_centrally_on_success`, `reschedule_centrally_on_failure`, `handler_service_name`, `handler_name`, `idempotency_key`) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
+                [utils.uuid(), name, JSON.stringify(payload), 'scheduled', scheduled, recurringInterval, recurringIntervalCount, rescheduleCentrallyOnSuccess, rescheduleCentrallyOnFailure, handlerServiceName, handlerName, idempotencyKey]
+            );
+
+            return result.insertId;
+        } catch (error) {
+            logger.error("Error scheduling task:" + error);
+            throw error;
+        }
+    },
+
+    // update task status
+    updateTaskStatus: async ({id, status}) => {
+        try {
+            const [result] = await db.execute(
+                'UPDATE `tasks` SET `status` = ? WHERE `id` = ?',
+                [status, id]
+            );
+
+            return result.affectedRows;
+        } catch (error) {
+            logger.error("Error updating task status:" + error);
+            throw error;
+        }
+    },
+
+    // cancel tasks by associated resource id
+    cancelTasksByAssociatedResourceId: async ({associatedResourceId}) => {
+        try {
+            const [result] = await db.execute(
+                'UPDATE `tasks` SET `status` = ? WHERE `associated_resource_id` = ?',
+                ['cancelled', associatedResourceId]
+            );
+
+            return result.affectedRows;
+        } catch (error) {
+            logger.error("Error cancelling tasks by associated resource id:" + error);
+            throw error;
+        }
+    },
+
+    // get task batch
+    getTaskBatch: async ({status}) => {
+        try {
+            const [result] = await db.execute(
+                'SELECT * FROM `tasks` WHERE `status` = ? AND `scheduled` <= NOW()',
+                [status]
+            );
+
+            // map from snake case to camel case
+            const tasks = result.map(task => {
+                return {
+                    id: task.id,
+                    name: task.name,
+                    payload: JSON.parse(task.payload),
+                    status: task.status,
+                    scheduled: task.scheduled,
+                    recurringInterval: task.recurring_interval,
+                    recurringIntervalCount: task.recurring_interval_count,
+                    rescheduleCentrallyOnSuccess: task.reschedule_centrally_on_success,
+                    rescheduleCentrallyOnFailure: task.reschedule_centrally_on_failure,
+                    handlerServiceName: task.handler_service_name,
+                    handlerName: task.handler_name,
+                    idempotencyKey: task.idempotency_key
+                };
+            });
+
+            return tasks;
+        } catch (error) {
+            logger.error("Error getting task batch:" + error);
+            throw error;
+        }
+    },
+
+    // get tasks by status
+    getTasksByStatus: async ({status}) => {
+        try {
+            const [result] = await db.execute(
+                'SELECT * FROM `tasks` WHERE `status` = ?',
+                [status]
+            );
+
+            // map from snake case to camel case
+            const tasks = result.map(task => {
+                return {
+                    id: task.id,
+                    name: task.name,
+                    payload: JSON.parse(task.payload),
+                    status: task.status,
+                    scheduled: task.scheduled,
+                    recurringInterval: task.recurring_interval,
+                    recurringIntervalCount: task.recurring_interval_count,
+                    rescheduleCentrallyOnSuccess: task.reschedule_centrally_on_success,
+                    rescheduleCentrallyOnFailure: task.reschedule_centrally_on_failure,
+                    handlerServiceName: task.handler_service_name,
+                    handlerName: task.handler_name,
+                    idempotencyKey: task.idempotency_key
+                };
+            });
+
+            return tasks;
+        } catch (error) {
+            logger.error("Error getting tasks by status in service:" + error);
+            throw error;
+        }
+    },
+
+    // ensure task is the only scheduled with this indempotency key
+    checkIndempotent: async ({idempotencyKey}) => {
+        try {
+            if (!idempotencyKey) {
+                return true;
+            }
+
+            const [result] = await db.execute(
+                'SELECT * FROM `tasks` WHERE `idempotency_key` = ? AND `status` = ?',
+                [idempotencyKey, 'scheduled']
+            );
+
+            return result.length === 0;
+        } catch (error) {
+            logger.error("Error checking indempotency:" + error);
+            throw error;
+        }
+    },
+
+    // delete failed tasks
+    deleteFailedTasks: async () => {
+        try {
+            const [result] = await db.execute(
+                'DELETE FROM `tasks` WHERE `status` = ?',
+                ['failed']
+            );
+
+            return result.affectedRows;
+        } catch (error) {
+            logger.error("Error deleting failed tasks:" + error);
+            throw error;
+        }
+    }
+};

package/bootstrap/services/control/src/tests/control.test.js

@@ -0,0 +1,50 @@
+import request from 'supertest';
+const url = 'http://localhost:4000';
+const authUrl = 'http://localhost:4001';
+
+describe('Products API CRUD', () => {
+
+    let authToken;
+    let productId;
+
+    beforeAll(async () => {
+        // check we are not in production mode
+        if (process.env.NODE_ENV === 'production') {
+            throw new Error('Do not run tests in production mode!');
+        }
+    });
+
+    // authenticate with email and password
+    it('POST /authenticate', async () => {
+        const response = await request(authUrl).post('/authenticate')
+        .set('Content-Type', 'application/json')
+        .send({
+            username: 'adam@gnar.co.uk',
+            password: 'password'
+        });
+        console.log(response.body);
+        expect(response.status).toBe(200);
+        expect(response.body).toHaveProperty('token');
+
+        authToken = response.body.token;
+    });
+
+    // schedule a task
+    it('should return 200 OK - POST /tasks/schedule', async () => {
+        const res = await request(url).post('/tasks/schedule')
+        .set('Content-Type', 'application/json')
+        .set('Authorization', 'Bearer ' + authToken)
+        .send({
+            name: 'test-task',
+            payload: { test: 'data' },
+            scheduled: new Date().addMonths(1),
+            recurringInterval: 'monthly',
+            recurringIntervalCount: 1,
+            handlerServiceName: 'userService',
+            handlerName: 'testHandler'
+        });
+        console.log(res.body);
+        expect(res.statusCode).toEqual(200);
+    });
+
+});

package/bootstrap/services/notification/Dockerfile

@@ -0,0 +1,23 @@
+# Dockerfile for Notification Service
+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/notification/package*.json ./
+
+# Install nodemon
+RUN npm install -g nodemon
+
+# Install app dependencies
+RUN npm install
+
+# Expose the port the service will run on
+EXPOSE 4000
+
+# Start the application
+CMD ["nodemon", "--watch", "./gnar_engine", "./gnar_engine/app.js"]

package/bootstrap/services/notification/Dockerfile.prod

@@ -0,0 +1,37 @@
+# Stage 1: Builder
+FROM node:20-alpine AS builder
+
+WORKDIR /app
+
+# Copy app source
+COPY ./services/notification/src ./src
+COPY ./Lib ./Lib
+
+# Copy environment variables (do this later in build only if needed)
+COPY ./.env.production .env
+
+# Copy package files and install deps
+COPY ./services/notification/package*.json ./
+RUN npm install --omit=dev
+
+# Stage 2: Runtime
+FROM node:20-alpine
+
+WORKDIR /app
+
+# Copy built app from builder stage
+COPY --from=builder /app /app
+
+# Install system deps
+RUN apk add --no-cache ca-certificates wget
+
+# Install AWS DocumentDB CA certificates
+RUN mkdir -p /usr/local/share/ca-certificates && \
+    wget https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem -O /usr/local/share/ca-certificates/aws-docdb.pem && \
+    update-ca-certificates
+
+# Expose port
+EXPOSE 4000
+
+# Start app
+CMD ["npm", "run", "start"]

package/bootstrap/services/notification/README.md

@@ -0,0 +1,3 @@
+# Gnar Engine Notification Service
+
+- Email sending

package/bootstrap/services/notification/package.json

@@ -0,0 +1,34 @@
+{
+  "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/*"
+  ]
+}

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

@@ -0,0 +1,51 @@
+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);
+});
+
+/**
+ * @function startServer
+ * @description Initializes and starts the Fastify server.
+ */
+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();

package/bootstrap/services/notification/src/commands/command-bus.js

@@ -0,0 +1,20 @@
+/**
+ * Command bus
+ */
+export const commandBus = {
+    handlers: new Map(),
+  
+    register(commandName, handlerFunction) {
+      this.handlers.set(commandName, handlerFunction);
+    },
+  
+    async execute(commandName, ...args) {
+      const handlerFunction = this.handlers.get(commandName);
+      if (!handlerFunction) {
+        console.log('handlers', this.handlers);
+        throw new Error(`Command ${commandName} not registered`);
+      }
+  
+      return await handlerFunction(...args);
+    }
+}

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

@@ -0,0 +1,18 @@
+
+/**
+ * Run seeders
+ * 
+ * @param {Object} params
+ * @param {string} params.seeder Name of single seeder to run (optional)
+ */
+export const runSeeders = async ({seeder}) => {
+    // checkout service has no db
+}
+
+/**
+ * Internal health check (kills process if it fails)
+ */
+export const internalHealthCheck = async () => {
+
+    // Nothing to check for checkout service
+}

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

@@ -0,0 +1,157 @@
+import { logger } from '../../services/logger.service.js';
+import { emailSendingService, emailHeaderLogoUrl } from './../../config.js';
+import { helpers } from '@gnar-engine/helpers';
+import fs from 'fs';
+import handlebars from 'handlebars';
+import nodemailer from 'nodemailer';
+import { getSesClient } from '../../services/ses.service.js';
+import { SendEmailCommand } from '@aws-sdk/client-ses';
+
+
+/**
+ * Send a notification
+ * 
+ * @param {Object} params
+ * @param {string} params.templateName - Name of the template file (without extension)
+ * @param {string} params.to - Recipient email address
+ * @param {Object} params.params - Parameters to be passed to the template
+ * @param {string} params.subject - Subject of the email
+ */
+export const sendNotification = async ({ templateName, to, params, subject }) => {
+    let source;
+    let template;
+
+    // get the requested template
+    try {
+        const workingDir = process.cwd();
+        const path = workingDir + '/src/templates/' + templateName + '.hbs';    
+        source = fs.readFileSync(path, 'utf8');
+    } catch (error) {
+        logger.error('Error reading template file: ' + error.message);
+        throw new Error('Template not found');
+    }
+
+    // compile the template
+    try {
+        template = handlebars.compile(source);
+    } catch (error) {
+        logger.error('Error compiling template: ' + error.message);
+        throw new Error('Template compilation failed');
+    }
+
+    // append other params
+    params = prepareParams(params, templateName);
+
+    // prepare the template
+    const html = template(params);
+
+    // send the email
+    switch (emailSendingService) {
+        case 'SMTP':
+            await sendSmtpEmail({ to, subject, html });
+            break;
+
+        case 'SES':
+            await sendSesEmail({ to, subject, html });
+            break;
+
+        case 'Direct':
+            logger.error('Email sending service not implemented: ' + emailSendingService);
+            throw new Error('Email sending service not implemented');
+        
+        default:
+            logger.error('Invalid email sending service: ' + emailSendingService);
+            throw new Error('Invalid email sending service');
+    }
+}
+
+/**
+ * Send SMTP email
+ * 
+ * @param {Object} params
+ * @param {string} params.to - Recipient email address
+ * @param {string} params.subject - Email subject
+ * @param {string} params.html - HTML content of the email
+ */
+export const sendSmtpEmail = async ({ to, subject, html }) => {
+    try {
+        const transporter = nodemailer.createTransport({
+            host: process.env.SMTP_HOST,
+            port: parseInt(process.env.SMTP_PORT || '465'),
+            secure: true,
+            auth: {
+                user: process.env.SMTP_USER,
+                pass: process.env.SMTP_PASS
+            }
+        });
+
+        const mailOptions = {
+            from: `"Your App Name" <${process.env.SMTP_USER}>`,
+            to,
+            subject,
+            html
+        };
+
+        await transporter.sendMail(mailOptions);
+    } catch (error) {
+        logger.error('SMTP email send error: ' + error.message);
+        throw new Error('SMTP email failed to send');
+    }
+}
+
+/**
+ * Send SES email
+ * 
+ * @param {Object} params
+ * @param {string} params.to - Recipient email address
+ * @param {string} params.subject - Email subject
+ * @param {string} params.html - HTML content of the email
+ */
+export const sendSesEmail = async ({ to, subject, html }) => {
+    try {
+        const sesClient = getSesClient();
+
+        const command = new SendEmailCommand({
+            Source: process.env.NOTIFICATION_SES_SOURCE_EMAIL,
+            Destination: {
+                ToAddresses: [to]
+            },
+            Message: {
+                Subject: {
+                    Data: subject,
+                    Charset: 'UTF-8'
+                },
+                Body: {
+                    Html: {
+                        Data: html,
+                        Charset: 'UTF-8'
+                    }
+                }
+            }
+        });
+
+        await sesClient.send(command);
+    } catch (error) {
+        logger.error('Error sending email with SES: ' + error.message);
+        throw new Error('SES email failed to send');
+    }
+}
+
+/**
+ * Prepare parameters for the template
+ * 
+ * @param {Object} params - Parameters to be passed to the template
+ * @param {string} templateName - Name of the template file (without extension)
+ * @returns {Object} - Prepared parameters
+ */
+const prepareParams = (params, templateName) => {
+
+    // add shop logo
+    params.logoUrl = emailHeaderLogoUrl;
+
+    if (params.order?.currency) {
+        params.currencySymbol = helpers.ecommerce.getCurrencySymbol(params.order.currency);
+    }
+
+    return params
+}

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

@@ -0,0 +1,15 @@
+
+/**
+ * Email sending service
+ * 
+ * - Values:
+ *   - SES (not implemented yet)
+ *   - SMTP
+ *   - Direct (not implemented yet)
+ */
+export const emailSendingService = 'SES';
+
+/**
+ * Email header logo url
+ */
+export const emailHeaderLogoUrl = 'https://admin.gnarengine.com/public/gnarengine-logo-black.png';

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

@@ -0,0 +1,82 @@
+import { commandBus } from '../commands/command-bus.js';
+import { logger } from '../services/logger.service.js';
+import { initializeRabbitMQ } from '@gnar-engine/message-client';
+
+// Configuration
+const queueName = 'notificationServiceQueue';
+const prefetch = 3;
+
+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,
+            });
+        }
+
+        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);
+        }
+    },
+
+    // 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);
+        }
+    },
+
+    // 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);
+        }
+    },
+
+    // Initialize RabbitMQ and consumers
+    init: async function () {
+        await initializeRabbitMQ(
+            queueName,
+            prefetch,
+            this.handleMessage.bind(this)
+        );
+    },
+}

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

@@ -0,0 +1,16 @@
+import pino from 'pino';
+import fs from 'fs';
+import path from 'path';
+
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+
+// Create a logger instance
+export const logger = pino({
+    level: process.env.LOG_MODE || 'info',
+    transport: {
+      target: 'pino-pretty', // Pretty print logs for the console
+      options: {
+        colorize: true, // Colorize the logs in the console
+      }
+    }
+});