@gnar-engine/cli 1.0.3 → 1.0.5

package/src/dev/commands.js

@@ -12,6 +12,8 @@ export function registerDevCommands(program) {
 		.description('🛠️  Up Development Containers')
 		.option('-b, --build', 'Ruild without cache')
         .option('-d, --detach', 'Run containers in background')
+        .option('-t --test', 'Run the tests with ephemeral databases')
+        .option('--test-service <service>', 'Run the tests for the specified service with ephemeral databases')
         .addOption(new Option('--core-dev').hideHelp())
         .action(async (options) => {
 			let response = {};
@@ -27,13 +29,19 @@ export function registerDevCommands(program) {
 			// Change to the active profile directory
 			const projectDir = activeProfile.PROJECT_DIR;
 
+            if (options.testService) {
+                options.test = true;
+            }
+
 			try {
 				up({
                     projectDir: projectDir,
                     build: options.build || false,
                     detach: options.detach || false,
-                    coreDev: options.coreDev || false
-                });
+                    coreDev: options.coreDev || false,
+                    test: options.test || false,
+                    testService: options.testService || ''
+                 });
 			} catch (err) {
 				console.error("❌ Error running containers:", err.message);
 				process.exit(1);

package/src/dev/dev.service.js

@@ -5,6 +5,7 @@ import fs from "fs/promises";
 import path from "path";
 import yaml from "js-yaml";
 import { gnarEngineCliConfig } from "../config.js";
+import { directories } from "../cli.js";
 
 const docker = new Docker();
 
@@ -18,8 +19,18 @@ const docker = new Docker();
  * @param {boolean} [options.build=false] - Whether to re-build images
  * @param {boolean} [options.detached=false] - Whether to run containers in background
  * @param {boolean} [options.coreDev=false] - Whether to run in core development mode (requires access to core source)
+ * @param {boolean} [options.test=false] - Whether to run tests with ephemeral databases
+ * @param {string} [options.testService=''] - The service to run tests for (only applicable if test=true)
+ * @param {boolean} [options.removeOrphans=true] - Whether to remove orphaned containers
  */
-export async function up({ projectDir, build = false, detached = false, coreDev = false }) {
+export async function up({ projectDir, build = false, detached = false, coreDev = false, test = false, testService = '', removeOrphans = true }) {
+    
+    // core dev
+    if (coreDev) {
+        const fileDir = path.dirname(new URL(import.meta.url).pathname);
+        projectDir = path.resolve(fileDir, "../../bootstrap/");
+    }
+
     // parse config
     const configPath = path.join(projectDir, "deploy.localdev.yml");
     const secretsPath = path.join(projectDir, "secrets.localdev.yml");
@@ -33,8 +44,13 @@ export async function up({ projectDir, build = false, detached = false, coreDev
 
     // create nginx.conf dynamically from configPath
     const nginxConfPath = path.join(gnarHiddenDir, "nginx", "nginx.conf");
+    const serviceConfDir = path.join(gnarHiddenDir, "nginx", "service_conf")
+    await fs.mkdir(serviceConfDir, { recursive: true });
+
     const nginxConf = await createDynamicNginxConf({
-        config: parsedConfig.config
+        config: parsedConfig.config,
+        projectDir: projectDir,
+        serviceConfDir: serviceConfDir
     });
     await fs.writeFile(nginxConfPath, nginxConf);
 
@@ -45,7 +61,9 @@ export async function up({ projectDir, build = false, detached = false, coreDev
         secrets: parsedSecrets,
         gnarHiddenDir: gnarHiddenDir,
         projectDir: projectDir,
-        coreDev: coreDev
+        coreDev: coreDev,
+        test: test,
+        testService: testService
     });
     await fs.writeFile(dockerComposePath, yaml.dump(dockerCompose));
 
@@ -60,6 +78,10 @@ export async function up({ projectDir, build = false, detached = false, coreDev
         args.push("-d");
     }
 
+    if (removeOrphans) {
+        args.push("--remove-orphans")
+    }
+
     const processRef = spawn(
         "docker-compose",
         args,
@@ -121,19 +143,41 @@ export async function down({ projectDir, allContainers = false }) {
  * Create dynamic nginx.conf file for running application locally
  * 
  * @param {object} config
- * @param {string} outputPath - where to write nginx.conf
+ * @param {string} serviceConfDir
+ * @param {string} projectDir
  */
-export async function createDynamicNginxConf({ config, outputPath }) {
+export async function createDynamicNginxConf({ config, serviceConfDir, projectDir }) {
     // Start with the static parts of nginx.conf
     let nginxConf = `
-    http {
-        server {
-            listen 80;
-            server_name ${config.namespace};
+        events { worker_connections 1024; }
+
+        http {
+            server {
+                listen 80;
+                server_name ${config.namespace};
+                include /etc/nginx/service_conf/*.conf;
+
     `;
 
     // Loop over each service
     for (const service of config.services || []) {
+        // Check if override is present and add conf to service_conf dir
+        const serviceDir = path.join(projectDir, 'services', service.name);
+
+        if (await fs.stat(serviceDir).then(() => true).catch(() => false)) {
+            const overridePath = path.join(serviceDir, 'nginx.conf');
+            if (await fs.stat(overridePath).then(() => true).catch(() => false)) {
+                const overrideConf = await fs.readFile(overridePath, 'utf8');
+
+                // write to service_conf directory
+                const serviceConfPath = path.join(serviceConfDir, `${service.name}.conf`);
+                await fs.writeFile(serviceConfPath, overrideConf);
+
+                continue;
+            }
+        }
+
+        // Otherwise create generic conf block
         const serviceName = service.name;
         const paths = service.listener_rules?.paths || [];
         const containerPort = service.ports && service.ports.length > 0 ? service.ports[0].split(':')[1] : '3000';
@@ -155,8 +199,8 @@ export async function createDynamicNginxConf({ config, outputPath }) {
 
     // Close server and http blocks
     nginxConf += `
+            }
         }
-    }
     `;
 
     return nginxConf;
@@ -170,12 +214,56 @@ export async function createDynamicNginxConf({ config, outputPath }) {
  * @param {string} gnarHiddenDir
  * @param {string} projectDir
  * @param {boolean} coreDev - Whether to volume mount the core source code
+ * @param {boolean} test - Whether to run tests with ephemeral databases
+ * @param {string} testService - The service to run tests for (only applicable if test=true)
+ * @param {boolean} attachAll - Whether to attach to all containers' stdio (otherwise databases and message queue are detached)
  */
-async function createDynamicDockerCompose({ config, secrets, gnarHiddenDir, projectDir, coreDev = false }) {
+async function createDynamicDockerCompose({ config, secrets, gnarHiddenDir, projectDir, coreDev = false, test = false, testService, attachAll = false }) {
     let mysqlPortsCounter = 3306;
     let mongoPortsCounter = 27017;
+    let mysqlHostsRequired = [];
+    let mongoHostsRequired = [];
     const services = {};
-    
+
+    // test mode env var adjustments
+    for (const svc of config.services) {
+        if (test) {
+            if (secrets.services?.[svc.name]?.MYSQL_HOST) {
+                secrets.services[svc.name].MYSQL_HOST = 'db-mysql-test';
+            }
+
+            if (secrets.services?.[svc.name]) {
+                secrets.services[svc.name].NODE_ENV = 'test';
+
+                if (testService && svc.name === testService) {
+                    secrets.services[svc.name].RUN_TESTS = 'true';
+                }
+            }
+        }
+    }
+
+    // provision the provisioner service
+    services['provisioner'] = {
+        container_name: `ge-${config.environment}-${config.namespace}-provisioner`,
+        image: `ge-${config.environment}-${config.namespace}-provisioner`,
+        build: {
+            context: directories.provisioner,
+            dockerfile: `./Dockerfile`
+        },
+        environment: {
+            PROVISIONER_SECRETS: JSON.stringify(secrets)
+        },
+        volumes: [
+            `${directories.provisioner}/src:/usr/gnar_engine/app/src`
+        ],
+        restart: 'no',
+        attach: attachAll
+    }
+
+    if (coreDev) {
+        services['provisioner'].volumes.push(`../../../core/:${gnarEngineCliConfig.corePath}`);
+    }
+
     // nginx
     services['nginx'] = {
         image: 'nginx:latest',
@@ -185,9 +273,11 @@ async function createDynamicDockerCompose({ config, secrets, gnarHiddenDir, proj
             "443:443"
         ],
         volumes: [
-            `${gnarHiddenDir}/nginx/nginx.conf:/etc/nginx/nginx.conf`
+            `${gnarHiddenDir}/nginx/nginx.conf:/etc/nginx/nginx.conf`,
+            `${gnarHiddenDir}/nginx/service_conf:/etc/nginx/service_conf`
         ],
-        restart: 'always'
+        restart: 'always',
+        attach: attachAll
     }
 
     // rabbit
@@ -202,7 +292,8 @@ async function createDynamicDockerCompose({ config, secrets, gnarHiddenDir, proj
             RABBITMQ_DEFAULT_USER: secrets.global.RABBITMQ_USER || '',
             RABBITMQ_DEFAULT_PASS: secrets.global.RABBITMQ_PASS || ''
         },
-        restart: 'always'
+        restart: 'always',
+        attach: attachAll
     }
 
     // services
@@ -211,7 +302,7 @@ async function createDynamicDockerCompose({ config, secrets, gnarHiddenDir, proj
         // env variables
         const serviceEnvVars = secrets.services?.[svc.name] || {};
         const localisedServiceEnvVars = {};
-        
+
         for (const [key, value] of Object.entries(serviceEnvVars)) {
             localisedServiceEnvVars[svc.name.toUpperCase() + '_' + key] = value;
         }
@@ -221,6 +312,14 @@ async function createDynamicDockerCompose({ config, secrets, gnarHiddenDir, proj
             ...(localisedServiceEnvVars || {})
         };
 
+        // test mode adjustments
+        if (test) {
+            if (svc.depends_on && svc.depends_on.includes('db-mysql')) {
+                svc.depends_on = svc.depends_on.filter(d => d !== 'db-mysql');
+                svc.depends_on.push('db-mysql-test');
+            }
+        }
+
         // service block
         services[`${svc.name}-service`] = {
             container_name: `ge-${config.environment}-${config.namespace}-${svc.name}`,
@@ -239,71 +338,86 @@ async function createDynamicDockerCompose({ config, secrets, gnarHiddenDir, proj
             restart: 'always'
         };
 
-        // add the core source code mount if in coreDeve mode
+        // add the core source code mount if in coreDev mode
         if (coreDev) {
-            services[`${svc.name}-service`].volumes.push(`../../../gnar-engine-core:${gnarEngineCliConfig.corePath}`);
+            services[`${svc.name}-service`].volumes.push(`../../../core/:${gnarEngineCliConfig.corePath}`);
         }
 
-        // add a mysql instance if required
+        // check if mysql service required
         if (
             serviceEnvVars.MYSQL_HOST &&
-            serviceEnvVars.MYSQL_DATABASE &&
-            serviceEnvVars.MYSQL_USER &&
-            serviceEnvVars.MYSQL_PASSWORD &&
-            serviceEnvVars.MYSQL_RANDOM_ROOT_PASSWORD
+            secrets.provision?.MYSQL_ROOT_PASSWORD
+        ) {
+            mysqlHostsRequired.push(serviceEnvVars.MYSQL_HOST);
+        }
+
+        // add a mongodb instance if required
+        if (
+            serviceEnvVars.MONGO_HOST &&
+            secrets.provision?.MONGO_ROOT_PASSWORD
         ) {
-            services[`${svc.name}-db`] = {
-                container_name: `ge-${config.environment}-${config.namespace}-${svc.name}-db`,
+            mongoHostsRequired.push(serviceEnvVars.MONGO_HOST);
+        }
+    }
+
+    // add mysql if required
+    if (mysqlHostsRequired.length > 0) {
+        for (const host of mysqlHostsRequired) {
+            if (services[host]) {
+                continue;
+            }
+
+            services[host] = {
+                container_name: `ge-${config.environment}-${config.namespace}-${host}`,
                 image: 'mysql',
                 ports: [
                     `${mysqlPortsCounter}:${mysqlPortsCounter}`
                 ],
                 restart: 'always',
                 environment: {
-                    MYSQL_HOST: serviceEnvVars.MYSQL_HOST,
-                    MYSQL_DATABASE: serviceEnvVars.MYSQL_DATABASE,
-                    MYSQL_USER: serviceEnvVars.MYSQL_USER,
-                    MYSQL_PASSWORD: serviceEnvVars.MYSQL_PASSWORD,
-                    MYSQL_RANDOM_ROOT_PASSWORD: serviceEnvVars.MYSQL_RANDOM_ROOT_PASSWORD,
+                    MYSQL_HOST: host,
+                    MYSQL_ROOT_PASSWORD: secrets.provision.MYSQL_ROOT_PASSWORD
                 },
                 volumes: [
-                    `${gnarHiddenDir}/data/${svc.name}-db-data:/var/lib/mysql`
-                ]
-            }; 
+                    `${gnarHiddenDir}/data/${host}-data:/var/lib/mysql`
+                ],
+                attach: attachAll
+            };
 
-            // increment mysql port for next service as required
             mysqlPortsCounter++;
         }
 
-        // add a mongodb instance if required
-        if (
-            serviceEnvVars.MONGO_URL &&
-            serviceEnvVars.MONGO_ROOT_PASSWORD &&
-            serviceEnvVars.MONGO_USER &&
-            serviceEnvVars.MONGO_PASSWORD
-        ) {
-            services[`${svc.name}-mongo`] = {
-                container_name: `ge-${config.environment}-${config.namespace}-${svc.name}-mongo`,
-                image: `ge-${config.environment}-${config.namespace}-${svc.name}-mongo`,
+        services['provisioner'].depends_on = [...new Set(mysqlHostsRequired)];
+    }
+    
+    // add mongo hosts if required
+    if (mongoHostsRequired.length > 0) {
+        for (const host of mongoHostsRequired) {
+            if (services[host]) {
+                continue;
+            }
+
+            services[host] = {
+                container_name: `ge-${config.environment}-${config.namespace}-${host}`,
+                image: 'mongo:latest',
                 ports: [
-                    `${mongoPortsCounter}:${mongoPortsCounter}`
+                    `${mongoPortsCounter}:27017`
                 ],
                 restart: 'always',
                 environment: {
-                    [`${svc.name.toUpperCase()}_MONGO_URL`]: serviceEnvVars.MONGO_URL,
-                    [`${svc.name.toUpperCase()}_MONGO_ROOT_PASSWORD`]: serviceEnvVars.MONGO_ROOT_PASSWORD,
-                    [`${svc.name.toUpperCase()}_MONGO_USER`]: serviceEnvVars.MONGO_USER,
-                    [`${svc.name.toUpperCase()}_MONGO_PASSWORD`]: serviceEnvVars.MONGO_PASSWORD,
+                    MONGO_INITDB_ROOT_USERNAME: 'root',
+                    MONGO_INITDB_ROOT_PASSWORD: secrets.provision.MONGO_ROOT_PASSWORD
                 },
                 volumes: [
-                    `${gnarHiddenDir}/Data/${svc.name}-mongo-data:/data/db`
-                ]
+                    `${gnarHiddenDir}/data/${host}-data:/data/db`,
+                    './mongo-init-scripts:/docker-entrypoint-initdb.d'
+                ],
+                attach: attachAll
             };
 
             // increment mongo port for next service as required
             mongoPortsCounter++;
         }
-        
     }
 
     return {
@@ -318,3 +432,4 @@ async function createDynamicDockerCompose({ config, secrets, gnarHiddenDir, proj
 async function assertGnarEngineHiddenDir(gnarHiddenDir) {
     await fs.mkdir(gnarHiddenDir, { recursive: true });
 }
+

package/src/provisioner/Dockerfile

@@ -0,0 +1,27 @@
+# Dockerfile for the ephemeral provisioning service
+#
+# This service is responsible for asserting the databases 
+# & database users, or other single runtime provisioning tasks.
+
+FROM node:20-alpine
+
+# Set the working directory
+WORKDIR /usr/gnar_engine/app
+
+# Define a global env var
+ENV GLOBAL_SERVICE_BASE_DIR=/usr/gnar_engine/app/src/
+
+# Copy package.json and package-lock.json
+COPY ./package*.json ./
+
+# Copy source
+COPY ./src ./src
+
+# Install nodemon
+RUN npm install -g nodemon
+
+# Install app dependencies
+RUN npm install
+
+# Start the application
+CMD ["nodemon", "--watch", "./gnar_engine", "./gnar_engine/app.js"]

package/src/provisioner/package.json

@@ -0,0 +1,19 @@
+{
+    "name": "gnar_engine_user",
+    "version": "1.0.0",
+    "description": "Gnar Engine - User Service",
+    "type": "module",
+    "scripts": {
+        "start": "node ./src/app.js",
+        "start:dev": "nodemon --watch ./src ./src/app.js",
+        "test": "jest --watchAll --verbose"
+    },
+    "author": "Gnar Software Ltd.",
+    "license": "ISC",
+    "dependencies": {
+        "@gnar-engine/core": "^1.0.1",
+        "dotenv": "^16.4.7",
+        "mongodb": "^5.9.2",
+        "mysql2": "^3.12.0"
+    }
+}

package/src/provisioner/src/app.js

@@ -0,0 +1,56 @@
+import { mysqlService } from './services/mysql.js';
+import { mongoService } from './services/mongodb.js';
+import { secrets } from './services/secrets.js';
+
+/**
+ * Initialise service
+ */
+export const initService = async () => {
+
+	console.log('G n a r  E n g i n e | Provisioner provisioning databases...');
+
+    let provisionerSecrets;
+
+    // get all secrets
+    try {
+        provisionerSecrets = JSON.parse(process.env.PROVISIONER_SECRETS);
+    } catch (error) {
+        console.error('Error parsing provisioner secrets', error);
+        return;
+    }
+
+    // collate databases to provision from secrets
+    const mysqlDatabases = secrets.collateMysqlDatabases(provisionerSecrets);
+    const mongoDatabases = secrets.collateMongoDatabases(provisionerSecrets);
+
+    // provision mysql databases
+    if (mysqlDatabases) {
+        for (const [key, value] of Object.entries(mysqlDatabases)) {
+            mysqlService.provisionDatabase({
+                host: value.host,
+                database: value.database,
+                user: value.user,
+                password: value.password,
+                rootPassword: provisionerSecrets.provision.MYSQL_ROOT_PASSWORD
+            });
+        }
+    } else {
+        console.log('No MySQL databases to provision.');
+    }
+
+    if (mongoDatabases) {
+        for (const [key, value] of Object.entries(mongoDatabases)) {
+            mongoService.provisionDatabase({
+                host: value.host,
+                database: value.database,
+                user: value.user,
+                password: value.password,
+                rootPassword: provisionerSecrets.provision.MONGO_ROOT_PASSWORD
+            })
+        }
+    } else {
+        console.log('No MongoDB databases to provision.');
+    }
+}
+
+initService();

package/src/provisioner/src/services/mongodb.js

@@ -0,0 +1,58 @@
+import { MongoClient } from 'mongodb';
+
+const retryInterval = 5000;
+const maxRetries = 5;
+
+let db;
+
+export const mongoService = {
+
+    /**
+     * Provision database and users
+     *
+     * @param {Object} params - The parameters object
+     * @param {string} host - The database host
+     * @param {string} database - The database name
+     * @param {string} user - The database user
+     * @param {string} password - The database user password
+     * @param {string} rootPassword - The root user password
+     * @param {number} [port=27017] - The database port
+     */
+    provisionDatabase: async ({host, database, user, password, rootPassword, port = 27017}) => {
+
+        const connectionUrl = `mongodb://root:${rootPassword}@${host}:${port}/admin`;
+        let retries = 0;
+
+        while (retries < maxRetries) {
+            try {
+                const dbClient = await MongoClient.connect(connectionUrl);
+                db = dbClient.db(database);
+
+                const existingUsers = await db.command({ usersInfo: 1 });
+
+                if (!existingUsers.users.some(u => u.user === user)) {
+                    await db.command({
+                        createUser: user,
+                        pwd: password,
+                        roles: [{ role: "readWrite", db: database }]
+                    });
+                }
+
+                console.log(`Successfully provisioned MongoDB database: ${database} and user: ${user}`);
+                await dbClient.close();
+                return;
+
+            } catch (error) {
+                console.error(`Failed provisioning Mongo database "${database}" for user "${user}" ": ${error.message}`);
+                retries++;
+
+                if (retries >= maxRetries) {
+                    console.error(`Max retries reached. Could not provision database "${database}".`);
+                    return;
+                }
+
+                await new Promise(resolve => setTimeout(resolve, retryInterval));
+            }
+        }
+    }
+}

package/src/provisioner/src/services/mysql.js

@@ -0,0 +1,51 @@
+import mysql from 'mysql2/promise';
+
+const retryInterval = 5000;
+const maxRetries = 5;
+
+export const mysqlService = {
+
+    /**
+     * Provision database and users
+     *
+     * @param {Object} params - The parameters object
+     * @param {string} host - The database host
+     * @param {string} database - The database name
+     * @param {string} user - The database user
+     * @param {string} password - The database user password
+     * @param {string} rootPassword - The root user password
+     */
+    provisionDatabase: async ({host, database, user, password, rootPassword}) => {
+        let retries = 0;
+
+        while (retries < maxRetries) {
+            try {
+                const conn = await mysql.createConnection({
+                    host: host || 'db-mysql',
+                    user: 'root',
+                    password: rootPassword
+                });
+
+                await conn.query(`CREATE DATABASE IF NOT EXISTS ${mysql.escapeId(database)};`);
+                await conn.query(`CREATE USER IF NOT EXISTS ${mysql.escape(user)}@'%' IDENTIFIED BY ${mysql.escape(password)};`);
+                await conn.query(`GRANT ALL PRIVILEGES ON ${mysql.escapeId(database)}.* TO ${mysql.escape(user)}@'%';`);
+                await conn.query(`FLUSH PRIVILEGES;`);
+
+                console.log(`Successfully provisioned MySQL database: ${database} and user: ${user}`);
+                await conn.end();
+                return;
+
+            } catch (error) {
+                console.error(`Failed provisioning MySQL database "${database}" for user "${user}" ": ${error.message}`);
+                retries++;
+
+                if (retries >= maxRetries) {
+                    console.error(`Max retries reached. Could not provision database "${database}".`);
+                    return;
+                }
+
+                await new Promise(resolve => setTimeout(resolve, retryInterval));
+            }
+        }
+    }
+}

package/src/provisioner/src/services/secrets.js

@@ -0,0 +1,84 @@
+
+
+export const secrets = {
+
+    /**
+     * Collate MySQL databases from provisioner secrets
+     *
+     * @param {Object} provisionerSecrets - The provisioner secrets object
+     * @returns {Object} - Collated MySQL databases
+     */
+    collateMysqlDatabases: (provisionerSecrets) => {
+
+        const mysqlDatabases = {};
+
+        for (const [serviceKey, service] of Object.entries(provisionerSecrets.services)) {
+            for (const key of Object.keys(service)) {
+                if (key.startsWith('MYSQL_')) {
+                    mysqlDatabases[serviceKey] = true;
+                    break;
+                }
+            }
+        }
+
+        for (const [key, value] of Object.entries(mysqlDatabases)) {
+            try {
+                mysqlDatabases[key] = {};
+                mysqlDatabases[key].host = provisionerSecrets.services[key].MYSQL_HOST;
+                mysqlDatabases[key].database = provisionerSecrets.services[key].MYSQL_DATABASE;
+                mysqlDatabases[key].user = provisionerSecrets.services[key].MYSQL_USER;
+                mysqlDatabases[key].password = provisionerSecrets.services[key].MYSQL_PASSWORD;
+            } catch (error) {
+                console.error(`Missing database credentials for ${key} service. Please include: MYSQL_DATABASE, MYSQL_USER, and MYSQL_PASSWORD.`);
+                return;
+            }
+        }
+
+        if (!provisionerSecrets.provision.MYSQL_ROOT_PASSWORD) {
+            console.error('Missing MYSQL_ROOT_PASSWORD in provisioner secrets. Cannot provision databases.');
+            return;
+        }
+
+        return mysqlDatabases;
+    },
+
+    /**
+     * Collate MongoDB databases from provisioner secrets
+     *
+     * @param {Object} provisionerSecrets - The provisioner secrets object
+     * @returns {Object} - Collated MongoDB databases
+     */
+    collateMongoDatabases: (provisionerSecrets) => {
+
+        const mongoDatabases = {};
+
+        for (const [serviceKey, service] of Object.entries(provisionerSecrets.services)) {
+            for (const key of Object.keys(service)) {
+                if (key.startsWith('MONGO_')) {
+                    mongoDatabases[serviceKey] = true;
+                    break;
+                }
+            }
+        }
+
+        for (const [key, value] of Object.entries(mongoDatabases)) {
+            try {
+                mongoDatabases[key] = {};
+                mongoDatabases[key].host = provisionerSecrets.services[key].MONGO_HOST;
+                mongoDatabases[key].database = provisionerSecrets.services[key].MONGO_DATABASE;
+                mongoDatabases[key].user = provisionerSecrets.services[key].MONGO_USER;
+                mongoDatabases[key].password = provisionerSecrets.services[key].MONGO_PASSWORD;
+            } catch (error) {
+                console.error(`Missing database credentials for ${key} service. Please include: MONGO_DATABASE, MONGO_USER, and MONGO_PASSWORD.`);
+                return;
+            }
+        }
+
+        if (!provisionerSecrets.provision.MONGO_ROOT_PASSWORD) {
+            console.error('Missing MONGO_ROOT_PASSWORD in provisioner secrets. Cannot provision databases.');
+            return;
+        }
+
+        return mongoDatabases;
+    }
+}