cyberia 3.2.22 → 3.2.70

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

@@ -1,18 +1,35 @@
 import { DataBaseProviderService } from '../../db/DataBaseProvider.js';
 import { loggerFactory } from '../../server/logger.js';
 import { DataQuery } from '../../server/data-query.js';
+import { DefaultCyberiaQuests } from '../cyberia-server-defaults/cyberia-server-defaults.js';
 
 const logger = loggerFactory(import.meta);
 
+// A step may not repeat the same (type, itemId) objective combination.
+const validateQuestObjectives = (body) => {
+  for (const [stepIndex, step] of (body?.steps || []).entries()) {
+    const seen = new Set();
+    for (const objective of step?.objectives || []) {
+      const key = `${objective?.type}::${objective?.itemId}`;
+      if (seen.has(key))
+        throw new Error(
+          `Duplicate objective "${objective?.type}" for itemId "${objective?.itemId}" in step ${stepIndex + 1}.`,
+        );
+      seen.add(key);
+    }
+  }
+};
+
 class CyberiaQuestService {
   static post = async (req, res, options) => {
     /** @type {import('./cyberia-quest.model.js').CyberiaQuestModel} */
-    const CyberiaQuest = DataBaseProviderService.getModel("CyberiaQuest", options);
+    const CyberiaQuest = DataBaseProviderService.getModel('CyberiaQuest', options);
+    validateQuestObjectives(req.body);
     return await new CyberiaQuest(req.body).save();
   };
   static get = async (req, res, options) => {
     /** @type {import('./cyberia-quest.model.js').CyberiaQuestModel} */
-    const CyberiaQuest = DataBaseProviderService.getModel("CyberiaQuest", options);
+    const CyberiaQuest = DataBaseProviderService.getModel('CyberiaQuest', options);
     if (req.params.id) return await CyberiaQuest.findById(req.params.id);
 
     // Parse query parameters using DataQuery helper
@@ -26,14 +43,52 @@ class CyberiaQuestService {
     const totalPages = Math.ceil(total / limit);
     return { data, total, page, totalPages };
   };
+  static getByCode = async (req, res, options) => {
+    /** @type {import('./cyberia-quest.model.js').CyberiaQuestModel} */
+    const CyberiaQuest = DataBaseProviderService.getModel('CyberiaQuest', options);
+    const { code } = req.params;
+    if (!code) throw new Error('code parameter is required');
+    const data = await CyberiaQuest.findOne({ code }).lean();
+    if (data) return data;
+    // Fallback world delivers quests to the Go server via gRPC from the
+    // canonical defaults without persisting them. Serve those same defaults so
+    // the client can resolve metadata even when Mongo has no seeded quest.
+    const fallback = DefaultCyberiaQuests.find((q) => q.code === code);
+    if (fallback) return fallback;
+    throw new Error(`No quest found for code: ${code}`);
+  };
+  // Quest OFFERS are located by the quest's own (sourceMapCode, sourceCellX,
+  // sourceCellY). The client queries this with the interacted entity's binding
+  // cell — no dependency on CyberiaAction. Full docs are returned so the client
+  // populates its quest metadata cache in a single request.
+  static getByCell = async (req, res, options) => {
+    /** @type {import('./cyberia-quest.model.js').CyberiaQuestModel} */
+    const CyberiaQuest = DataBaseProviderService.getModel('CyberiaQuest', options);
+    const { mapCode } = req.params;
+    const cellX = parseInt(req.params.cellX);
+    const cellY = parseInt(req.params.cellY);
+    if (!mapCode || Number.isNaN(cellX) || Number.isNaN(cellY))
+      throw new Error('mapCode, cellX and cellY parameters are required');
+    const docs = await CyberiaQuest.find({ sourceMapCode: mapCode, sourceCellX: cellX, sourceCellY: cellY }).lean();
+    const seen = new Set(docs.map((d) => d.code));
+    // Fallback-world quests are served from the canonical defaults, not Mongo.
+    for (const q of DefaultCyberiaQuests) {
+      if (q.sourceMapCode === mapCode && q.sourceCellX === cellX && q.sourceCellY === cellY && !seen.has(q.code)) {
+        docs.push(q);
+        seen.add(q.code);
+      }
+    }
+    return docs;
+  };
   static put = async (req, res, options) => {
     /** @type {import('./cyberia-quest.model.js').CyberiaQuestModel} */
-    const CyberiaQuest = DataBaseProviderService.getModel("CyberiaQuest", options);
+    const CyberiaQuest = DataBaseProviderService.getModel('CyberiaQuest', options);
+    validateQuestObjectives(req.body);
     return await CyberiaQuest.findByIdAndUpdate(req.params.id, req.body);
   };
   static delete = async (req, res, options) => {
     /** @type {import('./cyberia-quest.model.js').CyberiaQuestModel} */
-    const CyberiaQuest = DataBaseProviderService.getModel("CyberiaQuest", options);
+    const CyberiaQuest = DataBaseProviderService.getModel('CyberiaQuest', options);
     if (req.params.id) return await CyberiaQuest.findByIdAndDelete(req.params.id);
     else return await CyberiaQuest.deleteMany();
   };

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

@@ -0,0 +1,74 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaSagaService } from './cyberia-saga.service.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaSagaController {
+  static post = async (req, res, options) => {
+    try {
+      const result = await CyberiaSagaService.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 CyberiaSagaService.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 CyberiaSagaService.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 CyberiaSagaService.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 { CyberiaSagaController };

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

@@ -0,0 +1,59 @@
+import { Schema, model } from 'mongoose';
+
+const CyberiaSagaSchema = new Schema(
+  {
+    // Unique thematic namespace identifier.
+    // Example: "cyberia-saga-neon-frontier"
+    code: { type: String, required: true, unique: true, trim: true },
+
+    // Human-readable saga name.
+    name: { type: String, required: true },
+
+    // Optional description of the saga, its setting, or narrative theme.
+    description: { type: String, default: '' },
+
+    // Complete set of map identifiers that belong to this saga.
+    // Any map outside this list is considered external to the saga.
+    mapCodes: { type: [String], default: [] },
+
+    // Complete set of item identifiers associated with this saga.
+    itemIds: { type: [String], default: [] },
+
+    // Quests that belong to this saga, each paired with the NPC skin item that
+    // provides it (the bot whose interaction opens or advances the quest).
+    questCodes: {
+      type: [
+        {
+          providerSkinItemId: { type: String, required: true },
+          questCode: { type: String, required: true },
+        },
+      ],
+      default: [],
+    },
+
+    // Actions that belong to this saga, each paired with the NPC skin item the
+    // action is mounted on (the bot the action represents).
+    actionCodes: {
+      type: [
+        {
+          providerSkinItemId: { type: String, required: true },
+          actionCode: { type: String, required: true },
+        },
+      ],
+      default: [],
+    },
+
+    // Publication or visibility status.
+    status: { type: String, default: 'unlisted' },
+
+    // User who created the saga.
+    creator: { type: Schema.Types.ObjectId, ref: 'User' },
+  },
+  { timestamps: true },
+);
+
+const CyberiaSagaModel = model('CyberiaSaga', CyberiaSagaSchema);
+
+const ProviderSchema = CyberiaSagaSchema;
+
+export { CyberiaSagaSchema, CyberiaSagaModel, ProviderSchema };

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

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

package/src/api/cyberia-saga/cyberia-saga.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 CyberiaSagaService {
+  static post = async (req, res, options) => {
+    /** @type {import('./cyberia-saga.model.js').CyberiaSagaModel} */
+    const CyberiaSaga = DataBaseProviderService.getModel("CyberiaSaga", options);
+    return await new CyberiaSaga(req.body).save();
+  };
+  static get = async (req, res, options) => {
+    /** @type {import('./cyberia-saga.model.js').CyberiaSagaModel} */
+    const CyberiaSaga = DataBaseProviderService.getModel("CyberiaSaga", options);
+    if (req.params.id) return await CyberiaSaga.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([
+      CyberiaSaga.find(query).sort(sort).limit(limit).skip(skip),
+      CyberiaSaga.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  };
+  static put = async (req, res, options) => {
+    /** @type {import('./cyberia-saga.model.js').CyberiaSagaModel} */
+    const CyberiaSaga = DataBaseProviderService.getModel("CyberiaSaga", options);
+    return await CyberiaSaga.findByIdAndUpdate(req.params.id, req.body);
+  };
+  static delete = async (req, res, options) => {
+    /** @type {import('./cyberia-saga.model.js').CyberiaSagaModel} */
+    const CyberiaSaga = DataBaseProviderService.getModel("CyberiaSaga", options);
+    if (req.params.id) return await CyberiaSaga.findByIdAndDelete(req.params.id);
+    else return await CyberiaSaga.deleteMany();
+  };
+}
+
+export { CyberiaSagaService };