From be25d8a74677da9cb6f67fc865663e74260c66a7 Mon Sep 17 00:00:00 2001
From: Aurthur Musendame <musendamea@nmrl.org.zw>
Date: Fri, 2 Aug 2024 17:29:19 +0200
Subject: [PATCH] fixed audit to mongo, updated event system

---
 .idea/workspace.xml                           |   40 +-
 .vscode/PythonImportHelper-v2-Completion.json | 1647 ++++++-----------
 docker-compose.dev.yml                        |   65 +-
 .../analysis/mutations/analysis_request.py    |   19 +-
 felicity/api/gql/audit/query.py               |   22 +-
 felicity/api/gql/audit/types.py               |   12 +-
 felicity/api/gql/notification/subscription.py |    4 +-
 felicity/api/gql/notification/types.py        |    7 +-
 felicity/api/gql/types/generic.py             |    4 +-
 felicity/apps/abstract/events.py              |   85 +-
 felicity/apps/abstract/trackable.py           |   47 +-
 felicity/apps/analysis/services/analysis.py   |   16 +-
 felicity/apps/analysis/utils.py               |   31 +-
 felicity/apps/auditlog/__init__.py            |    1 -
 felicity/apps/auditlog/entities.py            |   90 -
 felicity/apps/auditlog/mixin.py               |  111 --
 felicity/apps/auditlog/repositories.py        |    7 -
 felicity/apps/auditlog/services.py            |    9 -
 felicity/apps/common/utils/serializer.py      |   50 +-
 felicity/apps/errlog/__init__.py              |    0
 felicity/apps/errlog/entities.py              |   10 -
 felicity/apps/errlog/repositories.py          |    7 -
 felicity/apps/errlog/schemas.py               |   24 -
 felicity/apps/errlog/services.py              |    9 -
 felicity/apps/iol/meilisearch/client.py       |   13 +-
 felicity/apps/iol/meilisearch/handler.py      |   25 +-
 felicity/apps/iol/minio/client.py             |    9 +-
 felicity/apps/notification/services.py        |   54 +-
 felicity/core/events.py                       |  111 +-
 felicity/database/base.py                     |    3 -
 felicity/database/mongo.py                    |   34 +-
 felicity/database/queryset/__init__.py        |    4 -
 felicity/database/queryset/builder.py         |  646 -------
 webapp/components/audit/FelAuditLog.vue       |   12 +-
 webapp/components/result/ResultDetail.vue     |    2 +-
 webapp/graphql/operations/_queries.ts         |    8 +-
 webapp/views/client/_id/ClientDetail.vue      |    2 +-
 webapp/views/patient/PatientsCompact.vue      |    2 +-
 webapp/views/patient/_id/PatientDetail.vue    |    2 +-
 webapp/views/sample/_id/SampleDetail.vue      |    2 +-
 webapp/views/shipment/_id/ShipmentDetail.vue  |    2 +-
 .../views/worksheet/_id/WorkSheetDetail.vue   |    2 +-
 42 files changed, 1029 insertions(+), 2221 deletions(-)
 delete mode 100644 felicity/apps/auditlog/__init__.py
 delete mode 100644 felicity/apps/auditlog/entities.py
 delete mode 100644 felicity/apps/auditlog/mixin.py
 delete mode 100644 felicity/apps/auditlog/repositories.py
 delete mode 100644 felicity/apps/auditlog/services.py
 delete mode 100644 felicity/apps/errlog/__init__.py
 delete mode 100644 felicity/apps/errlog/entities.py
 delete mode 100644 felicity/apps/errlog/repositories.py
 delete mode 100644 felicity/apps/errlog/schemas.py
 delete mode 100644 felicity/apps/errlog/services.py
 delete mode 100644 felicity/database/queryset/__init__.py
 delete mode 100644 felicity/database/queryset/builder.py

diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index ee379e16..d7c3c787 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -6,9 +6,47 @@
   <component name="ChangeListManager">
     <list default="true" id="9f590b69-f929-45a1-8512-12ed6efbf028" name="Changes" comment="Added Invetory starter">
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/.vscode/PythonImportHelper-v2-Completion.json" beforeDir="false" afterPath="$PROJECT_DIR$/.vscode/PythonImportHelper-v2-Completion.json" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/docker-compose.dev.yml" beforeDir="false" afterPath="$PROJECT_DIR$/docker-compose.dev.yml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/felicity/core/config.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/core/config.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/api/gql/analysis/mutations/analysis_request.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/api/gql/analysis/mutations/analysis_request.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/api/gql/audit/query.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/api/gql/audit/query.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/api/gql/audit/types.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/api/gql/audit/types.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/api/gql/notification/subscription.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/api/gql/notification/subscription.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/api/gql/notification/types.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/api/gql/notification/types.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/api/gql/types/generic.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/api/gql/types/generic.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/abstract/events.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/apps/abstract/events.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/abstract/trackable.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/apps/abstract/trackable.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/analysis/services/analysis.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/apps/analysis/services/analysis.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/analysis/utils.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/apps/analysis/utils.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/auditlog/__init__.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/auditlog/entities.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/auditlog/mixin.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/auditlog/repositories.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/auditlog/services.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/common/utils/serializer.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/apps/common/utils/serializer.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/errlog/__init__.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/errlog/entities.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/errlog/repositories.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/errlog/schemas.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/errlog/services.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/iol/meilisearch/client.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/apps/iol/meilisearch/client.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/iol/meilisearch/handler.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/apps/iol/meilisearch/handler.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/iol/minio/client.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/apps/iol/minio/client.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/apps/notification/services.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/apps/notification/services.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/core/events.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/core/events.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/database/base.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/database/base.py" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/felicity/database/mongo.py" beforeDir="false" afterPath="$PROJECT_DIR$/felicity/database/mongo.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/database/queryset/__init__.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/felicity/database/queryset/builder.py" beforeDir="false" />
+      <change beforePath="$PROJECT_DIR$/webapp/components/audit/FelAuditLog.vue" beforeDir="false" afterPath="$PROJECT_DIR$/webapp/components/audit/FelAuditLog.vue" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/webapp/components/result/ResultDetail.vue" beforeDir="false" afterPath="$PROJECT_DIR$/webapp/components/result/ResultDetail.vue" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/webapp/graphql/operations/_queries.ts" beforeDir="false" afterPath="$PROJECT_DIR$/webapp/graphql/operations/_queries.ts" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/webapp/views/client/_id/ClientDetail.vue" beforeDir="false" afterPath="$PROJECT_DIR$/webapp/views/client/_id/ClientDetail.vue" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/webapp/views/patient/PatientsCompact.vue" beforeDir="false" afterPath="$PROJECT_DIR$/webapp/views/patient/PatientsCompact.vue" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/webapp/views/patient/_id/PatientDetail.vue" beforeDir="false" afterPath="$PROJECT_DIR$/webapp/views/patient/_id/PatientDetail.vue" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/webapp/views/sample/_id/SampleDetail.vue" beforeDir="false" afterPath="$PROJECT_DIR$/webapp/views/sample/_id/SampleDetail.vue" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/webapp/views/shipment/_id/ShipmentDetail.vue" beforeDir="false" afterPath="$PROJECT_DIR$/webapp/views/shipment/_id/ShipmentDetail.vue" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/webapp/views/worksheet/_id/WorkSheetDetail.vue" beforeDir="false" afterPath="$PROJECT_DIR$/webapp/views/worksheet/_id/WorkSheetDetail.vue" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
diff --git a/.vscode/PythonImportHelper-v2-Completion.json b/.vscode/PythonImportHelper-v2-Completion.json
index 443d6381..bdfa4131 100644
--- a/.vscode/PythonImportHelper-v2-Completion.json
+++ b/.vscode/PythonImportHelper-v2-Completion.json
@@ -185,14 +185,6 @@
         "detail": "typing",
         "documentation": {}
     },
-    {
-        "label": "Text",
-        "importPath": "typing",
-        "description": "typing",
-        "isExtraImport": true,
-        "detail": "typing",
-        "documentation": {}
-    },
     {
         "label": "List",
         "importPath": "typing",
@@ -465,14 +457,6 @@
         "detail": "typing",
         "documentation": {}
     },
-    {
-        "label": "List",
-        "importPath": "typing",
-        "description": "typing",
-        "isExtraImport": true,
-        "detail": "typing",
-        "documentation": {}
-    },
     {
         "label": "Optional",
         "importPath": "typing",
@@ -1129,46 +1113,6 @@
         "detail": "typing",
         "documentation": {}
     },
-    {
-        "label": "Any",
-        "importPath": "typing",
-        "description": "typing",
-        "isExtraImport": true,
-        "detail": "typing",
-        "documentation": {}
-    },
-    {
-        "label": "AsyncIterator",
-        "importPath": "typing",
-        "description": "typing",
-        "isExtraImport": true,
-        "detail": "typing",
-        "documentation": {}
-    },
-    {
-        "label": "Set",
-        "importPath": "typing",
-        "description": "typing",
-        "isExtraImport": true,
-        "detail": "typing",
-        "documentation": {}
-    },
-    {
-        "label": "Any",
-        "importPath": "typing",
-        "description": "typing",
-        "isExtraImport": true,
-        "detail": "typing",
-        "documentation": {}
-    },
-    {
-        "label": "Optional",
-        "importPath": "typing",
-        "description": "typing",
-        "isExtraImport": true,
-        "detail": "typing",
-        "documentation": {}
-    },
     {
         "label": "TypeVar",
         "importPath": "typing",
@@ -1473,6 +1417,30 @@
         "detail": "typing",
         "documentation": {}
     },
+    {
+        "label": "List",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Dict",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Any",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
     {
         "label": "Any",
         "importPath": "typing",
@@ -1530,7 +1498,7 @@
         "documentation": {}
     },
     {
-        "label": "TypeVar",
+        "label": "Optional",
         "importPath": "typing",
         "description": "typing",
         "isExtraImport": true,
@@ -1538,7 +1506,7 @@
         "documentation": {}
     },
     {
-        "label": "Optional",
+        "label": "Any",
         "importPath": "typing",
         "description": "typing",
         "isExtraImport": true,
@@ -2411,6 +2379,14 @@
         "detail": "felicity.api.gql.types",
         "documentation": {}
     },
+    {
+        "label": "JSONScalar",
+        "importPath": "felicity.api.gql.types",
+        "description": "felicity.api.gql.types",
+        "isExtraImport": true,
+        "detail": "felicity.api.gql.types",
+        "documentation": {}
+    },
     {
         "label": "OperationError",
         "importPath": "felicity.api.gql.types",
@@ -3668,22 +3644,6 @@
         "detail": "dataclasses",
         "documentation": {}
     },
-    {
-        "label": "dataclass",
-        "importPath": "dataclasses",
-        "description": "dataclasses",
-        "isExtraImport": true,
-        "detail": "dataclasses",
-        "documentation": {}
-    },
-    {
-        "label": "field",
-        "importPath": "dataclasses",
-        "description": "dataclasses",
-        "isExtraImport": true,
-        "detail": "dataclasses",
-        "documentation": {}
-    },
     {
         "label": "analysis",
         "importPath": "felicity.apps.analysis.entities",
@@ -4164,14 +4124,6 @@
         "detail": "felicity.apps.analysis.entities.analysis",
         "documentation": {}
     },
-    {
-        "label": "\\",
-        "importPath": "felicity.apps.analysis.entities.analysis",
-        "description": "felicity.apps.analysis.entities.analysis",
-        "isExtraImport": true,
-        "detail": "felicity.apps.analysis.entities.analysis",
-        "documentation": {}
-    },
     {
         "label": "CodingStandard",
         "importPath": "felicity.apps.analysis.entities.analysis",
@@ -4254,7 +4206,23 @@
         "documentation": {}
     },
     {
-        "label": "Queue",
+        "label": "create_task",
+        "importPath": "asyncio",
+        "description": "asyncio",
+        "isExtraImport": true,
+        "detail": "asyncio",
+        "documentation": {}
+    },
+    {
+        "label": "gather",
+        "importPath": "asyncio",
+        "description": "asyncio",
+        "isExtraImport": true,
+        "detail": "asyncio",
+        "documentation": {}
+    },
+    {
+        "label": "Lock",
         "importPath": "asyncio",
         "description": "asyncio",
         "isExtraImport": true,
@@ -4590,6 +4558,22 @@
         "detail": "datetime",
         "documentation": {}
     },
+    {
+        "label": "datetime",
+        "importPath": "datetime",
+        "description": "datetime",
+        "isExtraImport": true,
+        "detail": "datetime",
+        "documentation": {}
+    },
+    {
+        "label": "datetime",
+        "importPath": "datetime",
+        "description": "datetime",
+        "isExtraImport": true,
+        "detail": "datetime",
+        "documentation": {}
+    },
     {
         "label": "timedelta",
         "importPath": "datetime",
@@ -8360,6 +8344,22 @@
         "detail": "sqlalchemy",
         "documentation": {}
     },
+    {
+        "label": "event",
+        "importPath": "sqlalchemy",
+        "description": "sqlalchemy",
+        "isExtraImport": true,
+        "detail": "sqlalchemy",
+        "documentation": {}
+    },
+    {
+        "label": "inspect",
+        "importPath": "sqlalchemy",
+        "description": "sqlalchemy",
+        "isExtraImport": true,
+        "detail": "sqlalchemy",
+        "documentation": {}
+    },
     {
         "label": "Boolean",
         "importPath": "sqlalchemy",
@@ -8616,54 +8616,6 @@
         "detail": "sqlalchemy",
         "documentation": {}
     },
-    {
-        "label": "Column",
-        "importPath": "sqlalchemy",
-        "description": "sqlalchemy",
-        "isExtraImport": true,
-        "detail": "sqlalchemy",
-        "documentation": {}
-    },
-    {
-        "label": "Integer",
-        "importPath": "sqlalchemy",
-        "description": "sqlalchemy",
-        "isExtraImport": true,
-        "detail": "sqlalchemy",
-        "documentation": {}
-    },
-    {
-        "label": "String",
-        "importPath": "sqlalchemy",
-        "description": "sqlalchemy",
-        "isExtraImport": true,
-        "detail": "sqlalchemy",
-        "documentation": {}
-    },
-    {
-        "label": "UnicodeText",
-        "importPath": "sqlalchemy",
-        "description": "sqlalchemy",
-        "isExtraImport": true,
-        "detail": "sqlalchemy",
-        "documentation": {}
-    },
-    {
-        "label": "event",
-        "importPath": "sqlalchemy",
-        "description": "sqlalchemy",
-        "isExtraImport": true,
-        "detail": "sqlalchemy",
-        "documentation": {}
-    },
-    {
-        "label": "inspect",
-        "importPath": "sqlalchemy",
-        "description": "sqlalchemy",
-        "isExtraImport": true,
-        "detail": "sqlalchemy",
-        "documentation": {}
-    },
     {
         "label": "Boolean",
         "importPath": "sqlalchemy",
@@ -8784,14 +8736,6 @@
         "detail": "sqlalchemy",
         "documentation": {}
     },
-    {
-        "label": "Column",
-        "importPath": "sqlalchemy",
-        "description": "sqlalchemy",
-        "isExtraImport": true,
-        "detail": "sqlalchemy",
-        "documentation": {}
-    },
     {
         "label": "DateTime",
         "importPath": "sqlalchemy",
@@ -9520,38 +9464,6 @@
         "detail": "sqlalchemy",
         "documentation": {}
     },
-    {
-        "label": "asc",
-        "importPath": "sqlalchemy",
-        "description": "sqlalchemy",
-        "isExtraImport": true,
-        "detail": "sqlalchemy",
-        "documentation": {}
-    },
-    {
-        "label": "desc",
-        "importPath": "sqlalchemy",
-        "description": "sqlalchemy",
-        "isExtraImport": true,
-        "detail": "sqlalchemy",
-        "documentation": {}
-    },
-    {
-        "label": "inspect",
-        "importPath": "sqlalchemy",
-        "description": "sqlalchemy",
-        "isExtraImport": true,
-        "detail": "sqlalchemy",
-        "documentation": {}
-    },
-    {
-        "label": "select",
-        "importPath": "sqlalchemy",
-        "description": "sqlalchemy",
-        "isExtraImport": true,
-        "detail": "sqlalchemy",
-        "documentation": {}
-    },
     {
         "label": "create_engine",
         "importPath": "sqlalchemy",
@@ -10496,6 +10408,38 @@
         "detail": "felicity.apps.user.services",
         "documentation": {}
     },
+    {
+        "label": "MongoService",
+        "importPath": "database.mongo",
+        "description": "database.mongo",
+        "isExtraImport": true,
+        "detail": "database.mongo",
+        "documentation": {}
+    },
+    {
+        "label": "MongoCollection",
+        "importPath": "database.mongo",
+        "description": "database.mongo",
+        "isExtraImport": true,
+        "detail": "database.mongo",
+        "documentation": {}
+    },
+    {
+        "label": "MongoService",
+        "importPath": "database.mongo",
+        "description": "database.mongo",
+        "isExtraImport": true,
+        "detail": "database.mongo",
+        "documentation": {}
+    },
+    {
+        "label": "MongoCollection",
+        "importPath": "database.mongo",
+        "description": "database.mongo",
+        "isExtraImport": true,
+        "detail": "database.mongo",
+        "documentation": {}
+    },
     {
         "label": "AuditLogType",
         "importPath": "felicity.api.gql.audit.types",
@@ -10504,14 +10448,6 @@
         "detail": "felicity.api.gql.audit.types",
         "documentation": {}
     },
-    {
-        "label": "AuditLogService",
-        "importPath": "felicity.apps.auditlog.services",
-        "description": "felicity.apps.auditlog.services",
-        "isExtraImport": true,
-        "detail": "felicity.apps.auditlog.services",
-        "documentation": {}
-    },
     {
         "label": "Info",
         "importPath": "strawberry.types",
@@ -12433,14 +12369,6 @@
         "detail": "felicity.core.dtz",
         "documentation": {}
     },
-    {
-        "label": "format_datetime",
-        "importPath": "felicity.core.dtz",
-        "description": "felicity.core.dtz",
-        "isExtraImport": true,
-        "detail": "felicity.core.dtz",
-        "documentation": {}
-    },
     {
         "label": "datetime_math",
         "importPath": "felicity.core.dtz",
@@ -12506,15 +12434,16 @@
         "documentation": {}
     },
     {
-        "label": "BroadcastEvent",
-        "importPath": "felicity.apps.common.channel",
-        "description": "felicity.apps.common.channel",
+        "label": "json",
+        "kind": 6,
         "isExtraImport": true,
-        "detail": "felicity.apps.common.channel",
+        "importPath": "json",
+        "description": "json",
+        "detail": "json",
         "documentation": {}
     },
     {
-        "label": "Subscriber",
+        "label": "broadcast",
         "importPath": "felicity.apps.common.channel",
         "description": "felicity.apps.common.channel",
         "isExtraImport": true,
@@ -13555,12 +13484,99 @@
         "documentation": {}
     },
     {
-        "label": "json",
-        "kind": 6,
+        "label": "marshaller",
+        "importPath": "felicity.apps.common.utils.serializer",
+        "description": "felicity.apps.common.utils.serializer",
         "isExtraImport": true,
-        "importPath": "json",
-        "description": "json",
-        "detail": "json",
+        "detail": "felicity.apps.common.utils.serializer",
+        "documentation": {}
+    },
+    {
+        "label": "marshaller",
+        "importPath": "felicity.apps.common.utils.serializer",
+        "description": "felicity.apps.common.utils.serializer",
+        "isExtraImport": true,
+        "detail": "felicity.apps.common.utils.serializer",
+        "documentation": {}
+    },
+    {
+        "label": "marshaller",
+        "importPath": "felicity.apps.common.utils.serializer",
+        "description": "felicity.apps.common.utils.serializer",
+        "isExtraImport": true,
+        "detail": "felicity.apps.common.utils.serializer",
+        "documentation": {}
+    },
+    {
+        "label": "marshaller",
+        "importPath": "felicity.apps.common.utils.serializer",
+        "description": "felicity.apps.common.utils.serializer",
+        "isExtraImport": true,
+        "detail": "felicity.apps.common.utils.serializer",
+        "documentation": {}
+    },
+    {
+        "label": "marshaller",
+        "importPath": "felicity.apps.common.utils.serializer",
+        "description": "felicity.apps.common.utils.serializer",
+        "isExtraImport": true,
+        "detail": "felicity.apps.common.utils.serializer",
+        "documentation": {}
+    },
+    {
+        "label": "marshaller",
+        "importPath": "felicity.apps.common.utils.serializer",
+        "description": "felicity.apps.common.utils.serializer",
+        "isExtraImport": true,
+        "detail": "felicity.apps.common.utils.serializer",
+        "documentation": {}
+    },
+    {
+        "label": "marshaller",
+        "importPath": "felicity.apps.common.utils.serializer",
+        "description": "felicity.apps.common.utils.serializer",
+        "isExtraImport": true,
+        "detail": "felicity.apps.common.utils.serializer",
+        "documentation": {}
+    },
+    {
+        "label": "marshaller",
+        "importPath": "felicity.apps.common.utils.serializer",
+        "description": "felicity.apps.common.utils.serializer",
+        "isExtraImport": true,
+        "detail": "felicity.apps.common.utils.serializer",
+        "documentation": {}
+    },
+    {
+        "label": "marshaller",
+        "importPath": "felicity.apps.common.utils.serializer",
+        "description": "felicity.apps.common.utils.serializer",
+        "isExtraImport": true,
+        "detail": "felicity.apps.common.utils.serializer",
+        "documentation": {}
+    },
+    {
+        "label": "marshaller",
+        "importPath": "felicity.apps.common.utils.serializer",
+        "description": "felicity.apps.common.utils.serializer",
+        "isExtraImport": true,
+        "detail": "felicity.apps.common.utils.serializer",
+        "documentation": {}
+    },
+    {
+        "label": "marshaller",
+        "importPath": "felicity.apps.common.utils.serializer",
+        "description": "felicity.apps.common.utils.serializer",
+        "isExtraImport": true,
+        "detail": "felicity.apps.common.utils.serializer",
+        "documentation": {}
+    },
+    {
+        "label": "marshaller",
+        "importPath": "felicity.apps.common.utils.serializer",
+        "description": "felicity.apps.common.utils.serializer",
+        "isExtraImport": true,
+        "detail": "felicity.apps.common.utils.serializer",
         "documentation": {}
     },
     {
@@ -13645,7 +13661,7 @@
         "documentation": {}
     },
     {
-        "label": "get_settings",
+        "label": "settings",
         "importPath": "felicity.core.config",
         "description": "felicity.core.config",
         "isExtraImport": true,
@@ -13684,6 +13700,22 @@
         "detail": "felicity.core.config",
         "documentation": {}
     },
+    {
+        "label": "settings",
+        "importPath": "felicity.core.config",
+        "description": "felicity.core.config",
+        "isExtraImport": true,
+        "detail": "felicity.core.config",
+        "documentation": {}
+    },
+    {
+        "label": "settings",
+        "importPath": "felicity.core.config",
+        "description": "felicity.core.config",
+        "isExtraImport": true,
+        "detail": "felicity.core.config",
+        "documentation": {}
+    },
     {
         "label": "get_settings",
         "importPath": "felicity.core.config",
@@ -13708,6 +13740,22 @@
         "detail": "felicity.core.config",
         "documentation": {}
     },
+    {
+        "label": "settings",
+        "importPath": "felicity.core.config",
+        "description": "felicity.core.config",
+        "isExtraImport": true,
+        "detail": "felicity.core.config",
+        "documentation": {}
+    },
+    {
+        "label": "get_settings",
+        "importPath": "felicity.core.config",
+        "description": "felicity.core.config",
+        "isExtraImport": true,
+        "detail": "felicity.core.config",
+        "documentation": {}
+    },
     {
         "label": "get_settings",
         "importPath": "felicity.core.config",
@@ -13796,6 +13844,22 @@
         "detail": "felicity.core.events",
         "documentation": {}
     },
+    {
+        "label": "post_event",
+        "importPath": "felicity.core.events",
+        "description": "felicity.core.events",
+        "isExtraImport": true,
+        "detail": "felicity.core.events",
+        "documentation": {}
+    },
+    {
+        "label": "subscribe",
+        "importPath": "felicity.core.events",
+        "description": "felicity.core.events",
+        "isExtraImport": true,
+        "detail": "felicity.core.events",
+        "documentation": {}
+    },
     {
         "label": "generate_password_reset_token",
         "importPath": "felicity.core.security",
@@ -14780,22 +14844,6 @@
         "detail": "pydantic",
         "documentation": {}
     },
-    {
-        "label": "ConfigDict",
-        "importPath": "pydantic",
-        "description": "pydantic",
-        "isExtraImport": true,
-        "detail": "pydantic",
-        "documentation": {}
-    },
-    {
-        "label": "BaseModel",
-        "importPath": "pydantic",
-        "description": "pydantic",
-        "isExtraImport": true,
-        "detail": "pydantic",
-        "documentation": {}
-    },
     {
         "label": "BaseModel",
         "importPath": "pydantic",
@@ -15044,86 +15092,6 @@
         "detail": "pydantic",
         "documentation": {}
     },
-    {
-        "label": "marshaller",
-        "importPath": "felicity.apps.common.utils.serializer",
-        "description": "felicity.apps.common.utils.serializer",
-        "isExtraImport": true,
-        "detail": "felicity.apps.common.utils.serializer",
-        "documentation": {}
-    },
-    {
-        "label": "marshaller",
-        "importPath": "felicity.apps.common.utils.serializer",
-        "description": "felicity.apps.common.utils.serializer",
-        "isExtraImport": true,
-        "detail": "felicity.apps.common.utils.serializer",
-        "documentation": {}
-    },
-    {
-        "label": "marshaller",
-        "importPath": "felicity.apps.common.utils.serializer",
-        "description": "felicity.apps.common.utils.serializer",
-        "isExtraImport": true,
-        "detail": "felicity.apps.common.utils.serializer",
-        "documentation": {}
-    },
-    {
-        "label": "marshaller",
-        "importPath": "felicity.apps.common.utils.serializer",
-        "description": "felicity.apps.common.utils.serializer",
-        "isExtraImport": true,
-        "detail": "felicity.apps.common.utils.serializer",
-        "documentation": {}
-    },
-    {
-        "label": "marshaller",
-        "importPath": "felicity.apps.common.utils.serializer",
-        "description": "felicity.apps.common.utils.serializer",
-        "isExtraImport": true,
-        "detail": "felicity.apps.common.utils.serializer",
-        "documentation": {}
-    },
-    {
-        "label": "marshaller",
-        "importPath": "felicity.apps.common.utils.serializer",
-        "description": "felicity.apps.common.utils.serializer",
-        "isExtraImport": true,
-        "detail": "felicity.apps.common.utils.serializer",
-        "documentation": {}
-    },
-    {
-        "label": "marshaller",
-        "importPath": "felicity.apps.common.utils.serializer",
-        "description": "felicity.apps.common.utils.serializer",
-        "isExtraImport": true,
-        "detail": "felicity.apps.common.utils.serializer",
-        "documentation": {}
-    },
-    {
-        "label": "marshaller",
-        "importPath": "felicity.apps.common.utils.serializer",
-        "description": "felicity.apps.common.utils.serializer",
-        "isExtraImport": true,
-        "detail": "felicity.apps.common.utils.serializer",
-        "documentation": {}
-    },
-    {
-        "label": "marshaller",
-        "importPath": "felicity.apps.common.utils.serializer",
-        "description": "felicity.apps.common.utils.serializer",
-        "isExtraImport": true,
-        "detail": "felicity.apps.common.utils.serializer",
-        "documentation": {}
-    },
-    {
-        "label": "marshaller",
-        "importPath": "felicity.apps.common.utils.serializer",
-        "description": "felicity.apps.common.utils.serializer",
-        "isExtraImport": true,
-        "detail": "felicity.apps.common.utils.serializer",
-        "documentation": {}
-    },
     {
         "label": "default_setup",
         "importPath": "felicity.lims.seeds",
@@ -15564,38 +15532,6 @@
         "detail": "sqlalchemy.orm",
         "documentation": {}
     },
-    {
-        "label": "relationship",
-        "importPath": "sqlalchemy.orm",
-        "description": "sqlalchemy.orm",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.orm",
-        "documentation": {}
-    },
-    {
-        "label": "relationship",
-        "importPath": "sqlalchemy.orm",
-        "description": "sqlalchemy.orm",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.orm",
-        "documentation": {}
-    },
-    {
-        "label": "relationship",
-        "importPath": "sqlalchemy.orm",
-        "description": "sqlalchemy.orm",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.orm",
-        "documentation": {}
-    },
-    {
-        "label": "relationship",
-        "importPath": "sqlalchemy.orm",
-        "description": "sqlalchemy.orm",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.orm",
-        "documentation": {}
-    },
     {
         "label": "class_mapper",
         "importPath": "sqlalchemy.orm",
@@ -15612,6 +15548,38 @@
         "detail": "sqlalchemy.orm",
         "documentation": {}
     },
+    {
+        "label": "relationship",
+        "importPath": "sqlalchemy.orm",
+        "description": "sqlalchemy.orm",
+        "isExtraImport": true,
+        "detail": "sqlalchemy.orm",
+        "documentation": {}
+    },
+    {
+        "label": "relationship",
+        "importPath": "sqlalchemy.orm",
+        "description": "sqlalchemy.orm",
+        "isExtraImport": true,
+        "detail": "sqlalchemy.orm",
+        "documentation": {}
+    },
+    {
+        "label": "relationship",
+        "importPath": "sqlalchemy.orm",
+        "description": "sqlalchemy.orm",
+        "isExtraImport": true,
+        "detail": "sqlalchemy.orm",
+        "documentation": {}
+    },
+    {
+        "label": "relationship",
+        "importPath": "sqlalchemy.orm",
+        "description": "sqlalchemy.orm",
+        "isExtraImport": true,
+        "detail": "sqlalchemy.orm",
+        "documentation": {}
+    },
     {
         "label": "backref",
         "importPath": "sqlalchemy.orm",
@@ -15756,38 +15724,6 @@
         "detail": "sqlalchemy.orm",
         "documentation": {}
     },
-    {
-        "label": "RelationshipProperty",
-        "importPath": "sqlalchemy.orm",
-        "description": "sqlalchemy.orm",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.orm",
-        "documentation": {}
-    },
-    {
-        "label": "aliased",
-        "importPath": "sqlalchemy.orm",
-        "description": "sqlalchemy.orm",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.orm",
-        "documentation": {}
-    },
-    {
-        "label": "joinedload",
-        "importPath": "sqlalchemy.orm",
-        "description": "sqlalchemy.orm",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.orm",
-        "documentation": {}
-    },
-    {
-        "label": "subqueryload",
-        "importPath": "sqlalchemy.orm",
-        "description": "sqlalchemy.orm",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.orm",
-        "documentation": {}
-    },
     {
         "label": "object_session",
         "importPath": "sqlalchemy.orm",
@@ -15933,19 +15869,11 @@
         "documentation": {}
     },
     {
-        "label": "BaseEntity",
-        "importPath": "felicity.apps.abstract.entity",
-        "description": "felicity.apps.abstract.entity",
+        "label": "TrackableEntity",
+        "importPath": "felicity.apps.abstract.trackable",
+        "description": "felicity.apps.abstract.trackable",
         "isExtraImport": true,
-        "detail": "felicity.apps.abstract.entity",
-        "documentation": {}
-    },
-    {
-        "label": "AuditHistoryMixin",
-        "importPath": "felicity.apps.auditlog.mixin",
-        "description": "felicity.apps.auditlog.mixin",
-        "isExtraImport": true,
-        "detail": "felicity.apps.auditlog.mixin",
+        "detail": "felicity.apps.abstract.trackable",
         "documentation": {}
     },
     {
@@ -16044,6 +15972,14 @@
         "detail": "felicity.core.uid_gen",
         "documentation": {}
     },
+    {
+        "label": "MeilisearchSyncHandler",
+        "importPath": "apps.iol.meilisearch.handler",
+        "description": "apps.iol.meilisearch.handler",
+        "isExtraImport": true,
+        "detail": "apps.iol.meilisearch.handler",
+        "documentation": {}
+    },
     {
         "label": "BaseNestedSets",
         "importPath": "felicity.libs.sqlalchemy_mptt",
@@ -16076,22 +16012,6 @@
         "detail": "sqlalchemy.sql",
         "documentation": {}
     },
-    {
-        "label": "extract",
-        "importPath": "sqlalchemy.sql",
-        "description": "sqlalchemy.sql",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.sql",
-        "documentation": {}
-    },
-    {
-        "label": "operators",
-        "importPath": "sqlalchemy.sql",
-        "description": "sqlalchemy.sql",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.sql",
-        "documentation": {}
-    },
     {
         "label": "func",
         "importPath": "sqlalchemy.sql",
@@ -16325,11 +16245,19 @@
         "documentation": {}
     },
     {
-        "label": "BaseRepository",
-        "importPath": "felicity.apps.abstract.repository",
-        "description": "felicity.apps.abstract.repository",
+        "label": "get_history",
+        "importPath": "sqlalchemy.orm.attributes",
+        "description": "sqlalchemy.orm.attributes",
         "isExtraImport": true,
-        "detail": "felicity.apps.abstract.repository",
+        "detail": "sqlalchemy.orm.attributes",
+        "documentation": {}
+    },
+    {
+        "label": "get_history",
+        "importPath": "sqlalchemy.orm.attributes",
+        "description": "sqlalchemy.orm.attributes",
+        "isExtraImport": true,
+        "detail": "sqlalchemy.orm.attributes",
         "documentation": {}
     },
     {
@@ -16428,22 +16356,6 @@
         "detail": "felicity.apps.abstract",
         "documentation": {}
     },
-    {
-        "label": "BaseRepository",
-        "importPath": "felicity.apps.abstract",
-        "description": "felicity.apps.abstract",
-        "isExtraImport": true,
-        "detail": "felicity.apps.abstract",
-        "documentation": {}
-    },
-    {
-        "label": "BaseService",
-        "importPath": "felicity.apps.abstract",
-        "description": "felicity.apps.abstract",
-        "isExtraImport": true,
-        "detail": "felicity.apps.abstract",
-        "documentation": {}
-    },
     {
         "label": "AuditHistory",
         "importPath": "felicity.apps.abstract",
@@ -16484,14 +16396,6 @@
         "detail": "felicity.apps.abstract",
         "documentation": {}
     },
-    {
-        "label": "AuditUser",
-        "importPath": "felicity.apps.abstract",
-        "description": "felicity.apps.abstract",
-        "isExtraImport": true,
-        "detail": "felicity.apps.abstract",
-        "documentation": {}
-    },
     {
         "label": "BaseEntity",
         "importPath": "felicity.apps.abstract",
@@ -16900,14 +16804,6 @@
         "detail": "felicity.apps.abstract.service",
         "documentation": {}
     },
-    {
-        "label": "BaseService",
-        "importPath": "felicity.apps.abstract.service",
-        "description": "felicity.apps.abstract.service",
-        "isExtraImport": true,
-        "detail": "felicity.apps.abstract.service",
-        "documentation": {}
-    },
     {
         "label": "AnalysisCategoryRepository",
         "importPath": "felicity.apps.analysis.repository.analysis",
@@ -17652,14 +17548,6 @@
         "detail": "felicity.apps.common.schemas.dummy",
         "documentation": {}
     },
-    {
-        "label": "Dummy",
-        "importPath": "felicity.apps.common.schemas.dummy",
-        "description": "felicity.apps.common.schemas.dummy",
-        "isExtraImport": true,
-        "detail": "felicity.apps.common.schemas.dummy",
-        "documentation": {}
-    },
     {
         "label": "IntEnum",
         "importPath": "enum",
@@ -17716,6 +17604,14 @@
         "detail": "enum",
         "documentation": {}
     },
+    {
+        "label": "Enum",
+        "importPath": "enum",
+        "description": "enum",
+        "isExtraImport": true,
+        "detail": "enum",
+        "documentation": {}
+    },
     {
         "label": "IntEnum",
         "importPath": "enum",
@@ -17764,6 +17660,14 @@
         "detail": "enum",
         "documentation": {}
     },
+    {
+        "label": "StrEnum",
+        "importPath": "enum",
+        "description": "enum",
+        "isExtraImport": true,
+        "detail": "enum",
+        "documentation": {}
+    },
     {
         "label": "IntEnum",
         "importPath": "enum",
@@ -18421,78 +18325,6 @@
         "detail": "pandas",
         "documentation": {}
     },
-    {
-        "label": "get_history",
-        "importPath": "sqlalchemy.orm.attributes",
-        "description": "sqlalchemy.orm.attributes",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.orm.attributes",
-        "documentation": {}
-    },
-    {
-        "label": "get_history",
-        "importPath": "sqlalchemy.orm.attributes",
-        "description": "sqlalchemy.orm.attributes",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.orm.attributes",
-        "documentation": {}
-    },
-    {
-        "label": "AuditLog",
-        "importPath": "felicity.apps.auditlog.entities",
-        "description": "felicity.apps.auditlog.entities",
-        "isExtraImport": true,
-        "detail": "felicity.apps.auditlog.entities",
-        "documentation": {}
-    },
-    {
-        "label": "AuditLog",
-        "importPath": "felicity.apps.auditlog.entities",
-        "description": "felicity.apps.auditlog.entities",
-        "isExtraImport": true,
-        "detail": "felicity.apps.auditlog.entities",
-        "documentation": {}
-    },
-    {
-        "label": "AuditLog",
-        "importPath": "felicity.apps.auditlog.entities",
-        "description": "felicity.apps.auditlog.entities",
-        "isExtraImport": true,
-        "detail": "felicity.apps.auditlog.entities",
-        "documentation": {}
-    },
-    {
-        "label": "AuditLog",
-        "importPath": "felicity.apps.auditlog.entities",
-        "description": "felicity.apps.auditlog.entities",
-        "isExtraImport": true,
-        "detail": "felicity.apps.auditlog.entities",
-        "documentation": {}
-    },
-    {
-        "label": "AuditLog",
-        "importPath": "felicity.apps.auditlog.entities",
-        "description": "felicity.apps.auditlog.entities",
-        "isExtraImport": true,
-        "detail": "felicity.apps.auditlog.entities",
-        "documentation": {}
-    },
-    {
-        "label": "AuditLogRepository",
-        "importPath": "felicity.apps.auditlog.repositories",
-        "description": "felicity.apps.auditlog.repositories",
-        "isExtraImport": true,
-        "detail": "felicity.apps.auditlog.repositories",
-        "documentation": {}
-    },
-    {
-        "label": "JSONB",
-        "importPath": "sqlalchemy.dialects.postgresql",
-        "description": "sqlalchemy.dialects.postgresql",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.dialects.postgresql",
-        "documentation": {}
-    },
     {
         "label": "JSONB",
         "importPath": "sqlalchemy.dialects.postgresql",
@@ -18981,6 +18813,14 @@
         "detail": "felicity.apps.client.schemas",
         "documentation": {}
     },
+    {
+        "label": "AuditLog",
+        "importPath": "felicity.apps.auditlog.entities",
+        "description": "felicity.apps.auditlog.entities",
+        "isExtraImport": true,
+        "detail": "felicity.apps.auditlog.entities",
+        "documentation": {}
+    },
     {
         "label": "enum",
         "importPath": "felicity.apps.common.hooks",
@@ -18990,59 +18830,11 @@
         "documentation": {}
     },
     {
-        "label": "asynccontextmanager",
-        "importPath": "contextlib",
-        "description": "contextlib",
+        "label": "Broadcast",
+        "importPath": "broadcaster",
+        "description": "broadcaster",
         "isExtraImport": true,
-        "detail": "contextlib",
-        "documentation": {}
-    },
-    {
-        "label": "asynccontextmanager",
-        "importPath": "contextlib",
-        "description": "contextlib",
-        "isExtraImport": true,
-        "detail": "contextlib",
-        "documentation": {}
-    },
-    {
-        "label": "ErrorLog",
-        "importPath": "felicity.apps.errlog.entities",
-        "description": "felicity.apps.errlog.entities",
-        "isExtraImport": true,
-        "detail": "felicity.apps.errlog.entities",
-        "documentation": {}
-    },
-    {
-        "label": "ErrorLog",
-        "importPath": "felicity.apps.errlog.entities",
-        "description": "felicity.apps.errlog.entities",
-        "isExtraImport": true,
-        "detail": "felicity.apps.errlog.entities",
-        "documentation": {}
-    },
-    {
-        "label": "ErrorLogRepository",
-        "importPath": "felicity.apps.errlog.repositories",
-        "description": "felicity.apps.errlog.repositories",
-        "isExtraImport": true,
-        "detail": "felicity.apps.errlog.repositories",
-        "documentation": {}
-    },
-    {
-        "label": "ErrorLogCreate",
-        "importPath": "felicity.apps.errlog.schemas",
-        "description": "felicity.apps.errlog.schemas",
-        "isExtraImport": true,
-        "detail": "felicity.apps.errlog.schemas",
-        "documentation": {}
-    },
-    {
-        "label": "ErrorLogUpdate",
-        "importPath": "felicity.apps.errlog.schemas",
-        "description": "felicity.apps.errlog.schemas",
-        "isExtraImport": true,
-        "detail": "felicity.apps.errlog.schemas",
+        "detail": "broadcaster",
         "documentation": {}
     },
     {
@@ -20230,6 +20022,39 @@
         "detail": "felicity.apps.shipment.entities",
         "documentation": {}
     },
+    {
+        "label": "meilisearch",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "meilisearch",
+        "description": "meilisearch",
+        "detail": "meilisearch",
+        "documentation": {}
+    },
+    {
+        "label": "marshaller",
+        "importPath": "apps.common.utils.serializer",
+        "description": "apps.common.utils.serializer",
+        "isExtraImport": true,
+        "detail": "apps.common.utils.serializer",
+        "documentation": {}
+    },
+    {
+        "label": "marshaller",
+        "importPath": "apps.common.utils.serializer",
+        "description": "apps.common.utils.serializer",
+        "isExtraImport": true,
+        "detail": "apps.common.utils.serializer",
+        "documentation": {}
+    },
+    {
+        "label": "MeiliSearchClient",
+        "importPath": "apps.iol.meilisearch.client",
+        "description": "apps.iol.meilisearch.client",
+        "isExtraImport": true,
+        "detail": "apps.iol.meilisearch.client",
+        "documentation": {}
+    },
     {
         "label": "Minio",
         "importPath": "minio",
@@ -21449,6 +21274,14 @@
         "detail": "felicity.apps.worksheet.schemas",
         "documentation": {}
     },
+    {
+        "label": "init_entity_tracker_events",
+        "importPath": "felicity.apps.abstract.events",
+        "description": "felicity.apps.abstract.events",
+        "isExtraImport": true,
+        "detail": "felicity.apps.abstract.events",
+        "documentation": {}
+    },
     {
         "label": "init_user_events",
         "importPath": "felicity.apps.user.events",
@@ -21490,6 +21323,14 @@
         "detail": "threading",
         "documentation": {}
     },
+    {
+        "label": "Lock",
+        "importPath": "threading",
+        "description": "threading",
+        "isExtraImport": true,
+        "detail": "threading",
+        "documentation": {}
+    },
     {
         "label": "Celery",
         "importPath": "celery",
@@ -21555,6 +21396,15 @@
         "detail": "felicity.utils.env",
         "documentation": {}
     },
+    {
+        "label": "traceback",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "traceback",
+        "description": "traceback",
+        "detail": "traceback",
+        "documentation": {}
+    },
     {
         "label": "format_exception",
         "importPath": "traceback",
@@ -21563,6 +21413,22 @@
         "detail": "traceback",
         "documentation": {}
     },
+    {
+        "label": "ThreadPoolExecutor",
+        "importPath": "concurrent.futures",
+        "description": "concurrent.futures",
+        "isExtraImport": true,
+        "detail": "concurrent.futures",
+        "documentation": {}
+    },
+    {
+        "label": "as_completed",
+        "importPath": "concurrent.futures",
+        "description": "concurrent.futures",
+        "isExtraImport": true,
+        "detail": "concurrent.futures",
+        "documentation": {}
+    },
     {
         "label": "run_in_threadpool",
         "importPath": "starlette.concurrency",
@@ -21587,62 +21453,6 @@
         "detail": "passlib.context",
         "documentation": {}
     },
-    {
-        "label": "OrderedDict",
-        "importPath": "collections",
-        "description": "collections",
-        "isExtraImport": true,
-        "detail": "collections",
-        "documentation": {}
-    },
-    {
-        "label": "abc",
-        "importPath": "collections",
-        "description": "collections",
-        "isExtraImport": true,
-        "detail": "collections",
-        "documentation": {}
-    },
-    {
-        "label": "hybrid_method",
-        "importPath": "sqlalchemy.ext.hybrid",
-        "description": "sqlalchemy.ext.hybrid",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.ext.hybrid",
-        "documentation": {}
-    },
-    {
-        "label": "hybrid_property",
-        "importPath": "sqlalchemy.ext.hybrid",
-        "description": "sqlalchemy.ext.hybrid",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.ext.hybrid",
-        "documentation": {}
-    },
-    {
-        "label": "hybrid_method",
-        "importPath": "sqlalchemy.ext.hybrid",
-        "description": "sqlalchemy.ext.hybrid",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.ext.hybrid",
-        "documentation": {}
-    },
-    {
-        "label": "InstanceState",
-        "importPath": "sqlalchemy.orm.state",
-        "description": "sqlalchemy.orm.state",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.orm.state",
-        "documentation": {}
-    },
-    {
-        "label": "AliasedClass",
-        "importPath": "sqlalchemy.orm.util",
-        "description": "sqlalchemy.orm.util",
-        "isExtraImport": true,
-        "detail": "sqlalchemy.orm.util",
-        "documentation": {}
-    },
     {
         "label": "ObjectId",
         "importPath": "bson",
@@ -21676,6 +21486,14 @@
         "detail": "sqlalchemy.orm.base",
         "documentation": {}
     },
+    {
+        "label": "hybrid_method",
+        "importPath": "sqlalchemy.ext.hybrid",
+        "description": "sqlalchemy.ext.hybrid",
+        "isExtraImport": true,
+        "detail": "sqlalchemy.ext.hybrid",
+        "documentation": {}
+    },
     {
         "label": "Session",
         "importPath": "sqlalchemy.orm.session",
@@ -21724,6 +21542,14 @@
         "detail": "tenacity",
         "documentation": {}
     },
+    {
+        "label": "asynccontextmanager",
+        "importPath": "contextlib",
+        "description": "contextlib",
+        "isExtraImport": true,
+        "detail": "contextlib",
+        "documentation": {}
+    },
     {
         "label": "trace",
         "importPath": "opentelemetry",
@@ -21733,7 +21559,7 @@
         "documentation": {}
     },
     {
-        "label": "\\",
+        "label": "OTLPSpanExporter",
         "importPath": "opentelemetry.exporter.otlp.proto.grpc.trace_exporter",
         "description": "opentelemetry.exporter.otlp.proto.grpc.trace_exporter",
         "isExtraImport": true,
@@ -23310,7 +23136,7 @@
         "kind": 6,
         "importPath": "felicity.api.gql.audit.query",
         "description": "felicity.api.gql.audit.query",
-        "peekOfCode": "class AuditLogQuery:\n    @strawberry.field(permission_classes=[IsAuthenticated])\n    async def audit_logs_filter(\n        self, info, target_type: str, target_id: str\n    ) -> List[AuditLogType]:\n        return await AuditLogService().get_all(\n            target_type=target_type, target_id=target_id\n        )",
+        "peekOfCode": "class AuditLogQuery:\n    @strawberry.field(permission_classes=[IsAuthenticated])\n    async def audit_logs_filter(\n            self, info, target_type: str, target_uid: str\n    ) -> List[AuditLogType] | None:\n        documents = await MongoService().search(\n            MongoCollection.AUDIT_LOG,\n            filters={\n                \"target_type\": target_type,\n                \"target_uid\": target_uid",
         "detail": "felicity.api.gql.audit.query",
         "documentation": {}
     },
@@ -23319,7 +23145,7 @@
         "kind": 6,
         "importPath": "felicity.api.gql.audit.types",
         "description": "felicity.api.gql.audit.types",
-        "peekOfCode": "class AuditLogType:\n    uid: str\n    user_id: str | None = None\n    target_type: str | None = None\n    target_id: str | None = None\n    action: int | None = None\n    state_before: Optional[Text] = None\n    state_after: Optional[Text] = None",
+        "peekOfCode": "class AuditLogType:\n    uid: str\n    user_uid: str | None = None\n    target_type: str | None = None\n    target_uid: str | None = None\n    action: int | None = None\n    state_before: Optional[JSONScalar] = None\n    state_after: Optional[JSONScalar] = None",
         "detail": "felicity.api.gql.audit.types",
         "documentation": {}
     },
@@ -24642,7 +24468,7 @@
         "kind": 6,
         "importPath": "felicity.api.gql.notification.subscription",
         "description": "felicity.api.gql.notification.subscription",
-        "peekOfCode": "class StreamSubscription:\n    @strawberry.subscription()  # permission_classes=[IsAuthenticated]\n    async def latest_activity(self) -> AsyncGenerator[ActivityStreamType, None]:  # noqa\n        subscriber: Subscriber\n        async with broadcast.subscribe(channel=\"activities\") as subscriber:\n            logger.info(\"Subscribed\")\n            event: BroadcastEvent\n            try:\n                async for event in subscriber:\n                    logger.info(event)",
+        "peekOfCode": "class StreamSubscription:\n    @strawberry.subscription()  # permission_classes=[IsAuthenticated]\n    async def latest_activity(self) -> AsyncGenerator[ActivityStreamType, None]:  # noqa\n        async with broadcast.subscribe(channel=\"activities\") as subscriber:\n            logger.info(\"Subscribed\")\n            try:\n                async for event in subscriber:\n                    logger.info(event)\n                    yield ActivityStreamType(**json.loads(event.message))\n            finally:",
         "detail": "felicity.api.gql.notification.subscription",
         "documentation": {}
     },
@@ -24651,7 +24477,7 @@
         "kind": 5,
         "importPath": "felicity.api.gql.notification.subscription",
         "description": "felicity.api.gql.notification.subscription",
-        "peekOfCode": "logger = logging.getLogger(__name__)\n@strawberry.type\nclass StreamSubscription:\n    @strawberry.subscription()  # permission_classes=[IsAuthenticated]\n    async def latest_activity(self) -> AsyncGenerator[ActivityStreamType, None]:  # noqa\n        subscriber: Subscriber\n        async with broadcast.subscribe(channel=\"activities\") as subscriber:\n            logger.info(\"Subscribed\")\n            event: BroadcastEvent\n            try:",
+        "peekOfCode": "logger = logging.getLogger(__name__)\n@strawberry.type\nclass StreamSubscription:\n    @strawberry.subscription()  # permission_classes=[IsAuthenticated]\n    async def latest_activity(self) -> AsyncGenerator[ActivityStreamType, None]:  # noqa\n        async with broadcast.subscribe(channel=\"activities\") as subscriber:\n            logger.info(\"Subscribed\")\n            try:\n                async for event in subscriber:\n                    logger.info(event)",
         "detail": "felicity.api.gql.notification.subscription",
         "documentation": {}
     },
@@ -24669,7 +24495,7 @@
         "kind": 6,
         "importPath": "felicity.api.gql.notification.types",
         "description": "felicity.api.gql.notification.types",
-        "peekOfCode": "class ActivityFeedType:\n    uid: str\n    name: str\n    subscribers: list[UserType] | None = None\n@strawberry.type\nclass ActivityStreamType:\n    uid: str\n    feeds: Optional[List[ActivityFeedType]] = None\n    actor_uid: str | None = None\n    verb: str | None = None",
+        "peekOfCode": "class ActivityFeedType:\n    uid: str\n    name: str\n    subscribers: list[UserType] | None = None\n@strawberry.type\nclass ActivityStreamType:\n    uid: str\n    feeds: Optional[list[ActivityFeedType]] = None\n    actor_uid: str | None = None\n    verb: str | None = None",
         "detail": "felicity.api.gql.notification.types",
         "documentation": {}
     },
@@ -24678,7 +24504,7 @@
         "kind": 6,
         "importPath": "felicity.api.gql.notification.types",
         "description": "felicity.api.gql.notification.types",
-        "peekOfCode": "class ActivityStreamType:\n    uid: str\n    feeds: Optional[List[ActivityFeedType]] = None\n    actor_uid: str | None = None\n    verb: str | None = None\n    action_object_type: str | None = None\n    action_object_uid: str | None = None\n    target_uid: str | None = None\n    target: str | None = None\n    viewers: list[UserType] | None = None",
+        "peekOfCode": "class ActivityStreamType:\n    uid: str\n    feeds: Optional[list[ActivityFeedType]] = None\n    actor_uid: str | None = None\n    verb: str | None = None\n    action_object_type: str | None = None\n    action_object_uid: str | None = None\n    target_uid: str | None = None\n    target: str | None = None\n    viewers: list[UserType] | None = None",
         "detail": "felicity.api.gql.notification.types",
         "documentation": {}
     },
@@ -25686,7 +25512,7 @@
         "kind": 5,
         "importPath": "felicity.api.gql.types.generic",
         "description": "felicity.api.gql.types.generic",
-        "peekOfCode": "T = TypeVar(\"T\")\nJSONScalar = strawberry.scalar(\n    NewType(\"JSONScalar\", Any),\n    serialize=lambda v: v,\n    parse_value=lambda v: json.loads(v),\n    description=\"json field\",\n)\nclass BytesEncoder(json.JSONEncoder):\n    def default(self, obj):\n        if isinstance(obj, bytes):",
+        "peekOfCode": "T = TypeVar(\"T\")\nJSONScalar = strawberry.scalar(\n    NewType(\"JSONScalar\", Any),\n    serialize=lambda v: marshaller(v),\n    parse_value=lambda v: json.loads(v),\n    description=\"json field\",\n)\nclass BytesEncoder(json.JSONEncoder):\n    def default(self, obj):\n        if isinstance(obj, bytes):",
         "detail": "felicity.api.gql.types.generic",
         "documentation": {}
     },
@@ -25695,7 +25521,7 @@
         "kind": 5,
         "importPath": "felicity.api.gql.types.generic",
         "description": "felicity.api.gql.types.generic",
-        "peekOfCode": "JSONScalar = strawberry.scalar(\n    NewType(\"JSONScalar\", Any),\n    serialize=lambda v: v,\n    parse_value=lambda v: json.loads(v),\n    description=\"json field\",\n)\nclass BytesEncoder(json.JSONEncoder):\n    def default(self, obj):\n        if isinstance(obj, bytes):\n            return obj.decode(\"utf-8\")",
+        "peekOfCode": "JSONScalar = strawberry.scalar(\n    NewType(\"JSONScalar\", Any),\n    serialize=lambda v: marshaller(v),\n    parse_value=lambda v: json.loads(v),\n    description=\"json field\",\n)\nclass BytesEncoder(json.JSONEncoder):\n    def default(self, obj):\n        if isinstance(obj, bytes):\n            return obj.decode(\"utf-8\")",
         "detail": "felicity.api.gql.types.generic",
         "documentation": {}
     },
@@ -26325,7 +26151,7 @@
         "kind": 6,
         "importPath": "felicity.apps.abstract.audit",
         "description": "felicity.apps.abstract.audit",
-        "peekOfCode": "class AuditUser(BaseEntity, TrailMixin):\n    \"\"\"Track Actioners: creator and updater\"\"\"\n    __abstract__ = True\nclass AuditHistory(AuditUser, AuditHistoryMixin):\n    \"\"\"Track Model History -> Audit Log\"\"\"\n    __abstract__ = True",
+        "peekOfCode": "class AuditUser(BaseEntity, TrailMixin):\n    \"\"\"Track Actioners: creator and updater\"\"\"\n    __abstract__ = True\nclass AuditHistory(AuditUser, TrackableEntity):\n    \"\"\"Track Model Events\"\"\"\n    __abstract__ = True",
         "detail": "felicity.apps.abstract.audit",
         "documentation": {}
     },
@@ -26334,7 +26160,7 @@
         "kind": 6,
         "importPath": "felicity.apps.abstract.audit",
         "description": "felicity.apps.abstract.audit",
-        "peekOfCode": "class AuditHistory(AuditUser, AuditHistoryMixin):\n    \"\"\"Track Model History -> Audit Log\"\"\"\n    __abstract__ = True",
+        "peekOfCode": "class AuditHistory(AuditUser, TrackableEntity):\n    \"\"\"Track Model Events\"\"\"\n    __abstract__ = True",
         "detail": "felicity.apps.abstract.audit",
         "documentation": {}
     },
@@ -26365,6 +26191,33 @@
         "detail": "felicity.apps.abstract.entity",
         "documentation": {}
     },
+    {
+        "label": "meilisearch_tracker",
+        "kind": 2,
+        "importPath": "felicity.apps.abstract.events",
+        "description": "felicity.apps.abstract.events",
+        "peekOfCode": "def meilisearch_tracker(action: str, table_name: str, metadata):\n    logger.info(f\"Event fired: {action}:{table_name}\")\n    if not metadata:\n        return\n    if action == \"after-update\":\n        metadata = {\n            \"uid\": metadata[\"uid\"],\n            **metadata.get(\"state_after\")\n        }\n    MeilisearchSyncHandler().on_event(action, table_name, metadata)",
+        "detail": "felicity.apps.abstract.events",
+        "documentation": {}
+    },
+    {
+        "label": "init_entity_tracker_events",
+        "kind": 2,
+        "importPath": "felicity.apps.abstract.events",
+        "description": "felicity.apps.abstract.events",
+        "peekOfCode": "def init_entity_tracker_events():\n    subscribe(\"entity-tracker\", meilisearch_tracker)\n    subscribe(\"entity-tracker\", auditlog_tracker)",
+        "detail": "felicity.apps.abstract.events",
+        "documentation": {}
+    },
+    {
+        "label": "logger",
+        "kind": 5,
+        "importPath": "felicity.apps.abstract.events",
+        "description": "felicity.apps.abstract.events",
+        "peekOfCode": "logger = logging.getLogger(__name__)\ndef meilisearch_tracker(action: str, table_name: str, metadata):\n    logger.info(f\"Event fired: {action}:{table_name}\")\n    if not metadata:\n        return\n    if action == \"after-update\":\n        metadata = {\n            \"uid\": metadata[\"uid\"],\n            **metadata.get(\"state_after\")\n        }",
+        "detail": "felicity.apps.abstract.events",
+        "documentation": {}
+    },
     {
         "label": "BaseMPTT",
         "kind": 6,
@@ -26437,6 +26290,24 @@
         "detail": "felicity.apps.abstract.service",
         "documentation": {}
     },
+    {
+        "label": "TrackableEntity",
+        "kind": 6,
+        "importPath": "felicity.apps.abstract.trackable",
+        "description": "felicity.apps.abstract.trackable",
+        "peekOfCode": "class TrackableEntity:\n    \"\"\"Allow a model to be automatically tracked\"\"\"\n    @staticmethod\n    def put_out(action, table_name, metadata):\n        \"\"\"\"handle an event that something has happened\"\"\"\n        post_event(\n            event_type=\"entity-tracker\",\n            action=action,\n            table_name=table_name,\n            metadata=metadata",
+        "detail": "felicity.apps.abstract.trackable",
+        "documentation": {}
+    },
+    {
+        "label": "logger",
+        "kind": 5,
+        "importPath": "felicity.apps.abstract.trackable",
+        "description": "felicity.apps.abstract.trackable",
+        "peekOfCode": "logger = logging.getLogger(__name__)\nclass TrackableEntity:\n    \"\"\"Allow a model to be automatically tracked\"\"\"\n    @staticmethod\n    def put_out(action, table_name, metadata):\n        \"\"\"\"handle an event that something has happened\"\"\"\n        post_event(\n            event_type=\"entity-tracker\",\n            action=action,\n            table_name=table_name,",
+        "detail": "felicity.apps.abstract.trackable",
+        "documentation": {}
+    },
     {
         "label": "CodingStandard",
         "kind": 6,
@@ -28750,96 +28621,6 @@
         "detail": "felicity.apps.analytics.tasks",
         "documentation": {}
     },
-    {
-        "label": "AuditLog",
-        "kind": 6,
-        "importPath": "felicity.apps.auditlog.entities",
-        "description": "felicity.apps.auditlog.entities",
-        "peekOfCode": "class AuditLog(BaseEntity):\n    \"\"\"Model an audit log of user actions\"\"\"\n    __tablename__ = \"audit_log\"\n    user_id = Column(String, doc=\"The ID of the user who made the change\")\n    target_type = Column(\n        String(100), nullable=False, doc=\"The table name of the altered object\"\n    )\n    target_id = Column(String, doc=\"The ID of the altered object\")\n    action = Column(Integer, doc=\"Create (1), update (2), or delete (3)\")\n    state_before = Column(",
-        "detail": "felicity.apps.auditlog.entities",
-        "documentation": {}
-    },
-    {
-        "label": "AuditHistoryMixin",
-        "kind": 6,
-        "importPath": "felicity.apps.auditlog.mixin",
-        "description": "felicity.apps.auditlog.mixin",
-        "peekOfCode": "class AuditHistoryMixin:\n    \"\"\"Allow a model to be automatically audited\"\"\"\n    @staticmethod\n    def create_audit(connection, object_type, object_id, action, **kwargs):\n        audit = AuditLog(\n            object_type,\n            object_id,\n            action,\n            kwargs.get(\"state_before\"),\n            kwargs.get(\"state_after\"),",
-        "detail": "felicity.apps.auditlog.mixin",
-        "documentation": {}
-    },
-    {
-        "label": "custom_serial",
-        "kind": 2,
-        "importPath": "felicity.apps.auditlog.mixin",
-        "description": "felicity.apps.auditlog.mixin",
-        "peekOfCode": "def custom_serial(o):\n    if isinstance(o, (datetime.date, datetime.datetime)):\n        return o.isoformat()\n    raise TypeError(\"Type %s not serializable\" % type(o))\nclass AuditHistoryMixin:\n    \"\"\"Allow a model to be automatically audited\"\"\"\n    @staticmethod\n    def create_audit(connection, object_type, object_id, action, **kwargs):\n        audit = AuditLog(\n            object_type,",
-        "detail": "felicity.apps.auditlog.mixin",
-        "documentation": {}
-    },
-    {
-        "label": "logger",
-        "kind": 5,
-        "importPath": "felicity.apps.auditlog.mixin",
-        "description": "felicity.apps.auditlog.mixin",
-        "peekOfCode": "logger = logging.getLogger(__name__)\nACTION_CREATE = 1\nACTION_UPDATE = 2\nACTION_DELETE = 3\n# Only audit the events in this list\nPLEASE_AUDIT = [ACTION_UPDATE]\ndef custom_serial(o):\n    if isinstance(o, (datetime.date, datetime.datetime)):\n        return o.isoformat()\n    raise TypeError(\"Type %s not serializable\" % type(o))",
-        "detail": "felicity.apps.auditlog.mixin",
-        "documentation": {}
-    },
-    {
-        "label": "ACTION_CREATE",
-        "kind": 5,
-        "importPath": "felicity.apps.auditlog.mixin",
-        "description": "felicity.apps.auditlog.mixin",
-        "peekOfCode": "ACTION_CREATE = 1\nACTION_UPDATE = 2\nACTION_DELETE = 3\n# Only audit the events in this list\nPLEASE_AUDIT = [ACTION_UPDATE]\ndef custom_serial(o):\n    if isinstance(o, (datetime.date, datetime.datetime)):\n        return o.isoformat()\n    raise TypeError(\"Type %s not serializable\" % type(o))\nclass AuditHistoryMixin:",
-        "detail": "felicity.apps.auditlog.mixin",
-        "documentation": {}
-    },
-    {
-        "label": "ACTION_UPDATE",
-        "kind": 5,
-        "importPath": "felicity.apps.auditlog.mixin",
-        "description": "felicity.apps.auditlog.mixin",
-        "peekOfCode": "ACTION_UPDATE = 2\nACTION_DELETE = 3\n# Only audit the events in this list\nPLEASE_AUDIT = [ACTION_UPDATE]\ndef custom_serial(o):\n    if isinstance(o, (datetime.date, datetime.datetime)):\n        return o.isoformat()\n    raise TypeError(\"Type %s not serializable\" % type(o))\nclass AuditHistoryMixin:\n    \"\"\"Allow a model to be automatically audited\"\"\"",
-        "detail": "felicity.apps.auditlog.mixin",
-        "documentation": {}
-    },
-    {
-        "label": "ACTION_DELETE",
-        "kind": 5,
-        "importPath": "felicity.apps.auditlog.mixin",
-        "description": "felicity.apps.auditlog.mixin",
-        "peekOfCode": "ACTION_DELETE = 3\n# Only audit the events in this list\nPLEASE_AUDIT = [ACTION_UPDATE]\ndef custom_serial(o):\n    if isinstance(o, (datetime.date, datetime.datetime)):\n        return o.isoformat()\n    raise TypeError(\"Type %s not serializable\" % type(o))\nclass AuditHistoryMixin:\n    \"\"\"Allow a model to be automatically audited\"\"\"\n    @staticmethod",
-        "detail": "felicity.apps.auditlog.mixin",
-        "documentation": {}
-    },
-    {
-        "label": "PLEASE_AUDIT",
-        "kind": 5,
-        "importPath": "felicity.apps.auditlog.mixin",
-        "description": "felicity.apps.auditlog.mixin",
-        "peekOfCode": "PLEASE_AUDIT = [ACTION_UPDATE]\ndef custom_serial(o):\n    if isinstance(o, (datetime.date, datetime.datetime)):\n        return o.isoformat()\n    raise TypeError(\"Type %s not serializable\" % type(o))\nclass AuditHistoryMixin:\n    \"\"\"Allow a model to be automatically audited\"\"\"\n    @staticmethod\n    def create_audit(connection, object_type, object_id, action, **kwargs):\n        audit = AuditLog(",
-        "detail": "felicity.apps.auditlog.mixin",
-        "documentation": {}
-    },
-    {
-        "label": "AuditLogRepository",
-        "kind": 6,
-        "importPath": "felicity.apps.auditlog.repositories",
-        "description": "felicity.apps.auditlog.repositories",
-        "peekOfCode": "class AuditLogRepository(BaseRepository[AuditLog]):\n    def __init__(self) -> None:\n        super().__init__(AuditLog)",
-        "detail": "felicity.apps.auditlog.repositories",
-        "documentation": {}
-    },
-    {
-        "label": "AuditLogService",
-        "kind": 6,
-        "importPath": "felicity.apps.auditlog.services",
-        "description": "felicity.apps.auditlog.services",
-        "peekOfCode": "class AuditLogService(BaseService[AuditLog, Dummy, Dummy]):\n    def __init__(self) -> None:\n        super().__init__(AuditLogRepository)",
-        "detail": "felicity.apps.auditlog.services",
-        "documentation": {}
-    },
     {
         "label": "AnalysisPrice",
         "kind": 6,
@@ -29826,109 +29607,19 @@
         "kind": 2,
         "importPath": "felicity.apps.common.utils.serializer",
         "description": "felicity.apps.common.utils.serializer",
-        "peekOfCode": "def marshaller(\n    obj, path=None, memoize=None, exclude: list[str] = None, depth=2\n) -> dict | str:\n    \"\"\"Notes:\n    1. We use memoization To prevent marshalling the same object again hence speed things up\n    2. We use path tracking To stop marshalling when a path starts to repeat itself or meets a certain path restriction\n    \"\"\"\n    if memoize is None:\n        memoize = {}\n    if path is None:",
+        "peekOfCode": "def marshaller(\n        obj, path=None, memoize=None, exclude: list[str] = None, depth=2\n) -> dict | str:\n    \"\"\"\n    Custom marshaller function to convert objects to dictionaries or strings with proper handling for\n    StrEnum, datetime, and other custom objects.\n    \"\"\"\n    if memoize is None:\n        memoize = {}\n    if path is None:",
         "detail": "felicity.apps.common.utils.serializer",
         "documentation": {}
     },
-    {
-        "label": "BroadcastEvent",
-        "kind": 6,
-        "importPath": "felicity.apps.common.channel",
-        "description": "felicity.apps.common.channel",
-        "peekOfCode": "class BroadcastEvent:\n    channel: str\n    message: Any\n@dataclass\nclass Subscriber:\n    queue: \"Queue[BroadcastEvent]\" = field(default_factory=Queue)\n    async def __aiter__(self) -> AsyncIterator[BroadcastEvent]:\n        while True:\n            item = await self.get()\n            yield item",
-        "detail": "felicity.apps.common.channel",
-        "documentation": {}
-    },
-    {
-        "label": "Subscriber",
-        "kind": 6,
-        "importPath": "felicity.apps.common.channel",
-        "description": "felicity.apps.common.channel",
-        "peekOfCode": "class Subscriber:\n    queue: \"Queue[BroadcastEvent]\" = field(default_factory=Queue)\n    async def __aiter__(self) -> AsyncIterator[BroadcastEvent]:\n        while True:\n            item = await self.get()\n            yield item\n    async def get(self) -> BroadcastEvent:\n        item = await self.queue.get()\n        return item\n@dataclass",
-        "detail": "felicity.apps.common.channel",
-        "documentation": {}
-    },
-    {
-        "label": "Broadcast",
-        "kind": 6,
-        "importPath": "felicity.apps.common.channel",
-        "description": "felicity.apps.common.channel",
-        "peekOfCode": "class Broadcast:\n    subscribers: dict[str, Set[Queue]] = field(default_factory=dict)\n    published: Queue = Queue()\n    @asynccontextmanager\n    async def subscribe(self, channel: str) -> AsyncIterator[Subscriber]:\n        subscriber = Subscriber()\n        subscribers_set = self.subscribers.get(channel, set())\n        subscribers_set.add(subscriber.queue)\n        self.subscribers[channel] = subscribers_set\n        try:",
-        "detail": "felicity.apps.common.channel",
-        "documentation": {}
-    },
     {
         "label": "broadcast",
         "kind": 5,
         "importPath": "felicity.apps.common.channel",
         "description": "felicity.apps.common.channel",
-        "peekOfCode": "broadcast = Broadcast()",
+        "peekOfCode": "broadcast = Broadcast(f\"redis://{settings.REDIS_SERVER}\")",
         "detail": "felicity.apps.common.channel",
         "documentation": {}
     },
-    {
-        "label": "ErrorLog",
-        "kind": 6,
-        "importPath": "felicity.apps.errlog.entities",
-        "description": "felicity.apps.errlog.entities",
-        "peekOfCode": "class ErrorLog(AuditUser):\n    __tablename__ = \"error_log\"\n    content = Column(JSONB)",
-        "detail": "felicity.apps.errlog.entities",
-        "documentation": {}
-    },
-    {
-        "label": "ErrorLogRepository",
-        "kind": 6,
-        "importPath": "felicity.apps.errlog.repositories",
-        "description": "felicity.apps.errlog.repositories",
-        "peekOfCode": "class ErrorLogRepository(BaseRepository[ErrorLog]):\n    def __init__(self) -> None:\n        super().__init__(ErrorLog)",
-        "detail": "felicity.apps.errlog.repositories",
-        "documentation": {}
-    },
-    {
-        "label": "ErrorLogBase",
-        "kind": 6,
-        "importPath": "felicity.apps.errlog.schemas",
-        "description": "felicity.apps.errlog.schemas",
-        "peekOfCode": "class ErrorLogBase(BaseModel):\n    content: Optional[Any] = None\nclass ErrorLog(ErrorLogBase):\n    uid: str | None = None\n    model_config = ConfigDict(from_attributes=True)\nclass ErrorLogCreate(ErrorLogBase):\n    pass\nclass ErrorLogUpdate(ErrorLogBase):\n    pass",
-        "detail": "felicity.apps.errlog.schemas",
-        "documentation": {}
-    },
-    {
-        "label": "ErrorLog",
-        "kind": 6,
-        "importPath": "felicity.apps.errlog.schemas",
-        "description": "felicity.apps.errlog.schemas",
-        "peekOfCode": "class ErrorLog(ErrorLogBase):\n    uid: str | None = None\n    model_config = ConfigDict(from_attributes=True)\nclass ErrorLogCreate(ErrorLogBase):\n    pass\nclass ErrorLogUpdate(ErrorLogBase):\n    pass",
-        "detail": "felicity.apps.errlog.schemas",
-        "documentation": {}
-    },
-    {
-        "label": "ErrorLogCreate",
-        "kind": 6,
-        "importPath": "felicity.apps.errlog.schemas",
-        "description": "felicity.apps.errlog.schemas",
-        "peekOfCode": "class ErrorLogCreate(ErrorLogBase):\n    pass\nclass ErrorLogUpdate(ErrorLogBase):\n    pass",
-        "detail": "felicity.apps.errlog.schemas",
-        "documentation": {}
-    },
-    {
-        "label": "ErrorLogUpdate",
-        "kind": 6,
-        "importPath": "felicity.apps.errlog.schemas",
-        "description": "felicity.apps.errlog.schemas",
-        "peekOfCode": "class ErrorLogUpdate(ErrorLogBase):\n    pass",
-        "detail": "felicity.apps.errlog.schemas",
-        "documentation": {}
-    },
-    {
-        "label": "ErrorLogService",
-        "kind": 6,
-        "importPath": "felicity.apps.errlog.services",
-        "description": "felicity.apps.errlog.services",
-        "peekOfCode": "class ErrorLogService(BaseService[ErrorLog, ErrorLogCreate, ErrorLogUpdate]):\n    def __int__(self):\n        super().__init__(ErrorLogRepository)",
-        "detail": "felicity.apps.errlog.services",
-        "documentation": {}
-    },
     {
         "label": "Role",
         "kind": 6,
@@ -31945,12 +31636,57 @@
         "detail": "felicity.apps.iol.fhir.schema",
         "documentation": {}
     },
+    {
+        "label": "MeiliSearchClient",
+        "kind": 6,
+        "importPath": "felicity.apps.iol.meilisearch.client",
+        "description": "felicity.apps.iol.meilisearch.client",
+        "peekOfCode": "class MeiliSearchClient:\n    def __init__(self):\n        self.client = meilisearch.Client(settings.MEILISEARCH_SERVER, settings.MEILISEARCH_API_KEY)\n    def create_index(self, index_name: str):\n        logger.info(\"meilisearch -- create index --\")\n        return self.client.create_index(uid=index_name, options={\"primaryKey\": \"uid\"})\n    def add_documents(self, index_name: str, docs: list):\n        logger.info(\"meilisearch -- add documents --\")\n        index = self.client.index(index_name)\n        return index.add_documents(docs)",
+        "detail": "felicity.apps.iol.meilisearch.client",
+        "documentation": {}
+    },
+    {
+        "label": "logger",
+        "kind": 5,
+        "importPath": "felicity.apps.iol.meilisearch.client",
+        "description": "felicity.apps.iol.meilisearch.client",
+        "peekOfCode": "logger = logging.getLogger(__name__)\nclass MeiliSearchClient:\n    def __init__(self):\n        self.client = meilisearch.Client(settings.MEILISEARCH_SERVER, settings.MEILISEARCH_API_KEY)\n    def create_index(self, index_name: str):\n        logger.info(\"meilisearch -- create index --\")\n        return self.client.create_index(uid=index_name, options={\"primaryKey\": \"uid\"})\n    def add_documents(self, index_name: str, docs: list):\n        logger.info(\"meilisearch -- add documents --\")\n        index = self.client.index(index_name)",
+        "detail": "felicity.apps.iol.meilisearch.client",
+        "documentation": {}
+    },
+    {
+        "label": "CustomJSONEncoder",
+        "kind": 6,
+        "importPath": "felicity.apps.iol.meilisearch.handler",
+        "description": "felicity.apps.iol.meilisearch.handler",
+        "peekOfCode": "class CustomJSONEncoder(json.JSONEncoder):\n    def default(self, obj):\n        if isinstance(obj, StrEnum):\n            return obj.value  # Serialize StrEnum to its value\n        if isinstance(obj, datetime):\n            return obj.isoformat()  # Serialize datetime to ISO format string\n        return super().default(obj)\nclass MeilisearchSyncHandler:\n    def __init__(self):\n        self.client = MeiliSearchClient()",
+        "detail": "felicity.apps.iol.meilisearch.handler",
+        "documentation": {}
+    },
+    {
+        "label": "MeilisearchSyncHandler",
+        "kind": 6,
+        "importPath": "felicity.apps.iol.meilisearch.handler",
+        "description": "felicity.apps.iol.meilisearch.handler",
+        "peekOfCode": "class MeilisearchSyncHandler:\n    def __init__(self):\n        self.client = MeiliSearchClient()\n        self.tables_of_interest = {'sample', 'worksheet', \"result\"}\n    def should_sync(self, table_name: str):\n        return table_name in self.tables_of_interest\n    @staticmethod\n    def get_document(metadata):\n        return marshaller(metadata)\n    def on_event(self, event_type, table_name, tracked):",
+        "detail": "felicity.apps.iol.meilisearch.handler",
+        "documentation": {}
+    },
     {
         "label": "MinioClient",
         "kind": 6,
         "importPath": "felicity.apps.iol.minio.client",
         "description": "felicity.apps.iol.minio.client",
-        "peekOfCode": "class MinioClient:\n    def __init__(self):\n        self.client = Minio(\n            \"localhost:9000\",\n            access_key=\"felicity\",\n            secret_key=\"felicity\",\n            secure=False\n        )\n    def bucket_exists(self, bucket: MinioBucket):\n        return self.client.bucket_exists(bucket)",
+        "peekOfCode": "class MinioClient:\n    def __init__(self):\n        self.client = Minio(\n            endpoint=settings.MINIO_SERVER,\n            access_key=settings.MINIO_ACCESS,\n            secret_key=settings.MINIO_SECRET,\n            secure=False\n        )\n    def bucket_exists(self, bucket: MinioBucket):\n        return self.client.bucket_exists(bucket)",
+        "detail": "felicity.apps.iol.minio.client",
+        "documentation": {}
+    },
+    {
+        "label": "logger",
+        "kind": 5,
+        "importPath": "felicity.apps.iol.minio.client",
+        "description": "felicity.apps.iol.minio.client",
+        "peekOfCode": "logger = logging.getLogger(__name__)\nclass MinioClient:\n    def __init__(self):\n        self.client = Minio(\n            endpoint=settings.MINIO_SERVER,\n            access_key=settings.MINIO_ACCESS,\n            secret_key=settings.MINIO_SECRET,\n            secure=False\n        )\n    def bucket_exists(self, bucket: MinioBucket):",
         "detail": "felicity.apps.iol.minio.client",
         "documentation": {}
     },
@@ -32616,7 +32352,7 @@
         "kind": 6,
         "importPath": "felicity.apps.notification.services",
         "description": "felicity.apps.notification.services",
-        "peekOfCode": "class ActivityFeedService(\n    BaseService[ActivityFeed, ActivityFeedCreate, ActivityFeedUpdate]\n):\n    def __init__(self):\n        super().__init__(ActivityFeedRepository)\n    async def reset_subscribers(self, activity_feed: ActivityFeed) -> ActivityFeed:\n        activity_feed.subscribers.clear()\n        return await super().save(activity_feed)\n    async def remove_subscriber(\n        self, activity_feed: ActivityFeed, user: User",
+        "peekOfCode": "class ActivityFeedService(\n    BaseService[ActivityFeed, ActivityFeedCreate, ActivityFeedUpdate]\n):\n    def __init__(self):\n        super().__init__(ActivityFeedRepository)\n    async def reset_subscribers(self, activity_feed: ActivityFeed) -> ActivityFeed:\n        activity_feed.subscribers.clear()\n        return await super().save(activity_feed)\n    async def remove_subscriber(\n            self, activity_feed: ActivityFeed, user: User",
         "detail": "felicity.apps.notification.services",
         "documentation": {}
     },
@@ -32625,7 +32361,7 @@
         "kind": 6,
         "importPath": "felicity.apps.notification.services",
         "description": "felicity.apps.notification.services",
-        "peekOfCode": "class ActivityStreamService(\n    BaseService[ActivityStream, ActivityStreamCreate, ActivityStreamUpdate]\n):\n    def __init__(self):\n        super().__init__(ActivityStreamRepository)\n    async def stream(\n        self,\n        obj: Any,\n        actor: User,\n        verb: str,",
+        "peekOfCode": "class ActivityStreamService(\n    BaseService[ActivityStream, ActivityStreamCreate, ActivityStreamUpdate]\n):\n    def __init__(self):\n        super().__init__(ActivityStreamRepository)\n    async def stream(\n            self,\n            obj: Any,\n            actor: User,\n            verb: str,",
         "detail": "felicity.apps.notification.services",
         "documentation": {}
     },
@@ -32634,7 +32370,7 @@
         "kind": 6,
         "importPath": "felicity.apps.notification.services",
         "description": "felicity.apps.notification.services",
-        "peekOfCode": "class NotificationService(\n    BaseService[Notification, NotificationCreate, NotificationUpdate]\n):\n    def __init__(self):\n        super().__init__(NotificationRepository)\n    async def notify(self,message: str, users, departments=None, groups=None) -> None:\n        n_in = NotificationCreate(message=message)\n        notification = await super().create(n_in, related=[\"users\", \"departments\", \"groups\"])\n        if not isinstance(users, list):\n            users = [users]",
+        "peekOfCode": "class NotificationService(\n    BaseService[Notification, NotificationCreate, NotificationUpdate]\n):\n    def __init__(self):\n        super().__init__(NotificationRepository)\n    async def notify(self, message: str, users, departments=None, groups=None) -> None:\n        n_in = NotificationCreate(message=message)\n        notification = await super().create(n_in, related=[\"users\", \"departments\", \"groups\"])\n        if not isinstance(users, list):\n            users = [users]",
         "detail": "felicity.apps.notification.services",
         "documentation": {}
     },
@@ -35253,7 +34989,7 @@
         "kind": 2,
         "importPath": "felicity.apps.events",
         "description": "felicity.apps.events",
-        "peekOfCode": "def observe_events():\n    init_user_events()",
+        "peekOfCode": "def observe_events():\n    init_user_events()\n    init_entity_tracker_events()",
         "detail": "felicity.apps.events",
         "documentation": {}
     },
@@ -35482,12 +35218,39 @@
         "detail": "felicity.core.dtz",
         "documentation": {}
     },
+    {
+        "label": "partition_functions",
+        "kind": 2,
+        "importPath": "felicity.core.events",
+        "description": "felicity.core.events",
+        "peekOfCode": "def partition_functions(functions: List[Callable[..., Any]]) -> (List[Callable[..., Any]], List[Callable[..., Any]]):\n    async_funcs = [fn for fn in functions if inspect.iscoroutinefunction(fn)]\n    sync_funcs = [fn for fn in functions if not inspect.iscoroutinefunction(fn)]\n    return async_funcs, sync_funcs\ndef get_or_create_event_loop() -> asyncio.AbstractEventLoop:\n    try:\n        return asyncio.get_event_loop()\n    except RuntimeError:\n        loop = asyncio.new_event_loop()\n        asyncio.set_event_loop(loop)",
+        "detail": "felicity.core.events",
+        "documentation": {}
+    },
+    {
+        "label": "get_or_create_event_loop",
+        "kind": 2,
+        "importPath": "felicity.core.events",
+        "description": "felicity.core.events",
+        "peekOfCode": "def get_or_create_event_loop() -> asyncio.AbstractEventLoop:\n    try:\n        return asyncio.get_event_loop()\n    except RuntimeError:\n        loop = asyncio.new_event_loop()\n        asyncio.set_event_loop(loop)\n        return loop\n# Synchronous Event System\ndef subscribe(event_type: str, fn: Callable[..., Any]) -> None:\n    with sync_lock:",
+        "detail": "felicity.core.events",
+        "documentation": {}
+    },
     {
         "label": "subscribe",
         "kind": 2,
         "importPath": "felicity.core.events",
         "description": "felicity.core.events",
-        "peekOfCode": "def subscribe(event_type: str, fn: Callable):\n    if event_type not in subscribers:\n        subscribers[event_type] = []\n    subscribers[event_type].append(fn)\ndef post_event(event_type: str, **kwargs):\n    if event_type not in subscribers:\n        return\n    for fn in subscribers[event_type]:\n        fn(**kwargs)",
+        "peekOfCode": "def subscribe(event_type: str, fn: Callable[..., Any]) -> None:\n    with sync_lock:\n        subscribers.setdefault(event_type, []).append(fn)\ndef unsubscribe(event_type: str, fn: Callable[..., Any]) -> None:\n    with sync_lock:\n        if event_type in subscribers:\n            try:\n                subscribers[event_type].remove(fn)\n            except ValueError:\n                logger.error(",
+        "detail": "felicity.core.events",
+        "documentation": {}
+    },
+    {
+        "label": "unsubscribe",
+        "kind": 2,
+        "importPath": "felicity.core.events",
+        "description": "felicity.core.events",
+        "peekOfCode": "def unsubscribe(event_type: str, fn: Callable[..., Any]) -> None:\n    with sync_lock:\n        if event_type in subscribers:\n            try:\n                subscribers[event_type].remove(fn)\n            except ValueError:\n                logger.error(\n                    f\"Function not found in subscribers for event type: {event_type}\\n{traceback.format_exc()}\")\ndef post_event(event_type: str, **kwargs: Any) -> None:\n    with sync_lock:",
         "detail": "felicity.core.events",
         "documentation": {}
     },
@@ -35496,16 +35259,43 @@
         "kind": 2,
         "importPath": "felicity.core.events",
         "description": "felicity.core.events",
-        "peekOfCode": "def post_event(event_type: str, **kwargs):\n    if event_type not in subscribers:\n        return\n    for fn in subscribers[event_type]:\n        fn(**kwargs)",
+        "peekOfCode": "def post_event(event_type: str, **kwargs: Any) -> None:\n    with sync_lock:\n        current_subscribers = subscribers.get(event_type, [])\n    # Separate sync from async functions\n    async_funcs, sync_funcs = partition_functions(current_subscribers)\n    # Handle async functions\n    loop = get_or_create_event_loop()\n    for fn in async_funcs:\n        if loop.is_running():\n            loop.create_task(fn(**kwargs))",
         "detail": "felicity.core.events",
         "documentation": {}
     },
     {
-        "label": "subscribers",
+        "label": "safe_execute",
+        "kind": 2,
+        "importPath": "felicity.core.events",
+        "description": "felicity.core.events",
+        "peekOfCode": "def safe_execute(fn: Callable[..., Any], **kwargs: Any) -> None:\n    try:\n        fn(**kwargs)\n    except Exception as e:\n        logger.error(f\"Error in event subscriber {fn.__name__}: {e}\\n{traceback.format_exc()}\")\n# Asynchronous Event System\nasync def asubscribe(event_type: str, fn: Callable[..., Any]) -> None:\n    async with async_lock:\n        subscribers.setdefault(event_type, []).append(fn)\nasync def aunsubscribe(event_type: str, fn: Callable[..., Any]) -> None:",
+        "detail": "felicity.core.events",
+        "documentation": {}
+    },
+    {
+        "label": "logger",
         "kind": 5,
         "importPath": "felicity.core.events",
         "description": "felicity.core.events",
-        "peekOfCode": "subscribers = dict()\ndef subscribe(event_type: str, fn: Callable):\n    if event_type not in subscribers:\n        subscribers[event_type] = []\n    subscribers[event_type].append(fn)\ndef post_event(event_type: str, **kwargs):\n    if event_type not in subscribers:\n        return\n    for fn in subscribers[event_type]:\n        fn(**kwargs)",
+        "peekOfCode": "logger = logging.getLogger(__name__)\nsubscribers: Dict[str, List[Callable[..., Any]]] = {}\nsync_lock = Lock()  # Synchronous lock\nasync_lock = ALock()  # Asynchronous lock\ndef partition_functions(functions: List[Callable[..., Any]]) -> (List[Callable[..., Any]], List[Callable[..., Any]]):\n    async_funcs = [fn for fn in functions if inspect.iscoroutinefunction(fn)]\n    sync_funcs = [fn for fn in functions if not inspect.iscoroutinefunction(fn)]\n    return async_funcs, sync_funcs\ndef get_or_create_event_loop() -> asyncio.AbstractEventLoop:\n    try:",
+        "detail": "felicity.core.events",
+        "documentation": {}
+    },
+    {
+        "label": "sync_lock",
+        "kind": 5,
+        "importPath": "felicity.core.events",
+        "description": "felicity.core.events",
+        "peekOfCode": "sync_lock = Lock()  # Synchronous lock\nasync_lock = ALock()  # Asynchronous lock\ndef partition_functions(functions: List[Callable[..., Any]]) -> (List[Callable[..., Any]], List[Callable[..., Any]]):\n    async_funcs = [fn for fn in functions if inspect.iscoroutinefunction(fn)]\n    sync_funcs = [fn for fn in functions if not inspect.iscoroutinefunction(fn)]\n    return async_funcs, sync_funcs\ndef get_or_create_event_loop() -> asyncio.AbstractEventLoop:\n    try:\n        return asyncio.get_event_loop()\n    except RuntimeError:",
+        "detail": "felicity.core.events",
+        "documentation": {}
+    },
+    {
+        "label": "async_lock",
+        "kind": 5,
+        "importPath": "felicity.core.events",
+        "description": "felicity.core.events",
+        "peekOfCode": "async_lock = ALock()  # Asynchronous lock\ndef partition_functions(functions: List[Callable[..., Any]]) -> (List[Callable[..., Any]], List[Callable[..., Any]]):\n    async_funcs = [fn for fn in functions if inspect.iscoroutinefunction(fn)]\n    sync_funcs = [fn for fn in functions if not inspect.iscoroutinefunction(fn)]\n    return async_funcs, sync_funcs\ndef get_or_create_event_loop() -> asyncio.AbstractEventLoop:\n    try:\n        return asyncio.get_event_loop()\n    except RuntimeError:\n        loop = asyncio.new_event_loop()",
         "detail": "felicity.core.events",
         "documentation": {}
     },
@@ -35662,228 +35452,12 @@
         "detail": "felicity.core.security",
         "documentation": {}
     },
-    {
-        "label": "ModelNotFoundError",
-        "kind": 6,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "class ModelNotFoundError(ValueError):\n    pass\ndef _flatten_filter_keys(filters):\n    \"\"\"\n    :type filters: dict|list\n    Flatten the nested filters, extracting keys where they correspond\n    to smart_query paths, e.g.\n    {or_: {'id__gt': 1000, and_ : {\n        'id__lt': 500,\n        'related___property__in': (1,2,3)",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "QueryBuilder",
-        "kind": 6,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "class QueryBuilder:\n    def __init__(self, model: M) -> None:\n        self.model = model\n    @property\n    def query(self):\n        return select(self.model)\n    def with_(self, schema):\n        \"\"\"\n        Query class and eager load schema at once.\n        :type schema: dict",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "filter_expr",
-        "kind": 2,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "def filter_expr(model, **filters):\n    \"\"\"\n    forms expressions like [Product.age_from = 5,\n                            Product.subject_ids.in_([1,2])]\n    from filters like {'age_from': 5, 'subject_ids__in': [1,2]}\n    Example 1:\n        db.query(Product).filter(\n            *Product.filter_expr(age_from = 5, subject_ids__in=[1, 2]))\n    Example 2:\n        filters = {'age_from': 5, 'subject_ids__in': [1,2]}",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "smart_query",
-        "kind": 2,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "def smart_query(query, filters=None, sort_attrs=None, schema=None):\n    \"\"\"\n    Does magic Django-ish joins like post___user___name__startswith='Bob'\n     (see https://goo.gl/jAgCyM)\n    Does filtering, sorting and eager loading at the same time.\n    And if, say, filters and sorting need the same joinm it will be done\n     only one. That's why all stuff is combined in single method\n    :param query: sqlalchemy.orm.query.Query\n    :param filters: dict\n    :param sort_attrs: List[basestring]",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "eager_expr",
-        "kind": 2,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "def eager_expr(schema):\n    \"\"\"\n    :type schema: dict\n    \"\"\"\n    return _eager_expr_from_schema(schema)\ndef _flatten_schema(schema):\n    \"\"\"\n    :type schema: dict\n    \"\"\"\n    def _flatten(schema, parent_path, result):",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "order_expr",
-        "kind": 2,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "def order_expr(model, *columns):\n    \"\"\"\n    Forms expressions like [desc(User.first_name), asc(User.phone)]\n      from list like ['-first_name', 'phone']\n    Example for 1 column:\n      db.query(User).order_by(*User.order_expr('-first_name'))\n      # will compile to ORDER BY user.first_name DESC\n    Example for multiple columns:\n      columns = ['-first_name', 'phone']\n      db.query(User).order_by(*User.order_expr(*columns))",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "columns",
-        "kind": 2,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "def columns(model):\n    \"\"\"classproperty\"\"\"\n    cls = _klass(model)\n    return inspect(cls).columns.keys()\ndef primary_keys_full(model):\n    \"\"\"classproperty\n    Get primary key properties for a SQLAlchemy cls.\n    Taken from marshmallow_sqlalchemy\n    \"\"\"\n    cls = _klass(model)",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "primary_keys_full",
-        "kind": 2,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "def primary_keys_full(model):\n    \"\"\"classproperty\n    Get primary key properties for a SQLAlchemy cls.\n    Taken from marshmallow_sqlalchemy\n    \"\"\"\n    cls = _klass(model)\n    mapper = cls.__mapper__\n    return [mapper.get_property_by_column(column) for column in mapper.primary_key]\ndef primary_keys(model):\n    \"\"\"classproperty\"\"\"",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "primary_keys",
-        "kind": 2,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "def primary_keys(model):\n    \"\"\"classproperty\"\"\"\n    cls = _klass(model)\n    return [pk.key for pk in primary_keys_full(cls)]\ndef relations(model):\n    \"\"\"classproperty\n    Return a `list` of relationship names or the given model\"\"\"\n    cls = _klass(model)\n    return [c.key for c in cls.__mapper__.attrs if isinstance(c, RelationshipProperty)]\ndef settable_relations(model):",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "relations",
-        "kind": 2,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "def relations(model):\n    \"\"\"classproperty\n    Return a `list` of relationship names or the given model\"\"\"\n    cls = _klass(model)\n    return [c.key for c in cls.__mapper__.attrs if isinstance(c, RelationshipProperty)]\ndef settable_relations(model):\n    \"\"\"classproperty\n    Return a `list` of relationship names or the given model\"\"\"\n    cls = _klass(model)\n    return [r for r in relations(cls) if getattr(model, r).property.viewonly is False]",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "settable_relations",
-        "kind": 2,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "def settable_relations(model):\n    \"\"\"classproperty\n    Return a `list` of relationship names or the given model\"\"\"\n    cls = _klass(model)\n    return [r for r in relations(cls) if getattr(model, r).property.viewonly is False]\ndef hybrid_properties(model):\n    \"\"\"classproperty\"\"\"\n    cls = _klass(model)\n    items = inspect(cls).all_orm_descriptors\n    return [item.__name__ for item in items if isinstance(item, hybrid_property)]",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "hybrid_properties",
-        "kind": 2,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "def hybrid_properties(model):\n    \"\"\"classproperty\"\"\"\n    cls = _klass(model)\n    items = inspect(cls).all_orm_descriptors\n    return [item.__name__ for item in items if isinstance(item, hybrid_property)]\ndef hybrid_methods_full(model):\n    \"\"\"classproperty\"\"\"\n    cls = _klass(model)\n    items = inspect(cls).all_orm_descriptors\n    return {item.func.__name__: item for item in items if type(item) == hybrid_method}",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "hybrid_methods_full",
-        "kind": 2,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "def hybrid_methods_full(model):\n    \"\"\"classproperty\"\"\"\n    cls = _klass(model)\n    items = inspect(cls).all_orm_descriptors\n    return {item.func.__name__: item for item in items if type(item) == hybrid_method}\ndef hybrid_methods(model):\n    \"\"\"classproperty\"\"\"\n    cls = _klass(model)\n    return list(hybrid_methods_full(cls).keys())\ndef filterable_attributes(model):",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "hybrid_methods",
-        "kind": 2,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "def hybrid_methods(model):\n    \"\"\"classproperty\"\"\"\n    cls = _klass(model)\n    return list(hybrid_methods_full(cls).keys())\ndef filterable_attributes(model):\n    cls = _klass(model)\n    return relations(cls) + columns(cls) + hybrid_properties(cls) + hybrid_methods(cls)\ndef sortable_attributes(model):\n    cls = _klass(model)\n    return columns(cls) + hybrid_properties(cls)",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "filterable_attributes",
-        "kind": 2,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "def filterable_attributes(model):\n    cls = _klass(model)\n    return relations(cls) + columns(cls) + hybrid_properties(cls) + hybrid_methods(cls)\ndef sortable_attributes(model):\n    cls = _klass(model)\n    return columns(cls) + hybrid_properties(cls)\ndef settable_attributes(model):\n    cls = _klass(model)\n    return sortable_attributes(cls) + settable_relations(cls)\nclass QueryBuilder:",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "sortable_attributes",
-        "kind": 2,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "def sortable_attributes(model):\n    cls = _klass(model)\n    return columns(cls) + hybrid_properties(cls)\ndef settable_attributes(model):\n    cls = _klass(model)\n    return sortable_attributes(cls) + settable_relations(cls)\nclass QueryBuilder:\n    def __init__(self, model: M) -> None:\n        self.model = model\n    @property",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "settable_attributes",
-        "kind": 2,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "def settable_attributes(model):\n    cls = _klass(model)\n    return sortable_attributes(cls) + settable_relations(cls)\nclass QueryBuilder:\n    def __init__(self, model: M) -> None:\n        self.model = model\n    @property\n    def query(self):\n        return select(self.model)\n    def with_(self, schema):",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "M",
-        "kind": 5,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "M = TypeVar(\"M\")\nJOINED = \"joined\"\nSUBQUERY = \"subquery\"\nRELATION_SPLITTER = \"___\"\nOPERATOR_SPLITTER = \"__\"\nDESC_PREFIX = \"-\"\nclass ModelNotFoundError(ValueError):\n    pass\ndef _flatten_filter_keys(filters):\n    \"\"\"",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "JOINED",
-        "kind": 5,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "JOINED = \"joined\"\nSUBQUERY = \"subquery\"\nRELATION_SPLITTER = \"___\"\nOPERATOR_SPLITTER = \"__\"\nDESC_PREFIX = \"-\"\nclass ModelNotFoundError(ValueError):\n    pass\ndef _flatten_filter_keys(filters):\n    \"\"\"\n    :type filters: dict|list",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "SUBQUERY",
-        "kind": 5,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "SUBQUERY = \"subquery\"\nRELATION_SPLITTER = \"___\"\nOPERATOR_SPLITTER = \"__\"\nDESC_PREFIX = \"-\"\nclass ModelNotFoundError(ValueError):\n    pass\ndef _flatten_filter_keys(filters):\n    \"\"\"\n    :type filters: dict|list\n    Flatten the nested filters, extracting keys where they correspond",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "RELATION_SPLITTER",
-        "kind": 5,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "RELATION_SPLITTER = \"___\"\nOPERATOR_SPLITTER = \"__\"\nDESC_PREFIX = \"-\"\nclass ModelNotFoundError(ValueError):\n    pass\ndef _flatten_filter_keys(filters):\n    \"\"\"\n    :type filters: dict|list\n    Flatten the nested filters, extracting keys where they correspond\n    to smart_query paths, e.g.",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "OPERATOR_SPLITTER",
-        "kind": 5,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "OPERATOR_SPLITTER = \"__\"\nDESC_PREFIX = \"-\"\nclass ModelNotFoundError(ValueError):\n    pass\ndef _flatten_filter_keys(filters):\n    \"\"\"\n    :type filters: dict|list\n    Flatten the nested filters, extracting keys where they correspond\n    to smart_query paths, e.g.\n    {or_: {'id__gt': 1000, and_ : {",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "DESC_PREFIX",
-        "kind": 5,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "DESC_PREFIX = \"-\"\nclass ModelNotFoundError(ValueError):\n    pass\ndef _flatten_filter_keys(filters):\n    \"\"\"\n    :type filters: dict|list\n    Flatten the nested filters, extracting keys where they correspond\n    to smart_query paths, e.g.\n    {or_: {'id__gt': 1000, and_ : {\n        'id__lt': 500,",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
-    {
-        "label": "_operators",
-        "kind": 5,
-        "importPath": "felicity.database.queryset.builder",
-        "description": "felicity.database.queryset.builder",
-        "peekOfCode": "_operators = {\n    \"isnull\": lambda c, v: (c == None) if v else (c != None),\n    \"exact\": operators.eq,\n    \"ne\": operators.ne,  # not equal or is not (for None)\n    \"gt\": operators.gt,  # greater than , >\n    \"ge\": operators.ge,  # greater than or equal, >=\n    \"lt\": operators.lt,  # lower than, <\n    \"le\": operators.le,  # lower than or equal, <=\n    \"in\": operators.in_op,\n    \"notin\": operators.notin_op,",
-        "detail": "felicity.database.queryset.builder",
-        "documentation": {}
-    },
     {
         "label": "MongoCollection",
         "kind": 6,
         "importPath": "felicity.database.mongo",
         "description": "felicity.database.mongo",
-        "peekOfCode": "class MongoCollection(StrEnum):\n    DIAGNOSTIC_REPORT = \"diagnostic-report\"\n    INVOICE = \"invoice\"\nclass MongoService:\n    def __init__(self):\n        self.db = client.felicity\n    async def create(self, collection: MongoCollection, data: dict) -> Optional[dict]:\n        collection = self.db.get_collection(collection)\n        created = await collection.insert_one(data)\n        return await collection.find_one({\"_id\": created.inserted_id})",
+        "peekOfCode": "class MongoCollection(StrEnum):\n    DIAGNOSTIC_REPORT = \"diagnostic-report\"\n    INVOICE = \"invoice\"\n    AUDIT_LOG = \"audit-log\"\nclass MongoService:\n    def __init__(self):\n        self.db = client.felicity\n    async def create(self, collection: MongoCollection, data: dict) -> Optional[dict]:\n        logger.info(f\"mongodb -- create:{collection} --\")\n        collection = self.db.get_collection(collection)",
         "detail": "felicity.database.mongo",
         "documentation": {}
     },
@@ -35892,7 +35466,16 @@
         "kind": 6,
         "importPath": "felicity.database.mongo",
         "description": "felicity.database.mongo",
-        "peekOfCode": "class MongoService:\n    def __init__(self):\n        self.db = client.felicity\n    async def create(self, collection: MongoCollection, data: dict) -> Optional[dict]:\n        collection = self.db.get_collection(collection)\n        created = await collection.insert_one(data)\n        return await collection.find_one({\"_id\": created.inserted_id})\n    async def upsert(self, collection: MongoCollection, uid: str, data: dict) -> Optional[dict]:\n        collection = self.db.get_collection(collection)\n        result = await collection.update_one({'_id': self.oid(uid)}, {'$set': data}, upsert=True)",
+        "peekOfCode": "class MongoService:\n    def __init__(self):\n        self.db = client.felicity\n    async def create(self, collection: MongoCollection, data: dict) -> Optional[dict]:\n        logger.info(f\"mongodb -- create:{collection} --\")\n        collection = self.db.get_collection(collection)\n        created = await collection.insert_one(data)\n        return await collection.find_one({\"_id\": created.inserted_id})\n    async def upsert(self, collection: MongoCollection, uid: str, data: dict) -> Optional[dict]:\n        logger.info(f\"mongodb -- upsert:{collection} --\")",
+        "detail": "felicity.database.mongo",
+        "documentation": {}
+    },
+    {
+        "label": "logger",
+        "kind": 5,
+        "importPath": "felicity.database.mongo",
+        "description": "felicity.database.mongo",
+        "peekOfCode": "logger = logging.getLogger(__name__)\nclient = AsyncIOMotorClient(\n    f\"mongodb://{settings.MONGODB_USER}:{settings.MONGODB_PASS}@{settings.MONGODB_SERVER}\"\n)\nclass MongoCollection(StrEnum):\n    DIAGNOSTIC_REPORT = \"diagnostic-report\"\n    INVOICE = \"invoice\"\n    AUDIT_LOG = \"audit-log\"\nclass MongoService:\n    def __init__(self):",
         "detail": "felicity.database.mongo",
         "documentation": {}
     },
@@ -35901,7 +35484,7 @@
         "kind": 5,
         "importPath": "felicity.database.mongo",
         "description": "felicity.database.mongo",
-        "peekOfCode": "client = AsyncIOMotorClient(\"mongodb://felicity:felicity@localhost:27027\")\nclass MongoCollection(StrEnum):\n    DIAGNOSTIC_REPORT = \"diagnostic-report\"\n    INVOICE = \"invoice\"\nclass MongoService:\n    def __init__(self):\n        self.db = client.felicity\n    async def create(self, collection: MongoCollection, data: dict) -> Optional[dict]:\n        collection = self.db.get_collection(collection)\n        created = await collection.insert_one(data)",
+        "peekOfCode": "client = AsyncIOMotorClient(\n    f\"mongodb://{settings.MONGODB_USER}:{settings.MONGODB_PASS}@{settings.MONGODB_SERVER}\"\n)\nclass MongoCollection(StrEnum):\n    DIAGNOSTIC_REPORT = \"diagnostic-report\"\n    INVOICE = \"invoice\"\n    AUDIT_LOG = \"audit-log\"\nclass MongoService:\n    def __init__(self):\n        self.db = client.felicity",
         "detail": "felicity.database.mongo",
         "documentation": {}
     },
@@ -36333,7 +35916,7 @@
         "kind": 5,
         "importPath": "felicity.lims.boot",
         "description": "felicity.lims.boot",
-        "peekOfCode": "settings = get_settings()\n@asynccontextmanager\nasync def lifespan(app: FastAPI):\n    if settings.LOAD_SETUP_DATA:\n        await initialize_felicity()\n    # bg_tasks = BackgroundTasks(tasks=None)\n    # bg_tasks.add_task(felicity_workforce_init)\n    felicity_workforce_init()\n    observe_events()\n    #",
+        "peekOfCode": "settings = get_settings()\n@asynccontextmanager\nasync def lifespan(app: FastAPI):\n    if settings.LOAD_SETUP_DATA:\n        await initialize_felicity()\n    felicity_workforce_init()\n    observe_events()\n    await broadcast.connect()\n    #\n    yield",
         "detail": "felicity.lims.boot",
         "documentation": {}
     },
diff --git a/docker-compose.dev.yml b/docker-compose.dev.yml
index 4971b153..67035ae9 100644
--- a/docker-compose.dev.yml
+++ b/docker-compose.dev.yml
@@ -2,15 +2,15 @@ version: '3.5'
 
 services:
 
-  felicity_fe:
-    container_name: felicity_fe
+  felicity-webapp:
+    container_name: felicity-webapp
     restart: unless-stopped
     build:
       context: ./
       target: webapp
       dockerfile: Dockerfile.dev
     volumes:
-      - ./webapp:/app/webapp
+      - ./webapp/:/app/webapp
     environment:
       - NODE_ENV=development
       - VITE_NODE_ENV=development
@@ -19,49 +19,49 @@ services:
     ports:
       - "3000:3000"
     depends_on:
-      - felicity_pg
+      - felicity-postgres
     networks:
       - felicitynet
     command: bash -c "pnpm webapp:dev --host --port 3000"
 
-  felicity_be:
-    container_name: felicity_be
+  felicity-api:
+    container_name: felicity-api
     restart: unless-stopped
     build:
       context: ./
       target: webapi
       dockerfile: Dockerfile.dev
     environment:
-      - POSTGRES_SERVER=felicity_pg
+      - POSTGRES_SERVER=felicity-postgres
       - POSTGRES_DB=felicity_lims
       - POSTGRES_USER=felicity
       - POSTGRES_PASSWORD=felicity
       - POSTGRES_HOST_AUTH_METHOD=trust
       - LOAD_SETUP_DATA=${LOAD_SETUP_DATA:-False}
       - SERVE_WEBAPP=${SERVE_WEBAPP:-False}
-      - REDIS_SERVER=felicity_df:6379
-      - MONGODB_SERVER=felicity_mg:27027
+      - REDIS_SERVER=felicity-dragonfly:6379
+      - MONGODB_SERVER=felicity-mongo:27017
       - MONGODB_USER=felicity
       - MONGODB_PASS=felicity
-      - MINIO_SERVER=felicity_min:9000
+      - MINIO_SERVER=felicity-minio:9000
       - MINIO_ACCESS=felicity
       - MINIO_SECRET=felicity
-      - MEILISEARCH_SERVER=http://felicity_ms:7700
-      - MEILISEARCH_API_KEY=http:api_key
+      - MEILISEARCH_SERVER=http://felicity-meilisearch:7700
+      - MEILISEARCH_API_KEY=masterKey
     volumes:
       - ./felicity/:/app/felicity
     ports:
       - 8000:8000
     depends_on:
-      - felicity_pg
+      - felicity-postgres
     networks:
       - felicitynet
     extra_hosts:
       - "host.docker.internal:host-gateway"
-    command: bash -c "cd felicity && alembic upgrade head && uvicorn main:felicity --host=0.0.0.0 --port=8000"
+    command: bash -c "cd felicity && alembic upgrade head && uvicorn main:felicity --reload --host=0.0.0.0 --port=8000"
 
-  felicity_min:
-    container_name: felicity_min
+  felicity-minio:
+    container_name: felicity-minio
     image: bitnami/minio:2024.7.31
     ports:
       - '9000:9000'
@@ -75,8 +75,8 @@ services:
       - MINIO_ROOT_PASSWORD=felicity
       - MINIO_DEFAULT_BUCKET=felicity
 
-  felicity_ms:
-    container_name: felicity_ms
+  felicity-meilisearch:
+    container_name: felicity-meilisearch
     image: getmeili/meilisearch:v1.8.4
     restart: unless-stopped
     volumes:
@@ -94,8 +94,17 @@ services:
     networks:
       - felicitynet
 
-  felicity_df:
-    container_name: felicity_df
+  felicity-meiliui:
+    container_name: felicity-meiliui
+    image: riccoxie/meilisearch-ui:latest
+    restart: unless-stopped
+    ports:
+      - ${MEILI_UI_PORT:-24900}:24900
+    networks:
+      - felicitynet
+
+  felicity-dragonfly:
+    container_name: felicity-dragonfly
     image: 'docker.dragonflydb.io/dragonflydb/dragonfly'
     ulimits:
       memlock: -1
@@ -110,8 +119,8 @@ services:
     networks:
       - felicitynet
 
-  felicity_pg:
-    container_name: felicity_pg
+  felicity-postgres:
+    container_name: felicity-postgres
     image: postgres:12
     restart: unless-stopped
     environment:
@@ -129,8 +138,8 @@ services:
     networks:
       - felicitynet
 
-  felicity_mg:
-    container_name: felicity_mg
+  felicity-mongo:
+    container_name: felicity-mongo
     image: mongo
     restart: always
     environment:
@@ -141,8 +150,8 @@ services:
     networks:
       - felicitynet
 
-  felicity_dg:
-    container_name: felicity_dg
+  felicity-dbgate:
+    container_name: felicity-dbgate
     image: dbgate/dbgate
     restart: always
     ports:
@@ -154,7 +163,7 @@ services:
       PASSWORD: felicity
       CONNECTIONS: pg,mg
       LABEL_pg: Felicity Postgres
-      SERVER_pg: felicity_pg
+      SERVER_pg: felicity-postgres
       USER_pg: felicity
       PASSWORD_pg: felicity
       DATABASE_pg: felicity_lims
@@ -162,7 +171,7 @@ services:
       ENGINE_pg: postgres@dbgate-plugin-postgres
       READONLY_pg: 1
       LABEL_mg: Felicity Mongo
-      URL_mg: mongodb://felicity:felicity@felicity_mg:27017/
+      URL_mg: mongodb://felicity:felicity@felicity-mongo:27017/
       DATABASE_mg: felicity
       ENGINE_mg: mongo@dbgate-plugin-mongo
       READONLY_mg: 1
diff --git a/felicity/api/gql/analysis/mutations/analysis_request.py b/felicity/api/gql/analysis/mutations/analysis_request.py
index 289a02c5..12e8cb29 100644
--- a/felicity/api/gql/analysis/mutations/analysis_request.py
+++ b/felicity/api/gql/analysis/mutations/analysis_request.py
@@ -256,7 +256,7 @@ async def create_analysis_request(
 
         # initialise reflex action if exist
         logger.debug(f"ReflexUtil .... set_reflex_actions ...")
-        ReflexEngineService(created[0], felicity_user).set_reflex_actions(created)
+        await ReflexEngineService(created[0], felicity_user).set_reflex_actions(created)
 
     # ! paramount !
     await asyncio.sleep(1)
@@ -305,11 +305,13 @@ async def clone_samples(info, samples: List[str]) -> SampleActionResponse:
                     "status": ResultState.PENDING,
                 }
                 a_result_schema = schemas.AnalysisResultCreate(**a_result_in)
-                created = await AnalysisResultService().create(a_result_schema)
+                created = await AnalysisResultService().create(a_result_schema, related=["sample", "analysis"])
                 await ReflexEngineService(created, felicity_user).set_reflex_actions(
                     [created]
                 )
-
+    clones = [
+        (await SampleService().get_related(related=["sample_type"], uid=clone.uid)) for clone in clones
+    ]
     return SampleListingType(samples=clones)
 
 
@@ -482,11 +484,12 @@ async def publish_samples(
 
     # !important for frontend
     # unfreeze frontend and return sample to original state since it is a non final publish
-    ns_samples = await SampleService().get_by_uids([nf.uid for nf in not_final])
-    for sample in ns_samples:
-        await ActivityStreamService().stream(
-            sample, felicity_user, sample.status, "sample"
-        )
+    if not_final:
+        ns_samples = await SampleService().get_by_uids([nf.uid for nf in not_final])
+        for sample in ns_samples:
+            await ActivityStreamService().stream(
+                sample, felicity_user, sample.status, "sample"
+            )
 
     return OperationSuccess(
         message="Your results are being published in the background."
diff --git a/felicity/api/gql/audit/query.py b/felicity/api/gql/audit/query.py
index b6fa9ba8..8ca5d229 100644
--- a/felicity/api/gql/audit/query.py
+++ b/felicity/api/gql/audit/query.py
@@ -2,17 +2,29 @@ from typing import List
 
 import strawberry  # noqa
 
+from database.mongo import MongoService, MongoCollection
 from felicity.api.gql.audit.types import AuditLogType
 from felicity.api.gql.permissions import IsAuthenticated
-from felicity.apps.auditlog.services import AuditLogService
 
 
 @strawberry.type
 class AuditLogQuery:
     @strawberry.field(permission_classes=[IsAuthenticated])
     async def audit_logs_filter(
-        self, info, target_type: str, target_id: str
-    ) -> List[AuditLogType]:
-        return await AuditLogService().get_all(
-            target_type=target_type, target_id=target_id
+            self, info, target_type: str, target_uid: str
+    ) -> List[AuditLogType] | None:
+        documents = await MongoService().search(
+            MongoCollection.AUDIT_LOG,
+            filters={
+                "target_type": target_type,
+                "target_uid": target_uid
+            }
         )
+
+        def _log(doc: dict) -> AuditLogType:
+            print(type(doc))
+            doc["uid"] = doc["_id"]
+            del doc["_id"]
+            return AuditLogType(**doc)
+
+        return [_log(doc) for doc in documents] if documents else None
diff --git a/felicity/api/gql/audit/types.py b/felicity/api/gql/audit/types.py
index a5b33e1e..357b12d0 100644
--- a/felicity/api/gql/audit/types.py
+++ b/felicity/api/gql/audit/types.py
@@ -1,14 +1,16 @@
-from typing import Optional, Text
+from typing import Optional
 
 import strawberry  # noqa
 
+from felicity.api.gql.types import JSONScalar
+
 
 @strawberry.type
 class AuditLogType:
     uid: str
-    user_id: str | None = None
+    user_uid: str | None = None
     target_type: str | None = None
-    target_id: str | None = None
+    target_uid: str | None = None
     action: int | None = None
-    state_before: Optional[Text] = None
-    state_after: Optional[Text] = None
+    state_before: Optional[JSONScalar] = None
+    state_after: Optional[JSONScalar] = None
diff --git a/felicity/api/gql/notification/subscription.py b/felicity/api/gql/notification/subscription.py
index 9d7d3254..da55a9bd 100644
--- a/felicity/api/gql/notification/subscription.py
+++ b/felicity/api/gql/notification/subscription.py
@@ -1,11 +1,11 @@
 import asyncio
+import json
 import logging
 from typing import AsyncGenerator
 
 import strawberry  # noqa
 
 from felicity.api.gql.notification.types import ActivityStreamType
-# from felicity.api.gql.permissions import IsAuthenticated
 from felicity.apps.common.channel import broadcast
 from felicity.apps.notification.services import ActivityStreamService
 
@@ -22,7 +22,7 @@ class StreamSubscription:
             try:
                 async for event in subscriber:
                     logger.info(event)
-                    yield event.message
+                    yield ActivityStreamType(**json.loads(event.message))
             finally:
                 logger.info("Unsubscribed")
 
diff --git a/felicity/api/gql/notification/types.py b/felicity/api/gql/notification/types.py
index cf487a3c..64285dbf 100644
--- a/felicity/api/gql/notification/types.py
+++ b/felicity/api/gql/notification/types.py
@@ -1,4 +1,4 @@
-from typing import List, Optional, Union
+from typing import Optional, Union
 
 import strawberry  # noqa
 
@@ -37,7 +37,7 @@ class ActivityFeedType:
 @strawberry.type
 class ActivityStreamType:
     uid: str
-    feeds: Optional[List[ActivityFeedType]] = None
+    feeds: Optional[list[ActivityFeedType]] = None
     actor_uid: str | None = None
     verb: str | None = None
     action_object_type: str | None = None
@@ -48,6 +48,9 @@ class ActivityStreamType:
     created_at: str | None = None
     created_by_uid: str | None = None
     created_by: UserType | None = None
+    updated_at: str | None = None
+    updated_by_uid: str | None = None
+    updated_by: UserType | None = None
 
     @strawberry.field
     async def actor(self) -> UserType:
diff --git a/felicity/api/gql/types/generic.py b/felicity/api/gql/types/generic.py
index bdc55470..233abfdd 100644
--- a/felicity/api/gql/types/generic.py
+++ b/felicity/api/gql/types/generic.py
@@ -4,11 +4,13 @@ from typing import Any, Generic, NewType, TypeVar
 
 import strawberry
 
+from felicity.apps.common.utils.serializer import marshaller
+
 T = TypeVar("T")
 
 JSONScalar = strawberry.scalar(
     NewType("JSONScalar", Any),
-    serialize=lambda v: v,
+    serialize=lambda v: marshaller(v),
     parse_value=lambda v: json.loads(v),
     description="json field",
 )
diff --git a/felicity/apps/abstract/events.py b/felicity/apps/abstract/events.py
index d9feeeea..307b5801 100644
--- a/felicity/apps/abstract/events.py
+++ b/felicity/apps/abstract/events.py
@@ -1,11 +1,5 @@
-import datetime
-import json
 import logging
 
-from sqlalchemy import inspect
-from sqlalchemy.orm import class_mapper
-from sqlalchemy.orm.attributes import get_history
-
 from apps.iol.meilisearch.handler import MeilisearchSyncHandler
 from database.mongo import MongoService, MongoCollection
 from felicity.core.events import subscribe
@@ -14,75 +8,32 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-def custom_serial(o):
-    if isinstance(o, (datetime.date, datetime.datetime)):
-        return o.isoformat()
-
-    raise TypeError("Type %s not serializable" % type(o))
-
-
-def get_changes(target) -> dict:
-    state_before = {}
-    state_after = {}
-    inspector = inspect(target)
-    attrs = class_mapper(target.__class__).column_attrs
-
-    for attr in attrs:  # noqa
-        hist = getattr(inspector.attrs, attr.key).history
-        if hist.has_changes():
-            if isinstance(get_history(target, attr.key)[2], tuple):
-                continue
-            state_before[attr.key] = get_history(target, attr.key)[2].pop()
-            state_after[attr.key] = getattr(target, attr.key)
-        else:
-            if attr.key in ["updated_by_uid", "created_by_uid"]:
-                state_after[attr.key] = getattr(target, attr.key)
-                try:
-                    state_before[attr.key] = get_history(target, attr.key)[2].pop()
-                except Exception:  # noqa
-                    state_before[attr.key] = getattr(target, attr.key)
-
-    if len(state_after.keys()) == 1:
-        if "updated_at" in list(state_after.keys()):
-            return {}
-
-    return {
-        "uid": target.uid,
-        "state_before": json.dumps(state_before, default=custom_serial),
-        "state_after": json.dumps(state_after, default=custom_serial),
-    }
-
-
-def meilisearch_tracker(action: str, table_name: str, instance):
+def meilisearch_tracker(action: str, table_name: str, metadata):
     logger.info(f"Event fired: {action}:{table_name}")
-    data = instance
-    if action == "after-update":
-        changes = get_changes(instance)
-        data = {
-            "uid": changes["uid"],
-            **changes["state_after"]
-        }
-
-    if data:
-        MeilisearchSyncHandler().on_event(action, table_name, data)
-
-
-def auditlog_tracker(action: str, table_name: str, instance):
-    logger.info(f"Event fired: {action}:{table_name}")
-    if action != "after-update":
+    if not metadata:
         return
 
-    data = get_changes(instance)
-    if not data:
+    if action == "after-update":
+        metadata = {
+            "uid": metadata["uid"],
+            **metadata.get("state_after")
+        }
+
+    MeilisearchSyncHandler().on_event(action, table_name, metadata)
+
+
+async def auditlog_tracker(action: str, table_name: str, metadata):
+    logger.info(f"Event fired: {action}:{table_name}")
+    if action != "after-update" and not metadata:
         return
 
     update = {
-        **data,
-        "user_uid": data["state_after"].get("updated_by_uid", None),
+        **metadata,
+        "user_uid": metadata["state_after"].get("updated_by_uid", None),
         "target_type": table_name,
-        "target_id": instance.uid,
+        "target_uid": metadata.get("uid"),
     }
-    MongoService().create(MongoCollection.AUDIT_LOG, update)
+    await MongoService().create(MongoCollection.AUDIT_LOG, update)
 
 
 def init_entity_tracker_events():
diff --git a/felicity/apps/abstract/trackable.py b/felicity/apps/abstract/trackable.py
index 8acb8a5b..1738e942 100644
--- a/felicity/apps/abstract/trackable.py
+++ b/felicity/apps/abstract/trackable.py
@@ -1,7 +1,10 @@
 import logging
 
-from sqlalchemy import event
+from sqlalchemy import event, inspect
+from sqlalchemy.orm import class_mapper
+from sqlalchemy.orm.attributes import get_history
 
+from felicity.apps.common.utils.serializer import marshaller
 from felicity.core.events import post_event
 
 logging.basicConfig(level=logging.INFO)
@@ -12,13 +15,13 @@ class TrackableEntity:
     """Allow a model to be automatically tracked"""
 
     @staticmethod
-    def put_out(action, table_name, target):
+    def put_out(action, table_name, metadata):
         """"handle an event that something has happened"""
         post_event(
             event_type="entity-tracker",
             action=action,
             table_name=table_name,
-            instance=target
+            metadata=metadata
         )
 
     @classmethod
@@ -30,12 +33,44 @@ class TrackableEntity:
 
     @staticmethod
     def handle_insert(mapper, connection, target):
-        target.put_out("after-insert", target.__tablename__, target)
+        target.put_out("after-insert", target.__tablename__, marshaller(target))
 
     @staticmethod
     def handle_delete(mapper, connection, target):
-        target.put_out("after-delete", target.__tablename__, target)
+        target.put_out("after-delete", target.__tablename__, marshaller(target))
 
     @staticmethod
     def handle_update(mapper, connection, target):
-        target.put_out("after-update", target.__tablename__, target)
+        target.put_out("after-update", target.__tablename__, target.get_changes(target))
+
+    @staticmethod
+    def get_changes(target) -> dict:
+        state_before = {}
+        state_after = {}
+        inspector = inspect(target)
+        attrs = class_mapper(target.__class__).column_attrs
+
+        for attr in attrs:  # noqa
+            hist = getattr(inspector.attrs, attr.key).history
+            if hist.has_changes():
+                if isinstance(get_history(target, attr.key)[2], tuple):
+                    continue
+                state_before[attr.key] = get_history(target, attr.key)[2].pop()
+                state_after[attr.key] = getattr(target, attr.key)
+            else:
+                if attr.key in ["updated_by_uid", "created_by_uid"]:
+                    state_after[attr.key] = getattr(target, attr.key)
+                    try:
+                        state_before[attr.key] = get_history(target, attr.key)[2].pop()
+                    except Exception:  # noqa
+                        state_before[attr.key] = getattr(target, attr.key)
+
+        if len(state_after.keys()) == 1:
+            if "updated_at" in list(state_after.keys()):
+                return {}
+
+        return {
+            "uid": target.uid,
+            "state_before": state_before,
+            "state_after": state_after
+        }
diff --git a/felicity/apps/analysis/services/analysis.py b/felicity/apps/analysis/services/analysis.py
index e3d6144d..d5345ae7 100644
--- a/felicity/apps/analysis/services/analysis.py
+++ b/felicity/apps/analysis/services/analysis.py
@@ -482,28 +482,28 @@ class SampleService(BaseService[Sample, SampleCreate, SampleUpdate]):
         return await super().create(data, related)
 
     async def duplicate_unique(self, uid: str, duplicator):
-        sample = await self.get(uid=uid)
+        sample = await self.get_related(related=["profiles", "analyses"], uid=uid)
         data = sample.to_dict(nested=False)
         data["sample_id"] = self.copy_sample_id_unique(sample)
         for key, _ in list(data.items()):
             if key not in self.copy_include_keys():
                 del data[key]
         data["status"] = SampleState.RECEIVED
-        data["profiles"] = self.profiles
-        data["analyses"] = self.analyses
-        data["parent_id"] = self.uid
+        data["profiles"] = sample.profiles
+        data["analyses"] = sample.analyses
+        data["parent_id"] = sample.uid
         data["created_by_uid"] = duplicator.uid
         return await super().create(data)
 
     async def clone_afresh(self, uid: str, cloner):
-        sample = await self.get(uid=uid)
+        sample = await self.get_related(related=["profiles", "analyses"], uid=uid)
         data = sample.to_dict(nested=False)
         for key, _ in list(data.items()):
             if key not in self.copy_include_keys():
                 del data[key]
         data["status"] = SampleState.RECEIVED
-        data["profiles"] = self.profiles
-        data["analyses"] = self.analyses
-        data["parent_id"] = self.uid
+        data["profiles"] = sample.profiles
+        data["analyses"] = sample.analyses
+        data["parent_id"] = sample.uid
         data["created_by_uid"] = cloner.uid
         return await self.create(obj_in=data)
diff --git a/felicity/apps/analysis/utils.py b/felicity/apps/analysis/utils.py
index 69c7feb5..0177359b 100644
--- a/felicity/apps/analysis/utils.py
+++ b/felicity/apps/analysis/utils.py
@@ -40,7 +40,6 @@ from felicity.utils import has_value_or_is_truthy
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-
 QC_SAMPLE = {"name": "QC Sample", "description": "QC Sample", "abbr": "QCS"}
 
 
@@ -67,7 +66,7 @@ async def get_last_verificator(result_uid: str) -> User | None:
 
 
 async def sample_search(
-    model, status: str, text: str, client_uid: str
+        model, status: str, text: str, client_uid: str
 ) -> list[SampleType]:
     """No pagination"""
     sample_service = SampleService()
@@ -100,7 +99,7 @@ async def sample_search(
 
 
 async def retest_from_result_uids(
-    uids: list[str], user: User
+        uids: list[str], user: User
 ) -> tuple[list[AnalysisResult], list[AnalysisResult]]:
     analysis_result_service = AnalysisResultService()
     analysis_result_wf = AnalysisResultWorkFlow()
@@ -124,7 +123,7 @@ async def retest_from_result_uids(
 
 
 async def results_submitter(
-    analysis_results: List[dict], submitter: User
+        analysis_results: List[dict], submitter: User
 ) -> list[AnalysisResult]:
     analysis_result_service = AnalysisResultService()
     sample_wf = SampleWorkFlow()
@@ -178,9 +177,9 @@ async def verify_from_result_uids(uids: list[str], user: User) -> list[AnalysisR
         logger.info(f"ReflexUtil .... done")
 
         # try to verify associated sample
-        sample_verified=False
+        sample_verified = False
         try:
-            sample_verified, _ = await sample_wf.approve([a_result.sample_uid], submitted_by=user)
+            sample_verified, _ = await sample_wf.approve(a_result.sample_uid, approved_by=user)
         except Exception as e:
             await sample_wf.revert(a_result.sample_uid, by_uid=user.uid)
             logger.warning(e)
@@ -188,7 +187,7 @@ async def verify_from_result_uids(uids: list[str], user: User) -> list[AnalysisR
         # try to submit associated worksheet
         if a_result.worksheet_uid:
             try:
-                await worksheet_wf.approve(a_result.worksheet_uid, verified_by=user)
+                await worksheet_wf.approve(a_result.worksheet_uid, approved_by=user)
             except Exception as e:
                 await worksheet_wf.revert(a_result.worksheet_uid, by_uid=user.uid)
                 logger.warning(e)
@@ -248,11 +247,11 @@ async def result_mutator(result: AnalysisResult) -> None:
         # Correction factor
         for cf in correction_factors:
             if (
-                cf.instrument_uid == result.laboratory_instrument_uid
-                and cf.method_uid == result.method_uid
+                    cf.instrument_uid == result.laboratory_instrument_uid
+                    and cf.method_uid == result.method_uid
             ):
                 await result_mutation_service.create(
-                    obj_in={
+                    c={
                         "result_uid": result.uid,
                         "before": result.result,
                         "after": result.result * cf.factor,
@@ -267,7 +266,7 @@ async def result_mutator(result: AnalysisResult) -> None:
             # Min
             if result.result < spec.min_warn:
                 await result_mutation_service.create(
-                    obj_in={
+                    c={
                         "result_uid": result.uid,
                         "before": result.result,
                         "after": spec.min_report,
@@ -283,7 +282,7 @@ async def result_mutator(result: AnalysisResult) -> None:
             # Max
             if result.result > spec.max_warn:
                 await result_mutation_service.create(
-                    obj_in={
+                    c={
                         "result_uid": result.uid,
                         "before": result.result,
                         "after": spec.max_report,
@@ -300,7 +299,7 @@ async def result_mutator(result: AnalysisResult) -> None:
         for dlim in detection_limits:
             if result.result < dlim.lower_limit:
                 await result_mutation_service.create(
-                    obj_in={
+                    c={
                         "result_uid": result.uid,
                         "before": result.result,
                         "after": f"< {dlim.lower_limit}",
@@ -312,7 +311,7 @@ async def result_mutator(result: AnalysisResult) -> None:
 
             if result.result > dlim.upper_limit:
                 await result_mutation_service.create(
-                    obj_in={
+                    c={
                         "result_uid": result.uid,
                         "before": result.result,
                         "after": f"> {dlim.upper_limit}",
@@ -327,7 +326,7 @@ async def result_mutator(result: AnalysisResult) -> None:
             for uncert in uncertainties:
                 if uncert.min <= result.result <= uncert.max:
                     await result_mutation_service.create(
-                        obj_in={
+                        c={
                             "result_uid": result.uid,
                             "before": result.result,
                             "after": f"{result.result} +/- {uncert.value}",
@@ -341,7 +340,7 @@ async def result_mutator(result: AnalysisResult) -> None:
         for spec in specifications:
             if result.result in spec.warn_values.split(","):
                 await result_mutation_service.create(
-                    obj_in={
+                    c={
                         "result_uid": result.uid,
                         "before": result.result,
                         "after": spec.warn_report,
diff --git a/felicity/apps/auditlog/__init__.py b/felicity/apps/auditlog/__init__.py
deleted file mode 100644
index 882f3b05..00000000
--- a/felicity/apps/auditlog/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# https://github.com/accent-starlette/starlette-audit/blob/master/starlette_audit/tables.py
diff --git a/felicity/apps/auditlog/entities.py b/felicity/apps/auditlog/entities.py
deleted file mode 100644
index f18ad619..00000000
--- a/felicity/apps/auditlog/entities.py
+++ /dev/null
@@ -1,90 +0,0 @@
-import json
-
-from sqlalchemy import Column, Integer, String, UnicodeText
-
-from felicity.apps.abstract.entity import BaseEntity
-
-
-class AuditLog(BaseEntity):
-    """Model an audit log of user actions"""
-
-    __tablename__ = "audit_log"
-
-    user_id = Column(String, doc="The ID of the user who made the change")
-    target_type = Column(
-        String(100), nullable=False, doc="The table name of the altered object"
-    )
-    target_id = Column(String, doc="The ID of the altered object")
-    action = Column(Integer, doc="Create (1), update (2), or delete (3)")
-    state_before = Column(
-        UnicodeText,
-        doc="Stores a JSON string representation of a dict containing the altered "
-        "column names and original values",
-    )
-    state_after = Column(
-        UnicodeText,
-        doc="Stores a JSON string representation of a dict containing the altered "
-        "column names and new values",
-    )
-
-    def __init__(self, target_type, target_id, action, state_before, state_after):
-
-        self.state_after = state_after
-        self.target_type = target_type
-        self.target_id = target_id
-        self.action = action
-        self.state_before = state_before
-
-        if isinstance(state_after, str):
-            state_after = json.loads(state_after)
-
-        try:
-            updated_by_uid = state_after["updated_by_uid"]
-        except (KeyError, TypeError):
-            updated_by_uid = None
-
-        self.user_id = updated_by_uid if updated_by_uid else None
-
-    def __repr__(self):
-        return "<AuditLog %r: %r -> %r>" % (self.user_id, self.target_type, self.action)
-
-    def save(self, connection):
-
-        state_after = self.state_after
-        if isinstance(state_after, str):
-            state_after = json.loads(state_after)
-
-        state_before = self.state_before
-        if isinstance(state_before, str):
-            state_before = json.loads(state_before)
-
-        if state_after:
-            to_delete = []
-            for key in state_after.keys():
-                if state_after[key] == state_before[key]:
-                    to_delete.append(key)
-
-            for _key in to_delete:
-                del state_after[_key]
-                del state_before[_key]
-
-            if len(state_after.keys()) == 1:
-                if list(state_after.keys())[0] == "updated_at":
-                    return
-
-        state_after = json.dumps(state_after) if state_after else json.dumps({})
-        state_before = json.dumps(state_before) if state_before else json.dumps({})
-
-        connection.execute(
-            self.__table__.insert(),
-            [
-                {
-                    "user_id": self.user_id,
-                    "target_type": self.target_type,
-                    "target_id": self.target_id,
-                    "action": self.action,
-                    "state_before": state_before,
-                    "state_after": state_after,
-                }
-            ],
-        )
diff --git a/felicity/apps/auditlog/mixin.py b/felicity/apps/auditlog/mixin.py
deleted file mode 100644
index 42445e1d..00000000
--- a/felicity/apps/auditlog/mixin.py
+++ /dev/null
@@ -1,111 +0,0 @@
-import datetime
-import json
-import logging
-
-from sqlalchemy import event, inspect
-from sqlalchemy.orm import class_mapper
-from sqlalchemy.orm.attributes import get_history
-
-from felicity.apps.auditlog.entities import AuditLog
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-ACTION_CREATE = 1
-ACTION_UPDATE = 2
-ACTION_DELETE = 3
-
-# Only audit the events in this list
-PLEASE_AUDIT = [ACTION_UPDATE]
-
-
-def custom_serial(o):
-    if isinstance(o, (datetime.date, datetime.datetime)):
-        return o.isoformat()
-
-    raise TypeError("Type %s not serializable" % type(o))
-
-
-class AuditHistoryMixin:
-    """Allow a model to be automatically audited"""
-
-    @staticmethod
-    def create_audit(connection, object_type, object_id, action, **kwargs):
-        audit = AuditLog(
-            object_type,
-            object_id,
-            action,
-            kwargs.get("state_before"),
-            kwargs.get("state_after"),
-        )
-
-        audit.save(connection)
-
-    @classmethod
-    def __declare_last__(cls):
-        logger.debug("trigger")
-        if ACTION_CREATE in PLEASE_AUDIT:
-            event.listens_for(cls, "after_insert", cls.audit_insert)
-
-        if ACTION_DELETE in PLEASE_AUDIT:
-            event.listen(cls, "after_delete", cls.audit_delete)
-
-        if ACTION_UPDATE in PLEASE_AUDIT:
-            event.listen(cls, "after_update", cls.audit_update)
-
-    @staticmethod
-    def audit_insert(mapper, connection, target):
-        """Listen for the `after_insert` event and create an AuditLog entry"""
-        target.create_audit(connection, target.__tablename__, target.uid, ACTION_CREATE)
-
-    @staticmethod
-    def audit_delete(mapper, connection, target):
-        """Listen for the `after_delete` event and create an AuditLog entry"""
-        target.create_audit(connection, target.__tablename__, target.uid, ACTION_DELETE)
-
-    @staticmethod
-    def audit_update(mapper, connection, target):
-        """Listen for the `after_update` event and create an AuditLog entry with before and after state changes"""
-        state_before = {}
-        state_after = {}
-        inspector = inspect(target)
-        attrs = class_mapper(target.__class__).column_attrs
-
-        for attr in attrs:
-            hist = getattr(inspector.attrs, attr.key).history
-            if hist.has_changes():
-                if isinstance(get_history(target, attr.key)[2], tuple):
-                    continue
-                state_before[attr.key] = get_history(target, attr.key)[2].pop()
-                state_after[attr.key] = getattr(target, attr.key)
-            else:
-                if attr.key in ["updated_by_uid", "created_by_uid"]:
-                    state_after[attr.key] = getattr(target, attr.key)
-                    try:
-                        state_before[attr.key] = get_history(target, attr.key)[2].pop()
-                    except Exception:
-                        state_before[attr.key] = getattr(target, attr.key)
-
-        if len(state_after.keys()) == 1:
-            if "updated_at" in list(state_after.keys()):
-                return
-
-        # clean up
-        if "json_content" in state_before:
-            del state_before["json_content"]
-        if "json_content" in state_after:
-            del state_after["json_content"]
-
-        if "pdf_content" in state_after:
-            del state_after["pdf_content"]
-        if "pdf_content" in state_before:
-            del state_before["pdf_content"]
-
-        target.create_audit(
-            connection,
-            target.__tablename__,
-            target.uid,
-            ACTION_UPDATE,
-            state_before=json.dumps(state_before, default=custom_serial),
-            state_after=json.dumps(state_after, default=custom_serial),
-        )
diff --git a/felicity/apps/auditlog/repositories.py b/felicity/apps/auditlog/repositories.py
deleted file mode 100644
index e8afea04..00000000
--- a/felicity/apps/auditlog/repositories.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from felicity.apps.abstract import BaseRepository
-from felicity.apps.auditlog.entities import AuditLog
-
-
-class AuditLogRepository(BaseRepository[AuditLog]):
-    def __init__(self) -> None:
-        super().__init__(AuditLog)
diff --git a/felicity/apps/auditlog/services.py b/felicity/apps/auditlog/services.py
deleted file mode 100644
index efdbb3e7..00000000
--- a/felicity/apps/auditlog/services.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from felicity.apps.abstract import BaseService
-from felicity.apps.auditlog.entities import AuditLog
-from felicity.apps.auditlog.repositories import AuditLogRepository
-from felicity.apps.common.schemas.dummy import Dummy
-
-
-class AuditLogService(BaseService[AuditLog, Dummy, Dummy]):
-    def __init__(self) -> None:
-        super().__init__(AuditLogRepository)
diff --git a/felicity/apps/common/utils/serializer.py b/felicity/apps/common/utils/serializer.py
index 00231e2f..19a70a4f 100644
--- a/felicity/apps/common/utils/serializer.py
+++ b/felicity/apps/common/utils/serializer.py
@@ -1,14 +1,16 @@
 from datetime import datetime
+from enum import Enum
 
-from felicity.core.dtz import format_datetime
+
+# from felicity.core.dtz import format_datetime
 
 
 def marshaller(
-    obj, path=None, memoize=None, exclude: list[str] = None, depth=2
+        obj, path=None, memoize=None, exclude: list[str] = None, depth=2
 ) -> dict | str:
-    """Notes:
-    1. We use memoization To prevent marshalling the same object again hence speed things up
-    2. We use path tracking To stop marshalling when a path starts to repeat itself or meets a certain path restriction
+    """
+    Custom marshaller function to convert objects to dictionaries or strings with proper handling for
+    StrEnum, datetime, and other custom objects.
     """
     if memoize is None:
         memoize = {}
@@ -22,34 +24,38 @@ def marshaller(
     if id(obj) in memoize:
         return memoize[id(obj)]
 
-    if not hasattr(obj, "__dict__"):
+    # Handling non-dict objects a.k.a values
+    if not (hasattr(obj, "__dict__") or isinstance(obj, dict)):
         if obj is None:
             return ""
-        if isinstance(obj, datetime):
-            return format_datetime(obj, human_format=False, with_time=True)
-        if hasattr(obj, "__str__"):
-            return obj.__str__()
-        return obj
+        elif isinstance(obj, datetime):
+            return obj.isoformat()  # format_datetime(obj, human_format=False, with_time=True)
+        elif hasattr(obj, "__str__"):
+            return obj.__str__()  # Convert other objects to their string representation
+        else:
+            return obj
+
+    # Handling dict and objects with __dict__
+    if isinstance(obj, Enum):  # enums are dicts
+        return obj.value  # Convert StrEnum to its value
 
     if depth <= 0:
         return {}
 
+    items = obj.__dict__.items() if hasattr(obj, "__dict__") else obj.items()
     result = {}
-    for key, val in obj.__dict__.items():
+
+    for key, val in items:
         if (key.startswith("_") or key in exclude) or (path and path[-1] == key):
             continue
 
-        element = []
-        # if isinstance(val, bool):
-        #     element = val
+        # Process lists and other values
         if isinstance(val, list):
-            for item in val:
-                element.append(
-                    marshaller(item, path + [key], memoize, exclude, depth - 1)
-                )
+            result[key] = [
+                marshaller(item, path + [key], memoize, exclude, depth - 1) for item in val
+            ]
         else:
-            element = marshaller(val, path + [key], memoize, exclude, depth - 1)
-        result[key] = element
+            result[key] = marshaller(val, path + [key], memoize, exclude, depth - 1)
 
-        memoize[id(obj)] = result
+    memoize[id(obj)] = result
     return result
diff --git a/felicity/apps/errlog/__init__.py b/felicity/apps/errlog/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/felicity/apps/errlog/entities.py b/felicity/apps/errlog/entities.py
deleted file mode 100644
index 2f980b20..00000000
--- a/felicity/apps/errlog/entities.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from sqlalchemy import Column
-from sqlalchemy.dialects.postgresql import JSONB
-
-from felicity.apps.abstract import AuditUser
-
-
-class ErrorLog(AuditUser):
-    __tablename__ = "error_log"
-
-    content = Column(JSONB)
diff --git a/felicity/apps/errlog/repositories.py b/felicity/apps/errlog/repositories.py
deleted file mode 100644
index 8501ed90..00000000
--- a/felicity/apps/errlog/repositories.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from felicity.apps.abstract.repository import BaseRepository
-from felicity.apps.errlog.entities import ErrorLog
-
-
-class ErrorLogRepository(BaseRepository[ErrorLog]):
-    def __init__(self) -> None:
-        super().__init__(ErrorLog)
diff --git a/felicity/apps/errlog/schemas.py b/felicity/apps/errlog/schemas.py
deleted file mode 100644
index e830eb2f..00000000
--- a/felicity/apps/errlog/schemas.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from typing import Any, Optional
-
-from pydantic import BaseModel, ConfigDict
-
-
-#
-# Job Schemas
-#
-class ErrorLogBase(BaseModel):
-    content: Optional[Any] = None
-
-
-class ErrorLog(ErrorLogBase):
-    uid: str | None = None
-
-    model_config = ConfigDict(from_attributes=True)
-
-
-class ErrorLogCreate(ErrorLogBase):
-    pass
-
-
-class ErrorLogUpdate(ErrorLogBase):
-    pass
diff --git a/felicity/apps/errlog/services.py b/felicity/apps/errlog/services.py
deleted file mode 100644
index d60634ec..00000000
--- a/felicity/apps/errlog/services.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from felicity.apps.abstract.service import BaseService
-from felicity.apps.errlog.entities import ErrorLog
-from felicity.apps.errlog.repositories import ErrorLogRepository
-from felicity.apps.errlog.schemas import ErrorLogCreate, ErrorLogUpdate
-
-
-class ErrorLogService(BaseService[ErrorLog, ErrorLogCreate, ErrorLogUpdate]):
-    def __int__(self):
-        super().__init__(ErrorLogRepository)
diff --git a/felicity/apps/iol/meilisearch/client.py b/felicity/apps/iol/meilisearch/client.py
index e29881a8..3098a183 100644
--- a/felicity/apps/iol/meilisearch/client.py
+++ b/felicity/apps/iol/meilisearch/client.py
@@ -1,26 +1,34 @@
+import logging
 from datetime import datetime
 
 import meilisearch
 
 from felicity.core.config import settings
 
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 
 class MeiliSearchClient:
     def __init__(self):
         self.client = meilisearch.Client(settings.MEILISEARCH_SERVER, settings.MEILISEARCH_API_KEY)
 
     def create_index(self, index_name: str):
-        return self.client.create_index(uid=index_name, options={"primary_key": "uid"})
+        logger.info("meilisearch -- create index --")
+        return self.client.create_index(uid=index_name, options={"primaryKey": "uid"})
 
     def add_documents(self, index_name: str, docs: list):
+        logger.info("meilisearch -- add documents --")
         index = self.client.index(index_name)
         return index.add_documents(docs)
 
     def update_documents(self, index_name: str, docs: list):
+        logger.info("meilisearch -- update documents --")
         index = self.client.index(index_name)
         return index.update_documents(docs)
 
     def delete_document(self, index_name: str, doc_id: str):
+        logger.info("meilisearch -- delete document --")
         index = self.client.index(index_name)
         return index.delete_document(doc_id)
 
@@ -33,6 +41,7 @@ class MeiliSearchClient:
             date_gt: datetime = None,
             date_lt: datetime = None
     ):
+        logger.info("meilisearch -- search --")
         index = self.client.index(index_name)
 
         # Build the filter string
@@ -55,7 +64,9 @@ class MeiliSearchClient:
         return index.search(query, options)
 
     def delete_index(self, index_name: str):
+        logger.info("meilisearch -- delete index --")
         return self.client.delete_index(index_name)
 
     def list_indexes(self):
+        logger.info("meilisearch -- list indexes --")
         return self.client.get_indexes()
diff --git a/felicity/apps/iol/meilisearch/handler.py b/felicity/apps/iol/meilisearch/handler.py
index e068cea6..17a0bb7a 100644
--- a/felicity/apps/iol/meilisearch/handler.py
+++ b/felicity/apps/iol/meilisearch/handler.py
@@ -1,7 +1,20 @@
+import json
+from datetime import datetime
+from enum import StrEnum
+
 from apps.common.utils.serializer import marshaller
 from apps.iol.meilisearch.client import MeiliSearchClient
 
 
+class CustomJSONEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, StrEnum):
+            return obj.value  # Serialize StrEnum to its value
+        if isinstance(obj, datetime):
+            return obj.isoformat()  # Serialize datetime to ISO format string
+        return super().default(obj)
+
+
 class MeilisearchSyncHandler:
     def __init__(self):
         self.client = MeiliSearchClient()
@@ -11,19 +24,19 @@ class MeilisearchSyncHandler:
         return table_name in self.tables_of_interest
 
     @staticmethod
-    def get_document(instance):
-        return marshaller(instance)
+    def get_document(metadata):
+        return marshaller(metadata)
 
     def on_event(self, event_type, table_name, tracked):
         if not self.should_sync(table_name):
             return
 
-        document = self.get_document(tracked)
+        doc = self.get_document(tracked)
 
         self.client.create_index(table_name)
         if event_type == 'after-insert':
-            self.client.add_documents(table_name, [document])
+            self.client.add_documents(table_name, [doc])
         elif event_type == 'after-update':
-            self.client.update_documents(table_name, [document])
+            self.client.update_documents(table_name, [doc])
         elif event_type == 'after-delete':
-            self.client.delete_document(table_name, document["uid"])
+            self.client.delete_document(table_name, doc["uid"])
diff --git a/felicity/apps/iol/minio/client.py b/felicity/apps/iol/minio/client.py
index 3c5ea542..b41f50d7 100644
--- a/felicity/apps/iol/minio/client.py
+++ b/felicity/apps/iol/minio/client.py
@@ -1,4 +1,5 @@
 import io
+import logging
 from typing import BinaryIO
 
 from minio import Minio
@@ -7,11 +8,14 @@ from minio.error import S3Error
 from felicity.core.config import settings
 from .enum import MinioBucket
 
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 
 class MinioClient:
     def __init__(self):
         self.client = Minio(
-            settings.MINIO_SERVER,
+            endpoint=settings.MINIO_SERVER,
             access_key=settings.MINIO_ACCESS,
             secret_key=settings.MINIO_SECRET,
             secure=False
@@ -21,10 +25,12 @@ class MinioClient:
         return self.client.bucket_exists(bucket)
 
     def make_bucket(self, bucket: MinioBucket):
+        logger.info(f"minio -- add {bucket} bucket --")
         if not self.bucket_exists(bucket):
             self.client.make_bucket(bucket)
 
     def put_object(self, bucket: MinioBucket, object_name: str, data, metadata, content_type="application/pdf"):
+        logger.info(f"minio -- put {bucket} object --")
         self.make_bucket(bucket)
 
         if not isinstance(data, BinaryIO):
@@ -43,6 +49,7 @@ class MinioClient:
             raise Exception(f"Failed to upload file: {str(e)}")
 
     def get_object(self, bucket: MinioBucket, object_names: list[str]):
+        logger.info(f"minio -- get {bucket} object --")
         objects = []
         try:
             for obj_name in object_names:
diff --git a/felicity/apps/notification/services.py b/felicity/apps/notification/services.py
index ca84d49a..a0962e37 100644
--- a/felicity/apps/notification/services.py
+++ b/felicity/apps/notification/services.py
@@ -1,5 +1,7 @@
+import json
 from typing import Any, List, Optional
 
+from apps.common.utils.serializer import marshaller
 from felicity.apps.abstract.service import BaseService
 from felicity.apps.common.channel import broadcast
 from felicity.apps.notification.entities import (ActivityFeed, ActivityStream,
@@ -29,13 +31,13 @@ class ActivityFeedService(
         return await super().save(activity_feed)
 
     async def remove_subscriber(
-        self, activity_feed: ActivityFeed, user: User
+            self, activity_feed: ActivityFeed, user: User
     ) -> ActivityFeed:
         activity_feed.subscribers.remove(user)
         return await super().save(activity_feed)
 
     async def add_subscriber(
-        self, activity_feed: ActivityFeed, user: User
+            self, activity_feed: ActivityFeed, user: User
     ) -> ActivityFeed:
         if user not in activity_feed.viewers:
             activity_feed.subscribers.append(user)
@@ -50,12 +52,12 @@ class ActivityStreamService(
         super().__init__(ActivityStreamRepository)
 
     async def stream(
-        self,
-        obj: Any,
-        actor: User,
-        verb: str,
-        object_type: str,
-        feeds: List[ActivityFeed] = None,
+            self,
+            obj: Any,
+            actor: User,
+            verb: str,
+            object_type: str,
+            feeds: List[ActivityFeed] = None,
     ):
         if feeds is None:
             feeds = []
@@ -68,20 +70,20 @@ class ActivityStreamService(
             target_uid=None,
         )
         stream = await self.create(s_in)
-        await broadcast.publish(NotificationChannel.ACTIVITIES, stream)
+        await broadcast.publish(NotificationChannel.ACTIVITIES, json.dumps(marshaller(stream)))
 
     async def reset_feeds(self, activity_stream: ActivityStream) -> ActivityStream:
         activity_stream.feeds.clear()
         return await super().save(activity_stream)
 
     async def remove_feed(
-        self, activity_stream: ActivityStream, feed: ActivityFeed
+            self, activity_stream: ActivityStream, feed: ActivityFeed
     ) -> ActivityStream:
         activity_stream.feeds.remove(feed)
         return await super().save(activity_stream)
 
     async def add_feed(
-        self, activity_stream: ActivityStream, feed: ActivityFeed
+            self, activity_stream: ActivityStream, feed: ActivityFeed
     ) -> ActivityStream:
         if feed not in activity_stream.feeds:
             activity_stream.feeds.append(feed)
@@ -93,13 +95,13 @@ class ActivityStreamService(
         return await super().save(activity_stream)
 
     async def remove_viewer(
-        self, activity_stream: ActivityStream, viewer: User
+            self, activity_stream: ActivityStream, viewer: User
     ) -> ActivityStream:
         activity_stream.viewers.remove(viewer)
         return await super().save(activity_stream)
 
     async def add_viewer(
-        self, activity_stream: ActivityStream, viewer: User
+            self, activity_stream: ActivityStream, viewer: User
     ) -> ActivityStream:
         if viewer not in activity_stream.viewers:
             activity_stream.viewers.append(viewer)
@@ -111,7 +113,7 @@ class ActivityStreamService(
 
     @classmethod
     async def for_viewer(
-        self, activity_stream: ActivityStream, viewer: User, seen=False
+            self, activity_stream: ActivityStream, viewer: User, seen=False
     ) -> Optional[List[ActivityStream]]:
         """Streams for user: seen or unseen"""
 
@@ -121,8 +123,8 @@ class NotificationService(
 ):
     def __init__(self):
         super().__init__(NotificationRepository)
-    
-    async def notify(self,message: str, users, departments=None, groups=None) -> None:
+
+    async def notify(self, message: str, users, departments=None, groups=None) -> None:
         n_in = NotificationCreate(message=message)
         notification = await super().create(n_in, related=["users", "departments", "groups"])
         if not isinstance(users, list):
@@ -131,13 +133,13 @@ class NotificationService(
         notification.departments = departments if departments else []
         notification.groups = groups if groups else []
         notification = await self.save(notification)
-        await broadcast.publish(NotificationChannel.NOTIFICATIONS, notification)
+        await broadcast.publish(NotificationChannel.NOTIFICATIONS, json.dumps(marshaller(notification)))
 
     async def filter(
-        self,
-        group_uid: str | None,
-        department_uid: str | None,
-        user_uid: str | None,
+            self,
+            group_uid: str | None,
+            department_uid: str | None,
+            user_uid: str | None,
     ) -> List[Notification]:
         filters = {}
 
@@ -157,7 +159,7 @@ class NotificationService(
         return await super().save(notification)
 
     async def remove_viewer(
-        self, notification: Notification, user: User
+            self, notification: Notification, user: User
     ) -> Notification:
         notification.viewers.remove(user)
         return await super().save(notification)
@@ -173,13 +175,13 @@ class NotificationService(
         return await super().save(notification)
 
     async def remove_department(
-        self, notification: Notification, department: Department
+            self, notification: Notification, department: Department
     ) -> Notification:
         notification.departments.remove(department)
         return await super().save(notification)
 
     async def add_department(
-        self, notification: Notification, department: Department
+            self, notification: Notification, department: Department
     ) -> Notification:
         if department not in self.departments:
             notification.departments.append(department)
@@ -191,7 +193,7 @@ class NotificationService(
         return await super().save(notification)
 
     async def remove_group(
-        self, notification: Notification, group: Group
+            self, notification: Notification, group: Group
     ) -> Notification:
         notification.groups.remove(group)
         return await super().save(notification)
@@ -207,7 +209,7 @@ class NotificationService(
         return await super().save(notification)
 
     async def remove_users(
-        self, notification: Notification, user: User
+            self, notification: Notification, user: User
     ) -> Notification:
         notification.users.remove(user)
         return await super().save(notification)
diff --git a/felicity/core/events.py b/felicity/core/events.py
index f94ae205..5add37c4 100644
--- a/felicity/core/events.py
+++ b/felicity/core/events.py
@@ -1,91 +1,114 @@
+import asyncio
+import inspect
 import logging
+import traceback
 from asyncio import create_task, gather, Lock as ALock
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from threading import Lock
-from typing import Callable, List, Dict
+from typing import Callable, List, Dict, Any
 
 # Initialize logger
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-subscribers: Dict[str, List[Callable]] = {}
-lock = Lock()  # Synchronous lock
-alock = ALock()  # Asynchronous lock
+subscribers: Dict[str, List[Callable[..., Any]]] = {}
+sync_lock = Lock()  # Synchronous lock
+async_lock = ALock()  # Asynchronous lock
+
+
+def partition_functions(functions: List[Callable[..., Any]]) -> (List[Callable[..., Any]], List[Callable[..., Any]]):
+    async_funcs = [fn for fn in functions if inspect.iscoroutinefunction(fn)]
+    sync_funcs = [fn for fn in functions if not inspect.iscoroutinefunction(fn)]
+    return async_funcs, sync_funcs
+
+
+def get_or_create_event_loop() -> asyncio.AbstractEventLoop:
+    try:
+        return asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        return loop
 
 
 # Synchronous Event System
-def subscribe(event_type: str, fn: Callable):
-    with lock:
-        if event_type not in subscribers:
-            subscribers[event_type] = []
-        subscribers[event_type].append(fn)
+def subscribe(event_type: str, fn: Callable[..., Any]) -> None:
+    with sync_lock:
+        subscribers.setdefault(event_type, []).append(fn)
 
 
-def unsubscribe(event_type: str, fn: Callable):
-    with lock:
+def unsubscribe(event_type: str, fn: Callable[..., Any]) -> None:
+    with sync_lock:
         if event_type in subscribers:
             try:
                 subscribers[event_type].remove(fn)
             except ValueError:
-                logger.warning(f"Function not found in subscribers for event type: {event_type}")
+                logger.error(
+                    f"Function not found in subscribers for event type: {event_type}\n{traceback.format_exc()}")
 
 
-def post_event(event_type: str, **kwargs):
-    with lock:
-        if event_type not in subscribers:
-            return
-        current_subscribers: List[Callable] = subscribers[event_type][:]
+def post_event(event_type: str, **kwargs: Any) -> None:
+    with sync_lock:
+        current_subscribers = subscribers.get(event_type, [])
 
+    # Separate sync from async functions
+    async_funcs, sync_funcs = partition_functions(current_subscribers)
+
+    # Handle async functions
+    loop = get_or_create_event_loop()
+    for fn in async_funcs:
+        if loop.is_running():
+            loop.create_task(fn(**kwargs))
+        else:
+            asyncio.run(fn(**kwargs))
+
+    # Handle sync functions
     with ThreadPoolExecutor() as executor:
-        futures = []
-        for fn in current_subscribers:
-            futures.append(executor.submit(safe_execute, fn, **kwargs))
+        futures = [executor.submit(safe_execute, fn, **kwargs) for fn in sync_funcs]
 
         for future in as_completed(futures):
-            if future.exception() is not None:
-                logger.error(f"Error executing event handler: {future.exception()}")
+            try:
+                future.result()  # Re-raise any exception from the executed function
+            except Exception as e:
+                logger.error(f"Error executing event handler: {e}\n{traceback.format_exc()}")
 
 
-def safe_execute(fn: Callable, **kwargs):
+def safe_execute(fn: Callable[..., Any], **kwargs: Any) -> None:
     try:
         fn(**kwargs)
     except Exception as e:
-        logger.error(f"Error in event subscriber {fn.__name__}: {e}")
+        logger.error(f"Error in event subscriber {fn.__name__}: {e}\n{traceback.format_exc()}")
 
 
 # Asynchronous Event System
-async def asubscribe(event_type: str, fn: Callable):
-    async with alock:
-        if event_type not in subscribers:
-            subscribers[event_type] = []
-        subscribers[event_type].append(fn)
+async def asubscribe(event_type: str, fn: Callable[..., Any]) -> None:
+    async with async_lock:
+        subscribers.setdefault(event_type, []).append(fn)
 
 
-async def aunsubscribe(event_type: str, fn: Callable):
-    async with alock:
+async def aunsubscribe(event_type: str, fn: Callable[..., Any]) -> None:
+    async with async_lock:
         if event_type in subscribers:
             try:
                 subscribers[event_type].remove(fn)
             except ValueError:
-                logger.warning(f"Function not found in subscribers for event type: {event_type}")
+                logger.error(
+                    f"Function not found in subscribers for event type: {event_type}\n{traceback.format_exc()}")
 
 
-async def apost_event(event_type: str, **kwargs):
-    async with alock:
-        if event_type not in subscribers:
-            return
-        current_subscribers: List[Callable] = subscribers[event_type][:]
+async def apost_event(event_type: str, **kwargs: Any) -> None:
+    async with async_lock:
+        current_subscribers = subscribers.get(event_type, [])
 
     tasks = [create_task(asafe_execute(fn, **kwargs)) for fn in current_subscribers]
     await gather(*tasks)
 
 
-async def asafe_execute(fn: Callable, **kwargs):
+async def asafe_execute(fn: Callable[..., Any], **kwargs: Any) -> None:
     try:
-        if callable(fn):
-            if hasattr(fn, "__await__"):  # Check if it's an async function
-                await fn(**kwargs)
-            else:
-                fn(**kwargs)
+        if inspect.iscoroutinefunction(fn):
+            await fn(**kwargs)
+        else:
+            fn(**kwargs)
     except Exception as e:
-        logger.error(f"Error in async event subscriber {fn.__name__}: {e}")
+        logger.error(f"Error in event subscriber {fn.__name__}: {e}\n{traceback.format_exc()}")
diff --git a/felicity/database/base.py b/felicity/database/base.py
index 6c1fb5ee..363d5887 100644
--- a/felicity/database/base.py
+++ b/felicity/database/base.py
@@ -4,8 +4,6 @@ from felicity.apps.analysis.entities.analysis import AnalysisCategory  # noqa
 from felicity.apps.analysis.entities.analysis import AnalysisCoding  # noqa
 from felicity.apps.analysis.entities.analysis import AnalysisInterim  # noqa
 from felicity.apps.analysis.entities.analysis import AnalysisRequest  # noqa
-from felicity.apps.analysis.entities.analysis import \
-    AnalysisUncertainty  # noqa
 from felicity.apps.analysis.entities.analysis import CodingStandard  # noqa
 from felicity.apps.analysis.entities.analysis import Profile  # noqa
 from felicity.apps.analysis.entities.analysis import ProfileCoding  # noqa
@@ -20,7 +18,6 @@ from felicity.apps.analysis.entities.qc import QCTemplate  # noqa
 from felicity.apps.analysis.entities.results import AnalysisResult  # noqa
 from felicity.apps.analysis.entities.results import ResultMutation  # noqa
 from felicity.apps.analytics.entities import ReportMeta  # noqa
-from felicity.apps.auditlog.entities import AuditLog  # noqa
 from felicity.apps.billing.entities import AnalysisDiscount  # noqa
 from felicity.apps.billing.entities import AnalysisPrice  # noqa
 from felicity.apps.billing.entities import ProfileDiscount  # noqa
diff --git a/felicity/database/mongo.py b/felicity/database/mongo.py
index 4bb38dd4..29404d74 100644
--- a/felicity/database/mongo.py
+++ b/felicity/database/mongo.py
@@ -1,11 +1,15 @@
+import logging
 from enum import StrEnum
-from typing import Optional
+from typing import Optional, Any
 
 from bson import ObjectId
 from motor.motor_asyncio import AsyncIOMotorClient
 
 from felicity.core.config import settings
 
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 client = AsyncIOMotorClient(
     f"mongodb://{settings.MONGODB_USER}:{settings.MONGODB_PASS}@{settings.MONGODB_SERVER}"
 )
@@ -22,22 +26,47 @@ class MongoService:
         self.db = client.felicity
 
     async def create(self, collection: MongoCollection, data: dict) -> Optional[dict]:
+        logger.info(f"mongodb -- create:{collection} --")
         collection = self.db.get_collection(collection)
         created = await collection.insert_one(data)
         return await collection.find_one({"_id": created.inserted_id})
 
     async def upsert(self, collection: MongoCollection, uid: str, data: dict) -> Optional[dict]:
+        logger.info(f"mongodb -- upsert:{collection} --")
         collection = self.db.get_collection(collection)
         result = await collection.update_one({'_id': self.oid(uid)}, {'$set': data}, upsert=True)
         return await collection.find_one({"_id": result.upserted_id})
 
     async def retrieve(self, collection: MongoCollection, uid: str):
+        logger.info(f"mongodb -- retrieve:{collection} --")
         collection = self.db.get_collection(collection)
         item = await collection.find_one({"_id": self.oid(uid)})
-        item['_id'] = self.flake_id_from_hex(str(item['_id']))
+        if item:
+            item['_id'] = self.flake_id_from_hex(str(item['_id']))
         return item
 
+    async def search(
+            self, collection: MongoCollection, filters: dict[str, Any], projection: dict[str, int] = None,
+            limit: int = 100
+    ) -> list[dict[str, Any]]:
+        """
+        Search documents in MongoDB based on user-defined filters.
+
+        :param filters: A dictionary of filters to apply.
+        :param projection: A dictionary specifying fields to include or exclude (1 to include, 0 to exclude).
+        :param limit: Maximum number of documents to return.
+        :return: A list of documents matching the filters.
+        """
+        logger.info(f"mongodb -- search:{collection} --")
+        collection = self.db.get_collection(collection)
+        cursor = collection.find(filters, projection).limit(limit)
+        results = []
+        async for document in cursor:
+            results.append(document)
+        return results
+
     async def update(self, collection: MongoCollection, uid: str, data: dict) -> Optional[bool]:
+        logger.info(f"mongodb -- update:{collection} --")
         collection = self.db.get_collection(collection)
         if len(data) < 1:
             return None
@@ -50,6 +79,7 @@ class MongoService:
         return False
 
     async def delete(self, collection: MongoCollection, uid: str) -> bool:
+        logger.info(f"mongodb -- delete:{collection} --")
         collection = self.db.get_collection(collection)
         item = await collection.find_one({"_id": self.oid(uid)})
         if item:
diff --git a/felicity/database/queryset/__init__.py b/felicity/database/queryset/__init__.py
deleted file mode 100644
index 481525f9..00000000
--- a/felicity/database/queryset/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from .builder import QueryBuilder, settable_attributes, smart_query
-from .builderx import SmartQueryMixin, EagerLoadMixin
-
-__all__ = ["QueryBuilder", "settable_attributes", "smart_query", "SmartQueryMixin"]
diff --git a/felicity/database/queryset/builder.py b/felicity/database/queryset/builder.py
deleted file mode 100644
index 8d2929ad..00000000
--- a/felicity/database/queryset/builder.py
+++ /dev/null
@@ -1,646 +0,0 @@
-from collections import OrderedDict, abc
-from typing import TypeVar
-
-from sqlalchemy import asc, desc, inspect, select
-from sqlalchemy.ext.hybrid import hybrid_method, hybrid_property
-from sqlalchemy.orm import (RelationshipProperty, aliased, joinedload,
-                            subqueryload)
-from sqlalchemy.orm.state import InstanceState
-from sqlalchemy.orm.util import AliasedClass
-from sqlalchemy.sql import extract, operators
-
-M = TypeVar("M")
-
-JOINED = "joined"
-SUBQUERY = "subquery"
-
-RELATION_SPLITTER = "___"
-OPERATOR_SPLITTER = "__"
-
-DESC_PREFIX = "-"
-
-
-class ModelNotFoundError(ValueError):
-    pass
-
-
-def _flatten_filter_keys(filters):
-    """
-    :type filters: dict|list
-    Flatten the nested filters, extracting keys where they correspond
-    to smart_query paths, e.g.
-    {or_: {'id__gt': 1000, and_ : {
-        'id__lt': 500,
-        'related___property__in': (1,2,3)
-    }}}
-
-    Yields:
-
-    'id__gt', 'id__lt', 'related___property__in'
-
-    Also allow lists (any abc.Sequence subclass) to enable support
-    of expressions like.
-
-    (X OR Y) AND (W OR Z)
-
-    { and_: [
-        {or_: {'id__gt': 5, 'related_id__lt': 10}},
-        {or_: {'related_id2__gt': 1, 'name__like': 'Bob' }}
-    ]}
-    """
-
-    if isinstance(filters, abc.Mapping):
-        for key, value in filters.items():
-            if callable(key):
-                yield from _flatten_filter_keys(value)
-            else:
-                yield key
-
-    elif isinstance(filters, abc.Sequence):
-        for f in filters:
-            yield from _flatten_filter_keys(f)
-
-    else:
-        raise TypeError(
-            "Unsupported type (%s) in filters: %r", (type(filters), filters)
-        )
-
-
-def _parse_path_and_make_aliases(entity, entity_path, attrs, aliases):
-    """
-    :type entity: InspectionMixin
-    :type entity_path: str
-    :type attrs: list
-    :type aliases: OrderedDict
-
-    Sample values:
-
-    attrs: ['product__subject_ids', 'user_id', '-group_id',
-            'user__name', 'product__name', 'product__grade_from__order']
-    relations: {'product': ['subject_ids', 'name'], 'user': ['name']}
-
-    """
-    relations = {}
-    # take only attributes that have magic RELATION_SPLITTER
-    for attr in attrs:
-        # from attr (say, 'product__grade__order')  take
-        # relationship name ('product') and nested attribute ('grade__order')
-        if RELATION_SPLITTER in attr:
-            relation_name, nested_attr = attr.split(RELATION_SPLITTER, 1)
-            if relation_name in relations:
-                relations[relation_name].append(nested_attr)
-            else:
-                relations[relation_name] = [nested_attr]
-
-    for relation_name, nested_attrs in relations.items():
-        path = (
-            entity_path + RELATION_SPLITTER + relation_name
-            if entity_path
-            else relation_name
-        )
-        if relation_name not in entity.relations:
-            raise KeyError(
-                "Incorrect path `{}`: "
-                "{} doesnt have `{}` relationship ".format(path, entity, relation_name)
-            )
-        relationship = getattr(entity, relation_name)
-        alias = aliased(relationship.property.mapper.class_)
-        aliases[path] = alias, relationship
-        _parse_path_and_make_aliases(alias, path, nested_attrs, aliases)
-
-
-def _get_root_cls(query):
-    # sqlalchemy < 1.4.0
-    if hasattr(query, "_entity_zero"):
-        return query._entity_zero().class_
-
-    # sqlalchemy >= 1.4.0
-    else:
-        if hasattr(query, "_entity_from_pre_ent_zero"):
-            return query._entity_from_pre_ent_zero().class_
-
-        # sqlalchemy 2.x
-        else:
-            if query.__dict__["_propagate_attrs"]["plugin_subject"].class_:
-                return query.__dict__["_propagate_attrs"]["plugin_subject"].class_
-
-    raise ValueError("Cannot get a root class from`{}`".format(query))
-
-
-def filter_expr(model, **filters):
-    """
-    forms expressions like [Product.age_from = 5,
-                            Product.subject_ids.in_([1,2])]
-    from filters like {'age_from': 5, 'subject_ids__in': [1,2]}
-
-    Example 1:
-        db.query(Product).filter(
-            *Product.filter_expr(age_from = 5, subject_ids__in=[1, 2]))
-
-    Example 2:
-        filters = {'age_from': 5, 'subject_ids__in': [1,2]}
-        db.query(Product).filter(*Product.filter_expr(**filters))
-
-
-    ### About alias ###:
-    If we will use alias:
-        alias = aliased(Product) # table name will be product_1
-    we can't just write query like
-        db.query(alias).filter(*Product.filter_expr(age_from=5))
-    because it will be compiled to
-        SELECT * FROM product_1 WHERE product.age_from=5
-    which is wrong: we select from 'product_1' but filter on 'product'
-    such filter will not work
-
-    We need to obtain
-        SELECT * FROM product_1 WHERE product_1.age_from=5
-    For such case, we can call filter_expr ON ALIAS:
-        alias = aliased(Product)
-        db.query(alias).filter(*alias.filter_expr(age_from=5))
-
-    Alias realization details:
-      * we allow to call this method
-        either ON ALIAS (say, alias.filter_expr())
-        or on class (Product.filter_expr())
-      * when method is called on alias, we need to generate SQL using
-        aliased table (say, product_1), but we also need to have a real
-        class to call methods on (say, Product.relations)
-      * so, we have 'mapper' that holds table name
-        and 'cls' that holds real class
-
-        when we call this method ON ALIAS, we will have:
-            mapper = <product_1 table>
-            cls = <Product>
-        when we call this method ON CLASS, we will simply have:
-            mapper = <Product> (or we could write <Product>.__mapper__.
-                                It doesn't matter because when we call
-                                <Product>.getattr, SA will magically
-                                call <Product>.__mapper__.getattr())
-            cls = <Product>
-    """
-    if isinstance(model, AliasedClass):
-        mapper, cls = model, inspect(model).mapper.class_
-    else:
-        mapper = cls = model
-
-    expressions = []
-    valid_attributes = filterable_attributes(model)
-    for attr, value in filters.items():
-        # if attribute is filtered by method, call this method
-        if attr in hybrid_methods(model):
-            method = getattr(cls, attr)
-            expressions.append(method(value, mapper=mapper))
-        # else just add simple condition (== for scalars or IN for lists)
-        else:
-            # determine attrbitute name and operator
-            # if they are explicitly set (say, id___between), take them
-            if OPERATOR_SPLITTER in attr:
-                attr_name, op_name = attr.rsplit(OPERATOR_SPLITTER, 1)
-                if op_name not in _operators:
-                    raise KeyError(
-                        "Expression `{}` has incorrect "
-                        "operator `{}`".format(attr, op_name)
-                    )
-                op = _operators[op_name]
-            # assume equality operator for other cases (say, id=1)
-            else:
-                attr_name, op = attr, operators.eq
-
-            if attr_name not in valid_attributes:
-                raise KeyError(
-                    "Expression `{}` "
-                    "has incorrect attribute `{}`".format(attr, attr_name)
-                )
-
-            column = getattr(mapper, attr_name)
-            expressions.append(op(column, value))
-
-    return expressions
-
-
-def smart_query(query, filters=None, sort_attrs=None, schema=None):
-    """
-    Does magic Django-ish joins like post___user___name__startswith='Bob'
-     (see https://goo.gl/jAgCyM)
-    Does filtering, sorting and eager loading at the same time.
-    And if, say, filters and sorting need the same joinm it will be done
-     only one. That's why all stuff is combined in single method
-
-    :param query: sqlalchemy.orm.query.Query
-    :param filters: dict
-    :param sort_attrs: List[basestring]
-    :param schema: dict
-    """
-    if not filters:
-        filters = {}
-    if not sort_attrs:
-        sort_attrs = []
-
-    # sqlalchemy >= 1.4.0, should probably a. check something else to determine if we need to convert
-    # AppenderQuery to a query, b. probably not hack it like this
-    # noinspection PyProtectedMember
-    if type(query).__name__ == "AppenderQuery" and query._statement:
-        sess = query.session
-        # noinspection PyProtectedMember
-        query = query._statement
-        query.session = sess
-
-    root_cls = _get_root_cls(query)  # for example, User or Post
-    attrs = list(_flatten_filter_keys(filters)) + list(
-        map(lambda s: s.lstrip(DESC_PREFIX), sort_attrs)
-    )
-    aliases = OrderedDict({})
-    _parse_path_and_make_aliases(root_cls, "", attrs, aliases)
-
-    loaded_paths = []
-    for path, al in aliases.items():
-        relationship_path = path.replace(RELATION_SPLITTER, ".")
-        query = query.outerjoin(al[0], al[1])
-        loaded_paths.append(relationship_path)
-
-    def recurse_filters(_filters):
-        if isinstance(_filters, abc.Mapping):
-            for attr, value in _filters.items():
-                if callable(attr):
-                    # E.g. or_, and_, or other sqlalchemy expression
-                    yield attr(*recurse_filters(value))
-                    continue
-                if RELATION_SPLITTER in attr:
-                    parts = attr.rsplit(RELATION_SPLITTER, 1)
-                    entity, attr_name = aliases[parts[0]][0], parts[1]
-                else:
-                    entity, attr_name = root_cls, attr
-                try:
-                    yield from filter_expr(entity, **{attr_name: value})
-                except KeyError as e:
-                    raise KeyError("Incorrect filter path `{}`: {}".format(attr, e))
-
-        elif isinstance(_filters, abc.Sequence):
-            for f in _filters:
-                yield from recurse_filters(f)
-
-    query = query.filter(*recurse_filters(filters))
-
-    for attr in sort_attrs:
-        if RELATION_SPLITTER in attr:
-            prefix = ""
-            if attr.startswith(DESC_PREFIX):
-                prefix = DESC_PREFIX
-                attr = attr.lstrip(DESC_PREFIX)
-            parts = attr.rsplit(RELATION_SPLITTER, 1)
-            entity, attr_name = aliases[parts[0]][0], prefix + parts[1]
-        else:
-            entity, attr_name = root_cls, attr
-        try:
-            query = query.order_by(*order_expr(entity, attr_name))
-        except KeyError as e:
-            raise KeyError("Incorrect order path `{}`: {}".format(attr, e))
-
-    if schema:
-        query = query.options(*_eager_expr_from_schema(schema))
-
-    return query
-
-
-def eager_expr(schema):
-    """
-    :type schema: dict
-    """
-    return _eager_expr_from_schema(schema)
-
-
-def _flatten_schema(schema):
-    """
-    :type schema: dict
-    """
-
-    def _flatten(schema, parent_path, result):
-        """
-        :type schema: dict
-        """
-        for path, value in schema.items():
-            # for supporting schemas like Product.user: {...},
-            # we transform, say, Product.user to 'user' string
-            attr = path
-            path = path.key
-
-            if isinstance(value, tuple):
-                join_method, inner_schema = value[0], value[1]
-            elif isinstance(value, dict):
-                join_method, inner_schema = JOINED, value
-            else:
-                join_method, inner_schema = value, None
-
-            full_path = parent_path + "." + path if parent_path else path
-            result[attr] = join_method
-
-            if inner_schema:
-                _flatten(inner_schema, full_path, result)
-
-    result = {}
-    _flatten(schema, "", result)
-    return result
-
-
-def _eager_expr_from_flat_schema(flat_schema):
-    """
-    :type flat_schema: dict
-    """
-    result = []
-    for path, join_method in flat_schema.items():
-        if join_method == JOINED:
-            result.append(joinedload(path))
-        elif join_method == SUBQUERY:
-            result.append(subqueryload(path))
-        else:
-            raise ValueError("Bad join method `{}` in `{}`".format(join_method, path))
-    return result
-
-
-def _eager_expr_from_schema(schema):
-    def _get_expr(schema, result):
-        for path, value in schema.items():
-            if isinstance(value, tuple):
-                join_method, inner_schema = value[0], value[1]
-                load_option = _create_eager_load_option(path, join_method)
-                result.append(
-                    load_option.options(*_eager_expr_from_schema(inner_schema))
-                )
-            elif isinstance(value, dict):
-                join_method, inner_schema = JOINED, value
-                load_option = _create_eager_load_option(path, join_method)
-                result.append(
-                    load_option.options(*_eager_expr_from_schema(inner_schema))
-                )
-                # load_option = _create_eager_load_option(path, value)
-            else:
-                result.append(_create_eager_load_option(path, value))
-
-    result = []
-    _get_expr(schema, result)
-    return result
-
-
-def _create_eager_load_option(path, join_method):
-    if join_method == JOINED:
-        return joinedload(path)
-    elif join_method == SUBQUERY:
-        return subqueryload(path)
-    else:
-        raise ValueError("Bad join method `{}` in `{}`".format(join_method, path))
-
-
-def order_expr(model, *columns):
-    """
-    Forms expressions like [desc(User.first_name), asc(User.phone)]
-      from list like ['-first_name', 'phone']
-
-    Example for 1 column:
-      db.query(User).order_by(*User.order_expr('-first_name'))
-      # will compile to ORDER BY user.first_name DESC
-
-    Example for multiple columns:
-      columns = ['-first_name', 'phone']
-      db.query(User).order_by(*User.order_expr(*columns))
-      # will compile to ORDER BY user.first_name DESC, user.phone ASC
-
-    About cls_or_alias, mapper, cls: read in filter_expr method description
-    """
-
-    expressions = []
-    for attr in columns:
-        fn, attr = (desc, attr[1:]) if attr.startswith(DESC_PREFIX) else (asc, attr)
-        if attr not in sortable_attributes(model):
-            raise KeyError("Cant order {} by {}".format(model, attr))
-
-        expr = fn(getattr(model, attr))
-        expressions.append(expr)
-    return expressions
-
-
-_operators = {
-    "isnull": lambda c, v: (c == None) if v else (c != None),
-    "exact": operators.eq,
-    "ne": operators.ne,  # not equal or is not (for None)
-    "gt": operators.gt,  # greater than , >
-    "ge": operators.ge,  # greater than or equal, >=
-    "lt": operators.lt,  # lower than, <
-    "le": operators.le,  # lower than or equal, <=
-    "in": operators.in_op,
-    "notin": operators.notin_op,
-    "between": lambda c, v: c.between(v[0], v[1]),
-    "like": operators.like_op,
-    "ilike": operators.ilike_op,
-    "startswith": operators.startswith_op,
-    "istartswith": lambda c, v: c.ilike(v + "%"),
-    "endswith": operators.endswith_op,
-    "iendswith": lambda c, v: c.ilike("%" + v),
-    "contains": lambda c, v: c.ilike("%{v}%".format(v=v)),
-    "year": lambda c, v: extract("year", c) == v,
-    "year_ne": lambda c, v: extract("year", c) != v,
-    "year_gt": lambda c, v: extract("year", c) > v,
-    "year_ge": lambda c, v: extract("year", c) >= v,
-    "year_lt": lambda c, v: extract("year", c) < v,
-    "year_le": lambda c, v: extract("year", c) <= v,
-    "month": lambda c, v: extract("month", c) == v,
-    "month_ne": lambda c, v: extract("month", c) != v,
-    "month_gt": lambda c, v: extract("month", c) > v,
-    "month_ge": lambda c, v: extract("month", c) >= v,
-    "month_lt": lambda c, v: extract("month", c) < v,
-    "month_le": lambda c, v: extract("month", c) <= v,
-    "day": lambda c, v: extract("day", c) == v,
-    "day_ne": lambda c, v: extract("day", c) != v,
-    "day_gt": lambda c, v: extract("day", c) > v,
-    "day_ge": lambda c, v: extract("day", c) >= v,
-    "day_lt": lambda c, v: extract("day", c) < v,
-    "day_le": lambda c, v: extract("day", c) <= v,
-}
-
-
-def _klass(obj):
-    if isinstance(inspect(obj), InstanceState):  # type(inspect(obj)) ==InstanceState
-        return obj._sa_instance_state.mapper.class_
-    return obj
-
-
-def columns(model):
-    """classproperty"""
-    cls = _klass(model)
-    return inspect(cls).columns.keys()
-
-
-def primary_keys_full(model):
-    """classproperty
-    Get primary key properties for a SQLAlchemy cls.
-    Taken from marshmallow_sqlalchemy
-    """
-    cls = _klass(model)
-    mapper = cls.__mapper__
-    return [mapper.get_property_by_column(column) for column in mapper.primary_key]
-
-
-def primary_keys(model):
-    """classproperty"""
-    cls = _klass(model)
-    return [pk.key for pk in primary_keys_full(cls)]
-
-
-def relations(model):
-    """classproperty
-    Return a `list` of relationship names or the given model"""
-    cls = _klass(model)
-    return [c.key for c in cls.__mapper__.attrs if isinstance(c, RelationshipProperty)]
-
-
-def settable_relations(model):
-    """classproperty
-    Return a `list` of relationship names or the given model"""
-    cls = _klass(model)
-    return [r for r in relations(cls) if getattr(model, r).property.viewonly is False]
-
-
-def hybrid_properties(model):
-    """classproperty"""
-    cls = _klass(model)
-    items = inspect(cls).all_orm_descriptors
-    return [item.__name__ for item in items if isinstance(item, hybrid_property)]
-
-
-def hybrid_methods_full(model):
-    """classproperty"""
-    cls = _klass(model)
-    items = inspect(cls).all_orm_descriptors
-    return {item.func.__name__: item for item in items if type(item) == hybrid_method}
-
-
-def hybrid_methods(model):
-    """classproperty"""
-    cls = _klass(model)
-    return list(hybrid_methods_full(cls).keys())
-
-
-def filterable_attributes(model):
-    cls = _klass(model)
-    return relations(cls) + columns(cls) + hybrid_properties(cls) + hybrid_methods(cls)
-
-
-def sortable_attributes(model):
-    cls = _klass(model)
-    return columns(cls) + hybrid_properties(cls)
-
-
-def settable_attributes(model):
-    cls = _klass(model)
-    return sortable_attributes(cls) + settable_relations(cls)
-
-
-class QueryBuilder:
-    def __init__(self, model: M) -> None:
-        self.model = model
-
-    @property
-    def query(self):
-        return select(self.model)
-
-    def with_(self, schema):
-        """
-        Query class and eager load schema at once.
-        :type schema: dict
-
-        Example:
-            schema = {
-                Post.user: JOINED,  # joinedload user
-                Post.comments: (SUBQUERY, { # load comments in separate query
-                    Comment.user: JOINED  # but, in this separate query, join user
-                })
-            }
-            User.with_(schema).first()
-        """
-        return self.query.options(*eager_expr(schema or {}))
-
-    def with_joined(self, *paths):
-        """
-        Eagerload for simple cases where we need to just
-         joined load some relations
-        You can only load direct relationships.
-
-        :type paths: *List[QueryableAttribute]
-
-        Example 1:
-            Comment.with_joined(Comment.user, Comment.post).first()
-        """
-        options = [joinedload(path) for path in paths]
-        return self.query.options(*options)
-
-    def with_subquery(self, *paths):
-        """
-        Eagerload for simple cases where we need to just
-         joined load some relations
-        You can only load direct relationships.
-
-        :type paths: *List[QueryableAttribute]
-
-        Example 1:
-            User.with_subquery(User.posts, User.comments).all()
-        """
-        options = [subqueryload(path) for path in paths]
-        return self.query.options(*options)
-
-    def smart_query(self, filters=None, sort_attrs=None, schema=None):
-        """
-        Does magic Django-ish joins like post___user___name__startswith='Bob'
-         (see https://goo.gl/jAgCyM)
-        Does filtering, sorting and eager loading at the same time.
-        And if, say, filters and sorting need the same joinm it will be done
-         only one. That's why all stuff is combined in single method
-
-        :param filters: dict
-        :param sort_attrs: List[basestring]
-        :param schema: dict
-        """
-        return smart_query(self.query, filters, sort_attrs, schema)
-
-    def where(self, **filters):
-        """
-        Shortcut for smart_query() method
-        Example 1:
-          Product.where(subject_ids__in=[1,2], grade_from_id=2).all()
-
-        Example 2:
-          filters = {'subject_ids__in': [1,2], 'grade_from_id': 2}
-          Product.where(**filters).all()
-
-        Example 3 (with joins):
-          Post.where(public=True, user___name__startswith='Bi').all()
-        """
-        return self.smart_query(filters)
-
-    def sort(self, *columns):
-        """
-        Shortcut for smart_query() method
-        Example 1:
-            User.sort('first_name','-user_id')
-        This is equal to
-            db.query(User).order_by(*User.order_expr('first_name','-user_id'))
-
-        Example 2:
-            columns = ['first_name','-user_id']
-            User.sort(*columns)
-        This is equal to
-            columns = ['first_name','-user_id']
-            db.query(User).order_by(*User.order_expr(*columns))
-
-        Exanple 3 (with joins):
-            Post.sort('comments___rating', 'user___name').all()
-        """
-        return self.smart_query({}, columns)
-
-    async def fill(self, **kwargs):
-        model = self.model
-        for name in kwargs.keys():
-            if name in settable_attributes(model):
-                setattr(model, name, kwargs[name])
-            else:
-                raise KeyError("Attribute '{}' doesn't exist".format(name))
-
-        return model
diff --git a/webapp/components/audit/FelAuditLog.vue b/webapp/components/audit/FelAuditLog.vue
index 34396b89..c03d2f99 100644
--- a/webapp/components/audit/FelAuditLog.vue
+++ b/webapp/components/audit/FelAuditLog.vue
@@ -8,10 +8,10 @@ const LoadingMessage = defineAsyncComponent(
 )
 
 const props = defineProps({
-  targetId: String,
+  targetUid: String,
   targetType: String,
 });
-const { targetType, targetId } = toRefs(props);
+const { targetType, targetUid } = toRefs(props);
 
 const userStore = useUserStore();
 const auditLogStore = useAuditLogStore();
@@ -22,14 +22,14 @@ const { auditLogs, fetchingAudits } = storeToRefs(auditLogStore);
 userStore.fetchUsers({});
 auditLogStore.fetchAuditLogs({
   targetType: targetType?.value,
-  targetId: targetId?.value,
+  targetUid: targetUid?.value,
 });
 
 let users = computed(() => userStore.getUsers);
 
-function translateUser(userId: any): string {
+function translateUser(userUid: any): string {
   const user = users?.value?.find(
-    (u: any) => u["uid"]?.toString() === userId?.toString()
+    (u: any) => u["uid"]?.toString() === userUid?.toString()
   );
   if (!user) return "";
   return (user as any)["userName"];
@@ -104,7 +104,7 @@ function changes(log: any): any {
           <div class="bg-indigo-600 rounded-full h-4 w-4 border-gray-200 border-2 z-10"></div>
           <div class="ml-4 font-medium italic">
             <span>
-              {{ translateUser(log?.userId) }} {{ translateAction(log?.action) }}
+              {{ translateUser(log?.userUid) }} {{ translateAction(log?.action) }}
               {{ log?.targetType }}
             </span>
             on <span> {{ parseDate(log?.stateAfter?.updated_at) }}</span>
diff --git a/webapp/components/result/ResultDetail.vue b/webapp/components/result/ResultDetail.vue
index 937ac4ec..7c926e63 100644
--- a/webapp/components/result/ResultDetail.vue
+++ b/webapp/components/result/ResultDetail.vue
@@ -61,5 +61,5 @@ const columns = [
     <span v-else>No Mutations for this result</span>
     <h4 class="mt-4 font-bold text-xl text-gray-500">Result Audit Log</h4>
     <hr>
-    <FelAuditLog targetType="analysis_result" :targetId="analysisResultesultUid" />
+    <FelAuditLog targetType="analysis_result" :targetUid="analysisResultesultUid" />
 </template>
diff --git a/webapp/graphql/operations/_queries.ts b/webapp/graphql/operations/_queries.ts
index 00f44c79..75564d55 100644
--- a/webapp/graphql/operations/_queries.ts
+++ b/webapp/graphql/operations/_queries.ts
@@ -103,12 +103,12 @@ export const GET_GROUPS_AND_PERMISSIONS = gql`
 `;
 
 export const GET_AUDIT_LOG_FOR_TARGET = gql`
-    query getAuditLogs($targetType: String!, $targetId: String!) {
-        auditLogsFilter(targetType: $targetType, targetId: $targetId) {
+    query getAuditLogs($targetType: String!, $targetUid: String!) {
+        auditLogsFilter(targetType: $targetType, targetUid: $targetUid) {
             uid
-            userId
+            userUid
             targetType
-            targetId
+            targetUid
             action
             stateBefore
             stateAfter
diff --git a/webapp/views/client/_id/ClientDetail.vue b/webapp/views/client/_id/ClientDetail.vue
index f3294e9f..2c52bc6c 100644
--- a/webapp/views/client/_id/ClientDetail.vue
+++ b/webapp/views/client/_id/ClientDetail.vue
@@ -30,7 +30,7 @@ let client = computed(() => clientStore.getClient);
     <div class="pt-4">
       <tab-samples v-if="currentTab === 'samples'" />
       <tab-contacts v-if="currentTab === 'contacts'" :clientUid="client?.uid" />
-      <tab-logs v-if="currentTab === 'logs'" targetType="client" :targetId="client?.uid" />
+      <tab-logs v-if="currentTab === 'logs'" targetType="client" :targetUid="client?.uid" />
     </div>
   </section>
 </template>
diff --git a/webapp/views/patient/PatientsCompact.vue b/webapp/views/patient/PatientsCompact.vue
index 9f025174..806faeb3 100644
--- a/webapp/views/patient/PatientsCompact.vue
+++ b/webapp/views/patient/PatientsCompact.vue
@@ -179,7 +179,7 @@ const updatePatient = (patient: IPatient) => {
         <tab-samples v-if="currentTab === 'samples'" target="patient-samples" :targetUid="patientForm.uid" />
         <tab-cases v-if="currentTab === 'cases'" />
         <tab-patient-bills v-if="currentTab === 'billing'"  :patientUid="patientForm?.uid" />
-        <tab-logs v-if="currentTab === 'logs'" targetType="patient" :targetId="patientForm?.uid" />
+        <tab-logs v-if="currentTab === 'logs'" targetType="patient" :targetUid="patientForm?.uid" />
       </section>
     </div>
 
diff --git a/webapp/views/patient/_id/PatientDetail.vue b/webapp/views/patient/_id/PatientDetail.vue
index 95c9055e..ce4d0bf9 100644
--- a/webapp/views/patient/_id/PatientDetail.vue
+++ b/webapp/views/patient/_id/PatientDetail.vue
@@ -64,7 +64,7 @@ function addSample(patient?: IPatient): void {
       <div>
         <tab-samples v-if="currentTab === 'samples'" target="patient-samples" :targetUid="patient?.uid" />
         <tab-cases v-if="currentTab === 'cases'" />
-        <tab-logs v-if="currentTab === 'logs'" targetType="patient" :targetId="patient?.uid" />
+        <tab-logs v-if="currentTab === 'logs'" targetType="patient" :targetUid="patient?.uid" />
         <tab-patient-bills v-if="currentTab === 'billing'"  :patientUid="patient?.uid" />
       </div>
     </section>
diff --git a/webapp/views/sample/_id/SampleDetail.vue b/webapp/views/sample/_id/SampleDetail.vue
index c0254b4b..11bee316 100644
--- a/webapp/views/sample/_id/SampleDetail.vue
+++ b/webapp/views/sample/_id/SampleDetail.vue
@@ -55,7 +55,7 @@ let currentTabComponent = computed(() => "tab-" + currentTab);
       <tab-logs
         v-if="currentTab === 'logs'"
         targetType="sample"
-        :targetId="sampleStore.sample?.uid"
+        :targetUid="sampleStore.sample?.uid"
       />
       <tab-impress v-if="currentTab === 'impress-reports'" />
     </div>
diff --git a/webapp/views/shipment/_id/ShipmentDetail.vue b/webapp/views/shipment/_id/ShipmentDetail.vue
index decfb1f1..65f3c80c 100644
--- a/webapp/views/shipment/_id/ShipmentDetail.vue
+++ b/webapp/views/shipment/_id/ShipmentDetail.vue
@@ -56,7 +56,7 @@
           <tab-logs 
           v-if="currentTab === 'logs'"
           targetType="shipment"
-          :targetId="shipment?.uid"
+          :targetUid="shipment?.uid"
           />
         </div>
 
diff --git a/webapp/views/worksheet/_id/WorkSheetDetail.vue b/webapp/views/worksheet/_id/WorkSheetDetail.vue
index 642ea81a..21622461 100644
--- a/webapp/views/worksheet/_id/WorkSheetDetail.vue
+++ b/webapp/views/worksheet/_id/WorkSheetDetail.vue
@@ -47,7 +47,7 @@
           <tab-logs 
           v-if="currentTab === 'logs'"
           targetType="worksheet"
-          :targetId="worksheet?.uid"
+          :targetUid="worksheet?.uid"
           />
         </div>