@gnar-engine/cli 1.0.5 → 1.0.7

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/src/services/docker.js

@@ -0,0 +1,173 @@
+import Docker from 'dockerode';
+import { Writable } from 'stream';
+import path from 'path';
+import fs from 'fs';
+
+const docker = new Docker();
+
+/**
+ * Build Docker image
+ *
+ * @param {Object} options
+ * @param {string} options.context - The build context directory
+ * @param {string} options.dockerfile - The Dockerfile path relative to the context
+ * @param {string} options.imageTag - The tag to assign to the built image
+ */
+export async function buildImage({ context, dockerfile, imageTag }) {
+
+    console.log('Building image...', imageTag);
+
+    const tarStream = await docker.buildImage(
+        {
+            context: context,
+            src: fs.readdirSync(context)
+        },
+        {
+            t: imageTag,
+            dockerfile
+        }
+    );
+
+    await new Promise((resolve, reject) => {
+        docker.modem.followProgress(tarStream, (err) => (err ? reject(err) : resolve()));
+    });
+
+    console.log('Built image:', imageTag);
+}
+
+/**
+ * Create docker container
+ *
+ * @param {Object} options
+ * @param {string} options.name - Container name
+ * @param {string} options.image - Docker image to use
+ * @param {Array} [options.command] - Command to run in the container
+ * @param {Object} [options.env] - Environment variables
+ * @param {Object} [options.ports] - Port mappings (containerPort: hostPort)
+ * @param {Array} [options.binds] - Volume bindings
+ * @param {string} [options.restart] - Restart policy
+ * @param {boolean} [options.attach] - Whether to attach to container output
+ * @param {string} [options.network] - Network name
+ * @returns {Promise<Docker.Container>} - The started container
+ */
+export async function createContainer({ name, image, command = [], env = {}, ports = {}, binds = [], restart = 'always', attach = true, network, aliases = [] }) {
+
+    // remove container first
+    try {
+        const existingContainer = docker.getContainer(name);
+        await existingContainer.inspect();
+        await existingContainer.remove({ force: true });
+    } catch (err) {
+        // Container does not exist, ignore
+    }
+
+    // create container
+    const containerConfig = {
+        name,
+        Image: image,
+        Cmd: command,
+        Env: Object.entries(env).map(([k, v]) => `${k}=${v}`),
+        HostConfig: {
+            RestartPolicy: { Name: restart },
+            Binds: binds,
+            PortBindings: Object.fromEntries(
+                Object.entries(ports).map(([cPort, hPort]) => [
+                    `${cPort}/tcp`,
+                    [{ HostPort: String(hPort) }]
+                ])
+            ),
+        },
+        ExposedPorts: Object.fromEntries(
+            Object.keys(ports).map(p => [`${p}/tcp`, {}])
+        )
+    };
+
+    const container = await docker.createContainer(containerConfig);
+
+    // Attach logs before starting the container
+    if (attach) {
+        const stream = await container.attach({ stream: true, stdout: true, stderr: true, logs: true });
+        const stdoutStream = createPrefixStream(name, process.stdout);
+        const stderrStream = createPrefixStream(name, process.stderr);
+
+        container.modem.demuxStream(stream, stdoutStream, stderrStream);
+    }
+
+    await docker.getNetwork(network).connect({
+        Container: container.id,
+        EndpointConfig: {
+            Aliases: aliases
+        }
+    });
+
+    return container;
+}
+
+/**
+ * Create network
+ *
+ * @param {String} name - Network name
+ */
+export async function createBridgeNetwork({ name }) {
+    try {
+        await docker.createNetwork({
+            Name: name,
+            Driver: 'bridge',
+            CheckDuplicate: true
+        });
+    } catch (err) {
+        if (err.statusCode === 409) {
+            // network already exists, ignore
+            return;
+        }
+        console.error(err);
+    }
+}
+
+/**
+ * Tansform stream
+ *
+ * @param {String} name - Container name
+ * @returns {Transform} - Transform stream
+ */
+function createPrefixStream(name, targetStream) {
+    const color = colorForName(name);
+    const labelWidth = 38;
+    name = '[' + name + ']';
+    const paddedName = name.padEnd(labelWidth, ' ');
+
+    return new Writable({
+        write(chunk, encoding, callback) {
+            const lines = chunk.toString().split(/\r?\n/);
+            for (const line of lines) {
+                if (line.trim()) {
+                    targetStream.write(`${color}${paddedName}${RESET} ${line}\n`);
+                }
+            }
+            callback();
+        }
+    });
+}
+
+/**
+ * Colours for container name
+ */
+const COLORS = [
+    '\x1b[31m', // red
+    '\x1b[32m', // green
+    '\x1b[33m', // yellow
+    '\x1b[34m', // blue
+    '\x1b[35m', // magenta
+    '\x1b[36m', // cyan
+    '\x1b[37m', // white
+];
+
+const RESET = '\x1b[0m';
+
+function colorForName(name) {
+    let hash = 0;
+    for (let i = 0; i < name.length; i++) {
+        hash = name.charCodeAt(i) + ((hash << 5) - hash);
+    }
+    return COLORS[Math.abs(hash) % COLORS.length];
+}

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);