@gnar-engine/cli 1.0.0 → 1.0.2

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

@@ -0,0 +1,231 @@
+import { commands, logger, message, db } from '@gnar-engine/core';
+import { registry } from "../services/registry.service.js";
+import { task } from "../services/task.service.js";
+import { reset } from "../services/reset.service.js";
+
+
+/**
+ * Run migrations
+ * 
+ * @param {Object} params
+ * @param {string} params.service The service name
+ * @param {string} params.migration The migration name
+ * @returns {Promise<void>}
+ */
+commands.register('controlService.runMigrations', async ({service, migration}) => {
+    let response;
+
+    // run single migration
+    if (service && migration) {
+        logger.info(`Running migration: ${migration} for service: ${service}`);
+
+        const payload = {
+            method: 'runMigrations',
+            data: {
+                migration: migration
+            }
+        };
+
+        // send message to service queue
+        try {
+            response = await message.sendAndForget(service.name, payload);
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    // run all migrations for service
+    else if (service) {
+        logger.info(`Running migrations for service: ${service}`);
+
+        if (service == 'controlService') {
+            try {
+                await migrations.runMigrations();
+                return;
+            } catch (error) {
+                throw error;
+            }
+        }
+
+        const payload = {
+            method: 'runMigrations',
+        };
+
+        // send message to service queue
+        try {
+            response = await message.sendAndForget(service.name, payload);
+        } catch (error) {
+            throw error;
+        }
+    }
+
+    // run all migrations
+    else {
+        // get registered services
+        const services = await registry.getServices();
+
+        logger.info(`Running migrations for services: ${JSON.stringify(services)}`);
+
+        // run migrations for each service
+        const migrationPromises = services.map(async (service) => {
+            const payload = { 
+                method: 'runMigrations'
+            };
+
+            try {
+                return await message.sendAndForget(service.name, payload);
+            } catch (error) {
+                throw error;
+            }
+        });
+
+        const responses = await Promise.all(migrationPromises);
+    }
+
+    return response;
+})
+
+/**
+ * Run seeders
+ * 
+ * @param {Object} params
+ * @param {string} params.service The service name
+ * @returns {Promise<void>}
+ */
+commands.register('controlService.runSeeders', async ({service}) => {
+    let response;
+
+    // run seeders for service
+    if (service) {
+        logger.info(`Running seeders for service: ${service}`);
+
+        const payload = {
+            method: 'runSeeders',
+        };
+
+        // send message to service queue
+        try {
+            response = await message.sendAndForget(service.name, payload);
+        } catch (error) {
+            throw error
+        }
+    }
+
+    // run seeders for all services
+    else {
+        // get registered services
+        const services = await registry.getServices();
+
+        logger.info(`Running seeders for services: ${JSON.stringify(services)}`);
+
+        // run seeders for each service
+        for (const service of services) {
+            const payload = {
+                method: 'runSeeders',
+            };
+
+            // send message to service queue
+            try {
+                response = await message.sendAndForget(service.name, payload);
+            } catch (error) {
+                throw error
+            }
+        }
+    }
+
+    return response;
+})
+
+/**
+ * Run full database reset (centrally)
+ */
+commands.register('controlService.runReset', async () => {
+
+    if (process.env.NODE_ENV !== 'development') {
+        throw new Error("Reset is only allowed in development environment");
+    }
+
+    // delete all mongodb collections
+    try {
+        await reset.dropMongoCollections();
+    } catch (error) {
+        logger.error("Error resetting MongoDB: " + error);
+    }
+
+    // delete all mysql databases
+    try {
+        await reset.dropMysqlDatabases();
+    } catch (error) {
+        logger.error("Error resetting MYSQL: " + error);
+    }
+})
+
+/**
+ * Run health check
+ * ----------------
+ * 
+ * Checks services are available and subscribed to RabbitMQ
+ */
+commands.register('controlService.runHealthcheck', async () => {
+
+    const services = [
+        'userService',
+        'contactService',
+        'productService',
+        'cartService',
+        'orderService',
+        'subscriptionService',
+        'checkoutService'
+    ]
+
+    const results = await Promise.all(
+        services.map(async (service) => {
+            try {
+                const result = await message.sendAwaitResponse(service, {
+                    method: 'healthCheck'
+                });
+                return { service, result };
+            } catch (error) {
+                return {
+                    service,
+                    error: `Error checking health of ${service}: ${error}`
+                };
+            }
+        })
+    );
+
+    const errors = results
+        .filter(r => r.error)
+        .map(r => r.error);
+
+    // Check for failed tasks
+    const failedTasks = await task.getTasksByStatus({
+        status: 'failed'
+    });
+
+    if (failedTasks.length > 0) {
+        errors.push(`${failedTasks.length} failed tasks`);
+    }
+
+    // Aggregate errors
+    if (errors.length > 0) {
+        throw new error.failedHealthCheck(JSON.stringify(errors));
+    }
+
+    logger.info('Health check passed');
+    return;
+})
+
+/**
+ * Internal health check (kills process if it fails)
+ */
+commands.register('controlService.internalHealthCheck', async () => {
+
+    // ensure db connection
+    try {
+        await db.checkConnection();
+    } catch (err) {
+        logger.error('[Internal health check] Failed - Exiting. Error connecting to MYSQL: ' + err);
+        process.exit(1);
+    }
+})

package/bootstrap/services/control/src/commands/service.handler.js

@@ -0,0 +1,81 @@
+import { commands, logger } from '@gnar-engine/core';
+import { registry } from '../services/registry.service.js';
+import { validateService } from '../schema/control.schema.js';
+
+
+/**
+ * Register a service in the registry
+ * 
+ * @param {Object} params
+ * @param {Object} params.serivce The service data
+ * @returns {Promise<Object>} The service data
+ */
+commands.register('controlService.registerService', async ({service}) => {
+    
+    // validate the service
+    const errors = validateService(service);
+
+    if (errors) {
+        throw new Error(JSON.stringify(errors));
+    }
+
+    // register the service
+    let serviceId;
+    try {
+        const existingServices = await registry.getServices();
+
+        if (existingServices.find(s => s.name === service.name)) {
+            await registry.updateService(service);
+        } else {
+            serviceId = await registry.registerService(service);
+        }
+
+        logger.info(`Service registered: ${service.name}`);
+    } catch (error) {
+        throw error;
+    }
+
+    // return the service data
+    return {
+        id: serviceId,
+        ...service
+    };
+})
+
+/**
+ * Get all registered services
+ *
+ * @param {Object} params
+ * @param {boolean} params.includeManifests Whether to include service manifests
+ * @returns {Promise<Array>} List of services
+ */
+commands.register('controlService.getServices', async ({includeManifests}) => {
+    let services;
+    try {
+        if (includeManifests) {
+            services = await registry.getServicesWithManifests();
+        } else {
+            services = await registry.getServices();
+        }
+    } catch (error) {
+        throw error;
+    }
+
+    return services;
+})
+
+/**
+ * Get all manifests
+ *
+ * @returns {Promise<Array>} List of manifests by service
+ */
+commands.register('controlService.getManifests', async() => {
+    let manifests;
+    try {
+        manifests = await registry.getManifests();
+    } catch (error) {
+        throw error;
+    }
+
+    return manifests;
+})

package/bootstrap/services/control/src/commands/task.handler.js

@@ -0,0 +1,247 @@
+import { message, commands, logger } from '@gnar-engine/core';
+import { task } from '../services/task.service.js';
+import { validateTask } from '../schema/control.schema.js';
+
+
+/**
+ * Handle task batch
+ * 
+ * @param {string} status - Task status
+ */
+commands.register('controlService.handleTaskBatch', async (status = null) => {
+    
+    if (!status) {
+        status = 'scheduled';
+    }
+
+    logger.info(`Running Task batch... Status: ${status}`);
+
+    const tasks = await task.getTaskBatch({
+        status: status
+    });
+
+    logger.info('Found tasks: ' + JSON.stringify(tasks));
+
+    const errors = [];
+
+    const taskPromises = tasks.map(taskObj => (
+        (async () => {
+            let success = false;
+
+            try {
+                logger.info(taskObj);
+                await handleTask(taskObj);
+                await task.updateTaskStatus({ id: taskObj.id, status: 'completed' });
+
+                success = true;
+            } catch (error) {
+                logger.error(`Error handling task ${taskObj.id}: ${error}`);
+                errors.push({
+                    task: taskObj,
+                    error: error.message
+                });
+                await task.updateTaskStatus({ id: taskObj.id, status: 'failed' });
+            }
+
+            try {
+                if (success) {
+                    if (taskObj.rescheduleCentrallyOnSuccess) {
+                        await centrallyRescheduleTask({ task: taskObj });
+                    }
+                } else {
+                    if (taskObj.rescheduleCentrallyOnFailure) {
+                        await centrallyRescheduleTask({ task: taskObj });
+                    }
+                }
+            } catch (error) {
+                logger.error(`Error rescheduling task ${taskObj.id}: ${error}`);
+                errors.push({
+                    task: taskObj,
+                    error: error.message
+                });
+            }
+        })()
+    ));
+
+    await Promise.allSettled(taskPromises);
+
+    if (errors.length > 0) {
+        logger.info(JSON.stringify(errors));
+        return errors;
+    }
+})
+
+/**
+ * Handle task
+ * 
+ * @param {Object} taskObj
+ * @returns {Promise<Object>} The task data
+ */
+commands.register('controlService.handleTask', async (taskObj) => {
+    try {
+        logger.info(`Running Task: ${taskObj.name} - ${taskObj.id}`);
+
+        // Add the task id to the payload
+        taskObj.payload.taskId = taskObj.id;
+
+        // Execute task 
+        try {
+            const response = await message.sendAwaitResponse(taskObj.handlerServiceName, {
+                method: taskObj.handlerName,
+                data: taskObj.payload
+            });
+
+            // if there are errors (these are for runtime errors - should not be used for retrying)
+            if (response.error || response.status === 'failed') {
+                logger.error(`Error executing task ${taskObj.name}: ${response.error}. Failing task...`);
+                throw new Error(`Error executing task ${taskObj.name}: ${response.error}`);
+            }
+        } catch (error) {
+            throw new Error(error);
+        }
+    } catch (error) {
+        await task.updateTaskStatus({id: taskObj.id, status: 'failed'});
+        throw new Error(`Error handling task: ${taskObj.name} - ${error}`);
+    }
+})
+
+/**
+ * Centrally reschedule task
+ * 
+ * @param {Object} params
+ * @param {Object} params.task The task data
+ * @returns {Promise<Object>} The task data
+ */
+commands.register('controlService.centrallyRescheduleTask', async ({task: taskObj}) => {
+    try {
+        let newScheduled;
+        let oldScheduledDate = new Date(taskObj.scheduled);
+
+        switch (taskObj.recurringInterval) {
+            case 'hourly':
+                newScheduled = new Date(oldScheduledDate.getTime() + taskObj.recurringIntervalCount * 60 * 60 * 1000);
+                break;
+            case 'daily':
+                newScheduled = new Date(oldScheduledDate.getTime() + taskObj.recurringIntervalCount * 24 * 60 * 60 * 1000);
+                break;
+            case 'weekly':
+                newScheduled = new Date(oldScheduledDate.getTime() + taskObj.recurringIntervalCount * 7 * 24 * 60 * 60 * 1000);
+                break;
+            case 'monthly': {
+                let scheduledDate = new Date(oldScheduledDate);
+                scheduledDate.setMonth(scheduledDate.getMonth() + taskObj.recurringIntervalCount);
+                newScheduled = scheduledDate;
+                break;
+            }
+            case 'yearly': {
+                let scheduledDate = new Date(oldScheduledDate);
+                scheduledDate.setFullYear(scheduledDate.getFullYear() + taskObj.recurringIntervalCount);
+                newScheduled = scheduledDate;
+                break;
+            }
+
+            default:
+                throw new Error('Invalid scheduling interval: ' + taskObj.recurringInterval);
+        }
+
+        // reschedule the task
+        delete taskObj.id;
+
+        await scheduleTask({
+            task: {
+                ...taskObj,
+                scheduled: newScheduled,
+                status: 'scheduled'
+            }
+        });
+
+    } catch (error) {
+        logger.error('Error rescheduling task centrally: ' + error);
+        throw new Error(`Error rescheduling task: ${error}`);
+    }
+})
+
+/**
+ * Schedule task
+ * 
+ * @param {Object} params
+ * @param {Object} params.task The task data
+ * @returns {Promise<Object>} The task data
+ */
+commands.register('controlService.scheduleTask', async ({task: taskObj}) => {
+    try {
+        // prep task object
+        taskObj.scheduled = new Date(taskObj.scheduled).toISOString().slice(0, 19).replace('T', ' ');
+        taskObj.rescheduleCentrallyOnSuccess = !!taskObj.rescheduleCentrallyOnSuccess;
+        taskObj.rescheduleCentrallyOnFailure = !!taskObj.rescheduleCentrallyOnFailure;
+        taskObj.recurringIntervalCount = taskObj.recurringIntervalCount || 1;
+        
+        // validate the task
+        const errors = validateTask(taskObj);
+
+        if (errors) {
+            throw new Error(JSON.stringify(errors));
+        }
+
+        // check indempotency
+        if (taskObj.idempotencyKey) {
+            const isIndempotent = await task.checkIndempotent({
+                idempotencyKey: taskObj.idempotencyKey
+            });
+
+            if (!isIndempotent) {
+                throw new Error('Task task is already scheduled: ' + taskObj.idempotencyKey);
+            }
+        }
+
+        // schedule the task
+        const taskId = await task.scheduleTask(taskObj);
+
+        logger.info('Scheduled task: ' + JSON.stringify(taskObj));
+
+        // return the task data
+        return {
+            id: taskId,
+            ...taskObj
+        }
+    } catch (error) {
+        logger.error('Error scheduling task: ' + error);
+        throw new Error(`Error scheduling task: ${error}`);
+    }
+})
+
+/**
+ * Get tasks by status
+ * 
+ * @param {string} status - Task status
+ */
+commands.register('controlService.getTasksByStatus', async (status) => {
+    try {
+        if (!status) {
+            status = 'scheduled';
+        }
+
+        const tasks = await task.getTasksByStatus({
+            status: status
+        });
+
+        return tasks;
+    } catch (error) {
+        logger.error('Error getting tasks by status in handler: ' + error);
+        throw new Error(`Error getting tasks by status in handler: ${error}`);
+    }
+})
+
+/**
+ * Delete failed tasks
+ */
+commands.register('controlService.deleteFailedTasks', async () => {
+    try {
+        const deleteFailedTasks = await task.deleteFailedTasks();
+        logger.info('Deleted failed tasks: ' + deleteFailedTasks);
+        return deleteFailedTasks;
+    } catch (error) {
+        logger.error('Error deleting failed tasks: ' + error);
+        throw new Error(`Error deleting failed tasks: ${error}`);
+    }
+})

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

@@ -0,0 +1,55 @@
+
+/**
+ * Gnar Engine Service Config
+ */
+export const config = {
+    // service name
+    serviceName: 'controlService',
+
+    // 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.CONTROL_MONGO_URL,
+        connectionArgs: {},
+
+        // MySQL
+        host: process.env.CONTROL_MYSQL_HOST,
+        user: process.env.CONTROL_MYSQL_USER,
+        password: process.env.CONTROL_MYSQL_PASSWORD,
+        database: process.env.CONTROL_MYSQL_DATABASE,
+        // port: process.env.CONTROL_MYSQL_PORT,
+        connectionLimit: 10,
+        queueLimit: 20,
+        maxRetries: 5
+    },
+
+    // message broker
+    message: {
+        url: process.env.RABBITMQ_URL,
+        queueName: 'controlServiceQueue',
+        prefetch: 20,
+    },
+
+    // web socket client & server
+    webSockets: {
+        reconnectInterval: 5000,
+        maxInitialConnectionAttempts: 5
+    }
+}