@gnar-engine/cli 1.0.3 → 1.0.4

package/bootstrap/deploy.localdev.yml

@@ -1,51 +1,38 @@
-# deploy.localdev.yml
-
-# - This file is used to orchestrate locally running containers for development
-# - environment: localdev is a named convention required for local development 
-
 config:
-  core-version: 1.0
+  core-version: 1
   architecture: microservice
   region: eu-west-2
   environment: localdev
   namespace: my-project
-
   services:
     - name: control
       listener_rules:
         paths:
           - /control
           - /tasks
-      min-tasks: 1
-      max-tasks: 1
+      min_tasks: 1
+      max_tasks: 1
       depends_on:
         - control-db
-      command: ["npm", "run", "start:dev"]
-      ports: 
-        - "4001:3000"
-
+      command:
+        - npm
+        - run
+        - start:dev
+      ports:
+        - '4001:3000'
     - name: user
       listener_rules:
         paths:
           - /authenticate
           - /users
-      min-tasks: 1
-      max-tasks: 1
-      depends_on:
-        - control-db
-      command: ["npm", "run", "start:dev"]
-      ports: 
-        - "4002:3000"
-
-    - name: agent
-      listener_rules:
-        paths:
-          - /agent
-      min-tasks: 1
-      max-tasks: 1
+      min_tasks: 1
+      max_tasks: 1
       depends_on:
-        - agent-db
-      command: ["npm", "run", "start:dev"]
-      ports: 
-        - "4003:3000"
+        - user-db
+      command:
+        - npm
+        - run
+        - start:dev
+      ports:
+        - '4002:3000'
 

package/bootstrap/secrets.localdev.yml

@@ -7,21 +7,16 @@ services:
     MYSQL_HOST: control-db
     MYSQL_DATABASE: ge_control_db
     MYSQL_USER: ge_control_db_user
-    MYSQL_PASSWORD: zWF85kfGJNRA9ayp
-    MYSQL_RANDOM_ROOT_PASSWORD: wH0Pzkht75NvMd3b
+    MYSQL_PASSWORD: bL6I1ABJFDPO3JAR
+    MYSQL_RANDOM_ROOT_PASSWORD: GExtMVydbpIihS5f
   user:
     MYSQL_HOST: user-db
     MYSQL_DATABASE: ge_user_db
     MYSQL_USER: ge_user_db_user
-    MYSQL_PASSWORD: WTEYWqs6wDBX459p
-    MYSQL_RANDOM_ROOT_PASSWORD: GXEy5T7Cp2zuOTah
+    MYSQL_PASSWORD: 7cm0crGDTaJy9Sa2
+    MYSQL_RANDOM_ROOT_PASSWORD: APJW3b7teaRHTvcv
     ROOT_ADMIN_EMAIL: adam@gnar.co.uk
     ROOT_ADMIN_USERNAME: engineadmin
-    ROOT_ADMIN_PASSWORD: n0eYk6aoiYAeSur1
-    ROOT_ADMIN_API_KEY: qydfeMcyutzIXBvHjrB2qGL9hTdco81X
-  agent:
-    MYSQL_HOST: agent-db
-    MYSQL_DATABASE: ge_agent_db
-    MYSQL_USER: ge_agent_db_user
-    MYSQL_PASSWORD: 4BARYvygGSv6BRPH
-    MYSQL_RANDOM_ROOT_PASSWORD: s27o951anIt8Lqmy
+    ROOT_ADMIN_PASSWORD: MOF4TWiFh4TXOHcL
+    ROOT_ADMIN_API_KEY: JPpmhQN0bs8f5x2jN5ypCU6Ww6VETrW2
+

package/bootstrap/services/user/Dockerfile

@@ -1,4 +1,4 @@
-# Dockerfile for Product Service
+# Dockerfile for User Service
 FROM node:20-alpine 
 
 # Set the working directory

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gnar-engine/cli",
-    "version": "1.0.3",
+    "version": "1.0.4",
     "description": "Gnar Engine Development Framework CLI: Project bootstrap, scaffolder & control plane.",
     "type": "module",
     "bin": {

package/src/config.js

@@ -4,5 +4,6 @@ export const gnarEngineCliConfig = {
     /**
      * The path the Gnar Engine service core should be found in the service containers
      */
-    corePath: '/usr/gnar_engine/app/gnarengine-service-core'
+    corePath: '/usr/gnar_engine/app/node_modules/@gnar-engine/core'
+
 }

package/src/dev/dev.service.js

@@ -20,6 +20,13 @@ const docker = new Docker();
  * @param {boolean} [options.coreDev=false] - Whether to run in core development mode (requires access to core source)
  */
 export async function up({ projectDir, build = false, detached = false, coreDev = false }) {
+    
+    // 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");
@@ -126,10 +133,12 @@ export async function down({ projectDir, allContainers = false }) {
 export async function createDynamicNginxConf({ config, outputPath }) {
     // 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};
     `;
 
     // Loop over each service
@@ -155,8 +164,8 @@ export async function createDynamicNginxConf({ config, outputPath }) {
 
     // Close server and http blocks
     nginxConf += `
+            }
         }
-    }
     `;
 
     return nginxConf;
@@ -241,7 +250,7 @@ async function createDynamicDockerCompose({ config, secrets, gnarHiddenDir, proj
 
         // add the core source code mount if in coreDeve 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
@@ -277,33 +286,52 @@ async function createDynamicDockerCompose({ config, secrets, gnarHiddenDir, proj
 
         // add a mongodb instance if required
         if (
-            serviceEnvVars.MONGO_URL &&
+            serviceEnvVars.MONGO_HOST &&
             serviceEnvVars.MONGO_ROOT_PASSWORD &&
+            serviceEnvVars.MONGO_DATABASE &&
             serviceEnvVars.MONGO_USER &&
             serviceEnvVars.MONGO_PASSWORD
         ) {
-            services[`${svc.name}-mongo`] = {
+            // add mongo init scripts to hidden dir
+            fs.mkdir(path.join(gnarHiddenDir, 'mongo-init-scripts'), { recursive: true });
+            const mongoInitScript = `
+                db = db.getSiblingDB("invoice_db");
+                db.createUser({
+                    user: "${serviceEnvVars.MONGO_USER}",
+                    pwd: "${serviceEnvVars.MONGO_PASSWORD}",
+                    roles: [{ role: "readWrite", db: "${serviceEnvVars.MONGO_DATABASE}" }]
+                });
+
+                print("Created user ${serviceEnvVars.MONGO_USER} with access to database ${serviceEnvVars.MONGO_DATABASE}");
+            `;
+            await fs.writeFile(path.join(gnarHiddenDir, 'mongo-init-scripts', `${svc.name}-init.js`), mongoInitScript);
+
+            // create mongo service
+            const mongoUrl = `mongodb://${serviceEnvVars.MONGO_USER}:${serviceEnvVars.MONGO_PASSWORD}@${serviceEnvVars.MONGO_HOST}:27017/${serviceEnvVars.MONGO_DATABASE}`;
+            
+            services[`${svc.name}-db`] = {
                 container_name: `ge-${config.environment}-${config.namespace}-${svc.name}-mongo`,
-                image: `ge-${config.environment}-${config.namespace}-${svc.name}-mongo`,
+                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: serviceEnvVars.MONGO_ROOT_PASSWORD,
+                    MONGO_INITDB_DATABASE: serviceEnvVars.MONGO_DATABASE,
+                    DB_USER: serviceEnvVars.MONGO_USER,
+                    DB_PASSWORD: serviceEnvVars.MONGO_PASSWORD,
                 },
                 volumes: [
-                    `${gnarHiddenDir}/Data/${svc.name}-mongo-data:/data/db`
+                    `${gnarHiddenDir}/data/${svc.name}-mongo-data:/data/db`,
+                    './mongo-init-scripts:/docker-entrypoint-initdb.d'
                 ]
             };
 
             // increment mongo port for next service as required
             mongoPortsCounter++;
         }
-        
     }
 
     return {

package/src/scaffolder/commands.js

@@ -48,9 +48,9 @@ export const registerScaffolderCommands = (program) => {
     create
         .command('service <service>')
         .description('📦 Create a new service: back-end|front-end')
-        .action(async (options) => {
+        .action(async (service) => {
             // validate
-            if (!options.service) {
+            if (!service) {
                 console.error('❌ Please specify a service name using gnar create service <serviceName>');
             }
 
@@ -95,10 +95,17 @@ export const registerScaffolderCommands = (program) => {
                 try {
                     console.log('Creating new service in... ' + activeProfile.profile.PROJECT_DIR);
 
+                    // add trailing slash to project dir if missing
+                    let projectDir = activeProfile.profile.PROJECT_DIR;
+
+                    if (!activeProfile.profile.PROJECT_DIR.endsWith(path.sep)) {
+                         projectDir += path.sep;
+                    }
+
                     scaffolder.createNewService({
-                        serviceName: options.service,
+                        serviceName: service,
                         database: backendAnswers.database,
-                        projectDir: activeProfile.profile.PROJECT_DIR
+                        projectDir: projectDir
                     });
 
                 } catch (error) {

package/src/scaffolder/scaffolder.handler.js

@@ -38,47 +38,78 @@ export const scaffolder = {
             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;
+        // 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.', '');
+                }
+            }
+
+            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;
+            }
+        });
+
+        // Scaffold deploy.yml
+        scaffolder.scaffoldServiceDeployYml({
+            deployPath: path.join(projectDir, 'deploy.localdev.yml'),
+            serviceName: serviceName,
+            database: database
+        });
+
+        // Scaffold secrets.yml
+        scaffolder.scaffoldServiceSecrets({
+            secretsPath: path.join(projectDir, 'secrets.localdev.yml'),
+            serviceName: serviceName,
+            database: database
+        });
 
         return {
             message: `Service "${serviceName}" created successfully at ${serviceDir}`,
@@ -198,27 +229,15 @@ export const scaffolder = {
             // 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');
+                const scaffoldedSecrets = scaffolder.scaffoldProjectSecrets({
+                    secretsPath: sourcePath,
+                    bootstrapDir: path.dirname(sourcePath),
+                    projectName: projectName,
+                    rootAdminEmail: rootAdminEmail
+                });
+                cliApiKey = scaffoldedSecrets.cliApiKey;
+                sourcePath = path.join(path.dirname(sourcePath), 'secrets.localdev.yml.temp');
             }
 
             fs.mkdirSync(path.dirname(targetPath), { recursive: true });
@@ -248,5 +267,159 @@ export const scaffolder = {
 
         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');
+    },
+
+    /**
+     * Scaffold secrets for a new project
+     *
+     * @param {object} param
+     * @param {string} param.bootstrapDir - The bootstrap directory path
+     * @param {string} param.projectName - The project name
+     * @param {string} param.rootAdminEmail - The root admin email
+     * @returns {object} - An object containing the CLI API key
+     */
+    scaffoldProjectSecrets: function ({bootstrapDir, projectName, rootAdminEmail}) {
+        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
+        const 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 to a temp file version (so we don't overwrite the original in templates)
+        const newSecretsContent = yaml.dump(parsedSecrets);
+        fs.writeFileSync(secretsPath + '.temp', newSecretsContent, 'utf8');
+
+        return { cliApiKey };
+    },
+
+    /**
+     * Scaffold secrets for a new service
+     *
+     * @param {object} param
+     * @param {string} param.secretsPath - The path to the secrets file
+     * @param {string} param.serviceName - The service name
+     * @param {string} param.database - The database type
+     */
+    scaffoldServiceSecrets: function ({secretsPath, serviceName, database}) {
+        const rawSecrets = fs.readFileSync(secretsPath, 'utf8');
+        const parsedSecrets = yaml.load(rawSecrets);
+
+        if (!parsedSecrets.services) {
+            parsedSecrets.services = {};
+        }
+
+        parsedSecrets.services[serviceName] = {};
+
+        // generate random passwords
+        switch (database) {
+            case 'mysql':
+                parsedSecrets.services[serviceName]['MYSQL_USER'] = serviceName + '_user';
+                parsedSecrets.services[serviceName]['MYSQL_PASSWORD'] = helpers.generateRandomString(16);
+                parsedSecrets.services[serviceName]['MYSQL_DATABASE'] = serviceName + '_db';
+                parsedSecrets.services[serviceName]['MYSQL_HOST'] = serviceName + '-db';
+                parsedSecrets.services[serviceName]['MYSQL_RANDOM_ROOT_PASSWORD'] = helpers.generateRandomString(16);
+                break;
+            case 'mongodb':
+                const mongoPassword = helpers.generateRandomString(16);
+                const mongoRootPassword = helpers.generateRandomString(16);
+                const mongoUser = serviceName + '_user';
+                const mongoDatabase = serviceName + '_db';
+                const mongoHost = serviceName + '-db';
+                const mongoUrl = `mongodb://${mongoUser}:${mongoPassword}@${mongoHost}:27017/${mongoDatabase}`;
+
+                parsedSecrets.services[serviceName]['MONGO_URL'] = mongoUrl;
+                parsedSecrets.services[serviceName]['MONGO_USER'] = mongoUser;
+                parsedSecrets.services[serviceName]['MONGO_PASSWORD'] = mongoPassword;
+                parsedSecrets.services[serviceName]['MONGO_ROOT_PASSWORD'] = mongoRootPassword;
+                parsedSecrets.services[serviceName]['MONGO_DATABASE'] = mongoDatabase;
+                parsedSecrets.services[serviceName]['MONGO_HOST'] = mongoHost;
+                break;
+            default:
+                throw new Error(`Unsupported database type in secret scaffolder: ${database}`);
+        }
+
+        // save updated secrets file
+        const newSecretsContent = yaml.dump(parsedSecrets);
+        fs.writeFileSync(secretsPath, newSecretsContent, 'utf8');
+    },
+
+    /**
+     * Scaffold deploy.yml for a new service
+     *
+     * @param {object} param
+     * @param {string} param.deployPath - The path to the deploy.yml file
+     * @param {string} param.serviceName - The service name
+     * @param {string} param.database - The database type
+     * @param {number} [param.hostPort=null] - The host port (optional)
+     */
+    scaffoldServiceDeployYml: function ({deployPath, serviceName, database, hostPort = null}) {
+        // parse existing deploy.yml
+        let deploy = yaml.load(fs.readFileSync(deployPath, 'utf8'));
+
+        // don't duplicate if service already exists
+        const existingService = deploy.config.services.find(svc => svc.name === serviceName);
+
+        if (existingService) {
+            return;
+        }
+
+        // get next available host port if not prescribed
+        if (!hostPort) {
+            const hostPorts = [];
+
+            deploy.config.services.forEach(svc => {
+                if (svc.ports && svc.ports.length > 0) {
+                    svc.ports.forEach(portMapping => {
+                        const [hostPort, containerPort] = portMapping.split(':').map(p => parseInt(p, 10));
+                        hostPorts.push(hostPort);
+                    });
+                }
+            });
+
+            hostPorts.sort((a, b) => a - b);
+            hostPort = hostPorts[hostPorts.length - 1] + 1;
+        }
+
+        // prepare new service config
+        const serviceConfig = {
+            name: serviceName,
+            listener_rules: {
+                paths: [
+                    `/${serviceName}`
+                ]
+            },
+            min_tasks: 1,
+            max_tasks: 1,
+            command: ["npm", "run", "start:dev"],
+            ports: [
+                `${hostPort}:3000`
+            ]
+        }
+
+        // add database service if required
+        if (database) {
+            serviceConfig.depends_on = [
+                `${serviceName}-db`
+            ]
+        }
+
+        // add to deploy config
+        deploy.config.services.push(serviceConfig);
+
+        // write deploy.yml file
+        const deployYmlContent = yaml.dump(deploy);
+        fs.writeFileSync(deployPath, deployYmlContent, 'utf8');
     }
 }

package/templates/service/Dockerfile.hbs

@@ -1,9 +1,12 @@
 # Dockerfile for {{pascalCase serviceName}} Service
-FROM gnarengine/service-core:1.0.0
+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 ./services/{{serviceName}}/package*.json ./
 

package/templates/service/package.json.hbs

@@ -1,18 +1,16 @@
 {
-  "name": "{{lowerCase serviceName}}-service",
-  "version": "1.0.0",
-  "description": "{{pascalCase serviceName}} microservice for Gnar Engine",
-  "main": "src/app.js",
-  "scripts": {
-    "start": "node src/app.js",
-    "dev": "nodemon src/app.js"
-  },
-  "dependencies": {
-    "@gnar-engine/core": "^1.0.1"
-  },
-  "devDependencies": {
-    "nodemon": "^3.0.0"
-  },
-  "author": "Gnar Software",
-  "license": "MIT"
+    "name": "{{lowerCase serviceName}}-service",
+    "version": "1.0.0",
+    "description": "{{pascalCase serviceName}} microservice for Gnar Engine",
+    "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"
+    }
 }

package/templates/service/{app.js.hbs → src/app.js.hbs}

@@ -1,7 +1,7 @@
 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';
+import { httpController as {{lowerCase serviceName}}PlatformHttpController } from './controllers/http.controller.js';
 
 /**
  * Initialise service
@@ -9,11 +9,15 @@ import { httpController as {{pascalCase serviceName}}PlatformHttpController } fr
 export const initService = async () => {
 
 	// Run migrations
-	db.migrations.runMigrations({config});
+    if (config.db.type == 'mysql') {
+	    db.migrations.runMigrations({config});
+    }
+
+    // Run seeders
 	db.seeders.runSeeders({config});
 
 	// Import command handlers after the command bus is initialised
-	await import('./commands/{{lowerCasePlural serviceName}}.handler.js');
+	await import('./commands/{{lowerCase serviceName}}.handler.js');
 	// Add more handlers as needed
 
 	// Initialise and register message handlers
@@ -25,7 +29,7 @@ export const initService = async () => {
 	// Register http routes
 	await http.registerRoutes({
 		controllers: [
-			{{pascalCase serviceName}}PlatformHttpController,
+			{{lowerCase serviceName}}PlatformHttpController,
 		]
 	});