fastapi-rtk 0.2.27__py3-none-any.whl → 1.0.13__py3-none-any.whl

fastapi_rtk/backends/sqla/extensions/audit/audit.py

@@ -6,25 +6,28 @@ import pydantic
 import sqlalchemy.dialects.postgresql
 import sqlalchemy.event
 import sqlalchemy.orm
-from sqlalchemy import MetaData, Sequence
 
 from .....const import logger
 from .....db import db
+from .....exceptions import raise_exception
 from .....globals import g
 from .....security.sqla.models import User
 from .....utils import (
+    AsyncTaskRunner,
     class_factory_from_dict,
+    get_pydantic_model_field,
     lazy,
     prettify_dict,
     run_coroutine_in_threadpool,
     safe_call_sync,
     smart_run,
     smartdefaultdict,
+    use_default_when_none,
 )
 from ...column import mapped_column
 from ...interface import SQLAInterface
 from ...model import Model
-from ...session import SQLAConnection, SQLASession
+from ...session import SQLASession
 from .types import AuditEntry, AuditOperation, SQLAModel
 
 __all__ = ["audit_model_factory", "Audit"]
@@ -57,14 +60,16 @@ def audit_model_factory(
     attrs = {
         "__tablename__": BASE_AUDIT_TABLE_NAME,
         "id": mapped_column(
-            sqlalchemy.Integer, Sequence(BASE_AUDIT_SEQUENCE), primary_key=True
+            sqlalchemy.Integer,
+            sqlalchemy.Sequence(BASE_AUDIT_SEQUENCE),
+            primary_key=True,
         ),
         "created": mapped_column(
             sqlalchemy.DateTime(timezone=True),
             nullable=False,
             default=lambda: datetime.datetime.now(datetime.timezone.utc),
         ),
-        "table": mapped_column(sqlalchemy.String(256), nullable=False),
+        "table_name": mapped_column(sqlalchemy.String(256), nullable=False),
         "table_id": mapped_column(sqlalchemy.String(1024), nullable=False),
         "operation": mapped_column(sqlalchemy.String(256), nullable=False),
         "data": mapped_column(
@@ -84,13 +89,15 @@ def audit_model_factory(
         ),
         "created_by": sqlalchemy.orm.relationship(User),
         "__table_args__": (
-            sqlalchemy.Index("ix_audit_table_id", "table", "table_id", unique=False),
+            sqlalchemy.Index(
+                "ix_audit_table_id", "table_name", "table_id", unique=False
+            ),
         ),
         "__repr__": lambda self: prettify_dict(
             {
                 "id": self.id,
                 "created": self.created,
-                "table": self.table,
+                "table_name": self.table_name,
                 "table_id": self.table_id,
                 "operation": self.operation,
                 "data": self.data,
@@ -173,6 +180,16 @@ class Audit:
     """
     Dictionary mapping models to properties that should be excluded from auditing.
     """
+    mapping_insert_updates_when_no_changes = collections.defaultdict[
+        typing.Type[SQLAModel], bool | None
+    ](lambda: None)
+    """
+    Dictionary mapping models to a flag indicating whether to insert audit entries for updates even when there are no changes if the model is dirty.
+    """
+    mapping_insert_updates_when_no_changes_default = False
+    """
+    Default value for `mapping_insert_updates_when_no_changes` if not set for a specific model.
+    """
     callbacks = list[
         typing.Callable[
             [AuditEntry], None | typing.Coroutine[typing.Any, typing.Any, None]
@@ -181,6 +198,14 @@ class Audit:
     """
     List of callbacks to be called after adding the audit to the database.
     """
+    scheduler = lazy(
+        lambda cls: raise_exception(
+            f"{cls.__name__}.scheduler is not configured. Please call `{cls.__name__}.run_in_background()` to configure it."
+        )
+    )
+    """
+    The scheduler for running audit inserts and callbacks in the background.
+    """
 
     _session_callbacks_after_flush_postexec = collections.defaultdict[
         sqlalchemy.orm.Session,
@@ -200,6 +225,14 @@ class Audit:
     """
     Dictionary mapping SQLAlchemy sessions to their commit callbacks.
     """
+    _session_is_commited = collections.defaultdict[SQLASession, bool](bool)
+    """
+    Dictionary mapping SQLAlchemy sessions to a flag indicating if they have been committed.
+    """
+    _run_in_background = False
+    """
+    Whether to insert audit entries and run callbacks in the background.
+    """
     _configured = False
     """
     Flag to indicate if the audit class has been configured.
@@ -237,6 +270,7 @@ class Audit:
         *,
         include: list[str] | str | None = None,
         exclude: list[str] | str | None = None,
+        insert_updates_when_no_changes: bool | None = None,
     ):
         """
         Decorator to register a model and its subclasses for auditing.
@@ -245,6 +279,7 @@ class Audit:
             model_cls (typing.Type[SQLAModel]): The SQLAlchemy model class to audit.
             include (list[str] | str | None, optional): List of property names to include in the audit. Defaults to None.
             exclude (list[str] | str | None, optional): List of property names to exclude from the audit. Defaults to None.
+            insert_updates_when_no_changes (bool | None, optional): Whether to insert audit entries for updates even when there are no changes if the model is dirty. Defaults to None.
 
         Returns:
             typing.Type[SQLAModel]: The audited model class.
@@ -266,20 +301,25 @@ class Audit:
                 updated = mapped_column(sqlalchemy.DateTime, default=sqlalchemy.func.now(), onupdate=sqlalchemy.func.now())
             ```
         """
-        if include or exclude:
+        if include or exclude or insert_updates_when_no_changes is not None:
 
             def decorator(model_cls: typing.Type[SQLAModel]) -> typing.Type[SQLAModel]:
                 model_cls = cls.audit_model(model_cls)
                 params = [
-                    (include, cls.include_properties),
-                    (exclude, cls.exclude_properties),
+                    (include, {}, cls.include_properties),
+                    (exclude, {}, cls.exclude_properties),
+                    (
+                        insert_updates_when_no_changes,
+                        {"decorator": True},
+                        cls.insert_updates_when_no_changes,
+                    ),
                 ]
-                for args, func in params:
-                    if not args:
+                for args, kwargs, func in params:
+                    if args is None:
                         continue
                     if not isinstance(args, tuple):
                         args = (args,)
-                    model_cls = func(*args)(model_cls)
+                    model_cls = func(*args, **kwargs)(model_cls)
                 return model_cls
 
             return decorator
@@ -386,6 +426,28 @@ class Audit:
 
         return decorator
 
+    @classmethod
+    def insert_updates_when_no_changes(cls, value=True, *, decorator=False):
+        """
+        Set whether to insert audit entries for updates even when there are no changes if the model is dirty.
+
+        Args:
+            value (bool, optional): Whether to insert audit entries for updates even when there are no changes if the model is dirty. Defaults to True.
+            decorator (bool, optional): Whether to use this method as a decorator. If True, the method returns a decorator function that can be applied to a model class. Defaults to False.
+        """
+        if decorator:
+
+            def decorator(model_cls: typing.Type[SQLAModel]):
+                cls.mapping_insert_updates_when_no_changes[model_cls] = value
+                logger.info(
+                    f"Set insert_updates_when_no_changes to {value} for model {model_cls.__name__}."
+                )
+                return model_cls
+
+            return decorator
+        cls.mapping_insert_updates_when_no_changes_default = value
+        logger.info(f"Set insert_updates_when_no_changes to {value}.")
+
     @classmethod
     def callback(
         cls,
@@ -406,6 +468,28 @@ class Audit:
         logger.info(f"Callback {func.__name__} registered.")
         return func
 
+    @classmethod
+    def run_in_background(cls, value: bool = True):
+        """
+        Set whether to insert audit entries and run callbacks in the background.
+
+        Args:
+            value (bool, optional): Whether to insert audit entries and run callbacks in the background. Defaults to True.
+        """
+        if value:
+            try:
+                import apscheduler.schedulers.asyncio
+
+                cls.scheduler = apscheduler.schedulers.asyncio.AsyncIOScheduler()
+                cls.scheduler.start()
+            except ImportError as e:
+                raise ImportError(
+                    "apscheduler is required to run audit in background. Please install it with `pip install apscheduler` or add it to your `requirements.txt`."
+                ) from e
+
+        cls._run_in_background = value
+        logger.info(f"Set run_in_background to {value}.")
+
     """
     --------------------------------------------------------------------------------------------------------
         MODEL METHODS - implemented
@@ -435,7 +519,7 @@ class Audit:
             AuditTable: An instance of the audit table model with the provided audit data.
         """
         return cls.model(
-            table=audit["model"].__tablename__,
+            table_name=audit["model"].__tablename__,
             table_id=str(audit["pk"]),
             operation=audit["operation"],
             data=audit.get("data"),
@@ -444,20 +528,11 @@ class Audit:
         )
 
     @classmethod
-    async def create_table(cls, conn: SQLAConnection = None):
+    async def create_table(cls):
         """
         Create the audit table in the database.
-
-        Args:
-            conn (SQLAConnection, optional): The database connection to use. Defaults to None.
         """
-        if not conn:
-            async with db.connect(cls.model.__bind_key__) as conn:
-                return await cls.create_table(conn)
-
-        audit_metadata = MetaData()
-        cls.model.__table__.to_metadata(audit_metadata)
-        return await db._create_all(conn, audit_metadata)
+        return await db.create_all(cls.model.__bind_key__, tables=[cls.model.__table__])
 
     @classmethod
     def create_table_sync(cls, *args, **kwargs):
@@ -476,7 +551,9 @@ class Audit:
     @classmethod
     async def insert_entries(
         cls,
-        entries: list[SQLAModel],
+        entries: list[AuditEntry],
+        model_entries: list[SQLAModel] | None = None,
+        *,
         session: SQLASession | None = None,
         commit=True,
         raise_exception=False,
@@ -485,7 +562,8 @@ class Audit:
         Insert multiple audit entries into the database.
 
         Args:
-            entries (list[SQLAModel]): The audit entries to insert.
+            entries (list[AuditEntry]): The audit entries to insert.
+            model_entries (list[SQLAModel] | None, optional): Pre-created audit model instances to insert. If not provided, will create from `entries`. Defaults to None.
             session (SQLASession | None, optional): The database session to use. Defaults to None.
             commit (bool, optional): Whether to commit the session after inserting. Defaults to True.
             raise_exception (bool, optional): Whether to raise an exception if the insert fails. Defaults to False.
@@ -494,35 +572,61 @@ class Audit:
             e: The exception raised during the insert.
         """
         try:
+            is_commited = cls._session_is_commited[session]
+            if is_commited:
+                logger.warning(
+                    "Session has already been committed, creating a new session to insert audit entries."
+                )
+                commit = is_commited
+                del cls._session_is_commited[session]
+                session = None
             if not session:
                 async with db.session(cls.model.__bind_key__) as session:
-                    await cls.insert_entries(entries, session, raise_exception)
-            session.add_all(entries)
-            for entry in entries:
-                logger.info(f"[{entry.operation}] {entry.table} {entry.table_id}")
-                logger.debug(f"Entry data: \n{prettify_dict(entry.data)}")
+                    await cls.insert_entries(
+                        entries,
+                        model_entries,
+                        session=session,
+                        commit=commit,
+                        raise_exception=raise_exception,
+                    )
+                    return
+            model_entries = model_entries or [
+                cls.create_entry(entry) for entry in entries
+            ]
+            session.add_all(model_entries)
+            for entry in model_entries:
+                operation = use_default_when_none(
+                    getattr(entry, "operation", None), "UNKNOWN OPERATION"
+                )
+                table_name = use_default_when_none(
+                    getattr(entry, "table_name", None), "UNKNOWN TABLE"
+                )
+                table_id = use_default_when_none(
+                    getattr(entry, "table_id", None), "UNKNOWN ID"
+                )
+                entry_data = use_default_when_none(
+                    getattr(entry, "data", None), {"detail": "No data"}
+                )
+                logger.info(f"[{operation}] {table_name} {table_id}")
+                logger.debug(f"Entry data: \n{prettify_dict(entry_data)}")
             if commit:
                 await smart_run(session.commit)
+                # Run callbacks immediately after commit if not part of a larger transaction
+                await cls._run_callbacks(entries)
+            else:
+
+                def callback_for_commit(entries=entries):
+                    return cls._run_async_function_or_delegate_to_runner(
+                        cls._run_callbacks, entries=entries
+                    )
+
+                cls._session_callbacks_after_commit[session].append(callback_for_commit)
         except Exception as e:
             logger.error(f"Error inserting audit entries: {e}")
             if not raise_exception:
                 return
             raise e
 
-    @classmethod
-    def insert_entries_sync(cls, *args, **kwargs):
-        """
-        Synchronous version of `insert_entries`.
-
-        Args:
-            *args: Positional arguments to pass to `insert_entries`.
-            **kwargs: Keyword arguments to pass to `insert_entries`.
-
-        Returns:
-            T: The result of the synchronous insert operation.
-        """
-        return run_coroutine_in_threadpool(cls.insert_entries(*args, **kwargs))
-
     """
     --------------------------------------------------------------------------------------------------------
         EVENT LISTENER METHODS - implemented
@@ -537,31 +641,48 @@ class Audit:
         Args:
             session (sqlalchemy.orm.Session): The SQLAlchemy session that was flushed.
         """
-        audit_entries = cls._get_audit_entries_sync(session)
+        audit_entries = cls._get_audit_entries(session)
         if not audit_entries:
             logger.debug("No models to be audited in `after_flush`.")
             return
 
-        audit_models = [cls.create_entry(entry) for entry in audit_entries]
-        existing_session = None
-        if any(
-            entry["model"].__bind_key__ == cls.model.__bind_key__
-            for entry in audit_entries
+        model_entries = [cls.create_entry(entry) for entry in audit_entries]
+        if cls._run_in_background:
+            cls._session_callbacks_after_commit[session].append(
+                lambda audit_entries=audit_entries,
+                model_entries=model_entries: cls.scheduler.add_job(
+                    cls.insert_entries,
+                    args=[audit_entries, model_entries],
+                    name=f"{cls.__name__}.insert_entries",
+                )
+            )
+            return
+
+        existing_session = (
+            session
+            if any(
+                entry["model"].__bind_key__ == cls.model.__bind_key__
+                for entry in audit_entries
+            )
+            else None
+        )
+
+        def callback_for_flush_postexec(
+            audit_entries=audit_entries,
+            model_entries=model_entries,
+            existing_session=existing_session,
         ):
-            existing_session = session
-        cls._session_callbacks_after_flush_postexec[session].append(
-            lambda audit_models=audit_models,
-            existing_session=existing_session: cls.insert_entries_sync(
-                audit_models, session=existing_session, commit=not existing_session
+            return cls._run_async_function_or_delegate_to_runner(
+                cls.insert_entries,
+                audit_entries,
+                model_entries,
+                session=existing_session,
+                commit=not existing_session,
             )
+
+        cls._session_callbacks_after_flush_postexec[session].append(
+            callback_for_flush_postexec
         )
-        for entry in audit_entries:
-            for callback in cls.callbacks:
-                cls._session_callbacks_after_commit[session].append(
-                    lambda entry=entry, callback=callback: safe_call_sync(
-                        callback(entry)
-                    )
-                )
 
     @classmethod
     def _after_flush_postexec(cls, session: sqlalchemy.orm.Session, *_):
@@ -586,6 +707,7 @@ class Audit:
         Args:
             session (sqlalchemy.orm.Session): The SQLAlchemy session that was committed.
         """
+        cls._session_is_commited[session] = True
         callbacks = cls._session_callbacks_after_commit.pop(session, [])
         if not callbacks:
             logger.debug("No callbacks to run in `after_commit`.")
@@ -612,20 +734,40 @@ class Audit:
     """
 
     @classmethod
-    async def _get_audit_entries(
+    def _get_audit_entries(cls, session: sqlalchemy.orm.Session):
+        """
+        Get audit entries from the given session.
+
+        Args:
+            session (sqlalchemy.orm.Session): The SQLAlchemy session to get audit entries from.
+
+        Returns:
+            list[AuditEntry]: A list of audit entries.
+        """
+        return cls._process_model_operations(cls._get_model_operations(session))
+
+    @classmethod
+    def _get_model_operations(
         cls,
         session: sqlalchemy.orm.Session,
     ):
         """
-        Get audit entries from the session.
+        Gets a deque of models and their corresponding audit operations from the given session.
 
         Args:
-            session (sqlalchemy.orm.Session): The SQLAlchemy session to get audit entries from.
+            session (sqlalchemy.orm.Session): The SQLAlchemy session to get models and operations from.
 
         Returns:
-            list[AuditEntry]: A list of audit entries.
+            collections.deque[tuple[SQLAModel, AuditOperation, list[str], dict[str, sqlalchemy.orm.attributes.History]]]: A deque of tuples containing the model, operation, properties to audit, and updated columns with their history.
         """
-        audit_entry_deque = collections.deque[tuple[SQLAInterface, AuditOperation]]()
+        model_operation_deque = collections.deque[
+            tuple[
+                SQLAModel,
+                AuditOperation,
+                list[str],
+                dict[str, sqlalchemy.orm.attributes.History],
+            ]
+        ]()
         for model in session.new:
             if not cls._should_audit(model):
                 logger.debug(
@@ -634,7 +776,9 @@ class Audit:
                 continue
             if not hasattr(model, "__tablename__"):
                 continue
-            audit_entry_deque.append((model, AuditOperation.INSERT))
+            model_operation_deque.append(
+                (model, AuditOperation.INSERT, cls._get_audit_properties(model), {})
+            )
         for model in session.dirty:
             if not cls._should_audit(model):
                 logger.debug(
@@ -645,7 +789,16 @@ class Audit:
                 continue
             if not session.is_modified(model):
                 continue
-            audit_entry_deque.append((model, AuditOperation.UPDATE))
+            state = sqlalchemy.inspect(model)
+            properties = cls._get_audit_properties(model)
+            updates = {
+                x.key: x.history
+                for x in state.attrs
+                if x.history.has_changes() and x.key in properties
+            }
+            model_operation_deque.append(
+                (model, AuditOperation.UPDATE, properties, updates)
+            )
         for model in session.deleted:
             if not cls._should_audit(model):
                 logger.debug(
@@ -654,153 +807,136 @@ class Audit:
                 continue
             if not hasattr(model, "__tablename__"):
                 continue
-            audit_entry_deque.append((model, AuditOperation.DELETE))
-        return await cls._process_audit_entries(audit_entry_deque)
-
-    @classmethod
-    def _get_audit_entries_sync(cls, *args, **kwargs):
-        """
-        Synchronous version of `_get_audit_entries`.
-
-        Args:
-            *args: Positional arguments to pass to `_get_audit_entries`.
-            **kwargs: Keyword arguments to pass to `_get_audit_entries`.
-
-        Returns:
-            list[AuditEntry]: A list of audit entries.
-        """
-        return run_coroutine_in_threadpool(cls._get_audit_entries(*args, **kwargs))
+            model_operation_deque.append((model, AuditOperation.DELETE, [], {}))
+        return model_operation_deque
 
     @classmethod
-    async def _process_audit_entries(
+    def _process_model_operations(
         cls,
-        audit_entry_deque: collections.deque[tuple[SQLAModel, AuditOperation]],
+        model_operation_deque: collections.deque[
+            tuple[
+                SQLAModel,
+                AuditOperation,
+                list[str],
+                dict[str, sqlalchemy.orm.attributes.History],
+            ]
+        ],
+        *,
         result: list[AuditEntry] | None = None,
-        sessions: dict[str, SQLASession] | None = None,
     ):
         """
-        Process audit entries from the given queue.
+        Process model operations from the given deque.
 
         Args:
-            audit_entry_deque (collections.deque[tuple[SQLAModel, AuditOperation]]): The audit entries to process.
+            model_operation_deque (collections.deque[tuple[SQLAModel, AuditOperation, list[str], dict[str, sqlalchemy.orm.attributes.History]]]): The model operations to process.
             result (list[AuditEntry] | None, optional): The list to store the processed audit entries. Defaults to None. Used for recursion.
-            sessions (dict[str, SQLASession] | None, optional): The sessions to use for processing. Defaults to None. Used for recursion.
-
-        Raises:
-            ValueError: If the data is invalid.
 
         Returns:
-            list[AuditEntry]: A list of processed audit entries.
+            list[AuditEntry]: A list of audit entries processed from the model operations.
         """
         result = result if result is not None else []
-        sessions = sessions if sessions is not None else {}
-        while audit_entry_deque:
-            dat = audit_entry_deque.popleft()
-            model, operation = dat
-            if model.__bind_key__ not in sessions:
-                async with db.session(model.__bind_key__) as session:
-                    sessions[model.__bind_key__] = session
-                    audit_entry_deque.appendleft(dat)  # Re-add to process later
-                    await cls._process_audit_entries(
-                        audit_entry_deque, result, sessions
+        while model_operation_deque:
+            dat = model_operation_deque.popleft()
+            model, operation, model_keys, update_history = dat
+            if operation == AuditOperation.DELETE:
+                result.append(
+                    AuditEntry(
+                        model=model,
+                        operation=AuditOperation.DELETE,
+                        pk=str(model.id_),
                     )
-                    del sessions[model.__bind_key__]
+                )
             else:
-                session = sessions[model.__bind_key__]
-                if operation == AuditOperation.DELETE:
+                datamodel = cls.interfaces[model.__class__]
+                schema_key = f"{model.__class__.__name__}-{'-'.join(model_keys)}"
+                schema = cls.schemas.get(schema_key)
+                if not schema:
+                    cls.schemas[schema_key] = schema = datamodel.generate_schema(
+                        model_keys,
+                        with_id=False,
+                        with_name=False,
+                        optional=True,
+                        related_kwargs={"with_property": False},
+                    )
+                data = schema.model_validate(model).model_dump(mode="json")
+                if operation == AuditOperation.INSERT:
+                    updates = {k: (None, v) for k, v in data.items()}
                     result.append(
                         AuditEntry(
                             model=model,
-                            operation=AuditOperation.DELETE,
+                            operation=AuditOperation.INSERT,
                             pk=str(model.id_),
+                            data=data,
+                            updates=updates,
                         )
                     )
-                else:
-                    excluded_properties = set[str]()
-                    for excluded_model in cls.excluded_properties:
-                        if model.__class__ == excluded_model or issubclass(
-                            model.__class__, excluded_model
-                        ):
-                            excluded_properties.update(
-                                cls.excluded_properties[excluded_model]
-                            )
-                    state = sqlalchemy.inspect(model)
-                    model_keys = cls.included_properties[model.__class__] or [
-                        x for x in state.attrs.keys() if x not in excluded_properties
-                    ]
-                    datamodel = cls.interfaces[model.__class__]
-                    schema_key = f"{model.__class__.__name__}-{'-'.join(model_keys)}"
-                    schema = cls.schemas.get(schema_key)
-                    if not schema:
-                        cls.schemas[schema_key] = schema = datamodel.generate_schema(
-                            model_keys,
-                            with_id=False,
-                            with_name=False,
-                            optional=True,
-                            related_kwargs={"with_property": False},
-                        )
-                    data = schema.model_validate(model).model_dump(mode="json")
-                    if operation == AuditOperation.INSERT:
-                        updates = {k: (None, v) for k, v in data.items()}
-                        result.append(
-                            AuditEntry(
-                                model=model,
-                                operation=AuditOperation.INSERT,
-                                pk=str(model.id_),
-                                data=data,
-                                updates=updates,
+                elif operation == AuditOperation.UPDATE:
+                    update_schema_key = (
+                        f"{model.__class__.__name__}-{'-'.join(update_history.keys())}"
+                    )
+                    update_schema = cls.schemas.get(update_schema_key)
+                    if not update_schema:
+                        cls.schemas[update_schema_key] = update_schema = (
+                            datamodel.generate_schema(
+                                update_history.keys(),
+                                with_id=False,
+                                with_name=False,
+                                optional=True,
+                                related_kwargs={"with_property": False},
                             )
                         )
-                    elif operation == AuditOperation.UPDATE:
-                        updated_columns = [
-                            x
-                            for x in model_keys
-                            if state.attrs[x].history.has_changes()
-                        ]
-                        old_model = await datamodel.get_one(
-                            session,
-                            {
-                                "list_columns": updated_columns,
-                                "where_id": model.id_,
-                            },
+                    old_data = {}
+                    for col, hist in update_history.items():
+                        old_value = hist.deleted if hist.deleted else None
+                        old_value = (
+                            old_value[0]
+                            if old_value and len(old_value) == 1
+                            else old_value
                         )
-                        if not old_model:
-                            logger.warning(
-                                f"[{AuditOperation.UPDATE}] Skipping audit entry due to missing old model data from the database: {model.__class__.__name__} {model.id_}"
-                            )
-                            continue
-                        change_schema_key = f"{old_model.__class__.__name__}-{'-'.join(updated_columns)}"
-                        change_schema = cls.schemas.get(change_schema_key)
-                        if not change_schema:
-                            cls.schemas[change_schema_key] = change_schema = (
-                                datamodel.generate_schema(
-                                    updated_columns,
-                                    with_id=False,
-                                    with_name=False,
-                                    optional=True,
-                                    related_kwargs={"with_property": False},
-                                )
+                        if datamodel.is_relation(col):
+                            related_schema = get_pydantic_model_field(
+                                update_schema, col
                             )
-                        old_data = change_schema.model_validate(old_model).model_dump(
-                            mode="json"
+                            if datamodel.is_relation_one_to_one(
+                                col
+                            ) or datamodel.is_relation_many_to_one(col):
+                                if old_value is not None:
+                                    old_value = related_schema.model_validate(
+                                        old_value
+                                    ).model_dump(mode="json")
+                            else:
+                                # For one-to-many and many-to-many relations, we need to calculate the old value
+                                old_value = list(hist.unchanged) + list(hist.deleted)
+                                old_value = [
+                                    related_schema.model_validate(x).model_dump(
+                                        mode="json"
+                                    )
+                                    for x in old_value
+                                ]
+
+                        old_data[col] = old_value
+                    old_data = update_schema.model_validate(
+                        old_data, from_attributes=False
+                    ).model_dump(mode="json")
+                    updates = {k: (old_data[k], data[k]) for k in old_data if k in data}
+                    if not updates:
+                        logger.debug(
+                            f"[{AuditOperation.UPDATE}] No changes detected for model: {model.__class__.__name__} {model.id_}"
                         )
-                        updates = {
-                            k: (old_data[k], data[k]) for k in old_data if k in data
-                        }
-                        if not updates:
-                            logger.debug(
-                                f"[{AuditOperation.UPDATE}] No changes detected for model: {model.__class__.__name__} {model.id_}"
-                            )
+                        if not use_default_when_none(
+                            cls.mapping_insert_updates_when_no_changes[model.__class__],
+                            cls.mapping_insert_updates_when_no_changes_default,
+                        ):
                             continue
-                        result.append(
-                            AuditEntry(
-                                model=model,
-                                operation=AuditOperation.UPDATE,
-                                pk=str(model.id_),
-                                data=data,
-                                updates=updates,
-                            )
+                    result.append(
+                        AuditEntry(
+                            model=model,
+                            operation=AuditOperation.UPDATE,
+                            pk=str(model.id_),
+                            data=data,
+                            updates=updates,
                         )
+                    )
         return result
 
     @classmethod
@@ -818,3 +954,79 @@ class Audit:
             model.__class__ in cls.models
             or any(issubclass(model.__class__, m) for m in cls.models)
         )
+
+    @classmethod
+    async def _run_callbacks(cls, entries: list[AuditEntry]):
+        """
+        Run registered callbacks for the given audit entries in parallel.
+
+        Args:
+            entries (list[AuditEntry]): The audit entries to process.
+        """
+        async with AsyncTaskRunner():
+            for entry in entries:
+                for callback in cls.callbacks:
+                    AsyncTaskRunner.add_task(
+                        lambda callback=callback, entry=entry: smart_run(
+                            callback, entry
+                        )
+                    )
+
+    @classmethod
+    def _run_async_function_or_delegate_to_runner(
+        cls,
+        async_function: typing.Callable[
+            ..., typing.Coroutine[typing.Any, typing.Any, None]
+        ],
+        *args,
+        kwargs_in_task_runner: dict[str, typing.Any] | None = None,
+        **kwargs,
+    ):
+        """
+        Run an async function in the current threadpool or delegate it to the current AsyncTaskRunner if available.
+
+        Args:
+            async_function (typing.Callable[ ..., typing.Coroutine[typing.Any, typing.Any, None] ]): The async function to run.
+            *args: Positional arguments to pass to the async function.
+            kwargs_in_task_runner (dict[str, typing.Any] | None, optional): Additional keyword arguments to pass to function when run in AsyncTaskRunner. Defaults to None.
+            **kwargs: Keyword arguments to pass to the async function.
+
+        Returns:
+            typing.Any: The result of the async function or None if delegated.
+        """
+        try:
+            return safe_call_sync(async_function(*args, **kwargs))
+        except Exception as e:
+            try:
+                task_runner = AsyncTaskRunner.get_current_runner()
+                params = {**kwargs, **(kwargs_in_task_runner or {})}
+                task_runner.add_task(lambda: async_function(*args, **params))
+                logger.warning(
+                    f"Delegated async function {async_function.__name__} to AsyncTaskRunner due to error running in threadpool"
+                )
+            except RuntimeError:
+                logger.error(
+                    f"Error running async function {async_function.__name__} in threadpool and no AsyncTaskRunner is available to delegate the task to: {e}"
+                )
+
+    @classmethod
+    def _get_audit_properties(cls, model: SQLAModel):
+        """
+        Get the list of properties to include in the audit for the given model.
+
+        Args:
+            model (SQLAModel): The SQLAlchemy model instance to get included properties for.
+
+        Returns:
+            list[str]: A list of included property names.
+        """
+        excluded_properties = set[str]()
+        for excluded_model in cls.excluded_properties:
+            if model.__class__ == excluded_model or issubclass(
+                model.__class__, excluded_model
+            ):
+                excluded_properties.update(cls.excluded_properties[excluded_model])
+        state = sqlalchemy.inspect(model)
+        return cls.included_properties[model.__class__] or [
+            x for x in state.attrs.keys() if x not in excluded_properties
+        ]