cyberia 3.2.5 → 3.2.12

package/src/api/crypto/crypto.router.js

@@ -1,20 +1,26 @@
 import { loggerFactory } from '../../server/logger.js';
 import { CryptoController } from './crypto.controller.js';
 import express from 'express';
+
 const logger = loggerFactory(import.meta);
 
-const CryptoRouter = (options) => {
-  const router = express.Router();
-  const authMiddleware = options.authMiddleware;
-  router.post(`/:id`, async (req, res) => await CryptoController.post(req, res, options));
-  router.post(`/`, authMiddleware, async (req, res) => await CryptoController.post(req, res, options));
-  router.get(`/:id`, async (req, res) => await CryptoController.get(req, res, options));
-  router.get(`/`, async (req, res) => await CryptoController.get(req, res, options));
-  router.delete(`/:id`, async (req, res) => await CryptoController.delete(req, res, options));
-  router.delete(`/`, async (req, res) => await CryptoController.delete(req, res, options));
-  return router;
-};
+class CryptoRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    router.post(`/:id`, async (req, res) => await CryptoController.post(req, res, options));
+    router.post(`/`, options.authMiddleware, async (req, res) => await CryptoController.post(req, res, options));
+    router.get(`/:id`, async (req, res) => await CryptoController.get(req, res, options));
+    router.get(`/`, async (req, res) => await CryptoController.get(req, res, options));
+    router.delete(`/:id`, async (req, res) => await CryptoController.delete(req, res, options));
+    router.delete(`/`, async (req, res) => await CryptoController.delete(req, res, options));
+    return router;
+  }
+}
 
-const ApiRouter = CryptoRouter;
+const ApiRouter = (options) => CryptoRouter.router(options);
 
 export { ApiRouter, CryptoRouter };

package/src/api/crypto/crypto.service.js

@@ -1,14 +1,14 @@
 import { loggerFactory } from '../../server/logger.js';
 import crypto from 'crypto';
-import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 const logger = loggerFactory(import.meta);
 
-const CryptoService = {
-  post: async (req, res, options) => {
+class CryptoService {
+  static post = async (req, res, options) => {
     /** @type {import('./crypto.model.js').CryptoModel} */
-    const Crypto = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Crypto;
+    const Crypto = DataBaseProviderService.getModel("Crypto", options);
     /** @type {import('../user/user.model.js').UserModel} */
-    const User = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.User;
+    const User = DataBaseProviderService.getModel("User", options);
 
     switch (req.params.id) {
       case 'verify': {
@@ -48,17 +48,17 @@ const CryptoService = {
         return publicKey;
       }
     }
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     switch (req.params.id) {
       default:
     }
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     switch (req.params.id) {
       default:
     }
-  },
-};
+  };
+}
 
 export { CryptoService };

package/src/api/cyberia-action/cyberia-action.controller.js

@@ -0,0 +1,74 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaActionService } from './cyberia-action.service.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaActionController {
+  static post = async (req, res, options) => {
+    try {
+      const result = await CyberiaActionService.post(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+  static get = async (req, res, options) => {
+    try {
+      const { page, limit } = req.query;
+      const result = await CyberiaActionService.get(
+        { ...req, query: { ...req.query, page: parseInt(page), limit: parseInt(limit) } },
+        res,
+        options,
+      );
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+  static put = async (req, res, options) => {
+    try {
+      const result = await CyberiaActionService.put(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+  static delete = async (req, res, options) => {
+    try {
+      const result = await CyberiaActionService.delete(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+}
+
+export { CyberiaActionController };

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

@@ -0,0 +1,87 @@
+import { Schema, model } from 'mongoose';
+import { CYBERIA_ACTION_TYPES } from '../../client/components/cyberia/SharedDefaultsCyberia.js';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const CyberiaActionSchema = new Schema(
+  {
+    // Spatial origin: the NPC/entity cell that provides this action.
+    // Matched against map entity initCellX/initCellY during instance init
+    // and assignable from ObjectLayerEngineModal.
+    sourceMapCode: { type: String, trim: true },
+    sourceCellX: { type: Number },
+    sourceCellY: { type: Number },
+
+    // ── Identity ──────────────────────────────────────────────────────────
+    code: { type: String, required: true, trim: true },
+    type: {
+      type: String,
+      required: true,
+      trim: true,
+      enum: CYBERIA_ACTION_TYPES,
+    },
+    label: { type: String, trim: true, default: '' },
+
+    // The item ID of the NPC/entity that provides this action.
+    // Used to match 'talk' quest objectives: a step with { type: 'talk', itemId: X }
+    // is satisfied when the player triggers an action where provideItemId === X.
+    // Typically the entity's active skin ObjectLayer item ID (e.g. 'wason', 'alex').
+    provideItemId: { type: String, trim: true, default: '' },
+
+    // Quest code granted to the player on their first interaction with this action.
+    // Used by 'quest-talk' NPCs to start a quest chain on first contact.
+    // Empty string = no quest granted.
+    grantQuestCode: { type: String, trim: true, default: '' },
+
+    // ── Dialogue ──────────────────────────────────────────────────────────
+    // General greeting/intro dialogue shown when the action button is tapped.
+    dialogCode: { type: String, trim: true, default: '' },
+
+    // Ordered list of CyberiaDialogue codes the player must view to satisfy
+    // a 'talk' quest objective linked to this action via provideItemId.
+    // For simple actions this may match dialogCode; for multi-stage NPCs it can diverge.
+    questDialogueCodes: [{ type: String, trim: true }],
+
+    // ── Shop payload (type="shop") ─────────────────────────────────────────
+    shopItems: [
+      {
+        itemId: { type: String, required: true, trim: true },
+        priceItemId: { type: String, default: 'coin', trim: true },
+        priceQty: { type: Number, default: 1, min: 0 },
+      },
+    ],
+
+    // ── Craft payload (type="craft") ───────────────────────────────────────
+    craftRecipes: [
+      {
+        outputItems: [
+          {
+            itemId: { type: String, required: true, trim: true },
+            qty: { type: Number, default: 1, min: 1 },
+          },
+        ],
+        ingredients: [
+          {
+            itemId: { type: String, required: true, trim: true },
+            qty: { type: Number, default: 1, min: 1 },
+          },
+        ],
+      },
+    ],
+
+    // ── Storage payload (type="storage") ──────────────────────────────────
+    storageSlots: { type: Number, default: 0, min: 0 },
+  },
+  { timestamps: true },
+);
+
+CyberiaActionSchema.index({ code: 1 }, { unique: true });
+CyberiaActionSchema.index({ provideItemId: 1 });
+CyberiaActionSchema.index({ grantQuestCode: 1 }, { sparse: true });
+CyberiaActionSchema.index({ sourceMapCode: 1, sourceCellX: 1, sourceCellY: 1 });
+
+const CyberiaActionModel = model('CyberiaAction', CyberiaActionSchema);
+
+const ProviderSchema = CyberiaActionSchema;
+
+export { CyberiaActionSchema, CyberiaActionModel, ProviderSchema };

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

@@ -0,0 +1,31 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaActionController } from './cyberia-action.controller.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaActionRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+    router.post(`/:id`, async (req, res) => await CyberiaActionController.post(req, res, options));
+    router.post(`/`, async (req, res) => await CyberiaActionController.post(req, res, options));
+    router.get(`/:id`,
+      // options.authMiddleware,
+      async (req, res) => await CyberiaActionController.get(req, res, options),
+    );
+    router.get(`/`, async (req, res) => await CyberiaActionController.get(req, res, options));
+    router.put(`/:id`, async (req, res) => await CyberiaActionController.put(req, res, options));
+    router.put(`/`, async (req, res) => await CyberiaActionController.put(req, res, options));
+    router.delete(`/:id`, async (req, res) => await CyberiaActionController.delete(req, res, options));
+    router.delete(`/`, async (req, res) => await CyberiaActionController.delete(req, res, options));
+    return router;
+  }
+}
+
+const ApiRouter = (options) => CyberiaActionRouter.router(options);
+
+export { ApiRouter, CyberiaActionRouter };

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

@@ -0,0 +1,42 @@
+import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { DataQuery } from '../../server/data-query.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaActionService {
+  static post = async (req, res, options) => {
+    /** @type {import('./cyberia-action.model.js').CyberiaActionModel} */
+    const CyberiaAction = DataBaseProviderService.getModel("CyberiaAction", options);
+    return await new CyberiaAction(req.body).save();
+  };
+  static get = async (req, res, options) => {
+    /** @type {import('./cyberia-action.model.js').CyberiaActionModel} */
+    const CyberiaAction = DataBaseProviderService.getModel("CyberiaAction", options);
+    if (req.params.id) return await CyberiaAction.findById(req.params.id);
+
+    // Parse query parameters using DataQuery helper
+    const { query, sort, skip, limit, page } = DataQuery.parse(req.query);
+
+    const [data, total] = await Promise.all([
+      CyberiaAction.find(query).sort(sort).limit(limit).skip(skip),
+      CyberiaAction.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  };
+  static put = async (req, res, options) => {
+    /** @type {import('./cyberia-action.model.js').CyberiaActionModel} */
+    const CyberiaAction = DataBaseProviderService.getModel("CyberiaAction", options);
+    return await CyberiaAction.findByIdAndUpdate(req.params.id, req.body);
+  };
+  static delete = async (req, res, options) => {
+    /** @type {import('./cyberia-action.model.js').CyberiaActionModel} */
+    const CyberiaAction = DataBaseProviderService.getModel("CyberiaAction", options);
+    if (req.params.id) return await CyberiaAction.findByIdAndDelete(req.params.id);
+    else return await CyberiaAction.deleteMany();
+  };
+}
+
+export { CyberiaActionService };

package/src/api/cyberia-client-hints/cyberia-client-hints.controller.js

@@ -0,0 +1,74 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaClientHintsService } from './cyberia-client-hints.service.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaClientHintsController {
+  static post = async (req, res, options) => {
+    try {
+      const result = await CyberiaClientHintsService.post(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+  static get = async (req, res, options) => {
+    try {
+      const { page, limit } = req.query;
+      const result = await CyberiaClientHintsService.get(
+        { ...req, query: { ...req.query, page: parseInt(page), limit: parseInt(limit) } },
+        res,
+        options,
+      );
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+  static put = async (req, res, options) => {
+    try {
+      const result = await CyberiaClientHintsService.put(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+  static delete = async (req, res, options) => {
+    try {
+      const result = await CyberiaClientHintsService.delete(req, res, options);
+      return res.status(200).json({
+        status: 'success',
+        data: result,
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  };
+}
+
+export { CyberiaClientHintsController };

package/src/api/cyberia-client-hints/cyberia-client-hints.model.js

@@ -0,0 +1,99 @@
+/**
+ * Mongoose model for `CyberiaClientHints`.
+ *
+ * Dedicated collection for per-instance presentation overrides.
+ *
+ * Ownership:
+ *   - Read by:  cyberia-client (via /api/cyberia-client-hints/:code), CMS UIs.
+ *   - Written by: CMS / editor flows. The Cyberia simulation server
+ *                 never reads or writes this collection.
+ *   - Cacheable: yes — the service layer keeps an in-memory TTL cache.
+ *
+ * Schema scope: purely visual fields. Anything that influences simulation
+ * belongs in `CyberiaInstanceConf`.
+ *
+ * @module src/api/cyberia-client-hints/cyberia-client-hints.model.js
+ */
+
+import { Schema, model } from 'mongoose';
+
+const ColorRgbaSchema = new Schema(
+    {
+        r: { type: Number, default: 0 },
+        g: { type: Number, default: 0 },
+        b: { type: Number, default: 0 },
+        a: { type: Number, default: 255 },
+    },
+    { _id: false },
+);
+
+const PaletteEntrySchema = new Schema(
+    {
+        key: { type: String, required: true },
+        r: { type: Number, default: 0 },
+        g: { type: Number, default: 0 },
+        b: { type: Number, default: 0 },
+        a: { type: Number, default: 255 },
+    },
+    { _id: false },
+);
+
+const StatusIconHintSchema = new Schema(
+    {
+        id: { type: Number, required: true },
+        iconId: { type: String, default: '' },
+        bounce: { type: Boolean, default: false },
+        borderColor: { type: ColorRgbaSchema, default: () => ({ r: 100, g: 100, b: 100, a: 200 }) },
+    },
+    { _id: false },
+);
+
+const EntityColorKeySchema = new Schema(
+    {
+        entityType: { type: String, required: true },
+        colorKey: { type: String, required: true },
+    },
+    { _id: false },
+);
+
+const CyberiaClientHintsSchema = new Schema(
+    {
+        // Instance code this hint set is scoped to. Matches CyberiaInstance.code
+        // and CyberiaInstanceConf.instanceCode. Indexed and unique to make the
+        // service-layer cache a 1-to-1 keyed lookup.
+        code: { type: String, required: true, unique: true, index: true },
+
+        // Optional palette overrides. Keys not present here fall back to the
+        // client's compile-time defaults.
+        palette: { type: [PaletteEntrySchema], default: [] },
+
+        // Optional per-entity-type color-key overrides.
+        entityColorKeys: { type: [EntityColorKeySchema], default: [] },
+
+        // Optional status-icon visual overrides (id → iconId + borderColor).
+        statusIcons: { type: [StatusIconHintSchema], default: [] },
+
+        // Camera, viewport, and cell-sizing tunings — null/undefined means
+        // "use the SharedDefaultsCyberia.RENDER_DEFAULTS value".
+        cellSize: { type: Number, default: null },
+        defaultObjWidth: { type: Number, default: null },
+        defaultObjHeight: { type: Number, default: null },
+        cameraSmoothing: { type: Number, default: null },
+        cameraZoom: { type: Number, default: null },
+        defaultWidthScreenFactor: { type: Number, default: null },
+        defaultHeightScreenFactor: { type: Number, default: null },
+        interpolationMs: { type: Number, default: null },
+        devUi: { type: Boolean, default: null },
+    },
+    { timestamps: true },
+);
+
+const CyberiaClientHintsModel = model('CyberiaClientHints', CyberiaClientHintsSchema);
+
+const ProviderSchema = CyberiaClientHintsSchema;
+
+export {
+    CyberiaClientHintsSchema,
+    CyberiaClientHintsModel,
+    ProviderSchema,
+};

package/src/api/cyberia-client-hints/cyberia-client-hints.router.js

@@ -0,0 +1,98 @@
+/**
+ * @module src/api/cyberia-client-hints
+ *
+ * Client presentation hints — read-only REST endpoint.
+ *
+ * Purpose
+ * -------
+ * The cyberia-server (Go authoritative simulation) and the WS init payload
+ * carry *only* simulation contracts. Client-render policy (palette, camera
+ * defaults, status-icon visuals, interpolation window, dev-overlay flag)
+ * lives off the simulation path entirely.
+ *
+ * This endpoint exposes optional per-instance overrides of those values.
+ * The client is required to function with no calls to this endpoint at
+ * all (it ships built-in defaults that match the canonical engine
+ * defaults 1-to-1 — see cyberia-client/src/domain/presentation_defaults.h).
+ *
+ * Endpoint
+ * --------
+ *   GET /api/cyberia-client-hints/:instanceCode
+ *     -> 200 { palette, entityColorKeys, statusIcons, cameraSmoothing,
+ *              cameraZoom, defaultWidthScreenFactor,
+ *              defaultHeightScreenFactor, interpolationMs, devUi }
+ *     -> 404 if no instance with that code exists in the database — the
+ *            client falls back to its built-in defaults on 404 (this is
+ *            the normal path for stateless servers / fresh deployments).
+ *
+ *   GET /api/cyberia-client-hints/
+ *     -> 200 canonical defaults — same shape as above, no DB read.
+ *
+ * What it intentionally does NOT do
+ * ---------------------------------
+ *   - It does not touch gameplay state (no entity, map, economy, skill,
+ *     equipment, or stat fields).
+ *   - It is not consumed by cyberia-server; the Go process never calls
+ *     this endpoint.
+ *   - It is not authenticated. Presentation hints are not secret.
+ */
+
+import express from 'express';
+import { loggerFactory } from '../../server/logger.js';
+import { CYBERIA_CLIENT_HINTS_DEFAULTS } from '../../client/components/cyberia/SharedDefaultsCyberia.js';
+import { resolveClientHints } from './cyberia-client-hints.service.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaClientHintsRouter {
+  /**
+   * @param {import('../types.js').RouterOptions} options
+   * @returns {import('express').Router}
+   */
+  static router(options) {
+    const router = express.Router();
+
+    // GET /:code -> resolved hints.
+    // Resolution order is documented in cyberia-client-hints.service.js:
+    //   1. In-memory TTL cache.
+    //   2. CyberiaClientHints collection (preferred).
+    //   3. Legacy presentation fields on CyberiaInstanceConf (back-compat).
+    //   4. Canonical client defaults (never cached so a later DB insert wins).
+    router.get('/:code', async (req, res) => {
+      try {
+        if (req && req.headers && req.headers.origin) {
+          res.set('Access-Control-Allow-Origin', req.headers.origin);
+        } else res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
+        const { data, source } = await resolveClientHints(req.params.code, {
+          host: options.host || 'default',
+          path: options.path || '/',
+        });
+        // Surface the resolution source as a non-authoritative header so
+        // operators can see whether the runtime fetched from the new
+        // collection, the compatibility read on instance-conf, the cache, or defaults.
+        res.setHeader('X-Cyberia-Hints-Source', source);
+        return res.status(200).json({ status: 'success', data });
+      } catch (err) {
+        logger.error('cyberia-client-hints GET failed:', err);
+        return res.status(500).json({ status: 'error', message: err.message });
+      }
+    });
+
+    // GET / -> canonical defaults. No DB read. Documentation/diagnostic.
+    router.get('/', async (_req, res) => {
+      if (_req && _req.headers && _req.headers.origin) {
+        res.set('Access-Control-Allow-Origin', _req.headers.origin);
+      } else res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Cross-Origin-Resource-Policy', 'cross-origin');
+      res.setHeader('X-Cyberia-Hints-Source', 'defaults');
+      return res.status(200).json({ status: 'success', data: CYBERIA_CLIENT_HINTS_DEFAULTS });
+    });
+
+    return router;
+  }
+}
+
+const ApiRouter = (options) => CyberiaClientHintsRouter.router(options);
+
+export { ApiRouter, CyberiaClientHintsRouter };