@gnar-engine/cli 1.0.5 → 1.0.6

package/src/scaffolder/scaffolder.handler.js

@@ -3,7 +3,7 @@ import fs from 'fs';
 import yaml from 'js-yaml';
 import { profiles } from '../profiles/profiles.client.js';
 import { helpers } from '../helpers/helpers.js';
-import { directories } from '../cli.js';
+import { directories } from '../config.js';
 import Handlebars from 'handlebars';
 
 
@@ -36,67 +36,21 @@ export const scaffolder = {
 
         // Get all files in the templates directory
         const templateFiles = scaffolder.getAllTemplateFiles({
-            dir: directories.scaffolderTemplates,
-            baseDir: directories.scaffolderTemplates
+            dir: directories.scaffolderServiceTemplates,
+            baseDir: directories.scaffolderServiceTemplates
         }); 
 
-        // Register Handlebars helpers
-        Object.entries(helpers).forEach(([name, fn]) => {
-            Handlebars.registerHelper(name, fn);
-        });
-
-        // Write the files to the service directory
-        templateFiles.forEach(file => {
-            let sourcePath;
-            let targetPath;
-            const templateArgs = {
-                serviceName,
-                database
-            };
-
-            let fileRelativePath = file.relativePath;
-
-            // Database specific
-            if (fileRelativePath.includes('mongodb.')) {
-                if (database !== 'mongodb') {
-                    return;
-                } else {
-                    fileRelativePath = fileRelativePath.replace('mongodb.', '');
-                }
-            }
-
-            if (fileRelativePath.includes('mysql.')) {
-                if (database !== 'mysql') {
-                    return;
-                } else {
-                    fileRelativePath = fileRelativePath.replace('mysql.', '');
-                }
-            }
+        // scaffold the hbs templates
+        const templateArgs = {
+            serviceName,
+            database
+        };
 
-            switch (file.extension) {
-                case '.hbs':
-                    // Compile the Handlebars template for content
-                    const templateContent = fs.readFileSync(file.fullPath, 'utf8');
-                    const compiledTemplate = Handlebars.compile(templateContent);
-                    const renderedContent = compiledTemplate(templateArgs);
-
-                    // Compile the Handlebars template for the filename (excluding .hbs)
-                    const filenameTemplate = Handlebars.compile(fileRelativePath.replace(/\.hbs$/, ''));
-                    const renderedFilename = filenameTemplate(templateArgs);
-                    targetPath = path.join(serviceDir, renderedFilename);
-
-                    // Ensure directory exists
-                    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-                    fs.writeFileSync(targetPath, renderedContent, 'utf8');
-                    break;
-                default:
-                    // By default, copy the file to the service directory
-                    sourcePath = file.fullPath;
-                    targetPath = path.join(serviceDir, fileRelativePath);
-                    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-                    fs.copyFileSync(sourcePath, targetPath);
-                    break;
-            }
+        scaffolder.scaffoldHandlebarTemplates({
+            templateFiles: templateFiles,
+            serviceDir: serviceDir,
+            database: database,
+            templateArgs: templateArgs
         });
 
         // Scaffold deploy.yml
@@ -173,8 +127,10 @@ export const scaffolder = {
 
         entries.forEach(entry => {
             const fullPath = path.join(dir, entry.name);
+            // if the full path contains src, the 'data' directory can be included
+            const includeDataDir = fullPath.includes(`${path.sep}src${path.sep}`) && fullPath.includes('data') ? true : false;
             if (entry.isDirectory()) {
-                if (entry.name !== 'node_modules' && entry.name !== 'data') {
+                if (entry.name !== 'node_modules' && (entry.name !== 'data' || includeDataDir)) {
                     if (!entry.name.startsWith('.') || entry.name == '.gnarengine') {
                         scaffolder.getAllTemplateFiles({
                             dir: fullPath,
@@ -446,5 +402,116 @@ export const scaffolder = {
         // write deploy.yml file
         const deployYmlContent = yaml.dump(deploy);
         fs.writeFileSync(deployPath, deployYmlContent, 'utf8');
+    },
+
+    /**
+     * Create new entity in existing service
+     * 
+     * @param {object} param
+     * @param {string} param.entityName - The name of the entity to create
+     * @param {string} param.inService - The service in which to add the entity
+     * @param {string} param.serviceDir - The service directory where the entity will be created
+     * @param {string} param.database - The database type (e.g., 'mysql', 'mongodb')
+     * @returns {object} - An object containing a success message
+     */
+    createNewEntity: ({ entityName, inService, serviceDir, database }) => {
+
+        entityName = entityName.toLowerCase();
+
+        // validate serviceDir exists
+        if (!fs.existsSync(serviceDir)) {
+            throw new Error(`Service directory "${serviceDir}" does not exist`);
+        }
+
+        // Get all files in the templates directory
+        const templateFiles = scaffolder.getAllTemplateFiles({
+            dir: directories.scaffolderEntityTemplates,
+            baseDir: directories.scaffolderEntityTemplates
+        });
+
+        // scaffold the hbs templates
+        const templateArgs = {
+            entityName: entityName,
+            serviceName: inService,
+            database: database
+        };
+
+        scaffolder.scaffoldHandlebarTemplates({
+            templateFiles: templateFiles,
+            serviceDir: serviceDir,
+            database: database,
+            templateArgs: templateArgs
+        });
+    },
+
+    /**
+     * Scaffold handlebar templates
+     *
+     * @param {object} param
+     * @param {string} param.templateFiles - The list of template files
+     * @param {string} param.serviceDir - The service directory
+     * @param {string} param.serviceName - The service name
+     * @param {string} param.database - The database type
+     * @param {object} param.templateArgs - The template arguments
+     */
+    scaffoldHandlebarTemplates: function ({ templateFiles, serviceDir, serviceName, database, templateArgs }) {
+        try {
+            // Register Handlebars helpers
+            Object.entries(helpers).forEach(([name, fn]) => {
+                Handlebars.registerHelper(name, fn);
+            });
+
+            // Write the files to the service directory
+            templateFiles.forEach(file => {
+                let sourcePath;
+                let targetPath;
+
+                let fileRelativePath = file.relativePath;
+
+                // Database specific
+                if (fileRelativePath.includes('mongodb.')) {
+                    if (database !== 'mongodb') {
+                        return;
+                    } else {
+                        fileRelativePath = fileRelativePath.replace('mongodb.', '');
+                    }
+                }
+
+                if (fileRelativePath.includes('mysql.')) {
+                    if (database !== 'mysql') {
+                        return;
+                    } else {
+                        fileRelativePath = fileRelativePath.replace('mysql.', '');
+                    }
+                }
+
+                switch (file.extension) {
+                    case '.hbs':
+                        // Compile the Handlebars template for content
+                        const templateContent = fs.readFileSync(file.fullPath, 'utf8');
+                        const compiledTemplate = Handlebars.compile(templateContent);
+                        const renderedContent = compiledTemplate(templateArgs);
+
+                        // Compile the Handlebars template for the filename (excluding .hbs)
+                        const filenameTemplate = Handlebars.compile(fileRelativePath.replace(/\.hbs$/, ''));
+                        const renderedFilename = filenameTemplate(templateArgs);
+                        targetPath = path.join(serviceDir, renderedFilename);
+
+                        // Ensure directory exists
+                        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+                        fs.writeFileSync(targetPath, renderedContent, 'utf8');
+                        break;
+                    default:
+                        // By default, copy the file to the service directory
+                        sourcePath = file.fullPath;
+                        targetPath = path.join(serviceDir, fileRelativePath);
+                        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+                        fs.copyFileSync(sourcePath, targetPath);
+                        break;
+                }
+            });
+        } catch (error) {
+            throw new Error('Error scaffolding Handlebars templates: ' + error.message);
+        }
     }
 }

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/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
-}