@gnar-engine/cli 1.0.3 → 1.0.5

package/bootstrap/deploy.localdev.yml

@@ -1,51 +1,65 @@
-# deploy.localdev.yml
-
-# - This file is used to orchestrate locally running containers for development
-# - environment: localdev is a named convention required for local development 
-
 config:
-  core-version: 1.0
+  core-version: 1
   architecture: microservice
   region: eu-west-2
   environment: localdev
   namespace: my-project
-
   services:
     - name: control
       listener_rules:
         paths:
           - /control
           - /tasks
-      min-tasks: 1
-      max-tasks: 1
+      min_tasks: 1
+      max_tasks: 1
       depends_on:
-        - control-db
-      command: ["npm", "run", "start:dev"]
-      ports: 
-        - "4001:3000"
-
+        - db-mysql
+      command:
+        - npm
+        - run
+        - start:dev
+      ports:
+        - '4001:3000'
     - name: user
       listener_rules:
         paths:
           - /authenticate
           - /users
-      min-tasks: 1
-      max-tasks: 1
+      min_tasks: 1
+      max_tasks: 1
       depends_on:
-        - control-db
-      command: ["npm", "run", "start:dev"]
-      ports: 
-        - "4002:3000"
-
-    - name: agent
+        - db-mysql
+      command:
+        - npm
+        - run
+        - start:dev
+      ports:
+        - '4002:3000'
+    - name: portal
       listener_rules:
         paths:
-          - /agent
-      min-tasks: 1
-      max-tasks: 1
+          - /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:
-        - agent-db
-      command: ["npm", "run", "start:dev"]
-      ports: 
-        - "4003:3000"
-
+        - db-mongo

package/bootstrap/secrets.localdev.yml

@@ -1,27 +1,33 @@
+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: 
+  AWS_SECRET_ACCESS_KEY: 
 services:
   control:
-    MYSQL_HOST: control-db
+    MYSQL_HOST: db-mysql
     MYSQL_DATABASE: ge_control_db
     MYSQL_USER: ge_control_db_user
-    MYSQL_PASSWORD: zWF85kfGJNRA9ayp
-    MYSQL_RANDOM_ROOT_PASSWORD: wH0Pzkht75NvMd3b
+    MYSQL_PASSWORD: bL6I1ABJFDPO3JAR
   user:
-    MYSQL_HOST: user-db
+    MYSQL_HOST: db-mysql
     MYSQL_DATABASE: ge_user_db
     MYSQL_USER: ge_user_db_user
-    MYSQL_PASSWORD: WTEYWqs6wDBX459p
-    MYSQL_RANDOM_ROOT_PASSWORD: GXEy5T7Cp2zuOTah
+    MYSQL_PASSWORD: 7cm0crGDTaJy9Sa2
     ROOT_ADMIN_EMAIL: adam@gnar.co.uk
     ROOT_ADMIN_USERNAME: engineadmin
-    ROOT_ADMIN_PASSWORD: n0eYk6aoiYAeSur1
-    ROOT_ADMIN_API_KEY: qydfeMcyutzIXBvHjrB2qGL9hTdco81X
-  agent:
-    MYSQL_HOST: agent-db
-    MYSQL_DATABASE: ge_agent_db
-    MYSQL_USER: ge_agent_db_user
-    MYSQL_PASSWORD: 4BARYvygGSv6BRPH
-    MYSQL_RANDOM_ROOT_PASSWORD: s27o951anIt8Lqmy
+    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
+

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/{agent → page}/Dockerfile

@@ -1,5 +1,5 @@
-# Dockerfile for Agent Service
-FROM node:20-alpine
+# Dockerfile for Page Service
+FROM node:20-alpine 
 
 # Set the working directory
 WORKDIR /usr/gnar_engine/app
@@ -8,7 +8,7 @@ WORKDIR /usr/gnar_engine/app
 ENV GLOBAL_SERVICE_BASE_DIR=/usr/gnar_engine/app/src/
 
 # Copy package.json and package-lock.json
-COPY ./services/agent/package*.json ./
+COPY ./services/page/package*.json ./
 
 # Install nodemon
 RUN npm install -g nodemon

package/bootstrap/services/page/package.json

@@ -0,0 +1,16 @@
+{
+    "name": "page-service",
+    "version": "1.0.0",
+    "description": "Page 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/page/src/app.js

@@ -0,0 +1,50 @@
+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 pagePlatformHttpController } from './controllers/page.http.controller.js';
+import { httpController as blockPlatformHttpController } from './controllers/block.http.controller.js';
+
+/**
+ * Initialise service
+ */
+export const initService = async () => {
+
+    // Run seeders
+	db.seeders.runSeeders({config});
+
+	// Import command handlers after the command bus is initialised
+	await import('./commands/page.handler.js');
+    await import('./commands/block.handler.js');
+
+	// 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: [
+			pagePlatformHttpController,
+            blockPlatformHttpController
+		]
+	});
+
+	// 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 | Page Service initialised successfully.');
+
+    // Tests
+    if (config.environment === 'test' && config.runTests) {
+        test.runCommandTests({config});
+    }
+}
+
+initService();

package/bootstrap/services/page/src/commands/block.handler.js

@@ -0,0 +1,94 @@
+import { commands, logger, error } from '@gnar-engine/core';
+import { block } from '../services/block.service.js';
+import { config } from '../config.js';
+import { validateBlock } from '../schema/page.schema.js';
+
+
+/**
+ * Get single block
+ */
+commands.register('pageService.getSingleBlock', async ({id}) => {
+    if (id) {
+        return await block.getById({id: id});
+    } else {
+        throw new error.badRequest('Block id required');
+    }
+});
+
+/**
+ * Get many blocks
+ */
+commands.register('pageService.getManyBlocks', async ({}) => {
+    return await block.getAll();
+});
+
+/**
+ * Create blocks
+ */
+commands.register('pageService.createBlocks', async ({ blocks }) => {
+    const validationErrors = [];
+    let createdNewBlocks = [];
+
+    for (const newData of blocks) {
+        const { errors } = validateBlock(newData);
+        if (errors?.length) {
+            validationErrors.push(errors);
+            continue;
+        }
+
+        const created = await block.create(newData);
+        createdNewBlocks.push(created);
+    }
+
+    if (validationErrors.length) {
+        throw new error.badRequest(`Invalid block data: ${validationErrors}`);
+    }
+
+    return createdNewBlocks;
+});
+
+/**
+ * Update block
+ */
+commands.register('pageService.updateBlock', async ({id, newBlockData}) => {
+
+    const validationErrors = [];
+
+    if (!id) {
+        throw new error.badRequest('Block ID required');
+    }
+
+    const obj = await block.getById({id: id});
+
+    if (!obj) {
+        throw new error.notFound('Block not found');
+    }
+
+    delete newBlockData.id;
+
+    const { errors } = validateBlock(newBlockData);
+
+    if (errors?.length) {
+        validationErrors.push(errors);
+    }
+
+    if (validationErrors.length) {
+        throw new error.badRequest(`Invalid block data: ${validationErrors}`);
+    }
+
+    return await block.update({
+        id: id,
+        updatedData: newBlockData
+    });
+});
+
+/**
+ * Delete block
+ */
+commands.register('pageService.deleteBlock', async ({id}) => {
+    const obj = await block.getById({id: id});
+    if (!obj) {
+        throw new error.notFound('Block not found');
+    }
+    return await block.delete({id: id});
+});

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

@@ -0,0 +1,167 @@
+import { commands, logger, error, storage } from '@gnar-engine/core';
+import { page } from '../services/page.service.js';
+import { config } from '../config.js';
+import { validatePage } from '../schema/page.schema.js';
+
+
+/**
+ * Get single page
+ */
+commands.register('pageService.getSinglePage', async ({id}) => {
+    if (id) {
+        return await page.getById({id: id});
+    } else {
+        throw new error.badRequest('Page email or id required');
+    }
+});
+
+/**
+ * Get many pages
+ */
+commands.register('pageService.getManyPages', async ({}) => {
+    return await page.getAll();
+});
+
+/**
+ * Create pages
+ */
+commands.register('pageService.createPages', async ({ pages, requestUser }) => {
+    const validationErrors = [];
+    let createdNewPages = [];
+
+    for (const newData of pages) {
+        const { errors } = validatePage(newData);
+        if (errors?.length) {
+            validationErrors.push(errors);
+            continue;
+        }
+
+        newData = await commands.execute('processUploadsInData', { data: newData, requestUser });
+
+        const created = await page.create(newData);
+        createdNewPages.push(created);
+    }
+
+    if (validationErrors.length) {
+        throw new error.badRequest(`Invalid page data: ${validationErrors}`);
+    }
+
+    return createdNewPages;
+});
+
+/**
+ * Update page
+ */
+commands.register('pageService.updatePage', async ({id, newPageData, requestUser}) => {
+
+    const validationErrors = [];
+
+    if (!id) {
+        throw new error.badRequest('Page ID required');
+
+    }
+
+    const obj = await page.getById({id: id});
+
+    if (!obj) {
+        throw new error.notFound('Page not found');
+
+    }
+
+    delete newPageData.id;
+
+    const { errors } = validatePage(newPageData);
+
+    if (errors?.length) {
+        validationErrors.push(errors);
+    }
+
+    if (validationErrors.length) {
+        throw new error.badRequest(`Invalid page data: ${validationErrors}`);
+    }
+
+    newPageData = await commands.execute('processUploadsInData', { data: newPageData, requestUser });
+
+    return await page.update({
+        id: id,
+        updatedData: newPageData
+    });
+});
+
+/**
+ * Delete page
+ */
+commands.register('pageService.deletePage', async ({id}) => {
+    const obj = await page.getById({id: id});
+    if (!obj) {
+        throw new error.notFound('Page not found');
+    }
+    return await page.delete({id: id});
+});
+
+
+/**
+ * Find file and image uploads and store them
+ *
+ * @param {Object} data - The data object to search for files/images
+ * @param {Function} uploadFn - Function to handle the actual upload process
+ * @returns {Object} - The updated data object with stored file/image references
+ */
+commands.register('pageService.processUploadsInData', async ({ data, requestUser }) => {
+
+    const uploadFilesRecursive = async (data) => {
+        if (Array.isArray(data)) {
+            return Promise.all(data.map(item => uploadFilesRecursive(item)));
+        } else if (data && typeof data === 'object') {
+            const result = { ...data };
+
+            for (const [key, value] of Object.entries(data)) {
+                if (key === 'file' && typeof value === 'string') {
+
+                    logger.info('Processing file upload in page data');
+
+                    // Filename
+                    const fileName = result.fileName || `upload_${Date.now()}`;
+
+                    // Mime type 
+                    let mimeType = result.mimeType;
+                    let base64Data = value;
+
+                    const matches = value.match(/^data:(.+);base64,(.+)$/);
+                    if (matches) {
+                        mimeType = mimeType || matches[1];
+                        base64Data = matches[2];
+                    }
+
+                    if (!mimeType) mimeType = 'application/octet-stream';
+
+                    // Upload
+                    const url = await storage.upload({
+                        file: Buffer.from(base64Data, 'base64'),
+                        key: 'public/page-content/' + fileName,
+                        contentType: mimeType,
+                        metadata: {
+                            uploadedAt: new Date().toISOString(),
+                            uploadedBy: requestUser ? requestUser.id : 'unknown'
+                        }
+                    });
+
+                    // Add url and remove upload keys
+                    result.url = url;
+                    delete result.file;
+                    if (result.fileName) delete result.fileName;
+                    if (result.mimeType) delete result.mimeType;
+
+                } else {
+                    result[key] = await uploadFilesRecursive(value);
+                }
+            }
+
+            return result;
+        }
+
+        return data;
+    };
+
+    return await uploadFilesRecursive(data);
+});

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

@@ -0,0 +1,62 @@
+/**
+ * Gnar Engine Service Config
+ */
+export const config = {
+    // service name
+    serviceName: 'pageService',
+
+    // 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: 'mongodb',
+
+        // MongoDB
+        host: process.env.PAGE_MONGO_HOST,
+        database: process.env.PAGE_MONGO_DATABASE,
+        user: process.env.PAGE_MONGO_USER,
+        password: process.env.PAGE_MONGO_PASSWORD,
+        port: process.env.PAGE_MONGO_PORT || 27017,
+        connectionArgs: {},
+    },
+
+    // storage
+    storage: {
+        // driver: s3
+        driver: 's3',
+        uploadsUrl: process.env.UPLOADS_URL,
+
+        // s3
+        bucket: process.env.S3_BUCKET,
+        region: process.env.AWS_REGION,
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
+    },
+
+    // message broker
+    message: {
+        url: process.env.RABBITMQ_URL,
+        queueName: 'pageServiceQueue',
+        prefetch: 20
+    },
+
+    webSockets: {
+        reconnectInterval: 5000,
+        maxInitialConnectionAttempts: 5
+    },
+
+    hashNameSpace: '',
+}

package/bootstrap/services/page/src/controllers/block.http.controller.js

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