exonware-xwnode 0.0.1.13__py3-none-any.whl → 0.0.1.15__py3-none-any.whl

exonware/xwnode/queries/executors/core/create_executor.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/core/create_executor.py
+
+CREATE Executor
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+Generation Date: 08-Oct-2025
+"""
+
+from typing import Any, Dict, List
+from ..base import AUniversalOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+from ..types import OperationType
+from ...nodes.strategies.contracts import NodeType
+
+
+class CreateExecutor(AUniversalOperationExecutor):
+    """
+    CREATE operation executor - Universal operation.
+    
+    Creates new structures (collections, indices, schemas) in nodes.
+    Works on all node types (LINEAR, TREE, GRAPH, MATRIX, HYBRID).
+    
+    Capability: Universal
+    Operation Type: CORE
+    """
+    
+    OPERATION_NAME = "CREATE"
+    OPERATION_TYPE = OperationType.CORE
+    SUPPORTED_NODE_TYPES = []  # Empty = Universal (all types)
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute CREATE operation."""
+        # 1. Extract parameters
+        params = action.params
+        structure_type = params.get('type', 'collection')  # collection, index, schema
+        name = params.get('name', 'new_structure')
+        schema = params.get('schema', {})
+        options = params.get('options', {})
+        
+        # 2. Get node strategy
+        node = context.node
+        
+        # 3. Execute create
+        result_data = self._execute_create(node, structure_type, name, schema, options, context)
+        
+        # 4. Return result
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={
+                'structure_type': structure_type,
+                'name': name,
+                'created': result_data.get('created', False)
+            }
+        )
+    
+    def _execute_create(self, node: Any, structure_type: str, name: str, 
+                       schema: Dict, options: Dict, context: ExecutionContext) -> Dict:
+        """Actual CREATE logic."""
+        try:
+            # Create structure based on type
+            if structure_type == 'collection':
+                # Create a new collection/path
+                node.set(name, {})
+                created = True
+            elif structure_type == 'index':
+                # Create an index (simplified)
+                index_path = f"_indices.{name}"
+                node.set(index_path, {'type': 'index', 'fields': schema})
+                created = True
+            elif structure_type == 'schema':
+                # Create a schema definition
+                schema_path = f"_schemas.{name}"
+                node.set(schema_path, schema)
+                created = True
+            else:
+                created = False
+            
+            return {
+                'created': created,
+                'type': structure_type,
+                'name': name,
+                'path': name
+            }
+        except Exception as e:
+            return {
+                'created': False,
+                'error': str(e)
+            }
+

exonware/xwnode/queries/executors/core/delete_executor.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/core/delete_executor.py
+
+DELETE Executor
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+Generation Date: 08-Oct-2025
+"""
+
+from typing import Any, Dict, List
+from ..base import AUniversalOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+from ..types import OperationType
+from ...nodes.strategies.contracts import NodeType
+
+
+class DeleteExecutor(AUniversalOperationExecutor):
+    """
+    DELETE operation executor - Universal operation.
+    
+    Deletes data from nodes based on specified conditions.
+    Works on all node types (LINEAR, TREE, GRAPH, MATRIX, HYBRID).
+    
+    Capability: Universal
+    Operation Type: CORE
+    """
+    
+    OPERATION_NAME = "DELETE"
+    OPERATION_TYPE = OperationType.CORE
+    SUPPORTED_NODE_TYPES = []  # Empty = Universal (all types)
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute DELETE operation."""
+        # 1. Extract parameters
+        params = action.params
+        target = params.get('target', None)  # What to delete (path/key)
+        condition = params.get('where', None)  # Delete condition
+        
+        # 2. Get node strategy
+        node = context.node
+        
+        # 3. Execute delete
+        result_data = self._execute_delete(node, target, condition, context)
+        
+        # 4. Return result
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={
+                'deleted_count': result_data.get('count', 0),
+                'target': target,
+                'condition': condition
+            }
+        )
+    
+    def _execute_delete(self, node: Any, target: str, condition: Any, 
+                       context: ExecutionContext) -> Dict:
+        """Actual DELETE logic."""
+        deleted_count = 0
+        deleted_items = []
+        
+        if target:
+            # Delete specific target
+            try:
+                current = node.get(target, default=None)
+                if current is not None and self._matches_condition(current, condition):
+                    node.delete(target)
+                    deleted_count = 1
+                    deleted_items.append(target)
+            except Exception as e:
+                return {
+                    'count': 0,
+                    'items': [],
+                    'error': str(e)
+                }
+        else:
+            # Delete all matching items
+            # This is a simplified implementation
+            deleted_count = 0
+            deleted_items = []
+        
+        return {
+            'count': deleted_count,
+            'items': deleted_items
+        }
+    
+    def _matches_condition(self, item: Any, condition: Any) -> bool:
+        """Check if item matches condition."""
+        if condition is None:
+            return True
+        
+        # Simplified condition checking
+        return True
+

exonware/xwnode/queries/executors/core/drop_executor.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/core/drop_executor.py
+
+DROP Executor
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+Generation Date: 08-Oct-2025
+"""
+
+from typing import Any, Dict, List
+from ..base import AUniversalOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+from ..types import OperationType
+from ...nodes.strategies.contracts import NodeType
+
+
+class DropExecutor(AUniversalOperationExecutor):
+    """
+    DROP operation executor - Universal operation.
+    
+    Drops/removes structures (collections, indices, schemas) from nodes.
+    Works on all node types (LINEAR, TREE, GRAPH, MATRIX, HYBRID).
+    
+    Capability: Universal
+    Operation Type: CORE
+    """
+    
+    OPERATION_NAME = "DROP"
+    OPERATION_TYPE = OperationType.CORE
+    SUPPORTED_NODE_TYPES = []  # Empty = Universal (all types)
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute DROP operation."""
+        # 1. Extract parameters
+        params = action.params
+        structure_type = params.get('type', 'collection')
+        name = params.get('name')
+        if_exists = params.get('if_exists', False)
+        
+        # 2. Get node strategy
+        node = context.node
+        
+        # 3. Execute drop
+        result_data = self._execute_drop(node, structure_type, name, if_exists, context)
+        
+        # 4. Return result
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={
+                'structure_type': structure_type,
+                'name': name,
+                'dropped': result_data.get('dropped', False)
+            }
+        )
+    
+    def _execute_drop(self, node: Any, structure_type: str, name: str, 
+                     if_exists: bool, context: ExecutionContext) -> Dict:
+        """Actual DROP logic."""
+        try:
+            # Determine path based on structure type
+            if structure_type == 'index':
+                path = f"_indices.{name}"
+            elif structure_type == 'schema':
+                path = f"_schemas.{name}"
+            else:
+                path = name
+            
+            # Check if exists
+            exists = node.get(path, default=None) is not None
+            
+            if not exists and not if_exists:
+                return {
+                    'dropped': False,
+                    'error': f"Structure '{name}' does not exist"
+                }
+            
+            if exists:
+                node.delete(path)
+                dropped = True
+            else:
+                dropped = False
+            
+            return {
+                'dropped': dropped,
+                'type': structure_type,
+                'name': name,
+                'path': path
+            }
+        except Exception as e:
+            return {
+                'dropped': False,
+                'error': str(e)
+            }
+

exonware/xwnode/queries/executors/core/insert_executor.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/core/insert_executor.py
+
+INSERT Operation Executor
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+Generation Date: 08-Oct-2025
+"""
+
+from ..base import AUniversalOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+
+
+class InsertExecutor(AUniversalOperationExecutor):
+    """INSERT operation executor - Universal operation."""
+    
+    OPERATION_NAME = "INSERT"
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute INSERT operation on node."""
+        key = action.params.get('key')
+        value = action.params.get('value')
+        
+        # Insert into node using strategy
+        if hasattr(context.node, 'insert'):
+            context.node.insert(key, value)
+        elif hasattr(context.node, 'put'):
+            context.node.put(key, value)
+        elif hasattr(context.node, '_strategy'):
+            context.node._strategy.insert(key, value)
+        
+        return ExecutionResult(data={'inserted': key}, affected_count=1)
+
+
+__all__ = ['InsertExecutor']

exonware/xwnode/queries/executors/core/select_executor.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/core/select_executor.py
+
+SELECT Operation Executor
+
+Implements SELECT operation execution on all node types.
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+Generation Date: 08-Oct-2025
+"""
+
+from typing import Any, List, Dict, Optional
+from ..base import AUniversalOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+from ..types import OperationCapability
+from ...nodes.strategies.contracts import NodeType
+
+
+class SelectExecutor(AUniversalOperationExecutor):
+    """
+    SELECT operation executor - Universal operation.
+    
+    Works on all node types (LINEAR, TREE, GRAPH, MATRIX).
+    Retrieves and projects data from nodes.
+    """
+    
+    OPERATION_NAME = "SELECT"
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """
+        Execute SELECT operation.
+        
+        Supports:
+        - Column projection
+        - Star (*) selection
+        - Expressions and aliases
+        - Adapts to different node types
+        """
+        # Extract parameters
+        columns = action.params.get('columns', ['*'])
+        source = action.params.get('from', context.node)
+        
+        # Get node type
+        node_type = self._get_node_type(context.node)
+        
+        # Route to appropriate handler based on node type
+        if node_type == NodeType.LINEAR:
+            data = self._select_from_linear(source, columns, context)
+        elif node_type == NodeType.TREE:
+            data = self._select_from_tree(source, columns, context)
+        elif node_type == NodeType.GRAPH:
+            data = self._select_from_graph(source, columns, context)
+        elif node_type == NodeType.MATRIX:
+            data = self._select_from_matrix(source, columns, context)
+        else:  # HYBRID
+            data = self._select_from_tree(source, columns, context)  # Default to tree
+        
+        return ExecutionResult(
+            data=data,
+            affected_count=len(data) if isinstance(data, list) else 1
+        )
+    
+    def _get_node_type(self, node: Any) -> NodeType:
+        """Get node's strategy type."""
+        if hasattr(node, '_strategy') and hasattr(node._strategy, 'STRATEGY_TYPE'):
+            return node._strategy.STRATEGY_TYPE
+        elif hasattr(node, 'STRATEGY_TYPE'):
+            return node.STRATEGY_TYPE
+        return NodeType.TREE  # Default
+    
+    def _select_from_linear(self, source: Any, columns: List[str], context: ExecutionContext) -> List[Dict]:
+        """Select from linear node (list-like)."""
+        results = []
+        
+        # Iterate through linear structure
+        if hasattr(source, 'items'):
+            for key, value in source.items():
+                if columns == ['*']:
+                    results.append({'key': key, 'value': value})
+                else:
+                    row = self._project_columns(value, columns)
+                    results.append(row)
+        
+        return results
+    
+    def _select_from_tree(self, source: Any, columns: List[str], context: ExecutionContext) -> List[Dict]:
+        """Select from tree node (key-value map)."""
+        results = []
+        
+        # Iterate through tree structure
+        if hasattr(source, 'items'):
+            for key, value in source.items():
+                if columns == ['*']:
+                    results.append({'key': key, 'value': value})
+                else:
+                    row = self._project_columns(value, columns)
+                    if row:
+                        results.append(row)
+        
+        return results
+    
+    def _select_from_graph(self, source: Any, columns: List[str], context: ExecutionContext) -> List[Dict]:
+        """Select from graph node."""
+        # For graphs, return nodes
+        results = []
+        
+        if hasattr(source, 'items'):
+            for key, value in source.items():
+                if columns == ['*']:
+                    results.append({'node_id': key, 'node_data': value})
+                else:
+                    row = self._project_columns(value, columns)
+                    if row:
+                        row['node_id'] = key
+                        results.append(row)
+        
+        return results
+    
+    def _select_from_matrix(self, source: Any, columns: List[str], context: ExecutionContext) -> List[Dict]:
+        """Select from matrix node."""
+        results = []
+        
+        # Iterate through matrix
+        if hasattr(source, 'items'):
+            for key, value in source.items():
+                if columns == ['*']:
+                    results.append({'position': key, 'value': value})
+                else:
+                    row = self._project_columns(value, columns)
+                    if row:
+                        results.append(row)
+        
+        return results
+    
+    def _project_columns(self, value: Any, columns: List[str]) -> Optional[Dict]:
+        """Project specific columns from a value."""
+        if not isinstance(value, dict):
+            return {'value': value}
+        
+        projected = {}
+        for col in columns:
+            if col in value:
+                projected[col] = value[col]
+        
+        return projected if projected else None
+
+
+__all__ = ['SelectExecutor']

exonware/xwnode/queries/executors/core/update_executor.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/core/update_executor.py
+
+UPDATE Executor
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+Generation Date: 08-Oct-2025
+"""
+
+from typing import Any, Dict, List
+from ..base import AUniversalOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+from ..types import OperationType
+from ...nodes.strategies.contracts import NodeType
+
+
+class UpdateExecutor(AUniversalOperationExecutor):
+    """
+    UPDATE operation executor - Universal operation.
+    
+    Updates existing data in nodes based on specified conditions.
+    Works on all node types (LINEAR, TREE, GRAPH, MATRIX, HYBRID).
+    
+    Capability: Universal
+    Operation Type: CORE
+    """
+    
+    OPERATION_NAME = "UPDATE"
+    OPERATION_TYPE = OperationType.CORE
+    SUPPORTED_NODE_TYPES = []  # Empty = Universal (all types)
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute UPDATE operation."""
+        # 1. Extract parameters
+        params = action.params
+        target = params.get('target', None)  # What to update (path/key)
+        values = params.get('values', {})    # New values
+        condition = params.get('where', None)  # Update condition
+        
+        # 2. Get node strategy
+        node = context.node
+        
+        # 3. Execute update
+        result_data = self._execute_update(node, target, values, condition, context)
+        
+        # 4. Return result
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={
+                'updated_count': result_data.get('count', 0),
+                'target': target,
+                'condition': condition
+            }
+        )
+    
+    def _execute_update(self, node: Any, target: str, values: Dict, 
+                       condition: Any, context: ExecutionContext) -> Dict:
+        """Actual UPDATE logic."""
+        updated_count = 0
+        updated_items = []
+        
+        if target:
+            # Update specific target
+            try:
+                current = node.get(target, default=None)
+                if current is not None and self._matches_condition(current, condition):
+                    node.set(target, values)
+                    updated_count = 1
+                    updated_items.append(target)
+            except Exception as e:
+                return {
+                    'count': 0,
+                    'items': [],
+                    'error': str(e)
+                }
+        else:
+            # Update all matching items
+            # This is a simplified implementation - real version would traverse node
+            updated_count = 0
+            updated_items = []
+        
+        return {
+            'count': updated_count,
+            'items': updated_items,
+            'values': values
+        }
+    
+    def _matches_condition(self, item: Any, condition: Any) -> bool:
+        """Check if item matches condition."""
+        if condition is None:
+            return True
+        
+        # Simplified condition checking
+        # Real implementation would evaluate WHERE clause
+        return True
+

exonware/xwnode/queries/executors/data/__init__.py

@@ -0,0 +1,13 @@
+"""Data operation executors."""
+
+from .load_executor import LoadExecutor
+from .store_executor import StoreExecutor
+from .merge_executor import MergeExecutor
+from .alter_executor import AlterExecutor
+
+__all__ = [
+    'LoadExecutor',
+    'StoreExecutor',
+    'MergeExecutor',
+    'AlterExecutor',
+]

exonware/xwnode/queries/executors/data/alter_executor.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+#exonware/xwnode/src/exonware/xwnode/queries/executors/data/alter_executor.py
+
+ALTER Executor
+
+Company: eXonware.com
+Author: Eng. Muhammad AlShehri
+Email: connect@exonware.com
+Version: 0.0.1.15
+Generation Date: 09-Oct-2025
+"""
+
+from typing import Any, Dict, List
+from ..base import AUniversalOperationExecutor
+from ..contracts import Action, ExecutionContext, ExecutionResult
+from ..types import OperationType
+
+class AlterExecutor(AUniversalOperationExecutor):
+    """
+    ALTER operation executor.
+    
+    Alters structure/schema
+    
+    Capability: Universal
+    Operation Type: DATA_OPS
+    """
+    
+    OPERATION_NAME = "ALTER"
+    OPERATION_TYPE = OperationType.DATA_OPS
+    SUPPORTED_NODE_TYPES = []  # Universal
+    
+    def _do_execute(self, action: Action, context: ExecutionContext) -> ExecutionResult:
+        """Execute ALTER operation."""
+        params = action.params
+        node = context.node
+        
+        result_data = self._execute_alter(node, params, context)
+        
+        return ExecutionResult(
+            success=True,
+            data=result_data,
+            operation=self.OPERATION_NAME,
+            metadata={'operation': self.OPERATION_NAME}
+        )
+    
+    def _execute_alter(self, node: Any, params: Dict, context: ExecutionContext) -> Dict:
+        """Execute alter logic."""
+        # Implementation here
+        return {'result': 'ALTER executed', 'params': params}