@bizone-ai/cli 0.1.0

package/src/commands/environment.js

@@ -0,0 +1,104 @@
+// `bizone environment|env get|set|remove`
+
+import { loadConfig, saveConfig } from '../config.js';
+import { IMAGE_TYPES, SECRET_ENV_KEYS, SECRET_KEY_SUBSTRINGS, defaultEnvFor } from '../defaults.js';
+import { color, log } from '../colors.js';
+
+function isValidType(type) {
+  return IMAGE_TYPES.includes(type);
+}
+
+function typesHint() {
+  log.plain(`  Valid types: ${IMAGE_TYPES.map((t) => color.cyan(t)).join(', ')}`);
+}
+
+function isSecret(name) {
+  const lower = name.toLowerCase();
+  if (SECRET_ENV_KEYS.some((k) => k.toLowerCase() === lower)) return true;
+  return SECRET_KEY_SUBSTRINGS.some((s) => lower.includes(s));
+}
+
+// Mask a value showing only first 4 and last 4 characters.
+function mask(value) {
+  const v = String(value);
+  if (v.length <= 8) return '*'.repeat(v.length);
+  return `${v.slice(0, 4)}${'*'.repeat(Math.max(3, v.length - 8))}${v.slice(-4)}`;
+}
+
+export function environment(args) {
+  const [sub, type, name, ...rest] = args;
+  const cfg = loadConfig();
+
+  switch (sub) {
+    case 'get': {
+      if (!type) {
+        log.err('Usage: bizone env get {type}');
+        typesHint();
+        return 1;
+      }
+      if (!isValidType(type)) {
+        log.err(`Unknown type "${type}".`);
+        typesHint();
+        return 1;
+      }
+      const defaults = defaultEnvFor(type);
+      const userVars = cfg.env[type] || {};
+      // Effective view: defaults first, then user overrides.
+      const effective = { ...defaults, ...userVars };
+      const keys = Object.keys(effective);
+      log.plain(color.bold(`Environment for ${color.cyan(type)}:`));
+      if (keys.length === 0) {
+        log.plain(color.dim('  (none set)'));
+        return 0;
+      }
+      for (const k of keys) {
+        const val = effective[k];
+        const display = isSecret(k) ? color.dim(mask(val)) : val;
+        const isUser = Object.prototype.hasOwnProperty.call(userVars, k);
+        const isDefault = Object.prototype.hasOwnProperty.call(defaults, k);
+        let tag = '';
+        if (isUser && isDefault) tag = color.yellow(' (override)');
+        else if (isDefault) tag = color.dim(' (default)');
+        log.plain(`  ${color.cyan(k)} = ${display}${tag}`);
+      }
+      return 0;
+    }
+    case 'set': {
+      if (!type || !name || rest.length === 0) {
+        log.err('Usage: bizone env set {type} {name} {value}');
+        typesHint();
+        return 1;
+      }
+      if (!isValidType(type)) {
+        log.err(`Unknown type "${type}".`);
+        typesHint();
+        return 1;
+      }
+      if (!cfg.env[type]) cfg.env[type] = {};
+      cfg.env[type][name] = rest.join(' ');
+      saveConfig(cfg);
+      log.ok(`Set env ${color.cyan(type)}.${color.cyan(name)}`);
+      return 0;
+    }
+    case 'remove': {
+      if (!type || !name) {
+        log.err('Usage: bizone env remove {type} {name}');
+        typesHint();
+        return 1;
+      }
+      if (cfg.env[type] && Object.prototype.hasOwnProperty.call(cfg.env[type], name)) {
+        delete cfg.env[type][name];
+        if (Object.keys(cfg.env[type]).length === 0) delete cfg.env[type];
+        saveConfig(cfg);
+        log.ok(`Removed env ${color.cyan(type)}.${color.cyan(name)}`);
+      } else {
+        log.warn(`No env var ${color.cyan(name)} set for ${color.cyan(type)}.`);
+      }
+      return 0;
+    }
+    default:
+      log.err('Usage: bizone env <get|set|remove> ...');
+      typesHint();
+      return 1;
+  }
+}

package/src/commands/images.js

@@ -0,0 +1,66 @@
+// `bizone images|img get|set|remove`
+
+import { loadConfig, saveConfig } from '../config.js';
+import { CONTAINERS, IMAGE_TYPES } from '../defaults.js';
+import { color, log } from '../colors.js';
+
+function isValidType(type) {
+  return Object.prototype.hasOwnProperty.call(CONTAINERS, type);
+}
+
+function typesHint() {
+  log.plain(`  Valid types: ${IMAGE_TYPES.map((t) => color.cyan(t)).join(', ')}`);
+}
+
+export function images(args) {
+  const [sub, type, ...rest] = args;
+  const cfg = loadConfig();
+
+  switch (sub) {
+    case 'get': {
+      log.plain(color.bold('Images:'));
+      for (const t in CONTAINERS) {
+        const override = cfg.images[t];
+        const val = override || CONTAINERS[t].image;
+        const tag = override ? color.yellow(' (override)') : color.dim(' (default)');
+        log.plain(`  ${color.cyan(t)} -> ${val}${tag}`);
+      }
+      return 0;
+    }
+    case 'set': {
+      if (!type || rest.length === 0) {
+        log.err('Usage: bizone images set {type} {url}');
+        typesHint();
+        return 1;
+      }
+      if (!isValidType(type)) {
+        log.err(`Unknown image type "${type}".`);
+        typesHint();
+        return 1;
+      }
+      cfg.images[type] = rest.join(' ');
+      saveConfig(cfg);
+      log.ok(`Set image ${color.cyan(type)} -> ${cfg.images[type]}`);
+      return 0;
+    }
+    case 'remove': {
+      if (!type) {
+        log.err('Usage: bizone images remove {type}');
+        typesHint();
+        return 1;
+      }
+      if (Object.prototype.hasOwnProperty.call(cfg.images, type)) {
+        delete cfg.images[type];
+        saveConfig(cfg);
+        log.ok(`Removed override for ${color.cyan(type)} (now: ${CONTAINERS[type].image})`);
+      } else {
+        log.warn(`No override set for ${color.cyan(type)}.`);
+      }
+      return 0;
+    }
+    default:
+      log.err('Usage: bizone images <get|set|remove> ...');
+      typesHint();
+      return 1;
+  }
+}

package/src/commands/resources.js

@@ -0,0 +1,60 @@
+// `bizone resources|res|r get|set|remove`
+
+import { existsSync } from 'node:fs';
+
+import { loadConfig, saveConfig } from '../config.js';
+import { resolveResourcePath } from '../resources-loader.js';
+import { color, log } from '../colors.js';
+
+export function resources(args) {
+  const [sub, namespace, ...rest] = args;
+  const cfg = loadConfig();
+
+  switch (sub) {
+    case 'get': {
+      log.plain(color.bold('Resource sources:'));
+      const entries = Object.entries(cfg.resources);
+      if (entries.length === 0) {
+        log.plain(color.dim('  (none set)'));
+        return 0;
+      }
+      for (const [ns, p] of entries) {
+        const exists = existsSync(resolveResourcePath(p));
+        const tag = exists ? '' : color.red(' (path not found)');
+        log.plain(`  ${color.cyan(ns)} -> ${p}${tag}`);
+      }
+      return 0;
+    }
+    case 'set': {
+      if (!namespace || rest.length === 0) {
+        log.err('Usage: bizone resources set {namespace} {folder_or_file_path}');
+        return 1;
+      }
+      const path = rest.join(' ');
+      if (!existsSync(resolveResourcePath(path))) {
+        log.warn(`Path "${path}" does not currently exist; storing anyway.`);
+      }
+      cfg.resources[namespace] = path;
+      saveConfig(cfg);
+      log.ok(`Set resource namespace ${color.cyan(namespace)} -> ${path}`);
+      return 0;
+    }
+    case 'remove': {
+      if (!namespace) {
+        log.err('Usage: bizone resources remove {namespace}');
+        return 1;
+      }
+      if (Object.prototype.hasOwnProperty.call(cfg.resources, namespace)) {
+        delete cfg.resources[namespace];
+        saveConfig(cfg);
+        log.ok(`Removed resource namespace ${color.cyan(namespace)}`);
+      } else {
+        log.warn(`No resource set for namespace ${color.cyan(namespace)}.`);
+      }
+      return 0;
+    }
+    default:
+      log.err('Usage: bizone resources <get|set|remove> ...');
+      return 1;
+  }
+}

package/src/commands/start.js

@@ -0,0 +1,201 @@
+// `bizone start` — start the platform via the startup sequence (non-blocking:
+// returns control to the shell once everything is ready).
+
+import {
+  loadConfig,
+  getConfigValue,
+  getBool,
+  getNumber,
+  loadContainers,
+  saveContainers,
+} from '../config.js';
+import {
+  CONTAINERS,
+  AWS_ENV_VARS,
+  defaultEnvFor,
+} from '../defaults.js';
+import {
+  dockerAvailable,
+  ensureNetwork,
+  ensureImage,
+  runDetached,
+  runBlocking,
+  removeIfExists,
+  mysqlReady,
+  isContainerRunning,
+} from '../docker.js';
+import { waitForReady, importNamespace } from '../http.js';
+import { loadItems } from '../resources-loader.js';
+import { color, log } from '../colors.js';
+
+function imageFor(cfg, type) {
+  return cfg.images[type] || CONTAINERS[type].image;
+}
+
+function hostPort(cfg, service) {
+  return getConfigValue(cfg, service.portKey);
+}
+
+// Effective env for a container type: baked-in defaults, overridden by any
+// user-set values (`bizone env set`).
+function envFor(cfg, type) {
+  return { ...defaultEnvFor(type), ...(cfg.env[type] || {}) };
+}
+
+// A service runs if it has no enableKey (always-on) or its enableKey is true.
+// state-store and cloud-tools are opt-in (disabled by default).
+function isEnabled(cfg, service) {
+  return service.enableKey ? getBool(cfg, service.enableKey) : true;
+}
+
+export async function start() {
+  const cfg = loadConfig();
+  const timeoutSec = getNumber(cfg, 'timeout_sec');
+
+  if (!dockerAvailable()) {
+    log.err('Docker does not appear to be running or installed. Start Docker and retry.');
+    return 1;
+  }
+
+  log.plain(color.bold('Starting Bizone platform...'));
+
+  // 1. Shared network.
+  const network = getConfigValue(cfg, 'network_name');
+  log.step('Ensuring docker network');
+  const created = ensureNetwork(network);
+  log.ok(created ? `Created network ${network}` : `Network ${network} ready`);
+
+  const containers = loadContainers();
+
+  const imageHooks = {
+    onBeforePull: (image) => log.step(`Pulling image ${image} (this may take a while)...`),
+    onBeforeLogin: (registry) => log.step(`Authenticating to AWS ECR for ${registry}...`),
+  };
+
+  // Helper to start one service detached and record its id.
+  const startService = (service, extraEnv = {}) => {
+    removeIfExists(service.containerName); // avoid name conflicts from stale runs
+    ensureImage(imageFor(cfg, service.type), imageHooks); // pull + ECR login if needed
+    const id = runDetached({
+      name: service.containerName,
+      hostPort: hostPort(cfg, service),
+      containerPort: service.containerPort,
+      image: imageFor(cfg, service.type),
+      env: { ...envFor(cfg, service.type), ...extraEnv },
+      volume: service.volume || null,
+      network,
+    });
+    containers[service.containerName] = id;
+    saveContainers(containers);
+    return id;
+  };
+
+  const waitService = (service) =>
+    waitForReady({
+      url: `http://localhost:${hostPort(cfg, service)}${service.readyPath}`,
+      checkName: service.readyCheck,
+      timeoutSec,
+      label: service.containerName,
+    });
+
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  const waitForMysql = async (containerName) => {
+    const deadline = Date.now() + timeoutSec * 1000;
+    while (Date.now() < deadline) {
+      if (mysqlReady(containerName)) return true;
+      await sleep(1500);
+    }
+    throw new Error(`Timed out waiting for ${containerName} (MySQL) to be ready (${timeoutSec}s)`);
+  };
+
+  try {
+    // 1b. MySQL — must be up before the resource-manager (which stores into it).
+    // Reuse an already-running DB container; data lives in a persistent volume.
+    const mysql = CONTAINERS.mysql;
+    if (isContainerRunning(mysql.containerName)) {
+      log.ok(`${mysql.containerName} already running`);
+    } else {
+      log.step(`Starting ${mysql.containerName} (port ${hostPort(cfg, mysql)})`);
+      startService(mysql);
+    }
+    log.step('Waiting for MySQL to be ready...');
+    await waitForMysql(mysql.containerName);
+    log.ok('mysql ready');
+
+    // 2. Resource manager.
+    const rm = CONTAINERS['resource-manager'];
+    log.step(`Starting ${rm.containerName} (port ${hostPort(cfg, rm)})`);
+    startService(rm);
+    log.step('Waiting for resource-manager to be ready...');
+    await waitService(rm);
+    log.ok('resource-manager ready');
+
+    // 3. Resources init job (blocking).
+    const resources = CONTAINERS.resources;
+    log.step('Running resources initialization job (bizone-resources)...');
+    removeIfExists(resources.containerName);
+    ensureImage(imageFor(cfg, resources.type), imageHooks);
+    await runBlocking({
+      name: resources.containerName,
+      image: imageFor(cfg, resources.type),
+      env: envFor(cfg, resources.type),
+      network,
+    });
+    log.ok('Resources initialization job complete');
+
+    // 4. Import user-configured resources.
+    const namespaces = Object.entries(cfg.resources || {});
+    if (namespaces.length > 0) {
+      const rmPort = hostPort(cfg, rm);
+      log.step(`Importing ${namespaces.length} resource namespace(s)...`);
+      for (const [namespace, path] of namespaces) {
+        const items = loadItems(path);
+        await importNamespace({ port: rmPort, namespace, items });
+        log.ok(`Imported "${namespace}" (${items.length} item(s))`);
+      }
+    }
+
+    // 5. Start remaining services in parallel (non-blocking).
+    const remaining = ['orchestrator', 'state-store', 'cloud-tools', 'ui']
+      .map((t) => CONTAINERS[t])
+      .filter((s) => {
+        if (!isEnabled(cfg, s)) {
+          //log.warn(`Skipping ${s.containerName} (not enabled; set ${s.enableKey}=true to run)`);
+          return false;
+        }
+        return true;
+      });
+
+    for (const service of remaining) {
+      const extraEnv = {};
+      if (service.type === 'orchestrator' && getBool(cfg, 'forward_aws_env')) {
+        for (const v of AWS_ENV_VARS) {
+          if (process.env[v]) extraEnv[v] = process.env[v];
+        }
+      }
+      log.step(`Starting ${service.containerName} (port ${hostPort(cfg, service)})`);
+      startService(service, extraEnv);
+    }
+
+    // 6. Wait for all remaining services to become ready (in parallel).
+    log.step('Waiting for services to be ready...');
+    await Promise.all(
+      remaining.map((s) =>
+        waitService(s).then(() => log.ok(`${s.containerName} ready`)),
+      ),
+    );
+
+    log.plain('');
+    log.plain(color.green(color.bold('✓ Platform is running')));
+    const ui = CONTAINERS.ui;
+    if (isEnabled(cfg, ui)) {
+      log.plain(`  UI: ${color.cyan(`http://localhost:${hostPort(cfg, ui)}`)}`);
+    }
+    log.plain(`  Run ${color.cyan('bizone stop')} to stop the platform.`);
+    return 0;
+  } catch (err) {
+    log.err(err.message);
+    log.warn('Startup failed. Containers that did start are still running; run `bizone stop` to clean up.');
+    return 1;
+  }
+}

package/src/commands/stop.js

@@ -0,0 +1,53 @@
+// `bizone stop` — stop running platform containers recorded in containers.json,
+// validating against `docker ps`, then update the local file.
+
+import { loadContainers, saveContainers } from '../config.js';
+import { CONTAINERS } from '../defaults.js';
+import { dockerAvailable, runningContainerIds, stopContainer } from '../docker.js';
+import { color, log } from '../colors.js';
+
+const DB_CONTAINER = CONTAINERS.mysql.containerName;
+
+export function stop() {
+  if (!dockerAvailable()) {
+    log.err('Docker does not appear to be running or installed.');
+    return 1;
+  }
+
+  const containers = loadContainers();
+  const entries = Object.entries(containers);
+  if (entries.length === 0) {
+    log.warn('No recorded containers to stop (containers.json is empty).');
+    return 0;
+  }
+
+  const running = runningContainerIds();
+  let stopped = 0;
+
+  for (const [name, id] of entries) {
+    // Never stop or remove the database; it keeps running so data persists and
+    // the next `bizone start` reuses it. Use `bizone db destroy` to remove it.
+    if (name === DB_CONTAINER) {
+      log.info(`${color.dim('•')} Keeping ${name} running (database)`);
+      continue;
+    }
+    const isRunning = running.has(id) || [...running].some((r) => r.startsWith(id) || id.startsWith(r));
+    if (isRunning) {
+      log.step(`Stopping ${name}...`);
+      if (stopContainer(id)) {
+        log.ok(`Stopped ${name}`);
+        stopped += 1;
+      } else {
+        log.warn(`Could not stop ${name}; removing from record anyway`);
+      }
+    } else {
+      log.warn(`${name} not running (skipping)`);
+    }
+    delete containers[name];
+  }
+
+  saveContainers(containers);
+  log.plain('');
+  log.plain(color.green(color.bold(`✓ Stopped ${stopped} container(s)`)));
+  return 0;
+}

package/src/config.js

@@ -0,0 +1,78 @@
+// Configuration file handling. Cross-platform: stores config under the user's
+// home directory in a `.bizone` folder.
+//
+//   MacOS/Linux: ~/.bizone/config.json
+//   Windows:     %USERPROFILE%\.bizone\config.json
+
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
+
+import { DEFAULT_CONFIG } from './defaults.js';
+
+export const BIZONE_DIR = join(homedir(), '.bizone');
+export const CONFIG_PATH = join(BIZONE_DIR, 'config.json');
+export const CONTAINERS_PATH = join(BIZONE_DIR, 'containers.json');
+
+function ensureDir() {
+  if (!existsSync(BIZONE_DIR)) {
+    mkdirSync(BIZONE_DIR, { recursive: true });
+  }
+}
+
+const EMPTY = { config: {}, images: {}, env: {}, resources: {} };
+
+export function loadConfig() {
+  if (!existsSync(CONFIG_PATH)) {
+    return structuredClone(EMPTY);
+  }
+  try {
+    const raw = readFileSync(CONFIG_PATH, 'utf8');
+    const parsed = JSON.parse(raw || '{}');
+    return {
+      config: parsed.config || {},
+      images: parsed.images || {},
+      env: parsed.env || {},
+      resources: parsed.resources || {},
+    };
+  } catch (err) {
+    throw new Error(`Failed to read config at ${CONFIG_PATH}: ${err.message}`);
+  }
+}
+
+export function saveConfig(cfg) {
+  ensureDir();
+  writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + '\n', 'utf8');
+}
+
+// Resolve a general config value, falling back to the documented default.
+export function getConfigValue(cfg, key) {
+  if (cfg.config && Object.prototype.hasOwnProperty.call(cfg.config, key)) {
+    return cfg.config[key];
+  }
+  return DEFAULT_CONFIG[key];
+}
+
+export function getBool(cfg, key) {
+  return String(getConfigValue(cfg, key)).toLowerCase() === 'true';
+}
+
+export function getNumber(cfg, key) {
+  return Number(getConfigValue(cfg, key));
+}
+
+// --- containers.json (running container ids) ---
+
+export function loadContainers() {
+  if (!existsSync(CONTAINERS_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(CONTAINERS_PATH, 'utf8') || '{}');
+  } catch {
+    return {};
+  }
+}
+
+export function saveContainers(map) {
+  ensureDir();
+  writeFileSync(CONTAINERS_PATH, JSON.stringify(map, null, 2) + '\n', 'utf8');
+}

package/src/containers/_commons.js

@@ -0,0 +1,16 @@
+export const BIZONE_SERVICE_ENV = {
+    // kafka
+    "transport.kafka.disable": "true",
+    "handler.kafka.disable": "true",
+    // amqp
+    "transport.amqp.disable": "true",
+    "handler.amqp.disable": "true",
+    // aws-sns
+    "transport.aws-sns.disable": "true",
+    // aws-sqs
+    "transport.aws-sqs.disable": "true",
+    "handler.aws-sqs.disable": "true",
+    // azure-queue
+    "transport.azure-queue.disable": "true",
+    "handler.azure-queue.disable": "true"
+}

package/src/containers/cloud-tools.js

@@ -0,0 +1,28 @@
+import {BIZONE_SERVICE_ENV} from "./_commons.js";
+
+export const CLOUD_TOOLS_SERVICE = {
+    type: 'cloud-tools',
+    image: `699453144787.dkr.ecr.us-east-1.amazonaws.com/bizone-cloud-tools:latest`,
+    containerName: 'bizone-cloud-tools',
+    containerPort: 80,
+    portKey: 'cloud_tools_port',
+    defaultPort: '8086',
+    enableKey: 'cloud_tools_enable',
+    readyPath: '/.system/status',
+    readyCheck: 'systemStatusOk',
+    defaultEnv: {
+        "http.port": "80",
+        "transport.config.endpoint": "http://bizone-res-manager/",
+
+        'storage.type': 'mysql',
+        "storage.supported": "memory,mysql",
+
+        'mysql.storage': 'jdbc:mysql://bizone-mysql:3306',
+        'mysql.storage.user': 'root',
+        'mysql.storage.password.secret': 'mysql/password',
+
+        'secret.mysql.password': 'root',
+
+        ...BIZONE_SERVICE_ENV
+    }
+}

package/src/containers/mysql.js

@@ -0,0 +1,18 @@
+export const MYSQL_SERVICE = {
+    type: 'mysql',
+    image: "mysql:8.4.4-oracle",
+    containerName: 'bizone-mysql',
+    containerPort: 3306,
+    portKey: 'mysql_port',
+    defaultPort: '33306',
+    enableKey: null,
+    readyCheck: 'mysqlPing', // not an HTTP service; readiness via mysqladmin
+    // Named docker volume so DB data survives container restarts.
+    volume: {
+        name: 'bizone-mysql-data',
+        mount: '/var/lib/mysql'
+    },
+    defaultEnv: {
+        MYSQL_ROOT_PASSWORD: 'root'
+    }
+}

package/src/containers/orchestrator.js

@@ -0,0 +1,36 @@
+import {BIZONE_SERVICE_ENV} from "./_commons.js";
+
+export const ORCHESTRATOR_SERVICE = {
+    type: 'orchestrator',
+    image: `699453144787.dkr.ecr.us-east-1.amazonaws.com/bizone-orchestrator:latest`,
+    containerName: 'bizone-orchestrator',
+    containerPort: 80,
+    portKey: 'orchestrator_port',
+    defaultPort: '8001',
+    enableKey: null,
+    readyPath: '/.system/status',
+    readyCheck: 'systemStatusOk',
+    defaultEnv: {
+        "http.port": "80",
+        "transport.config.endpoint": "http://bizone-res-manager/",
+
+        'storage.type': 'mysql',
+        "storage.supported": "memory,mysql",
+        "journal.type": "mysql",
+        "journal.supported": "memory,mysql,none",
+
+        'mysql.storage': 'jdbc:mysql://bizone-mysql:3306',
+        'mysql.storage.user': 'root',
+        'mysql.storage.password.secret': 'mysql/password',
+
+        'mysql.journal': 'jdbc:mysql://bizone-mysql:3306',
+        'mysql.journal.user': 'root',
+        'mysql.journal.password.secret': 'mysql/password',
+
+        'secret.mysql.password': 'root',
+
+        "expired.flow.check.delay": '10000',
+
+        ...BIZONE_SERVICE_ENV
+    }
+};

package/src/containers/resource-manager.js

@@ -0,0 +1,25 @@
+import {BIZONE_SERVICE_ENV} from "./_commons.js";
+
+export const RESOURCE_MANAGER_SERVICE = {
+    type: 'resource-manager',
+    image: "699453144787.dkr.ecr.us-east-1.amazonaws.com/bizone-res-manager:latest",
+    containerName: 'bizone-res-manager',
+    containerPort: 80,
+    portKey: 'resource_manager_port',
+    defaultPort: '7070',
+    enableKey: null,
+    readyPath: '/.system/status',
+    readyCheck: 'systemStatusOk',
+    defaultEnv: {
+        "http.port": "80",
+        'storage.type': 'mysql',
+
+        'mysql.storage': 'jdbc:mysql://bizone-mysql:3306',
+        'mysql.storage.user': 'root',
+        'mysql.storage.password.secret': 'mysql/password',
+
+        'secret.mysql.password': 'root',
+
+        ...BIZONE_SERVICE_ENV
+    }
+};