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

{velocity_python-0.0.185 → velocity_python-0.0.186}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.0.185
+Version: 0.0.186
 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.185 → velocity_python-0.0.186}/pyproject.toml

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

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

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

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

@@ -58,319 +58,322 @@ class DataServiceMixin:
             else self._pg_types.get(column_info["type_name"], "string")
         )
     
-    # ========== Hook Methods (Override These) ==========
-    
-    def read_hook(self, tx, table_name, sys_id, row, context):
+    def _call_rwx_hook(self, hook_name, table, *args, **kwargs):
         """
-        Called after reading an object. Override to add custom logic.
+        Call a table-specific RWX hook if it exists.
         
-        Args:
-            tx: Database transaction
-            table_name: Name of the table
-            sys_id: Record ID
-            row: Dictionary of record data
-            context: Request context
-        """
-        pass
-    
-    def write_hook(self, tx, table_name, sys_id, incoming, context):
-        """
-        Called before writing an object. Override to add validation/transformation.
+        This method tries to load a hook from the rwx package and call it.
+        If the hook doesn't exist, execution continues silently.
         
         Args:
-            tx: Database transaction
-            table_name: Name of the table
-            sys_id: Record ID (or "@new" for new records)
-            incoming: Dictionary of data to write
-            context: Request context
+            hook_name: Name of the hook (e.g., 'before_write', 'after_read')
+            table: Table name (used to load table-specific module)
+            *args: Arguments to pass to the hook
+            **kwargs: Keyword arguments to pass to the hook
         """
-        pass
+        try:
+            m = importlib.import_module(f".{table}", "rwx")
+            if hasattr(m, hook_name):
+                getattr(m, hook_name)(*args, **kwargs)
+        except ImportError:
+            # rwx package not available, continue without hooks
+            pass
     
-    def query_hook(self, tx, table_name, params, data, context):
-        """
-        Called after querying objects. Override to transform results.
-        
-        Args:
-            tx: Database transaction
-            table_name: Name of the table
-            params: Query parameters
-            data: Query results
-            context: Request context
-        """
-        pass
+    # ========== Hook Methods (Override These) ==========
     
-    def delete_hook(self, tx, table_name, sys_id, context):
-        """
-        Called before deleting an object. Override to add authorization.
-        
-        Args:
-            tx: Database transaction
-            table_name: Name of the table
-            sys_id: Record ID to delete
-            context: Request context
-        """
-        pass
+    def read_hook(self, tx, table, sys_id, context):
+        row = {}
+        if not sys_id:
+            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", 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", 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", table, tx, table, sys_id, row, context)
+        return row
+
+    def find_hook(self, tx, table, where, context):
+        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", 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", table, tx, table, where, row, context)
+        if row:
+            row = row.to_dict()
+        return row
+    
+    def write_hook(self, tx, table, sys_id, incoming, context):
+        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", 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", 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", 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", 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", table, tx, table, payload, context)
+        params = payload.get("params", {})
+        result = tx.table(payload["obj"]).select(**params)
+        if payload.get("result_format") == "excel":
+            data = {
+                "headers": payload.get(
+                    "headers", [x.replace("_", " ").title() for x in result.headers]
+                ),
+                "rows": result.as_list().all(),
+            }
+        else:
+            data = {
+                "rows": result.all(),
+                "config": {
+                    "lastFetch": datetime.datetime.now(),
+                    "query": result.sql,
+                    "format": payload.get("result_format"),
+                },
+            }
+        if payload.get("count"):
+            data["count"] = tx.table(payload["obj"]).count(where=params.get("where", None))
+        if payload.get("headers"):
+            data["columns"] = [
+                {
+                    "field": x["name"],
+                    "headerName": x["name"].replace("_", " ").title(),
+                    "type": self._get_field_type(x),
+                }
+                for x in result.columns.values()
+            ]
+        self._call_rwx_hook("after_query", "common", tx, "common", 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", 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", table, tx, table, sys_id, context)
+
     
     # ========== CRUD Action Methods ==========
     
     def OnActionReadObject(self, tx, context):
-        """
-        Read a single object by sys_id.
-        
-        Payload:
-            tableName: str - Name of the database table
-            object: dict - Object containing sys_id field
-        """
         payload = context.payload()
-        
+
         # Validate required parameters
         if "tableName" not in payload:
             raise ValueError("Missing required parameter 'tableName' in payload")
         if "object" not in payload:
             raise ValueError("Missing required parameter 'object' in payload")
-        
+
         table_name = payload["tableName"]
         obj = payload["object"]
-        
+
         if not table_name:
             raise ValueError("Parameter 'tableName' cannot be empty")
         if not obj:
             raise ValueError("Parameter 'object' cannot be empty")
+
+        row = self.read_hook(
+            tx,
+            table_name,
+            obj.get("sys_id"),
+            context,
+        )
         
-        sys_id = obj.get("sys_id")
-        
-        if not sys_id:
-            raise ValueError("Object must contain 'sys_id' field")
-        
-        if sys_id == "@new":
-            row = {}
-        else:
-            sys_id = int(sys_id)
-            row = tx.table(table_name).find(sys_id)
-            row = row.to_dict() if row else {}
-        
-        # Call hook for custom logic
-        self.read_hook(tx, table_name, sys_id, row, context)
-        
-        context.response().set_body({
-            "object": row,
-            "lastFetch": datetime.datetime.now(),
-        })
-        
+        context.response().set_body(
+            {
+                "object": row,
+                "lastFetch": datetime.datetime.now(),
+            }
+        )
         if row:
             context.response().load_object(row)
         else:
             message = f"Object {obj.get('sys_id')} was not found in the database. You may create it as a new object."
             context.response().toast(message, "warning")
-    
+
     def OnActionFindObject(self, tx, context):
-        """
-        Find a single object by query predicate.
-        
-        Payload:
-            tableName: str - Name of the database table
-            query: dict - Query containing 'where' clause
-        """
         payload = context.payload()
-        
+
         # Validate required parameters
         if "tableName" not in payload:
             raise ValueError("Missing required parameter 'tableName' in payload")
         if "query" not in payload:
             raise ValueError("Missing required parameter 'query' in payload")
-        
+
         table_name = payload["tableName"]
         query = payload["query"]
-        
+
         if not table_name:
             raise ValueError("Parameter 'tableName' cannot be empty")
         if not query or "where" not in query:
             raise ValueError("Parameter 'query' must contain 'where' clause")
-        
-        row = tx.table(table_name).find(query["where"])
-        
-        if row:
-            row = row.to_dict()
-            self.read_hook(tx, table_name, None, row, context)
-        else:
-            row = {}
-        
-        context.response().set_body({
-            "object": row,
-            "lastFetch": datetime.datetime.now(),
-        })
+
+        row = self.find_hook(
+            tx,
+            table_name,
+            query["where"],
+            context,
+        )
+        context.response().set_body(
+            {
+                "object": row,
+                "lastFetch": datetime.datetime.now(),
+            }
+        )
         context.response().load_object(row)
-    
+
     def OnActionWriteObject(self, tx, context):
-        """
-        Write (insert or update) an object.
-        
-        Payload:
-            tableName: str - Name of the database table
-            object: dict - Object data to write
-        """
         payload = context.payload()
-        
+
         # Validate required parameters
         if "tableName" not in payload:
             raise ValueError("Missing required parameter 'tableName' in payload")
         if "object" not in payload:
             raise ValueError("Missing required parameter 'object' in payload")
-        
+
         table_name = payload["tableName"]
         obj = payload["object"]
-        
+
         if not table_name:
             raise ValueError("Parameter 'tableName' cannot be empty")
         if not obj or not isinstance(obj, dict):
             raise ValueError("Parameter 'object' must be a non-empty dictionary")
-        
+
         # Ensure the object has at least some data
         incoming = obj.copy()
         if not any(value is not None for value in incoming.values()):
             raise ValueError("Parameter 'object' cannot contain only None values")
-        
-        sys_id = incoming.pop("sys_id", None)
-        
-        # Call hook before write
-        self.write_hook(tx, table_name, sys_id, incoming, context)
-        
+
+        print(
+            f"WRITE_LOG: Writing to table {table_name} with sys_id {incoming.get('sys_id')}"
+        )
+        print(f"WRITE_LOG: Object keys: {list(incoming.keys())}")
+
         try:
-            if sys_id == "@new":
-                row = tx.table(table_name).new()
-                row.update(incoming)
-            elif sys_id:
-                sys_id = int(sys_id)
-                row = tx.table(table_name).get(sys_id)
-                row.update(incoming)
-            else:
-                raise ValueError("Object sys_id was not supplied on write operation")
-            
-            row_dict = row.to_dict()
-            
-            context.response().set_body({
-                "object": row_dict,
-                "lastFetch": datetime.datetime.now(),
-            })
-            context.response().load_object(row_dict)
-            
+            row = self.write_hook(
+                tx,
+                table_name,
+                incoming.get("sys_id"),
+                incoming,
+                context,
+            )
+
+            if not row:
+                print(f"WARNING: self.write_hook returned empty row for table {table_name}")
+                row = {}
+
+            context.response().set_body(
+                {
+                    "object": row,
+                    "lastFetch": datetime.datetime.now(),
+                }
+            )
+            print(f"WRITE_LOG: Successfully wrote to {table_name}")
+
         except Exception as e:
-            raise Exception(f"Failed to write object to {table_name}: {str(e)}")
-    
+            print(f"ERROR in OnActionWriteObject: {e}")
+            print(f"table_name={table_name}, incoming_keys={list(incoming.keys())}")
+            raise
+        context.response().load_object(row)
+
+    # Query a table for rows. If the requested result format is excel, then return the
+    # data as a downloadedable excel file. If the requested result format is raw,
+    # then return the data as rows for the application front end to handle as it wishes.
+    # Otherwise, return the data as a dataset to be populated into a datatable,
+    # and load the data into 'store.repo' as such.
+    # @param self
+    # @param tx
+    # @param args
+    # @param postdata
+    # @param response
+    #
+    # Payload parameters
+
     def OnActionQuery(self, tx, context):
-        """
-        Query table for multiple rows.
-        
-        Payload:
-            obj: str - Table name to query
-            params: dict - Query parameters (where, orderby, limit, offset)
-            result_format: str - 'excel', 'raw', or 'datatable' (default)
-            datatable: str - Name for datatable in response (defaults to obj)
-            count: bool - Include total count in response
-            headers: bool - Include column headers in response
-        """
         payload = context.payload()
-        
+
         # Validate required parameters
         if "obj" not in payload:
             raise ValueError("Missing required parameter 'obj' in payload")
-        
+
         table = payload["obj"]
         if not table:
             raise ValueError("Parameter 'obj' cannot be empty")
-        
-        params = payload.get("params", {})
-        result = tx.table(table).select(**params)
-        
+
+        data = self.query_hook(tx, table, payload, context)
         if payload.get("result_format") == "excel":
-            headers = payload.get(
-                "headers", [x.replace("_", " ").title() for x in result.headers]
-            )
-            rows = result.as_list().all()
-            
             filebuffer = BytesIO()
-            export.create_spreadsheet(headers, rows, filebuffer)
-            context.response().file_download({
-                "filename": payload.get("filename", "temp_file.xls"),
-                "data": base64.b64encode(filebuffer.getvalue()).decode(),
-            })
-            return
-        
-        data = {
-            "rows": result.all(),
-            "config": {
-                "lastFetch": datetime.datetime.now(),
-                "query": result.sql,
-                "format": payload.get("result_format"),
-            },
-        }
-        
-        if payload.get("count"):
-            data["count"] = tx.table(table).count(where=params.get("where", None))
-        
-        if payload.get("headers"):
-            data["columns"] = [
+            export.create_spreadsheet(data["headers"], data["rows"], filebuffer)
+            context.response().file_download(
                 {
-                    "field": x["name"],
-                    "headerName": x["name"].replace("_", " ").title(),
-                    "type": self._get_field_type(x),
+                    "filename": payload.get("filename", "temp_file.xls"),
+                    "data": base64.b64encode(filebuffer.getvalue()).decode(),
                 }
-                for x in result.columns.values()
-            ]
-        
-        # Call hook after query
-        self.query_hook(tx, table, params, data, context)
-        
+            )
+            return
         if payload.get("result_format") == "raw":
             context.response().set_body(data)
         else:
-            context.response().set_table({
-                payload.get("datatable", payload.get("obj")): data
-            })
-    
+            context.response().set_table(
+                {payload.get("datatable", payload.get("obj")): data}
+            )
+
     def OnActionDeleteObject(self, tx, context):
-        """
-        Delete one or more objects.
-        
-        Payload:
-            tableName: str - Name of the database table
-            deleteList: list - List of sys_id values to delete (optional)
-            object: dict - Single object with sys_id to delete (optional)
-        """
         payload = context.payload()
-        
+
         # Validate required parameters
         if "tableName" not in payload:
             raise ValueError("Missing required parameter 'tableName' in payload")
-        
+
         table_name = payload["tableName"]
         if not table_name:
             raise ValueError("Parameter 'tableName' cannot be empty")
-        
+
         table = tx.table(table_name)
         deleteList = []
-        
         if "deleteList" in payload:
             deleteList.extend(payload.get("deleteList"))
-        
         if "object" in payload:
             obj = payload["object"]
             if obj and obj.get("sys_id"):
                 deleteList.append(obj.get("sys_id"))
         
         for sys_id in deleteList:
-            # Call hook before delete
             self.delete_hook(tx, table_name, sys_id, context)
             
-            obj = table.find(int(sys_id))
-            if obj:
-                obj.clear()
-                context.response().toast(f"Object {sys_id} deleted", "success")
-            else:
-                context.response().toast(f"Object {sys_id} not found", "warning")
-        
-        if not deleteList:
-            context.response().toast("No items were selected.", "warning")
+        if not (deleteList):
+            context.response().toast(f"No items were selected.", "warning")
     
     def OnActionGetTables(self, tx, context):
         """Get list of all tables in the database."""
@@ -534,20 +537,63 @@ class RWXHookSystem:
     """
     RWX (Read/Write/eXecute) hook system for table-specific business logic.
     
-    This class provides a way to dynamically load and execute table-specific
-    hooks (before_read, after_write, etc.) from an rwx package.
-    
-    Usage:
-        from velocity.aws.handlers.mixins import RWXHookSystem
+    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'  # Your rwx package
+            hook_module_name = 'rwx'  # Name of your rwx package
         
+        @engine.transaction
         class HttpEventHandler(DataServiceMixin, LambdaHandler):
-            def read_hook(self, tx, table_name, sys_id, row, context):
-                MyRWXSystem.call_hooks(
-                    'read', tx, table_name, sys_id, row, context
-                )
+            def __init__(self, aws_event, aws_context):
+                super().__init__(aws_event, aws_context)
     """
     
     hook_module_name = None  # Override in subclass (e.g., 'rwx')
@@ -569,29 +615,6 @@ class RWXHookSystem:
         if module and hasattr(module, hook_name):
             return getattr(module, hook_name)(*args, **kwargs)
         return None
-    
-    @classmethod
-    def call_hooks(cls, operation, tx, table_name, *args, context=None):
-        """
-        Call before/after hooks for an operation.
-        
-        Args:
-            operation: 'read', 'write', 'delete', 'query'
-            tx: Database transaction
-            table_name: Name of the table
-            *args: Operation-specific arguments
-            context: Request context (keyword only)
-        """
-        # Call before hook
-        cls._call_hook(f'before_{operation}', table_name, tx, table_name, *args, context)
-        
-        # Note: after hooks should be called by the application after the operation
-        # This method is just for the before hook pattern
-    
-    @classmethod
-    def call_after_hook(cls, operation, tx, table_name, *args, context=None):
-        """Call after hook for an operation"""
-        cls._call_hook(f'after_{operation}', table_name, tx, table_name, *args, context)
 
 
 def apply_sys_modified_by(incoming, context):