fuli-context 0.2.0

package/graph-provider/fuli_graph/store_publication.py

@@ -0,0 +1,370 @@
+from fastapi import HTTPException
+
+from .models import (
+    MembershipCreate,
+    MembershipRecord,
+    ProposalCreate,
+    ProposalDecision,
+    ProposalRecord,
+    PublicationDraftCreate,
+    PublicationDraftDecision,
+    PublicationDraftRecord,
+    SubscriptionCreate,
+    SubscriptionDeleteResult,
+    SubscriptionRecord,
+)
+from .provider_values import native_datetime, now_utc, stable_uuid
+
+
+class StorePublication:
+    async def create_publication_draft(
+        self,
+        actor: dict,
+        request: PublicationDraftCreate,
+    ) -> PublicationDraftRecord:
+        self._require_personal()
+        await self.authorize(actor, request.personal_space_id, 'maintainer')
+        draft_id = stable_uuid(
+            self.settings.provider_id,
+            request.personal_space_id,
+            request.provider_url,
+            request.target_project_id,
+            request.episode.idempotency_key,
+        )
+        created_at = now_utc()
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (space:FuliSpace {id: $personal_space_id, kind: 'personal'})
+            MERGE (draft:FuliPublicationDraft {id: $id})
+            ON CREATE SET draft.personal_space_id = $personal_space_id,
+                          draft.target_project_id = $target_project_id,
+                          draft.provider_url = $provider_url,
+                          draft.status = 'pending',
+                          draft.payload = $payload,
+                          draft.created_at = $created_at
+            MERGE (space)-[:HAS_PUBLICATION_DRAFT]->(draft)
+            RETURN draft
+            ''',
+            personal_space_id=request.personal_space_id,
+            id=draft_id,
+            target_project_id=request.target_project_id,
+            provider_url=request.provider_url,
+            payload=request.episode.model_dump_json(),
+            created_at=created_at,
+        )
+        return self._publication_draft(records[0]['draft'])
+
+    async def list_publication_drafts(
+        self,
+        actor: dict,
+        personal_space_id: str,
+        draft_status: str = 'pending',
+    ) -> list[PublicationDraftRecord]:
+        self._require_personal()
+        await self.authorize(actor, personal_space_id, 'reader')
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (:FuliSpace {id: $personal_space_id, kind: 'personal'})-
+                  [:HAS_PUBLICATION_DRAFT]->
+                  (draft:FuliPublicationDraft {status: $status})
+            RETURN draft ORDER BY draft.created_at DESC
+            ''',
+            personal_space_id=personal_space_id,
+            status=draft_status,
+            routing_='r',
+        )
+        return [self._publication_draft(record['draft']) for record in records]
+
+    async def get_publication_draft(
+        self,
+        actor: dict,
+        personal_space_id: str,
+        draft_id: str,
+    ) -> PublicationDraftRecord:
+        self._require_personal()
+        await self.authorize(actor, personal_space_id, 'reader')
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (:FuliSpace {id: $personal_space_id, kind: 'personal'})-
+                  [:HAS_PUBLICATION_DRAFT]->
+                  (draft:FuliPublicationDraft {id: $draft_id})
+            RETURN draft
+            ''',
+            personal_space_id=personal_space_id,
+            draft_id=draft_id,
+            routing_='r',
+        )
+        if not records:
+            raise HTTPException(status_code=404, detail='publication draft not found')
+        return self._publication_draft(records[0]['draft'])
+
+    async def decide_publication_draft(
+        self,
+        actor: dict,
+        personal_space_id: str,
+        draft_id: str,
+        decision: PublicationDraftDecision,
+    ) -> PublicationDraftRecord:
+        self._require_personal()
+        space = await self.authorize(actor, personal_space_id, 'maintainer')
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (:FuliSpace {id: $personal_space_id, kind: 'personal'})-
+                  [:HAS_PUBLICATION_DRAFT]->
+                  (draft:FuliPublicationDraft {id: $draft_id, status: 'pending'})
+            RETURN draft
+            ''',
+            personal_space_id=personal_space_id,
+            draft_id=draft_id,
+        )
+        if not records:
+            raise HTTPException(status_code=409, detail='publication draft is not pending')
+        draft = self._publication_draft(records[0]['draft'])
+        if decision.decision == 'keep_personal':
+            await self._commit_episode(space, draft.episode)
+            final_status = 'kept_personal'
+        elif decision.decision == 'submit_public':
+            final_status = 'submitted'
+        else:
+            final_status = 'ignored'
+        updated, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (draft:FuliPublicationDraft {id: $draft_id, status: 'pending'})
+            SET draft.status = $status,
+                draft.shared_proposal_id = $shared_proposal_id,
+                draft.decided_at = $decided_at
+            RETURN draft
+            ''',
+            draft_id=draft_id,
+            status=final_status,
+            shared_proposal_id=decision.shared_proposal_id,
+            decided_at=now_utc(),
+        )
+        return self._publication_draft(updated[0]['draft'])
+
+    async def add_membership(
+        self,
+        actor: dict,
+        project_id: str,
+        request: MembershipCreate,
+    ) -> MembershipRecord:
+        self._require_workspace()
+        await self.authorize(actor, project_id, 'maintainer')
+        created_at = now_utc()
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (principal:FuliPrincipal {id: $principal_id})
+            MATCH (project:FuliSpace {id: $project_id, kind: 'project'})
+            MERGE (principal)-[membership:MEMBER_OF]->(project)
+            SET membership.role = $role,
+                membership.created_at = coalesce(membership.created_at, $created_at),
+                membership.updated_at = $created_at
+            RETURN membership.created_at AS created_at
+            ''',
+            principal_id=request.principal_id,
+            project_id=project_id,
+            role=request.role,
+            created_at=created_at,
+        )
+        if not records:
+            raise HTTPException(status_code=404, detail='principal or project not found')
+        return MembershipRecord(
+            project_id=project_id,
+            principal_id=request.principal_id,
+            role=request.role,
+            created_at=native_datetime(records[0]['created_at']),
+        )
+
+    async def subscribe(
+        self,
+        actor: dict,
+        request: SubscriptionCreate,
+    ) -> SubscriptionRecord:
+        self._require_personal()
+        await self.authorize(actor, request.personal_space_id, 'maintainer')
+        subscription_id = stable_uuid(
+            self.settings.provider_id,
+            request.personal_space_id,
+            request.provider_url,
+            request.project_id,
+        )
+        created_at = now_utc()
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (personal:FuliSpace {id: $personal_space_id, kind: 'personal'})
+            MERGE (subscription:FuliSubscription {id: $id})
+            ON CREATE SET subscription.created_at = $created_at
+            SET subscription.project_id = $project_id,
+                subscription.provider_url = $provider_url,
+                subscription.project_name = $project_name,
+                subscription.active = true
+            MERGE (personal)-[:SUBSCRIBES_TO]->(subscription)
+            RETURN subscription
+            ''',
+            personal_space_id=request.personal_space_id,
+            id=subscription_id,
+            project_id=request.project_id,
+            provider_url=request.provider_url,
+            project_name=request.project_name,
+            created_at=created_at,
+        )
+        return self._subscription(records[0]['subscription'], request.personal_space_id)
+
+    async def list_subscriptions(
+        self,
+        actor: dict,
+        personal_space_id: str,
+    ) -> list[SubscriptionRecord]:
+        self._require_personal()
+        await self.authorize(actor, personal_space_id, 'reader')
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (personal:FuliSpace {id: $personal_space_id})-[:SUBSCRIBES_TO]->
+                  (subscription:FuliSubscription {active: true})
+            RETURN subscription ORDER BY subscription.created_at
+            ''',
+            personal_space_id=personal_space_id,
+            routing_='r',
+        )
+        return [
+            self._subscription(record['subscription'], personal_space_id)
+            for record in records
+        ]
+
+    async def unsubscribe(
+        self,
+        actor: dict,
+        personal_space_id: str,
+        project_id: str,
+        provider_url: str,
+    ) -> SubscriptionDeleteResult:
+        self._require_personal()
+        await self.authorize(actor, personal_space_id, 'maintainer')
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (:FuliSpace {id: $personal_space_id})-[:SUBSCRIBES_TO]->
+                  (subscription:FuliSubscription {
+                    project_id: $project_id,
+                    provider_url: $provider_url,
+                    active: true
+                  })
+            SET subscription.active = false,
+                subscription.deleted_at = $deleted_at
+            RETURN subscription.id AS id
+            ''',
+            personal_space_id=personal_space_id,
+            project_id=project_id,
+            provider_url=provider_url,
+            deleted_at=now_utc(),
+        )
+        return SubscriptionDeleteResult(project_id=project_id, deleted=bool(records))
+
+    async def create_proposal(
+        self,
+        actor: dict,
+        project_id: str,
+        request: ProposalCreate,
+    ) -> ProposalRecord:
+        self._require_workspace()
+        await self.authorize(actor, project_id, 'contributor')
+        proposal_id = stable_uuid(
+            self.settings.provider_id,
+            project_id,
+            actor['id'],
+            request.episode.idempotency_key,
+        )
+        payload = request.episode.model_dump_json()
+        created_at = now_utc()
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (project:FuliSpace {id: $project_id, kind: 'project'})
+            MERGE (proposal:FuliProposal {id: $id})
+            ON CREATE SET proposal.project_id = $project_id,
+                          proposal.submitted_by = $submitted_by,
+                          proposal.status = 'pending',
+                          proposal.payload = $payload,
+                          proposal.created_at = $created_at
+            MERGE (proposal)-[:TARGETS]->(project)
+            RETURN proposal
+            ''',
+            project_id=project_id,
+            id=proposal_id,
+            submitted_by=actor['id'],
+            payload=payload,
+            created_at=created_at,
+        )
+        return self._proposal(records[0]['proposal'])
+
+    async def list_proposals(
+        self,
+        actor: dict,
+        project_id: str,
+        proposal_status: str = 'pending',
+    ) -> list[ProposalRecord]:
+        self._require_workspace()
+        await self.authorize(actor, project_id, 'maintainer')
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (proposal:FuliProposal {project_id: $project_id, status: $status})
+            RETURN proposal ORDER BY proposal.created_at
+            ''',
+            project_id=project_id,
+            status=proposal_status,
+            routing_='r',
+        )
+        return [self._proposal(record['proposal']) for record in records]
+
+    async def decide_proposal(
+        self,
+        actor: dict,
+        project_id: str,
+        proposal_id: str,
+        decision: ProposalDecision,
+    ) -> ProposalRecord:
+        self._require_workspace()
+        space = await self.authorize(actor, project_id, 'maintainer')
+        records, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (proposal:FuliProposal {
+              id: $proposal_id,
+              project_id: $project_id,
+              status: 'pending'
+            })
+            SET proposal.status = 'processing'
+            RETURN proposal
+            ''',
+            proposal_id=proposal_id,
+            project_id=project_id,
+        )
+        if not records:
+            raise HTTPException(status_code=409, detail='proposal is not pending')
+        proposal = self._proposal(records[0]['proposal'])
+        decided_at = now_utc()
+        if decision.decision == 'approve':
+            try:
+                await self._commit_episode(space, proposal.episode)
+            except Exception:
+                await self.runtime.driver.execute_query(
+                    "MATCH (p:FuliProposal {id: $id, status: 'processing'}) SET p.status = 'pending'",
+                    id=proposal_id,
+                )
+                raise
+            final_status = 'approved'
+        else:
+            final_status = 'rejected'
+        updated, _, _ = await self.runtime.driver.execute_query(
+            '''
+            MATCH (proposal:FuliProposal {id: $id, status: 'processing'})
+            SET proposal.status = $status,
+                proposal.decided_at = $decided_at,
+                proposal.decided_by = $decided_by,
+                proposal.decision_note = $note
+            RETURN proposal
+            ''',
+            id=proposal_id,
+            status=final_status,
+            decided_at=decided_at,
+            decided_by=actor['id'],
+            note=decision.note,
+        )
+        return self._proposal(updated[0]['proposal'])

package/graph-provider/fuli_graph/store_records.py

@@ -0,0 +1,134 @@
+from .models import (
+    PersonalProjectRecord,
+    ProjectProfile,
+    ProjectReleaseRecord,
+    ProjectRelationRecord,
+    ProposalRecord,
+    PublicationDraftRecord,
+    SpaceRecord,
+    StructuredEpisode,
+    SubscriptionRecord,
+)
+from .provider_values import native_datetime, stable_uuid
+
+
+class StoreRecords:
+    def _space(
+        self,
+        raw,
+        *,
+        owner_id: str,
+        role: str,
+        can_manage: bool = False,
+    ) -> SpaceRecord:
+        value = dict(raw)
+        current_release = None
+        if value.get('release_version'):
+            current_release = ProjectReleaseRecord(
+                id=value.get('release_id') or stable_uuid(
+                    value['id'], 'release', value['release_version']
+                ),
+                project_id=value['id'],
+                version=value['release_version'],
+                summary=value.get('release_summary') or '未记录更新内容',
+                publisher_id=value.get('release_publisher_id') or owner_id,
+                publisher_name=value.get('release_publisher_name') or owner_id,
+                published_at=native_datetime(
+                    value.get('released_at') or value['created_at']
+                ),
+            )
+        return SpaceRecord(
+            id=value['id'],
+            name=value['name'],
+            kind=value['kind'],
+            group_id=value['group_id'],
+            description=value.get('description'),
+            visibility=value['visibility'],
+            owner_id=owner_id,
+            role=role,
+            publication_key=value.get('publication_key'),
+            can_manage=can_manage,
+            profile=(
+                ProjectProfile.model_validate_json(value['profile_json'])
+                if value.get('profile_json') else None
+            ),
+            current_release=current_release,
+            created_at=native_datetime(value['created_at']),
+        )
+
+    def _project_release(self, raw) -> ProjectReleaseRecord:
+        value = dict(raw)
+        return ProjectReleaseRecord(
+            id=value['id'],
+            project_id=value['project_id'],
+            version=value['version'],
+            summary=value['summary'],
+            publisher_id=value['publisher_id'],
+            publisher_name=value.get('publisher_name') or value['publisher_id'],
+            published_at=native_datetime(value['published_at']),
+        )
+
+    def _personal_project(self, raw, personal_space_id: str) -> PersonalProjectRecord:
+        value = dict(raw)
+        return PersonalProjectRecord(
+            project_id=value['project_id'],
+            personal_space_id=personal_space_id,
+            publication_key=value['publication_key'],
+            profile=ProjectProfile.model_validate_json(value['profile_json']),
+            created_at=native_datetime(value['created_at']),
+            updated_at=native_datetime(value['updated_at']),
+        )
+
+    def _project_relation(self, raw) -> ProjectRelationRecord:
+        value = dict(raw)
+        return ProjectRelationRecord(
+            id=value['id'],
+            source_project_id=value['source_project_id'],
+            target_project_id=value['target_project_id'],
+            relation_type=value['relation_type'],
+            status=value['status'],
+            note=value.get('note'),
+            created_by=value['created_by'],
+            created_at=native_datetime(value['created_at']),
+            decided_by=value.get('decided_by'),
+            decided_at=native_datetime(value.get('decided_at')),
+        )
+
+    def _publication_draft(self, raw) -> PublicationDraftRecord:
+        value = dict(raw)
+        return PublicationDraftRecord(
+            id=value['id'],
+            personal_space_id=value['personal_space_id'],
+            target_project_id=value['target_project_id'],
+            provider_url=value['provider_url'],
+            status=value['status'],
+            episode=StructuredEpisode.model_validate_json(value['payload']),
+            created_at=native_datetime(value['created_at']),
+            decided_at=native_datetime(value.get('decided_at')),
+            shared_proposal_id=value.get('shared_proposal_id'),
+        )
+
+    def _subscription(self, raw, personal_space_id: str) -> SubscriptionRecord:
+        value = dict(raw)
+        return SubscriptionRecord(
+            id=value['id'],
+            personal_space_id=personal_space_id,
+            project_id=value['project_id'],
+            provider_url=value['provider_url'],
+            project_name=value['project_name'],
+            created_at=native_datetime(value['created_at']),
+        )
+
+    def _proposal(self, raw) -> ProposalRecord:
+        value = dict(raw)
+        return ProposalRecord(
+            id=value['id'],
+            project_id=value['project_id'],
+            submitted_by=value['submitted_by'],
+            status=value['status'],
+            episode=StructuredEpisode.model_validate_json(value['payload']),
+            created_at=native_datetime(value['created_at']),
+            decided_at=native_datetime(value.get('decided_at')),
+            decided_by=value.get('decided_by'),
+            decision_note=value.get('decision_note'),
+        )

package/graph-provider/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "fuli-graph-provider"
+version = "0.2.0"
+description = "Graphiti-backed personal and shared project provider for Fuli."
+requires-python = ">=3.12"
+dependencies = [
+  "fastapi==0.116.1",
+  "graphiti-core==0.29.2",
+  "pydantic-settings==2.10.1",
+  "uvicorn[standard]==0.35.0",
+]
+
+[build-system]
+requires = ["setuptools>=80"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["fuli_graph*"]
+
+[project.optional-dependencies]
+dev = [
+  "httpx==0.28.1",
+  "pytest==8.4.1",
+  "pytest-asyncio==1.1.0",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+
+[tool.ruff.format]
+quote-style = "single"