infrahub-server 1.2.9__py3-none-any.whl → 1.2.10__py3-none-any.whl

infrahub/core/query/diff.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Generator
 
 from infrahub import config
-from infrahub.core.constants import GLOBAL_BRANCH_NAME, BranchSupportType
+from infrahub.core.constants import GLOBAL_BRANCH_NAME, BranchSupportType, DiffAction, RelationshipStatus
 from infrahub.core.query import Query, QueryType
 from infrahub.core.timestamp import Timestamp
 
@@ -128,12 +129,13 @@ CALL {
     // add base branch paths before branched_from, if they exist
     // -------------------------------------
     WITH n, attr_rel, r_node, r_prop
+    // 'base_n' instead of 'n' here to get previous value for node with a migrated kind/inheritance
     OPTIONAL MATCH latest_base_path = (:Root)<-[base_r_root:IS_PART_OF {branch: $base_branch_name}]
-        -(n)-[base_r_node {branch: $base_branch_name}]
+        -(base_n {uuid: n.uuid})-[base_r_node {branch: $base_branch_name}]
         -(attr_rel)-[base_r_prop {branch: $base_branch_name}]->(base_prop)
     WHERE type(base_r_node) = type(r_node)
     AND type(base_r_prop) = type(r_prop)
-    AND [%(id_func)s(n), type(base_r_node)] <> [%(id_func)s(base_prop), type(base_r_prop)]
+    AND [%(id_func)s(base_n), type(base_r_node)] <> [%(id_func)s(base_prop), type(base_r_prop)]
     AND all(
         r in relationships(latest_base_path)
         WHERE r.from < $branch_from_time
@@ -143,7 +145,7 @@ CALL {
     // the migration leaves two nodes with the same UUID linked to the same Relationship
     // ------------------------
     AND (
-        n.uuid IS NULL OR base_prop.uuid IS NULL OR n.uuid <> base_prop.uuid
+        base_n.uuid IS NULL OR base_prop.uuid IS NULL OR base_n.uuid <> base_prop.uuid
         OR type(base_r_node) <> "IS_RELATED" OR type(base_r_prop) <> "IS_RELATED"
     )
     WITH latest_base_path, base_r_root, base_r_node, base_r_prop
@@ -277,7 +279,7 @@ WITH p, q, diff_rel, CASE
     WHEN $new_node_ids_list IS NOT NULL AND p.uuid IN $new_node_ids_list THEN $branch_from_time
     ELSE $from_time
 END AS row_from_time
-ORDER BY p.uuid DESC
+ORDER BY %(id_func)s(p) DESC
 SKIP $offset
 LIMIT $limit
 // -------------------------------------
@@ -314,15 +316,15 @@ CALL {
     AND node.branch_support IN [$branch_aware, $branch_agnostic]
     AND type(r_prop) IN ["IS_VISIBLE", "IS_PROTECTED", "HAS_SOURCE", "HAS_OWNER", "HAS_VALUE", "IS_RELATED"]
     AND any(l in labels(prop) WHERE l in ["Boolean", "Node", "AttributeValue"])
-    AND ALL(
-        r in [r_node, r_prop]
-        WHERE r.from < $to_time AND r.branch = top_diff_rel.branch
-    )
     AND (top_diff_rel.to IS NULL OR top_diff_rel.to >= r_node.from)
     AND (r_node.to IS NULL OR r_node.to >= r_prop.from)
     AND [%(id_func)s(p), type(r_node)] <> [%(id_func)s(prop), type(r_prop)]
-    AND top_diff_rel.status = r_node.status
-    AND top_diff_rel.status = r_prop.status
+    AND r_node.from < $to_time
+    AND r_node.branch = top_diff_rel.branch
+    AND r_node.status = top_diff_rel.status
+    AND r_prop.from < $to_time
+    AND r_prop.branch = top_diff_rel.branch
+    AND r_prop.status = top_diff_rel.status
     // ------------------------
     // special handling for nodes that had their kind updated,
     // the migration leaves two nodes with the same UUID linked to the same Relationship
@@ -717,7 +719,7 @@ CALL {
     CALL {
         WITH n, row_from_time
         OPTIONAL MATCH (root:Root)<-[r_root_deleted:IS_PART_OF {branch: $branch_name}]-(n)
-        WHERE row_from_time <= r_root_deleted.from < $to_time
+        WHERE r_root_deleted.from < $to_time
         WITH r_root_deleted
         ORDER BY r_root_deleted.status DESC
         LIMIT 1
@@ -745,3 +747,85 @@ WITH n, p, type(diff_rel) AS drt, head(collect(diff_rel_path)) AS diff_path, has
         self.add_to_query(self.get_relationship_peer_side_query(db=db))
         self.add_to_query("UNWIND diff_rel_paths AS diff_path")
         self.return_labels = ["DISTINCT diff_path AS diff_path", "has_more_data"]
+
+
+@dataclass
+class MigratedKindNode:
+    uuid: str
+    kind: str
+    db_id: str
+    from_time: Timestamp
+    action: DiffAction
+    has_more_data: bool
+
+
+class DiffMigratedKindNodesQuery(DiffCalculationQuery):
+    name = "diff_migrated_kind_nodes_query"
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        params_dict = self.get_params()
+        self.params.update(params_dict)
+        migrated_kind_nodes_query = """
+// -------------------------------------
+// Identify nodes added/removed on branch in the time frame
+// -------------------------------------
+MATCH (:Root)<-[diff_rel:IS_PART_OF {branch: $branch_name}]-(n:Node)
+WHERE (
+    ($from_time <= diff_rel.from < $to_time AND (diff_rel.to IS NULL OR diff_rel.to > $to_time))
+    OR ($from_time <= diff_rel.to < $to_time)
+)
+AND n.branch_support = $branch_aware
+WITH DISTINCT n.uuid AS node_uuid, %(id_func)s(n) AS db_id
+WITH node_uuid, count(*) AS num_nodes_with_uuid
+WHERE num_nodes_with_uuid > 1
+// -------------------------------------
+// Limit the number of nodes
+// -------------------------------------
+WITH node_uuid
+ORDER BY node_uuid
+SKIP $offset
+LIMIT $limit
+WITH collect(node_uuid) AS node_uuids
+WITH node_uuids, size(node_uuids) = $limit AS has_more_data
+MATCH (:Root)<-[diff_rel:IS_PART_OF {branch: $branch_name}]-(n:Node)
+WHERE n.uuid IN node_uuids
+AND (
+    ($from_time <= diff_rel.from < $to_time AND (diff_rel.to IS NULL OR diff_rel.to > $to_time))
+    OR ($from_time <= diff_rel.to < $to_time)
+)
+// -------------------------------------
+// Ignore node created and deleted on this branch
+// -------------------------------------
+CALL {
+    WITH n
+    OPTIONAL MATCH (:Root)<-[diff_rel:IS_PART_OF {branch: $branch_name}]-(n)
+    WITH diff_rel
+    ORDER BY diff_rel.from ASC
+    WITH collect(diff_rel.status) AS statuses
+    RETURN statuses = ["active", "deleted"] AS intra_branch_update
+}
+WITH n.uuid AS uuid, n.kind AS kind, %(id_func)s(n) AS db_id, diff_rel.from_time AS from_time, diff_rel.status AS status, has_more_data
+WHERE intra_branch_update = FALSE
+        """ % {"id_func": db.get_id_function_name()}
+        self.add_to_query(query=migrated_kind_nodes_query)
+        self.return_labels = [
+            "uuid",
+            "kind",
+            "db_id",
+            "from_time",
+            "status",
+            "has_more_data",
+        ]
+
+    def get_migrated_kind_nodes(self) -> Generator[MigratedKindNode, None, None]:
+        for result in self.get_results():
+            yield MigratedKindNode(
+                uuid=result.get_as_type("uuid", return_type=str),
+                kind=result.get_as_type("kind", return_type=str),
+                db_id=result.get_as_type("db_id", return_type=str),
+                from_time=result.get_as_type("from_time", return_type=Timestamp),
+                action=DiffAction.REMOVED
+                if result.get_as_type("status", return_type=str).lower() == RelationshipStatus.DELETED.value
+                else DiffAction.ADDED,
+                has_more_data=result.get_as_type("has_more_data", bool),
+            )

infrahub/core/query/node.py

@@ -92,7 +92,7 @@ class NodeAttributesFromDB:
 class PeerInfo:
     uuid: str
     kind: str
-    labels: frozenset[str]
+    db_id: str
 
 
 class NodeQuery(Query):
@@ -413,9 +413,32 @@ class NodeDeleteQuery(NodeQuery):
         self.params["branch"] = self.branch.name
         self.params["branch_level"] = self.branch.hierarchy_level
 
+        if self.branch.is_global or self.branch.is_default:
+            node_query_match = """
+            MATCH (n:Node { uuid: $uuid })
+            OPTIONAL MATCH (n)-[delete_edge:IS_PART_OF {status: "deleted", branch: $branch}]->(:Root)
+            WHERE delete_edge.from <= $at
+            WITH n WHERE delete_edge IS NULL
+            """
+        else:
+            node_filter, node_filter_params = self.branch.get_query_filter_path(at=self.at, variable_name="r")
+            node_query_match = """
+                MATCH (n:Node { uuid: $uuid })
+                CALL {
+                    WITH n
+                    MATCH (n)-[r:IS_PART_OF]->(:Root)
+                    WHERE %(node_filter)s
+                    RETURN r.status = "active" AS is_active
+                    ORDER BY r.from DESC
+                    LIMIT 1
+                }
+                WITH n WHERE is_active = TRUE
+                """ % {"node_filter": node_filter}
+            self.params.update(node_filter_params)
+        self.add_to_query(node_query_match)
+
         query = """
         MATCH (root:Root)
-        MATCH (n:Node { uuid: $uuid })
         CREATE (n)-[r:IS_PART_OF { branch: $branch, branch_level: $branch_level, status: "deleted", from: $at }]->(root)
         """
 
@@ -1554,5 +1577,5 @@ class NodeGetHierarchyQuery(Query):
             yield PeerInfo(
                 uuid=peer_node.get("uuid"),
                 kind=peer_node.get("kind"),
-                labels=peer_node.labels,
+                db_id=peer_node.element_id,
             )

infrahub/core/query/relationship.py

@@ -73,30 +73,27 @@ class RelationshipPeerData:
     source_id: UUID
     """UUID of the Source Node."""
 
+    source_db_id: str
+    """Internal DB ID of the Source Node."""
+
     source_kind: str
     """Kind of the Source Node."""
 
-    source_labels: frozenset[str]
-    """Labels of the Source Node."""
-
     peer_id: UUID
     """UUID of the Peer Node."""
 
+    peer_db_id: str
+    """Internal DB ID of the Peer Node."""
+
     peer_kind: str
     """Kind of the Peer Node."""
 
-    peer_labels: frozenset[str]
-    """Labels of the Peer Node."""
-
     properties: dict[str, FlagPropertyData | NodePropertyData]
     """UUID of the Relationship Node."""
 
     rel_node_id: UUID | None = None
     """UUID of the Relationship Node."""
 
-    peer_db_id: str | None = None
-    """Internal DB ID of the Peer Node."""
-
     rel_node_db_id: str | None = None
     """Internal DB ID of the Relationship Node."""
 
@@ -205,6 +202,63 @@ class RelationshipQuery(Query):
             rel_prop_dict["hierarchy"] = self.schema.hierarchical
         return rel_prop_dict
 
+    def add_source_match_to_query(self, source_branch: Branch) -> None:
+        self.params["source_id"] = self.source_id or self.source.get_id()
+        if source_branch.is_global or source_branch.is_default:
+            source_query_match = """
+            MATCH (s:Node { uuid: $source_id })
+            OPTIONAL MATCH (s)-[delete_edge:IS_PART_OF {status: "deleted", branch: $source_branch}]->(:Root)
+            WHERE delete_edge.from <= $at
+            WITH *, s WHERE delete_edge IS NULL
+            """
+            self.params["source_branch"] = source_branch.name
+        source_filter, source_filter_params = source_branch.get_query_filter_path(
+            at=self.at, variable_name="r", params_prefix="src_"
+        )
+        source_query_match = """
+            MATCH (s:Node { uuid: $source_id })
+            CALL {
+                WITH s
+                MATCH (s)-[r:IS_PART_OF]->(:Root)
+                WHERE %(source_filter)s
+                RETURN r.status = "active" AS s_is_active
+                ORDER BY r.from DESC
+                LIMIT 1
+            }
+            WITH *, s WHERE s_is_active = TRUE
+            """ % {"source_filter": source_filter}
+        self.params.update(source_filter_params)
+        self.add_to_query(source_query_match)
+
+    def add_dest_match_to_query(self, destination_branch: Branch, destination_id: str) -> None:
+        self.params["destination_id"] = destination_id
+        if destination_branch.is_global or destination_branch.is_default:
+            destination_query_match = """
+            MATCH (d:Node { uuid: $destination_id })
+            OPTIONAL MATCH (d)-[delete_edge:IS_PART_OF {status: "deleted", branch: $destination_branch}]->(:Root)
+            WHERE delete_edge.from <= $at
+            WITH *, d WHERE delete_edge IS NULL
+            """
+            self.params["destination_branch"] = destination_branch.name
+        else:
+            destination_filter, destination_filter_params = destination_branch.get_query_filter_path(
+                at=self.at, variable_name="r", params_prefix="dst_"
+            )
+            destination_query_match = """
+            MATCH (d:Node { uuid: $destination_id })
+            CALL {
+                WITH d
+                MATCH (d)-[r:IS_PART_OF]->(:Root)
+                WHERE %(destination_filter)s
+                RETURN r.status = "active" AS d_is_active
+                ORDER BY r.from DESC
+                LIMIT 1
+            }
+            WITH *, d WHERE d_is_active = TRUE
+            """ % {"destination_filter": destination_filter}
+            self.params.update(destination_filter_params)
+        self.add_to_query(destination_query_match)
+
 
 class RelationshipCreateQuery(RelationshipQuery):
     name = "relationship_create"
@@ -223,8 +277,6 @@ class RelationshipCreateQuery(RelationshipQuery):
         super().__init__(destination=destination, destination_id=destination_id, **kwargs)
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
-        self.params["source_id"] = self.source_id
-        self.params["destination_id"] = self.destination_id
         self.params["name"] = self.schema.identifier
         self.params["branch_support"] = self.schema.branch.value
 
@@ -237,12 +289,11 @@ class RelationshipCreateQuery(RelationshipQuery):
         self.params["is_protected"] = self.rel.is_protected
         self.params["is_visible"] = self.rel.is_visible
 
-        query_match = """
-        MATCH (s:Node { uuid: $source_id })
-        MATCH (d:Node { uuid: $destination_id })
-        """
-        self.add_to_query(query_match)
-
+        self.add_source_match_to_query(source_branch=self.source.get_branch_based_on_support_type())
+        self.add_dest_match_to_query(
+            destination_branch=self.destination.get_branch_based_on_support_type(),
+            destination_id=self.destination_id or self.destination.get_id(),
+        )
         self.query_add_all_node_property_match()
 
         self.params["rel_prop"] = self.get_relationship_properties_dict(status=RelationshipStatus.ACTIVE)
@@ -387,7 +438,6 @@ class RelationshipDataDeleteQuery(RelationshipQuery):
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
         self.params["source_id"] = self.source_id
-        self.params["destination_id"] = self.data.peer_id
         self.params["rel_node_id"] = self.data.rel_node_id
         self.params["name"] = self.schema.identifier
         self.params["branch"] = self.branch.name
@@ -397,9 +447,10 @@ class RelationshipDataDeleteQuery(RelationshipQuery):
         # -----------------------------------------------------------------------
         # Match all nodes, including properties
         # -----------------------------------------------------------------------
+
+        self.add_source_match_to_query(source_branch=self.source.get_branch_based_on_support_type())
+        self.add_dest_match_to_query(destination_branch=self.branch, destination_id=self.data.peer_id)
         query = """
-        MATCH (s:Node { uuid: $source_id })
-        MATCH (d:Node { uuid: $destination_id })
         MATCH (rl:Relationship { uuid: $rel_node_id })
         """
         self.add_to_query(query)
@@ -451,8 +502,6 @@ class RelationshipDeleteQuery(RelationshipQuery):
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
         rel_filter, rel_params = self.branch.get_query_filter_path(at=self.at, variable_name="edge")
-        self.params["source_id"] = self.source_id
-        self.params["destination_id"] = self.destination_id
         self.params["rel_id"] = self.rel.id
         self.params["branch"] = self.branch.name
         self.params["rel_prop"] = self.get_relationship_properties_dict(status=RelationshipStatus.DELETED)
@@ -463,9 +512,14 @@ class RelationshipDeleteQuery(RelationshipQuery):
         r1 = f"{arrows.left.start}[r1:{self.rel_type} $rel_prop ]{arrows.left.end}"
         r2 = f"{arrows.right.start}[r2:{self.rel_type} $rel_prop ]{arrows.right.end}"
 
+        self.add_source_match_to_query(source_branch=self.source.get_branch_based_on_support_type())
+        self.add_dest_match_to_query(
+            destination_branch=self.destination.get_branch_based_on_support_type(),
+            destination_id=self.destination_id or self.destination.get_id(),
+        )
         query = """
-        MATCH (s:Node { uuid: $source_id })-[:IS_RELATED]-(rl:Relationship {uuid: $rel_id})-[:IS_RELATED]-(d:Node { uuid: $destination_id })
-        WITH s, rl, d
+        MATCH (s)-[:IS_RELATED]-(rl:Relationship {uuid: $rel_id})-[:IS_RELATED]-(d)
+        WITH DISTINCT s, rl, d
         LIMIT 1
         CREATE (s)%(r1)s(rl)
         CREATE (rl)%(r2)s(d)
@@ -765,11 +819,11 @@ class RelationshipGetPeerQuery(Query):
             peer_node = result.get_node("peer")
             data = RelationshipPeerData(
                 source_id=source_node.get("uuid"),
+                source_db_id=source_node.element_id,
                 source_kind=source_node.get("kind"),
-                source_labels=source_node.labels,
                 peer_id=peer_node.get("uuid"),
+                peer_db_id=peer_node.element_id,
                 peer_kind=peer_node.get("kind"),
-                peer_labels=peer_node.labels,
                 rel_node_db_id=result.get("rl").element_id,
                 rel_node_id=result.get("rl").get("uuid"),
                 updated_at=rels[0]["from"],
@@ -807,8 +861,6 @@ class RelationshipGetQuery(RelationshipQuery):
     type: QueryType = QueryType.READ
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
-        self.params["source_id"] = self.source_id
-        self.params["destination_id"] = self.destination_id
         self.params["name"] = self.schema.identifier
         self.params["branch"] = self.branch.name
 
@@ -822,9 +874,12 @@ class RelationshipGetQuery(RelationshipQuery):
         r1 = f"{arrows.left.start}[r1:{self.rel.rel_type}]{arrows.left.end}"
         r2 = f"{arrows.right.start}[r2:{self.rel.rel_type}]{arrows.right.end}"
 
+        self.add_source_match_to_query(source_branch=self.source.get_branch_based_on_support_type())
+        self.add_dest_match_to_query(
+            destination_branch=self.destination.get_branch_based_on_support_type(),
+            destination_id=self.destination_id or self.destination.get_id(),
+        )
         query = """
-        MATCH (s:Node { uuid: $source_id })
-        MATCH (d:Node { uuid: $destination_id })
         MATCH (s)%s(rl:Relationship { name: $name })%s(d)
         WHERE %s
         """ % (
@@ -1051,7 +1106,11 @@ class RelationshipDeleteAllQuery(Query):
         CALL {
             WITH rl
             MATCH (rl)-[active_edge:IS_RELATED]->(n)
-            WHERE %(active_rel_filter)s AND active_edge.status ="active"
+            WHERE %(active_rel_filter)s
+            WITH rl, active_edge, n
+            ORDER BY %(id_func)s(rl), %(id_func)s(n), active_edge.from DESC
+            WITH rl, n, head(collect(active_edge)) AS active_edge
+            WHERE active_edge.status = "active"
             CREATE (rl)-[deleted_edge:IS_RELATED $rel_prop]->(n)
             SET deleted_edge.hierarchy = active_edge.hierarchy
             WITH rl, active_edge, n
@@ -1067,7 +1126,11 @@ class RelationshipDeleteAllQuery(Query):
 
             WITH rl
             MATCH (rl)<-[active_edge:IS_RELATED]-(n)
-            WHERE %(active_rel_filter)s AND active_edge.status ="active"
+            WHERE %(active_rel_filter)s
+            WITH rl, active_edge, n
+            ORDER BY %(id_func)s(rl), %(id_func)s(n), active_edge.from DESC
+            WITH rl, n, head(collect(active_edge)) AS active_edge
+            WHERE active_edge.status = "active"
             CREATE (rl)<-[deleted_edge:IS_RELATED $rel_prop]-(n)
             SET deleted_edge.hierarchy = active_edge.hierarchy
             WITH rl, active_edge, n
@@ -1080,9 +1143,7 @@ class RelationshipDeleteAllQuery(Query):
                 "inbound" as rel_direction
         }
         RETURN DISTINCT uuid, kind, rel_identifier, rel_direction
-        """ % {
-            "active_rel_filter": active_rel_filter,
-        }
+        """ % {"active_rel_filter": active_rel_filter, "id_func": db.get_id_function_name()}
 
         self.add_to_query(query)
 

infrahub/core/relationship/model.py

@@ -416,7 +416,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
             await update_relationships_to(rel_ids_to_update, to=delete_at, db=db)
 
         delete_query = await RelationshipDeleteQuery.init(
-            db=db, rel=self, source_id=node.id, destination_id=peer.id, branch=branch, at=delete_at
+            db=db, rel=self, source=node, destination=peer, branch=branch, at=delete_at
         )
         await delete_query.execute(db=db)
 

infrahub/core/validators/uniqueness/query.py

@@ -225,6 +225,13 @@ class NodeUniqueAttributeConstraintQuery(Query):
             attr_name,
             attr_value,
             relationship_identifier
+        ORDER BY
+            node_id,
+            deepest_branch_name,
+            node_count,
+            attr_name,
+            attr_value,
+            relationship_identifier
         """ % {
             "select_subqueries_str": select_subqueries_str,
             "branch_filter": branch_filter,

infrahub/trigger/setup.py

@@ -39,9 +39,9 @@ async def setup_triggers(
     report = TriggerSetupReport()
 
     if trigger_type:
-        log.info(f"Setting up triggers of type {trigger_type.value}")
+        log.debug(f"Setting up triggers of type {trigger_type.value}")
     else:
-        log.info("Setting up all triggers")
+        log.debug("Setting up all triggers")
 
     # -------------------------------------------------------------
     # Retrieve existing Deployments and Automation from the server
@@ -112,4 +112,15 @@ async def setup_triggers(
         await client.delete_automation(automation_id=existing_automation.id)
         log.info(f"{item_to_delete} Deleted")
 
+    if trigger_type:
+        log.info(
+            f"Processed triggers of type {trigger_type.value}: "
+            f"{len(report.created)} created, {len(report.updated)} updated, {len(report.unchanged)} unchanged, {len(report.deleted)} deleted"
+        )
+    else:
+        log.info(
+            f"Processed all triggers: "
+            f"{len(report.created)} created, {len(report.updated)} updated, {len(report.unchanged)} unchanged, {len(report.deleted)} deleted"
+        )
+
     return report

infrahub/types.py

@@ -366,7 +366,7 @@ ATTRIBUTE_PYTHON_TYPES: dict[str, type] = {
 ATTRIBUTE_KIND_LABELS = list(ATTRIBUTE_TYPES.keys())
 
 # Data types supporting large values, which can therefore not be indexed in neo4j.
-LARGE_ATTRIBUTE_TYPES = [TextArea, JSON]
+LARGE_ATTRIBUTE_TYPES = [TextArea, JSON, List]
 
 
 def get_attribute_type(kind: str = "Default") -> type[InfrahubDataType]:

infrahub/webhook/models.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import base64
 import hashlib
 import hmac
+import json
 from typing import TYPE_CHECKING, Any
 from uuid import UUID, uuid4
 
@@ -170,7 +171,7 @@ class StandardWebhook(Webhook):
     def _assign_headers(self, uuid: UUID | None = None, at: Timestamp | None = None) -> None:
         message_id = f"msg_{uuid.hex}" if uuid else f"msg_{uuid4().hex}"
         timestamp = str(at.to_timestamp()) if at else str(Timestamp().to_timestamp())
-        payload = self._payload or {}
+        payload = json.dumps(self._payload or {})
         unsigned_data = f"{message_id}.{timestamp}.{payload}".encode()
         signature = self._sign(data=unsigned_data)
 

infrahub/workflows/catalogue.py

@@ -251,6 +251,14 @@ COMPUTED_ATTRIBUTE_PROCESS_JINJA2 = WorkflowDefinition(
     tags=[WorkflowTag.DATABASE_CHANGE],
 )
 
+COMPUTED_ATTRIBUTE_JINJA2_UPDATE_VALUE = WorkflowDefinition(
+    name="computed-attribute-jinja2-update-value",
+    type=WorkflowType.CORE,
+    module="infrahub.computed_attribute.tasks",
+    function="computed_attribute_jinja2_update_value",
+    tags=[WorkflowTag.DATABASE_CHANGE],
+)
+
 TRIGGER_UPDATE_JINJA_COMPUTED_ATTRIBUTES = WorkflowDefinition(
     name="trigger_update_jinja2_computed_attributes",
     type=WorkflowType.CORE,
@@ -443,6 +451,7 @@ workflows = [
     BRANCH_MERGE_POST_PROCESS,
     BRANCH_REBASE,
     BRANCH_VALIDATE,
+    COMPUTED_ATTRIBUTE_JINJA2_UPDATE_VALUE,
     COMPUTED_ATTRIBUTE_PROCESS_JINJA2,
     COMPUTED_ATTRIBUTE_PROCESS_TRANSFORM,
     COMPUTED_ATTRIBUTE_SETUP_JINJA2,

infrahub_sdk/timestamp.py

@@ -153,7 +153,7 @@ class Timestamp:
         nanoseconds: int = 0,
         disambiguate: Literal["compatible"] = "compatible",
     ) -> Timestamp:
-        return Timestamp(
+        return self.__class__(
             self._obj.add(
                 years=years,
                 months=months,
@@ -183,7 +183,7 @@ class Timestamp:
         nanoseconds: int = 0,
         disambiguate: Literal["compatible"] = "compatible",
     ) -> Timestamp:
-        return Timestamp(
+        return self.__class__(
             self._obj.subtract(
                 years=years,
                 months=months,

{infrahub_server-1.2.9.dist-info → infrahub_server-1.2.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: infrahub-server
-Version: 1.2.9
+Version: 1.2.10
 Summary: Infrahub is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run.
 Home-page: https://opsmill.com
 License: AGPL-3.0-only
@@ -77,7 +77,7 @@ Description-Content-Type: text/markdown
 
 Infrahub from [OpsMill](https://opsmill.com) is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run. Infrahub offers a central hub to manage the data, templates and playbooks that powers your infrastructure by combining the version control and branch management capabilities similar to Git with the flexible data model and UI of a graph database.
 
-If you just want to try Infrahub out, you can use our [Always-On Sandbox](https://demo.infrahub.app/) to get started.
+If you just want to try Infrahub out, you can use our [Infrahub Sandbox](https://sandbox.infrahub.app/) to get started.
 
 ![infrahub screenshot](docs/docs/media/infrahub-readme.gif)
 
@@ -103,7 +103,7 @@ If you just want to try Infrahub out, you can use our [Always-On Sandbox](https:
 
 ## Quick Start
 
-[Always-On Sandbox](https://demo.infrahub.app/) - Instantly login to the UI of a demo environment of Infrahub with sample data pre-loaded.
+[Infrahub Sandbox](https://sandbox.infrahub.app/) - Instantly login to the UI of a demo environment of Infrahub with sample data pre-loaded.
 
 [Getting Started Environment & Tutorial](https://opsmill.instruqt.com/pages/labs) - It spins up an instance of Infrahub on our cloud, provides a browser, terminal, code editor and walks you through the basic concepts: