@ozdao/martyrs 0.2.477 → 0.2.479

package/src/modules/{globals/views/core → core/classes}/module-manager.js

@@ -1,44 +1,44 @@
 export const createModuleManager = () => {
-  const modules = new Map()
-  const plugins = new Map()
-  const events = createEventBus()
-  
+  const modules = new Map();
+  const plugins = new Map();
+  const events = createEventBus();
+
   const manager = {
     registerModule(module) {
       if (!module?.name) {
-        throw new Error('Invalid module object')
+        throw new Error('Invalid module object');
       }
-      
+
       if (modules.has(module.name)) {
-        throw new Error(`Module ${module.name} is already registered`)
+        throw new Error(`Module ${module.name} is already registered`);
       }
-      
-      modules.set(module.name, module)
-      events.emit('moduleRegistered', module)
+
+      modules.set(module.name, module);
+      events.emit('moduleRegistered', module);
     },
 
     unregisterModule(name) {
-      const module = modules.get(name)
+      const module = modules.get(name);
 
       if (module) {
-        module.destroy()
-        modules.delete(name)
-        plugins.delete(name)
-        events.emit('moduleUnregistered', name)
+        module.destroy();
+        modules.delete(name);
+        plugins.delete(name);
+        events.emit('moduleUnregistered', name);
       }
     },
 
     _detectCircularDependencies(moduleName, visited = new Set()) {
       if (visited.has(moduleName)) {
-        throw new Error(`Circular dependency detected for module ${moduleName}`)
+        throw new Error(`Circular dependency detected for module ${moduleName}`);
       }
-      
-      visited.add(moduleName)
-      
-      const module = modules.get(moduleName)
-      
+
+      visited.add(moduleName);
+
+      const module = modules.get(moduleName);
+
       for (const dep of module.requires) {
-        this._detectCircularDependencies(dep, new Set(visited))
+        this._detectCircularDependencies(dep, new Set(visited));
       }
     },
 
@@ -46,46 +46,43 @@ export const createModuleManager = () => {
       try {
         // Check for circular dependencies
         for (const module of modules.values()) {
-          this._detectCircularDependencies(module.name)
+          this._detectCircularDependencies(module.name);
         }
-        
-        const sortedModules = this._sortModulesByDependencies()
-        
+
+        const sortedModules = this._sortModulesByDependencies();
+
         // Initialize modules sequentially to maintain dependency order
         for (const module of sortedModules) {
-          const moduleOptions = options[module.name] || {}
-          
+          const moduleOptions = options[module.name] || {};
+
           try {
-            await module.initialize(app, store, router, moduleOptions)
-            
+            await module.initialize(app, store, router, moduleOptions);
+
             // Initialize plugins
             if (plugins.has(module.name)) {
-              await Promise.all(
-                Array.from(plugins.get(module.name))
-                  .map(plugin => plugin.initialize(app, store, router, moduleOptions))
-              )
+              await Promise.all(Array.from(plugins.get(module.name)).map(plugin => plugin.initialize(app, store, router, moduleOptions)));
             }
           } catch (error) {
-            throw new Error(`Failed to initialize module ${module.name}: ${error.message}`)
+            throw new Error(`Failed to initialize module ${module.name}: ${error.message}`);
           }
         }
       } catch (error) {
         // Cleanup on initialization failure
-        this.destroy()
-        throw error
+        this.destroy();
+        throw error;
       }
     },
 
     // Proper cleanup
     destroy() {
       for (const module of modules.values()) {
-        module.destroy()
+        module.destroy();
       }
-      modules.clear()
-      plugins.clear()
-      events.destroy()
-    }
-  }
-
-  return manager
-}
+      modules.clear();
+      plugins.clear();
+      events.destroy();
+    },
+  };
+
+  return manager;
+};

package/src/modules/{globals/views/core → core/classes}/module.js

@@ -2,105 +2,104 @@ export const createModule = ({
   name,
   version,
   requires = [],
-  framework = 'vue' // Support for different frameworks
+  framework = 'vue', // Support for different frameworks
 }) => {
-  if (!name) throw new Error('Module name is required')
-  if (!version) throw new Error('Module version is required')
-  
+  if (!name) throw new Error('Module name is required');
+  if (!version) throw new Error('Module version is required');
+
   // Private fields with WeakMap for better garbage collection
-  const stores = new WeakMap()
-  const routes = new WeakMap()
-  const components = new WeakMap()
-  const hooks = new WeakMap()
-  const events = createEventBus()
-  
-  let isInitialized = false
-  
+  const stores = new WeakMap();
+  const routes = new WeakMap();
+  const components = new WeakMap();
+  const hooks = new WeakMap();
+  const events = createEventBus();
+
+  let isInitialized = false;
+
   // Validate component name uniqueness
-  const validateComponentName = (name) => {
+  const validateComponentName = name => {
     if (components.has(name)) {
-      throw new Error(`Component ${name} already registered`)
+      throw new Error(`Component ${name} already registered`);
     }
-  }
+  };
 
   const module = {
     name,
     version,
     requires,
     events,
-    
+
     addComponent(name, component, options = {}) {
-      validateComponentName(name)
-      
-      const { async = false } = options
-      
+      validateComponentName(name);
+
+      const { async = false } = options;
+
       components.set(name, {
         component,
         async,
-        framework
-      })
+        framework,
+      });
     },
 
     // Add proper cleanup
     destroy() {
-      stores.clear()
-      routes.clear()
-      components.clear()
-      hooks.clear()
-      events.destroy()
-      isInitialized = false
+      stores.clear();
+      routes.clear();
+      components.clear();
+      hooks.clear();
+      events.destroy();
+      isInitialized = false;
     },
 
     async initialize(app, store, router, options = {}) {
       if (isInitialized) {
-        throw new Error(`Module ${name} is already initialized`)
+        throw new Error(`Module ${name} is already initialized`);
       }
 
       try {
-        await this._runHooks('beforeInit', { app, store, router })
-        
+        await this._runHooks('beforeInit', { app, store, router });
+
         // Initialize features with error handling
-        await Promise.all([
-          this._initializeComponents(app, options),
-          this._initializeStores(store, options),
-          this._initializeRoutes(router, options)
-        ])
-
-        await this._runHooks('init', { app, store, router })
-        await this._runHooks('afterInit', { app, store, router })
-        
-        isInitialized = true
+        await Promise.all([this._initializeComponents(app, options), this._initializeStores(store, options), this._initializeRoutes(router, options)]);
+
+        await this._runHooks('init', { app, store, router });
+        await this._runHooks('afterInit', { app, store, router });
+
+        isInitialized = true;
       } catch (error) {
         // Cleanup on initialization failure
-        this.destroy()
-        throw new Error(`Failed to initialize module ${name}: ${error.message}`)
+        this.destroy();
+        throw new Error(`Failed to initialize module ${name}: ${error.message}`);
       }
     },
 
     // Private methods with proper error handling
     async _initializeComponents(app, options) {
-      const usedFeatures = options.use || []
-      
+      const usedFeatures = options.use || [];
+
       for (const [name, { component, async, framework }] of components) {
         if (!usedFeatures.length || usedFeatures.includes(name)) {
           try {
             if (framework === 'vue') {
               if (async) {
-                app.component(name, defineAsyncComponent(() => component))
+                app.component(
+                  name,
+                  defineAsyncComponent(() => component)
+                );
               } else {
-                app.component(name, component)
+                app.component(name, component);
               }
             } else {
               // Support for other frameworks
-              throw new Error(`Framework ${framework} not supported`)
+              throw new Error(`Framework ${framework} not supported`);
             }
           } catch (error) {
-            throw new Error(`Failed to register component ${name}: ${error.message}`)
+            throw new Error(`Failed to register component ${name}: ${error.message}`);
           }
         }
       }
-    }
-  }
+    },
+  };
 
-  return module
-}
+  return module;
+};

package/src/modules/core/model/Adapter.js

@@ -0,0 +1,17 @@
+// DBAdapter.js
+class DBAdapter {
+  constructor(modelName) {
+    this.modelName = modelName;
+  }
+  
+  async create(data) { throw new Error('Not implemented'); }
+  async find(query) { throw new Error('Not implemented'); }
+  async findOne(query) { throw new Error('Not implemented'); }
+  async findById(id) { throw new Error('Not implemented'); }
+  async update(id, data) { throw new Error('Not implemented'); }
+  async delete(id) { throw new Error('Not implemented'); }
+  async aggregate(pipeline) { throw new Error('Not implemented'); }
+  async count(query) { throw new Error('Not implemented'); }
+}
+
+export default DBAdapter;

package/src/modules/core/model/Adapter.mogodb.js

@@ -0,0 +1,65 @@
+// MongoDBAdapter.js
+import DBAdapter from './DBAdapter.js';
+import { ObjectId } from 'mongodb';
+
+class MongoDBAdapter extends DBAdapter {
+  constructor(modelName, connection) {
+    super(modelName);
+    this.db = connection.db;
+  }
+  
+  // Преобразование строкового ID в ObjectId
+  convertId(id) {
+    return new ObjectId(id);
+  }
+  
+  async create(data) {
+    const collection = this.db.collection(this.modelName);
+    const result = await collection.insertOne(data);
+    return { ...data, _id: result.insertedId };
+  }
+  
+  async findById(id) {
+    const collection = this.db.collection(this.modelName);
+    return await collection.findOne({ _id: this.convertId(id) });
+  }
+  
+  async find(query = {}) {
+    const collection = this.db.collection(this.modelName);
+    return await collection.find(query).toArray();
+  }
+  
+  async findOne(query = {}) {
+    const collection = this.db.collection(this.modelName);
+    return await collection.findOne(query);
+  }
+  
+  async update(id, data) {
+    const collection = this.db.collection(this.modelName);
+    const result = await collection.findOneAndUpdate(
+      { _id: this.convertId(id) },
+      { $set: data },
+      { returnDocument: 'after' }
+    );
+    
+    return result.value;
+  }
+  
+  async delete(id) {
+    const collection = this.db.collection(this.modelName);
+    const result = await collection.deleteOne({ _id: this.convertId(id) });
+    return result.deletedCount > 0;
+  }
+  
+  async aggregate(pipeline) {
+    const collection = this.db.collection(this.modelName);
+    return await collection.aggregate(pipeline).toArray();
+  }
+  
+  async count(query = {}) {
+    const collection = this.db.collection(this.modelName);
+    return await collection.countDocuments(query);
+  }
+}
+
+export default MongoDBAdapter;

package/src/modules/core/model/Adapter.postgre.js

@@ -0,0 +1,127 @@
+// PostgreSQLAdapter.js
+import DBAdapter from './DBAdapter.js';
+
+class PostgreSQLAdapter extends DBAdapter {
+  constructor(modelName, connection) {
+    super(modelName);
+    this.pool = connection;
+  }
+  
+  async create(data) {
+    const fields = Object.keys(data);
+    const placeholders = fields.map((_, i) => `$${i + 1}`).join(', ');
+    const values = fields.map(field => data[field]);
+    
+    const query = `
+      INSERT INTO ${this.modelName} (${fields.join(', ')})
+      VALUES (${placeholders})
+      RETURNING *
+    `;
+    
+    const result = await this.pool.query(query, values);
+    return result.rows[0];
+  }
+  
+  async findById(id) {
+    const query = `
+      SELECT * FROM ${this.modelName}
+      WHERE id = $1
+    `;
+    
+    const result = await this.pool.query(query, [id]);
+    return result.rows[0];
+  }
+  
+  async find(query = {}) {
+    // Преобразование объекта запроса в WHERE условия
+    const conditions = [];
+    const values = [];
+    let paramIndex = 1;
+    
+    for (const [key, value] of Object.entries(query)) {
+      conditions.push(`${key} = $${paramIndex}`);
+      values.push(value);
+      paramIndex++;
+    }
+    
+    const sqlQuery = `
+      SELECT * FROM ${this.modelName}
+      ${conditions.length ? `WHERE ${conditions.join(' AND ')}` : ''}
+    `;
+    
+    const result = await this.pool.query(sqlQuery, values);
+    return result.rows;
+  }
+  
+  async findOne(query = {}) {
+    // Преобразование объекта запроса в WHERE условия
+    const conditions = [];
+    const values = [];
+    let paramIndex = 1;
+    
+    for (const [key, value] of Object.entries(query)) {
+      conditions.push(`${key} = $${paramIndex}`);
+      values.push(value);
+      paramIndex++;
+    }
+    
+    const sqlQuery = `
+      SELECT * FROM ${this.modelName}
+      ${conditions.length ? `WHERE ${conditions.join(' AND ')}` : ''}
+      LIMIT 1
+    `;
+    
+    const result = await this.pool.query(sqlQuery, values);
+    return result.rows[0];
+  }
+  
+  async update(id, data) {
+    const fields = Object.keys(data);
+    const setClause = fields.map((field, index) => `${field} = $${index + 2}`).join(', ');
+    const values = [id, ...fields.map(field => data[field])];
+    
+    const query = `
+      UPDATE ${this.modelName}
+      SET ${setClause}
+      WHERE id = $1
+      RETURNING *
+    `;
+    
+    const result = await this.pool.query(query, values);
+    return result.rows[0];
+  }
+  
+  async delete(id) {
+    const query = `
+      DELETE FROM ${this.modelName}
+      WHERE id = $1
+      RETURNING *
+    `;
+    
+    const result = await this.pool.query(query, [id]);
+    return result.rowCount > 0;
+  }
+  
+  async count(query = {}) {
+    // Преобразование объекта запроса в WHERE условия
+    const conditions = [];
+    const values = [];
+    let paramIndex = 1;
+    
+    for (const [key, value] of Object.entries(query)) {
+      conditions.push(`${key} = $${paramIndex}`);
+      values.push(value);
+      paramIndex++;
+    }
+    
+    const sqlQuery = `
+      SELECT COUNT(*) FROM ${this.modelName}
+      ${conditions.length ? `WHERE ${conditions.join(' AND ')}` : ''}
+    `;
+    
+    const result = await this.pool.query(sqlQuery, values);
+    return parseInt(result.rows[0].count);
+  }
+}
+
+export default PostgreSQLAdapter;

package/src/modules/core/model/Model.js

@@ -0,0 +1,99 @@
+// Model.js
+import ModelSchema from './ModelSchema.js';
+import ModelValidator from './ModelValidator.js';
+
+class Model {
+  constructor(db, name, schema) {
+    this.name = name;
+    this._schema = new ModelSchema(schema);
+    this._validator = new ModelValidator(this._schema);
+    
+    if (db.type === 'mongodb') {
+      this.adapter = new MongoDBAdapter(name, db);
+    } else if (db.type === 'postgresql') {
+      this.adapter = new PostgreSQLAdapter(name, db);
+    } else {
+      // По умолчанию MongoDB
+      this.adapter = new MongoDBAdapter(name, db);
+    }
+  
+  // CRUD операции, делегируемые адаптеру
+  async create(data) {
+    if (!this._adapter) {
+      throw new Error('DB adapter not set');
+    }
+    
+    const validationResult = this.validate(data);
+    if (!validationResult.isValid) {
+      throw new Error('Validation failed: ' + JSON.stringify(validationResult.errors));
+    }
+    
+    return await this._adapter.create(data);
+  }
+  
+  async find(query = {}) {
+    if (!this._adapter) {
+      throw new Error('DB adapter not set');
+    }
+    
+    return await this._adapter.find(query);
+  }
+  
+  async findOne(query = {}) {
+    if (!this._adapter) {
+      throw new Error('DB adapter not set');
+    }
+    
+    return await this._adapter.findOne(query);
+  }
+  
+  async findById(id) {
+    if (!this._adapter) {
+      throw new Error('DB adapter not set');
+    }
+    
+    return await this._adapter.findById(id);
+  }
+  
+  async update(id, data) {
+    if (!this._adapter) {
+      throw new Error('DB adapter not set');
+    }
+    
+    const validationResult = this.validate(data);
+    
+    if (!validationResult.isValid) {
+      throw new Error('Validation failed: ' + JSON.stringify(validationResult.errors));
+    }
+    
+    return await this._adapter.update(id, data);
+  }
+  
+  async delete(id) {
+    if (!this._adapter) {
+      throw new Error('DB adapter not set');
+    }
+    
+    return await this._adapter.delete(id);
+  }
+  
+  // Методы валидации
+  validate(data) {
+    return this._validator.validate(data);
+  }
+  
+  validateField(field, value) {
+    return this._validator.validateField(field, value);
+  }
+  
+  // Методы для доступа к схеме
+  getSchema() {
+    return this._schema.getDefinition();
+  }
+  
+  createEmpty() {
+    return this._schema.createEmpty();
+  }
+}
+
+export default Model;

package/src/modules/core/model/Schema.js

@@ -0,0 +1,70 @@
+// ModelSchema.js
+class ModelSchema {
+  constructor(schemaDefinition) {
+    this.definition = this._normalizeSchema(schemaDefinition);
+  }
+  
+  // Нормализация схемы, чтобы все поля имели одинаковую структуру
+  _normalizeSchema(schema) {
+    const normalized = {};
+    
+    for (const [field, config] of Object.entries(schema)) {
+      normalized[field] = {
+        type: config.type || String,
+        required: !!config.required,
+        default: config.default,
+        custom: config.custom || null,
+        // Остальные поля из конфигурации
+        ...config
+      };
+    }
+    
+    return normalized;
+  }
+  
+  getFieldNames() {
+    return Object.keys(this.definition);
+  }
+  
+  getFieldDefinition(field) {
+    return this.definition[field];
+  }
+  
+  getDefinition() {
+    return this.definition;
+  }
+  
+  // Создание пустого объекта с дефолтными значениями
+  createEmpty() {
+    const result = {};
+    
+    for (const [field, config] of Object.entries(this.definition)) {
+      if (config.default !== undefined) {
+        // Если default - функция, вызываем её
+        if (typeof config.default === 'function') {
+          result[field] = config.default();
+        } else {
+          result[field] = config.default;
+        }
+      } else if (config.type === String) {
+        result[field] = '';
+      } else if (config.type === Number) {
+        result[field] = 0;
+      } else if (config.type === Boolean) {
+        result[field] = false;
+      } else if (config.type === Date) {
+        result[field] = new Date();
+      } else if (config.type === Array) {
+        result[field] = [];
+      } else if (config.type === Object) {
+        result[field] = {};
+      } else {
+        result[field] = null;
+      }
+    }
+    
+    return result;
+  }
+}
+
+export default ModelSchema;