@gnar-engine/cli 1.0.4 → 1.0.6

package/templates/entity/src/commands/{{entityName}}.handler.js.hbs

@@ -0,0 +1,94 @@
+import { commands, logger, error } from '@gnar-engine/core';
+import { {{entityName}} } from '../services/{{entityName}}.service.js';
+import { config } from '../config.js';
+import { validate{{pascalCase entityName}} } from '../schema/{{entityName}}.schema.js';
+
+
+/**
+ * Get single {{entityName}}
+ */
+commands.register('{{serviceName}}Service.getSingle{{pascalCase entityName}}', async ({id}) => {
+    if (id) {
+        return await {{entityName}}.getById({id: id});
+    } else {
+        throw new error.badRequest('{{pascalCase entityName}} id required');
+    }
+});
+
+/**
+ * Get many {{lowerCasePlural entityName}}
+ */
+commands.register('{{serviceName}}Service.getMany{{pascalCasePlural entityName}}', async ({}) => {
+    return await {{entityName}}.getAll();
+});
+
+/**
+ * Create {{lowerCasePlural entityName}}
+ */
+commands.register('{{serviceName}}Service.create{{pascalCasePlural entityName}}', async ({ {{lowerCasePlural entityName}} }) => {
+    const validationErrors = [];
+    let createdNew{{pascalCasePlural entityName}} = [];
+
+    for (const newData of {{lowerCasePlural entityName}}) {
+        const { errors } = validate{{pascalCase entityName}}(newData);
+        if (errors?.length) {
+            validationErrors.push(errors);
+            continue;
+        }
+
+        const created = await {{entityName}}.create(newData);
+        createdNew{{pascalCasePlural entityName}}.push(created);
+    }
+
+    if (validationErrors.length) {
+        throw new error.badRequest(`Invalid {{entityName}} data: ${validationErrors}`);
+    }
+
+    return createdNew{{pascalCasePlural entityName}};
+});
+
+/**
+ * Update {{entityName}}
+ */
+commands.register('{{serviceName}}Service.update{{pascalCase entityName}}', async ({id, new{{pascalCase entityName}}Data}) => {
+
+    const validationErrors = [];
+
+    if (!id) {
+        throw new error.badRequest('{{pascalCase entityName}} ID required');
+    }
+
+    const obj = await {{entityName}}.getById({id: id});
+
+    if (!obj) {
+        throw new error.notFound('{{pascalCase entityName}} not found');
+    }
+
+    delete new{{pascalCase entityName}}Data.id;
+
+    const { errors } = validate{{pascalCase entityName}}Update(new{{pascalCase entityName}}Data);
+ 
+    if (errors?.length) {
+        validationErrors.push(errors);
+    }
+
+    if (validationErrors.length) {
+        throw new error.badRequest(`Invalid {{entityName}} data: ${validationErrors}`);
+    }
+
+    return await {{entityName}}.update({
+        id: id,
+        updatedData: new{{pascalCase entityName}}Data
+    });
+});
+
+/**
+ * Delete {{entityName}}
+ */
+commands.register('{{serviceName}}Service.delete{{pascalCase entityName}}', async ({id}) => {
+    const obj = await {{entityName}}.getById({id: id});
+    if (!obj) {
+        throw new error.notFound('{{pascalCase entityName}} not found');
+    }
+    return await {{entityName}}.delete({id: id});
+});

package/templates/entity/src/controllers/{{entityName}}.http.controller.js.hbs

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

package/templates/entity/src/mysql.db/migrations/03-{{entityName}}-entity-init.js.hbs

@@ -0,0 +1,23 @@
+import { logger, db } from '@gnar-engine/core';
+
+/**
+ * Up
+ */
+export const up = async () => {
+    logger.info('Creating table: {{lowerCasePlural entityName}}');
+    await db.query(`
+        CREATE TABLE {{lowerCasePlural entityName}} (
+            id INT AUTO_INCREMENT PRIMARY KEY,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+        )
+    `);
+}
+
+/**
+ * Down
+ */
+export const down = async () => {
+    logger.info('Dropping table: {{lowerCasePlural entityName}}');
+    await db.query('DROP TABLE IF EXISTS {{lowerCasePlural entityName}}');
+}

package/templates/entity/src/policies/{{entityName}}.policy.js.hbs

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

package/templates/entity/src/schema/{{entityName}}.schema.js.hbs

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

package/templates/entity/src/services/mongodb.{{entityName}}.service.js.hbs

@@ -0,0 +1,70 @@
+import { db, logger } from '@gnar-engine/core';
+import { ObjectId } from 'mongodb';
+
+export const {{entityName}} = {
+
+    // Get all {{lowerCasePlural entityName}}
+    getAll: async () => {
+        try {
+            const items = await db.collection('{{lowerCasePlural entityName}}').find().toArray();
+            return items;
+        } catch (error) {
+            logger.error("Error fetching {{lowerCasePlural entityName}}:", error);
+            throw error;
+        }
+    },
+
+    // Create a {{lowerCase entityName}}
+    create: async (data) => {
+        try {
+            const collection = db.collection('{{lowerCasePlural entityName}}');
+            const result = await collection.insertOne(data);
+            return await collection.findOne({ _id: result.insertedId });
+        } catch (error) {
+            logger.error("Error creating {{lowerCase entityName}}:", error);
+            throw error;
+        }
+    },
+
+    // Get a {{lowerCase entityName}} by ID
+    getById: async ({ id }) => {
+        try {
+            const collection = db.collection('{{lowerCasePlural entityName}}');
+            const objectId = new ObjectId(id);
+            const item = await collection.findOne({ _id: objectId });
+            return item;
+        } catch (error) {
+            logger.error("Error fetching {{lowerCase entityName}}:", error);
+            throw error;
+        }
+    },
+
+    // Update a {{lowerCase entityName}}
+    update: async ({ id, updatedData }) => {
+        try {
+            const collection = db.collection('{{lowerCasePlural entityName}}');
+            const objectId = new ObjectId(id);
+            const result = await collection.updateOne(
+                { _id: objectId },
+                { $set: updatedData }
+            );
+            return result.modifiedCount > 0;
+        } catch (error) {
+            logger.error("Error updating {{lowerCase entityName}}:", error);
+            throw error;
+        }
+    },
+
+    // Delete a {{lowerCase entityName}}
+    delete: async ({ id }) => {
+        try {
+            const collection = db.collection('{{lowerCasePlural entityName}}');
+            const objectId = new ObjectId(id);
+            const result = await collection.deleteOne({ _id: objectId });
+            return result.deletedCount > 0;
+        } catch (error) {
+            logger.error("Error deleting {{lowerCase entityName}}:", error);
+            throw error;
+        }
+    }
+};

package/templates/entity/src/services/mysql.{{entityName}}.service.js.hbs

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

package/templates/service/src/app.js.hbs

@@ -1,4 +1,4 @@
-import { message, http, logger, db } from '@gnar-engine/core';
+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 {{lowerCase serviceName}}PlatformHttpController } from './controllers/http.controller.js';
@@ -26,6 +26,9 @@ export const initService = async () => {
 		handlers: messageHandlers
 	});
 
+    // Initialise websocket client & server
+    await webSockets.init(config.webSockets, config.serviceName);
+
 	// Register http routes
 	await http.registerRoutes({
 		controllers: [
@@ -36,7 +39,15 @@ export const initService = async () => {
 	// 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 | {{capitaliseFirstLetter serviceName}} Service initialised successfully.');
+
+    // Tests
+    if (config.environment === 'test' && config.runTests) {
+        test.runCommandTests({config});
+    }
 }
 
 initService();

package/templates/service/src/commands/{{serviceName}}.handler.js.hbs

@@ -80,7 +80,7 @@ commands.register('{{serviceName}}Service.update{{pascalCase serviceName}}', asy
     
     return await {{serviceName}}.update({
         id: id,
-        ...new{{pascalCase serviceName}}Data
+        updatedData: new{{pascalCase serviceName}}Data
     });
 });
 

package/templates/service/src/mongodb.config.js.hbs

@@ -25,7 +25,11 @@ export const config = {
         type: 'mongodb',
 
         // MongoDB
-        connectionUrl: process.env.{{upperCase serviceName}}_MONGO_URL,
+        host: process.env.{{upperCase serviceName}}_MONGO_HOST,
+        database: process.env.{{upperCase serviceName}}_MONGO_DATABASE,
+        user: process.env.{{upperCase serviceName}}_MONGO_USER,
+        password: process.env.{{upperCase serviceName}}_MONGO_PASSWORD,
+        port: process.env.{{upperCase serviceName}}_MONGO_PORT || 27017,
         connectionArgs: {},
     },
 

package/templates/service/src/mysql.config.js.hbs

@@ -5,6 +5,10 @@ export const config = {
     // service name
     serviceName: '{{serviceName}}Service',
 
+    // environment
+    environment: process.env.{{upperCase serviceName}}_NODE_ENV || 'dev',
+    runTests: process.env.{{upperCase serviceName}}_RUN_TESTS || false,
+
     // microservice | modular-monolith
     architecture: process.env.GLOBAL_ARCHITECTURE || 'microservice',
 

package/bootstrap/services/notification/Dockerfile.prod

@@ -1,37 +0,0 @@
-# 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

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

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

@@ -1,20 +0,0 @@
-/**
- * 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

@@ -1,18 +0,0 @@
-
-/**
- * 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

@@ -1,157 +0,0 @@
-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
-}