@gnar-engine/cli 1.0.0 → 1.0.1

package/bootstrap/services/portal/src/ui/pagination/Pagination.jsx

@@ -0,0 +1,23 @@
+import React from 'react';
+
+const Pagination = ({ numPages, currentPage, setCurrentPage }) => {
+    const handlePageChange = (page) => {
+        setCurrentPage(page);
+    };
+
+    return (
+        <div className="pagination">
+            {Array.from({ length: numPages }, (_, i) => (
+                <button
+                    key={i}
+                    onClick={() => handlePageChange(i + 1)}
+                    disabled={currentPage === i + 1}
+                >
+                    {i + 1}
+                </button>
+            ))}
+        </div>
+    );
+};
+
+export default Pagination;

package/bootstrap/services/portal/src/ui/repeater/Repeater.jsx

@@ -0,0 +1,29 @@
+import React from "react";
+
+const Repeater = ({ items = [], setItems, defaultItem, renderRow, buttonText }) => {
+
+    const addItem = () => {
+        setItems([...items, defaultItem]);
+    }
+
+    const updateItem = (index, newItem) => {
+        const newItems = [...items];
+        newItems[index] = newItem;
+        setItems(newItems);
+    };
+  
+    const removeItem = (index) => setItems(items.filter((_, i) => i !== index));
+
+    return (
+        <div>
+            {items.length > 0 && items.map((item, index) =>
+                renderRow(item, index, (newItem) => updateItem(index, newItem), () => removeItem(index))
+            )}
+            <div className="button-cont right">
+                <button className="mainButton wide" onClick={addItem}>{buttonText}</button>
+            </div>
+        </div>
+    );
+};
+
+export default Repeater;

package/bootstrap/services/portal/src/ui/saveButton/SaveButton.jsx

@@ -0,0 +1,69 @@
+import React, { useState, useEffect } from 'react';
+
+const SaveButton = ({ save, loading, textCreate, textCreateLoading, textCreateSuccess, textCreateError, textUpdate, textUpdateLoading, textUpdateSuccess, textUpdateError, isUpdating}) => {
+    
+    const [buttonText, setButtonText] = useState(textCreate || 'Save');
+
+    // Determine the button class name based on the loading state
+    const getButtonClassName = () => {
+        if (loading === 'loading') {
+            return 'btn-loading';
+        }
+    
+        if (loading === 'success') {
+            return 'success';
+        }
+    
+        if (loading === 'error') {
+            return 'error';
+        }
+    
+        if (isUpdating) {
+            return 'update';
+        } else {
+            return 'create';
+        }
+    };
+
+    useEffect(() => {
+        if (isUpdating) {
+            // If updating
+            switch (loading) {
+                case 'loading':
+                    setButtonText(textUpdateLoading || 'Updating...');
+                    break;
+                case 'success':
+                    setButtonText(textUpdateSuccess || 'Updated');
+                    break;
+                case 'error':
+                    setButtonText(textUpdateError || 'Error');
+                    break;
+                default:
+                    setButtonText(textUpdate || 'Update');
+                    break;
+            }
+        } else {
+            // If creating
+            switch (loading) {
+                case 'loading':
+                    setButtonText(textCreateLoading || 'Creating...');
+                    break;
+                case 'success':
+                    setButtonText(textCreateSuccess || 'Saved');
+                    break;
+                case 'error':
+                    setButtonText(textCreateError || 'Error');
+                    break;
+                default:
+                    setButtonText(textCreate || 'Save');
+                    break;
+            }
+        }
+    }, [loading, isUpdating, textCreate, textCreateLoading, textCreateSuccess, textCreateError, textUpdate, textUpdateLoading, textUpdateSuccess, textUpdateError]);
+
+    return (
+        <button className={getButtonClassName()} onClick={save}>{buttonText}</button>
+    );
+};
+
+export default SaveButton;

package/bootstrap/services/rabbit-mq/Dockerfile.prod

@@ -0,0 +1,9 @@
+# From RabbitMQ official image
+FROM rabbitmq:management
+
+# # Copy shared Erlang cookie
+# COPY .erlang.cookie /var/lib/rabbitmq/.erlang.cookie
+
+# # Set correct permissions
+# RUN chown rabbitmq:rabbitmq /var/lib/rabbitmq/.erlang.cookie && \
+#     chmod 400 /var/lib/rabbitmq/.erlang.cookie

package/bootstrap/services/user/Dockerfile

@@ -0,0 +1,23 @@
+# Dockerfile for Product 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/user/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/user/Dockerfile.prod

@@ -0,0 +1,37 @@
+# Stage 1: Builder
+FROM node:20-alpine AS builder
+
+WORKDIR /app
+
+# Copy app source
+COPY ./services/user/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/user/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/user/README.md

@@ -0,0 +1,8 @@
+# Gnar Engine Products Service
+
+### Commands
+
+Start dev server           npm start:dev
+Start production server    npm start
+Run tests                  npm test
+Seed production            npm seed:production

package/bootstrap/services/user/package.json

@@ -0,0 +1,16 @@
+{
+    "name": "gnar_engine_user",
+    "version": "1.0.0",
+    "description": "Gnar Engine - User Service",
+    "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/user/src/app.js

@@ -0,0 +1,45 @@
+import { message, http, logger, db, registerService, webSockets } from '@gnar-engine/core';
+import { config } from './config.js';
+import { messageHandlers } from './controllers/message.controller.js';
+import { httpController as userPlatformHttpController } from './controllers/http.controller.js';
+
+
+/**
+ * Initialise service
+ */
+export const initService = async () => {
+
+	// Run migrations
+	await db.migrations.runMigrations({config});
+	db.seeders.runSeeders({config});
+
+	// Import command handlers after the command bus is initialised
+	await import('./commands/user.handler.js');
+	await import('./commands/session.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: [
+			userPlatformHttpController,
+		]
+	});
+
+	// 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 | User Service initialised successfully.');
+}
+
+initService();

package/bootstrap/services/user/src/commands/session.handler.js

@@ -0,0 +1,23 @@
+import { commands } from '@gnar-engine/core';
+import { unauthenticatedSession } from '../services/session.service.js';
+
+
+/**
+ * Create unauthenticated session token
+ * 
+ * @returns {string} Session token
+ */
+commands.register('userService.createUnauthenticatedSessionToken', async () => {
+    return unauthenticatedSession.createSessionToken();
+});
+
+/**
+ * Verify unauthenticated session token
+ * 
+ * @param {Object} params
+ * @param {string} params.sessionToken
+ * @returns {boolean} Session token valid
+ */
+commands.register('userService.verifyUnauthenticatedSessionToken', async ({sessionToken}) => {
+    return unauthenticatedSession.verifySessionToken({sessionToken});
+});

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

@@ -0,0 +1,286 @@
+import { commands, logger, error } from '@gnar-engine/core';
+import { auth } from '../services/authentication.service.js';
+import { user } from '../services/user.service.js';
+import { config } from '../config.js';
+import { validateUser, validateServiceAdminUser, validateUserUpdate, validateServiceAdminUserUpdate } from '../schema/user.schema.js';
+
+
+/**
+ * Authentication
+ * 
+ * @param {Object} params
+ * @param {string} params.email
+ * @param {string} params.password
+ * @param {string} params.apiKey
+ * @returns {Promise<Object>} The user data
+ */
+commands.register('userService.authenticate', async ({username, password, apiKey}) => {
+
+    // authenticate
+    let token = '';
+
+    if (config.authenticationOptions.password_auth_enabled) {
+        if (username && password) {
+            // verify credentials
+            const userId = await auth.verifyCredentials({
+                username: username,
+                password: password
+            });
+
+            if (!userId) {
+                throw new error.unauthorised('Invalid credentials');
+            }
+
+            // create new session token
+            token = auth.createSessionToken(userId);
+        }
+    }
+
+    if (config.authenticationOptions.api_key_auth_enabled) {
+        if (apiKey && username) {
+            // verify credentials
+            const userId = await auth.verifyApiKey({
+                apiKey: apiKey,
+                username: username
+            });
+
+            if (!userId) {
+                throw new error.unauthorised('Invalid API key');
+            }
+
+            // create new session token
+            token = auth.createSessionToken(userId);
+        }
+    }
+
+    // send response
+    if (token) {
+        logger.info('returning token ' + token);
+        return token;
+    }
+
+    logger.info('invalid credentials');
+
+    throw new error.unauthorised('Invalid credentials');
+});
+
+/**
+ * Get authenticated user
+ * 
+ * @param {Object} params
+ * @param {string} params.token - Session token
+ * @returns {Promise<Object>} The user data
+ */
+commands.register('userService.getAuthenticatedUser', async ({token}) => {
+
+    const user_id = await auth.getAuthenticatedUser(token);
+
+    if (user_id) {
+        logger.info('Auth user: ' + user_id);
+        const userObj = await user.getById({id: user_id});
+
+        if (userObj) {
+            delete userObj.password;
+            delete userObj.apiKey;
+
+            return userObj;
+        }
+    }
+
+    return;
+});
+
+
+/**
+ * Get single user
+ * 
+ * @param {Object} params
+ * @param {string|number} params.id - User ID
+ * @returns {Promise<Object>} The user data
+ */
+commands.register('userService.getSingleUser', async ({id, email}) => {
+
+    if (id) {
+        return await user.getById({id: id});
+    } else if (email) {
+        return await user.getByEmail({email: email});
+    } else {
+        throw new error.badRequest('User email or id required');
+    }
+});
+
+/**
+ * Get many users
+ * 
+ * @param {Object} params
+ * @returns {Promise<Object>} The user data
+ */
+commands.register('userService.getManyUsers', async ({}) => {
+
+    return await user.getAll();
+});
+
+/**
+ * Creat users with random password
+ * 
+ * @param {Object} params
+ * @param {Object} params.user - New user data
+ */
+commands.register('userService.createUserWithRandomPassword', async ({user}) => {
+
+    // create random password
+    const password = Math.random().toString(36);
+    const userData = {
+        ...user,
+        password: password
+    };
+
+    logger.info('creating new user : ' + JSON.stringify(userData));
+
+    // create user
+    try {
+        const newUsers = await createUsers({users: [userData]})
+
+        if (!newUsers || newUsers.length === 0) {
+            throw new error.badRequest('User creation failed');
+        }
+    
+        return newUsers[0];
+    } catch (error) {
+        throw new error.badRequest('User creation failed: ' + error);
+    }
+});
+
+/**
+ * Create users
+ * 
+ * @param {Object} params
+ * @param {Object[]} params.users - Array of new user data
+ * @returns {Promise<Array>} Array of new users
+ */
+commands.register('userService.createUsers', async ({users}) => {
+
+    const validationErrors = [];
+    let createdNewUsers = [];
+
+    // validate user data
+    for (const newUserData of users) {
+        if (!newUserData.role || newUserData.role !== 'service_admin') {
+            const { errors } = validateUser(newUserData);
+
+            if (errors?.length) {
+                validationErrors.push(errors);
+                continue;
+            }
+        } else {
+            const { errors } = validateServiceAdminUser(newUserData);
+
+            if (errors?.length) {
+                validationErrors.push(errors);
+                continue;
+            }
+        }
+
+        // ensure emails are unique
+        const existingUser = await user.getByEmail({email: newUserData.email});
+
+        if (existingUser) {
+            validationErrors.push(`User with email ${newUserData.email} already exists`);
+        }
+    }
+
+    if (validationErrors.length) {
+        throw new error.badRequest(`Invalid user data: ${validationErrors}`);
+    }
+
+    // add users
+    for (const newUserData of users) {
+        const newUser = await user.create(newUserData);
+        createdNewUsers.push(newUser);
+    }
+
+    return createdNewUsers;
+});
+
+/**
+ * Update user
+ * 
+ * @param {Object} params
+ * @param {string|number} params.id - User ID
+ * @param {Object[]} params.newUserData - New user data
+ * @returns {Promise<Array>} Array of new users
+ */
+commands.register('userService.updateUser', async ({id, newUserData}) => {
+
+    const validationErrors = [];
+
+    // check request includes user id
+    if (!id) {
+        throw new error.badRequest('User ID required');
+    }
+
+    // check user exists
+    const userObj = await user.getById({id: id});
+
+    if (!userObj) {
+        throw new error.notFound('User not found');
+    }
+    
+    // remove id from new user data
+    delete newUserData.id;
+
+    // validate user data
+    if (newUserData.role == 'service_admin') {
+        const { errors } = validateServiceAdminUserUpdate(newUserData);
+
+        if (errors?.length) {
+            validationErrors.push(errors);
+        }
+    } else {
+        const { errors } = validateUserUpdate(newUserData);
+
+        if (errors?.length) {
+            validationErrors.push(errors);
+        }
+    }
+
+    // ensure emails are unique if being updated
+    if (newUserData.email && newUserData.email !== userObj.email) {
+        const existingUser = await user.getByEmail({email: newUserData.email});
+        logger.info('Existing user with this email:' + existingUser);
+
+        if (existingUser) {
+            validationErrors.push(`User with email ${newUserData.email} already exists`);
+        }
+    }
+
+    if (validationErrors.length) {
+        throw new error.badRequest(`Invalid user data: ${validationErrors}`);
+    }
+
+    // update
+    return await user.update({
+        id: id,
+        username: newUserData.username ?? userObj.username ?? '',
+        email: newUserData.email ?? userObj.email ?? '',
+        role: newUserData.role ?? userObj.role ?? config.defaultUserRole
+    });
+});
+
+/**
+ * Delete user
+ * 
+ * @param {Object} params
+ * @param {string|number} params.id - User ID
+ * @returns {Promise<Boolean>} Success
+ */
+commands.register('userService.deleteUser', async ({id}) => {
+
+    const userObj = await user.getById({id: id});
+
+    if (!userObj) {
+        throw new error.notFound('User not found');
+    }
+
+    return await user.delete({id: id});
+});

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

@@ -0,0 +1,73 @@
+
+/**
+ * Gnar Engine Service Config
+ */
+export const config = {
+    // service name
+    serviceName: 'userService',
+
+    // 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.USER_MONGO_URL,
+        connectionArgs: {},
+
+        // MySQL
+        host: process.env.USER_MYSQL_HOST,
+        user: process.env.USER_MYSQL_USER,
+        password: process.env.USER_MYSQL_PASSWORD,
+        database: process.env.USER_MYSQL_DATABASE,
+        connectionLimit: 10,
+        queueLimit: 20,
+        maxRetries: 5
+    },
+
+    // message broker
+    message: {
+        url: process.env.RABBITMQ_URL,
+        queueName: 'userServiceQueue',
+        prefetch: 20
+    },
+
+    webSockets: {
+        reconnectInterval: 5000,
+        maxInitialConnectionAttempts: 5
+    },
+
+    // service specific config
+    userRoles: [
+        'service_admin',
+        'admin',
+        'customer'
+    ],
+
+    publicCanCreateRoles: [
+        'customer'
+    ],
+
+    defaultUserRole: 'customer',
+
+    authenticationOptions: {
+        password_auth_enabled: true,
+        api_key_auth_enabled: true
+    },
+
+    hashNameSpace: '8a07b16c-327f-45c5-9484-8d843f57bb4b',
+}