@gnar-engine/cli 1.0.4 → 1.0.6

package/bootstrap/services/notification/src/db/migrations/01-init.js

@@ -0,0 +1,50 @@
+import { logger, db } from '@gnar-engine/core';
+
+/**
+ * Up
+ */
+export const up = async () => {
+    await initDatabaseTables();
+}
+
+/**
+ * Down
+ */
+export const down = async () => {
+    await dropDatabaseTables();
+}
+
+/**
+ * Create all tables
+ */
+export const initDatabaseTables = async () => {
+
+    // Migrations table
+    logger.info("Creating migrations table");
+    const createMigrationsTableQuery = `
+        CREATE TABLE migrations (
+            id INT AUTO_INCREMENT PRIMARY KEY,
+            name VARCHAR(255) NOT NULL UNIQUE,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )`;
+    await db.query(createMigrationsTableQuery);
+
+    // Seeders table
+    logger.info("Creating seeders table");
+    const createSeedersTableQuery = `
+        CREATE TABLE seeders (
+            id INT AUTO_INCREMENT PRIMARY KEY,
+            name VARCHAR(255) NOT NULL UNIQUE,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )`;
+    await db.query(createSeedersTableQuery);
+}
+
+/**
+ * Drop all tables
+ */
+export const dropDatabaseTables = async () => {
+    logger.info('Dropping tables');
+    await db.query('DROP TABLE IF EXISTS migrations');
+    await db.query('DROP TABLE IF EXISTS seeders');
+}

package/bootstrap/services/notification/src/db/migrations/02-notification-service-init.js

@@ -0,0 +1,23 @@
+import { logger, db } from '@gnar-engine/core';
+
+/**
+ * Up
+ */
+export const up = async () => {
+    logger.info('Creating table: notifications');
+    await db.query(`
+        CREATE TABLE notifications (
+            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: notifications');
+    await db.query('DROP TABLE IF EXISTS notifications');
+}

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/page/Dockerfile

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

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