velocity-python 0.0.186__tar.gz → 0.0.188__tar.gz

{velocity_python-0.0.186/src/velocity_python.egg-info → velocity_python-0.0.188}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.186
+Version: 0.0.188
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.0.186 → velocity_python-0.0.188}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.0.186"
+version = "0.0.188"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.0.186 → velocity_python-0.0.188}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.186"
+__version__ = version = "0.0.188"
 
 from . import aws
 from . import db

{velocity_python-0.0.186 → velocity_python-0.0.188}/src/velocity/aws/handlers/mixins/__init__.py

@@ -8,6 +8,6 @@ This package provides mixins for common Lambda handler patterns:
 """
 
 from .web_handler import WebHandler, ButtonHandler
-from .data_service import DataServiceMixin, RWXHookSystem, apply_sys_modified_by
+from .data_service import DataServiceMixin
 
-__all__ = ['WebHandler', 'ButtonHandler', 'DataServiceMixin', 'RWXHookSystem', 'apply_sys_modified_by']
+__all__ = ['WebHandler', 'ButtonHandler', 'DataServiceMixin',]

{velocity_python-0.0.186 → velocity_python-0.0.188}/src/velocity/aws/handlers/mixins/data_service.py

@@ -87,15 +87,15 @@ class DataServiceMixin:
             raise Exception("An object id was not provided for read operation")
         if sys_id == "@new":
             row = {}
-            self._call_rwx_hook("on_new", "common", tx, "common", row, context)
+            self._call_rwx_hook("on_new", "common", tx, table, row, context)
             self._call_rwx_hook("on_new", table, tx, table, row, context)
             return row
         sys_id = int(sys_id)
-        self._call_rwx_hook("before_read", "common", tx, "common", sys_id, context)
+        self._call_rwx_hook("before_read", "common", tx, table, sys_id, context)
         self._call_rwx_hook("before_read", table, tx, table, sys_id, context)
         row = tx.table(table).find(sys_id)
         row = row.to_dict() if row else {}
-        self._call_rwx_hook("after_read", "common", tx, "common", sys_id, row, context)
+        self._call_rwx_hook("after_read", "common", tx, table, sys_id, row, context)
         self._call_rwx_hook("after_read", table, tx, table, sys_id, row, context)
         return row
 
@@ -103,10 +103,10 @@ class DataServiceMixin:
         row = {}
         if not where:
             raise Exception("An query predicate was not provided for this read operation")
-        self._call_rwx_hook("before_find", "common", tx, "common", where, context)
+        self._call_rwx_hook("before_find", "common", tx, table, where, context)
         self._call_rwx_hook("before_find", table, tx, table, where, context)
         row = tx.table(table).find(where)
-        self._call_rwx_hook("after_find", "common", tx, "common", where, row, context)
+        self._call_rwx_hook("after_find", "common", tx, table, where, row, context)
         self._call_rwx_hook("after_find", table, tx, table, where, row, context)
         if row:
             row = row.to_dict()
@@ -116,28 +116,28 @@ class DataServiceMixin:
         row = {}
         incoming.pop("sys_id", None)
         if sys_id == "@new":
-            self._call_rwx_hook("before_new", "common", tx, "common", sys_id, incoming, context)
+            self._call_rwx_hook("before_new", "common", tx, table, sys_id, incoming, context)
             self._call_rwx_hook("before_new", table, tx, table, sys_id, incoming, context)
             row = tx.table(table).new()
             sys_id = row["sys_id"]
-            self._call_rwx_hook("after_new", "common", tx, "common", sys_id, row, context)
+            self._call_rwx_hook("after_new", "common", tx, table, sys_id, row, context)
             self._call_rwx_hook("after_new", table, tx, table, sys_id, row, context)
         elif sys_id:
             sys_id = int(sys_id)
         else:
             raise Exception("Object sys_id was not supplied on write operation.")
-        self._call_rwx_hook("before_write", "common", tx, "common", sys_id, incoming, context)
+        self._call_rwx_hook("before_write", "common", tx, table, sys_id, incoming, context)
         self._call_rwx_hook("before_write", table, tx, table, sys_id, incoming, context)
         if not row:
             row = tx.table(table).get(sys_id)
         row.update(incoming)
-        self._call_rwx_hook("after_write", "common", tx, "common", sys_id, row, context)
+        self._call_rwx_hook("after_write", "common", tx, table, sys_id, row, context)
         self._call_rwx_hook("after_write", table, tx, table, sys_id, row, context)
 
         return row.to_dict()
     
     def query_hook(self, tx, table, payload, context):
-        self._call_rwx_hook("before_query", "common", tx, "common", payload, context)
+        self._call_rwx_hook("before_query", "common", tx, table, payload, context)
         self._call_rwx_hook("before_query", table, tx, table, payload, context)
         params = payload.get("params", {})
         result = tx.table(payload["obj"]).select(**params)
@@ -168,19 +168,19 @@ class DataServiceMixin:
                 }
                 for x in result.columns.values()
             ]
-        self._call_rwx_hook("after_query", "common", tx, "common", data, payload, context)
+        self._call_rwx_hook("after_query", "common", tx, table, data, payload, context)
         self._call_rwx_hook("after_query", table, tx, table, data, payload, context)
         return data
     
     def delete_hook(self, tx, table, sys_id, context):
         if sys_id:
             sys_id = int(sys_id)
-            self._call_rwx_hook("before_delete", "common", tx, "common", sys_id, context)
+            self._call_rwx_hook("before_delete", "common", tx, table, sys_id, context)
             self._call_rwx_hook("before_delete", table, tx, table, sys_id, context)
             row = tx.table(table).find(sys_id)
             if row:
                 row.clear()
-            self._call_rwx_hook("after_delete", "common", tx, "common", sys_id, context)
+            self._call_rwx_hook("after_delete", "common", tx, table, sys_id, context)
             self._call_rwx_hook("after_delete", table, tx, table, sys_id, context)
 
     
@@ -532,134 +532,3 @@ class DataServiceMixin:
                 )
             raise Exception(f"Failed to retrieve table schema: {str(e)}")
 
-
-class RWXHookSystem:
-    """
-    RWX (Read/Write/eXecute) hook system for table-specific business logic.
-    
-    This system allows you to create table-specific hook modules in an 'rwx' package
-    and have them automatically called during CRUD operations. This is useful for
-    adding custom business logic (validation, permissions, data enrichment) for
-    specific tables without modifying the generic DataServiceMixin.
-    
-    How it works:
-    1. Create a Python package called 'rwx' in your Lambda handler
-    2. For each table that needs custom logic, create a module (e.g., rwx/admin_users.py)
-    3. Define hook functions in the module (before_read, after_write, before_delete, etc.)
-    4. Subclass RWXHookSystem and set hook_module_name = 'rwx'
-    5. Use it from your handler class
-    
-    Example structure:
-        src/
-            index.py
-            rwx/
-                __init__.py
-                admin_users.py      # hooks for admin_users table
-                donors.py           # hooks for donors table
-    
-    Example hook in rwx/admin_users.py:
-        def before_write(tx, table, sys_id, incoming, context):
-            # Validate incoming data
-            if not incoming.get('email_address'):
-                raise ValueError("Email is required")
-            # Modify data
-            incoming['description'] = f"{incoming['full_name']} ({incoming['email_address']})"
-        
-        def after_read(tx, table, sys_id, row, context):
-            # Enrich response data
-            context.response().set_body({'extra_data': 'value'})
-    
-    Hook signatures:
-    - on_new(tx, table, row, context) - When creating new empty object
-    - before_read(tx, table, sys_id, context) - Before reading an object
-    - after_read(tx, table, sys_id, row, context) - After reading an object
-    - before_find(tx, table, query, context) - Before finding by query
-    - after_find(tx, table, query, row, context) - After finding by query
-    - before_new(tx, table, sys_id, incoming, context) - Before creating new object
-    - after_new(tx, table, sys_id, row, context) - After creating new object
-    - before_write(tx, table, sys_id, incoming, context) - Before write (insert/update)
-    - after_write(tx, table, sys_id, row, context) - After write (insert/update)
-    - before_delete(tx, table, sys_id, context) - Before deleting an object
-    - after_delete(tx, table, sys_id, context) - After deleting an object
-    - before_query(tx, table, payload, context) - Before querying objects
-    - after_query(tx, table, data, payload, context) - After querying objects
-    
-    Usage in a Lambda handler:
-        from velocity.aws.handlers.mixins import DataServiceMixin, RWXHookSystem
-        
-        class MyRWXSystem(RWXHookSystem):
-            hook_module_name = 'rwx'  # Name of your rwx package
-        
-        @engine.transaction
-        class HttpEventHandler(DataServiceMixin, LambdaHandler):
-            def __init__(self, aws_event, aws_context):
-                super().__init__(aws_event, aws_context)
-    """
-    
-    hook_module_name = None  # Override in subclass (e.g., 'rwx')
-    
-    @classmethod
-    def _get_table_module(cls, table):
-        """Load table-specific hook module if it exists"""
-        if not cls.hook_module_name:
-            return None
-        try:
-            return importlib.import_module(f".{table}", cls.hook_module_name)
-        except ImportError:
-            return None
-    
-    @classmethod
-    def _call_hook(cls, hook_name, table, *args, **kwargs):
-        """Call a hook on table-specific module if it exists"""
-        module = cls._get_table_module(table)
-        if module and hasattr(module, hook_name):
-            return getattr(module, hook_name)(*args, **kwargs)
-        return None
-
-
-def apply_sys_modified_by(incoming, context):
-    """
-    Strip sys_* fields and set sys_modified_by from context.
-    
-    Common pattern for applications that track who modified records.
-    Call this from your write_hook implementation.
-    
-    Args:
-        incoming: Dictionary of data being written
-        context: Request context with session/payload
-    """
-    payload = context.payload()
-    
-    # Strip system fields from incoming data
-    for key in list(incoming.keys()):
-        if "sys_" in key:
-            incoming.pop(key)
-    
-    # Extract email from session
-    session = context.session() if hasattr(context, "session") else None
-    email_address = None
-    
-    if isinstance(session, dict):
-        email_address = session.get("cognito_user_email")
-        if not email_address:
-            cognito_user = session.get("cognito_user")
-            if isinstance(cognito_user, dict):
-                email_address = cognito_user.get("email") or (
-                    cognito_user.get("attributes") or {}
-                ).get("email")
-        if not email_address:
-            email_address = session.get("email_address")
-    
-    if not email_address and isinstance(payload, dict):
-        payload_user = payload.get("cognito_user")
-        if isinstance(payload_user, dict):
-            email_address = payload_user.get("email") or (
-                payload_user.get("attributes") or {}
-            ).get("email")
-    
-    incoming["sys_modified_by"] = (
-        email_address.lower()
-        if isinstance(email_address, str)
-        else incoming.get("sys_modified_by", "unknown")
-    )
-    incoming["sys_dirty"] = True

{velocity_python-0.0.186 → velocity_python-0.0.188/src/velocity_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.186
+Version: 0.0.188
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT