cyberia 3.2.5 → 3.2.9

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

@@ -0,0 +1,67 @@
+import { Schema, model } from 'mongoose';
+import { QUEST_STEPS_TYPES } from '../../client/components/cyberia-portal/CommonCyberiaPortal.js';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const CyberiaQuestSchema = new Schema(
+  {
+    // Spatial origin: the NPC/entity cell that grants this quest.
+    // Matched against map entity initCellX/initCellY during instance init
+    // and assignable from ObjectLayerEngineModal.
+    sourceMapCode: { type: String, trim: true },
+    sourceCellX: { type: Number },
+    sourceCellY: { type: Number },
+
+    // Stable slug, e.g. "fallback-intro-quest"
+    code: { type: String, required: true, trim: true },
+    title: { type: String, required: true, trim: true },
+    description: { type: String, default: '' },
+
+    // ── Chain / tree unlock structure ─────────────────────────────────────
+    // All listed quest codes must be completed before this quest becomes
+    // available (AND logic). Empty array = no prerequisites.
+    prerequisiteCodes: { type: [String], default: [] },
+
+    // Quest codes unlocked when this quest is completed.
+    // Supports both chain (one successor) and tree (multiple successors).
+    // The server re-checks prerequisiteCodes on each target before activating it.
+    unlocksQuestCodes: { type: [String], default: [] },
+
+    // ── Steps ─────────────────────────────────────────────────────────────
+    // Ordered linear sequence. The active step is always the first incomplete one.
+    steps: [
+      {
+        id: { type: String, required: true },
+        description: { type: String, default: '' },
+        objectives: [
+          {
+            // collect — itemId = item that must appear in the player's inventory
+            // talk    — itemId = provideItemId of the CyberiaAction to interact with
+            // kill    — itemId = skin item ID of the target entity
+            type: { type: String, required: true, enum: QUEST_STEPS_TYPES },
+            itemId: { type: String, required: true, trim: true },
+            quantity: { type: Number, default: 1, min: 1 },
+          },
+        ],
+      },
+    ],
+
+    // ── Rewards ───────────────────────────────────────────────────────────
+    rewards: [
+      {
+        itemId: { type: String, required: true, trim: true },
+        quantity: { type: Number, default: 1, min: 1 },
+      },
+    ],
+  },
+  { timestamps: true },
+);
+
+CyberiaQuestSchema.index({ code: 1 }, { unique: true });
+CyberiaQuestSchema.index({ sourceMapCode: 1, sourceCellX: 1, sourceCellY: 1 });
+
+const CyberiaQuestModel = model('CyberiaQuest', CyberiaQuestSchema);
+
+const ProviderSchema = CyberiaQuestSchema;
+
+export { CyberiaQuestSchema, CyberiaQuestModel, ProviderSchema };

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

@@ -0,0 +1,27 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaQuestController } from './cyberia-quest.controller.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const CyberiaQuestRouter = (options) => {
+  const router = express.Router();
+  const authMiddleware = options.authMiddleware;
+  router.post(`/:id`, async (req, res) => await CyberiaQuestController.post(req, res, options));
+  router.post(`/`, async (req, res) => await CyberiaQuestController.post(req, res, options));
+  router.get(
+    `/:id`,
+    // authMiddleware,
+    async (req, res) => await CyberiaQuestController.get(req, res, options),
+  );
+  router.get(`/`, async (req, res) => await CyberiaQuestController.get(req, res, options));
+  router.put(`/:id`, async (req, res) => await CyberiaQuestController.put(req, res, options));
+  router.put(`/`, async (req, res) => await CyberiaQuestController.put(req, res, options));
+  router.delete(`/:id`, async (req, res) => await CyberiaQuestController.delete(req, res, options));
+  router.delete(`/`, async (req, res) => await CyberiaQuestController.delete(req, res, options));
+  return router;
+};
+
+const ApiRouter = CyberiaQuestRouter;
+
+export { ApiRouter, CyberiaQuestRouter };

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

@@ -0,0 +1,42 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { DataQuery } from '../../server/data-query.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaQuestService {
+  static post = async (req, res, options) => {
+    /** @type {import('./cyberia-quest.model.js').CyberiaQuestModel} */
+    const CyberiaQuest = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaQuest;
+    return await new CyberiaQuest(req.body).save();
+  };
+  static get = async (req, res, options) => {
+    /** @type {import('./cyberia-quest.model.js').CyberiaQuestModel} */
+    const CyberiaQuest = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaQuest;
+    if (req.params.id) return await CyberiaQuest.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([
+      CyberiaQuest.find(query).sort(sort).limit(limit).skip(skip),
+      CyberiaQuest.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  };
+  static put = async (req, res, options) => {
+    /** @type {import('./cyberia-quest.model.js').CyberiaQuestModel} */
+    const CyberiaQuest = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaQuest;
+    return await CyberiaQuest.findByIdAndUpdate(req.params.id, req.body);
+  };
+  static delete = async (req, res, options) => {
+    /** @type {import('./cyberia-quest.model.js').CyberiaQuestModel} */
+    const CyberiaQuest = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaQuest;
+    if (req.params.id) return await CyberiaQuest.findByIdAndDelete(req.params.id);
+    else return await CyberiaQuest.deleteMany();
+  };
+}
+
+export { CyberiaQuestService };

package/src/api/cyberia-quest-progress/cyberia-quest-progress.controller.js

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

package/src/api/cyberia-quest-progress/cyberia-quest-progress.model.js

@@ -0,0 +1,49 @@
+import { Schema, model } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const CyberiaQuestProgressSchema = new Schema(
+  {
+    // Matches the Go relay server's player UUID
+    playerId: { type: String, required: true, trim: true },
+    // References CyberiaQuest.code
+    questCode: { type: String, required: true, trim: true },
+    // active | completed
+    // Quests do not fail — they stay active until completed or abandoned by the player.
+    status: {
+      type: String,
+      required: true,
+      enum: ['active', 'completed'],
+      default: 'active',
+    },
+    // One entry per step in the corresponding CyberiaQuest.steps[].
+    // A step is complete when all its objectiveProgress entries satisfy current >= required.
+    // The active step is the first step where not all objectives are done.
+    // done flags are intentionally omitted — completeness is always computed, never stored.
+    stepProgress: [
+      {
+        stepId: { type: String, required: true },
+        // One entry per objective in CyberiaQuest.steps[i].objectives[].
+        // `required` is denormalized from the quest definition for efficient server checks.
+        objectiveProgress: [
+          {
+            current: { type: Number, default: 0, min: 0 },
+            required: { type: Number, default: 1, min: 1 },
+          },
+        ],
+      },
+    ],
+    startedAt: { type: Date, default: Date.now },
+    completedAt: { type: Date, default: null },
+  },
+  { timestamps: true },
+);
+
+CyberiaQuestProgressSchema.index({ playerId: 1, questCode: 1 }, { unique: true });
+CyberiaQuestProgressSchema.index({ playerId: 1, status: 1 });
+
+const CyberiaQuestProgressModel = model('CyberiaQuestProgress', CyberiaQuestProgressSchema);
+
+const ProviderSchema = CyberiaQuestProgressSchema;
+
+export { CyberiaQuestProgressSchema, CyberiaQuestProgressModel, ProviderSchema };

package/src/api/cyberia-quest-progress/cyberia-quest-progress.router.js

@@ -0,0 +1,27 @@
+import { loggerFactory } from '../../server/logger.js';
+import { CyberiaQuestProgressController } from './cyberia-quest-progress.controller.js';
+import express from 'express';
+
+const logger = loggerFactory(import.meta);
+
+const CyberiaQuestProgressRouter = (options) => {
+  const router = express.Router();
+  const authMiddleware = options.authMiddleware;
+  router.post(`/:id`, async (req, res) => await CyberiaQuestProgressController.post(req, res, options));
+  router.post(`/`, async (req, res) => await CyberiaQuestProgressController.post(req, res, options));
+  router.get(
+    `/:id`,
+    // authMiddleware,
+    async (req, res) => await CyberiaQuestProgressController.get(req, res, options),
+  );
+  router.get(`/`, async (req, res) => await CyberiaQuestProgressController.get(req, res, options));
+  router.put(`/:id`, async (req, res) => await CyberiaQuestProgressController.put(req, res, options));
+  router.put(`/`, async (req, res) => await CyberiaQuestProgressController.put(req, res, options));
+  router.delete(`/:id`, async (req, res) => await CyberiaQuestProgressController.delete(req, res, options));
+  router.delete(`/`, async (req, res) => await CyberiaQuestProgressController.delete(req, res, options));
+  return router;
+};
+
+const ApiRouter = CyberiaQuestProgressRouter;
+
+export { ApiRouter, CyberiaQuestProgressRouter };

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

@@ -0,0 +1,42 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { DataQuery } from '../../server/data-query.js';
+
+const logger = loggerFactory(import.meta);
+
+class CyberiaQuestProgressService {
+  static post = async (req, res, options) => {
+    /** @type {import('./cyberia-quest-progress.model.js').CyberiaQuestProgressModel} */
+    const CyberiaQuestProgress = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaQuestProgress;
+    return await new CyberiaQuestProgress(req.body).save();
+  };
+  static get = async (req, res, options) => {
+    /** @type {import('./cyberia-quest-progress.model.js').CyberiaQuestProgressModel} */
+    const CyberiaQuestProgress = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaQuestProgress;
+    if (req.params.id) return await CyberiaQuestProgress.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([
+      CyberiaQuestProgress.find(query).sort(sort).limit(limit).skip(skip),
+      CyberiaQuestProgress.countDocuments(query),
+    ]);
+
+    const totalPages = Math.ceil(total / limit);
+    return { data, total, page, totalPages };
+  };
+  static put = async (req, res, options) => {
+    /** @type {import('./cyberia-quest-progress.model.js').CyberiaQuestProgressModel} */
+    const CyberiaQuestProgress = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaQuestProgress;
+    return await CyberiaQuestProgress.findByIdAndUpdate(req.params.id, req.body);
+  };
+  static delete = async (req, res, options) => {
+    /** @type {import('./cyberia-quest-progress.model.js').CyberiaQuestProgressModel} */
+    const CyberiaQuestProgress = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.CyberiaQuestProgress;
+    if (req.params.id) return await CyberiaQuestProgress.findByIdAndDelete(req.params.id);
+    else return await CyberiaQuestProgress.deleteMany();
+  };
+}
+
+export { CyberiaQuestProgressService };

package/src/api/default/default.controller.js

@@ -3,8 +3,8 @@ import { DefaultService } from './default.service.js';
 
 const logger = loggerFactory(import.meta);
 
-const DefaultController = {
-  post: async (req, res, options) => {
+class DefaultController {
+  static post = async (req, res, options) => {
     try {
       const result = await DefaultService.post(req, res, options);
       return res.status(200).json({
@@ -18,8 +18,8 @@ const DefaultController = {
         message: error.message,
       });
     }
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     try {
       const { page, limit } = req.query;
       const result = await DefaultService.get(
@@ -38,8 +38,8 @@ const DefaultController = {
         message: error.message,
       });
     }
-  },
-  put: async (req, res, options) => {
+  };
+  static put = async (req, res, options) => {
     try {
       const result = await DefaultService.put(req, res, options);
       return res.status(200).json({
@@ -53,8 +53,8 @@ const DefaultController = {
         message: error.message,
       });
     }
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     try {
       const result = await DefaultService.delete(req, res, options);
       return res.status(200).json({
@@ -68,7 +68,7 @@ const DefaultController = {
         message: error.message,
       });
     }
-  },
-};
+  };
+}
 
 export { DefaultController };

package/src/api/default/default.service.js

@@ -4,13 +4,13 @@ import { DataQuery } from '../../server/data-query.js';
 
 const logger = loggerFactory(import.meta);
 
-const DefaultService = {
-  post: async (req, res, options) => {
+class DefaultService {
+  static post = async (req, res, options) => {
     /** @type {import('./default.model.js').DefaultModel} */
     const Default = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Default;
     return await new Default(req.body).save();
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     /** @type {import('./default.model.js').DefaultModel} */
     const Default = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Default;
     if (req.params.id) return await Default.findById(req.params.id);
@@ -25,18 +25,18 @@ const DefaultService = {
 
     const totalPages = Math.ceil(total / limit);
     return { data, total, page, totalPages };
-  },
-  put: async (req, res, options) => {
+  };
+  static put = async (req, res, options) => {
     /** @type {import('./default.model.js').DefaultModel} */
     const Default = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Default;
     return await Default.findByIdAndUpdate(req.params.id, req.body);
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     /** @type {import('./default.model.js').DefaultModel} */
     const Default = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Default;
     if (req.params.id) return await Default.findByIdAndDelete(req.params.id);
     else return await Default.deleteMany();
-  },
-};
+  };
+}
 
 export { DefaultService };

package/src/api/document/document.controller.js

@@ -2,8 +2,8 @@ import { loggerFactory } from '../../server/logger.js';
 import { DocumentService } from './document.service.js';
 const logger = loggerFactory(import.meta);
 
-const DocumentController = {
-  post: async (req, res, options) => {
+class DocumentController {
+  static post = async (req, res, options) => {
     try {
       return res.status(200).json({
         status: 'success',
@@ -16,8 +16,8 @@ const DocumentController = {
         message: error.message,
       });
     }
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     try {
       return res.status(200).json({
         status: 'success',
@@ -30,8 +30,8 @@ const DocumentController = {
         message: error.message,
       });
     }
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     try {
       const result = await DocumentService.delete(req, res, options);
       return res.status(200).json({
@@ -45,8 +45,8 @@ const DocumentController = {
         message: error.message,
       });
     }
-  },
-  put: async (req, res, options) => {
+  };
+  static put = async (req, res, options) => {
     try {
       const result = await DocumentService.put(req, res, options);
       return res.status(200).json({
@@ -60,8 +60,8 @@ const DocumentController = {
         message: error.message,
       });
     }
-  },
-  patch: async (req, res, options) => {
+  };
+  static patch = async (req, res, options) => {
     try {
       const result = await DocumentService.patch(req, res, options);
       return res.status(200).json({
@@ -75,7 +75,7 @@ const DocumentController = {
         message: error.message,
       });
     }
-  },
-};
+  };
+}
 
 export { DocumentController };

package/src/api/document/document.model.js

@@ -1,7 +1,5 @@
 import { Schema, model, Types } from 'mongoose';
-
 // https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
-
 const DocumentSchema = new Schema(
   {
     userId: {
@@ -35,13 +33,10 @@ const DocumentSchema = new Schema(
     timestamps: true,
   },
 );
-
 const DocumentModel = model('Document', DocumentSchema);
-
 const ProviderSchema = DocumentSchema;
-
-const DocumentDto = {
-  populate: {
+class DocumentDto {
+  static populate = {
     file: () => {
       return {
         path: 'fileId',
@@ -68,34 +63,33 @@ const DocumentDto = {
         },
       };
     },
-  },
-  getTotalCopyShareLinkCount: (document) => {
+  };
+  static getTotalCopyShareLinkCount = (document) => {
     if (!document.share || !document.share.copyShareLinkEvent) return 0;
     return document.share.copyShareLinkEvent.reduce((total, event) => total + (event.count || 0), 0);
-  },
+  };
   /**
    * Filter 'public' tag from tags array
    * The 'public' tag is internal and should not be rendered to users
    * @param {string[]} tags - Array of tags
    * @returns {string[]} - Filtered tags without 'public'
    */
-  filterPublicTag: (tags) => {
+  static filterPublicTag = (tags) => {
     if (!tags || !Array.isArray(tags)) return [];
     return tags.filter((tag) => tag !== 'public');
-  },
+  };
   /**
    * Extract isPublic boolean from tags array and return cleaned tags
    * @param {string[]} tags - Array of tags potentially containing 'public'
    * @returns {{ isPublic: boolean, tags: string[] }} - Object with isPublic flag and cleaned tags
    */
-  extractPublicFromTags: (tags) => {
+  static extractPublicFromTags = (tags) => {
     if (!tags || !Array.isArray(tags)) {
       return { isPublic: false, tags: [] };
     }
     const hasPublicTag = tags.includes('public');
     const cleanedTags = tags.filter((tag) => tag !== 'public');
     return { isPublic: hasPublicTag, tags: cleanedTags };
-  },
-};
-
+  };
+}
 export { DocumentSchema, DocumentModel, ProviderSchema, DocumentDto };

package/src/api/file/file.controller.js

@@ -2,8 +2,8 @@ import { loggerFactory } from '../../server/logger.js';
 import { FileService } from './file.service.js';
 const logger = loggerFactory(import.meta);
 
-const FileController = {
-  post: async (req, res, options) => {
+class FileController {
+  static post = async (req, res, options) => {
     try {
       return res.status(200).json({
         status: 'success',
@@ -16,8 +16,8 @@ const FileController = {
         message: error.message,
       });
     }
-  },
-  get: async (req, res, options) => {
+  };
+  static get = async (req, res, options) => {
     try {
       if (req && req.headers && req.headers.origin) {
         res.set('Access-Control-Allow-Origin', req.headers.origin);
@@ -38,8 +38,8 @@ const FileController = {
         message: error.message,
       });
     }
-  },
-  delete: async (req, res, options) => {
+  };
+  static delete = async (req, res, options) => {
     try {
       const result = await FileService.delete(req, res, options);
       return res.status(200).json({
@@ -53,7 +53,7 @@ const FileController = {
         message: error.message,
       });
     }
-  },
-};
+  };
+}
 
 export { FileController };

package/src/api/file/file.model.js

@@ -47,7 +47,7 @@ const ProviderSchema = FileSchema;
  * @namespace FileModelServer.FileModelDto
  * @memberof FileModelServer
  */
-const FileModelDto = {
+class FileModelDto {
   /**
    * Returns file metadata only (no buffer data).
    * Used for list responses and API integration.
@@ -56,7 +56,7 @@ const FileModelDto = {
    * @param {Object} file - File document from database.
    * @returns {Object|null} File metadata object, or null if file is falsy.
    */
-  toMetadata: (file) => {
+  static toMetadata = (file) => {
     if (!file) return null;
     return {
       _id: file._id,
@@ -68,7 +68,7 @@ const FileModelDto = {
       createdAt: file.createdAt,
       updatedAt: file.updatedAt,
     };
-  },
+  };
 
   /**
    * Returns file with complete data.
@@ -78,7 +78,7 @@ const FileModelDto = {
    * @param {Object} file - File document from database.
    * @returns {Object|null} Complete file object with buffer data, or null if file is falsy.
    */
-  toFull: (file) => {
+  static toFull = (file) => {
     if (!file) return null;
     return {
       _id: file._id,
@@ -92,7 +92,7 @@ const FileModelDto = {
       createdAt: file.createdAt,
       updatedAt: file.updatedAt,
     };
-  },
+  };
 
   /**
    * Transforms array of files to metadata only.
@@ -101,10 +101,10 @@ const FileModelDto = {
    * @param {Array} files - Array of file documents.
    * @returns {Array} Array of file metadata objects.
    */
-  toMetadataArray: (files) => {
+  static toMetadataArray = (files) => {
     if (!Array.isArray(files)) return [];
     return files.map((file) => FileModelDto.toMetadata(file));
-  },
+  };
 
   /**
    * Ensures UTF-8 encoding for filenames.
@@ -114,14 +114,14 @@ const FileModelDto = {
    * @param {string} filename - Raw filename from upload.
    * @returns {string} UTF-8 encoded filename.
    */
-  normalizeFilename: (filename) => {
+  static normalizeFilename = (filename) => {
     if (!filename) return '';
     // Ensure string and normalize to UTF-8
     let normalized = String(filename);
     // Replace any incorrectly encoded sequences
     normalized = Buffer.from(normalized, 'utf8').toString('utf8');
     return normalized;
-  },
-};
+  };
+}
 
 export { FileSchema, FileModel, ProviderSchema, FileModelDto };