fuli-context 0.2.0

package/graph-provider/fuli_graph/store_knowledge.py

@@ -0,0 +1,447 @@
+import asyncio
+import json
+
+from fastapi import HTTPException
+
+from .collaboration_context import read_collaboration_context
+from .graph_models import GraphResult
+from .graph_query import read_graph
+from .knowledge_search import search_knowledge
+from .models import (
+    CollaborationContextResult,
+    CommitResult,
+    KnowledgeCommit,
+    SearchRequest,
+    SearchResult,
+    StructuredEpisode,
+)
+from .personal_project_access import authorize_personal_project
+from .provider_values import now_utc, stable_uuid
+
+
+class StoreKnowledge:
+    async def commit_personal(self, actor: dict, request: KnowledgeCommit) -> CommitResult:
+        self._require_personal()
+        space = await self.authorize(actor, request.space_id, 'maintainer')
+        if space['kind'] != 'personal':
+            raise HTTPException(status_code=422, detail='direct commits are personal-only')
+        if request.personal_project_id:
+            await authorize_personal_project(
+                self, actor, space, request.personal_project_id
+            )
+        return await self._commit_episode(
+            space,
+            request.episode,
+            personal_project_id=request.personal_project_id,
+        )
+
+    async def search(self, actor: dict, request: SearchRequest) -> SearchResult:
+        return await search_knowledge(self, actor, request)
+
+    async def graph(
+        self,
+        actor: dict,
+        space_id: str,
+        limit: int | None = None,
+        personal_project_id: str | None = None,
+    ) -> GraphResult:
+        return await read_graph(
+            self, actor, space_id, limit, personal_project_id
+        )
+
+    async def collaboration_context(
+        self,
+        actor: dict,
+        space_id: str,
+        personal_project_id: str | None = None,
+        limit: int = 100,
+    ) -> CollaborationContextResult:
+        return await read_collaboration_context(
+            self,
+            actor,
+            space_id,
+            personal_project_id,
+            limit,
+        )
+
+    async def _commit_episode(
+        self,
+        space: dict,
+        episode: StructuredEpisode,
+        *,
+        personal_project_id: str | None = None,
+    ) -> CommitResult:
+        group_id = space['group_id']
+        lock = self._group_locks.setdefault(group_id, asyncio.Lock())
+        async with lock:
+            episode_id = stable_uuid(group_id, 'episode', episode.idempotency_key)
+            existing, _, _ = await self.runtime.driver.execute_query(
+                'MATCH (e:Episodic {uuid: $uuid}) RETURN e.uuid AS uuid',
+                uuid=episode_id,
+                routing_='r',
+            )
+            entity_ids = [
+                _entity_id(
+                    group_id,
+                    space['kind'],
+                    personal_project_id,
+                    entity.key,
+                )
+                for entity in episode.entities
+            ]
+            relationship_ids = [
+                _relationship_id(
+                    group_id,
+                    space['kind'],
+                    personal_project_id,
+                    relationship.key,
+                    relationship.fact,
+                    (relationship.valid_at or episode.reference_time).isoformat(),
+                )
+                for relationship in episode.relationships
+            ]
+            if existing:
+                return CommitResult(
+                    status='duplicate',
+                    space_id=space['id'],
+                    episode_id=episode_id,
+                    entity_ids=entity_ids,
+                    relationship_ids=relationship_ids,
+                )
+
+            entity_vectors = await self.runtime.embedder.create_batch(
+                [entity.name for entity in episode.entities]
+            )
+            fact_vectors = await self.runtime.embedder.create_batch(
+                [relationship.fact for relationship in episode.relationships]
+            )
+            entity_rows = []
+            entity_by_key = {}
+            for entity, entity_id, vector in zip(
+                episode.entities, entity_ids, entity_vectors, strict=True
+            ):
+                entity_by_key[entity.key] = entity_id
+                entity_rows.append(
+                    {
+                        'uuid': entity_id,
+                        'key': entity.key,
+                        'name': entity.name,
+                        'type': entity.type,
+                        'summary': entity.summary,
+                        'origin_quadrant': entity.origin_quadrant,
+                        'current_quadrant': entity.current_quadrant,
+                        'epistemic_status': entity.epistemic_status,
+                        'confirmation_status': entity.confirmation_status,
+                        'utility_score': 0.0,
+                        'confidence_score': _initial_confidence(
+                            entity.confirmation_status
+                        ),
+                        'confirmation_basis_json': json.dumps(
+                            entity.confirmation_basis.model_dump(mode='json'),
+                            ensure_ascii=False,
+                            sort_keys=True,
+                        ),
+                        'reasoning_summary': entity.reasoning_summary,
+                        'profile_aspect': entity.profile_aspect,
+                        'inheritance_mode': entity.inheritance_mode,
+                        'inherited_project_ids': entity.inherited_project_ids,
+                        'preference_scope': (
+                            'project' if entity.profile_aspect and personal_project_id
+                            else 'global' if entity.profile_aspect else None
+                        ),
+                        'preference_project_id': (
+                            personal_project_id if entity.profile_aspect else None
+                        ),
+                        'attributes_json': json.dumps(
+                            entity.attributes, ensure_ascii=False, sort_keys=True
+                        ),
+                        'embedding': vector,
+                    }
+                )
+            relationship_rows = []
+            superseded_relationships: list[dict[str, str]] = []
+            for relationship, relationship_id, vector in zip(
+                episode.relationships, relationship_ids, fact_vectors, strict=True
+            ):
+                superseded_relationships.extend(
+                    {
+                        'key': superseded_key,
+                        'replacement_id': relationship_id,
+                    }
+                    for superseded_key in relationship.supersedes
+                )
+                relationship_rows.append(
+                    {
+                        'uuid': relationship_id,
+                        'key': relationship.key,
+                        'source_uuid': entity_by_key[relationship.source],
+                        'target_uuid': entity_by_key[relationship.target],
+                        'name': relationship.type,
+                        'fact': relationship.fact,
+                        'embedding': vector,
+                        'valid_at': relationship.valid_at or episode.reference_time,
+                        'invalid_at': relationship.invalid_at,
+                        'confidence': relationship.confidence,
+                        'origin_quadrant': relationship.origin_quadrant,
+                        'current_quadrant': relationship.current_quadrant,
+                        'epistemic_status': relationship.epistemic_status,
+                        'confirmation_status': relationship.confirmation_status,
+                        'utility_score': 0.0,
+                        'confidence_score': _initial_confidence(
+                            relationship.confirmation_status
+                        ),
+                        'confirmation_basis_json': json.dumps(
+                            relationship.confirmation_basis.model_dump(mode='json'),
+                            ensure_ascii=False,
+                            sort_keys=True,
+                        ),
+                        'reasoning_summary': relationship.reasoning_summary,
+                        'profile_aspect': relationship.profile_aspect,
+                        'inheritance_mode': relationship.inheritance_mode,
+                        'inherited_project_ids': relationship.inherited_project_ids,
+                        'preference_scope': (
+                            'project' if relationship.profile_aspect and personal_project_id
+                            else 'global' if relationship.profile_aspect else None
+                        ),
+                        'preference_project_id': (
+                            personal_project_id if relationship.profile_aspect else None
+                        ),
+                        'attributes_json': json.dumps(
+                            relationship.attributes, ensure_ascii=False, sort_keys=True
+                        ),
+                    }
+                )
+
+            created_at = now_utc()
+            await self.runtime.driver.execute_query(
+                '''
+                UNWIND $entities AS row
+                MERGE (entity:Entity {uuid: row.uuid})
+                ON CREATE SET entity.group_id = $group_id,
+                    entity.name = row.name,
+                    entity.name_embedding = row.embedding,
+                    entity.summary = row.summary,
+                    entity.created_at = coalesce(entity.created_at, $created_at),
+                    entity.fuli_key = row.key,
+                    entity.fuli_type = row.type,
+                    entity.fuli_origin_quadrant = coalesce(
+                      entity.fuli_origin_quadrant, row.origin_quadrant
+                    ),
+                    entity.fuli_current_quadrant = row.current_quadrant,
+                    entity.fuli_epistemic_status = row.epistemic_status,
+                    entity.fuli_confirmation_status = row.confirmation_status,
+                    entity.fuli_confirmation_basis_json = row.confirmation_basis_json,
+                    entity.fuli_utility_score = coalesce(
+                      entity.fuli_utility_score, row.utility_score
+                    ),
+                    entity.fuli_confidence_score = coalesce(
+                      entity.fuli_confidence_score, row.confidence_score
+                    ),
+                    entity.fuli_qualified_use_count = coalesce(
+                      entity.fuli_qualified_use_count, 0
+                    ),
+                    entity.fuli_distinct_task_count = coalesce(
+                      entity.fuli_distinct_task_count, 0
+                    ),
+                    entity.fuli_usage_generation = coalesce(
+                      entity.fuli_usage_generation, 1
+                    ),
+                    entity.fuli_reasoning_summary = coalesce(
+                      row.reasoning_summary, entity.fuli_reasoning_summary
+                    ),
+                    entity.fuli_profile_aspect = row.profile_aspect,
+                    entity.fuli_inheritance_mode = row.inheritance_mode,
+                    entity.fuli_inherited_project_ids = row.inherited_project_ids,
+                    entity.fuli_preference_scope = row.preference_scope,
+                    entity.fuli_preference_project_id = row.preference_project_id,
+                    entity.fuli_attributes_json = row.attributes_json
+                WITH count(entity) AS entity_count
+                CREATE (episode:Episodic {
+                  uuid: $episode_id,
+                  group_id: $group_id,
+                  name: $episode_name,
+                  source: 'json',
+                  source_description: $source_description,
+                  content: '',
+                  valid_at: $reference_time,
+                  created_at: $created_at,
+                  entity_edges: $relationship_ids,
+                  fuli_session_id: $session_id,
+                  fuli_source_kind: $source_kind,
+                  fuli_source_application: $source_application,
+                  fuli_source_turn_id: $source_turn_id,
+                  fuli_source_excerpt: $source_excerpt,
+                  fuli_summary: $summary,
+                  fuli_sensitivity: $sensitivity,
+                  fuli_personal_project_id: $personal_project_id,
+                  fuli_idempotency_key: $idempotency_key
+                })
+                WITH episode
+                UNWIND $entities AS row
+                MATCH (entity:Entity {uuid: row.uuid})
+                MERGE (episode)-[mention:MENTIONS {uuid: row.mention_uuid}]->(entity)
+                SET mention.group_id = $group_id,
+                    mention.created_at = $created_at
+                WITH episode
+                UNWIND $relationships AS row
+                MATCH (source:Entity {uuid: row.source_uuid})
+                MATCH (target:Entity {uuid: row.target_uuid})
+                MERGE (source)-[edge:RELATES_TO {uuid: row.uuid}]->(target)
+                ON CREATE SET edge.group_id = $group_id,
+                    edge.name = row.name,
+                    edge.fact = row.fact,
+                    edge.fact_embedding = row.embedding,
+                    edge.episodes = [$episode_id],
+                    edge.created_at = $created_at,
+                    edge.valid_at = row.valid_at,
+                    edge.invalid_at = row.invalid_at,
+                    edge.reference_time = $reference_time,
+                    edge.fuli_key = row.key,
+                    edge.fuli_confidence = row.confidence,
+                    edge.fuli_origin_quadrant = row.origin_quadrant,
+                    edge.fuli_current_quadrant = row.current_quadrant,
+                    edge.fuli_epistemic_status = row.epistemic_status,
+                    edge.fuli_confirmation_status = row.confirmation_status,
+                    edge.fuli_confirmation_basis_json = row.confirmation_basis_json,
+                    edge.fuli_utility_score = row.utility_score,
+                    edge.fuli_confidence_score = row.confidence_score,
+                    edge.fuli_qualified_use_count = 0,
+                    edge.fuli_distinct_task_count = 0,
+                    edge.fuli_usage_generation = 1,
+                    edge.fuli_reasoning_summary = row.reasoning_summary,
+                    edge.fuli_profile_aspect = row.profile_aspect,
+                    edge.fuli_inheritance_mode = row.inheritance_mode,
+                    edge.fuli_inherited_project_ids = row.inherited_project_ids,
+                    edge.fuli_preference_scope = row.preference_scope,
+                    edge.fuli_preference_project_id = row.preference_project_id,
+                    edge.fuli_attributes_json = row.attributes_json
+                SET edge.episodes =
+                  CASE WHEN $episode_id IN coalesce(edge.episodes, [])
+                       THEN edge.episodes
+                       ELSE coalesce(edge.episodes, []) + $episode_id END
+                WITH count(edge) AS edge_count
+                OPTIONAL MATCH ()-[old:RELATES_TO {group_id: $group_id}]->()
+                WHERE old.invalid_at IS NULL
+                  AND NOT (old.uuid IN $relationship_ids)
+                  AND (
+                    EXISTS {
+                      MATCH (:FuliSpace {id: $space_id})-
+                            [:HAS_KNOWLEDGE_ASSIGNMENT]->
+                            (assignment:FuliKnowledgeAssignment {
+                              item_kind: 'relationship',
+                              item_id: old.uuid
+                            })
+                      WHERE assignment.project_id = $personal_project_id
+                    }
+                    OR (
+                      NOT EXISTS {
+                        MATCH (:FuliSpace {id: $space_id})-
+                              [:HAS_KNOWLEDGE_ASSIGNMENT]->
+                              (:FuliKnowledgeAssignment {
+                                item_kind: 'relationship',
+                                item_id: old.uuid
+                              })
+                      }
+                      AND EXISTS {
+                        MATCH (old_episode:Episodic {group_id: $group_id})
+                        WHERE old_episode.uuid IN coalesce(old.episodes, [])
+                          AND (
+                            old_episode.fuli_personal_project_id =
+                              $personal_project_id
+                            OR (
+                              old_episode.fuli_personal_project_id IS NULL
+                              AND $personal_project_id IS NULL
+                            )
+                          )
+                      }
+                    )
+                  )
+                  AND any(
+                    replacement IN $superseded_relationships
+                    WHERE replacement.key = old.fuli_key
+                  )
+                WITH edge_count, old, head([
+                  replacement IN $superseded_relationships
+                  WHERE replacement.key = old.fuli_key | replacement
+                ]) AS replacement
+                FOREACH (_ IN CASE WHEN old IS NULL THEN [] ELSE [1] END |
+                  SET old.invalid_at = $reference_time,
+                      old.expired_at = $created_at,
+                      old.fuli_replaced_by_item_id = replacement.replacement_id,
+                      old.fuli_replaced_by_item_kind = 'relationship'
+                )
+                RETURN edge_count
+                ''',
+                entities=[
+                    {
+                        **row,
+                        'mention_uuid': stable_uuid(episode_id, 'mentions', row['uuid']),
+                    }
+                    for row in entity_rows
+                ],
+                relationships=relationship_rows,
+                superseded_relationships=superseded_relationships,
+                space_id=space['id'],
+                group_id=group_id,
+                episode_id=episode_id,
+                episode_name=episode.name,
+                source_description=episode.source_description,
+                reference_time=episode.reference_time,
+                created_at=created_at,
+                relationship_ids=relationship_ids,
+                session_id=episode.session_id,
+                source_kind=episode.source_kind,
+                source_application=episode.source_application,
+                source_turn_id=episode.source_turn_id,
+                source_excerpt=episode.source_excerpt,
+                summary=episode.summary,
+                sensitivity=episode.sensitivity,
+                personal_project_id=personal_project_id,
+                idempotency_key=episode.idempotency_key,
+            )
+            return CommitResult(
+                status='committed',
+                space_id=space['id'],
+                episode_id=episode_id,
+                entity_ids=entity_ids,
+                relationship_ids=relationship_ids,
+            )
+
+
+def _initial_confidence(status: str) -> float:
+    return {
+        'pending': 0.5,
+        'agent_confirmed': 0.75,
+        'confirmed': 1.0,
+    }[status]
+
+
+def _entity_id(
+    group_id: str,
+    space_kind: str,
+    personal_project_id: str | None,
+    key: str,
+) -> str:
+    if space_kind == 'personal' and personal_project_id:
+        return stable_uuid(
+            group_id,
+            'entity',
+            'personal-project',
+            personal_project_id,
+            key,
+        )
+    return stable_uuid(group_id, 'entity', key)
+
+
+def _relationship_id(
+    group_id: str,
+    space_kind: str,
+    personal_project_id: str | None,
+    key: str,
+    fact: str,
+    reference_time: str,
+) -> str:
+    parts = [group_id, 'relationship']
+    if space_kind == 'personal' and personal_project_id:
+        parts.extend(['personal-project', personal_project_id])
+    return stable_uuid(*parts, key, fact, reference_time)

package/graph-provider/fuli_graph/store_projects.py

@@ -0,0 +1,242 @@
+from fastapi import HTTPException
+
+from .models import (
+    PersonalProjectRecord,
+    PersonalProjectUpsert,
+    ProjectDeleteResult,
+    ProjectReleaseRecord,
+    ProjectRelationCreate,
+    ProjectRelationDecision,
+    ProjectRelationRecord,
+)
+from .project_management import (
+    delete_project as delete_public_project,
+    list_project_releases as read_project_releases,
+)
+from .provider_values import now_utc, stable_uuid
+
+
+class StoreProjects:
+    async def list_project_releases(
+        self,
+        actor: dict,
+        project_id: str,
+    ) -> list[ProjectReleaseRecord]:
+        self._require_workspace()
+        return await read_project_releases(self, actor, project_id)
+
+    async def delete_project(
+        self,
+        actor: dict,
+        project_id: str,
+    ) -> ProjectDeleteResult:
+        return await delete_public_project(self, actor, project_id)
+
+    async def upsert_personal_project(
+        self,
+        actor: dict,
+        request: PersonalProjectUpsert,
+    ) -> PersonalProjectRecord:
+        self._require_personal()
+        await self.authorize(actor, request.personal_space_id, 'maintainer')
+        node_id = stable_uuid(
+            self.settings.provider_id,
+            request.personal_space_id,
+            'personal-project',
+            request.project_id,
+        )
+        publication_key = stable_uuid(node_id, 'publication')
+        updated_at = now_utc()
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (space:FuliSpace {id: $personal_space_id, kind: 'personal'})
+            MERGE (project:FuliPersonalProject {id: $id})
+            ON CREATE SET project.project_id = $project_id,
+                          project.publication_key = $publication_key,
+                          project.created_at = $updated_at
+            SET project.profile_json = $profile_json,
+                project.name = $name,
+                project.updated_at = $updated_at
+            MERGE (space)-[:CONTAINS_PROJECT]->(project)
+            RETURN project
+            ''',
+            personal_space_id=request.personal_space_id,
+            id=node_id,
+            project_id=request.project_id,
+            publication_key=publication_key,
+            profile_json=request.profile.model_dump_json(),
+            name=request.profile.name,
+            updated_at=updated_at,
+        )
+        return self._personal_project(records[0]['project'], request.personal_space_id)
+
+    async def list_personal_projects(
+        self,
+        actor: dict,
+        personal_space_id: str,
+    ) -> list[PersonalProjectRecord]:
+        self._require_personal()
+        await self.authorize(actor, personal_space_id, 'reader')
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (space:FuliSpace {id: $personal_space_id, kind: 'personal'})-
+                  [:CONTAINS_PROJECT]->(project:FuliPersonalProject)
+            RETURN project ORDER BY project.updated_at DESC
+            ''',
+            personal_space_id=personal_space_id,
+            routing_='r',
+        )
+        return [
+            self._personal_project(record['project'], personal_space_id)
+            for record in records
+        ]
+
+    async def get_personal_project(
+        self,
+        actor: dict,
+        personal_space_id: str,
+        project_id: str,
+    ) -> PersonalProjectRecord:
+        self._require_personal()
+        await self.authorize(actor, personal_space_id, 'reader')
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (space:FuliSpace {id: $personal_space_id, kind: 'personal'})-
+                  [:CONTAINS_PROJECT]->
+                  (project:FuliPersonalProject {project_id: $project_id})
+            RETURN project
+            ''',
+            personal_space_id=personal_space_id,
+            project_id=project_id,
+            routing_='r',
+        )
+        if not records:
+            raise HTTPException(status_code=404, detail='personal project not found')
+        return self._personal_project(records[0]['project'], personal_space_id)
+
+    async def create_project_relation(
+        self,
+        actor: dict,
+        source_project_id: str,
+        request: ProjectRelationCreate,
+    ) -> ProjectRelationRecord:
+        self._require_workspace()
+        if source_project_id == request.target_project_id:
+            raise HTTPException(status_code=422, detail='a project cannot relate to itself')
+        await self.authorize(actor, source_project_id, 'maintainer')
+        target, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (target:FuliSpace {
+              id: $target_project_id,
+              kind: 'project',
+              visibility: 'public'
+            })
+            RETURN target
+            ''',
+            target_project_id=request.target_project_id,
+            routing_='r',
+        )
+        if not target:
+            raise HTTPException(status_code=404, detail='target project not found')
+        if request.relation_type == 'PART_OF':
+            existing_parent, _, _ = await self.runtime.driver.execute_query(
+                '''
+                MATCH (:FuliSpace {id: $source_project_id})-
+                      [relation:FULI_PROJECT_RELATION {relation_type: 'PART_OF'}]->
+                      (:FuliSpace)
+                WHERE relation.status IN ['pending', 'active']
+                RETURN relation.id AS id
+                ''',
+                source_project_id=source_project_id,
+                routing_='r',
+            )
+            if existing_parent:
+                raise HTTPException(status_code=409, detail='project already has a parent relation')
+        relation_id = stable_uuid(
+            self.settings.provider_id,
+            'project-relation',
+            source_project_id,
+            request.relation_type,
+            request.target_project_id,
+        )
+        relation_status = 'pending' if request.relation_type == 'PART_OF' else 'active'
+        created_at = now_utc()
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (source:FuliSpace {id: $source_project_id, kind: 'project'})
+            MATCH (target:FuliSpace {id: $target_project_id, kind: 'project'})
+            MERGE (source)-[relation:FULI_PROJECT_RELATION {id: $id}]->(target)
+            ON CREATE SET relation.source_project_id = $source_project_id,
+                          relation.target_project_id = $target_project_id,
+                          relation.relation_type = $relation_type,
+                          relation.status = $relation_status,
+                          relation.note = $note,
+                          relation.created_by = $created_by,
+                          relation.created_at = $created_at
+            RETURN relation
+            ''',
+            source_project_id=source_project_id,
+            target_project_id=request.target_project_id,
+            id=relation_id,
+            relation_type=request.relation_type,
+            relation_status=relation_status,
+            note=request.note,
+            created_by=actor['id'],
+            created_at=created_at,
+        )
+        return self._project_relation(records[0]['relation'])
+
+    async def list_project_relations(
+        self,
+        actor: dict,
+        project_id: str,
+    ) -> list[ProjectRelationRecord]:
+        self._require_workspace()
+        await self.authorize(actor, project_id, 'reader')
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (source:FuliSpace)-[relation:FULI_PROJECT_RELATION]->
+                  (target:FuliSpace)
+            WHERE source.id = $project_id OR target.id = $project_id
+            RETURN relation ORDER BY relation.created_at DESC
+            ''',
+            project_id=project_id,
+            routing_='r',
+        )
+        return [self._project_relation(record['relation']) for record in records]
+
+    async def decide_project_relation(
+        self,
+        actor: dict,
+        target_project_id: str,
+        relation_id: str,
+        decision: ProjectRelationDecision,
+    ) -> ProjectRelationRecord:
+        self._require_workspace()
+        await self.authorize(actor, target_project_id, 'maintainer')
+        decided_at = now_utc()
+        relation_status = 'active' if decision.decision == 'confirm' else 'rejected'
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (:FuliSpace)-[relation:FULI_PROJECT_RELATION {
+              id: $relation_id,
+              target_project_id: $target_project_id,
+              relation_type: 'PART_OF',
+              status: 'pending'
+            }]->(:FuliSpace)
+            SET relation.status = $relation_status,
+                relation.decision_note = $note,
+                relation.decided_by = $decided_by,
+                relation.decided_at = $decided_at
+            RETURN relation
+            ''',
+            relation_id=relation_id,
+            target_project_id=target_project_id,
+            relation_status=relation_status,
+            note=decision.note,
+            decided_by=actor['id'],
+            decided_at=decided_at,
+        )
+        if not records:
+            raise HTTPException(status_code=409, detail='project relation is not pending')
+        return self._project_relation(records[0]['relation'])