@ozdao/martyrs 0.2.551 → 0.2.552

package/dist/rents.server.cjs

@@ -1,509 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const index = require("./index-BFxqqmgh.cjs");
-const core_abac = require("./core.abac-DqDvtkHR.cjs");
-const core_logger = require("./core.logger-BuW7JHMY.cjs");
-const core_verifier = require("./core.verifier-Bi-XLEi9.cjs");
-const queryProcessor = require("./queryProcessor-DJUTwCLN.cjs");
-const queryValidatorConfig = {
-  // status: { rule: 'optional', validator: Validator.schema().string().oneOf(['published', 'pending']), default: 'pending' },
-  owner: { rule: "optional", validator: core_verifier.Validator.schema().string(), default: null },
-  order: { rule: "optional", validator: core_verifier.Validator.schema().string(), default: null },
-  dateStart: { rule: "optional", validator: core_verifier.Validator.schema().date(), default: null },
-  dateEnd: { rule: "optional", validator: core_verifier.Validator.schema().date(), default: null },
-  startDate: { rule: "optional", validator: core_verifier.Validator.schema().date(), default: null },
-  endDate: { rule: "optional", validator: core_verifier.Validator.schema().date(), default: null },
-  sortParam: { rule: "optional", validator: core_verifier.Validator.schema().string(), default: null },
-  sortOrder: {
-    rule: "optional",
-    validator: core_verifier.Validator.schema().string().oneOf(["asc", "desc"]),
-    default: "asc"
-  },
-  skip: { rule: "optional", validator: core_verifier.Validator.schema().number().integer().min(0), default: 0 },
-  limit: {
-    rule: "optional",
-    validator: core_verifier.Validator.schema().number().integer().min(1).max(1e3),
-    default: 1e3
-  },
-  productId: { rule: "optional", validator: core_verifier.Validator.schema().string(), default: null },
-  variantId: { rule: "optional", validator: core_verifier.Validator.schema().string(), default: null }
-};
-const bodyValidatorConfig = {
-  // _id: { rule: 'optional', validator: Validator.schema().string() },
-  // order: { rule: 'optional', validator: Validator.schema().string() },
-  product: { rule: "optional", validator: core_verifier.Validator.schema().string().required() },
-  variant: { rule: "optional", validator: core_verifier.Validator.schema().string() },
-  // quantity: { rule: 'optional', validator: Validator.schema().number().integer().min(1).required() },
-  startDate: { rule: "optional", validator: core_verifier.Validator.schema().date().required() },
-  endDate: { rule: "optional", validator: core_verifier.Validator.schema().date().required() },
-  status: {
-    rule: "optional",
-    validator: core_verifier.Validator.schema().string().oneOf(["pending", "confirmed", "active", "completed", "canceled"]),
-    default: "pending"
-  },
-  creator: {
-    rule: "optional",
-    validator: core_verifier.Validator.schema().object({
-      type: core_verifier.Validator.schema().string().oneOf(["user", "organization", "customer", "User", "Organization", "Customer"]).required(),
-      target: core_verifier.Validator.schema().string().required()
-    }).required()
-  },
-  owner: {
-    rule: "optional",
-    validator: core_verifier.Validator.schema().object({
-      type: core_verifier.Validator.schema().string().oneOf(["organization", "Organization"]).required(),
-      target: core_verifier.Validator.schema().string().required()
-    }).required()
-  },
-  comment: { rule: "optional", validator: core_verifier.Validator.schema().string(), default: "" }
-};
-const queryVerifier = new core_verifier.Verifier(queryValidatorConfig);
-const bodyVerifier = new core_verifier.Verifier(bodyValidatorConfig);
-const controller = (db) => {
-  const Rent = db.rent;
-  const logger = new core_logger.LoggerNamespaced(db);
-  const cache = new core_logger.CacheNamespaced({ ttlSeconds: 300 });
-  const cacheMetadata = /* @__PURE__ */ new Map();
-  const invalidateCacheForRent = async (rentId, productId, startDate, endDate) => {
-    const specificTags = [`rent:${rentId}`, `product:${productId}`];
-    await cache.delByTags(specificTags);
-    if (!startDate || !endDate) {
-      await logger.info(`Cache invalidated for specific rent:${rentId} and product:${productId}`);
-      return;
-    }
-    const keysToInvalidate = [];
-    for (const [cacheKey, metadata] of cacheMetadata.entries()) {
-      if ((!metadata.dateStart || new Date(metadata.dateStart) <= new Date(endDate)) && (!metadata.dateEnd || new Date(metadata.dateEnd) >= new Date(startDate))) {
-        keysToInvalidate.push(cacheKey);
-      }
-    }
-    if (keysToInvalidate.length > 0) {
-      for (const key of keysToInvalidate) {
-        await cache.del(key);
-        cacheMetadata.delete(key);
-      }
-      await logger.info(`Invalidated ${keysToInvalidate.length} date-related cache entries for rent:${rentId}`);
-    }
-  };
-  const read = async (req, res) => {
-    try {
-      const validationResult = queryVerifier.verify(req.query, {
-        applyDefaults: true,
-        removeInvalid: true
-      });
-      if (!validationResult.isValid) {
-        await logger.info(`Invalid query parameters: ${JSON.stringify(validationResult.verificationErrors)}`);
-        return res.status(400).json({
-          errorCode: "INVALID_QUERY_PARAMS",
-          message: "Invalid query parameters.",
-          details: validationResult.verificationErrors
-        });
-      }
-      const verifiedData = validationResult.verifiedData;
-      const cacheKey = `rents:${JSON.stringify(verifiedData)}`;
-      const cachedResult = await cache.get(cacheKey);
-      if (cachedResult) {
-        await logger.info(`Cache hit for key: ${cacheKey}`);
-        return res.status(200).json(cachedResult);
-      }
-      const stages = [
-        // Базовые фильтры
-        ...queryProcessor.queryProcessorCore.getBasicOptions(verifiedData),
-        // Фильтр по датам
-        ...queryProcessor.queryProcessorCore.getFilterDate(verifiedData.dateStart, verifiedData.dateEnd, {
-          start: "startDate",
-          end: "endDate"
-        }),
-        // Добавляем lookup продуктов
-        {
-          $lookup: {
-            from: "products",
-            localField: "product",
-            foreignField: "_id",
-            as: "productDetails"
-          }
-        },
-        {
-          $unwind: {
-            path: "$productDetails",
-            preserveNullAndEmptyArrays: true
-          }
-        },
-        // Добавляем стейджи для creator и owner
-        queryProcessor.queryProcessorCore.getCreatorUserLookupStage(),
-        queryProcessor.queryProcessorCore.getCreatorOrganizationLookupStage(),
-        queryProcessor.queryProcessorCore.getCreatorCustomerLookupStage(),
-        queryProcessor.queryProcessorCore.getOwnerUserLookupStage(),
-        queryProcessor.queryProcessorCore.getOwnerOrganizationLookupStage(),
-        queryProcessor.queryProcessorCore.getAddFieldsCreatorOwnerStage(),
-        // Проекция нужных полей
-        {
-          $project: {
-            product: 1,
-            productDetails: 1,
-            quantity: 1,
-            startDate: 1,
-            endDate: 1,
-            status: 1,
-            creator: 1,
-            owner: 1,
-            comment: 1
-          }
-        },
-        // Удаляем временные свойства
-        queryProcessor.queryProcessorCore.removeTempPropeties(),
-        // Сортировка и пагинация
-        ...queryProcessor.queryProcessorCore.getSortingOptions(verifiedData.sortParam, verifiedData.sortOrder),
-        ...queryProcessor.queryProcessorCore.getPaginationOptions(verifiedData.skip, verifiedData.limit)
-      ];
-      const results = await Rent.aggregate(stages);
-      const tags = results.map((rent) => [`rent:${rent._id}`, `product:${rent.product}`]).flat();
-      cacheMetadata.set(cacheKey, {
-        dateStart: verifiedData.dateStart,
-        dateEnd: verifiedData.dateEnd,
-        timestamp: Date.now()
-      });
-      await cache.setWithTags(cacheKey, results, tags);
-      await logger.info(`Rents fetched and cached: ${results.length} items`);
-      return res.status(200).json(results);
-    } catch (err) {
-      console.log(err);
-      await logger.error(`Error fetching rents: ${err.message}`);
-      const errorCode = err.name === "MongoError" ? "DATABASE_ERROR" : "INTERNAL_SERVER_ERROR";
-      return res.status(500).json({ errorCode, message: "Error occurred.", details: err.message });
-    }
-  };
-  const create = async (req, res) => {
-    try {
-      const validationResult = bodyVerifier.verify(req.body, {
-        applyDefaults: true,
-        removeInvalid: false
-      });
-      if (!validationResult || !validationResult.isValid) {
-        console.log(validationResult);
-        await logger.info(`Invalid request body: ${JSON.stringify(validationResult.verificationErrors)}`);
-        return res.status(400).json({
-          errorCode: "INVALID_BODY",
-          message: "Invalid request body.",
-          details: validationResult.verificationErrors
-        });
-      }
-      const rent = await Rent.create(validationResult.verifiedData);
-      const populatedRent = await Rent.findById(rent._id).populate("product");
-      await logger.info(`Rent created: ${rent._id}`);
-      await invalidateCacheForRent(rent._id, rent.product, rent.startDate, rent.endDate);
-      return res.status(201).json(populatedRent);
-    } catch (err) {
-      console.log(err);
-      await logger.error(`Error creating rent: ${err.message}`);
-      const errorCode = err.name === "MongoError" ? "DATABASE_ERROR" : "INTERNAL_SERVER_ERROR";
-      return res.status(500).json({ errorCode, message: "Error occurred while creating rent.", details: err.message });
-    }
-  };
-  const cleanupCacheMetadata = () => {
-    const now = Date.now();
-    const maxAge = 24 * 60 * 60 * 1e3;
-    for (const [key, metadata] of cacheMetadata.entries()) {
-      if (now - metadata.timestamp > maxAge) {
-        cacheMetadata.delete(key);
-      }
-    }
-  };
-  setInterval(cleanupCacheMetadata, 60 * 60 * 1e3);
-  const update = async (req, res) => {
-    try {
-      const validationResult = bodyVerifier.verify(req.body, {
-        applyDefaults: false,
-        removeInvalid: false
-      });
-      if (!validationResult || !validationResult.isValid) {
-        await logger.info(`Invalid update body: ${JSON.stringify(validationResult.verificationErrors)}`);
-        return res.status(400).json({
-          errorCode: "INVALID_BODY",
-          message: "Invalid request body.",
-          details: validationResult.verificationErrors
-        });
-      }
-      const { _id, ...updateData } = validationResult.verifiedData;
-      const updatedRent = await Rent.findOneAndUpdate({ _id }, updateData, { new: true }).populate("product");
-      if (!updatedRent) {
-        await logger.info(`Rent not found for update: ${_id}`);
-        return res.status(404).json({ errorCode: "RENT_NOT_FOUND", message: "Rent not found." });
-      }
-      await logger.info(`Rent updated: ${_id}`);
-      await invalidateCacheForRent(_id, updatedRent.product);
-      return res.status(200).json(updatedRent);
-    } catch (err) {
-      await logger.error(`Error updating rent: ${err.message}`);
-      const errorCode = err.name === "MongoError" ? "DATABASE_ERROR" : "INTERNAL_SERVER_ERROR";
-      return res.status(500).json({ errorCode, message: "Error occurred while updating rent.", details: err.message });
-    }
-  };
-  const deleteRent = async (req, res) => {
-    try {
-      const validationResult = bodyVerifier.verify({ _id: req.body._id }, { applyDefaults: false, removeInvalid: false });
-      if (!validationResult || !validationResult.isValid) {
-        await logger.info(`Invalid delete body: ${JSON.stringify(validationResult.verificationErrors)}`);
-        return res.status(400).json({
-          errorCode: "INVALID_BODY",
-          message: "Invalid request body.",
-          details: validationResult.verificationErrors
-        });
-      }
-      const { _id } = validationResult.verifiedData;
-      const rentToDelete = await Rent.findById(_id);
-      if (!rentToDelete) {
-        await logger.info(`Rent not found for deletion: ${_id}`);
-        return res.status(404).json({ errorCode: "RENT_NOT_FOUND", message: "Rent not found." });
-      }
-      const deletedRent = await Rent.findOneAndDelete({ _id }).populate("product");
-      await logger.info(`Rent deleted: ${_id}`);
-      await invalidateCacheForRent(_id, rentToDelete.product);
-      return res.status(200).json(deletedRent);
-    } catch (err) {
-      await logger.error(`Error deleting rent: ${err.message}`);
-      const errorCode = err.name === "MongoError" ? "DATABASE_ERROR" : "INTERNAL_SERVER_ERROR";
-      return res.status(500).json({ errorCode, message: "Error occurred while deleting rent.", details: err.message });
-    }
-  };
-  const getAvailability = async (req, res) => {
-    try {
-      const validationResult = queryVerifier.verify(req.query, {
-        applyDefaults: true,
-        removeInvalid: true,
-        only: ["productId", "variantId", "startDate", "endDate"]
-      });
-      if (!validationResult || !validationResult.isValid) {
-        await logger.info(`Invalid query parameters: ${JSON.stringify(validationResult.verificationErrors)}`);
-        return res.status(400).json({
-          errorCode: "INVALID_QUERY_PARAMS",
-          message: "Invalid query parameters.",
-          details: validationResult.verificationErrors
-        });
-      }
-      const { productId, variantId, startDate, endDate } = validationResult.verifiedData;
-      if (!productId || !startDate || !endDate) {
-        return res.status(400).json({
-          errorCode: "MISSING_REQUIRED_PARAMS",
-          message: "productId, startDate, and endDate are required parameters."
-        });
-      }
-      const cacheKey = `availability:${productId}:${variantId || "no-variant"}:${startDate}:${endDate}`;
-      const cachedResult = await cache.get(cacheKey);
-      if (cachedResult) {
-        await logger.info(`Cache hit for availability: ${cacheKey}`);
-        return res.status(200).json(cachedResult);
-      }
-      let totalAvailable = 0;
-      if (variantId) {
-        const stockAvailabilities = await db.stockAvailability.find({ variant: variantId });
-        totalAvailable = stockAvailabilities.reduce((sum, stock) => sum + (stock.available || 0), 0);
-        if (totalAvailable === 0) {
-          await logger.info(`Variant not found or no stock available: ${variantId}`);
-          return res.status(404).json({ errorCode: "VARIANT_NOT_FOUND", message: "Variant not found or no stock available." });
-        }
-      } else {
-        const stockAvailabilities = await db.stockAvailability.find({ product: productId, variant: { $exists: false } });
-        totalAvailable = stockAvailabilities.reduce((sum, stock) => sum + (stock.available || 0), 0);
-        if (totalAvailable === 0) {
-          const product = await db.product.findById(productId);
-          if (!product) {
-            await logger.info(`Product not found: ${productId}`);
-            return res.status(404).json({ errorCode: "PRODUCT_NOT_FOUND", message: "Product not found." });
-          }
-          totalAvailable = product.quantity || 1;
-        }
-      }
-      const start = /* @__PURE__ */ new Date(`${startDate}T00:00:00Z`);
-      const end = /* @__PURE__ */ new Date(`${endDate}T23:59:59Z`);
-      const dateRange = [];
-      for (let dt = new Date(start); dt <= end; dt.setUTCDate(dt.getUTCDate() + 1)) {
-        dateRange.push(new Date(dt));
-      }
-      const rentQuery = {
-        product: productId,
-        status: { $in: ["pending", "confirmed", "active"] },
-        $or: [{ startDate: { $lte: end }, endDate: { $gte: start } }]
-      };
-      if (variantId) {
-        rentQuery.variant = variantId;
-      }
-      const activeRents = await Rent.find(rentQuery);
-      const availabilityByDate = dateRange.map((date) => {
-        const dateStr = date.toISOString().split("T")[0];
-        let rentedQuantity = 0;
-        activeRents.forEach((rent) => {
-          const rentStart = new Date(rent.startDate);
-          const rentEnd = new Date(rent.endDate);
-          if (date >= rentStart && date <= rentEnd) {
-            rentedQuantity += rent.quantity;
-          }
-        });
-        const available = Math.max(0, totalAvailable - rentedQuantity);
-        return {
-          date: dateStr,
-          totalQuantity: totalAvailable,
-          rentedQuantity,
-          availableQuantity: available
-        };
-      });
-      const result = {
-        productId,
-        variantId: variantId || null,
-        period: {
-          startDate: start.toISOString().split("T")[0],
-          endDate: end.toISOString().split("T")[0]
-        },
-        availability: availabilityByDate
-      };
-      await cache.setWithTags(cacheKey, result, [`product:${productId}`]);
-      await logger.info(`Availability calculated for product: ${productId}`);
-      return res.status(200).json(result);
-    } catch (err) {
-      await logger.error(`Error checking availability: ${err.message}`);
-      const errorCode = err.name === "MongoError" ? "DATABASE_ERROR" : "INTERNAL_SERVER_ERROR";
-      return res.status(500).json({
-        errorCode,
-        message: "Error occurred while checking availability.",
-        details: err.message
-      });
-    }
-  };
-  return {
-    read,
-    create,
-    update,
-    delete: deleteRent,
-    getAvailability
-  };
-};
-const { getInstance } = core_abac.coreabac;
-const RentRoutes = (function(app, db) {
-  const controller$1 = controller(db);
-  const abac = getInstance(db);
-  const { authJwt } = index.middlewareIndexFactory(db);
-  app.get(
-    "/api/rents",
-    [
-      authJwt.verifyToken(),
-      // Требуется аутентификация
-      abac.middleware("rents", "read")
-    ],
-    controller$1.read
-  );
-  app.post(
-    "/api/rents",
-    [
-      authJwt.verifyToken(),
-      // Требуется аутентификация
-      abac.middleware("rents", "create")
-      // Проверка прав доступа
-      // verifyRent.checkRequiredFields, // Проверка обязательных полей
-      // verifyRent.checkAvailability // Проверка доступности
-    ],
-    controller$1.create
-  );
-  app.put(
-    "/api/rents/update",
-    [
-      authJwt.verifyToken(),
-      // Требуется аутентификация
-      abac.middleware("rents", "update")
-      // Проверка прав доступа
-    ],
-    controller$1.update
-  );
-  app.delete(
-    "/api/rents/:id",
-    [
-      authJwt.verifyToken(),
-      // Требуется аутентификация
-      abac.middleware("rents", "delete")
-      // Проверка прав доступа
-    ],
-    controller$1.delete
-  );
-  app.get(
-    "/api/rents/availability",
-    [
-      authJwt.verifyToken(true),
-      abac.middleware("rents", "read", {
-        allowUnauthenticated: true
-        // Разрешить неаутентифицированным пользователям
-      })
-    ],
-    controller$1.getAvailability
-  );
-});
-const RentModel = (db, additionalFields = {}) => {
-  const RentSchema = new db.mongoose.Schema({
-    order: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: "Order",
-      default: null
-    },
-    product: { type: db.mongoose.Schema.Types.ObjectId, ref: "Product", required: true },
-    variant: { type: db.mongoose.Schema.Types.ObjectId, ref: "Variant", default: null },
-    quantity: {
-      type: Number,
-      required: true,
-      min: 1,
-      default: 1
-    },
-    startDate: {
-      type: Date,
-      required: true
-    },
-    endDate: {
-      type: Date,
-      required: true
-    },
-    status: {
-      type: String,
-      enum: ["pending", "confirmed", "active", "completed", "canceled"],
-      default: "pending"
-    },
-    creator: {
-      type: {
-        type: String,
-        enum: ["user", "organization", "customer", "User", "Organization", "Customer"],
-        required: true
-      },
-      target: { type: db.mongoose.Schema.Types.ObjectId, required: true }
-    },
-    owner: {
-      type: {
-        type: String,
-        enum: ["user", "organization", "customer", "User", "Organization", "Customer"],
-        required: true
-      },
-      target: { type: db.mongoose.Schema.Types.ObjectId, required: true }
-    },
-    comment: { type: String, default: "" },
-    ...additionalFields
-  });
-  return db.mongoose.model("Rent", RentSchema);
-};
-function initializeRenting(app, db, origins, publicPath, options = {}) {
-  const { rentFields = {} } = options;
-  db.rent = RentModel(db, rentFields);
-  if (app) {
-    RentRoutes(app, db);
-  }
-}
-const models = {
-  RentModel
-};
-const controllers = {
-  RentServices: controller,
-  RentRoutes
-};
-const rents_server = {
-  initialize: initializeRenting,
-  models,
-  controllers
-};
-exports.controllers = controllers;
-exports.default = rents_server;
-exports.initialize = initializeRenting;
-exports.models = models;

package/dist/reports.server.cjs

@@ -1,133 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const controllerFactory = (db) => {
-  const Report = db.report;
-  const read = async (req, res) => {
-    try {
-      const reports = await Report.find({});
-      if (reports.length === 0) {
-        return res.status(404).json({ errorCode: "REPORTS_NOT_FOUND" });
-      }
-      res.status(200).json(reports);
-    } catch (err) {
-      res.status(500).json({ errorCode: "INTERNAL_SERVER_ERROR", message: err.message });
-    }
-  };
-  const create = async (req, res) => {
-    const newReport = new Report(req.body);
-    try {
-      const savedReport = await newReport.save();
-      res.status(201).json(savedReport);
-    } catch (err) {
-      console.log(err);
-      res.status(500).json({ errorCode: "INTERNAL_SERVER_ERROR", message: err.message });
-    }
-  };
-  const update = async (req, res) => {
-    const { _id } = req.body;
-    try {
-      const updatedReport = await Report.findOneAndUpdate({ _id }, req.body, {
-        new: true,
-        runValidators: true
-      });
-      if (!updatedReport) {
-        return res.status(404).json({ errorCode: "REPORT_NOT_FOUND" });
-      }
-      res.status(200).json(updatedReport);
-    } catch (err) {
-      res.status(500).json({ errorCode: "INTERNAL_SERVER_ERROR", message: err.message });
-    }
-  };
-  const deleteReport = async (req, res) => {
-    const { _id } = req.body;
-    try {
-      const report = await Report.findOneAndDelete({ _id });
-      if (!report) {
-        return res.status(404).json({ errorCode: "REPORT_NOT_FOUND" });
-      }
-      res.status(200).json({ message: "Report deleted successfully." });
-    } catch (err) {
-      res.status(500).json({ errorCode: "INTERNAL_SERVER_ERROR", message: err.message });
-    }
-  };
-  return {
-    read,
-    create,
-    update,
-    delete: deleteReport
-  };
-};
-const ReportModel = (db) => {
-  const ReportSchema = new db.mongoose.Schema(
-    {
-      status: {
-        type: String,
-        enum: ["new", "in progress", "canceled", "closed"],
-        default: "new"
-      },
-      user: {
-        type: String,
-        default: "anonymous",
-        required: true
-      },
-      type: {
-        type: String,
-        enum: ["user", "organization", "blogpost", "event", "comment"],
-        default: "spam",
-        required: true
-      },
-      reason: {
-        type: String,
-        enum: ["spam", "harassment", "inappropriate", "misinformation", "copyright", "other"],
-        default: "spam",
-        required: true
-      },
-      target: {
-        type: db.mongoose.Schema.Types.ObjectId,
-        ref: function(value) {
-          if (this.type === "user") return "User";
-          if (this.type === "organization") return "Organization";
-        },
-        required: true
-      }
-    },
-    {
-      timestamps: { currentTime: () => Date.now() }
-    }
-  );
-  const Report = db.mongoose.model("Report", ReportSchema);
-  return Report;
-};
-const reportsRoutes = (function(app, db, origins) {
-  const controller = controllerFactory(db);
-  app.get("/reports", controller.read);
-  app.post("/reports", controller.create);
-  app.post("/reports", controller.update);
-  app.post("/reports", controller.delete);
-});
-function initializeReports(app, db, origins, publicPath) {
-  db.report = ReportModel(db);
-  if (app) {
-    reportsRoutes(app, db);
-  }
-}
-const models = {
-  ReportModel
-};
-const routes = {
-  reportsRoutes
-};
-const controllers = {
-  ReportsController: controllerFactory
-};
-const reports_server = {
-  initialize: initializeReports,
-  models,
-  routes,
-  controllers
-};
-exports.controllers = controllers;
-exports.default = reports_server;
-exports.initialize = initializeReports;
-exports.models = models;
-exports.routes = routes;

package/dist/socials.schema-CqEHax2w.cjs

@@ -1,24 +0,0 @@
-"use strict";
-const applySocialsSchema = (function applySocialsSchema2(schema, db) {
-  schema.add({
-    socials: {
-      telegram: {
-        type: String,
-        default: ""
-      },
-      twitter: {
-        type: String,
-        default: ""
-      },
-      facebook: {
-        type: String,
-        default: ""
-      },
-      instagram: {
-        type: String,
-        default: ""
-      }
-    }
-  });
-});
-exports.applySocialsSchema = applySocialsSchema;