@gnar-engine/cli 1.0.0 → 1.0.2

package/bootstrap/services/user/src/controllers/http.controller.js

@@ -0,0 +1,156 @@
+import { commands } from '@gnar-engine/core';
+import { authorise } from '../policies/user.policy.js';
+
+
+/**
+ * HTTP controller
+ */
+export const httpController = {
+
+	/**
+	 * Authenticate
+	 */
+	authenticate: {
+		method: 'POST',
+		url: '/authenticate/',
+		handler: async (request, reply) => {
+			// params from request
+			const params = {
+				username: request.body.username || null,
+				password: request.body.password || null,
+				email: request.body.email || null,
+				apiKey: request.body.apiKey || null
+			};
+
+			// execute
+			const token = await commands.execute('authenticate', params);
+
+			if (!token) {
+				return reply.code(401).send({ error: 'Authentication failed' });
+			}
+
+			// Get user data using token
+			const user = await commands.execute('getAuthenticatedUser', { token });
+
+			// handle response
+			reply.code(200).send({
+				token,
+				user
+			});
+		}
+	},
+
+	/**
+	 * Get single user
+	 */
+	getSingle: {
+		method: 'GET',
+		url: '/users/:id',
+		preHandler: async (request, reply) => authorise.getSingle(request, reply),
+		handler: async (request, reply) => {
+			// params from request
+			const params = {
+				id: request.params.id
+			};
+
+			// execute
+			const user = await commands.execute('getSingleUser', params);
+
+			// handle response
+			reply.code(200).send(
+				{ user: user }
+			);
+		}
+	},
+
+	/**
+	 * Get multiple users
+	 */
+	getMany: {
+		method: 'GET',
+		url: '/users/',
+		preHandler: async (request, reply) => authorise.getMany(request, reply),
+		handler: async (request, reply) => {
+			// params from request
+			const params = {};
+
+			// execute
+			const users = await commands.execute('getManyUsers', params);
+
+			// handle response
+			reply.code(200).send(
+				{ users: users }
+			);
+		}
+	},
+
+	/**
+	 * Create new user
+	 */
+	create: {
+		method: 'POST',
+		url: '/users/',
+		preHandler: async (request, reply) => authorise.create(request, reply),
+		handler: async (request, reply) => {
+			// params from request
+			const params = {
+				users: [request.body.user]
+			};
+
+			// execute
+			const users = await commands.execute('createUsers', params);
+
+			// handle response
+			reply.code(200).send(
+				{ users: users }
+			);
+		},
+	},
+
+	/**
+	 * Update user
+	 */
+	update: {
+		method: 'POST',
+		url: '/users/:id',
+		preHandler: async (request, reply) => authorise.update(request, reply),
+		handler: async (request, reply) => {
+			// params from request
+			const params = {
+				id: request.params.id,
+				newUserData: request.body
+			};
+
+			// execute
+			const user = await commands.execute('updateUser', params);
+
+			// handle response
+			reply.code(200).send(
+				{ user: user }
+			);
+		},
+	},
+
+	/**
+	 * Delete user
+	 */
+	delete: {
+		method: 'DELETE',
+		url: '/users/:id',
+		preHandler: async (request, reply) => authorise.delete(request, reply),
+		handler: async (request, reply) => {
+			// params from request
+			const params = {
+				id: request.params.id
+			};
+
+			// execute
+			await commands.execute('deleteUser', params);
+
+			// handle response
+			reply.code(200).send(
+				{ 'message': 'User deleted' }
+			);
+		},
+	},
+}

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

@@ -0,0 +1,51 @@
+import { commands } from '@gnar-engine/core';
+
+
+export const messageHandlers = {
+
+    getAuthenticatedUser: async (payload) => {
+        console.log('getAuthenticatedUser payload:', payload);
+        const user = await commands.execute('getAuthenticatedUser', {
+            token: payload.data.token
+        });
+
+        return { user };
+    },
+
+    createUnauthenticatedSessionToken: async (payload) => {
+        const unauthenticatedSessionToken = await commands.execute('createUnauthenticatedSessionToken');
+    
+        return { unauthenticatedSessionToken };
+    },
+
+    createUserWithRandomPassword: async (payload) => {
+        const user = await commands.execute('createUserWithRandomPassword', {
+            user: payload.data.user
+        });
+
+        return { user };
+    },
+
+    getUser: async (payload) => {
+        let user;
+
+        if (payload.data?.id) {
+            user = await commands.execute('getSingleUser', {
+                id: payload.data.id
+            });
+        } else if (payload.data?.email) {
+            user = await commands.execute('getSingleUser', {
+                email: payload.data.email
+            });
+        } else {
+            throw new Error('No user ID or email provided');
+        }
+
+        if (!user) {
+            throw new Error('User not found');
+        }
+
+        return { user };
+    },
+
+};

package/bootstrap/services/user/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/user/src/db/migrations/02-user-service-init.js

@@ -0,0 +1,63 @@
+import { logger, db } from '@gnar-engine/core';
+import { config } from '../../config.js';
+
+
+/**
+ * Up
+ */
+export const up = async () => {
+    await initDatabaseTables();
+}
+
+/**
+ * Down
+ */
+export const down = async () => {
+    await dropDatabaseTables();
+}
+
+/**
+ * Create tables
+ * 
+ * @param {*} db 
+ */
+export const initDatabaseTables = async () => {
+
+    // create users table
+    logger.info('Creating users table');
+    const createUserTableQuery = `
+        CREATE TABLE users (
+            id CHAR(36) PRIMARY KEY,
+            username VARCHAR(255),
+            email VARCHAR(255) NOT NULL UNIQUE,
+            password VARCHAR(255),
+            api_key VARCHAR(255),
+            role ENUM(${config.userRoles.map(role => `'${role}'`).join(',')}) NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+        )
+    `;
+    await db.query(createUserTableQuery, [config.userRoles.join(',')]);
+
+    // create sessions table
+    logger.info('Creating sessions table');
+    const createSessionsTableQuery = `
+        CREATE TABLE sessions (
+            token VARCHAR(255) PRIMARY KEY,
+            user_id CHAR(36) NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            expires_at TIMESTAMP GENERATED ALWAYS AS (created_at + INTERVAL 1 HOUR) VIRTUAL,
+            FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+        )
+    `;
+    await db.query(createSessionsTableQuery);
+}
+
+/**
+ * Drop all tables
+ */
+export const dropDatabaseTables = async () => {
+    logger.info('Dropping tables');
+    await db.query('DROP TABLE IF EXISTS sessions');
+    await db.query('DROP TABLE IF EXISTS users');
+}

package/bootstrap/services/user/src/db/migrations/03-unauth-sessions.js

@@ -0,0 +1,43 @@
+import { logger, db } from '@gnar-engine/core';
+
+
+/**
+ * Up
+ */
+export const up = async () => {
+    await initDatabaseTables();
+}
+
+/**
+ * Down
+ */
+export const down = async () => {
+    await dropDatabaseTables();
+}
+
+/**
+ * Create tables
+ * 
+ * @param {*} db 
+ */
+export const initDatabaseTables = async () => {
+
+    // create unauth sessions table
+    logger.info('Creating sessions table');
+    const createUnauthSessionsTableQuery = `
+        CREATE TABLE unauthenticated_sessions (
+            token VARCHAR(255) PRIMARY KEY,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            expires_at TIMESTAMP GENERATED ALWAYS AS (created_at + INTERVAL 1 DAY) VIRTUAL
+        )
+    `;
+    await db.query(createUnauthSessionsTableQuery);
+}
+
+/**
+ * Drop all tables
+ */
+export const dropDatabaseTables = async () => {
+    logger.info('Dropping tables');
+    await db.query('DROP TABLE IF EXISTS unauthenticated_sessions');
+}

package/bootstrap/services/user/src/db/seeders/development/01-root-user.js

@@ -0,0 +1,29 @@
+import { logger } from '@gnar-engine/core';
+import { user } from '../../../services/user.service.js';
+
+
+/**
+ * Up seeder
+ */
+export const up = async () => {
+
+    // create root users using user service
+    const users = [];
+
+    users.push(await user.create({
+        email: process.env.USER_ROOT_ADMIN_EMAIL,
+        username: process.env.USER_ROOT_ADMIN_USERNAME,
+        password: process.env.USER_ROOT_ADMIN_PASSWORD,
+        apiKey: process.env.USER_ROOT_ADMIN_API_KEY,
+        role: 'service_admin'
+    })); 
+
+    logger.info('Completed seeding root user data ' + JSON.stringify(users));
+}
+
+/**
+ * Down seeder
+ */
+export const down = async () => {
+    logger.info('Down seeder not implemented');
+}

package/bootstrap/services/user/src/db/seeders/development/02-portal-admin-user.js

@@ -0,0 +1,27 @@
+import { logger } from '@gnar-engine/core';
+import { user } from '../../../services/user.service.js';
+
+/**
+ * Up seeder
+ */
+export const up = async () => {
+
+    // create root users using user service
+    const users = [];
+
+    users.push(await user.create({
+        email: 'alex@gnar.co.uk',
+        username: 'alexgnar',
+        password: 'gnarlybulkwash',
+        role: 'admin'
+    })); 
+
+    logger.info('Completed seeding root user data ' + JSON.stringify(users));
+}
+
+/**
+ * Down seeder
+ */
+export const down = async () => {
+    logger.info('Down seeder not implemented');
+}

package/bootstrap/services/user/src/db/seeders/production/01-root-user.js

@@ -0,0 +1,29 @@
+import { logger } from '@gnar-engine/core';
+import { user } from '../../../services/user.service.js';
+
+
+/**
+ * Up seeder
+ */
+export const up = async () => {
+
+    // create root users using user service
+    const users = [];
+
+    users.push(await user.create({
+        email: process.env.USER_ROOT_ADMIN_EMAIL,
+        username: process.env.USER_ROOT_ADMIN_USERNAME,
+        password: process.env.USER_ROOT_ADMIN_PASSWORD,
+        apiKey: process.env.USER_ROOT_ADMIN_API_KEY,
+        role: 'service_admin'
+    })); 
+
+    logger.info('Completed seeding root user data ' + JSON.stringify(users));
+}
+
+/**
+ * Down seeder
+ */
+export const down = async () => {
+    logger.info('Down seeder not implemented');
+}

package/bootstrap/services/user/src/policies/user.policy.js

@@ -0,0 +1,81 @@
+import { config } from '../config.js';
+
+
+export const authorise = {
+
+    /**
+     * Authorise get single user
+     * 
+     * @param {} request 
+     * @param {*} reply 
+     */
+    getSingle: async (request, reply) => {
+        if (!request.user) {
+            reply.code(403).send({error: 'not authorised'});
+        }
+
+        if (request.user.role !== 'service_admin' && request.user.id !== request.params.id) {
+            reply.code(403).send({error: 'not authorised'});
+        }
+    },
+
+    /**
+     * Authorise get many users
+     */
+    getMany: async (request, reply) => {
+        if (!request.user || request.user.role !== 'service_admin') {
+            reply.code(403).send({error: 'not authorised'});
+        }
+    },
+
+    /**
+     * Authorise create users
+     */
+    create: async (request, reply) => {
+        // If no role is provided check if default role is publicly creatable
+        if (request.body.user?.role && config.publicCanCreateRoles.includes(request.body.user?.role)) {
+            return;
+        }
+
+        // allow anyone to create default role or roles that don't require admin rights
+        if (config.publicCanCreateRoles.includes(config.defaultUserRole)) {
+            return;
+        }
+        
+        // only admins can create other admin users
+        if (!request.user || request.user.role !== 'service_admin') {
+            reply.code(403).send({error: 'not authorised'});
+        }
+    },
+
+    /**
+     * Authorise update user
+     */
+    update: async (request, reply) => {
+        // users can update their own user
+        if (request.user?.id === request.params.id) {
+            // ensure the user is not trying to update their role to a non-publicly creatable role
+            if (request.body?.role && !config.publicCanCreateRoles.includes(request.body?.role)) {
+                reply.code(403).send({error: 'not authorised'});
+            }
+
+            // otherwise authorised
+            return;
+        }
+
+        // only admins can update other users
+        if (!request.user || request.user.role !== 'service_admin') {
+            reply.code(403).send({error: 'not authorised'});
+        }
+    },
+
+    /**
+     * Authorise delete user
+     */
+    delete: async (request, reply) => {
+        // only admins can delete users
+        if (!request.user || request.user.role !== 'service_admin') {
+            reply.code(403).send({error: 'not authorised'});
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+import { schema } from '@gnar-engine/core';
+import { config } from '../config.js';
+
+
+// User create schema
+const userSchema = {
+    schemaName: 'userService.userSchema',
+    schema: {
+        type: 'object',
+        properties: {
+            email: { type: 'string', format: 'email' },
+            password: { type: 'string', minLength: 8 },
+            role: { type: 'string', enum: config.allowedUserRoles, default: config.defaultUserRole },
+            contactId: { type: 'string' },
+            username: { type: 'string' }
+        },
+        required: ['email', 'password'],
+        additionalProperties: false
+    }
+};
+
+// Service admin user create schema
+const serviceAdminUserSchema = {
+    schemaName: 'userService.serviceAdminUserSchema',
+    schema: {
+        type: 'object',
+        properties: {
+            email: { type: 'string', format: 'email' },
+            role: { type: 'string', enum: ['service_admin'] },
+            contactId: { type: 'string' }
+        },
+        required: ['email'],
+        additionalProperties: false
+    }
+};
+
+// User update schema
+const userUpdateSchema = {
+    schemaName: 'userService.userUpdateSchema',
+    schema: {
+        type: 'object',
+        properties: {
+            email: { type: 'string', format: 'email' },
+            role: { type: 'string', enum: config.allowedUserRoles, default: config.defaultUserRole },
+            contactId: { type: 'string' }
+        },
+        additionalProperties: false
+    }
+};
+
+// Service admin user update schema
+const serviceAdminUserUpdateSchema = {
+    schemaName: 'userService.serviceAdminUserUpdateSchema',
+    schema: {
+        type: 'object',
+        properties: {
+            email: { type: 'string', format: 'email' },
+            role: { type: 'string', enum: ['service_admin'] },
+            contactId: { type: 'string' }
+        },
+        additionalProperties: false
+    }
+};
+
+// Compile schemas
+export const validateUser = schema.compile(userSchema);
+export const validateServiceAdminUser = schema.compile(serviceAdminUserSchema);
+export const validateUserUpdate = schema.compile(userUpdateSchema);
+export const validateServiceAdminUserUpdate = schema.compile(serviceAdminUserUpdateSchema);