cyberia 2.8.885

package/src/api/instance/instance.controller.js

@@ -0,0 +1,69 @@
+import { loggerFactory } from '../../server/logger.js';
+import { InstanceService } from './instance.service.js';
+
+const logger = loggerFactory(import.meta);
+
+const InstanceController = {
+  post: async (req, res, options) => {
+    try {
+      const result = await InstanceService.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,
+      });
+    }
+  },
+  get: async (req, res, options) => {
+    try {
+      const result = await InstanceService.get(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,
+      });
+    }
+  },
+  put: async (req, res, options) => {
+    try {
+      const result = await InstanceService.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,
+      });
+    }
+  },
+  delete: async (req, res, options) => {
+    try {
+      const result = await InstanceService.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 { InstanceController };

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

@@ -0,0 +1,40 @@
+import { Schema, model, Types } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const InstanceSchema = new Schema(
+  {
+    deployId: { type: String },
+    host: { type: String },
+    path: { type: String },
+    port: { type: String },
+    client: { type: String },
+    runtime: { type: String },
+    userId: {
+      type: Schema.Types.ObjectId,
+      ref: 'User',
+    },
+    apis: [{ type: String }],
+  },
+  {
+    timestamps: true,
+  },
+);
+
+const InstanceDto = {
+  populate: {
+    get: () => {
+      return {
+        path: 'userId',
+        model: 'User',
+        select: '_id email',
+      };
+    },
+  },
+};
+
+const InstanceModel = model('Instance', InstanceSchema);
+
+const ProviderSchema = InstanceSchema;
+
+export { InstanceSchema, InstanceModel, ProviderSchema, InstanceDto };

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

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

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

@@ -0,0 +1,70 @@
+import { DataBaseProvider } from '../../db/DataBaseProvider.js';
+import { loggerFactory } from '../../server/logger.js';
+import { InstanceDto } from './instance.model.js';
+
+const logger = loggerFactory(import.meta);
+
+const InstanceService = {
+  post: async (req, res, options) => {
+    /** @type {import('./instance.model.js').InstanceModel} */
+    const Instance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Instance;
+    return await new Instance(req.body).save();
+  },
+  get: async (req, res, options) => {
+    /** @type {import('./instance.model.js').InstanceModel} */
+    const Instance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Instance;
+
+    /** @type {import('../user/user.model.js').UserModel} */
+    const User = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.User;
+
+    const user = await User.findOne({
+      _id: req.auth.user._id,
+    });
+    switch (req.params.id) {
+      case 'count': {
+        switch (user.role) {
+          case 'admin':
+            return { total: await Instance.countDocuments() };
+          default:
+            return { total: await Instance.countDocuments({ userId: req.auth.user._id }) };
+        }
+      }
+      default:
+        const { page = 1, limit = 10, sort = { updatedAt: -1 } } = req.query;
+        const skip = (page - 1) * limit;
+
+        switch (user.role) {
+          case 'admin':
+            if (req.params.id) return await Instance.findById(req.params.id);
+            const [dataAdmin, totalAdmin] = await Promise.all([
+              Instance.find({}).sort(sort).limit(limit).skip(skip).populate(InstanceDto.populate.get()),
+              Instance.countDocuments({}),
+            ]);
+            return { data: dataAdmin, total: totalAdmin, page, totalPages: Math.ceil(totalAdmin / limit) };
+          default:
+            const [dataUser, totalUser] = await Promise.all([
+              Instance.find({ userId: req.auth.user._id })
+                .sort(sort)
+                .limit(limit)
+                .skip(skip)
+                .populate(InstanceDto.populate.get()),
+              Instance.countDocuments({ userId: req.auth.user._id }),
+            ]);
+            return { data: dataUser, total: totalUser, page, totalPages: Math.ceil(totalUser / limit) };
+        }
+    }
+  },
+  put: async (req, res, options) => {
+    /** @type {import('./instance.model.js').InstanceModel} */
+    const Instance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Instance;
+    return await Instance.findByIdAndUpdate(req.params.id, req.body);
+  },
+  delete: async (req, res, options) => {
+    /** @type {import('./instance.model.js').InstanceModel} */
+    const Instance = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Instance;
+    if (req.params.id) return await Instance.findByIdAndDelete(req.params.id);
+    else return await Instance.deleteMany();
+  },
+};
+
+export { InstanceService };

package/src/api/ipfs/ipfs.controller.js

@@ -0,0 +1,51 @@
+import { loggerFactory } from '../../server/logger.js';
+import { IPFSService } from './ipfs.service.js';
+const logger = loggerFactory(import.meta);
+
+const IPFSController = {
+  post: async (req, res, options) => {
+    try {
+      return res.status(200).json({
+        status: 'success',
+        data: await IPFSService.post(req, res, options),
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+  get: async (req, res, options) => {
+    try {
+      return res.status(200).json({
+        status: 'success',
+        data: await IPFSService.get(req, res, options),
+      });
+    } catch (error) {
+      logger.error(error, error.stack);
+      return res.status(400).json({
+        status: 'error',
+        message: error.message,
+      });
+    }
+  },
+  delete: async (req, res, options) => {
+    try {
+      const result = await IPFSService.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 { IPFSController };

package/src/api/ipfs/ipfs.model.js

@@ -0,0 +1,17 @@
+import { Schema, model } from 'mongoose';
+
+// https://mongoosejs.com/docs/2.7.x/docs/schematypes.html
+
+const PinSchema = new Schema({
+  userId: {
+    type: Schema.Types.ObjectId,
+    ref: 'User',
+  },
+  cid: { type: String },
+});
+
+const PinModel = model('Pin', PinSchema);
+
+const ProviderSchema = PinSchema;
+
+export { PinSchema, PinModel, ProviderSchema };

package/src/api/ipfs/ipfs.router.js

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

package/src/api/ipfs/ipfs.service.js

@@ -0,0 +1,25 @@
+import { loggerFactory } from '../../server/logger.js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+const logger = loggerFactory(import.meta);
+
+const IPFSService = {
+  post: async (req, res, options) => {
+    switch (req.params.id) {
+      default:
+    }
+  },
+  get: async (req, res, options) => {
+    switch (req.params.id) {
+      default:
+    }
+  },
+  delete: async (req, res, options) => {
+    switch (req.params.id) {
+      default:
+    }
+  },
+};
+
+export { IPFSService };

package/src/api/object-layer/README.md

@@ -0,0 +1,85 @@
+<p align="center">
+  <img src="https://www.cyberiaonline.com/assets/splash/apple-touch-icon-precomposed.png" alt="CYBERIA Network Object Layer Engine CLI"/>
+</p>
+
+<div align="center">
+
+<h1>cyberia</h1>
+
+<h2>Network Object Layer Engine CLI</h2>
+
+[![Downloads](https://img.shields.io/npm/dm/cyberia.svg)](https://www.npmjs.com/package/cyberia) [![Version](https://img.shields.io/npm/v/cyberia.svg)](https://www.npmjs.org/package/cyberia)
+
+</div>
+
+This Command Line Interface (CLI) is a core tool for the **Cyberia Network Object Layer Engine**, specifically designed for processing, generating, and managing game assets, primarily **Object Layer** elements like skins, floors, and weapons.
+
+It handles image asset quantization, generates data matrices and color palettes, and persists the resulting structured data into the game's database.
+
+## **🚀 Getting Started**
+
+### **Prerequisites**
+
+You must have the following installed in your environment:
+
+- **Node.js** (v24.10.0 recommended)
+- **npm** or **yarn**
+- **MongoDB** (or access to the configured MongoDB instance)
+
+### **Installation**
+
+1. **Clone the Repository** (If applicable):  
+   git clone \[Your Repository URL\]  
+   cd \[Your Project Directory\]
+
+2. **Install Dependencies:**  
+   npm install  
+   \# or  
+   yarn install
+
+3. Environment Setup:  
+   Ensure your required environment variables (e.g., DEFAULT_DEPLOY_ID, DEFAULT_DEPLOY_HOST, DEFAULT_DEPLOY_PATH) are correctly configured, typically in a .env file, to point the CLI to the correct database instance defined in conf.server.json.
+
+## **🛠️ Usage**
+
+The CLI is executed via Node.js, running the primary script cyberia.js. You can use your project's package.json scripts or run it directly.
+
+The main execution pattern is:
+
+node cyberia.js \[command\] \[options\]
+
+### **Main Commands**
+
+#### **1\. Processing and Saving Object Layer Assets**
+
+The primary function of this CLI is to process raw PNG/GIF assets, convert them into game-ready tile matrices and color palettes, and store the final data object in the database.
+
+| Option                  | Description                                                                                                                                                                                                                                 |
+| :---------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| \--process-object-layer | Iterates through all asset directories (/cyberia/assets/{type}/{id}/{direction}/{frame}), runs the frameFactory quantization logic, generates map_color and frame_matrix, and saves the final object to the database (with a SHA-256 hash). |
+
+**Example:** To process all defined assets (skins, floors, etc.):
+
+node cyberia.js \--process-object-layer
+
+#### **2\. Visualizing Processed Frames**
+
+This command allows developers to quickly visualize a single processed frame matrix, regenerating a standard PNG image from the tile data. This is useful for debugging the asset processing and quantization logic.
+
+| Option        | Format                             | Description                                                                                                                 |
+| :------------ | :--------------------------------- | :-------------------------------------------------------------------------------------------------------------------------- |
+| \--show-frame | objectLayerId_direction_frameIndex | Takes a processed asset ID, direction, and frame index, reconstructs the PNG, saves it locally, and opens it using firefox. |
+
+**Example:** To show the first frame (index 0\) of the skin-001 asset in direction 08:
+
+node cyberia.js \--show-frame skin-001_08_0
+
+This will create a file named skin-001_08_0.png in the current directory and open it.
+
+## **⚙️ Core Logic (from object-layer.js)**
+
+The CLI relies on the logic provided by the ObjectLayerEngine class, which handles:
+
+- **pngDirectoryIteratorByObjectLayerType**: Walks the file system to find all relevant asset files.
+- **frameFactory**: The core image processing method that converts raw image data (PNG/GIF) into a grid of color indices (frame_matrix) and a global color palette (map_color).
+- **buildImgFromTile**: Reverses the process, taking the stored frame_matrix and map_color to reconstruct and save a visual PNG.

package/src/api/object-layer/object-layer.controller.js

@@ -0,0 +1,69 @@
+import { loggerFactory } from '../../server/logger.js';
+import { ObjectLayerService } from './object-layer.service.js';
+
+const logger = loggerFactory(import.meta);
+
+const ObjectLayerController = {
+  post: async (req, res, options) => {
+    try {
+      const result = await ObjectLayerService.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,
+      });
+    }
+  },
+  get: async (req, res, options) => {
+    try {
+      const result = await ObjectLayerService.get(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,
+      });
+    }
+  },
+  put: async (req, res, options) => {
+    try {
+      const result = await ObjectLayerService.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,
+      });
+    }
+  },
+  delete: async (req, res, options) => {
+    try {
+      const result = await ObjectLayerService.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 { ObjectLayerController };

package/src/api/object-layer/object-layer.model.js

@@ -0,0 +1,181 @@
+/**
+ * Object layer model for managing the generation and deployment of cloud-init configuration files
+ * and associated scripts for baremetal provisioning.
+ * @module src/api/object-layer/object-layer.model.js
+ * @namespace CyberiaObjectLayerModel
+ */
+
+import { Schema, model } from 'mongoose';
+
+/**
+ * @typedef {Object} Stats
+ * @property {number} effect - The effect attribute value
+ * @property {number} resistance - The resistance attribute value
+ * @property {number} agility - The agility attribute value
+ * @property {number} range - The range attribute value
+ * @property {number} intelligence - The intelligence attribute value
+ * @property {number} utility - The utility attribute value
+ * @memberof CyberiaObjectLayerModel
+ */
+const StatsSchema = new Schema(
+  {
+    effect: { type: Number, required: true, min: 0 },
+    resistance: { type: Number, required: true, min: 0 },
+    agility: { type: Number, required: true, min: 0 },
+    range: { type: Number, required: true, min: 0 },
+    intelligence: { type: Number, required: true, min: 0 },
+    utility: { type: Number, required: true, min: 0 },
+  },
+  { _id: false },
+);
+
+/**
+ * @typedef {Object} RenderFrames
+ * @property {number[][][]} up_idle - Up idle animation frames
+ * @property {number[][][]} down_idle - Down idle animation frames
+ * @property {number[][][]} right_idle - Right idle animation frames
+ * @property {number[][][]} left_idle - Left idle animation frames
+ * @property {number[][][]} up_right_idle - Up-right idle animation frames
+ * @property {number[][][]} down_right_idle - Down-right idle animation frames
+ * @property {number[][][]} up_left_idle - Up-left idle animation frames
+ * @property {number[][][]} down_left_idle - Down-left idle animation frames
+ * @property {number[][][]} default_idle - Default idle animation frames
+ * @property {number[][][]} up_walking - Up walking animation frames
+ * @property {number[][][]} down_walking - Down walking animation frames
+ * @property {number[][][]} right_walking - Right walking animation frames
+ * @property {number[][][]} left_walking - Left walking animation frames
+ * @property {number[][][]} up_right_walking - Up-right walking animation frames
+ * @property {number[][][]} down_right_walking - Down-right walking frames
+ * @property {number[][][]} up_left_walking - Up-left walking animation frames
+ * @property {number[][][]} down_left_walking - Down-left walking frames
+ * @property {number[][][]} none_idle - None state animation frames
+ * @memberof CyberiaObjectLayerModel
+ */
+const RenderFramesSchema = new Schema(
+  {
+    up_idle: { type: [[[Number]]], default: [] },
+    down_idle: { type: [[[Number]]], default: [] },
+    right_idle: { type: [[[Number]]], default: [] },
+    left_idle: { type: [[[Number]]], default: [] },
+    up_right_idle: { type: [[[Number]]], default: [] },
+    down_right_idle: { type: [[[Number]]], default: [] },
+    up_left_idle: { type: [[[Number]]], default: [] },
+    down_left_idle: { type: [[[Number]]], default: [] },
+    default_idle: { type: [[[Number]]], default: [] },
+    up_walking: { type: [[[Number]]], default: [] },
+    down_walking: { type: [[[Number]]], default: [] },
+    right_walking: { type: [[[Number]]], default: [] },
+    left_walking: { type: [[[Number]]], default: [] },
+    up_right_walking: { type: [[[Number]]], default: [] },
+    down_right_walking: { type: [[[Number]]], default: [] },
+    up_left_walking: { type: [[[Number]]], default: [] },
+    down_left_walking: { type: [[[Number]]], default: [] },
+    none_idle: { type: [[[Number]]], default: [] },
+  },
+  { _id: false },
+);
+
+/**
+ * @typedef {Object} Render
+ * @property {RenderFrames} frames - Animation frames for different states
+ * @property {number[][]} colors - Color palette for rendering
+ * @property {number} frame_duration - Duration of each frame in milliseconds
+ * @property {boolean} is_stateless - Whether the render is stateless
+ * @memberof CyberiaObjectLayerModel
+ */
+const RenderSchema = new Schema(
+  {
+    frames: { type: RenderFramesSchema, required: true },
+    colors: { type: [[Number]], required: true },
+    frame_duration: { type: Number, required: true, min: 0 },
+    is_stateless: { type: Boolean, default: false },
+  },
+  { _id: false },
+);
+
+/**
+ * @typedef {Object} Item
+ * @property {string} id - Unique identifier for the item
+ * @property {string} type - Type of the item
+ * @property {string} description - Description of the item
+ * @property {boolean} activable - Whether the item can be activated
+ * @memberof CyberiaObjectLayerModel
+ */
+const ItemSchema = new Schema(
+  {
+    id: { type: String, required: true, trim: true },
+    type: { type: String, required: true, trim: true },
+    description: { type: String, default: '', trim: true },
+    activable: { type: Boolean, default: false },
+  },
+  { _id: false },
+);
+
+/**
+ * @typedef {Object} ObjectLayer
+ * @property {Object} data - Object layer data
+ * @property {Data.Stats} data.stats - Statistical attributes of the object layer
+ * @property {Data.Render} data.render - Rendering information and animations
+ * @property {Data.Item} data.item - Item information this layer represents
+ * @property {string} sha256 - SHA-256 hash of the object layer data
+ * @property {Date} createdAt - When the document was created
+ * @property {Date} updatedAt - When the document was last updated
+ * @memberof CyberiaObjectLayerModel
+ */
+const ObjectLayerSchema = new Schema(
+  {
+    data: {
+      stats: { type: StatsSchema, required: true },
+      render: { type: RenderSchema, required: true },
+      item: { type: ItemSchema, required: true },
+    },
+    sha256: {
+      type: String,
+      required: true,
+      unique: true,
+      match: [/^[a-f0-9]{64}$/, 'Please provide a valid SHA-256 hash'],
+    },
+  },
+  {
+    timestamps: true,
+    toJSON: { virtuals: true },
+    toObject: { virtuals: true },
+  },
+);
+
+// Index for faster querying
+ObjectLayerSchema.index({ 'data.item.id': 1 });
+ObjectLayerSchema.index({ 'data.item.type': 1 });
+ObjectLayerSchema.index({ sha256: 1 }, { unique: true });
+
+// Add text index for searchable fields
+ObjectLayerSchema.index(
+  {
+    'data.item.id': 'text',
+    'data.item.type': 'text',
+    'data.item.description': 'text',
+  },
+  {
+    weights: {
+      'data.item.id': 10,
+      'data.item.type': 5,
+      'data.item.description': 1,
+    },
+  },
+);
+
+// Pre-save hook to ensure data consistency
+ObjectLayerSchema.pre('save', function (next) {
+  // Ensure all required fields are present
+  if (!this.data.stats || !this.data.render || !this.data.item || !this.sha256) {
+    throw new Error('Missing required fields');
+  }
+  next();
+});
+
+// Create and export the model
+const ObjectLayerModel = model('ObjectLayer', ObjectLayerSchema);
+
+const ProviderSchema = ObjectLayerSchema;
+
+export { ObjectLayerSchema, ObjectLayerModel, ProviderSchema };