cyberia 3.1.3 → 3.2.5

package/src/api/cyberia-instance/cyberia-instance.model.js

@@ -0,0 +1,84 @@
+import { Schema, model } from 'mongoose';
+
+/**
+ * Directed edge in a graph.
+ * Each portal represents an adjacency relation:
+ * source node -> target node
+ */
+const PortalEdgeSchema = new Schema(
+  {
+    // Origin node (graph source vertex)
+    sourceMapCode: { type: String, required: true, trim: true },
+    sourceCellX: { type: Number },
+    sourceCellY: { type: Number },
+
+    // Destination node (graph target vertex)
+    targetMapCode: { type: String, required: true, trim: true },
+    targetCellX: { type: Number },
+    targetCellY: { type: Number },
+
+    // Transport behaviour of this edge:
+    //   inter-portal  — teleport to a portal entity on another map
+    //   inter-random  — teleport to a random walkable cell on another map
+    //   intra-random  — teleport to a random walkable cell on the same map
+    //   intra-portal  — teleport to a portal entity on the same map
+    portalMode: {
+      type: String,
+      enum: ['inter-portal', 'inter-random', 'intra-random', 'intra-portal'],
+      default: 'inter-portal',
+    },
+  },
+  { _id: false },
+);
+
+/**
+ * Graph container / instance.
+ * The instance stores:
+ * - nodes: cyberiaMapCodes[]
+ * - edges: portals[]
+ */
+const CyberiaInstanceSchema = new Schema(
+  {
+    // Instance identifier
+    code: { type: String, default: '', trim: true, unique: true },
+
+    name: { type: String, default: '', trim: true },
+    description: { type: String, default: '' },
+    tags: { type: [String], default: [] },
+    creator: { type: Schema.Types.ObjectId, ref: 'User' },
+    status: { type: String, default: 'unlisted' },
+    thumbnail: { type: Schema.Types.ObjectId, ref: 'File' },
+
+    // Vertex set of the graph
+    cyberiaMapCodes: { type: [String], default: [] },
+
+    // Directed edge set of the graph
+    portals: { type: [PortalEdgeSchema], default: [] },
+
+    // Optional topology generation mode
+    seed: { type: String, default: '' },
+    topologyMode: {
+      type: String,
+      enum: ['manual', 'procedural', 'hybrid'],
+      default: 'hybrid',
+    },
+
+    // Game server configuration (all tuning parameters live in a separate document).
+    // Linked to CyberiaInstanceConf.instanceCode === this.code.
+    conf: { type: Schema.Types.ObjectId, ref: 'CyberiaInstanceConf' },
+  },
+  { timestamps: true },
+);
+
+/**
+ * Indexes for fast adjacency lookups.
+ * Useful for traversing the graph by source or target node.
+ */
+CyberiaInstanceSchema.index({ 'portals.sourceMapCode': 1 });
+CyberiaInstanceSchema.index({ 'portals.targetMapCode': 1 });
+
+const CyberiaInstanceModel = model('CyberiaInstance', CyberiaInstanceSchema);
+
+const ProviderSchema = CyberiaInstanceSchema;
+
+export { CyberiaInstanceSchema, CyberiaInstanceModel, ProviderSchema };

package/src/api/cyberia-instance/cyberia-instance.router.js

@@ -0,0 +1,63 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaInstanceController } from './cyberia-instance.controller.js';
+import { userGuard, adminGuard } from '../../server/auth.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const CyberiaInstanceRouter = (options) => {
+  const router = express.Router();
+  const authMiddleware = options.authMiddleware;
+  // ── Custom actions (must come before generic /:id routes) ──────────────
+  router.get(`/fallback-world`, async (req, res) => await CyberiaInstanceController.fallbackWorld(req, res, options));
+  router.get(
+    `/:id/portal-connect`,
+    authMiddleware,
+    userGuard,
+    async (req, res) => await CyberiaInstanceController.portalConnect(req, res, options),
+  );
+
+  router.post(
+    `/:id`,
+    authMiddleware,
+    userGuard,
+    async (req, res) => await CyberiaInstanceController.post(req, res, options),
+  );
+  router.post(
+    `/`,
+    authMiddleware,
+    userGuard,
+    async (req, res) => await CyberiaInstanceController.post(req, res, options),
+  );
+  router.get(`/:id`, async (req, res) => await CyberiaInstanceController.get(req, res, options));
+  router.get(`/`, async (req, res) => await CyberiaInstanceController.get(req, res, options));
+  router.put(
+    `/:id`,
+    authMiddleware,
+    userGuard,
+    async (req, res) => await CyberiaInstanceController.put(req, res, options),
+  );
+  router.put(
+    `/`,
+    authMiddleware,
+    userGuard,
+    async (req, res) => await CyberiaInstanceController.put(req, res, options),
+  );
+  router.delete(
+    `/:id`,
+    authMiddleware,
+    userGuard,
+    async (req, res) => await CyberiaInstanceController.delete(req, res, options),
+  );
+  router.delete(
+    `/`,
+    authMiddleware,
+    adminGuard,
+    async (req, res) => await CyberiaInstanceController.delete(req, res, options),
+  );
+  return router;
+};
+
+const ApiRouter = CyberiaInstanceRouter;
+
+export { ApiRouter, CyberiaInstanceRouter };

package/src/api/cyberia-instance/cyberia-instance.service.js

@@ -0,0 +1,191 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { DataQuery } from '../../server/data-query.js';
+import { connectPortals, generateProceduralEntities } from './cyberia-portal-connector.js';
+import { generateFallbackWorld } from './cyberia-fallback-world.js';
+import { CYBERIA_INSTANCE_CONF_DEFAULTS } from '../cyberia-instance-conf/cyberia-instance-conf.defaults.js';
+
+const logger = loggerFactory(import.meta);
+
+const CyberiaInstanceService = {
+  post: async (req, res, options) => {
+    /** @type {import('./cyberia-instance.model.js').CyberiaInstanceModel} */
+    const CyberiaInstance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstance;
+    const CyberiaInstanceConf =
+      DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstanceConf;
+    if (req.auth && req.auth.user) req.body.creator = req.auth.user._id;
+    const instance = await new CyberiaInstance(req.body).save();
+
+    // Auto-upsert a CyberiaInstanceConf for this instance using schema defaults.
+    // $setOnInsert ensures existing conf documents are never overwritten.
+    if (instance.code && CyberiaInstanceConf) {
+      try {
+        const conf = await CyberiaInstanceConf.findOneAndUpdate(
+          { instanceCode: instance.code },
+          { $setOnInsert: { instanceCode: instance.code } },
+          { upsert: true, new: true },
+        );
+        if (conf && !instance.conf) {
+          await CyberiaInstance.findByIdAndUpdate(instance._id, { conf: conf._id });
+          instance.conf = conf._id;
+        }
+      } catch (e) {
+        logger.error('auto-upsert CyberiaInstanceConf failed:', e);
+      }
+    }
+
+    return instance;
+  },
+  get: async (req, res, options) => {
+    /** @type {import('./cyberia-instance.model.js').CyberiaInstanceModel} */
+    const CyberiaInstance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstance;
+    const populateCreator = { path: 'creator', model: 'User', select: '_id username' };
+    if (req.params.id) return await CyberiaInstance.findById(req.params.id).populate(populateCreator);
+
+    // Parse query parameters using DataQuery helper
+    const { query, sort, skip, limit, page } = DataQuery.parse(req.query);
+
+    const [data, total] = await Promise.all([
+      CyberiaInstance.find(query).sort(sort).limit(limit).skip(skip).populate(populateCreator),
+      CyberiaInstance.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  },
+  put: async (req, res, options) => {
+    /** @type {import('./cyberia-instance.model.js').CyberiaInstanceModel} */
+    const CyberiaInstance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstance;
+    const instance = await CyberiaInstance.findById(req.params.id);
+    if (!instance) throw new Error('instance not found');
+    if (req.auth.user.role !== 'admin' && String(instance.creator) !== String(req.auth.user._id))
+      throw new Error('insufficient permission');
+    if (req.body.thumbnail && instance.thumbnail && String(req.body.thumbnail) !== String(instance.thumbnail)) {
+      const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+      await File.findByIdAndDelete(instance.thumbnail);
+    }
+    return await CyberiaInstance.findByIdAndUpdate(req.params.id, req.body, { returnDocument: 'after' });
+  },
+  /**
+   * Central portal connector endpoint.
+   *
+   * Delegates topology computation to the pure-function `connectPortals()`
+   * from cyberia-portal-connector.js so the same logic can be used by the
+   * GUI without a DB dependency.
+   *
+   * Optionally generates procedural fallback obstacle/foreground entities
+   * for maps that have none, controlled by query flags:
+   *   ?generateEntities=true   — append procedural obstacles & foreground
+   *   ?obstacleCount=N         — obstacles per map   (default 5)
+   *   ?foregroundCount=N       — foreground per map   (default 3)
+   *   ?persist=true            — save generated portals & entities to DB
+   */
+  portalConnect: async (req, res, options) => {
+    const CyberiaInstance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstance;
+    const CyberiaMap = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaMap;
+
+    const instance = await CyberiaInstance.findById(req.params.id).lean();
+    if (!instance) throw new Error('instance not found');
+
+    const mapCodes = instance.cyberiaMapCodes || [];
+
+    // Load maps with the fields needed by the connector.
+    const mapDocs = await CyberiaMap.find(
+      { code: { $in: mapCodes } },
+      {
+        code: 1,
+        gridX: 1,
+        gridY: 1,
+        entities: 1,
+      },
+    ).lean();
+
+    // ── Portal topology (pure function) ──────────────────────────────────
+    const result = connectPortals(mapCodes, mapDocs);
+
+    // ── Procedural entity generation (optional) ──────────────────────────
+    const colors = CYBERIA_INSTANCE_CONF_DEFAULTS.colors;
+    const wantEntities = req.query?.generateEntities === 'true';
+    const obstacleCount = req.query?.obstacleCount ? parseInt(req.query.obstacleCount, 10) : undefined;
+    const foregroundCount = req.query?.foregroundCount ? parseInt(req.query.foregroundCount, 10) : undefined;
+    const seed = instance.seed || '';
+
+    const generatedEntities = {};
+    if (wantEntities) {
+      for (const doc of mapDocs) {
+        const hasObstacles = (doc.entities || []).some((e) => e.entityType === 'obstacle');
+        const hasForeground = (doc.entities || []).some((e) => e.entityType === 'foreground');
+        if (!hasObstacles || !hasForeground) {
+          const mapSeed = seed ? `${seed}:${doc.code}` : doc.code;
+          const generated = generateProceduralEntities({ gridX: doc.gridX || 16, gridY: doc.gridY || 16 }, colors, {
+            obstacleCount,
+            foregroundCount,
+            seed: mapSeed,
+          });
+          generatedEntities[doc.code] = {
+            obstacles: hasObstacles ? [] : generated.obstacles,
+            foreground: hasForeground ? [] : generated.foreground,
+          };
+        }
+      }
+    }
+
+    // ── Persist to DB when requested ─────────────────────────────────────
+    const persist = req.query?.persist === 'true';
+    if (persist) {
+      await CyberiaInstance.findByIdAndUpdate(req.params.id, { portals: result.portals });
+      for (const [mapCode, ents] of Object.entries(generatedEntities)) {
+        const toAdd = [...ents.obstacles, ...ents.foreground];
+        if (toAdd.length > 0) {
+          await CyberiaMap.findOneAndUpdate({ code: mapCode }, { $push: { entities: { $each: toAdd } } });
+        }
+      }
+    }
+
+    return {
+      ...result,
+      ...(wantEntities ? { generatedEntities } : {}),
+      persisted: persist,
+    };
+  },
+
+  delete: async (req, res, options) => {
+    /** @type {import('./cyberia-instance.model.js').CyberiaInstanceModel} */
+    const CyberiaInstance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaInstance;
+    if (req.params.id) {
+      const instance = await CyberiaInstance.findById(req.params.id);
+      if (!instance) throw new Error('instance not found');
+      if (req.auth.user.role !== 'admin' && String(instance.creator) !== String(req.auth.user._id))
+        throw new Error('insufficient permission');
+      if (instance.thumbnail) {
+        const File = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.File;
+        await File.findByIdAndDelete(instance.thumbnail);
+      }
+      return await CyberiaInstance.findByIdAndDelete(req.params.id);
+    } else return await CyberiaInstance.deleteMany();
+  },
+
+  /**
+   * Return an in-memory procedural fallback world.
+   *
+   * Nothing is persisted to MongoDB.  The world is regenerated on every
+   * call but stays deterministic for a given seed.
+   *
+   * Query params:
+   *   ?mapCount=<number>       — maps to generate  (default: 4)
+   *   ?botCount=<number>       — bots per map      (random 8–16 if omitted)
+   *   ?obstacleCount=<number>  — obstacles per map  (random 12–20 if omitted)
+   *   ?foregroundCount=<number>— foreground per map (random 6–12 if omitted)
+   */
+  fallbackWorld: async (req) => {
+    const q = req.query || {};
+    return generateFallbackWorld({
+      mapCount: q.mapCount ? parseInt(q.mapCount, 10) : undefined,
+      botCount: q.botCount ? parseInt(q.botCount, 10) : undefined,
+      obstacleCount: q.obstacleCount ? parseInt(q.obstacleCount, 10) : undefined,
+      foregroundCount: q.foregroundCount ? parseInt(q.foregroundCount, 10) : undefined,
+    });
+  },
+};
+
+export { CyberiaInstanceService };