@ozdao/martyrs 0.2.472 → 0.2.474

package/dist/style.css

@@ -336,10 +336,10 @@ button[disabled] {
 .color-overlay.active {
   background: rgba(0, 0, 0, 0.25);
   pointer-events: all;
-}li[data-v-bf25c24d] {
+}li[data-v-026b7d35] {
   list-style-type: none;
 }
-ul li[data-v-bf25c24d] {
+ul li[data-v-026b7d35] {
   line-height: 2;
 }.vue3-marquee {
   display: flex !important;
@@ -993,11 +993,11 @@ div.vue-tags-input.disabled * {
 .fade-leave-to[data-v-a766dedc] {
   opacity: 0;
 }
-.slider-hotpost .carousel__slide[data-v-e26065cc] {
+.slider-hotpost .carousel__slide {
   flex: 0 0 25%;
 }
 @media screen and (max-width: 1025px) {
-.slider-hotpost .carousel__slide[data-v-e26065cc] {
+.slider-hotpost .carousel__slide {
     flex: 0 0 75%;
 }
 }.error-wrapper {
@@ -2521,6 +2521,29 @@ to {
   border: 1px solid rgba(0, 0, 0, 0.1);
   margin-top: 1rem;
 }
+
+.working-hours-editor[data-v-f62ccd5d] {
+  border-radius: 8px;
+}
+.schedule-item[data-v-f62ccd5d] {
+  transition: all 0.3s ease;
+  border-bottom: 1px solid rgba(var(--grey), 0.1);
+}
+.schedule-item[data-v-f62ccd5d]:last-child {
+  border-bottom: none;
+}
+.period[data-v-f62ccd5d] {
+  display: inline-block;
+}
+.empty-schedule[data-v-f62ccd5d] {
+  color: rgba(var(--dark), 0.6);
+}
+.period-row[data-v-f62ccd5d] {
+  align-items: center;
+}
+.error-message[data-v-f62ccd5d] {
+  color: white;
+}
 #map[data-v-aa4fd3e0]:focus {
   outline: none;
 }

package/dist/wallet.server.js

@@ -1,6 +1,6 @@
 "use strict";
 const _commonjsHelpers = require("./_commonjsHelpers-DHfMLFPC.js");
-const index = require("./index-CVXl1rB5.js");
+const index = require("./index-BOmxJQ5W.js");
 require("axios");
 require("bcryptjs");
 require("crypto");
@@ -9,7 +9,7 @@ const tickets_controller = require("./tickets.controller-zEHIAe_B.js");
 const require$$0 = require("stripe");
 const require$$0$1 = require("mongoose");
 const require$$1 = require("bignumber.js");
-const queryProcessor = require("./queryProcessor-D6GuKfTV.js");
+const queryProcessor = require("./queryProcessor-DSUqSk3I.js");
 var wallet_model;
 var hasRequiredWallet_model;
 function requireWallet_model() {

package/dist/wallet.server.mjs

@@ -1,5 +1,5 @@
 import { g as getDefaultExportFromCjs } from "./_commonjsHelpers-CUmg6egw.mjs";
-import { r as requireMiddlewares } from "./index-Df8vtZx7.mjs";
+import { r as requireMiddlewares } from "./index-C_Fw0Umg.mjs";
 import "axios";
 import "bcryptjs";
 import "crypto";
@@ -8,7 +8,7 @@ import { r as requireTickets_controller } from "./tickets.controller-BIhfgjNb.mj
 import require$$0 from "stripe";
 import require$$0$1 from "mongoose";
 import require$$1 from "bignumber.js";
-import { r as requireQueryProcessor } from "./queryProcessor-CWnMIe2U.mjs";
+import { r as requireQueryProcessor } from "./queryProcessor-CVKI651_.mjs";
 var wallet_model;
 var hasRequiredWallet_model;
 function requireWallet_model() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ozdao/martyrs",
-  "version": "0.2.472",
+  "version": "0.2.474",
   "description": "Fullstack framework focused on user experience and ease of development.",
   "author": "OZ DAO <hello@ozdao.dev>",
   "license": "GPL-3.0-or-later",

package/src/builder/rspack/rspack.config.base.js

@@ -88,7 +88,7 @@ module.exports = (projectRoot) => {
     plugins: [
       ...(process.env.BUNDLE_ANALYZER ? [new RsdoctorRspackPlugin(), new BundleAnalyzerPlugin()] : []),
       new VueLoaderPlugin(),
-      ...(process.env.BUNDLE_ANALYZER ? [new rspack.CssExtractRspackPlugin({
+      ...(process.env.NODE_ENV === 'production' ? [new rspack.CssExtractRspackPlugin({
         filename: '[name].[contenthash].css',
         chunkFilename: '[id].[contenthash].css',
         ignoreOrder: true,

package/src/builder/rspack/rspack.config.client.js

@@ -47,15 +47,23 @@ module.exports = (projectRoot) => {
         safelist: { 
           standard: ["safelisted", /^html/, /^:root/],
           deep: [/^safelisted-deep-/, /^html/, /^:root/],
-          greedy: [ /data-v-.*/ ] 
+            greedy: [/^data-v-/, /\[data-v-.*\]/, /\[data-v-[a-zA-Z0-9]*\]/] 
         },
+        rejected: true, 
         extractors: [
           {
-            extractor: (content)=>{
-              // fix for escaped tailwind prefixes (sm:, lg:, etc)
-              return content.match(/[A-Za-z0-9-_:\/]+/g) || []
+            extractor: (content) => {
+              // Ищем классы и селекторы с префиксами Tailwind
+              const normalClasses = content.match(/[A-Za-z0-9-_:\/]+/g) || [];
+              
+              // Дополнительно ищем Vue атрибуты data-v-*
+              // Это важно для правильного распознавания scoped стилей
+              const scopedAttrs = content.match(/\[data-v-[a-zA-Z0-9]*\]/g) || [];
+              
+              // Объединяем результаты
+              return [...normalClasses, ...scopedAttrs];
             },
-            extensions: ['vue'],
+            extensions: ['vue', 'js', 'css', 'scss'],
           },
         ],
       }),

package/src/components/Select/Select.vue

@@ -15,7 +15,7 @@
     <li class="w-100">
       <!-- Selected Value -->
       <span>
-        {{ optionsSelected?.name ? optionsSelected?.name : optionsSelected || placeholder }}
+          {{ optionsSelected ? (optionsSelected.name || optionsSelected[props.value] || optionsSelected) : placeholder  }}
       </span>
     </li>
 
@@ -29,7 +29,8 @@
       >
         <li @click.stop="selectOption(option)" v-for="option in optionsListed">
           <span v-if="option" class="w-100">
-            {{ option.name || option }}
+
+            {{ option.name || option[props.value] || option }}
           </span>
         </li>
       </ul>
@@ -62,6 +63,7 @@ const props = defineProps({
   placeholder: { type: String, default: 'Please select an item' },
   select: [String, Object],
   property: String,
+  value: String,
   options: { type: Array, default: () => [] },
   validation: Boolean,
 })

package/src/modules/auth/models/user.model.js

@@ -21,7 +21,10 @@ module.exports = (db) => {
       default: 'active',
       required: true,
     },
-
+    birthday: {
+      type: Date,
+      default: null
+    },
     roles: [{
       type: db.mongoose.Schema.Types.ObjectId,
       ref: "Role"

package/src/modules/community/components/sections/HotPosts.vue

@@ -63,7 +63,7 @@ const props = defineProps({
 })
 </script>
 
-<style lang="scss" scoped>
+<style lang="scss">
 .slider-hotpost .carousel__slide {
   flex: 0 0 25%;
 }

package/src/modules/globals/controllers/classes/globals.abac.js

@@ -49,7 +49,7 @@ class GlobalABAC {
 
   // Автоматическое определение модели по имени ресурса
   getResourceModel(resourceName) {
-    if (resourceName === 'posts') resourceName = 'blogposts'
+    if (resourceName === 'posts') resourceName = 'blogposts';
 
     // Преобразуем название ресурса в singural форму модели
     const modelName = resourceName.endsWith('s') 
@@ -66,8 +66,45 @@ class GlobalABAC {
     return model;
   }
 
+  /**
+   * Нормализация результата политики для единообразной обработки
+   * @param {any} result - Результат выполнения политики
+   * @param {string} policyName - Имя политики для формирования причины
+   * @returns {Object} Нормализованный результат
+   */
+  _normalizeResult(result, policyName) {
+    // Результат уже в формате объекта с нужными полями
+    if (result && typeof result === 'object' && ('allow' in result || 'force' in result)) {
+      return {
+        allow: !!result.allow,
+        force: !!result.force,
+        reason: result.reason || `POLICY_${policyName.toUpperCase()}`
+      };
+    }
+    
+    // Boolean результаты
+    if (result === true) {
+      return { allow: true, force: false, reason: `ALLOWED_BY_${policyName.toUpperCase()}` };
+    }
+    
+    if (result === false) {
+      return { allow: false, force: false, reason: `DENIED_BY_${policyName.toUpperCase()}` };
+    }
+    
+    // Специальные случаи для adminAccessGranted и подобных
+    if (result === undefined && policyName === 'AdminModeratorAccessPolicy' && 
+        (this._context && this._context.adminAccessGranted)) {
+      return { allow: true, force: true, reason: 'ADMIN_MODERATOR_ACCESS_GRANTED' };
+    }
+    
+    // Нейтральный результат (пропуск политики)
+    return { allow: true, force: false, reason: `NEUTRAL_${policyName.toUpperCase()}` };
+  }
+
   // Базовый метод проверки доступа
   async checkAccess(context) {
+    this._context = context; // Сохраняем контекст для использования в _normalizeResult
+    
     const {
       user,      // Пользователь
       resource,  // Тип ресурса
@@ -124,34 +161,122 @@ class GlobalABAC {
       }
     }
 
-    // Выполнение глобальных политик
-    for (const [policyName, policyFn] of Object.entries(this.policies.global)) {
-      const result = await policyFn(context);
-      if (result === false) {
-        return { 
-          allowed: false, 
-          reason: `DENIED_BY_GLOBAL_POLICY_${policyName.toUpperCase()}` 
-        };
+    // Выполнение всех глобальных политик параллельно
+    const policyEntries = Object.entries(this.policies.global);
+    const policyPromises = policyEntries.map(async ([policyName, policyFn]) => {
+      try {
+        const result = await policyFn(context);
+        return { policyName, result };
+      } catch (error) {
+        console.error(`Error in policy ${policyName}:`, error);
+        // При ошибке возвращаем нейтральный результат
+        return { policyName, result: undefined, error };
       }
-    }
+    });
 
-    // Проверка политик для конкретного ресурса
+    // Ожидаем выполнения всех политик
+    const policyResults = await Promise.all(policyPromises);
+    
+    // Обработка результатов глобальных политик
+    let hasForceAllow = false;
+    let hasForceDisallow = false;
+    let hasDeny = false;
+    let denyReason = '';
+    let allowReason = '';
+    
+    for (const { policyName, result, error } of policyResults) {
+      if (error) continue; // Пропускаем политики с ошибками
+      
+      // Нормализуем результат для унифицированной обработки
+      const normalizedResult = this._normalizeResult(result, policyName);
+      
+      if (normalizedResult.force) {
+        if (normalizedResult.allow) {
+          hasForceAllow = true;
+          allowReason = normalizedResult.reason;
+        } else {
+          hasForceDisallow = true;
+          denyReason = normalizedResult.reason;
+        }
+      } else if (!normalizedResult.allow) {
+        hasDeny = true;
+        if (!denyReason) denyReason = normalizedResult.reason;
+      }
+    }
+    
+    // Принятие решения на основе результатов
+    // 1. Проверка на стопроцентный запрет
+    if (hasForceDisallow) {
+      return { 
+        allowed: false, 
+        reason: denyReason || 'FORCE_DENIED_BY_POLICY' 
+      };
+    }
+    
+    // 2. Проверка на стопроцентный доступ
+    if (hasForceAllow) {
+      return { 
+        allowed: true, 
+        reason: allowReason || 'FORCE_ALLOWED_BY_POLICY' 
+      };
+    }
+    
+    // 3. Проверка на обычный запрет
+    if (hasDeny) {
+      return { 
+        allowed: false, 
+        reason: denyReason || 'DENIED_BY_POLICY' 
+      };
+    }
+    
+    // 4. Проверка политик ресурсов (возможно асинхронное выполнение)
     if (this.policies.resources[resource]) {
-      const resourceResult = await this.policies.resources[resource](context);
-      if (resourceResult === true) {
-        return { 
-          allowed: true, 
-          reason: 'RESOURCE_POLICY_ALLOWED' 
-        };
+      try {
+        const resourceResult = await this.policies.resources[resource](context);
+        const normalizedResult = this._normalizeResult(resourceResult, `RESOURCE_${resource}`);
+        
+        if (normalizedResult.force) {
+          return { 
+            allowed: normalizedResult.allow, 
+            reason: normalizedResult.reason 
+          };
+        }
+        
+        if (!normalizedResult.allow) {
+          return { 
+            allowed: false, 
+            reason: normalizedResult.reason 
+          };
+        }
+        
+        if (normalizedResult.allow) {
+          return { 
+            allowed: true, 
+            reason: normalizedResult.reason 
+          };
+        }
+      } catch (error) {
+        console.error(`Error in resource policy for ${resource}:`, error);
       }
     }
 
-    // Выполнение расширений от внешних модулей
-    for (const [moduleName, extensionFn] of Object.entries(this.policies.extensions)) {
-      const extensionResult = await extensionFn(context);
+    // 5. Выполнение расширений от внешних модулей
+    const extensionPromises = Object.entries(this.policies.extensions).map(async ([moduleName, extensionFn]) => {
+      try {
+        const extensionResult = await extensionFn(context);
+        return { moduleName, result: extensionResult };
+      } catch (error) {
+        console.error(`Error in extension ${moduleName}:`, error);
+        return { moduleName, result: null, error };
+      }
+    });
+    
+    const extensionResults = await Promise.all(extensionPromises);
+    
+    for (const { moduleName, result, error } of extensionResults) {
+      if (error) continue;
       
-      // Если расширение вернуло положительный результат
-      if (extensionResult && extensionResult.allowed) {
+      if (result && result.allowed) {
         return { 
           allowed: true, 
           reason: `ALLOWED_BY_${moduleName.toUpperCase()}_EXTENSION` 
@@ -159,7 +284,7 @@ class GlobalABAC {
       }
     }
 
-    // Финальное решение на основе настроек
+    // 6. Финальное решение на основе настроек
     return { 
       allowed: !this.options.defaultDeny, 
       reason: this.options.defaultDeny ? 'ACCESS_DENIED' : 'ACCESS_ALLOWED'

package/src/modules/globals/controllers/classes/globals.validator.js

@@ -269,6 +269,42 @@ class Validator {
     return this;
   }
 
+  /**
+   * Проверяет, что значение соответствует одному из указанных типов через уже существующие правила валидатора
+   * @param {string[]} types - Массив допустимых типов (например: ['string', 'number', 'null', 'array'])
+   * @param {string} [message] - Сообщение об ошибке
+   * @returns {Validator}
+   */
+  oneOfTypes(types, message) {
+    const validators = types.map(type => {
+      const schema = Validator.schema();
+      if (type === 'string') return schema.string();
+      if (type === 'number') return schema.number();
+      if (type === 'integer') return schema.integer();
+      if (type === 'boolean') return schema.boolean();
+      if (type === 'array') return schema.array();
+      if (type === 'object') return schema.object({});
+      if (type === 'date') return schema.date();
+      if (type === 'null') {
+        // Кастомный валидатор для null
+        return Validator.schema().custom(val => val === null, 'Значение должно быть null');
+      }
+      throw new Error(`Unsupported type in oneOfTypes: ${type}`);
+    });
+
+    this.rules.push({
+      type: 'oneOfTypes',
+      check: value => {
+        return validators.some(validator => validator.validate(value).isValid);
+      },
+      param: types,
+      message
+    });
+
+    return this;
+  }
+
+
   /**
    * Добавляет пользовательскую проверку
    * @param {function} fn - Функция проверки
@@ -412,6 +448,7 @@ class Validator {
       case 'pattern': return `${context}не соответствует требуемому формату`;
       case 'email': return `${context}должно быть корректным email-адресом`;
       case 'oneOf': return `${context}должно быть одним из: ${rule.param.join(', ')}`;
+      case 'oneOfTypes': return `${context}должно быть одного из типов: ${rule.param.join(', ')}`;
       case 'custom': return rule.param;
       case 'items': return `${context}содержит невалидные элементы`;
       case 'object': return `${context}не соответствует типу объекта`;

package/src/modules/globals/controllers/classes/globals.verifier.js

@@ -192,6 +192,8 @@ class Verifier {
     if (Object.keys(result.verificationErrors).length === 0) {
       result.verificationErrors = null;
     }
+
+    console.log('Verification result:', result)
     
     return result;
   }

package/src/modules/globals/controllers/policies/globals.policies.js

@@ -1,12 +1,67 @@
 module.exports = function initializeDefaultPolicies(abacAccessControl) {
   // Политика личного владения ресурсом
+  abacAccessControl.registerGlobalPolicy('AdminModeratorAccessPolicy', async (context) => {
+    const { user, req } = context;
+
+    // Если пользователь не указан, политика не применяется
+    if (!user) {
+      return { allow: true, force: false };
+    }
+    
+    try {
+      // Вариант 3: загружаем пользователя из базы данных
+      const userModel = abacAccessControl.db.user;
+      const userDoc = await userModel.findById(user).populate('roles');
+      
+      if (userDoc && userDoc.roles) {
+        // Сохраняем документ пользователя в контексте для других политик
+        context.userDoc = userDoc;
+        
+        // Извлекаем роли из документа
+        userRoles = userDoc.roles.map(role => 
+          typeof role === 'string' ? role : role.name || role
+        );
+      }
+      
+      // Проверяем наличие ролей администратора или модератора
+      const isAdmin = userRoles.includes('admin');
+      const isModerator = userRoles.includes('moderator');
+
+      
+      if (isAdmin || isModerator) {
+        // Возвращаем стопроцентный доступ
+        return { 
+          allow: true, 
+          force: true, 
+          reason: isAdmin ? 'ADMIN_ACCESS_GRANTED' : 'MODERATOR_ACCESS_GRANTED' 
+        };
+      }
+      
+      // Для обычных пользователей не влияем на решение
+      return { allow: true, force: false };
+    } catch (error) {
+      console.error('Error in AdminModeratorPolicy:', error);
+      // При ошибке не блокируем доступ, продолжаем другие проверки
+      return { allow: true, force: false };
+    }
+  });
+
   abacAccessControl.registerGlobalPolicy('PersonalResourceOwnerPolicy', async (context) => {
     let { user, action, data, currentResource, options } = context;
     const ObjectId = abacAccessControl.db.mongoose.Types.ObjectId;
     
     // Для create операций с владением пользователя
-    if (action === 'create' && data.owner.type === 'user') {
-      return data.owner.target === user && data.creator.target === user;
+    if (action === 'create' && data.owner?.type === 'user') {
+      // Проверяем, что пользователь создает ресурс от своего имени
+      if (data.owner.target === user && data.creator.target === user) {
+        return { allow: true, force: false };
+      } else {
+        return { 
+          allow: false, 
+          force: false, 
+          reason: 'UNAUTHORIZED_RESOURCE_CREATION'
+        };
+      }
     }
     
     if (action === 'read') {
@@ -14,7 +69,8 @@ module.exports = function initializeDefaultPolicies(abacAccessControl) {
       const allowedPublicStatuses = ['published', 'active', 'featured'];
      
       // Для неавторизованных пользователей или не владельцев
-      if (!user || (currentResource && currentResource.creator && !currentResource.creator.target.equals(new ObjectId(user)))) {
+      if (!user || (currentResource && currentResource.creator && 
+          !currentResource.creator.target.equals(new ObjectId(user)))) {
         
         if (context.req && context.req.query) {
           // Если статус указан в запросе, проверяем его
@@ -24,13 +80,21 @@ module.exports = function initializeDefaultPolicies(abacAccessControl) {
               // Проверяем, что каждый статус из массива находится в списке разрешенных
               for (const queryStatus of context.req.query.status) {
                 if (!allowedPublicStatuses.includes(queryStatus)) {
-                  return false;
+                  return { 
+                    allow: false, 
+                    force: true,  // Стопроцентный запрет для неразрешенных статусов
+                    reason: 'UNAUTHORIZED_STATUS_ACCESS' 
+                  };
                 }
               }
             } else {
               // Проверка одиночного статуса
               if (!allowedPublicStatuses.includes(context.req.query.status)) {
-                return false;
+                return { 
+                  allow: false, 
+                  force: true,  // Стопроцентный запрет для неразрешенных статусов
+                  reason: 'UNAUTHORIZED_STATUS_ACCESS'
+                };
               }
             }
           }
@@ -38,82 +102,35 @@ module.exports = function initializeDefaultPolicies(abacAccessControl) {
         
         // Для единичного ресурса
         if (currentResource && !allowedPublicStatuses.includes(currentResource.status)) {
-          return false;
+          return { 
+            allow: false, 
+            force: true,  // Стопроцентный запрет для неразрешенных статусов
+            reason: 'UNAUTHORIZED_RESOURCE_ACCESS'
+          };
         }
       }
       
-      return true;
+      // По умолчанию не влияем на решение для read
+      return { allow: true, force: false };
     }
+    
     // Для update и delete операций
-    if ((action === 'edit' || action === 'delete') && currentResource && currentResource.owner.type === 'user') {
-      return currentResource.creator.target.equals(new ObjectId(user));
+    if ((action === 'edit' || action === 'delete') && currentResource && currentResource.owner?.type === 'user') {
+      // Проверяем владельца
+      if (currentResource.creator.target.equals(new ObjectId(user))) {
+        return { allow: true, force: false };
+      } else {
+        return { 
+          allow: false, 
+          force: false, 
+          reason: 'NOT_RESOURCE_OWNER'
+        };
+      }
     }
-    return true;
+    
+    // По умолчанию не влияем на решение
+    return { allow: true, force: false };
   });
 
-  // Политика публичного доступа к опубликованным ресурсам
-  // abacAccessControl.registerGlobalPolicy('PublishedResourceAccessPolicy', async (context) => {
-  //   const { currentResource, action } = context;
-
-  //   // Разрешаем чтение опубликованных ресурсов
-  //   if (
-  //     action === 'read' && 
-  //     currentResource?.status === 'published'
-  //   ) {
-  //     return true;
-  //   }
-
-  //   return false;
-  // });
-
-  // Политика ограничения доступа для удаления
-  // abacAccessControl.registerGlobalPolicy('DeleteRestrictionPolicy', async (context) => {
-  //   const { action, currentResource } = context;
-
-  //   // Запрещаем удаление ресурсов с определенным статусом
-  //   if (
-  //     action === 'delete' && 
-  //     currentResource?.status === 'in_use'
-  //   ) {
-  //     return false;
-  //   }
-
-  //   return true;
-  // });
-
-  // Политика проверки статуса пользователя
-  // abacAccessControl.registerGlobalPolicy('UserStatusPolicy', async (context) => {
-  //   const { user, action } = context;
-
-  //   // Блокировка действий для заблокированных пользователей
-  //   if (user.status === 'blocked') {
-  //     // Разрешаем только чтение
-  //     return action === 'read';
-  //   }
-
-  //   return true;
-  // });
-
-  // // Политика ограничения по времени
-  // abacAccessControl.registerGlobalPolicy('TimeBasedAccessPolicy', async (context) => {
-  //   const { action, currentResource } = context;
-
-  //   // Проверка времени создания ресурса
-  //   if (currentResource?.createdAt) {
-  //     const resourceAge = Date.now() - currentResource.createdAt.getTime();
-  //     const MAX_RESOURCE_AGE = 30 * 24 * 60 * 60 * 1000; // 30 дней
-
-  //     // Ограничение на изменение старых ресурсов
-  //     if (
-  //       ['edit', 'delete'].includes(action) && 
-  //       resourceAge > MAX_RESOURCE_AGE
-  //     ) {
-  //       return false;
-  //     }
-  //   }
-
-  //   return true;
-  // });
-
   return abacAccessControl;
 };