@aetherframework/database 1.1.0 → 1.1.2

package/src/plugins/GraphQLPlugin.js

@@ -0,0 +1,162 @@
+/**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/database/plugin/GrapthQLPlugin
+ */
+import { BasePlugin } from "./BasePlugin.js";
+
+/**
+ * GraphQL Plugin - Provides GraphQL-style field selection and relation loading
+ */
+export class GraphQLPlugin extends BasePlugin {
+  constructor(queryBuilder) {
+    super(queryBuilder);
+    this.pluginName = "GraphQLPlugin";
+    this.graphqlFields = null;
+  }
+
+  _registerMethods() {
+    // Register GraphQL-style methods to QueryBuilder
+    this.queryBuilder.selectFields = this.selectFields.bind(this);
+    this.queryBuilder.extractGraphQLFields = this.extractGraphQLFields.bind(this);
+    this.queryBuilder.with = this.with.bind(this);
+    this.queryBuilder.executeWithRelations = this.executeWithRelations.bind(this);
+    this.queryBuilder.loadRelation = this.loadRelation.bind(this);
+  }
+
+  /**
+   * GraphQL-style field selection
+   * @param {string|Array|Object} fields - Fields to select
+   * @returns {QueryBuilder} Query builder instance
+   */
+  selectFields(fields) {
+    if (typeof fields === "string") {
+      // Comma-separated string
+      this.queryBuilder.query.columns = fields.split(",").map((f) => f.trim());
+    } else if (Array.isArray(fields)) {
+      // Array of fields
+      this.queryBuilder.query.columns = fields;
+    } else if (typeof fields === "object") {
+      // GraphQL-style object with nested fields
+      this.graphqlFields = fields;
+      this.queryBuilder.query.columns = this.extractGraphQLFields(fields);
+    }
+    return this.queryBuilder;
+  }
+
+  /**
+   * Extract fields from GraphQL-style selection
+   * @param {Object} fields - GraphQL fields object
+   * @param {string} prefix - Field prefix
+   * @returns {Array} Extracted fields
+   */
+  extractGraphQLFields(fields, prefix = "") {
+    const extracted = [];
+
+    for (const [key, value] of Object.entries(fields)) {
+      if (value === true || value === 1) {
+        // Simple field
+        extracted.push(prefix ? `${prefix}.${key}` : key);
+      } else if (typeof value === "object") {
+        // Nested field or sub-query
+        if (value.fields) {
+          // Sub-query with fields
+          const subFields = this.extractGraphQLFields(value.fields, key);
+          extracted.push(...subFields);
+        } else {
+          // Nested object
+          const nestedFields = this.extractGraphQLFields(value, key);
+          extracted.push(...nestedFields);
+        }
+      }
+    }
+
+    return extracted;
+  }
+
+  /**
+   * Include related data (eager loading)
+   * @param {string|Object} relations - Relations to include
+   * @returns {QueryBuilder} Query builder instance
+   */
+  with(relations) {
+    if (typeof relations === "string") {
+      this.queryBuilder.query.with = [relations];
+    } else if (Array.isArray(relations)) {
+      this.queryBuilder.query.with = relations;
+    } else if (typeof relations === "object") {
+      this.queryBuilder.query.with = Object.keys(relations);
+      this.graphqlFields = relations;
+    }
+    return this.queryBuilder;
+  }
+
+  /**
+   * Execute query with GraphQL-style field selection
+   * @returns {Promise<Object>} Query result with nested relations
+   */
+  async executeWithRelations() {
+    const result = await this.queryBuilder.execute();
+
+    if (!this.queryBuilder.query.with || !result.rows || result.rows.length === 0) {
+      return result;
+    }
+
+    // Load relations for each row
+    for (const relation of this.queryBuilder.query.with) {
+      await this.loadRelation(result.rows, relation);
+    }
+
+    return result;
+  }
+
+  /**
+   * Load relation for rows
+   * @param {Array} rows - Parent rows
+   * @param {string} relation - Relation name
+   * @returns {Promise<void>}
+   */
+  async loadRelation(rows, relation) {
+    const relationConfig = this.graphqlFields?.[relation];
+    if (!relationConfig) return;
+
+    // Extract parent IDs
+    const parentIds = rows.map((row) => row.id).filter((id) => id);
+    if (parentIds.length === 0) return;
+
+    // Build relation query
+    const relationQuery = new this.queryBuilder.constructor(
+      relation,
+      this.queryBuilder.connection,
+      this.queryBuilder.dialect,
+    );
+
+    // Apply GraphQL field selection if specified
+    if (relationConfig.fields) {
+      relationQuery.selectFields(relationConfig.fields);
+    }
+
+    // Add WHERE condition for relation
+    const foreignKey =
+      relationConfig.foreignKey || `${this.queryBuilder.tableName.slice(0, -1)}_id`;
+    const relatedRows = await relationQuery
+      .whereIn(foreignKey, parentIds)
+      .get();
+
+    // Group related rows by foreign key
+    const relatedByParent = {};
+    relatedRows.forEach((row) => {
+      const parentId = row[foreignKey];
+      if (!relatedByParent[parentId]) {
+        relatedByParent[parentId] = [];
+      }
+      relatedByParent[parentId].push(row);
+    });
+
+    // Attach related rows to parent rows
+    rows.forEach((row) => {
+      row[relation] = relatedByParent[row.id] || [];
+    });
+  }
+}

package/src/plugins/HookPlugin.js

@@ -0,0 +1,211 @@
+/**
+ * @license MIT
+ * Copyright (c) 2026-present AetherFramework Contributors.
+ * SPDX-License-Identifier: MIT
+ * @module @aetherframework/database/plugin/HoolPlugin
+ */
+import { BasePlugin } from './BasePlugin.js';
+
+export class HookPlugin extends BasePlugin {
+  constructor(queryBuilder) {
+    super(queryBuilder);
+    this.hooks = {};
+    this.validationRules = {};
+  }
+
+  /**
+   * Register plugin methods to QueryBuilder
+   * @protected
+   */
+  _registerMethods() {
+    // Register hook management methods
+    this.queryBuilder.addHook = this.addHook.bind(this);
+    this.queryBuilder.triggerHook = this.triggerHook.bind(this);
+    this.queryBuilder.setValidationRules = this.setValidationRules.bind(this);
+    this.queryBuilder.validateData = this.validateData.bind(this);
+    
+    // Register specific hook shortcuts
+    this.queryBuilder.beforeInsert = (callback) => this.addHook('beforeInsert', callback);
+    this.queryBuilder.afterInsert = (callback) => this.addHook('afterInsert', callback);
+    this.queryBuilder.beforeUpdate = (callback) => this.addHook('beforeUpdate', callback);
+    this.queryBuilder.afterUpdate = (callback) => this.addHook('afterUpdate', callback);
+    this.queryBuilder.beforeDelete = (callback) => this.addHook('beforeDelete', callback);
+    this.queryBuilder.afterDelete = (callback) => this.addHook('afterDelete', callback);
+    this.queryBuilder.beforeSelect = (callback) => this.addHook('beforeSelect', callback);
+    this.queryBuilder.afterSelect = (callback) => this.addHook('afterSelect', callback);
+    this.queryBuilder.onBeforeInsert = (callback) => this.addHook('beforeInsert', callback);
+    this.queryBuilder.onAfterInsert = (callback) => this.addHook('afterInsert', callback);
+    this.queryBuilder.onBeforeUpdate = (callback) => this.addHook('beforeUpdate', callback);
+    this.queryBuilder.onAfterUpdate = (callback) => this.addHook('afterUpdate', callback);
+    this.queryBuilder.onBeforeDelete = (callback) => this.addHook('beforeDelete', callback);
+    this.queryBuilder.onAfterDelete = (callback) => this.addHook('afterDelete', callback);
+    this.queryBuilder.onBeforeSelect = (callback) => this.addHook('beforeSelect', callback);
+    this.queryBuilder.onAfterSelect = (callback) => this.addHook('afterSelect', callback);
+  }
+
+  /**
+   * Add a hook for specific event
+   * @param {string} event - Hook event name
+   * @param {Function} callback - Hook callback function
+   * @returns {QueryBuilder} Query builder instance
+   */
+  addHook(event, callback) {
+    if (!this.hooks[event]) {
+      this.hooks[event] = [];
+    }
+    this.hooks[event].push(callback);
+    return this.queryBuilder;
+  }
+
+  /**
+   * Trigger hooks for specific event
+   * @param {string} event - Hook event name
+   * @param {*} data - Data to pass to hooks
+   * @returns {Promise<void>}
+   */
+  async triggerHook(event, data) {
+    if (!this.hooks[event]) {
+      return;
+    }
+
+    for (const hook of this.hooks[event]) {
+      const result = await hook(data, this.queryBuilder);
+      if (result === false) {
+        throw new Error(`Hook ${event} returned false, operation cancelled`);
+      }
+    }
+  }
+
+  /**
+   * Set validation rules for data
+   * @param {Object} rules - Validation rules object
+   * @returns {QueryBuilder} Query builder instance
+   */
+  setValidationRules(rules) {
+    this.validationRules = rules;
+    return this.queryBuilder;
+  }
+
+  /**
+   * Validate data against rules
+   * @param {Object} data - Data to validate
+   * @returns {Array} Array of validation errors
+   */
+  validateData(data) {
+    const errors = [];
+
+    for (const [field, rule] of Object.entries(this.validationRules)) {
+      const value = data[field];
+
+      // Check required field
+      if (rule.required && (value === undefined || value === null || value === '')) {
+        errors.push(`${field} is required`);
+        continue;
+      }
+
+      // Skip validation if value is not provided and not required
+      if (value === undefined || value === null) {
+        continue;
+      }
+
+      // Type validation
+      if (rule.type) {
+        const typeCheck = this._validateType(value, rule.type);
+        if (!typeCheck.valid) {
+          errors.push(`${field} must be ${rule.type}, got ${typeCheck.actual}`);
+          continue;
+        }
+      }
+
+      // Minimum value validation
+      if (rule.min !== undefined) {
+        if (typeof value === 'number' && value < rule.min) {
+          errors.push(`${field} must be at least ${rule.min}`);
+        } else if (typeof value === 'string' && value.length < rule.min) {
+          errors.push(`${field} must be at least ${rule.min} characters`);
+        }
+      }
+
+      // Maximum value validation
+      if (rule.max !== undefined) {
+        if (typeof value === 'number' && value > rule.max) {
+          errors.push(`${field} must be at most ${rule.max}`);
+        } else if (typeof value === 'string' && value.length > rule.max) {
+          errors.push(`${field} must be at most ${rule.max} characters`);
+        }
+      }
+
+      // Pattern validation
+      if (rule.pattern && !rule.pattern.test(value)) {
+        errors.push(`${field} format is invalid`);
+      }
+
+      // Enum validation
+      if (rule.enum && !rule.enum.includes(value)) {
+        errors.push(`${field} must be one of: ${rule.enum.join(', ')}`);
+      }
+
+      // Custom validation function
+      if (rule.validate && typeof rule.validate === 'function') {
+        const customResult = rule.validate(value, data);
+        if (customResult !== true) {
+          errors.push(`${field}: ${customResult}`);
+        }
+      }
+    }
+
+    return errors;
+  }
+
+  /**
+   * Validate data type
+   * @private
+   */
+  _validateType(value, expectedType) {
+    const actualType = typeof value;
+    
+    // Handle special cases
+    if (expectedType === 'array' && Array.isArray(value)) {
+      return { valid: true, actual: 'array' };
+    }
+    
+    if (expectedType === 'object' && value !== null && !Array.isArray(value) && actualType === 'object') {
+      return { valid: true, actual: 'object' };
+    }
+    
+    if (expectedType === 'integer' && Number.isInteger(value)) {
+      return { valid: true, actual: 'integer' };
+    }
+    
+    if (expectedType === 'float' && typeof value === 'number' && !Number.isInteger(value)) {
+      return { valid: true, actual: 'float' };
+    }
+    
+    if (expectedType === 'date' && value instanceof Date) {
+      return { valid: true, actual: 'date' };
+    }
+    
+    if (expectedType === 'email' && typeof value === 'string' && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+      return { valid: true, actual: 'email' };
+    }
+    
+    if (expectedType === 'url' && typeof value === 'string' && /^https?:\/\/[^\s$.?#].[^\s]*$/.test(value)) {
+      return { valid: true, actual: 'url' };
+    }
+    
+    return { valid: actualType === expectedType, actual: actualType };
+  }
+
+  /**
+   * Get plugin metadata
+   * @returns {Object} Plugin metadata
+   */
+  getMetadata() {
+    return {
+      ...super.getMetadata(),
+      description: 'Hook and validation plugin for QueryBuilder',
+      hooks: Object.keys(this.hooks),
+      validationRules: Object.keys(this.validationRules)
+    };
+  }
+}