howler-api 4.1.0.dev1588__tar.gz → 4.1.0.dev1611__tar.gz

{howler_api-4.1.0.dev1588 → howler_api-4.1.0.dev1611}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: howler-api
-Version: 4.1.0.dev1588
+Version: 4.1.0.dev1611
 Summary: Howler - API server
 License: MIT
 Keywords: howler,alerting,gc,canada,cse-cst,cse,cst,cyber,cccs

{howler_api-4.1.0.dev1588 → howler_api-4.1.0.dev1611}/howler/api/v1/action.py

@@ -4,6 +4,7 @@ from flask import Response, request
 
 import howler.actions as actions
 from howler.api import bad_request, created, forbidden, internal_error, make_subapi_blueprint, no_content, not_found, ok
+from howler.api.v1.utils import permission_helper
 from howler.api.v1.utils.etag import add_etag
 from howler.api.v1.utils.params import parse_parameters, parse_refresh
 from howler.common.exceptions import HowlerException
@@ -21,6 +22,7 @@ classification_definition = CLASSIFICATION.get_parsed_classification_definition(
 
 action_api = make_subapi_blueprint(SUB_API, api_version=1)
 action_api._doc = "Endpoints relating to bulk actions and automation"  # type: ignore
+permission_helper.add_access_control_endpoints(action_api, Action)
 
 
 @generate_swagger_docs()
@@ -117,7 +119,7 @@ def add_action(user: User, **kwargs) -> Response:
         return error
 
     try:
-        new_action["owner_id"] = user.uname
+        new_action["owner"] = user.uname
 
         action_obj = Action(new_action)
 
@@ -168,6 +170,9 @@ def update_action(id: str, user: User, **kwargs) -> Response:
     if not isinstance(updated_action, dict):
         return bad_request(err="Incorrect data structure!")
 
+    if set(updated_action) & {"owner", "admins", "members"}:
+        return bad_request(err="You cannot change permissions using this endpoint.")
+
     refresh = kwargs.get("refresh")
 
     ds = datastore()
@@ -182,6 +187,12 @@ def update_action(id: str, user: User, **kwargs) -> Response:
     ):
         return forbidden(err="Updating triggers requires the role 'automation_advanced'.")
 
+    is_action_admin = user.uname == existing_action.get("owner") or user.uname in existing_action.get("admins", [])
+    if not is_action_admin and "admin" not in user.type:
+        return forbidden(
+            err="You cannot update an action that is not owned by you, or you are not an administrator of."
+        )
+
     updated_action = {
         **existing_action,
         **updated_action,
@@ -230,7 +241,7 @@ def delete_action(id: str, user: User, **kwargs) -> Response:
 
     action: Action = result["items"][0]
 
-    if action.owner_id != user.uname and "admin" not in user.type:
+    if action.owner != user.uname and "admin" not in user.type:
         return forbidden(err="You do not have the permissions necessary to delete this action.")
 
     try:

{howler_api-4.1.0.dev1588 → howler_api-4.1.0.dev1611}/howler/api/v1/dossier.py

@@ -1,6 +1,7 @@
 from flask import request
 
 from howler.api import bad_request, created, forbidden, internal_error, make_subapi_blueprint, no_content, not_found, ok
+from howler.api.v1.utils import permission_helper
 from howler.api.v1.utils.params import parse_parameters, parse_refresh
 from howler.common.exceptions import (
     ForbiddenException,
@@ -19,6 +20,7 @@ from howler.services import dossier_service
 SUB_API = "dossier"
 dossier_api = make_subapi_blueprint(SUB_API, api_version=1)
 dossier_api._doc = "Manage the different dossiers created for filtering hits"  # type: ignore
+permission_helper.add_access_control_endpoints(dossier_api, Dossier)
 
 logger = get_logger(__file__)
 
@@ -185,7 +187,7 @@ def delete_dossier(id: str, user: User, **kwargs):
         return not_found(err="This dossier does not exist")
 
     if existing_dossier.owner != user.uname and "admin" not in user.type:
-        return forbidden(err="You cannot delete a dossier unless you are an administrator, or the owner.")
+        return forbidden(err="You cannot delete a dossier unless you are a global administrator or the owner.")
 
     success = storage.dossier.delete(id, refresh=refresh)
 

howler_api-4.1.0.dev1611/howler/api/v1/utils/permission_helper.py

@@ -0,0 +1,83 @@
+from flask import Blueprint, Response
+
+from howler.api import bad_request, conflict, forbidden, ok
+from howler.api.v1.utils.params import parse_parameters, parse_refresh
+from howler.common.exceptions import ForbiddenException, InvalidDataException
+from howler.common.swagger import generate_swagger_docs
+from howler.datastore.exceptions import VersionConflictException
+from howler.odm.models.ownership import Ownership
+from howler.odm.models.user import User
+from howler.security.login import api_login
+from howler.services import permission_service
+
+
+def add_access_control_endpoints(api: Blueprint, odm: type[Ownership]):
+    """Add access control routes for managing user permissions."""
+
+    @generate_swagger_docs()
+    @api.route("/<id>/permission", methods=["PUT"])
+    @api_login(required_priv=["R", "W"])
+    @parse_parameters(refresh=parse_refresh)
+    def give_privilege(id: str, user: User, **kwargs) -> Response:
+        """Grant a permission on an action, dossier, or view.
+
+        Variables:
+        id => The identifier of the object whose permissions should be updated.
+
+        Arguments:
+        None
+
+        Optional Arguments:
+        refresh => ('true' | 'false' | 'wait_for') Whether to refresh the datastore before returning.
+
+        Data Block:
+        {
+            "privilege": "members",       # The permission level: 'owner', 'admins', or 'members'
+            "user_ids": ["username"]       # The users receiving the permission
+        }
+
+        Result Example:
+        {
+            ...object   # The updated action, dossier, or view
+        }
+        """
+        try:
+            result = permission_service.give_privilege(id, user, odm, refresh=kwargs.get("refresh"))
+        except VersionConflictException:
+            return conflict(err="Someone has updated this item. Please try again")
+        except ForbiddenException as e:
+            return forbidden(err=e.message)
+        except (ValueError, InvalidDataException) as e:
+            return bad_request(err=str(e))
+        return ok(result)
+
+    @generate_swagger_docs()
+    @api.route("/<id>/permission", methods=["DELETE"])
+    @api_login(required_priv=["R", "W"])
+    @parse_parameters(refresh=parse_refresh)
+    def remove_privilege(id: str, user: User, **kwargs) -> Response:
+        """Revoke a permission on an action, dossier, or view.
+
+        Variables:
+        id => The identifier of the object whose permissions should be updated.
+
+        Arguments:
+        None
+
+        Optional Arguments:
+        refresh => ('true' | 'false' | 'wait_for') Whether to refresh the datastore before returning.
+
+        Result Example:
+        {
+            ...object   # The updated action, dossier, or view
+        }
+        """
+        try:
+            result = permission_service.remove_privilege(id, user, odm, refresh=kwargs.get("refresh"))
+        except VersionConflictException:
+            return conflict(err="Someone has updated this item. Please try again")
+        except ForbiddenException as e:
+            return forbidden(err=e.message)
+        except (ValueError, InvalidDataException) as e:
+            return bad_request(err=str(e))
+        return ok(result)

{howler_api-4.1.0.dev1588 → howler_api-4.1.0.dev1611}/howler/api/v1/view.py

@@ -4,6 +4,7 @@ from flask import request
 from mergedeep.mergedeep import merge
 
 from howler.api import bad_request, created, forbidden, make_subapi_blueprint, no_content, not_found, ok
+from howler.api.v1.utils import permission_helper
 from howler.api.v1.utils.params import parse_parameters, parse_refresh
 from howler.common.exceptions import HowlerException
 from howler.common.loader import datastore
@@ -17,6 +18,7 @@ from howler.security.login import api_login
 SUB_API = "view"
 view_api = make_subapi_blueprint(SUB_API, api_version=1)
 view_api._doc = "Manage the different views created for filtering hits"  # type: ignore
+permission_helper.add_access_control_endpoints(view_api, View)
 
 logger = get_logger(__file__)
 
@@ -41,7 +43,10 @@ def get_views(user: User, **kwargs):
     try:
         return ok(
             datastore().view.search(
-                f"type:global OR owner:({user['uname']} OR none)", as_obj=False, rows=1000, sort="title asc"
+                f"type:global OR owner:({user['uname']} OR none) OR admins:{user['uname']} OR members:{user['uname']}",
+                as_obj=False,
+                rows=1000,
+                sort="title asc",
             )["items"]
         )
     except ValueError as e:
@@ -52,7 +57,7 @@ def get_views(user: User, **kwargs):
 @view_api.route("/", methods=["POST"])
 @api_login(required_priv=["R", "W"])
 @parse_parameters(refresh=parse_refresh)
-def create_view(**kwargs):
+def create_view(user: User, **kwargs):
     """Create a new view
 
     Variables:
@@ -95,12 +100,12 @@ def create_view(**kwargs):
         # Make sure the query is valid
         storage.hit.search(view_data["query"])
 
-        view = View(view_data)
+        view_data["owner"] = user.uname
 
-        view.owner = kwargs["user"]["uname"]
+        view = View(view_data)
 
         if view.type == "personal":
-            current_user = storage.user.get_if_exists(kwargs["user"]["uname"])
+            current_user = storage.user.get_if_exists(user.uname)
 
             current_user.favourite_views.append(view.view_id)
 
@@ -145,7 +150,7 @@ def delete_view(view_id: str, user: User, **kwargs):
         return not_found(err="This view does not exist")
 
     if existing_view.owner != user.uname and "admin" not in user.type:
-        return forbidden(err="You cannot delete a view unless you are an administrator, or the owner.")
+        return forbidden(err="You cannot delete a view unless you are an owner or a global admin.")
 
     if existing_view.type == "readonly":
         return forbidden(err="You cannot delete built-in views.")
@@ -159,7 +164,7 @@ def delete_view(view_id: str, user: User, **kwargs):
 @view_api.route("/<view_id>", methods=["PUT"])
 @api_login(required_priv=["R", "W"])
 @parse_parameters(refresh=parse_refresh)
-def update_view(view_id: str, user: User, **kwargs):
+def update_view(view_id: str, user: User, **kwargs):  # noqa: C901
     """Update a view
 
     Variables:
@@ -188,8 +193,11 @@ def update_view(view_id: str, user: User, **kwargs):
     if not isinstance(new_data, dict):
         return bad_request(err="Invalid data format")
 
-    if set(new_data.keys()) & {"view_id", "owner"}:
-        return bad_request(err="You cannot change the owner or id of a view.")
+    if "view_id" in new_data:
+        return bad_request(err="You cannot change the view ID.")
+
+    if set(new_data) & {"owner", "admins", "members"}:
+        return bad_request(err="You cannot change permissions using this endpoint.")
 
     existing_view: View = storage.view.get_if_exists(view_id)
     if not existing_view:
@@ -198,27 +206,23 @@ def update_view(view_id: str, user: User, **kwargs):
     if existing_view.type == "readonly":
         return forbidden(err="You cannot edit a built-in view.")
 
-    if existing_view.type == "personal" and existing_view.owner != user.uname:
-        return forbidden(err="You cannot update a personal view that is not owned by you.")
-
-    if existing_view.type == "global" and existing_view.owner != user.uname and "admin" not in user.type:
-        return forbidden(err="Only the owner of a view and administrators can edit a global view.")
-
-    new_view = View(cast(dict, merge({}, existing_view.as_primitives(), new_data)))
-
-    storage.view.save(new_view.view_id, new_view, refresh=refresh)
+    is_view_admin = user.uname == existing_view.owner or user.uname in existing_view.admins
+    if not is_view_admin and "admin" not in user.type:
+        return forbidden(err="You cannot update a view that is not owned by you, or you are not an administrator of.")
 
     try:
         if "query" in new_data:
-            # Make sure the query is valid
             storage.hit.search(new_data["query"])
-
-        return ok(storage.view.get_if_exists(existing_view.view_id, as_obj=False))
     except SearchException:
         return bad_request(err="You must use a valid query when updating a view.")
     except HowlerException as e:
         return bad_request(err=str(e))
 
+    new_view = View(cast(dict, merge({}, existing_view.as_primitives(), new_data)))
+    storage.view.save(new_view.view_id, new_view, refresh=refresh)
+
+    return ok(new_view.as_primitives())
+
 
 @generate_swagger_docs()
 @view_api.route("/<view_id>/favourite", methods=["POST"])
@@ -246,10 +250,12 @@ def set_as_favourite(view_id: str, **kwargs):
     if not existing_view:
         return not_found(err="This view does not exist")
 
-    if existing_view.type != "global" and (
-        existing_view.owner != kwargs["user"]["uname"] and existing_view.owner != "none"
+    if (
+        existing_view.type == "personal"
+        and kwargs["user"]["uname"] not in [existing_view.owner, *existing_view.admins, *existing_view.members]
+        and existing_view.owner != "none"
     ):
-        return forbidden(err="You can only favourite global views, or views owned by you.")
+        return forbidden(err="You can only favourite global views, or views you have permission to use.")
 
     try:
         current_user = storage.user.get_if_exists(kwargs["user"]["uname"])

{howler_api-4.1.0.dev1588 → howler_api-4.1.0.dev1611}/howler/datastore/collection.py

@@ -2,11 +2,13 @@ from __future__ import annotations
 
 import json
 import logging
+import math
 import re
 import sys
 import time
 import typing
 import warnings
+from collections.abc import Mapping as ABCMapping
 from copy import deepcopy
 from datetime import datetime
 from os import environ
@@ -170,6 +172,9 @@ class ESCollection(Generic[ModelType]):
     RETRY_NONE = 0
     RETRY_INFINITY = -1
     SCROLL_TIMEOUT = "5m"
+    TASK_POLL_TIMEOUT = 3600.0
+    TASK_POLL_INTERVAL = 0.5
+    MAX_VERSION_CONFLICT_ATTEMPTS = 3
     UPDATE_SET = "SET"
     UPDATE_INC = "INC"
     UPDATE_DEC = "DEC"
@@ -458,37 +463,138 @@ class ESCollection(Generic[ModelType]):
                 else:
                     raise
 
-    def _get_task_results(self: Self, task):
-        # This function is only used to wait for a asynchronous task to finish in a graceful manner without
-        #  timing out the elastic client. You can create an async task for long running operation like:
-        #   - update_by_query
-        #   - delete_by_query
-        #   - reindex ...
-        attempt = 0
-        res = None
-        while res is None:
-            attempt = attempt + 1
-            try:
-                res = self.with_retries(
+    @staticmethod
+    def _task_response_mapping(response, description: str) -> ABCMapping:
+        """Return an Elasticsearch response body as a mapping."""
+        if isinstance(response, ABCMapping):
+            return response
+
+        body = getattr(response, "body", None)
+        if isinstance(body, ABCMapping):
+            return body
+
+        raise DataStoreException(f"Elasticsearch {description} returned a malformed response.")
+
+    @staticmethod
+    def _task_duration(name: str, default: float) -> float:
+        value = environ.get(name, str(default))
+        try:
+            duration = float(value)
+        except ValueError as error:
+            raise DataStoreException(f"{name} must be a non-negative number, got {value!r}") from error
+        if not math.isfinite(duration) or duration < 0:
+            raise DataStoreException(f"{name} must be a non-negative number, got {value!r}")
+        return duration
+
+    def _get_task_results(self: Self, task, strict=True):
+        """Wait for an asynchronous Elasticsearch task to return a final response."""
+        task_response = self._task_response_mapping(task, "task submission")
+        if not isinstance(task_response.get("task"), str) or not task_response["task"]:
+            raise DataStoreException("Elasticsearch did not return a valid task identifier.")
+
+        task_id = task_response["task"]
+        poll_timeout = self._task_duration("HWL_DATASTORE_TASK_POLL_TIMEOUT", self.TASK_POLL_TIMEOUT)
+        poll_interval = self._task_duration("HWL_DATASTORE_TASK_POLL_INTERVAL", self.TASK_POLL_INTERVAL)
+        deadline = time.monotonic() + poll_timeout
+        while True:
+            if time.monotonic() >= deadline:
+                raise HowlerRuntimeError(f"Timed out waiting for Elasticsearch task {task_id} to complete.")
+
+            result = self._task_response_mapping(
+                self.with_retries(
                     self.datastore.client.tasks.get,
-                    task_id=task["task"],
-                    wait_for_completion=True,
-                    timeout="10s",
-                )
-            except (elasticsearch.exceptions.TransportError, elasticsearch.exceptions.ApiError) as e:
-                err_code, msg, _ = e.args
-                if (err_code == 500 or err_code == "500") and msg in [
-                    "timeout_exception",
-                    "receive_timeout_transport_exception",
-                ]:
-                    pass
-                else:
-                    logger.exception("Unexpected error on task check")
-                    raise
+                    task_id=task_id,
+                    wait_for_completion=False,
+                ),
+                f"task {task_id}",
+            )
+            if "error" in result and result["error"] is not None:
+                raise DataStoreException(f"Elasticsearch task {task_id} failed: {result['error']!r}")
+            if result.get("completed") is False:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    raise HowlerRuntimeError(f"Timed out waiting for Elasticsearch task {task_id} to complete.")
+                time.sleep(min(poll_interval, remaining))
+                continue
+            if result.get("completed") is not True:
+                raise DataStoreException(f"Elasticsearch task {task_id} did not report a completion state.")
+
+            response = result.get("response")
+            if not isinstance(response, ABCMapping):
+                raise DataStoreException(f"Elasticsearch task {task_id} completed without a valid response.")
+            response = dict(response)
+            if strict:
+                if response.get("timed_out") is not False:
+                    raise DataStoreException(f"Elasticsearch task {task_id} returned a timeout result.")
+                failures = response.get("failures")
+                if not isinstance(failures, list):
+                    raise DataStoreException(f"Elasticsearch task {task_id} returned an invalid failures list.")
+                if failures:
+                    raise DataStoreException(f"Elasticsearch task {task_id} reported failures: {failures!r}")
+            return response
+
+    @staticmethod
+    def _normalize_query_refresh(refresh):
+        if refresh is None or isinstance(refresh, bool):
+            return refresh
+        if isinstance(refresh, str):
+            normalized = refresh.lower()
+            if normalized == "true":
+                return True
+            if normalized == "false":
+                return False
+            if normalized == "wait_for":
+                return True
+        raise DataStoreException(f"Invalid refresh value for an Elasticsearch query operation: {refresh!r}")
 
-        result = res.get("response", res["task"]["status"])
+    @staticmethod
+    def _validate_async_query_result(result, count_field: str) -> dict[str, Any]:
+        result = ESCollection._task_response_mapping(result, "query task")
+        if result.get("error") is not None:
+            raise DataStoreException(f"Elasticsearch query task failed: {result['error']!r}")
+        if result.get("timed_out") is not False:
+            if result.get("timed_out") is True:
+                raise DataStoreException("Elasticsearch query task timed out.")
+            raise DataStoreException("Elasticsearch query task did not report whether it timed out.")
+
+        failures = result.get("failures")
+        if not isinstance(failures, list):
+            raise DataStoreException("Elasticsearch query task did not return a valid failures list.")
+        if failures:
+            raise DataStoreException(f"Elasticsearch query task reported failures: {failures!r}")
+
+        validated_result = dict(result)
+        for field_name in (count_field, "version_conflicts"):
+            value = validated_result.get(field_name)
+            if isinstance(value, bool) or not isinstance(value, int) or value < 0:
+                raise DataStoreException(f"Elasticsearch query task returned an invalid {field_name} value.")
+
+        return validated_result
+
+    def _run_async_query(self, operation, operation_name: str, count_field: str, **kwargs):
+        refresh = self._normalize_query_refresh(kwargs.pop("refresh", None))
+        if self.MAX_VERSION_CONFLICT_ATTEMPTS < 1:
+            raise DataStoreException("MAX_VERSION_CONFLICT_ATTEMPTS must be at least one.")
+
+        affected_documents = 0
+        for _ in range(self.MAX_VERSION_CONFLICT_ATTEMPTS):
+            task = self.with_retries(
+                operation,
+                **kwargs,
+                wait_for_completion=False,
+                conflicts="proceed",
+                refresh=refresh,
+            )
+            result = self._validate_async_query_result(self._get_task_results(task, strict=True), count_field)
+            affected_documents += result[count_field]
+            if result["version_conflicts"] == 0:
+                result[count_field] = affected_documents
+                return result
 
-        return result
+        raise DataStoreException(
+            f"Elasticsearch {operation_name} did not complete after "
+            f"{self.MAX_VERSION_CONFLICT_ATTEMPTS} version-conflict attempt(s)."
+        )
 
     def _get_current_alias(self: Self, index: str) -> typing.Optional[str]:
         if self.with_retries(self.datastore.client.indices.exists_alias, name=index):
@@ -524,46 +630,28 @@ class ESCollection(Generic[ModelType]):
         self._wait_for_status(target, min_status=min_status)
 
     def _delete_async(self: Self, index, query, max_docs=None, sort=None, refresh=None):
-        deleted = 0
-        while True:
-            task = self.with_retries(
-                self.datastore.client.delete_by_query,
-                index=index,
-                query=query,
-                wait_for_completion=False,
-                conflicts="proceed",
-                sort=sort,
-                max_docs=max_docs,
-                refresh=refresh,
-            )
-            res = self._get_task_results(task)
-
-            if res["version_conflicts"] == 0:
-                res["deleted"] += deleted
-                return res
-            else:
-                deleted += res["deleted"]
+        return self._run_async_query(
+            self.datastore.client.delete_by_query,
+            "delete-by-query",
+            "deleted",
+            index=index,
+            query=query,
+            sort=sort,
+            max_docs=max_docs,
+            refresh=refresh,
+        )
 
     def _update_async(self: Self, index, script, query, max_docs=None, refresh=None):
-        updated = 0
-        while True:
-            task = self.with_retries(
-                self.datastore.client.update_by_query,
-                index=index,
-                script=script,
-                query=query,
-                wait_for_completion=False,
-                conflicts="proceed",
-                max_docs=max_docs,
-                refresh=refresh,
-            )
-            res = self._get_task_results(task)
-
-            if res["version_conflicts"] == 0:
-                res["updated"] += updated
-                return res
-            else:
-                updated += res["updated"]
+        return self._run_async_query(
+            self.datastore.client.update_by_query,
+            "update-by-query",
+            "updated",
+            index=index,
+            script=script,
+            query=query,
+            max_docs=max_docs,
+            refresh=refresh,
+        )
 
     def bulk(self: Self, operations: ElasticBulkPlan, refresh: str | None = None):
         """
@@ -859,7 +947,7 @@ class ESCollection(Generic[ModelType]):
                     wait_for_completion=False,
                 )
                 logger.warning("Reindex taskId: %s", r_task["task"])
-                reindex_result = self._get_task_results(r_task)
+                reindex_result = self._get_task_results(r_task, strict=False)
 
                 # Validate the reindex did not silently drop or conflict on documents before
                 # we commit to deleting the source index further down.
@@ -1447,15 +1535,28 @@ class ESCollection(Generic[ModelType]):
 
         return True
 
-    def delete(self: Self, key, refresh=None):
+    def delete(self: Self, key: str, refresh=None, version=None):
         """This function should delete the underlying document referenced by the key.
         It should return true if the document was in fact properly deleted.
 
         :param key: id of the document to delete
+        :param version: version token returned by ``get_if_exists(..., version=True)`` for an atomic delete
         :return: True is delete successful
         """
+        index = self.name
+        kwargs = {"id": key, "index": index, "refresh": refresh}
+        if version:
+            if version == CREATE_TOKEN:
+                raise DataStoreException("Cannot delete a document using the create version token.")
+            index, seq_no, primary_term = self._get_version_write_target(version)
+            kwargs.update({"index": index, "if_seq_no": seq_no, "if_primary_term": primary_term})
+
         try:
-            info = self.with_retries(self.datastore.client.delete, id=key, index=self.name, refresh=refresh)
+            info = self.with_retries(
+                self.datastore.client.delete,
+                raise_conflicts=bool(version),
+                **kwargs,
+            )
             return info["result"] == "deleted"
         except elasticsearch.NotFoundError:
             return False
@@ -1802,6 +1903,9 @@ class ESCollection(Generic[ModelType]):
         if isinstance(fields, str):
             fields = fields.split(",")
 
+        if source_data is None:
+            source_data = {}
+
         if source_data is not None and (fields is None or "*" in fields or "id" in fields):
             source_data["id"] = [item_id]
 

{howler_api-4.1.0.dev1588 → howler_api-4.1.0.dev1611}/howler/datastore/howler_store.py

@@ -12,6 +12,7 @@ from howler.odm.models.config import ILMIndexConfig
 from howler.odm.models.dossier import Dossier
 from howler.odm.models.event import Event
 from howler.odm.models.hit import Hit
+from howler.odm.models.migration import MigrationRecord
 from howler.odm.models.overview import Overview
 from howler.odm.models.template import Template
 from howler.odm.models.user import User
@@ -29,6 +30,7 @@ INDEXES = {
     "overview": Overview,
     "analytic": Analytic,
     "action": Action,
+    "migration": MigrationRecord,
     "user": User,
     "view": View,
     "dossier": Dossier,
@@ -119,6 +121,10 @@ class HowlerDatastore(object):
     def action(self) -> ESCollection[Action]:
         return self.ds.action
 
+    @property
+    def migration(self) -> ESCollection[MigrationRecord]:
+        return self.ds.migration
+
     @property
     def user(self) -> ESCollection[User]:
         return self.ds.user

howler_api-4.1.0.dev1611/howler/datastore/migrations/__init__.py

@@ -0,0 +1,4 @@
+from howler.datastore.migrations.base import Migration
+from howler.datastore.migrations.runner import MIGRATIONS, run_migrations
+
+__all__ = ["MIGRATIONS", "Migration", "run_migrations"]