@gnar-engine/cli 1.0.0 → 1.0.1

package/src/scaffolder/scaffolder.handler.js

@@ -0,0 +1,252 @@
+import path from 'path';
+import fs from 'fs';
+import yaml from 'js-yaml';
+import { profiles } from '../profiles/profiles.client.js';
+import { helpers } from '../helpers/helpers.js';
+import Handlebars from 'handlebars';
+
+/**
+ * Gnar Engine Scaffolder
+ */
+export const scaffolder = {
+
+    /**
+     * Create a new service
+     * 
+     * @param {object} param
+     * @param {string} param.serviceName - The name of the service to create
+     * @param {string} param.database - The database type (e.g., 'mysql', 'mongodb')
+     * @param {string} param.projectDir - The project directory where the service will be created 
+     * @returns {object} - An object containing a success message and the service path
+     */
+    createNewService: function ({serviceName, database, projectDir}) {
+        const serviceDir = projectDir + 'services/' + serviceName;
+        console.log('Service directory:', serviceDir);
+
+        // Check if the service directory already exists
+        if (fs.existsSync(serviceDir)) {
+            throw new Error(`Service "${serviceName}" already exists at ${serviceDir}`);
+        }
+
+        // Create the service directory
+        fs.mkdirSync(serviceDir, { recursive: true });
+
+        // Get all files in the templates directory
+        const templatesDir = path.join(import.meta.dirname, '../../templates/service');
+        const templateFiles = scaffolder.getAllTemplateFiles({
+            dir: templatesDir,
+            baseDir: templatesDir
+        }); 
+
+        console.log('Template files:', templateFiles);
+
+        // 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
+                };
+
+                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(file.relativePath.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, file.relativePath);
+                        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+                        fs.copyFileSync(sourcePath, targetPath);
+                        break;
+                }
+            });
+
+        return {
+            message: `Service "${serviceName}" created successfully at ${serviceDir}`,
+            servicePath: serviceDir
+        };
+    },
+
+    /**
+     * Create new front-end service
+     * 
+     * @param {object} param
+     * @param {string} param.serviceName - The name of the service to create
+     * @param {string} param.projectDir - The project directory where the service will be created 
+     * @returns {object} - An object containing a success message and the service path
+     */
+    createNewFrontEndService: function ({serviceName, projectDir}) {
+        const serviceDir = projectDir + 'services/' + serviceName;
+        console.log('Service directory:', serviceDir);
+
+        // Check if the service directory already exists
+        if (fs.existsSync(serviceDir)) {
+            throw new Error(`Service "${serviceName}" already exists at ${serviceDir}`);
+        }
+
+        // Create the service directory
+        fs.mkdirSync(serviceDir, { recursive: true });
+    },
+
+    /**
+     * Recursively get all template files in a directory
+     * 
+     * @param {object} params
+     * @param {string} params.dir - The directory to search for template files
+     * @param {string} [params.baseDir=dir] - The base directory for relative paths
+     * @param {Array} [params.fileList=[]] - The list to store found files
+     * @returns {Array} - An array of objects containing full and relative paths of template files
+     */
+    getAllTemplateFiles: function ({dir, baseDir = dir, fileList = []}) {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+        entries.forEach(entry => {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name !== 'node_modules' && entry.name !== 'data') {
+                    if (!entry.name.startsWith('.') || entry.name == '.gnarengine') {
+                        scaffolder.getAllTemplateFiles({
+                            dir: fullPath,
+                            baseDir,
+                            fileList
+                        });
+                    }
+                }
+            } else {
+                const relativePath = path.relative(baseDir, fullPath);
+
+                if (entry.name !== 'docker-compose.dev.yml') {
+                    fileList.push({ fullPath, relativePath, extension: path.extname(entry.name) });
+                }
+            }
+        });
+
+        return fileList;
+    },
+
+    /**
+     * Create a new project
+     * 
+     * @param {object} param 
+     * @param {string} param.projectName - The name of the project to create
+     * @param {string} param.projectDir - The directory where the project will be created
+     * @param {string} param.rootAdminEmail - The email for the root admin user
+     */
+    createNewProject: function ({projectName, projectDir, rootAdminEmail}) {
+        projectName = projectName.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9\-]/g, '');
+
+        const fullProjectPath = path.join(projectDir, projectName);
+        console.log('Creating project in:', fullProjectPath);
+
+        // Check to make sure there isn't already a profile with this project name
+        const profileName = projectName + ':local';
+        const allProfiles = profiles.getAllProfiles();
+
+        if (allProfiles && allProfiles.profiles) {
+            if (allProfiles.profiles[profileName]) {
+                throw new Error(`A profile with the name "${projectName}:local" already exists. Please choose a different project name or delete the existing profile.`);
+            }
+        }
+
+        // Create the project directory
+        if (!fs.existsSync(fullProjectPath)) {
+            fs.mkdirSync(fullProjectPath, { recursive: true });
+            fs.mkdirSync(path.join(fullProjectPath, 'data'), { recursive: true });
+        }
+
+        // Copy bootstrap
+        const bootstrapDir = path.join(import.meta.dirname, '../../bootstrap');
+        const bootstrapFiles = scaffolder.getAllTemplateFiles({
+            dir: path.join(bootstrapDir),
+            baseDir: path.join(bootstrapDir)
+        });
+
+        let cliApiKey = '';
+
+        console.log('Copying bootstrap');
+        
+        if (!bootstrapFiles || bootstrapFiles.length === 0) {
+            throw new Error('No bootstrap files found');
+        }
+
+        bootstrapFiles.forEach(file => {
+            let sourcePath;
+            let targetPath;
+
+            sourcePath = file.fullPath;
+            targetPath = path.join(fullProjectPath, file.relativePath);
+
+            // create random secrets
+            if (file.relativePath === 'secrets.localdev.yml') {
+                console.log('Creating random secrets: secrets.localdev.yml');
+                const secretsPath = path.join(bootstrapDir, 'secrets.localdev.yml');
+                const rawSecrets = fs.readFileSync(secretsPath, 'utf8');
+                const parsedSecrets = yaml.load(rawSecrets);
+
+                // generate random passwords
+                Object.keys(parsedSecrets.services).forEach(serviceName => {
+                    Object.keys(parsedSecrets.services[serviceName]).forEach(key => {
+                        if (key.toLowerCase().includes('pass')) {
+                            parsedSecrets.services[serviceName][key] = helpers.generateRandomString(16);
+                        }
+                    });
+                });
+
+                // set random root api key
+                cliApiKey = helpers.generateRandomString(32);
+                parsedSecrets.services.user.ROOT_ADMIN_API_KEY = cliApiKey;
+                parsedSecrets.services.user.ROOT_ADMIN_EMAIL = rootAdminEmail || 'admin@' + projectName + '.local';
+
+                // save updated secrets file
+                const newSecretsContent = yaml.dump(parsedSecrets);
+                fs.writeFileSync(secretsPath, newSecretsContent, 'utf8');
+            }
+
+            fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+            fs.copyFileSync(sourcePath, targetPath);
+        });
+
+        // Create the profile
+        console.log('Creating new CLI profile: ' + profileName);
+        const config = {
+            CLI_API_URL: 'http://localhost',
+            CLI_API_USERNAME: 'gnarlyroot',
+            CLI_API_KEY: cliApiKey,
+            PROJECT_DIR: fullProjectPath
+        };
+        
+        // save profile to config file
+        profiles.createProfile({ 
+            profileName: profileName,
+            config: config
+        });
+
+        // set active profile if required
+        console.log('Setting CLI profile to active');
+        profiles.setActiveProfile({
+            profileName: profileName
+        });
+
+        console.log('g n a r  e n g i n e - Created new project: ' + projectName);
+        console.log('Run `gnar dev up` to start the development server');
+    }
+}

package/src/services/client.js

@@ -0,0 +1,174 @@
+import axios from 'axios';
+import { profiles } from '../profiles/profiles.client.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+let client;
+let profile;
+let profileName;
+let baseApiUrl;
+let authToken;
+let username;
+let apiKey;
+
+/**
+ * Initialise the profile
+ */
+export const initAxiosClient = () => {
+    // Determine the correct API URL based on the environment
+    try {
+        profile = profiles.getActiveProfile();
+        baseApiUrl = profile.profile.CLI_API_URL;
+        username = profile.profile.CLI_API_USERNAME;
+        apiKey = profile.profile.CLI_API_KEY;
+        profileName = profile.name;
+
+        console.log('Profile: ' + profile.name + ' | ' + baseApiUrl);
+
+    } catch (error) {
+        console.error('Error retrieving active profile:', error.message);
+        throw new Error('Active profile not found. Please set an active profile using `gnar profile set-active <profileName>`');
+    }
+
+    // Create axios client
+    client = axios.create({
+        baseURL: baseApiUrl,
+        withCredentials: true,
+    });
+
+    // Request interceptors
+    client.interceptors.request.use(
+        async (config) => {
+
+            // Return pre-existing acces token if we have one
+            try {
+                authToken = await getAccessToken({activeProfileName: profileName});
+
+                if (authToken) {
+                    config.headers['Authorization'] = `Bearer ${authToken}`;
+                }
+
+                return config;
+            } catch (error) {
+                //console.log('No access token found, authenticating...');
+            }
+
+            // Authenticate if no token is found
+            try {
+                const authResponse = await axios.post(`${baseApiUrl}/authenticate/`, {
+                    username: username,
+                    apiKey: apiKey
+                });          
+
+                if (!authResponse.data?.token) {
+                    throw new Error('Authentication failed', authResponse.data?.error || 'No token received');
+                }
+
+                authToken = authResponse.data.token;
+
+                setAccessToken({
+                    activeProfileName: profileName,
+                    accessToken: authToken,
+                    accessTokenExpires: new Date(Date.now() + 3600000).toISOString()
+                });
+
+                if (authToken) {
+                    config.headers['Authorization'] = `Bearer ${authToken}`;
+                }
+
+                return config;
+            } catch (error) {
+                console.error('Authentication failed:', error.response?.data?.message || error.message);
+                throw error;
+            }
+        },
+        (error) => {
+            return Promise.reject(error);
+        }
+    );
+}
+
+
+export default client;
+
+
+/**
+ * Get data resource
+ */
+export const getDataResource = async (resourceSlug) => {
+    try {
+        const response = await client.get(`/data/${resourceSlug}`);
+        return response.data;
+    } catch (error) {
+        throw error;
+    }
+}
+
+/**
+ * Get access token
+ * 
+ * @param {Object} options - Options for getting the access token
+ * @param {string} options.activeProfileName - The name of the active profile
+ * @returns {Promise<string>} - The access token
+ * @throws {Error} - If the access token is not found or has expired
+ */
+export const getAccessToken = async ({activeProfileName}) => {
+
+    let accessToken = null;
+    let accessTokenExpires = null;
+
+    try {
+        const profileCachePath = path.join(os.homedir(), '.gnarengine', activeProfileName + '.json');
+        const profileCache = JSON.parse(fs.readFileSync(profileCachePath, 'utf-8'));
+        accessToken = profileCache.accessToken;
+        accessTokenExpires = profileCache.accessTokenExpires;
+
+        if (!accessToken || !accessTokenExpires) {
+            throw new Error('Access token or expiration not found in cache');
+        }
+
+        if (new Date(accessTokenExpires) < new Date()) {
+            throw new Error('Access token has expired');
+        }
+    } catch (error) {
+        throw error;
+    }
+
+    return accessToken;
+}
+
+/**
+ * Set access token
+ * 
+ * @param {Object} options - Options for setting the access token
+ * @param {string} options.activeProfileName - The name of the active profile
+ * @param {string} options.accessToken - The access token to set
+ * @param {Date} options.accessTokenExpires - The expiration date of the access token
+ * @returns {Promise<void>}
+ * @throws {Error} - If unable to write to the profile cache file
+ */
+export const setAccessToken = async ({activeProfileName, accessToken, accessTokenExpires}) => {
+    try {
+        let profileCache = {};
+
+        const profileCachePath = path.join(os.homedir(), '.gnarengine', activeProfileName + '.json');
+
+        if (fs.existsSync(profileCachePath)) {
+            try {
+                profileCache = JSON.parse(fs.readFileSync(profileCachePath, 'utf-8'));
+            } catch (error) {
+
+            }
+        } else {
+            fs.mkdirSync(path.dirname(profileCachePath), { recursive: true });
+        }
+
+        profileCache.accessToken = accessToken;
+        profileCache.accessTokenExpires = accessTokenExpires;
+
+        fs.writeFileSync(profileCachePath, JSON.stringify(profileCache, null, 2));
+    } catch (error) {
+        throw new Error('Unable to write to profile cache file: ' + error.message);
+    }
+}

package/templates/service/Dockerfile.hbs

@@ -0,0 +1,20 @@
+# Dockerfile for {{pascalCase serviceName}} Service
+FROM gnarengine/service-core:1.0.0
+
+# Set the working directory
+WORKDIR /usr/gnar_engine/app
+
+# Copy package.json and package-lock.json
+COPY ./services/{{serviceName}}/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/templates/service/app.js.hbs

@@ -0,0 +1,38 @@
+import { message, http, logger, db } from '@gnar-engine/core';
+import { config } from './config.js';
+import { messageHandlers } from './controllers/message.controller.js';
+import { httpController as {{pascalCase serviceName}}PlatformHttpController } from './controllers/http.controller.js';
+
+/**
+ * Initialise service
+ */
+export const initService = async () => {
+
+	// Run migrations
+	db.migrations.runMigrations({config});
+	db.seeders.runSeeders({config});
+
+	// Import command handlers after the command bus is initialised
+	await import('./commands/{{lowerCasePlural serviceName}}.handler.js');
+	// Add more handlers as needed
+
+	// Initialise and register message handlers
+	await message.init({
+		config: config.message,
+		handlers: messageHandlers
+	});
+
+	// Register http routes
+	await http.registerRoutes({
+		controllers: [
+			{{pascalCase serviceName}}PlatformHttpController,
+		]
+	});
+
+	// Start the HTTP server
+	await http.start();
+
+	logger.info('G n a r  E n g i n e | {{capitaliseFirstLetter serviceName}} Service initialised successfully.');
+}
+
+initService();

package/templates/service/commands/{{serviceName}}.handler.js.hbs

@@ -0,0 +1,97 @@
+import { commands, logger, error } from '@gnar-engine/core';
+import { auth } from '../services/authentication.service.js';
+import { {{serviceName}} } from '../services/{{serviceName}}.service.js';
+import { config } from '../config.js';
+import { validate{{pascalCase serviceName}}, validateServiceAdmin{{pascalCase serviceName}}, validate{{pascalCase serviceName}}Update, validateServiceAdmin{{pascalCase serviceName}}Update } from '../schema/{{serviceName}}.schema.js';
+
+
+/**
+ * Get single {{serviceName}}
+ */
+commands.register('{{serviceName}}Service.getSingle{{pascalCase serviceName}}', async ({id}) => {
+    if (id) {
+        return await {{serviceName}}.getById({id: id});
+    } else {
+        throw new error.badRequest('{{pascalCase serviceName}} email or id required');
+    }
+});
+
+/**
+ * Get many {{lowerCasePlural serviceName}}
+ */
+commands.register('{{serviceName}}Service.getMany{{pascalCasePlural serviceName}}', async ({}) => {
+    return await {{serviceName}}.getAll();
+});
+
+/**
+ * Create {{lowerCasePlural serviceName}}
+ */
+commands.register('{{serviceName}}Service.create{{pascalCasePlural serviceName}}', async ({ {{lowerCasePlural serviceName}} }) => {
+    const validationErrors = [];
+    let createdNew{{pascalCasePlural serviceName}} = [];
+
+    for (const newData of {{lowerCasePlural serviceName}}) {
+        const { errors } = validate{{pascalCase serviceName}}(newData);
+        if (errors?.length) {
+            validationErrors.push(errors);
+            continue;
+        }
+
+        const created = await {{serviceName}}.create(newData);
+        createdNew{{pascalCasePlural serviceName}}.push(created);
+    }
+
+    if (validationErrors.length) {
+        throw new error.badRequest(`Invalid {{serviceName}} data: ${validationErrors}`);
+    }
+
+    return createdNew{{pascalCasePlural serviceName}};
+});
+
+/**
+ * Update {{serviceName}}
+ */
+commands.register('{{serviceName}}Service.update{{pascalCase serviceName}}', async ({id, new{{pascalCase serviceName}}Data}) => {
+    
+    const validationErrors = [];
+    
+    if (!id) {
+        throw new error.badRequest('{{pascalCase serviceName}} ID required');
+    
+    }
+    
+    const obj = await {{serviceName}}.getById({id: id});
+    
+    if (!obj) {
+        throw new error.notFound('{{pascalCase serviceName}} not found');
+    
+    }
+    
+    delete new{{pascalCase serviceName}}Data.id;
+    
+    const { errors } = validate{{pascalCase serviceName}}Update(new{{pascalCase serviceName}}Data);
+    
+    if (errors?.length) {
+        validationErrors.push(errors);
+    }
+    
+    if (validationErrors.length) {
+        throw new error.badRequest(`Invalid {{serviceName}} data: ${validationErrors}`);
+    }
+    
+    return await {{serviceName}}.update({
+        id: id,
+        ...new{{pascalCase serviceName}}Data
+    });
+});
+
+/**
+ * Delete {{serviceName}}
+ */
+commands.register('{{serviceName}}Service.delete{{pascalCase serviceName}}', async ({id}) => {
+    const obj = await {{serviceName}}.getById({id: id});
+    if (!obj) {
+        throw new error.notFound('{{pascalCase serviceName}} not found');
+    }
+    return await {{serviceName}}.delete({id: id});
+});

package/templates/service/config.js.hbs

@@ -0,0 +1,48 @@
+/**
+ * Gnar Engine Service Config
+ */
+export const config = {
+    // service name
+    serviceName: '{{serviceName}}Service',
+
+    // 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.{{upperCase serviceName}}_MONGO_URL,
+        connectionArgs: {},
+
+        // MySQL
+        host: process.env.{{upperCase serviceName}}_MYSQL_HOST,
+        user: process.env.{{upperCase serviceName}}_MYSQL_USER,
+        password: process.env.{{upperCase serviceName}}_MYSQL_PASSWORD,
+        database: process.env.{{upperCase serviceName}}_MYSQL_DATABASE,
+        connectionLimit: 10,
+        queueLimit: 20,
+        maxRetries: 5
+    },
+
+    // message broker
+    message: {
+        queueName: '{{serviceName}}ServiceQueue',
+        prefetch: 20
+    },
+
+    hashNameSpace: '{{uuid}}',
+}