velocity-python 0.0.139__tar.gz → 0.0.141__tar.gz

{velocity_python-0.0.139 → velocity_python-0.0.141}/PKG-INFO

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

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

{velocity_python-0.0.139 → velocity_python-0.0.141}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.0.139"
+__version__ = version = "0.0.141"
 
 from . import aws
 from . import db

{velocity_python-0.0.139 → velocity_python-0.0.141}/src/velocity/aws/handlers/mixins/activity_tracker.py

@@ -9,33 +9,34 @@ import copy
 import json
 import os
 import time
-from abc import ABC, abstractmethod
-from typing import Dict, Any, Optional
+from abc import ABC
+from datetime import date, datetime
+from typing import Dict, Any
 
 
 class ActivityTracker(ABC):
     """
     Mixin class providing standardized activity tracking for Lambda handlers.
-    
+
     Tracks API calls to the aws_api_activity table with consistent data structure
     and automatic duration calculation.
     """
-    
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.activity_log_key = None
         self.start_time = None
         self.end_time = None
         self.activity_data = {}
-    
+
     def track_activity_start(self, tx, context):
         """Start tracking activity for the current request"""
         self.start_time = time.time()
-        
+
         # Gather common activity data
         postdata = context.postdata()
         payload = context.payload()
-        
+
         self.activity_data = {
             "action": context.action(),
             "args": json.dumps(context.args()),
@@ -45,21 +46,34 @@ class ActivityTracker(ABC):
             "user_branch": os.environ.get("USER_BRANCH", "Unknown"),
             "start_timestamp": self.start_time,
         }
-        
+
         # Add user information if available
         user_info = self._extract_user_info(payload)
         if user_info:
             self.activity_data.update(user_info)
-            
+
         # Add session information
         session_data = context.session()
         if session_data:
-            self.activity_data.update({k: v for k, v in session_data.items() 
-                                     if k not in ['cognito_user']})
-        
+            self.activity_data.update(self._sanitize_session_data(session_data))
+
+        # Ensure all values are serializable before persisting
+        self.activity_data = {
+            key: self._normalize_activity_value(value)
+            for key, value in self.activity_data.items()
+            if value is not None
+        }
+
         # Create the activity record
-        self.activity_log_key = tx.table("aws_api_activity").new(self.activity_data).pk
-        
+        try:
+            self.activity_log_key = tx.table("aws_api_activity").new(self.activity_data).pk
+        except Exception as exc:
+            context.log(
+                f"ActivityTracker.track_activity_start failed: {exc}; keys={list(self.activity_data.keys())}",
+                "ActivityTracker.track_activity_start",
+            )
+            raise
+
         return self.activity_log_key
     
     def track_activity_success(self, tx, context):
@@ -140,3 +154,28 @@ class ActivityTracker(ABC):
                 pass
                 
         return user_info
+
+    def _sanitize_session_data(self, session: Dict[str, Any]) -> Dict[str, Any]:
+        """Remove sensitive session keys and normalize value types"""
+        sanitized = {}
+
+        for key, value in session.items():
+            if key == "cognito_user":
+                continue
+
+            sanitized[key] = self._normalize_activity_value(value)
+
+        return sanitized
+
+    def _normalize_activity_value(self, value: Any) -> Any:
+        """Convert activity data values into types acceptable by psycopg2"""
+        if isinstance(value, (dict, list, tuple, set)):
+            try:
+                return json.dumps(value)
+            except (TypeError, ValueError):
+                return str(value)
+        if isinstance(value, (datetime, date)):
+            return value.isoformat()
+        if isinstance(value, (bytes, bytearray)):
+            return value.decode("utf-8", errors="ignore")
+        return value

{velocity_python-0.0.139 → velocity_python-0.0.141}/src/velocity/db/core/table.py

@@ -163,6 +163,28 @@ class Table:
             return self.name in [f"{x[0]}.{x[1]}" for x in result.as_tuple()]
         return self.name in [x[1] for x in result.as_tuple()]
 
+    def ensure_sys_modified_count(self, **kwds):
+        """
+        Ensure the sys_modified_count column and trigger exist for this table.
+
+        Returns early when the column is already present unless `force=True` is provided.
+        """
+        force = kwds.get("force", False)
+
+        try:
+            columns = [col.lower() for col in self.sys_columns()]
+        except Exception:
+            columns = []
+
+        has_column = "sys_modified_count" in columns
+        if has_column and not force:
+            return
+
+        sql, vals = self.sql.ensure_sys_modified_count(self.name, has_column=has_column)
+        if kwds.get("sql_only", False):
+            return sql, vals
+        self.tx.execute(sql, vals, cursor=self.cursor())
+
     def column(self, name):
         """
         Returns a Column object for the given column name.

{velocity_python-0.0.139 → velocity_python-0.0.141}/src/velocity/db/servers/mysql/sql.py

@@ -18,6 +18,18 @@ TableHelper.reserved = reserved_words
 TableHelper.operators = OPERATORS
 
 
+system_fields = [
+    "sys_id",
+    "sys_created",
+    "sys_modified",
+    "sys_modified_by",
+    "sys_dirty",
+    "sys_table",
+    "sys_modified_count",
+    "description",
+]
+
+
 def quote(data):
     """Quote MySQL identifiers."""
     if isinstance(data, list):
@@ -361,12 +373,127 @@ class SQL(BaseSQLDialect):
 
     @classmethod
     def create_table(cls, name, columns=None, drop=False):
+        if not name or not isinstance(name, str):
+            raise ValueError("Table name must be a non-empty string")
+
+        columns = columns or {}
+        table_identifier = quote(name)
+        base_name = name.split(".")[-1].replace("`", "")
+        base_name_sql = base_name.replace("'", "''")
+        trigger_prefix = re.sub(r"[^0-9A-Za-z_]+", "_", f"cc_sysmod_{base_name}")
+
+        statements = []
         if drop:
-            drop_sql = f"DROP TABLE IF EXISTS {quote(name)}"
-            return drop_sql
-        
-        # Basic CREATE TABLE - would need more implementation
-        return f"CREATE TABLE {quote(name)} (id INT PRIMARY KEY AUTO_INCREMENT)"
+            statements.append(f"DROP TABLE IF EXISTS {table_identifier};")
+
+        statements.append(
+            f"""
+CREATE TABLE {table_identifier} (
+  `sys_id` BIGINT NOT NULL AUTO_INCREMENT,
+  `sys_table` TEXT,
+  `sys_created` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  `sys_modified` DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  `sys_modified_by` TEXT,
+  `sys_modified_count` INT NOT NULL DEFAULT 0,
+  `sys_dirty` TINYINT(1) NOT NULL DEFAULT 0,
+  `description` TEXT,
+  PRIMARY KEY (`sys_id`)
+) ENGINE=InnoDB;
+""".strip()
+        )
+
+        for key, val in columns.items():
+            clean_key = re.sub("<>!=%", "", key)
+            if clean_key in system_fields:
+                continue
+            col_type = TYPES.get_type(val)
+            statements.append(
+                f"ALTER TABLE {table_identifier} ADD COLUMN {quote(clean_key)} {col_type};"
+            )
+
+        statements.extend(
+            [
+                f"DROP TRIGGER IF EXISTS {trigger_prefix}_bi;",
+                f"DROP TRIGGER IF EXISTS {trigger_prefix}_bu;",
+                f"""
+CREATE TRIGGER {trigger_prefix}_bi
+BEFORE INSERT ON {table_identifier}
+FOR EACH ROW
+BEGIN
+    SET NEW.sys_created = COALESCE(NEW.sys_created, NOW());
+    SET NEW.sys_modified = NOW();
+    SET NEW.sys_modified_count = 0;
+    SET NEW.sys_dirty = IFNULL(NEW.sys_dirty, 0);
+    SET NEW.sys_table = '{base_name_sql}';
+END;
+""".strip(),
+                f"""
+CREATE TRIGGER {trigger_prefix}_bu
+BEFORE UPDATE ON {table_identifier}
+FOR EACH ROW
+BEGIN
+    IF OLD.sys_dirty = TRUE AND NEW.sys_dirty = FALSE THEN
+        SET NEW.sys_dirty = 0;
+        SET NEW.sys_modified_count = IFNULL(OLD.sys_modified_count, 0);
+    ELSE
+        SET NEW.sys_dirty = 1;
+        SET NEW.sys_modified_count = IFNULL(OLD.sys_modified_count, 0) + 1;
+    END IF;
+    SET NEW.sys_created = OLD.sys_created;
+    SET NEW.sys_modified = NOW();
+    SET NEW.sys_table = '{base_name_sql}';
+END;
+""".strip(),
+            ]
+        )
+
+        return "\n".join(statements), tuple()
+
+    @classmethod
+    def ensure_sys_modified_count(cls, name):
+        """Ensure sys_modified_count column and associated triggers exist for the table."""
+        table_identifier = quote(name)
+        base_name = name.split(".")[-1].replace("`", "")
+        base_name_sql = base_name.replace("'", "''")
+        trigger_prefix = re.sub(r"[^0-9A-Za-z_]+", "_", f"cc_sysmod_{base_name}")
+
+        statements = [
+            f"ALTER TABLE {table_identifier} ADD COLUMN IF NOT EXISTS `sys_modified_count` INT NOT NULL DEFAULT 0;",
+            f"UPDATE {table_identifier} SET `sys_modified_count` = 0 WHERE `sys_modified_count` IS NULL;",
+            f"DROP TRIGGER IF EXISTS {trigger_prefix}_bi;",
+            f"DROP TRIGGER IF EXISTS {trigger_prefix}_bu;",
+            f"""
+CREATE TRIGGER {trigger_prefix}_bi
+BEFORE INSERT ON {table_identifier}
+FOR EACH ROW
+BEGIN
+    SET NEW.sys_created = COALESCE(NEW.sys_created, NOW());
+    SET NEW.sys_modified = NOW();
+    SET NEW.sys_modified_count = 0;
+    SET NEW.sys_dirty = IFNULL(NEW.sys_dirty, 0);
+    SET NEW.sys_table = '{base_name_sql}';
+END;
+""".strip(),
+            f"""
+CREATE TRIGGER {trigger_prefix}_bu
+BEFORE UPDATE ON {table_identifier}
+FOR EACH ROW
+BEGIN
+    IF OLD.sys_dirty = TRUE AND NEW.sys_dirty = FALSE THEN
+        SET NEW.sys_dirty = 0;
+        SET NEW.sys_modified_count = IFNULL(OLD.sys_modified_count, 0);
+    ELSE
+        SET NEW.sys_dirty = 1;
+        SET NEW.sys_modified_count = IFNULL(OLD.sys_modified_count, 0) + 1;
+    END IF;
+    SET NEW.sys_created = OLD.sys_created;
+    SET NEW.sys_modified = NOW();
+    SET NEW.sys_table = '{base_name_sql}';
+END;
+""".strip(),
+        ]
+
+        return "\n".join(statements), tuple()
 
     @classmethod
     def drop_table(cls, name):

{velocity_python-0.0.139 → velocity_python-0.0.141}/src/velocity/db/servers/postgres/sql.py

@@ -734,11 +734,12 @@ class SQL(BaseSQLDialect):
             f"""
             CREATE TABLE {fqtn} (
               sys_id BIGSERIAL PRIMARY KEY,
-              sys_modified TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
               sys_created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-              sys_modified_by TEXT,
+              sys_modified TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+              sys_modified_by TEXT NOT NULL DEFAULT 'SYSTEM',
+              sys_modified_count INTEGER NOT NULL DEFAULT 0,
               sys_dirty BOOLEAN NOT NULL DEFAULT FALSE,
-              sys_table TEXT,
+              sys_table TEXT NOT NULL,
               description TEXT
             );
 
@@ -747,19 +748,29 @@ class SQL(BaseSQLDialect):
             CREATE OR REPLACE FUNCTION {schema}.on_sys_modified()
               RETURNS TRIGGER AS
             $BODY$
-                        BEGIN
-                        -- update sys_modified on each insert/update.
-                        NEW.sys_modified := now();
-                        if (TG_OP = 'INSERT') THEN
-                            NEW.sys_created :=now();
-                        ELSEIF (TG_OP = 'UDPATE') THEN
-                         -- Do not allow sys_created to be modified.
-                            NEW.sys_created := OLD.sys_created;
+                BEGIN
+                IF (TG_OP = 'INSERT') THEN
+                    NEW.sys_table := TG_TABLE_NAME;
+                    NEW.sys_created := clock_timestamp();
+                    NEW.sys_modified := clock_timestamp();
+                    NEW.sys_modified_count := 0;
+                ELSIF (TG_OP = 'UPDATE') THEN
+                    NEW.sys_table := TG_TABLE_NAME;
+                    NEW.sys_created := OLD.sys_created;
+                    NEW.sys_modified_count := COALESCE(OLD.sys_modified_count, 0);
+                    IF ROW(NEW.*) IS DISTINCT FROM ROW(OLD.*) THEN
+                        IF OLD.sys_dirty IS TRUE AND NEW.sys_dirty IS FALSE THEN
+                            NEW.sys_dirty := FALSE;
+                        ELSE
+                            NEW.sys_dirty := TRUE;
                         END IF;
-                        -- Insert table name to row
-                        NEW.sys_table := TG_TABLE_NAME;
-                        RETURN NEW;
-                        END;
+                        NEW.sys_modified := clock_timestamp();
+                        NEW.sys_modified_count := COALESCE(OLD.sys_modified_count, 0) + 1;
+                    END IF;
+                END IF;
+                
+                RETURN NEW;
+                END;
             $BODY$
               LANGUAGE plpgsql VOLATILE
               COST 100;
@@ -782,6 +793,61 @@ class SQL(BaseSQLDialect):
         sql = sqlparse.format(" ".join(sql), reindent=True, keyword_case="upper")
         return sql, tuple()
 
+    @classmethod
+    def ensure_sys_modified_count(cls, name):
+        """Return SQL to backfill sys_modified_count and refresh the on_sys_modified trigger."""
+        if "." in name:
+            fqtn = TableHelper.quote(name)
+        else:
+            fqtn = f"public.{TableHelper.quote(name)}"
+        schema, _ = fqtn.split(".")
+        trigger_name = f"on_update_row_{fqtn.replace('.', '_')}"
+        column_name = TableHelper.quote("sys_modified_count")
+        
+        sql = [
+            f"ALTER TABLE {fqtn} ADD COLUMN {column_name} INTEGER NOT NULL DEFAULT 0;",
+            f"UPDATE {fqtn} SET {column_name} = 0 WHERE {column_name} IS NULL;",
+            f"""
+            CREATE OR REPLACE FUNCTION {schema}.on_sys_modified()
+              RETURNS TRIGGER AS
+            $BODY$
+            BEGIN
+                IF (TG_OP = 'INSERT') THEN
+                    NEW.sys_table := TG_TABLE_NAME;
+                    NEW.sys_created := clock_timestamp();
+                    NEW.sys_modified := clock_timestamp();
+                    NEW.sys_modified_count := 0;
+                ELSIF (TG_OP = 'UPDATE') THEN
+                    NEW.sys_table := TG_TABLE_NAME;
+                    NEW.sys_created := OLD.sys_created;
+                    NEW.sys_modified_count := COALESCE(OLD.sys_modified_count, 0);
+                    IF ROW(NEW.*) IS DISTINCT FROM ROW(OLD.*) THEN
+                        IF OLD.sys_dirty IS TRUE AND NEW.sys_dirty IS FALSE THEN
+                            NEW.sys_dirty := FALSE;
+                        ELSE
+                            NEW.sys_dirty := TRUE;
+                        END IF;
+                        NEW.sys_modified := clock_timestamp();
+                        NEW.sys_modified_count := COALESCE(OLD.sys_modified_count, 0) + 1;
+                    END IF;
+                END IF;
+                RETURN NEW;
+            END;
+            $BODY$
+              LANGUAGE plpgsql VOLATILE
+              COST 100;
+        """,
+            f"DROP TRIGGER IF EXISTS {trigger_name} ON {fqtn};",
+            f"""
+            CREATE TRIGGER {trigger_name}
+            BEFORE INSERT OR UPDATE ON {fqtn}
+            FOR EACH ROW EXECUTE PROCEDURE {schema}.on_sys_modified();
+        """,
+            ]
+
+        sql = sqlparse.format(" ".join(sql), reindent=True, keyword_case="upper")
+        return sql, tuple()
+
     @classmethod
     def drop_table(cls, name):
         return f"drop table if exists {TableHelper.quote(name)} cascade;", tuple()

{velocity_python-0.0.139 → velocity_python-0.0.141}/src/velocity/db/servers/sqlite/sql.py

@@ -18,6 +18,18 @@ TableHelper.reserved = reserved_words
 TableHelper.operators = OPERATORS
 
 
+system_fields = [
+    "sys_id",
+    "sys_created",
+    "sys_modified",
+    "sys_modified_by",
+    "sys_dirty",
+    "sys_table",
+    "sys_modified_count",
+    "description",
+]
+
+
 def quote(data):
     """Quote SQLite identifiers."""
     if isinstance(data, list):
@@ -344,11 +356,122 @@ class SQL(BaseSQLDialect):
 
     @classmethod
     def create_table(cls, name, columns=None, drop=False):
+        if not name or not isinstance(name, str):
+            raise ValueError("Table name must be a non-empty string")
+
+        columns = columns or {}
+        table_identifier = quote(name)
+        base_name = name.split(".")[-1].replace('"', "")
+        base_name_sql = base_name.replace("'", "''")
+        trigger_prefix = re.sub(r"[^0-9A-Za-z_]+", "_", f"cc_sysmod_{base_name}")
+
+        statements = []
         if drop:
-            return f"DROP TABLE IF EXISTS {quote(name)}"
-        
-        # Basic CREATE TABLE
-        return f"CREATE TABLE {quote(name)} (id INTEGER PRIMARY KEY AUTOINCREMENT)"
+            statements.append(f"DROP TABLE IF EXISTS {table_identifier};")
+
+        statements.append(
+            f"""
+CREATE TABLE {table_identifier} (
+  "sys_id" INTEGER PRIMARY KEY AUTOINCREMENT,
+  "sys_table" TEXT,
+  "sys_created" TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "sys_modified" TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "sys_modified_by" TEXT,
+  "sys_modified_count" INTEGER NOT NULL DEFAULT 0,
+  "sys_dirty" INTEGER NOT NULL DEFAULT 0,
+  "description" TEXT
+);
+""".strip()
+        )
+
+        for key, val in columns.items():
+            clean_key = re.sub("<>!=%", "", key)
+            if clean_key in system_fields:
+                continue
+            col_type = TYPES.get_type(val)
+            statements.append(
+                f"ALTER TABLE {table_identifier} ADD COLUMN {quote(clean_key)} {col_type};"
+            )
+
+        statements.extend(
+            [
+                f"DROP TRIGGER IF EXISTS {trigger_prefix}_ai;",
+                f"DROP TRIGGER IF EXISTS {trigger_prefix}_au;",
+                f"""
+CREATE TRIGGER {trigger_prefix}_ai
+AFTER INSERT ON {table_identifier}
+FOR EACH ROW
+BEGIN
+    UPDATE {table_identifier}
+    SET sys_created = COALESCE(NEW.sys_created, CURRENT_TIMESTAMP),
+        sys_modified = CURRENT_TIMESTAMP,
+        sys_modified_count = 0,
+        sys_dirty = COALESCE(NEW.sys_dirty, 0),
+        sys_table = '{base_name_sql}'
+    WHERE rowid = NEW.rowid;
+END;
+""".strip(),
+                f"""
+CREATE TRIGGER {trigger_prefix}_au
+AFTER UPDATE ON {table_identifier}
+FOR EACH ROW
+BEGIN
+    UPDATE {table_identifier}
+    SET sys_created = OLD.sys_created,
+        sys_modified = CURRENT_TIMESTAMP,
+        sys_table = '{base_name_sql}',
+        sys_dirty = CASE WHEN OLD.sys_dirty = 1 AND NEW.sys_dirty = 0 THEN 0 ELSE 1 END,
+        sys_modified_count = CASE WHEN OLD.sys_dirty = 1 AND NEW.sys_dirty = 0 THEN COALESCE(OLD.sys_modified_count, 0) ELSE COALESCE(OLD.sys_modified_count, 0) + 1 END
+    WHERE rowid = NEW.rowid;
+END;
+""".strip(),
+            ]
+        )
+
+        return "\n".join(statements), tuple()
+
+    @classmethod
+    def ensure_sys_modified_count(cls, name):
+        """Ensure sys_modified_count exists for SQLite tables."""
+        table_identifier = quote(name)
+        base_name = name.split(".")[-1].replace('"', "")
+        base_name_sql = base_name.replace("'", "''")
+        trigger_prefix = re.sub(r"[^0-9A-Za-z_]+", "_", f"cc_sysmod_{base_name}")
+        statements = [
+            f"ALTER TABLE {table_identifier} ADD COLUMN sys_modified_count INTEGER NOT NULL DEFAULT 0;",
+            f"UPDATE {table_identifier} SET sys_modified_count = 0 WHERE sys_modified_count IS NULL;",
+            f"DROP TRIGGER IF EXISTS {trigger_prefix}_ai;",
+            f"DROP TRIGGER IF EXISTS {trigger_prefix}_au;",
+            f"""
+CREATE TRIGGER {trigger_prefix}_ai
+AFTER INSERT ON {table_identifier}
+FOR EACH ROW
+BEGIN
+    UPDATE {table_identifier}
+    SET sys_created = COALESCE(NEW.sys_created, CURRENT_TIMESTAMP),
+        sys_modified = CURRENT_TIMESTAMP,
+        sys_modified_count = 0,
+        sys_dirty = COALESCE(NEW.sys_dirty, 0),
+        sys_table = '{base_name_sql}'
+    WHERE rowid = NEW.rowid;
+END;
+""".strip(),
+            f"""
+CREATE TRIGGER {trigger_prefix}_au
+AFTER UPDATE ON {table_identifier}
+FOR EACH ROW
+BEGIN
+    UPDATE {table_identifier}
+    SET sys_created = OLD.sys_created,
+        sys_modified = CURRENT_TIMESTAMP,
+        sys_table = '{base_name_sql}',
+        sys_dirty = CASE WHEN OLD.sys_dirty = 1 AND NEW.sys_dirty = 0 THEN 0 ELSE 1 END,
+        sys_modified_count = CASE WHEN OLD.sys_dirty = 1 AND NEW.sys_dirty = 0 THEN COALESCE(OLD.sys_modified_count, 0) ELSE COALESCE(OLD.sys_modified_count, 0) + 1 END
+    WHERE rowid = NEW.rowid;
+END;
+""".strip(),
+        ]
+        return "\n".join(statements), tuple()
 
     @classmethod
     def drop_table(cls, name):