@underpostnet/cyberia 3.2.80

package/src/db/mongo/MongooseDB.js

@@ -0,0 +1,199 @@
+import mongoose from 'mongoose';
+import { getCapVariableName } from '../../client/components/core/CommonJs.js';
+import { loggerFactory } from '../../server/logger.js';
+
+/**
+ * Module for connecting to and loading models for a MongoDB database using Mongoose.
+ * @module src/db/MongooseDB.js
+ * @namespace MongooseDBService
+ */
+
+const logger = loggerFactory(import.meta);
+
+const MONGODB_SERVICE_NAME = 'mongodb-service';
+const MONGODB_STATEFULSET_NAME = 'mongodb';
+const MONGODB_DEFAULT_AUTH_SOURCE = 'admin';
+const MONGODB_DEFAULT_REPLICA_SET = 'rs0';
+const MONGODB_DEFAULT_REPLICA_COUNT = 3;
+
+/**
+ * Resolves MongoDB replica hosts from explicit input or StatefulSet defaults.
+ * @param {{hostList?: string, replicaCount?: number}} [options] - Host resolution options.
+ * @returns {Array<string>} Normalized host:port entries.
+ */
+const resolveMongoReplicaHosts = ({ hostList = '', replicaCount = MONGODB_DEFAULT_REPLICA_COUNT }) => {
+  if (hostList) {
+    return hostList
+      .split(',')
+      .map((host) => host.trim())
+      .filter(Boolean)
+      .map((host) => (host.includes(':') ? host : `${host}:27017`));
+  }
+
+  return Array.from(
+    { length: replicaCount },
+    (_, index) => `${MONGODB_STATEFULSET_NAME}-${index}.${MONGODB_SERVICE_NAME}:27017`,
+  );
+};
+
+/**
+ * @class
+ * @alias MongooseDBService
+ * @memberof MongooseDBService
+ * @classdesc Manages the Mongoose connection lifecycle and dynamic loading of database models
+ * based on API configuration.
+ *
+ * Connection parameters are resolved in the following order:
+ * 1. Explicit values passed as arguments to {@link MongooseDBService#connect}.
+ * 2. Environment variables (`DB_HOST` for host, `DB_NAME` for database name).
+ * 3. No built-in defaults — both `host` and `name` are required from the caller or environment.
+ */
+class MongooseDBService {
+  /**
+   * Normalizes Mongo host inputs into plain host:port entries.
+   * @param {Array<string>|string} hosts - Host input as list or comma-separated string.
+   * @returns {Array<string>} Normalized host:port entries.
+   */
+  normalizeHosts(hosts) {
+    const hostEntries = Array.isArray(hosts) ? hosts : `${hosts || ''}`.split(',');
+
+    return hostEntries
+      .map((entry) => `${entry || ''}`.trim())
+      .filter(Boolean)
+      .map((entry) => entry.replace(/^mongodb:\/\//, '').replace(/\/.*$/, ''));
+  }
+
+  /**
+   * Normalizes connection config from object or legacy host/name signature.
+   * @param {object|string} configOrHost - Connection config object or host string.
+   * @param {string} [name] - Legacy DB name when using host string input.
+   * @returns {{authSource: string, dbName: string, directConnection: boolean, hosts: Array<string>, password: string, replicaSet: string, user: string}} Normalized config.
+   */
+  normalizeConfig(configOrHost, name) {
+    const config =
+      typeof configOrHost === 'object' && configOrHost !== null ? { ...configOrHost } : { host: configOrHost, name };
+
+    const rawHosts = config.host || process.env.DB_HOST;
+    const hosts = this.normalizeHosts(rawHosts);
+    const dbName = config.name || process.env.DB_NAME;
+
+    if (!hosts.length || !dbName) {
+      const missing = [!hosts.length && 'host (db.host|DB_HOST)', !dbName && 'name (db.name|DB_NAME)']
+        .filter(Boolean)
+        .join(', ');
+      throw new Error(`MongooseDBService.connect: missing required parameter(s): ${missing}`);
+    }
+
+    const user = config.user || process.env.DB_USER || '';
+    const password = config.password || process.env.DB_PASSWORD || '';
+    const hasExplicitReplicaSet = !!(config.replicaSet || process.env.DB_REPLICA_SET);
+    const directConnection = hosts.length === 1 && !hasExplicitReplicaSet;
+    const replicaSet = directConnection
+      ? ''
+      : config.replicaSet || process.env.DB_REPLICA_SET || MONGODB_DEFAULT_REPLICA_SET;
+    const authSource = config.authSource || process.env.DB_AUTH_SOURCE || (user ? MONGODB_DEFAULT_AUTH_SOURCE : '');
+
+    return {
+      authSource,
+      dbName,
+      directConnection,
+      hosts,
+      password,
+      replicaSet,
+      user,
+    };
+  }
+
+  /**
+   * Builds a MongoDB URI from normalized config options.
+   * @param {object|string} configOrHost - Connection config object or host string.
+   * @param {string} [name] - Legacy DB name when using host string input.
+   * @returns {string} MongoDB connection URI.
+   */
+  buildUri(configOrHost, name) {
+    const config = this.normalizeConfig(configOrHost, name);
+    const credentials =
+      config.user && config.password
+        ? `${encodeURIComponent(config.user)}:${encodeURIComponent(config.password)}@`
+        : '';
+    const query = new URLSearchParams();
+
+    if (config.directConnection) query.set('directConnection', 'true');
+    else if (config.replicaSet) query.set('replicaSet', config.replicaSet);
+    if (config.authSource) query.set('authSource', config.authSource);
+
+    return `mongodb://${credentials}${config.hosts.join(',')}/${config.dbName}${query.size ? `?${query.toString()}` : ''}`;
+  }
+
+  /**
+   * Establishes a Mongoose connection to the specified MongoDB instance.
+   *
+   * @async
+   * @param {object|string} configOrHost - Either a db config object or a legacy host string.
+   * @param {string} [configOrHost.host] - Legacy single host or comma-separated host list.
+   * @param {string} [configOrHost.name] - The database name.
+   * @param {string} [configOrHost.replicaSet] - The MongoDB replica set name.
+   * @param {string} [configOrHost.authSource] - The authentication database.
+   * @param {string} [configOrHost.user] - The MongoDB username.
+   * @param {string} [configOrHost.password] - The MongoDB password.
+   * @param {string} [name] - Legacy database name when a host string is passed.
+   * @returns {Promise<mongoose.Connection>} A promise that resolves to the established Mongoose connection object.
+   * @throws {Error} If neither the argument nor the corresponding environment variable supplies a value.
+   */
+  async connect(configOrHost, name) {
+    const uri = this.buildUri(configOrHost, name);
+    if (process.env.NODE_ENV === 'development') logger.info(`Connecting to MongoDB with URI`, uri);
+    return await mongoose
+      .createConnection(uri, {
+        autoIndex: process.env.NODE_ENV !== 'production',
+        heartbeatFrequencyMS: 10000,
+        maxPoolSize: 20,
+        minPoolSize: 2,
+        retryReads: true,
+        retryWrites: true,
+        serverSelectionTimeoutMS: 5000,
+        socketTimeoutMS: 45000,
+      })
+      .asPromise();
+  }
+
+  /**
+   * Dynamically loads Mongoose models for a list of APIs and binds them to the given connection.
+   *
+   * @async
+   * @param {object} [options] - Options for model loading.
+   * @param {Array<string>} [options.apis=['test']] - List of API names (folders) to load models from.
+   * @param {mongoose.Connection} [options.conn=new mongoose.Connection()] - The active Mongoose connection.
+   * @returns {Promise<object>} A promise that resolves to an object map of loaded Mongoose models.
+   */
+  async loadModels(options = { apis: ['test'], conn: new mongoose.Connection() }) {
+    const { conn, apis } = options;
+    const models = {};
+    for (const api of apis) {
+      // Dynamic import of the model file
+      const { ProviderSchema } = await import(`../../api/${api}/${api}.model.js`);
+      const keyModel = getCapVariableName(api); // Assuming this returns a capitalized model name
+      models[keyModel] = conn.model(keyModel, ProviderSchema);
+    }
+
+    return models;
+  }
+}
+
+/**
+ * Singleton instance of the MongooseDBService class for backward compatibility.
+ * @alias MongooseDB
+ * @memberof MongooseDBService
+ * @type {MongooseDBService}
+ */
+const MongooseDB = new MongooseDBService();
+
+export {
+  MongooseDB,
+  MongooseDBService as MongooseDBClass,
+  MONGODB_DEFAULT_REPLICA_COUNT,
+  MONGODB_DEFAULT_REPLICA_SET,
+  MONGODB_SERVICE_NAME,
+  MONGODB_STATEFULSET_NAME,
+  resolveMongoReplicaHosts,
+};

package/src/grpc/cyberia/grpc-server.js

@@ -0,0 +1,162 @@
+/**
+ * gRPC transport for the Cyberia Engine data pipeline.
+ *
+ * Runs alongside Express on a separate port (default 50051).
+ * Thin adapter over src/projects/cyberia/instance-data.js — the shared
+ * world-load/boot assembly also served by the REST fallback at
+ * /api/cyberia-instance/boot/* — so both transports stay equivalent.
+ *
+ * @module src/grpc/cyberia/grpc-server.js
+ */
+
+import * as grpc from '@grpc/grpc-js';
+import * as protoLoader from '@grpc/proto-loader';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { loggerFactory } from '../../server/logger.js';
+import {
+  buildFallbackConfig,
+  buildFallbackInstanceConfig,
+  fetchFullInstance,
+  fetchMapData,
+  fetchObjectLayer,
+  fetchObjectLayerManifest,
+  getInstanceModels,
+  objectLayerQueryFilter,
+  pingData,
+  toObjectLayerMsg,
+} from '../../projects/cyberia/instance-data.js';
+
+const logger = loggerFactory(import.meta);
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const PROTO_PATH = path.resolve(__dirname, '../../../cyberia-server/gen/proto/cyberia.proto');
+
+const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
+  keepCase: false,
+  longs: Number,
+  enums: String,
+  defaults: true,
+  oneofs: true,
+});
+
+const proto = grpc.loadPackageDefinition(packageDefinition).cyberia;
+
+function buildHandlers(dbKey) {
+  return {
+    async ping(_call, callback) {
+      callback(null, pingData());
+    },
+
+    // Server-streaming: streams all ObjectLayers
+    async getObjectLayerBatch(call) {
+      try {
+        const models = getInstanceModels(dbKey);
+        const cursor = models.ObjectLayer.find(objectLayerQueryFilter(call.request.itemTypeFilter)).lean().cursor();
+        for await (const doc of cursor) {
+          call.write(toObjectLayerMsg(doc));
+        }
+        call.end();
+      } catch (err) {
+        logger.error('getObjectLayerBatch:', err);
+        call.destroy(new Error(err.message));
+      }
+    },
+
+    async getObjectLayer(call, callback) {
+      try {
+        const msg = await fetchObjectLayer(getInstanceModels(dbKey), call.request.itemId);
+        if (!msg)
+          return callback({ code: grpc.status.NOT_FOUND, message: `ObjectLayer "${call.request.itemId}" not found` });
+        callback(null, msg);
+      } catch (err) {
+        logger.error('getObjectLayer:', err);
+        callback({ code: grpc.status.INTERNAL, message: err.message });
+      }
+    },
+
+    async getMapData(call, callback) {
+      try {
+        const result = await fetchMapData(getInstanceModels(dbKey), call.request);
+        if (!result)
+          return callback({ code: grpc.status.NOT_FOUND, message: `Map "${call.request.mapCode}" not found` });
+        callback(null, result);
+      } catch (err) {
+        logger.error('getMapData:', err);
+        callback({ code: grpc.status.INTERNAL, message: err.message });
+      }
+    },
+
+    async getFullInstance(call, callback) {
+      try {
+        callback(null, await fetchFullInstance(getInstanceModels(dbKey), call.request.instanceCode));
+      } catch (err) {
+        logger.error('getFullInstance:', err);
+        callback({ code: grpc.status.INTERNAL, message: err.message });
+      }
+    },
+
+    async getObjectLayerManifest(_call, callback) {
+      try {
+        callback(null, await fetchObjectLayerManifest(getInstanceModels(dbKey)));
+      } catch (err) {
+        logger.error('getObjectLayerManifest:', err);
+        callback({ code: grpc.status.INTERNAL, message: err.message });
+      }
+    },
+  };
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// Server lifecycle
+// ═══════════════════════════════════════════════════════════════════
+
+class GrpcServer {
+  static _server = null;
+
+  /**
+   * @param {Object} opts
+   * @param {string} opts.host  - DataBaseProviderService host key
+   * @param {string} opts.path  - DataBaseProviderService path key
+   * @param {number} [opts.port=50051]
+   */
+  static async start({ host, path: dbPath, port = 50051 } = {}) {
+    const dbKey = `${host}${dbPath}`;
+    const server = new grpc.Server({
+      'grpc.max_send_message_length': 64 * 1024 * 1024,
+      'grpc.max_receive_message_length': 16 * 1024 * 1024,
+    });
+
+    server.addService(proto.CyberiaDataService.service, buildHandlers(dbKey));
+
+    // gRPC runs over Kubernetes internal network (ClusterIP) — always insecure
+    const creds = grpc.ServerCredentials.createInsecure();
+
+    return new Promise((resolve, reject) => {
+      server.bindAsync(`0.0.0.0:${port}`, creds, (err) => {
+        if (err) {
+          logger.error('gRPC bind failed:', err);
+          return reject(err);
+        }
+        GrpcServer._server = server;
+        logger.info(`gRPC server listening on 0.0.0.0:${port}`);
+        resolve(server);
+      });
+    });
+  }
+
+  static async stop() {
+    if (!GrpcServer._server) return;
+    return new Promise((resolve) => {
+      GrpcServer._server.tryShutdown(() => {
+        GrpcServer._server = null;
+        logger.info('gRPC server stopped');
+        resolve();
+      });
+    });
+  }
+}
+
+export { GrpcServer, buildFallbackConfig, buildFallbackInstanceConfig };

package/src/index.js

@@ -0,0 +1,357 @@
+/**
+ * Underpost index npm package
+ * @module src/index.js
+ * @namespace Underpost
+ */
+
+import UnderpostBaremetal from './cli/baremetal.js';
+import UnderpostCloudInit from './cli/cloud-init.js';
+import UnderpostKickStart from './cli/kickstart.js';
+import UnderpostCluster from './cli/cluster.js';
+import UnderpostDB from './cli/db.js';
+import UnderpostDeploy from './cli/deploy.js';
+import UnderpostDockerCompose from './cli/docker-compose.js';
+import UnderpostKubectl from './cli/kubectl.js';
+import UnderpostRootEnv from './cli/env.js';
+import UnderpostFileStorage from './cli/fs.js';
+import UnderpostIPFS from './cli/ipfs.js';
+import UnderpostImage from './cli/image.js';
+import UnderpostLxd from './cli/lxd.js';
+import UnderpostMonitor from './cli/monitor.js';
+import UnderpostRepository from './cli/repository.js';
+import UnderpostRun from './cli/run.js';
+import UnderpostSecret from './cli/secrets.js';
+import UnderpostSSH from './cli/ssh.js';
+import UnderpostStatic from './cli/static.js';
+import UnderpostTest from './cli/test.js';
+import UnderpostRelease from './cli/release.js';
+import UnderpostSystemProvisionig from './cli/system.js';
+
+import UnderpostDns from './server/dns.js';
+import UnderpostBackup from './server/backup.js';
+import UnderpostCron from './server/cron.js';
+import UnderpostStartUp from './server/start.js';
+import UnderpostTLS from './server/tls.js';
+
+/**
+ * Underpost main module methods
+ * @class Underpost
+ * @memberof Underpost
+ */
+class Underpost {
+  /**
+   * Underpost engine version
+   * @static
+   * @type {String}
+   * @memberof Underpost
+   */
+  static version = 'v3.2.80';
+
+  /**
+   * Required Node.js major version
+   * @static
+   * @type {String}
+   * @memberof Underpost
+   */
+  static majorNodejsVersion = 'v24';
+
+  /**
+   * Repository cli API
+   * @static
+   * @type {UnderpostRepository.API}
+   * @memberof Underpost
+   */
+  static get repo() {
+    return UnderpostRepository.API;
+  }
+  /**
+   * Root Env cli API
+   * @static
+   * @type {UnderpostRootEnv.API}
+   * @memberof Underpost
+   */
+  static get env() {
+    return UnderpostRootEnv.API;
+  }
+  /**
+   * Test cli API
+   * @static
+   * @type {UnderpostTest.API}
+   * @memberof Underpost
+   */
+  static get test() {
+    return UnderpostTest.API;
+  }
+
+  /**
+   * Static cli API
+   * @static
+   * @type {UnderpostStatic.API}
+   * @memberof Underpost
+   */
+  static get static() {
+    return UnderpostStatic.API;
+  }
+
+  /**
+   * Cluster cli API
+   * @static
+   * @type {UnderpostCluster.API}
+   * @memberof Underpost
+   */
+  static get cluster() {
+    return UnderpostCluster.API;
+  }
+  /**
+   * Image cli API
+   * @static
+   * @type {UnderpostImage.API}
+   * @memberof Underpost
+   */
+  static get image() {
+    return UnderpostImage.API;
+  }
+  /**
+   * Secrets cli API
+   * @static
+   * @type {UnderpostSecret.API}
+   * @memberof Underpost
+   */
+  static get secret() {
+    return UnderpostSecret.API;
+  }
+  /**
+   * Database cli API
+   * @static
+   * @type {UnderpostDB.API}
+   * @memberof Underpost
+   */
+  static get db() {
+    return UnderpostDB.API;
+  }
+  /**
+   * Kubectl cli API
+   * @static
+   * @type {UnderpostKubectl.API}
+   * @memberof Underpost
+   */
+  static get kubectl() {
+    return UnderpostKubectl.API;
+  }
+  /**
+   * Deployment cli API
+   * @static
+   * @type {UnderpostDeploy.API}
+   * @memberof Underpost
+   */
+  static get deploy() {
+    return UnderpostDeploy.API;
+  }
+  /**
+   * Docker Compose pipeline cli API
+   * @static
+   * @type {UnderpostDockerCompose.API}
+   * @memberof Underpost
+   */
+  static get dockerCompose() {
+    return UnderpostDockerCompose.API;
+  }
+  /**
+   * File Storage cli API
+   * @static
+   * @type {UnderpostFileStorage.API}
+   * @memberof Underpost
+   */
+  static get fs() {
+    return UnderpostFileStorage.API;
+  }
+  /**
+   * IPFS cli API
+   * @static
+   * @type {UnderpostIPFS.API}
+   * @memberof Underpost
+   */
+  static get ipfs() {
+    return UnderpostIPFS.API;
+  }
+  /**
+   * Monitor cli API
+   * @static
+   * @type {UnderpostMonitor.API}
+   * @memberof Underpost
+   */
+  static get monitor() {
+    return UnderpostMonitor.API;
+  }
+  /**
+   * SSH cli API
+   * @static
+   * @type {UnderpostSSH.API}
+   * @memberof Underpost
+   */
+  static get ssh() {
+    return UnderpostSSH.API;
+  }
+  /**
+   * LXD cli API
+   * @static
+   * @type {UnderpostLxd.API}
+   * @memberof Underpost
+   */
+  static get lxd() {
+    return UnderpostLxd.API;
+  }
+
+  /**
+   * Cloud Init cli API
+   * @static
+   * @type {UnderpostCloudInit.API}
+   * @memberof Underpost
+   */
+  static get cloudInit() {
+    return UnderpostCloudInit.API;
+  }
+
+  /**
+   * KickStart cli API
+   * @static
+   * @type {UnderpostKickStart.API}
+   * @memberof Underpost
+   */
+  static get kickstart() {
+    return UnderpostKickStart.API;
+  }
+
+  /**
+   * Run cli API
+   * @static
+   * @type {UnderpostRun.API}
+   * @memberof Underpost
+   */
+  static get run() {
+    return UnderpostRun.API;
+  }
+
+  /**
+   * Baremetal cli API
+   * @static
+   * @type {UnderpostBaremetal.API}
+   * @memberof Underpost
+   */
+  static get baremetal() {
+    return UnderpostBaremetal.API;
+  }
+
+  /**
+   * System Provisioning cli API
+   * @static
+   * @type {UnderpostSystemProvisionig.API}
+   * @memberof Underpost
+   */
+  static get system() {
+    return UnderpostSystemProvisionig.API;
+  }
+
+  /**
+   * Dns server API
+   * @static
+   * @type {UnderpostDns.API}
+   * @memberof Underpost
+   */
+  static get dns() {
+    return UnderpostDns.API;
+  }
+
+  /**
+   * BackUp server API
+   * @static
+   * @type {UnderpostBackup.API}
+   * @memberof Underpost
+   */
+  static get backup() {
+    return UnderpostBackup.API;
+  }
+
+  /**
+   * Cron server API
+   * @static
+   * @type {UnderpostCron.API}
+   * @memberof Underpost
+   */
+  static get cron() {
+    return UnderpostCron.API;
+  }
+
+  /**
+   * Start Up server API
+   * @static
+   * @type {UnderpostStartUp.API}
+   * @memberof Underpost
+   */
+  static get start() {
+    return UnderpostStartUp.API;
+  }
+
+  /**
+   * TLS/SSL server utilities API
+   * @static
+   * @type {UnderpostTLS.API}
+   * @memberof Underpost
+   */
+  static get tls() {
+    return UnderpostTLS.API;
+  }
+
+  /**
+   * Release orchestrator cli API
+   * @static
+   * @type {UnderpostRelease.API}
+   * @memberof Underpost
+   */
+  static get release() {
+    return UnderpostRelease.API;
+  }
+}
+
+if (!process.version || !process.version.startsWith(`${Underpost.majorNodejsVersion}.`))
+  console.warn(
+    `${`Underpost Warning: Required Node.js version is `.red}${`${Underpost.majorNodejsVersion}.x`.bgBlue.bold.white}${`, you are using `.red}${process.version.bgRed.bold.white}`,
+  );
+
+const up = Underpost;
+
+const underpost = Underpost;
+
+export {
+  underpost,
+  up,
+  Underpost,
+  UnderpostBaremetal,
+  UnderpostCloudInit,
+  UnderpostCluster,
+  UnderpostDB,
+  UnderpostDeploy,
+  UnderpostDockerCompose,
+  UnderpostKubectl,
+  UnderpostRootEnv,
+  UnderpostFileStorage,
+  UnderpostImage,
+  UnderpostStatic,
+  UnderpostLxd,
+  UnderpostKickStart,
+  UnderpostIPFS,
+  UnderpostMonitor,
+  UnderpostRepository,
+  UnderpostRun,
+  UnderpostSecret,
+  UnderpostSSH,
+  UnderpostTest,
+  UnderpostDns,
+  UnderpostBackup,
+  UnderpostCron,
+  UnderpostStartUp,
+  UnderpostRelease,
+  UnderpostTLS,
+};
+
+export default Underpost;