diff --git a/docs/design/multi-spaces.md b/docs/design/multi-spaces.md new file mode 100644 index 00000000..8ce624db --- /dev/null +++ b/docs/design/multi-spaces.md @@ -0,0 +1,200 @@ +# Multi-Spaces Design + +Status: Accepted + +Date: 2026-08-23 + +Existing domain language: [Memos context](../../CONTEXT.md) + +## Summary + +Multi-Spaces adds shared collaboration contexts inside one Memos instance. A Space groups members and memos, but it is not a tenant or workspace boundary. + +Every memo remains an author-owned, independent resource. Placement, audience, authorship, distribution, and relation context are separate. Memo authors control placement through the existing memo update API. Space governance controls the Space, its membership, and the aggregate deletion of directly assigned memos; it does not transfer authorship or grant collaborative editing rights. + +## Goals + +- Let an active user create or join multiple Spaces. +- Give each Space direct `ADMIN` and `USER` memberships. +- Let members contribute and browse memos in a shared Space context. +- Let every memo, including a comment, be Unassigned or assigned to exactly one Space while retaining its own author, audience, and lifecycle. +- Add a Space-members-only memo audience. +- Preserve existing memo identities, relations, data, and non-Space workflows. +- Keep existing memos Unassigned; do not create a default Space. +- Provide a complete backend workflow for Space creation, membership, memo placement, and Space browsing. + +## Non-goals + +- Tenant isolation, per-Space authentication, or per-Space instance settings. +- Multiple or nested Space placement, folders, or replacement of tags and saved views. +- Space ownership of memos, shared authorship, or collaborative editing. +- Space-admin mutation or moderation of an individual memo, including changing its placement. +- Thread ownership, inherited placement or audience, or relation-based cascading deletion. +- Mutable or re-parentable `COMMENT` relations. +- Space archival or restoration. +- Invitations, guests, open enrollment, federation, or public Space discovery. +- A generated default Space. +- UI/UX design or a redesign of global surfaces. + +## Research + +Research completed on 2026-08-22 compared the agreed boundary with Discourse Categories and Groups, Notion Teamspaces, and Mastodon. + +| Product | Useful model | What Memos should avoid | +| --- | --- | --- | +| Discourse | Posts retain their authors while a topic has one category and group permissions control access. | Separate Group, Category, and moderator concepts for one collaboration area; nested categories; default-open access. | +| Notion | Teamspaces are first-class membership and navigation contexts, and pages can move between personal and shared areas. | Mandatory default Teamspaces, shared page ownership, page trees, and layered permission inheritance. | +| Mastodon | A post's author, visibility, and feed distribution are independent. | Treating personal Lists or follows as shared membership, coupling audience to feed placement, or importing federation concerns. | + +The research supports four choices: + +- Make Space one first-class resource with direct membership and roles. +- Keep placement, audience, authorship, and distribution independent. +- Represent Unassigned as a real absence of placement. +- Eventually make Spaces visible in normal browsing and creation flows, while deferring UI/UX here. + +Sources: [Discourse category permissions](https://meta.discourse.org/t/understanding-groups-and-category-permissions/87678), [Discourse post ownership](https://meta.discourse.org/t/changing-ownership-of-posts/276672), [Notion Teamspaces](https://www.notion.com/help/intro-to-teamspaces), [Notion sharing and permissions](https://www.notion.com/help/sharing-and-permissions), [Mastodon post visibility](https://docs.joinmastodon.org/user/posting/), and [Mastodon Lists](https://docs.joinmastodon.org/entities/List/). + +These sources establish product mechanics, not demand or prevalence. This research did not include Memos analytics, user interviews, or usability testing. + +## Proposed design + +### Core model + +- A Space is an instance-scoped collaboration resource, not a tenant, group, folder, or memo author. It exists or is hard-deleted; there is no archived state. +- A memo keeps its `memos/{uid}` identity and author. Its placement is either Unassigned or one Space. +- Placement, audience, authorship, distribution, and relation context do not imply one another. +- Audience is a single choice: Author, Instance, Space, or Public. These are named domains, not ordered access levels. +- A comment is an independent memo connected to a context memo by one immutable `COMMENT` relation created atomically with it. The relation grants no ownership, inheritance, or lifecycle authority. +- A reaction belongs to one memo and has no independent audience. +- A Space membership connects one active registered user to one Space with role `ADMIN` or `USER`. The creator becomes the first `ADMIN`; there is no permanent owner. +- Application `ADMIN` is a control-plane role and is not an implicit Space member or memo reader. + +### Read access and distribution + +The v1 API calls a memo's audience `visibility` for compatibility. Ordinary identity-based read access is defined only by this table: + +| Visibility | Readers | +| --- | --- | +| `PRIVATE` | The active authenticated author. | +| `PROTECTED` | Active authenticated users. | +| `PUBLIC` | Active authenticated users, plus anonymous callers when instance policy permits. | +| `SPACE` | Active members of the assigned Space. It is invalid for an Unassigned memo. | + +Space placement adds no additional read gate. In particular, an active non-member may directly read an assigned `PROTECTED` or `PUBLIC` memo, and anonymous access to an assigned `PUBLIC` memo follows instance policy. Such access does not reveal Space metadata, membership, or the Space feed. A memo's Space reference is returned only to its author or an active member. + +An unexpired bearer share is an explicit capability exception for one exact memo. It does not grant list, feed, Space, or related-memo access. + +Distribution is derived rather than separately configured: + +- Global feeds return readable memos that do not have a `COMMENT` relation. +- A Space feed first requires active membership, then returns readable memos assigned to that Space that do not have a `COMMENT` relation. Membership does not make another author's assigned `PRIVATE` memo readable. +- Direct memo reads evaluate each memo independently, including comments. +- A comment or conversation query requires its context memo to be readable, then filters every replying memo by that memo's own audience. +- A `COMMENT` or `REFERENCE` relation and its snippet are returned only when both endpoints are readable. +- Reactions are readable whenever their memo is readable. +- RSS, public profiles, and other public surfaces continue to use `PUBLIC`, not Space placement. + +### Participation and governance + +Reading and participation are separate. A caller may read an assigned `PUBLIC` or `PROTECTED` memo without membership, but participation in assigned content requires active membership. + +| Action | Required authority | +| --- | --- | +| Create a Space | Any active registered user; creation atomically adds the first `ADMIN`. | +| View Space metadata, members, or feed | Active Space membership. | +| Update Space metadata | Space `ADMIN`. | +| Add or remove another member, or change a role | Space `ADMIN`; the Space must always retain an active `ADMIN`. | +| Leave a Space | The member; leaving must preserve an active `ADMIN`. | +| Create or assign a memo in a Space | The author is an active member of the target Space. | +| Comment on or react to an assigned memo | The caller can read the memo and is an active member of its Space. The new comment is authorized independently as a new memo. | +| Edit content or audience; manage attachments, references, or shares | Memo author; if assigned, the author is also an active member of its Space. | +| Delete one memo | Memo author. This does not delete another memo. | +| Withdraw or move a memo | Memo author. Source membership is unnecessary; target membership is required. | +| Hard-delete a Space | Space `ADMIN`. | + +Any membership change or user archival that would leave a Space without an active `ADMIN` is rejected. + +Only the memo author changes placement, using the existing memo update API to assign, move, or withdraw it. Assigning a memo does not change its audience. Changing placement and audience may be one atomic update. Moving a `SPACE` memo requires both `space` and `visibility` in the update mask, with visibility set to `SPACE`, to confirm the new member audience. Withdrawing one requires a non-Space audience in the same update. + +Creating a share for a `SPACE` memo is rejected. Changing a memo with active shares to `SPACE` is rejected until those shares are revoked. + +### Lifecycle + +Leaving or removing a member does not move or delete their memos. A removed author reads them only when their audience permits, so they cannot read a `SPACE` memo in the former Space. They retain narrow author lifecycle authority to delete it, withdraw it, or move it to a Space where they are active, but cannot otherwise mutate it while it remains assigned. + +Deleting one memo deletes that memo, its owned resources, and relations having it as an endpoint. It does not traverse relations or delete other memos. Inbox records are independent and are not deleted because their payload references a deleted memo; notification surfaces omit a complete notification when its required memo is missing or unreadable. + +Hard-deleting a Space atomically deletes the Space, its memberships, every directly assigned memo, those memos' owned database resources, and relations having a deleted endpoint. It does not follow relations into other Spaces or Unassigned memos, and it does not delete inbox records. The deleting `ADMIN` receives no content inventory for memos they cannot read. External attachment objects use the existing post-commit cleanup path; this feature adds no cleanup queue or dispatcher. + +General account erasure remains deferred. As a fail-closed guard, user hard deletion fails while the user has any Space membership, and `force` does not bypass this rule. Account deletion removes only inbox rows whose sender or receiver is that user; deleting the user's memos does not remove other inbox rows that reference them. + +### Persistence and migration + +```text +space(id, uid, title, description) +space_member(space_id, user_id, role ADMIN | USER) +memo(..., space_id NULL means Unassigned, visibility encodes audience) +memo_relation(memo_id, related_memo_id, type COMMENT | REFERENCE) +``` + +The Space-user pair is unique. The initial version does not record Space or membership timestamps; they can be added when a concrete audit or ordering requirement exists. A nullable `memo.space_id` directly enforces zero-or-one placement; an association table is unnecessary. Existing `memo_relation` rows remain the source of truth for comments. + +The change ships in migration `0.31` for SQLite, MySQL, and PostgreSQL, with equivalent fresh-install schemas. Existing memos keep their UID, author, visibility, relations, permalink, and become Unassigned. Comment rows and comment visibility are not rewritten. SQLite rebuilds `memo` only to add `space_id` and extend its visibility constraint. + +Space creation, membership changes, placement and audience changes, comment creation, memo deletion, and Space deletion use ordinary transactions where partial application would corrupt directly affected data. Space deletion directly removes assigned memos and their owned rows in the same style as existing user deletion, then uses the existing best-effort attachment storage cleanup after commit. The initial version does not introduce explicit row-lock protocols, transaction retries, a cleanup queue, or a global concurrency framework. + +### API shape + +A dedicated Space service provides create, list, get, update, and hard-delete operations plus member CRUD. Listing Spaces returns only Spaces in which the caller has active membership; no application-wide Space listing or archive API is added. An authenticated non-member receives `NotFound` for Space metadata, members, and feed requests. + +Memo responses gain an optional Space resource name, and `Visibility` adds `SPACE = 4` without renumbering existing values. The domain-to-v1 mapping is Author to `PRIVATE`, Instance to `PROTECTED`, Public to `PUBLIC`, and Space to `SPACE`. `VISIBILITY_UNSPECIFIED` remains an input sentinel: create treats it as `PRIVATE`, an explicit visibility update rejects it, and responses never return it. Visibility values are named domains and must not be compared numerically. The global default memo visibility setting continues to accept only `PRIVATE`, `PROTECTED`, and `PUBLIC`, because it cannot identify a Space. + +Memo listing gains explicit all-readable, Unassigned, and Space scopes. Space scope requires active membership. Existing global and Space feeds exclude comments by default, and Space identity is not added to the CEL filter schema. + +Placement and audience use the existing memo update mechanism so the memo author can change them atomically. The Space API does not add an operation for an `ADMIN` to move, withdraw, or otherwise mutate an individual memo. + +MCP memo operations reuse the same memo policy; Space management is not exposed through MCP in the initial version. + +### Security invariants + +Before `SPACE` can be stored, one shared, memo-local, fail-closed policy must cover point reads, lists and counts, files, reactions, relations, notifications, email, webhooks, shares, search, statistics, public feeds, and MCP. Child resources resolve the memo they directly belong to. Application `ADMIN` receives no implicit bypass. + +Unknown visibility denies access. A missing or invalid placement denies `SPACE` reads and placement-dependent operations. Other audiences continue to govern ordinary reads, but an invalid Space identity is omitted. Inactive users and invalid memberships deny any access that depends on them. Database list and count authorization is applied before pagination: + +```text +PRIVATE + active authenticated author +OR PROTECTED + active authenticated caller +OR PUBLIC permitted for caller +OR SPACE + active membership in memo.space_id +``` + +CEL filters may only narrow this predicate. Space membership is checked per request or through immediately invalidated cache state. Write paths validate membership and placement as part of their ordinary operation. Missing or unreadable notification subjects and relation endpoints fail closed without leaking partial metadata. Strong serialization between concurrent membership, placement, and Space-deletion operations is deferred. + +Live refresh is an authenticated, subject-free cache-invalidation channel. Successful memo, reaction, Space, and membership mutations broadcast only `{"type":"memo.changed"}` to connected clients. The event carries no resource name, audience, actor, or membership data; clients invalidate memo-backed caches and refetch through ordinary authorization. SSE does not materialize recipient sets or perform memo-level authorization. + +Notifications are authorized when presented. Email and user webhook payloads are authorized before entering the existing asynchronous queue; the initial version does not cancel a prepared delivery when access changes while it is queued. A comment webhook requires both the comment and its context memo to be readable by the webhook owner when the event is prepared. A deleted-memo webhook is built only from an author-readable pre-delete snapshot. + +Files for `PRIVATE`, `PROTECTED`, and `SPACE` memos use `private, no-store`; public files may use revalidation. + +## Alternatives considered + +| Alternative | Decision | +| --- | --- | +| Make Space a tenant, general Group, nested folder, or multi-placement label | Rejected; Space is one flat collaboration context inside an instance. | +| Derive audience from placement or add membership as a second read gate | Rejected; the memo audience alone defines ordinary reads, while membership separately controls Space browsing and participation. | +| Use a placement association table, nested memo names, or a default Space | Rejected; nullable `memo.space_id` preserves stable memo identity and a real Unassigned state. | +| Replace relations with parent/root columns or inherit thread placement, audience, or lifecycle | Rejected; every comment is an independent memo and no canonical thread participates in authorization. | +| Allow `COMMENT` mutation, require comments to share placement, or cascade individual deletion | Rejected; comment context is immutable and non-owning, and both endpoints remain independent. | +| Archive Spaces, reject non-empty deletion, or automatically unassign their memos | Rejected for the initial version; hard deletion has an explicit aggregate lifecycle for directly assigned memos. | +| Follow relations during Space deletion | Rejected; relations cannot extend deletion into other Spaces or Unassigned content. | +| Move or delete a member's memos when membership ends | Rejected; historical contributions remain until an author lifecycle action or Space deletion. | +| Give a Space `ADMIN` a separate operation to evict or otherwise mutate one memo | Rejected; placement belongs to the memo author's lifecycle, while Space governance is limited to Space metadata, membership, and aggregate hard deletion. | +| Give application `ADMIN` implicit Space or memo access | Rejected; moderation and recovery require separate control-plane design. | +| Rename v1 `visibility` to `audience`, or expose both fields | Rejected; the domain term is Audience, while one legacy v1 field remains the compatibility representation. | + +## Deferred design + +UI/UX is explicitly out of scope, including navigation, editor controls, membership screens, warnings, and confirmation flows. + +Invitations, open enrollment, account erasure beyond the membership guard, notification retention policy, application-admin moderation and recovery, audit history, soft deletion, restoration, retryable external-object cleanup, delivery-time cancellation of queued email/webhooks, concurrent mutation hardening, and asynchronous deletion of very large Spaces remain deferred. Later work must preserve independent memo authorization, non-propagating relations, and explicit Space aggregate deletion unless this design is revisited. diff --git a/proto/api/v1/memo_service.proto b/proto/api/v1/memo_service.proto index 4faf1790..dfacf7d0 100644 --- a/proto/api/v1/memo_service.proto +++ b/proto/api/v1/memo_service.proto @@ -16,7 +16,8 @@ option go_package = "gen/api/v1"; service MemoService { // CreateMemo creates a memo. The request body is a Memo; set its content - // (Markdown) and visibility (PRIVATE | PROTECTED | PUBLIC, default PRIVATE). + // (Markdown) and visibility (PRIVATE | PROTECTED | PUBLIC | SPACE, + // default PRIVATE). // The memo is owned by the authenticated user; requires authentication. rpc CreateMemo(CreateMemoRequest) returns (Memo) { option (google.api.http) = { @@ -25,7 +26,7 @@ service MemoService { }; option (google.api.method_signature) = "memo"; } - // ListMemos lists memos with pagination and filter. + // ListMemos lists readable non-comment memos with pagination and filter. rpc ListMemos(ListMemosRequest) returns (ListMemosResponse) { option (google.api.http) = {get: "/api/v1/memos"}; option (google.api.method_signature) = ""; @@ -43,7 +44,8 @@ service MemoService { }; option (google.api.method_signature) = "memo,update_mask"; } - // DeleteMemo deletes a memo. + // DeleteMemo deletes only the named memo and its owned resources. It removes + // incident relations but never deletes another memo. rpc DeleteMemo(DeleteMemoRequest) returns (google.protobuf.Empty) { option (google.api.http) = {delete: "/api/v1/{name=memos/*}"}; option (google.api.method_signature) = "name"; @@ -63,9 +65,9 @@ service MemoService { option (google.api.http) = {get: "/api/v1/{name=memos/*}/attachments"}; option (google.api.method_signature) = "name"; } - // SetMemoRelations replaces the full set of relations on a memo with the - // provided list (not an append). Pass the complete desired set; an empty list - // clears all relations. Idempotent. + // SetMemoRelations replaces the full set of mutable REFERENCE relations on a + // memo. COMMENT relations are immutable creation context and are rejected by + // this RPC. An empty list clears references without changing COMMENT. rpc SetMemoRelations(SetMemoRelationsRequest) returns (google.protobuf.Empty) { option (google.api.http) = { patch: "/api/v1/{name=memos/*}/relations" @@ -78,7 +80,9 @@ service MemoService { option (google.api.http) = {get: "/api/v1/{name=memos/*}/relations"}; option (google.api.method_signature) = "name"; } - // CreateMemoComment creates a comment for a memo. + // CreateMemoComment atomically creates an independent memo plus one immutable + // COMMENT context relation to the named memo. The new memo keeps its own + // placement, visibility, authorship, and lifecycle. rpc CreateMemoComment(CreateMemoCommentRequest) returns (Memo) { option (google.api.http) = { post: "/api/v1/{name=memos/*}/comments" @@ -152,8 +156,11 @@ enum Visibility { PRIVATE = 1; // PROTECTED: signed-in users of the instance can read the memo. PROTECTED = 2; - // PUBLIC: anyone, including anonymous visitors, can read the memo. + // PUBLIC: signed-in users can read the memo; anonymous visitors can read it + // when instance policy permits. PUBLIC = 3; + // SPACE: active members of the memo's space can read it. + SPACE = 4; } // Reaction is a reaction attached to a memo. @@ -228,8 +235,9 @@ message Memo { string content = 7 [(google.api.field_behavior) = REQUIRED]; // The visibility of the memo. - // One of PRIVATE (creator only), PROTECTED (signed-in users), or - // PUBLIC (anyone). Defaults to PRIVATE on creation when unspecified. + // One of PRIVATE (creator only), PROTECTED (signed-in users), PUBLIC + // (anonymous-eligible), or SPACE (active space members). Defaults to + // PRIVATE on creation when unspecified. Visibility visibility = 9 [(google.api.field_behavior) = REQUIRED]; // Output only. The tags extracted from the content. @@ -250,7 +258,8 @@ message Memo { // Output only. The computed properties of the memo. Property property = 15 [(google.api.field_behavior) = OUTPUT_ONLY]; - // Output only. The name of the parent memo. + // Output only. The readable context memo of this COMMENT relation, if any. + // This is omitted unless the caller may independently read both memos. // Format: memos/{memo} optional string parent = 16 [ (google.api.field_behavior) = OUTPUT_ONLY, @@ -263,6 +272,13 @@ message Memo { // Optional. The location of the memo. optional Location location = 18 [(google.api.field_behavior) = OPTIONAL]; + // Optional. The space in which this memo is placed. Format: spaces/{space}. + // Every memo, including a comment, owns its placement independently. + optional string space = 19 [ + (google.api.field_behavior) = OPTIONAL, + (google.api.resource_reference) = {type: "memos.api.v1/Space"} + ]; + // Computed properties of a memo. message Property { bool has_link = 1; @@ -323,7 +339,7 @@ message ListMemosRequest { // Available fields: // content (string), creator (string, e.g. "users/1"), // created_ts / updated_ts (timestamp), pinned (bool), - // visibility (string: PRIVATE | PROTECTED | PUBLIC), + // visibility (string: PRIVATE | PROTECTED | PUBLIC | SPACE), // tags (list; match with `"work" in tags`, not `tag == "work"`), // has_task_list / has_link / has_code / has_incomplete_tasks (bool), // has_location (bool; true when the memo has a location attached). @@ -337,6 +353,15 @@ message ListMemosRequest { // Optional. If true, show deleted memos in the response. bool show_deleted = 6 [(google.api.field_behavior) = OPTIONAL]; + + oneof scope { + // Optional. Limit results to readable non-comment memos in a space of + // which the caller is an active member. + string space = 7 [(google.api.resource_reference) = {type: "memos.api.v1/Space"}]; + + // Optional. Limit results to memos with no space. Must be true when set. + bool unassigned = 8; + } } message ListMemosResponse { @@ -450,7 +475,7 @@ message SetMemoRelationsRequest { (google.api.resource_reference) = {type: "memos.api.v1/Memo"} ]; - // Required. The relations to set for the memo. + // Required. The REFERENCE relations to set for the memo. COMMENT is invalid. repeated MemoRelation relations = 2 [(google.api.field_behavior) = REQUIRED]; } diff --git a/proto/api/v1/space_service.proto b/proto/api/v1/space_service.proto new file mode 100644 index 00000000..f4a8b76a --- /dev/null +++ b/proto/api/v1/space_service.proto @@ -0,0 +1,238 @@ +syntax = "proto3"; + +package memos.api.v1; + +import "google/api/annotations.proto"; +import "google/api/client.proto"; +import "google/api/field_behavior.proto"; +import "google/api/resource.proto"; +import "google/protobuf/empty.proto"; +import "google/protobuf/field_mask.proto"; + +option go_package = "gen/api/v1"; + +// SpaceService manages collaborative spaces and their memberships. +service SpaceService { + // CreateSpace creates a space and makes the authenticated caller its first + // administrator. + rpc CreateSpace(CreateSpaceRequest) returns (Space) { + option (google.api.http) = { + post: "/api/v1/spaces" + body: "space" + }; + option (google.api.method_signature) = "space"; + } + + // ListSpaces lists spaces of which the authenticated caller is a member. + rpc ListSpaces(ListSpacesRequest) returns (ListSpacesResponse) { + option (google.api.http) = {get: "/api/v1/spaces"}; + option (google.api.method_signature) = ""; + } + + // GetSpace gets a space of which the authenticated caller is a member. + rpc GetSpace(GetSpaceRequest) returns (Space) { + option (google.api.http) = {get: "/api/v1/{name=spaces/*}"}; + option (google.api.method_signature) = "name"; + } + + // UpdateSpace updates space metadata. + rpc UpdateSpace(UpdateSpaceRequest) returns (Space) { + option (google.api.http) = { + patch: "/api/v1/{space.name=spaces/*}" + body: "space" + }; + option (google.api.method_signature) = "space,update_mask"; + } + + // DeleteSpace permanently deletes a space and every memo currently placed + // in it. It never follows memo relations to other memos. + rpc DeleteSpace(DeleteSpaceRequest) returns (google.protobuf.Empty) { + option (google.api.http) = {delete: "/api/v1/{name=spaces/*}"}; + option (google.api.method_signature) = "name"; + } + + // CreateSpaceMember directly adds an existing active user to a space. + rpc CreateSpaceMember(CreateSpaceMemberRequest) returns (SpaceMember) { + option (google.api.http) = { + post: "/api/v1/{parent=spaces/*}/members" + body: "space_member" + }; + option (google.api.method_signature) = "parent,space_member"; + } + + // ListSpaceMembers lists the members of a space. + rpc ListSpaceMembers(ListSpaceMembersRequest) returns (ListSpaceMembersResponse) { + option (google.api.http) = {get: "/api/v1/{parent=spaces/*}/members"}; + option (google.api.method_signature) = "parent"; + } + + // GetSpaceMember gets one membership in a space. + rpc GetSpaceMember(GetSpaceMemberRequest) returns (SpaceMember) { + option (google.api.http) = {get: "/api/v1/{name=spaces/*/members/*}"}; + option (google.api.method_signature) = "name"; + } + + // UpdateSpaceMember changes a member's space role. + rpc UpdateSpaceMember(UpdateSpaceMemberRequest) returns (SpaceMember) { + option (google.api.http) = { + patch: "/api/v1/{space_member.name=spaces/*/members/*}" + body: "space_member" + }; + option (google.api.method_signature) = "space_member,update_mask"; + } + + // DeleteSpaceMember removes a member. A member may delete their own + // membership to leave the space. + rpc DeleteSpaceMember(DeleteSpaceMemberRequest) returns (google.protobuf.Empty) { + option (google.api.http) = {delete: "/api/v1/{name=spaces/*/members/*}"}; + option (google.api.method_signature) = "name"; + } +} + +// Space is a collaboration boundary for placed memos. +message Space { + option (google.api.resource) = { + type: "memos.api.v1/Space" + pattern: "spaces/{space}" + name_field: "name" + singular: "space" + plural: "spaces" + }; + + // The resource name of the space. Format: spaces/{space}. + string name = 1 [(google.api.field_behavior) = IDENTIFIER]; + + // Required. The human-readable title. + string title = 2 [(google.api.field_behavior) = REQUIRED]; + + // Optional. A description of the space. + string description = 3 [(google.api.field_behavior) = OPTIONAL]; +} + +// SpaceMember is a user's membership and governance role in a space. +message SpaceMember { + option (google.api.resource) = { + type: "memos.api.v1/SpaceMember" + pattern: "spaces/{space}/members/{member}" + name_field: "name" + singular: "spaceMember" + plural: "spaceMembers" + }; + + enum Role { + ROLE_UNSPECIFIED = 0; + ADMIN = 1; + USER = 2; + } + + // The resource name. Format: spaces/{space}/members/{username}. + string name = 1 [(google.api.field_behavior) = IDENTIFIER]; + + // Required. The member user. Format: users/{username}. + string user = 2 [ + (google.api.field_behavior) = REQUIRED, + (google.api.resource_reference) = {type: "memos.api.v1/User"} + ]; + + // Required. The member's role within this space. + Role role = 3 [(google.api.field_behavior) = REQUIRED]; +} + +message CreateSpaceRequest { + // Required. The space to create. + Space space = 1 [(google.api.field_behavior) = REQUIRED]; + + // Optional. The resource ID to use. If empty, one is generated. + string space_id = 2 [(google.api.field_behavior) = OPTIONAL]; +} + +message ListSpacesRequest { + // Optional. The maximum number of spaces to return. + int32 page_size = 1 [(google.api.field_behavior) = OPTIONAL]; + + // Optional. A token from a previous ListSpaces response. + string page_token = 2 [(google.api.field_behavior) = OPTIONAL]; +} + +message ListSpacesResponse { + repeated Space spaces = 1; + string next_page_token = 2; +} + +message GetSpaceRequest { + // Required. The resource name of the space. + string name = 1 [ + (google.api.field_behavior) = REQUIRED, + (google.api.resource_reference) = {type: "memos.api.v1/Space"} + ]; +} + +message UpdateSpaceRequest { + // Required. The space with updated values. + Space space = 1 [(google.api.field_behavior) = REQUIRED]; + + // Required. The fields to update: title or description. + google.protobuf.FieldMask update_mask = 2 [(google.api.field_behavior) = REQUIRED]; +} + +message DeleteSpaceRequest { + // Required. The resource name of the space. + string name = 1 [ + (google.api.field_behavior) = REQUIRED, + (google.api.resource_reference) = {type: "memos.api.v1/Space"} + ]; +} + +message CreateSpaceMemberRequest { + // Required. The parent space. Format: spaces/{space}. + string parent = 1 [ + (google.api.field_behavior) = REQUIRED, + (google.api.resource_reference) = {child_type: "memos.api.v1/SpaceMember"} + ]; + + // Required. The membership to create. + SpaceMember space_member = 2 [(google.api.field_behavior) = REQUIRED]; +} + +message ListSpaceMembersRequest { + // Required. The parent space. Format: spaces/{space}. + string parent = 1 [ + (google.api.field_behavior) = REQUIRED, + (google.api.resource_reference) = {child_type: "memos.api.v1/SpaceMember"} + ]; + + // Optional. The maximum number of members to return. + int32 page_size = 2 [(google.api.field_behavior) = OPTIONAL]; + + // Optional. A token from a previous ListSpaceMembers response. + string page_token = 3 [(google.api.field_behavior) = OPTIONAL]; +} + +message ListSpaceMembersResponse { + repeated SpaceMember space_members = 1; + string next_page_token = 2; +} + +message GetSpaceMemberRequest { + // Required. Format: spaces/{space}/members/{username}. + string name = 1 [ + (google.api.field_behavior) = REQUIRED, + (google.api.resource_reference) = {type: "memos.api.v1/SpaceMember"} + ]; +} + +message UpdateSpaceMemberRequest { + // Required. The membership with the new role. + SpaceMember space_member = 1 [(google.api.field_behavior) = REQUIRED]; + + // Required. Only role is supported. + google.protobuf.FieldMask update_mask = 2 [(google.api.field_behavior) = REQUIRED]; +} + +message DeleteSpaceMemberRequest { + // Required. Format: spaces/{space}/members/{username}. + string name = 1 [ + (google.api.field_behavior) = REQUIRED, + (google.api.resource_reference) = {type: "memos.api.v1/SpaceMember"} + ]; +} diff --git a/proto/gen/api/v1/ai_service.pb.go b/proto/gen/api/v1/ai_service.pb.go index 8f526a13..6b7bb50c 100644 --- a/proto/gen/api/v1/ai_service.pb.go +++ b/proto/gen/api/v1/ai_service.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.12 // protoc (unknown) // source: api/v1/ai_service.proto diff --git a/proto/gen/api/v1/apiv1connect/memo_service.connect.go b/proto/gen/api/v1/apiv1connect/memo_service.connect.go index 08938518..65635ce7 100644 --- a/proto/gen/api/v1/apiv1connect/memo_service.connect.go +++ b/proto/gen/api/v1/apiv1connect/memo_service.connect.go @@ -94,16 +94,18 @@ const ( // MemoServiceClient is a client for the memos.api.v1.MemoService service. type MemoServiceClient interface { // CreateMemo creates a memo. The request body is a Memo; set its content - // (Markdown) and visibility (PRIVATE | PROTECTED | PUBLIC, default PRIVATE). + // (Markdown) and visibility (PRIVATE | PROTECTED | PUBLIC | SPACE, + // default PRIVATE). // The memo is owned by the authenticated user; requires authentication. CreateMemo(context.Context, *connect.Request[v1.CreateMemoRequest]) (*connect.Response[v1.Memo], error) - // ListMemos lists memos with pagination and filter. + // ListMemos lists readable non-comment memos with pagination and filter. ListMemos(context.Context, *connect.Request[v1.ListMemosRequest]) (*connect.Response[v1.ListMemosResponse], error) // GetMemo gets a memo. GetMemo(context.Context, *connect.Request[v1.GetMemoRequest]) (*connect.Response[v1.Memo], error) // UpdateMemo updates a memo. UpdateMemo(context.Context, *connect.Request[v1.UpdateMemoRequest]) (*connect.Response[v1.Memo], error) - // DeleteMemo deletes a memo. + // DeleteMemo deletes only the named memo and its owned resources. It removes + // incident relations but never deletes another memo. DeleteMemo(context.Context, *connect.Request[v1.DeleteMemoRequest]) (*connect.Response[emptypb.Empty], error) // SetMemoAttachments replaces the full set of attachments on a memo with the // provided list (not an append). Pass the complete desired set; an empty list @@ -111,13 +113,15 @@ type MemoServiceClient interface { SetMemoAttachments(context.Context, *connect.Request[v1.SetMemoAttachmentsRequest]) (*connect.Response[emptypb.Empty], error) // ListMemoAttachments lists attachments for a memo. ListMemoAttachments(context.Context, *connect.Request[v1.ListMemoAttachmentsRequest]) (*connect.Response[v1.ListMemoAttachmentsResponse], error) - // SetMemoRelations replaces the full set of relations on a memo with the - // provided list (not an append). Pass the complete desired set; an empty list - // clears all relations. Idempotent. + // SetMemoRelations replaces the full set of mutable REFERENCE relations on a + // memo. COMMENT relations are immutable creation context and are rejected by + // this RPC. An empty list clears references without changing COMMENT. SetMemoRelations(context.Context, *connect.Request[v1.SetMemoRelationsRequest]) (*connect.Response[emptypb.Empty], error) // ListMemoRelations lists relations for a memo. ListMemoRelations(context.Context, *connect.Request[v1.ListMemoRelationsRequest]) (*connect.Response[v1.ListMemoRelationsResponse], error) - // CreateMemoComment creates a comment for a memo. + // CreateMemoComment atomically creates an independent memo plus one immutable + // COMMENT context relation to the named memo. The new memo keeps its own + // placement, visibility, authorship, and lifecycle. CreateMemoComment(context.Context, *connect.Request[v1.CreateMemoCommentRequest]) (*connect.Response[v1.Memo], error) // ListMemoComments lists comments for a memo. ListMemoComments(context.Context, *connect.Request[v1.ListMemoCommentsRequest]) (*connect.Response[v1.ListMemoCommentsResponse], error) @@ -403,16 +407,18 @@ func (c *memoServiceClient) BatchGetLinkMetadata(ctx context.Context, req *conne // MemoServiceHandler is an implementation of the memos.api.v1.MemoService service. type MemoServiceHandler interface { // CreateMemo creates a memo. The request body is a Memo; set its content - // (Markdown) and visibility (PRIVATE | PROTECTED | PUBLIC, default PRIVATE). + // (Markdown) and visibility (PRIVATE | PROTECTED | PUBLIC | SPACE, + // default PRIVATE). // The memo is owned by the authenticated user; requires authentication. CreateMemo(context.Context, *connect.Request[v1.CreateMemoRequest]) (*connect.Response[v1.Memo], error) - // ListMemos lists memos with pagination and filter. + // ListMemos lists readable non-comment memos with pagination and filter. ListMemos(context.Context, *connect.Request[v1.ListMemosRequest]) (*connect.Response[v1.ListMemosResponse], error) // GetMemo gets a memo. GetMemo(context.Context, *connect.Request[v1.GetMemoRequest]) (*connect.Response[v1.Memo], error) // UpdateMemo updates a memo. UpdateMemo(context.Context, *connect.Request[v1.UpdateMemoRequest]) (*connect.Response[v1.Memo], error) - // DeleteMemo deletes a memo. + // DeleteMemo deletes only the named memo and its owned resources. It removes + // incident relations but never deletes another memo. DeleteMemo(context.Context, *connect.Request[v1.DeleteMemoRequest]) (*connect.Response[emptypb.Empty], error) // SetMemoAttachments replaces the full set of attachments on a memo with the // provided list (not an append). Pass the complete desired set; an empty list @@ -420,13 +426,15 @@ type MemoServiceHandler interface { SetMemoAttachments(context.Context, *connect.Request[v1.SetMemoAttachmentsRequest]) (*connect.Response[emptypb.Empty], error) // ListMemoAttachments lists attachments for a memo. ListMemoAttachments(context.Context, *connect.Request[v1.ListMemoAttachmentsRequest]) (*connect.Response[v1.ListMemoAttachmentsResponse], error) - // SetMemoRelations replaces the full set of relations on a memo with the - // provided list (not an append). Pass the complete desired set; an empty list - // clears all relations. Idempotent. + // SetMemoRelations replaces the full set of mutable REFERENCE relations on a + // memo. COMMENT relations are immutable creation context and are rejected by + // this RPC. An empty list clears references without changing COMMENT. SetMemoRelations(context.Context, *connect.Request[v1.SetMemoRelationsRequest]) (*connect.Response[emptypb.Empty], error) // ListMemoRelations lists relations for a memo. ListMemoRelations(context.Context, *connect.Request[v1.ListMemoRelationsRequest]) (*connect.Response[v1.ListMemoRelationsResponse], error) - // CreateMemoComment creates a comment for a memo. + // CreateMemoComment atomically creates an independent memo plus one immutable + // COMMENT context relation to the named memo. The new memo keeps its own + // placement, visibility, authorship, and lifecycle. CreateMemoComment(context.Context, *connect.Request[v1.CreateMemoCommentRequest]) (*connect.Response[v1.Memo], error) // ListMemoComments lists comments for a memo. ListMemoComments(context.Context, *connect.Request[v1.ListMemoCommentsRequest]) (*connect.Response[v1.ListMemoCommentsResponse], error) diff --git a/proto/gen/api/v1/apiv1connect/space_service.connect.go b/proto/gen/api/v1/apiv1connect/space_service.connect.go new file mode 100644 index 00000000..bce6ca21 --- /dev/null +++ b/proto/gen/api/v1/apiv1connect/space_service.connect.go @@ -0,0 +1,395 @@ +// Code generated by protoc-gen-connect-go. DO NOT EDIT. +// +// Source: api/v1/space_service.proto + +package apiv1connect + +import ( + connect "connectrpc.com/connect" + context "context" + errors "errors" + v1 "github.com/usememos/memos/proto/gen/api/v1" + emptypb "google.golang.org/protobuf/types/known/emptypb" + http "net/http" + strings "strings" +) + +// This is a compile-time assertion to ensure that this generated file and the connect package are +// compatible. If you get a compiler error that this constant is not defined, this code was +// generated with a version of connect newer than the one compiled into your binary. You can fix the +// problem by either regenerating this code with an older version of connect or updating the connect +// version compiled into your binary. +const _ = connect.IsAtLeastVersion1_13_0 + +const ( + // SpaceServiceName is the fully-qualified name of the SpaceService service. + SpaceServiceName = "memos.api.v1.SpaceService" +) + +// These constants are the fully-qualified names of the RPCs defined in this package. They're +// exposed at runtime as Spec.Procedure and as the final two segments of the HTTP route. +// +// Note that these are different from the fully-qualified method names used by +// google.golang.org/protobuf/reflect/protoreflect. To convert from these constants to +// reflection-formatted method names, remove the leading slash and convert the remaining slash to a +// period. +const ( + // SpaceServiceCreateSpaceProcedure is the fully-qualified name of the SpaceService's CreateSpace + // RPC. + SpaceServiceCreateSpaceProcedure = "/memos.api.v1.SpaceService/CreateSpace" + // SpaceServiceListSpacesProcedure is the fully-qualified name of the SpaceService's ListSpaces RPC. + SpaceServiceListSpacesProcedure = "/memos.api.v1.SpaceService/ListSpaces" + // SpaceServiceGetSpaceProcedure is the fully-qualified name of the SpaceService's GetSpace RPC. + SpaceServiceGetSpaceProcedure = "/memos.api.v1.SpaceService/GetSpace" + // SpaceServiceUpdateSpaceProcedure is the fully-qualified name of the SpaceService's UpdateSpace + // RPC. + SpaceServiceUpdateSpaceProcedure = "/memos.api.v1.SpaceService/UpdateSpace" + // SpaceServiceDeleteSpaceProcedure is the fully-qualified name of the SpaceService's DeleteSpace + // RPC. + SpaceServiceDeleteSpaceProcedure = "/memos.api.v1.SpaceService/DeleteSpace" + // SpaceServiceCreateSpaceMemberProcedure is the fully-qualified name of the SpaceService's + // CreateSpaceMember RPC. + SpaceServiceCreateSpaceMemberProcedure = "/memos.api.v1.SpaceService/CreateSpaceMember" + // SpaceServiceListSpaceMembersProcedure is the fully-qualified name of the SpaceService's + // ListSpaceMembers RPC. + SpaceServiceListSpaceMembersProcedure = "/memos.api.v1.SpaceService/ListSpaceMembers" + // SpaceServiceGetSpaceMemberProcedure is the fully-qualified name of the SpaceService's + // GetSpaceMember RPC. + SpaceServiceGetSpaceMemberProcedure = "/memos.api.v1.SpaceService/GetSpaceMember" + // SpaceServiceUpdateSpaceMemberProcedure is the fully-qualified name of the SpaceService's + // UpdateSpaceMember RPC. + SpaceServiceUpdateSpaceMemberProcedure = "/memos.api.v1.SpaceService/UpdateSpaceMember" + // SpaceServiceDeleteSpaceMemberProcedure is the fully-qualified name of the SpaceService's + // DeleteSpaceMember RPC. + SpaceServiceDeleteSpaceMemberProcedure = "/memos.api.v1.SpaceService/DeleteSpaceMember" +) + +// SpaceServiceClient is a client for the memos.api.v1.SpaceService service. +type SpaceServiceClient interface { + // CreateSpace creates a space and makes the authenticated caller its first + // administrator. + CreateSpace(context.Context, *connect.Request[v1.CreateSpaceRequest]) (*connect.Response[v1.Space], error) + // ListSpaces lists spaces of which the authenticated caller is a member. + ListSpaces(context.Context, *connect.Request[v1.ListSpacesRequest]) (*connect.Response[v1.ListSpacesResponse], error) + // GetSpace gets a space of which the authenticated caller is a member. + GetSpace(context.Context, *connect.Request[v1.GetSpaceRequest]) (*connect.Response[v1.Space], error) + // UpdateSpace updates space metadata. + UpdateSpace(context.Context, *connect.Request[v1.UpdateSpaceRequest]) (*connect.Response[v1.Space], error) + // DeleteSpace permanently deletes a space and every memo currently placed + // in it. It never follows memo relations to other memos. + DeleteSpace(context.Context, *connect.Request[v1.DeleteSpaceRequest]) (*connect.Response[emptypb.Empty], error) + // CreateSpaceMember directly adds an existing active user to a space. + CreateSpaceMember(context.Context, *connect.Request[v1.CreateSpaceMemberRequest]) (*connect.Response[v1.SpaceMember], error) + // ListSpaceMembers lists the members of a space. + ListSpaceMembers(context.Context, *connect.Request[v1.ListSpaceMembersRequest]) (*connect.Response[v1.ListSpaceMembersResponse], error) + // GetSpaceMember gets one membership in a space. + GetSpaceMember(context.Context, *connect.Request[v1.GetSpaceMemberRequest]) (*connect.Response[v1.SpaceMember], error) + // UpdateSpaceMember changes a member's space role. + UpdateSpaceMember(context.Context, *connect.Request[v1.UpdateSpaceMemberRequest]) (*connect.Response[v1.SpaceMember], error) + // DeleteSpaceMember removes a member. A member may delete their own + // membership to leave the space. + DeleteSpaceMember(context.Context, *connect.Request[v1.DeleteSpaceMemberRequest]) (*connect.Response[emptypb.Empty], error) +} + +// NewSpaceServiceClient constructs a client for the memos.api.v1.SpaceService service. By default, +// it uses the Connect protocol with the binary Protobuf Codec, asks for gzipped responses, and +// sends uncompressed requests. To use the gRPC or gRPC-Web protocols, supply the connect.WithGRPC() +// or connect.WithGRPCWeb() options. +// +// The URL supplied here should be the base URL for the Connect or gRPC server (for example, +// http://api.acme.com or https://acme.com/grpc). +func NewSpaceServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.ClientOption) SpaceServiceClient { + baseURL = strings.TrimRight(baseURL, "/") + spaceServiceMethods := v1.File_api_v1_space_service_proto.Services().ByName("SpaceService").Methods() + return &spaceServiceClient{ + createSpace: connect.NewClient[v1.CreateSpaceRequest, v1.Space]( + httpClient, + baseURL+SpaceServiceCreateSpaceProcedure, + connect.WithSchema(spaceServiceMethods.ByName("CreateSpace")), + connect.WithClientOptions(opts...), + ), + listSpaces: connect.NewClient[v1.ListSpacesRequest, v1.ListSpacesResponse]( + httpClient, + baseURL+SpaceServiceListSpacesProcedure, + connect.WithSchema(spaceServiceMethods.ByName("ListSpaces")), + connect.WithClientOptions(opts...), + ), + getSpace: connect.NewClient[v1.GetSpaceRequest, v1.Space]( + httpClient, + baseURL+SpaceServiceGetSpaceProcedure, + connect.WithSchema(spaceServiceMethods.ByName("GetSpace")), + connect.WithClientOptions(opts...), + ), + updateSpace: connect.NewClient[v1.UpdateSpaceRequest, v1.Space]( + httpClient, + baseURL+SpaceServiceUpdateSpaceProcedure, + connect.WithSchema(spaceServiceMethods.ByName("UpdateSpace")), + connect.WithClientOptions(opts...), + ), + deleteSpace: connect.NewClient[v1.DeleteSpaceRequest, emptypb.Empty]( + httpClient, + baseURL+SpaceServiceDeleteSpaceProcedure, + connect.WithSchema(spaceServiceMethods.ByName("DeleteSpace")), + connect.WithClientOptions(opts...), + ), + createSpaceMember: connect.NewClient[v1.CreateSpaceMemberRequest, v1.SpaceMember]( + httpClient, + baseURL+SpaceServiceCreateSpaceMemberProcedure, + connect.WithSchema(spaceServiceMethods.ByName("CreateSpaceMember")), + connect.WithClientOptions(opts...), + ), + listSpaceMembers: connect.NewClient[v1.ListSpaceMembersRequest, v1.ListSpaceMembersResponse]( + httpClient, + baseURL+SpaceServiceListSpaceMembersProcedure, + connect.WithSchema(spaceServiceMethods.ByName("ListSpaceMembers")), + connect.WithClientOptions(opts...), + ), + getSpaceMember: connect.NewClient[v1.GetSpaceMemberRequest, v1.SpaceMember]( + httpClient, + baseURL+SpaceServiceGetSpaceMemberProcedure, + connect.WithSchema(spaceServiceMethods.ByName("GetSpaceMember")), + connect.WithClientOptions(opts...), + ), + updateSpaceMember: connect.NewClient[v1.UpdateSpaceMemberRequest, v1.SpaceMember]( + httpClient, + baseURL+SpaceServiceUpdateSpaceMemberProcedure, + connect.WithSchema(spaceServiceMethods.ByName("UpdateSpaceMember")), + connect.WithClientOptions(opts...), + ), + deleteSpaceMember: connect.NewClient[v1.DeleteSpaceMemberRequest, emptypb.Empty]( + httpClient, + baseURL+SpaceServiceDeleteSpaceMemberProcedure, + connect.WithSchema(spaceServiceMethods.ByName("DeleteSpaceMember")), + connect.WithClientOptions(opts...), + ), + } +} + +// spaceServiceClient implements SpaceServiceClient. +type spaceServiceClient struct { + createSpace *connect.Client[v1.CreateSpaceRequest, v1.Space] + listSpaces *connect.Client[v1.ListSpacesRequest, v1.ListSpacesResponse] + getSpace *connect.Client[v1.GetSpaceRequest, v1.Space] + updateSpace *connect.Client[v1.UpdateSpaceRequest, v1.Space] + deleteSpace *connect.Client[v1.DeleteSpaceRequest, emptypb.Empty] + createSpaceMember *connect.Client[v1.CreateSpaceMemberRequest, v1.SpaceMember] + listSpaceMembers *connect.Client[v1.ListSpaceMembersRequest, v1.ListSpaceMembersResponse] + getSpaceMember *connect.Client[v1.GetSpaceMemberRequest, v1.SpaceMember] + updateSpaceMember *connect.Client[v1.UpdateSpaceMemberRequest, v1.SpaceMember] + deleteSpaceMember *connect.Client[v1.DeleteSpaceMemberRequest, emptypb.Empty] +} + +// CreateSpace calls memos.api.v1.SpaceService.CreateSpace. +func (c *spaceServiceClient) CreateSpace(ctx context.Context, req *connect.Request[v1.CreateSpaceRequest]) (*connect.Response[v1.Space], error) { + return c.createSpace.CallUnary(ctx, req) +} + +// ListSpaces calls memos.api.v1.SpaceService.ListSpaces. +func (c *spaceServiceClient) ListSpaces(ctx context.Context, req *connect.Request[v1.ListSpacesRequest]) (*connect.Response[v1.ListSpacesResponse], error) { + return c.listSpaces.CallUnary(ctx, req) +} + +// GetSpace calls memos.api.v1.SpaceService.GetSpace. +func (c *spaceServiceClient) GetSpace(ctx context.Context, req *connect.Request[v1.GetSpaceRequest]) (*connect.Response[v1.Space], error) { + return c.getSpace.CallUnary(ctx, req) +} + +// UpdateSpace calls memos.api.v1.SpaceService.UpdateSpace. +func (c *spaceServiceClient) UpdateSpace(ctx context.Context, req *connect.Request[v1.UpdateSpaceRequest]) (*connect.Response[v1.Space], error) { + return c.updateSpace.CallUnary(ctx, req) +} + +// DeleteSpace calls memos.api.v1.SpaceService.DeleteSpace. +func (c *spaceServiceClient) DeleteSpace(ctx context.Context, req *connect.Request[v1.DeleteSpaceRequest]) (*connect.Response[emptypb.Empty], error) { + return c.deleteSpace.CallUnary(ctx, req) +} + +// CreateSpaceMember calls memos.api.v1.SpaceService.CreateSpaceMember. +func (c *spaceServiceClient) CreateSpaceMember(ctx context.Context, req *connect.Request[v1.CreateSpaceMemberRequest]) (*connect.Response[v1.SpaceMember], error) { + return c.createSpaceMember.CallUnary(ctx, req) +} + +// ListSpaceMembers calls memos.api.v1.SpaceService.ListSpaceMembers. +func (c *spaceServiceClient) ListSpaceMembers(ctx context.Context, req *connect.Request[v1.ListSpaceMembersRequest]) (*connect.Response[v1.ListSpaceMembersResponse], error) { + return c.listSpaceMembers.CallUnary(ctx, req) +} + +// GetSpaceMember calls memos.api.v1.SpaceService.GetSpaceMember. +func (c *spaceServiceClient) GetSpaceMember(ctx context.Context, req *connect.Request[v1.GetSpaceMemberRequest]) (*connect.Response[v1.SpaceMember], error) { + return c.getSpaceMember.CallUnary(ctx, req) +} + +// UpdateSpaceMember calls memos.api.v1.SpaceService.UpdateSpaceMember. +func (c *spaceServiceClient) UpdateSpaceMember(ctx context.Context, req *connect.Request[v1.UpdateSpaceMemberRequest]) (*connect.Response[v1.SpaceMember], error) { + return c.updateSpaceMember.CallUnary(ctx, req) +} + +// DeleteSpaceMember calls memos.api.v1.SpaceService.DeleteSpaceMember. +func (c *spaceServiceClient) DeleteSpaceMember(ctx context.Context, req *connect.Request[v1.DeleteSpaceMemberRequest]) (*connect.Response[emptypb.Empty], error) { + return c.deleteSpaceMember.CallUnary(ctx, req) +} + +// SpaceServiceHandler is an implementation of the memos.api.v1.SpaceService service. +type SpaceServiceHandler interface { + // CreateSpace creates a space and makes the authenticated caller its first + // administrator. + CreateSpace(context.Context, *connect.Request[v1.CreateSpaceRequest]) (*connect.Response[v1.Space], error) + // ListSpaces lists spaces of which the authenticated caller is a member. + ListSpaces(context.Context, *connect.Request[v1.ListSpacesRequest]) (*connect.Response[v1.ListSpacesResponse], error) + // GetSpace gets a space of which the authenticated caller is a member. + GetSpace(context.Context, *connect.Request[v1.GetSpaceRequest]) (*connect.Response[v1.Space], error) + // UpdateSpace updates space metadata. + UpdateSpace(context.Context, *connect.Request[v1.UpdateSpaceRequest]) (*connect.Response[v1.Space], error) + // DeleteSpace permanently deletes a space and every memo currently placed + // in it. It never follows memo relations to other memos. + DeleteSpace(context.Context, *connect.Request[v1.DeleteSpaceRequest]) (*connect.Response[emptypb.Empty], error) + // CreateSpaceMember directly adds an existing active user to a space. + CreateSpaceMember(context.Context, *connect.Request[v1.CreateSpaceMemberRequest]) (*connect.Response[v1.SpaceMember], error) + // ListSpaceMembers lists the members of a space. + ListSpaceMembers(context.Context, *connect.Request[v1.ListSpaceMembersRequest]) (*connect.Response[v1.ListSpaceMembersResponse], error) + // GetSpaceMember gets one membership in a space. + GetSpaceMember(context.Context, *connect.Request[v1.GetSpaceMemberRequest]) (*connect.Response[v1.SpaceMember], error) + // UpdateSpaceMember changes a member's space role. + UpdateSpaceMember(context.Context, *connect.Request[v1.UpdateSpaceMemberRequest]) (*connect.Response[v1.SpaceMember], error) + // DeleteSpaceMember removes a member. A member may delete their own + // membership to leave the space. + DeleteSpaceMember(context.Context, *connect.Request[v1.DeleteSpaceMemberRequest]) (*connect.Response[emptypb.Empty], error) +} + +// NewSpaceServiceHandler builds an HTTP handler from the service implementation. It returns the +// path on which to mount the handler and the handler itself. +// +// By default, handlers support the Connect, gRPC, and gRPC-Web protocols with the binary Protobuf +// and JSON codecs. They also support gzip compression. +func NewSpaceServiceHandler(svc SpaceServiceHandler, opts ...connect.HandlerOption) (string, http.Handler) { + spaceServiceMethods := v1.File_api_v1_space_service_proto.Services().ByName("SpaceService").Methods() + spaceServiceCreateSpaceHandler := connect.NewUnaryHandler( + SpaceServiceCreateSpaceProcedure, + svc.CreateSpace, + connect.WithSchema(spaceServiceMethods.ByName("CreateSpace")), + connect.WithHandlerOptions(opts...), + ) + spaceServiceListSpacesHandler := connect.NewUnaryHandler( + SpaceServiceListSpacesProcedure, + svc.ListSpaces, + connect.WithSchema(spaceServiceMethods.ByName("ListSpaces")), + connect.WithHandlerOptions(opts...), + ) + spaceServiceGetSpaceHandler := connect.NewUnaryHandler( + SpaceServiceGetSpaceProcedure, + svc.GetSpace, + connect.WithSchema(spaceServiceMethods.ByName("GetSpace")), + connect.WithHandlerOptions(opts...), + ) + spaceServiceUpdateSpaceHandler := connect.NewUnaryHandler( + SpaceServiceUpdateSpaceProcedure, + svc.UpdateSpace, + connect.WithSchema(spaceServiceMethods.ByName("UpdateSpace")), + connect.WithHandlerOptions(opts...), + ) + spaceServiceDeleteSpaceHandler := connect.NewUnaryHandler( + SpaceServiceDeleteSpaceProcedure, + svc.DeleteSpace, + connect.WithSchema(spaceServiceMethods.ByName("DeleteSpace")), + connect.WithHandlerOptions(opts...), + ) + spaceServiceCreateSpaceMemberHandler := connect.NewUnaryHandler( + SpaceServiceCreateSpaceMemberProcedure, + svc.CreateSpaceMember, + connect.WithSchema(spaceServiceMethods.ByName("CreateSpaceMember")), + connect.WithHandlerOptions(opts...), + ) + spaceServiceListSpaceMembersHandler := connect.NewUnaryHandler( + SpaceServiceListSpaceMembersProcedure, + svc.ListSpaceMembers, + connect.WithSchema(spaceServiceMethods.ByName("ListSpaceMembers")), + connect.WithHandlerOptions(opts...), + ) + spaceServiceGetSpaceMemberHandler := connect.NewUnaryHandler( + SpaceServiceGetSpaceMemberProcedure, + svc.GetSpaceMember, + connect.WithSchema(spaceServiceMethods.ByName("GetSpaceMember")), + connect.WithHandlerOptions(opts...), + ) + spaceServiceUpdateSpaceMemberHandler := connect.NewUnaryHandler( + SpaceServiceUpdateSpaceMemberProcedure, + svc.UpdateSpaceMember, + connect.WithSchema(spaceServiceMethods.ByName("UpdateSpaceMember")), + connect.WithHandlerOptions(opts...), + ) + spaceServiceDeleteSpaceMemberHandler := connect.NewUnaryHandler( + SpaceServiceDeleteSpaceMemberProcedure, + svc.DeleteSpaceMember, + connect.WithSchema(spaceServiceMethods.ByName("DeleteSpaceMember")), + connect.WithHandlerOptions(opts...), + ) + return "/memos.api.v1.SpaceService/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + switch r.URL.Path { + case SpaceServiceCreateSpaceProcedure: + spaceServiceCreateSpaceHandler.ServeHTTP(w, r) + case SpaceServiceListSpacesProcedure: + spaceServiceListSpacesHandler.ServeHTTP(w, r) + case SpaceServiceGetSpaceProcedure: + spaceServiceGetSpaceHandler.ServeHTTP(w, r) + case SpaceServiceUpdateSpaceProcedure: + spaceServiceUpdateSpaceHandler.ServeHTTP(w, r) + case SpaceServiceDeleteSpaceProcedure: + spaceServiceDeleteSpaceHandler.ServeHTTP(w, r) + case SpaceServiceCreateSpaceMemberProcedure: + spaceServiceCreateSpaceMemberHandler.ServeHTTP(w, r) + case SpaceServiceListSpaceMembersProcedure: + spaceServiceListSpaceMembersHandler.ServeHTTP(w, r) + case SpaceServiceGetSpaceMemberProcedure: + spaceServiceGetSpaceMemberHandler.ServeHTTP(w, r) + case SpaceServiceUpdateSpaceMemberProcedure: + spaceServiceUpdateSpaceMemberHandler.ServeHTTP(w, r) + case SpaceServiceDeleteSpaceMemberProcedure: + spaceServiceDeleteSpaceMemberHandler.ServeHTTP(w, r) + default: + http.NotFound(w, r) + } + }) +} + +// UnimplementedSpaceServiceHandler returns CodeUnimplemented from all methods. +type UnimplementedSpaceServiceHandler struct{} + +func (UnimplementedSpaceServiceHandler) CreateSpace(context.Context, *connect.Request[v1.CreateSpaceRequest]) (*connect.Response[v1.Space], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("memos.api.v1.SpaceService.CreateSpace is not implemented")) +} + +func (UnimplementedSpaceServiceHandler) ListSpaces(context.Context, *connect.Request[v1.ListSpacesRequest]) (*connect.Response[v1.ListSpacesResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("memos.api.v1.SpaceService.ListSpaces is not implemented")) +} + +func (UnimplementedSpaceServiceHandler) GetSpace(context.Context, *connect.Request[v1.GetSpaceRequest]) (*connect.Response[v1.Space], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("memos.api.v1.SpaceService.GetSpace is not implemented")) +} + +func (UnimplementedSpaceServiceHandler) UpdateSpace(context.Context, *connect.Request[v1.UpdateSpaceRequest]) (*connect.Response[v1.Space], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("memos.api.v1.SpaceService.UpdateSpace is not implemented")) +} + +func (UnimplementedSpaceServiceHandler) DeleteSpace(context.Context, *connect.Request[v1.DeleteSpaceRequest]) (*connect.Response[emptypb.Empty], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("memos.api.v1.SpaceService.DeleteSpace is not implemented")) +} + +func (UnimplementedSpaceServiceHandler) CreateSpaceMember(context.Context, *connect.Request[v1.CreateSpaceMemberRequest]) (*connect.Response[v1.SpaceMember], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("memos.api.v1.SpaceService.CreateSpaceMember is not implemented")) +} + +func (UnimplementedSpaceServiceHandler) ListSpaceMembers(context.Context, *connect.Request[v1.ListSpaceMembersRequest]) (*connect.Response[v1.ListSpaceMembersResponse], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("memos.api.v1.SpaceService.ListSpaceMembers is not implemented")) +} + +func (UnimplementedSpaceServiceHandler) GetSpaceMember(context.Context, *connect.Request[v1.GetSpaceMemberRequest]) (*connect.Response[v1.SpaceMember], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("memos.api.v1.SpaceService.GetSpaceMember is not implemented")) +} + +func (UnimplementedSpaceServiceHandler) UpdateSpaceMember(context.Context, *connect.Request[v1.UpdateSpaceMemberRequest]) (*connect.Response[v1.SpaceMember], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("memos.api.v1.SpaceService.UpdateSpaceMember is not implemented")) +} + +func (UnimplementedSpaceServiceHandler) DeleteSpaceMember(context.Context, *connect.Request[v1.DeleteSpaceMemberRequest]) (*connect.Response[emptypb.Empty], error) { + return nil, connect.NewError(connect.CodeUnimplemented, errors.New("memos.api.v1.SpaceService.DeleteSpaceMember is not implemented")) +} diff --git a/proto/gen/api/v1/attachment_service.pb.go b/proto/gen/api/v1/attachment_service.pb.go index 10d56028..279f5d11 100644 --- a/proto/gen/api/v1/attachment_service.pb.go +++ b/proto/gen/api/v1/attachment_service.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.12 // protoc (unknown) // source: api/v1/attachment_service.proto diff --git a/proto/gen/api/v1/auth_service.pb.go b/proto/gen/api/v1/auth_service.pb.go index 5cad4004..19dac0c9 100644 --- a/proto/gen/api/v1/auth_service.pb.go +++ b/proto/gen/api/v1/auth_service.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.12 // protoc (unknown) // source: api/v1/auth_service.proto diff --git a/proto/gen/api/v1/common.pb.go b/proto/gen/api/v1/common.pb.go index 0082d736..fcb0bddd 100644 --- a/proto/gen/api/v1/common.pb.go +++ b/proto/gen/api/v1/common.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.12 // protoc (unknown) // source: api/v1/common.proto diff --git a/proto/gen/api/v1/idp_service.pb.go b/proto/gen/api/v1/idp_service.pb.go index 70059e72..6b980df4 100644 --- a/proto/gen/api/v1/idp_service.pb.go +++ b/proto/gen/api/v1/idp_service.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.12 // protoc (unknown) // source: api/v1/idp_service.proto diff --git a/proto/gen/api/v1/memo_service.pb.go b/proto/gen/api/v1/memo_service.pb.go index f6acd8d3..19e91ab6 100644 --- a/proto/gen/api/v1/memo_service.pb.go +++ b/proto/gen/api/v1/memo_service.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.12 // protoc (unknown) // source: api/v1/memo_service.proto @@ -34,8 +34,11 @@ const ( Visibility_PRIVATE Visibility = 1 // PROTECTED: signed-in users of the instance can read the memo. Visibility_PROTECTED Visibility = 2 - // PUBLIC: anyone, including anonymous visitors, can read the memo. + // PUBLIC: signed-in users can read the memo; anonymous visitors can read it + // when instance policy permits. Visibility_PUBLIC Visibility = 3 + // SPACE: active members of the memo's space can read it. + Visibility_SPACE Visibility = 4 ) // Enum value maps for Visibility. @@ -45,12 +48,14 @@ var ( 1: "PRIVATE", 2: "PROTECTED", 3: "PUBLIC", + 4: "SPACE", } Visibility_value = map[string]int32{ "VISIBILITY_UNSPECIFIED": 0, "PRIVATE": 1, "PROTECTED": 2, "PUBLIC": 3, + "SPACE": 4, } ) @@ -225,8 +230,9 @@ type Memo struct { // Required. The content of the memo in Markdown format. Content string `protobuf:"bytes,7,opt,name=content,proto3" json:"content,omitempty"` // The visibility of the memo. - // One of PRIVATE (creator only), PROTECTED (signed-in users), or - // PUBLIC (anyone). Defaults to PRIVATE on creation when unspecified. + // One of PRIVATE (creator only), PROTECTED (signed-in users), PUBLIC + // (anonymous-eligible), or SPACE (active space members). Defaults to + // PRIVATE on creation when unspecified. Visibility Visibility `protobuf:"varint,9,opt,name=visibility,proto3,enum=memos.api.v1.Visibility" json:"visibility,omitempty"` // Output only. The tags extracted from the content. Tags []string `protobuf:"bytes,10,rep,name=tags,proto3" json:"tags,omitempty"` @@ -240,13 +246,17 @@ type Memo struct { Reactions []*Reaction `protobuf:"bytes,14,rep,name=reactions,proto3" json:"reactions,omitempty"` // Output only. The computed properties of the memo. Property *Memo_Property `protobuf:"bytes,15,opt,name=property,proto3" json:"property,omitempty"` - // Output only. The name of the parent memo. + // Output only. The readable context memo of this COMMENT relation, if any. + // This is omitted unless the caller may independently read both memos. // Format: memos/{memo} Parent *string `protobuf:"bytes,16,opt,name=parent,proto3,oneof" json:"parent,omitempty"` // Output only. The snippet of the memo content. Plain text only. Snippet string `protobuf:"bytes,17,opt,name=snippet,proto3" json:"snippet,omitempty"` // Optional. The location of the memo. - Location *Location `protobuf:"bytes,18,opt,name=location,proto3,oneof" json:"location,omitempty"` + Location *Location `protobuf:"bytes,18,opt,name=location,proto3,oneof" json:"location,omitempty"` + // Optional. The space in which this memo is placed. Format: spaces/{space}. + // Every memo, including a comment, owns its placement independently. + Space *string `protobuf:"bytes,19,opt,name=space,proto3,oneof" json:"space,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -393,6 +403,13 @@ func (x *Memo) GetLocation() *Location { return nil } +func (x *Memo) GetSpace() string { + if x != nil && x.Space != nil { + return *x.Space + } + return "" +} + type Location struct { state protoimpl.MessageState `protogen:"open.v1"` // A placeholder text for the location. @@ -538,7 +555,7 @@ type ListMemosRequest struct { // // content (string), creator (string, e.g. "users/1"), // created_ts / updated_ts (timestamp), pinned (bool), - // visibility (string: PRIVATE | PROTECTED | PUBLIC), + // visibility (string: PRIVATE | PROTECTED | PUBLIC | SPACE), // tags (list; match with `"work" in tags`, not `tag == "work"`), // has_task_list / has_link / has_code / has_incomplete_tasks (bool), // has_location (bool; true when the memo has a location attached). @@ -552,7 +569,12 @@ type ListMemosRequest struct { // content.contains("roadmap") && created_ts > now - duration("168h") Filter string `protobuf:"bytes,5,opt,name=filter,proto3" json:"filter,omitempty"` // Optional. If true, show deleted memos in the response. - ShowDeleted bool `protobuf:"varint,6,opt,name=show_deleted,json=showDeleted,proto3" json:"show_deleted,omitempty"` + ShowDeleted bool `protobuf:"varint,6,opt,name=show_deleted,json=showDeleted,proto3" json:"show_deleted,omitempty"` + // Types that are valid to be assigned to Scope: + // + // *ListMemosRequest_Space + // *ListMemosRequest_Unassigned + Scope isListMemosRequest_Scope `protobuf_oneof:"scope"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -629,6 +651,50 @@ func (x *ListMemosRequest) GetShowDeleted() bool { return false } +func (x *ListMemosRequest) GetScope() isListMemosRequest_Scope { + if x != nil { + return x.Scope + } + return nil +} + +func (x *ListMemosRequest) GetSpace() string { + if x != nil { + if x, ok := x.Scope.(*ListMemosRequest_Space); ok { + return x.Space + } + } + return "" +} + +func (x *ListMemosRequest) GetUnassigned() bool { + if x != nil { + if x, ok := x.Scope.(*ListMemosRequest_Unassigned); ok { + return x.Unassigned + } + } + return false +} + +type isListMemosRequest_Scope interface { + isListMemosRequest_Scope() +} + +type ListMemosRequest_Space struct { + // Optional. Limit results to readable non-comment memos in a space of + // which the caller is an active member. + Space string `protobuf:"bytes,7,opt,name=space,proto3,oneof"` +} + +type ListMemosRequest_Unassigned struct { + // Optional. Limit results to memos with no space. Must be true when set. + Unassigned bool `protobuf:"varint,8,opt,name=unassigned,proto3,oneof"` +} + +func (*ListMemosRequest_Space) isListMemosRequest_Scope() {} + +func (*ListMemosRequest_Unassigned) isListMemosRequest_Scope() {} + type ListMemosResponse struct { state protoimpl.MessageState `protogen:"open.v1"` // The list of memos. @@ -1080,7 +1146,7 @@ type SetMemoRelationsRequest struct { // Required. The resource name of the memo. // Format: memos/{memo} Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - // Required. The relations to set for the memo. + // Required. The REFERENCE relations to set for the memo. COMMENT is invalid. Relations []*MemoRelation `protobuf:"bytes,2,rep,name=relations,proto3" json:"relations,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -2315,7 +2381,7 @@ const file_api_v1_memo_service_proto_rawDesc = "" + "\vcreate_time\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampB\x03\xe0A\x03R\n" + "createTime:X\xeaAU\n" + "\x15memos.api.v1/Reaction\x12!memos/{memo}/reactions/{reaction}\x1a\x04name*\treactions2\breactionJ\x04\b\x03\x10\x04R\n" + - "content_id\"\xbe\b\n" + + "content_id\"\xff\b\n" + "\x04Memo\x12\x17\n" + "\x04name\x18\x01 \x01(\tB\x03\xe0A\bR\x04name\x12.\n" + "\x05state\x18\x02 \x01(\x0e2\x13.memos.api.v1.StateB\x03\xe0A\x02R\x05state\x123\n" + @@ -2339,7 +2405,9 @@ const file_api_v1_memo_service_proto_rawDesc = "" + "\x06parent\x18\x10 \x01(\tB\x19\xe0A\x03\xfaA\x13\n" + "\x11memos.api.v1/MemoH\x00R\x06parent\x88\x01\x01\x12\x1d\n" + "\asnippet\x18\x11 \x01(\tB\x03\xe0A\x03R\asnippet\x12<\n" + - "\blocation\x18\x12 \x01(\v2\x16.memos.api.v1.LocationB\x03\xe0A\x01H\x01R\blocation\x88\x01\x01\x1a\xac\x01\n" + + "\blocation\x18\x12 \x01(\v2\x16.memos.api.v1.LocationB\x03\xe0A\x01H\x01R\blocation\x88\x01\x01\x125\n" + + "\x05space\x18\x13 \x01(\tB\x1a\xe0A\x01\xfaA\x14\n" + + "\x12memos.api.v1/SpaceH\x02R\x05space\x88\x01\x01\x1a\xac\x01\n" + "\bProperty\x12\x19\n" + "\bhas_link\x18\x01 \x01(\bR\ahasLink\x12\"\n" + "\rhas_task_list\x18\x02 \x01(\bR\vhasTaskList\x12\x19\n" + @@ -2348,14 +2416,15 @@ const file_api_v1_memo_service_proto_rawDesc = "" + "\x05title\x18\x05 \x01(\tR\x05title:7\xeaA4\n" + "\x11memos.api.v1/Memo\x12\fmemos/{memo}\x1a\x04name*\x05memos2\x04memoB\t\n" + "\a_parentB\v\n" + - "\t_locationJ\x04\b\x06\x10\aR\fdisplay_time\"u\n" + + "\t_locationB\b\n" + + "\x06_spaceJ\x04\b\x06\x10\aR\fdisplay_time\"u\n" + "\bLocation\x12%\n" + "\vplaceholder\x18\x01 \x01(\tB\x03\xe0A\x01R\vplaceholder\x12\x1f\n" + "\blatitude\x18\x02 \x01(\x01B\x03\xe0A\x01R\blatitude\x12!\n" + "\tlongitude\x18\x03 \x01(\x01B\x03\xe0A\x01R\tlongitude\"^\n" + "\x11CreateMemoRequest\x12+\n" + "\x04memo\x18\x01 \x01(\v2\x12.memos.api.v1.MemoB\x03\xe0A\x02R\x04memo\x12\x1c\n" + - "\amemo_id\x18\x02 \x01(\tB\x03\xe0A\x01R\x06memoId\"\xed\x01\n" + + "\amemo_id\x18\x02 \x01(\tB\x03\xe0A\x01R\x06memoId\"\xc9\x02\n" + "\x10ListMemosRequest\x12 \n" + "\tpage_size\x18\x01 \x01(\x05B\x03\xe0A\x01R\bpageSize\x12\"\n" + "\n" + @@ -2363,7 +2432,13 @@ const file_api_v1_memo_service_proto_rawDesc = "" + "\x05state\x18\x03 \x01(\x0e2\x13.memos.api.v1.StateB\x03\xe0A\x01R\x05state\x12\x1e\n" + "\border_by\x18\x04 \x01(\tB\x03\xe0A\x01R\aorderBy\x12\x1b\n" + "\x06filter\x18\x05 \x01(\tB\x03\xe0A\x01R\x06filter\x12&\n" + - "\fshow_deleted\x18\x06 \x01(\bB\x03\xe0A\x01R\vshowDeleted\"e\n" + + "\fshow_deleted\x18\x06 \x01(\bB\x03\xe0A\x01R\vshowDeleted\x12/\n" + + "\x05space\x18\a \x01(\tB\x17\xfaA\x14\n" + + "\x12memos.api.v1/SpaceH\x00R\x05space\x12 \n" + + "\n" + + "unassigned\x18\b \x01(\bH\x00R\n" + + "unassignedB\a\n" + + "\x05scope\"e\n" + "\x11ListMemosResponse\x12(\n" + "\x05memos\x18\x01 \x03(\v2\x12.memos.api.v1.MemoR\x05memos\x12&\n" + "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"?\n" + @@ -2483,14 +2558,15 @@ const file_api_v1_memo_service_proto_rawDesc = "" + "\x03url\x18\x01 \x01(\tR\x03url\x12\x14\n" + "\x05title\x18\x02 \x01(\tR\x05title\x12 \n" + "\vdescription\x18\x03 \x01(\tR\vdescription\x12\x14\n" + - "\x05image\x18\x04 \x01(\tR\x05image*P\n" + + "\x05image\x18\x04 \x01(\tR\x05image*[\n" + "\n" + "Visibility\x12\x1a\n" + "\x16VISIBILITY_UNSPECIFIED\x10\x00\x12\v\n" + "\aPRIVATE\x10\x01\x12\r\n" + "\tPROTECTED\x10\x02\x12\n" + "\n" + - "\x06PUBLIC\x10\x032\x91\x15\n" + + "\x06PUBLIC\x10\x03\x12\t\n" + + "\x05SPACE\x10\x042\x91\x15\n" + "\vMemoService\x12e\n" + "\n" + "CreateMemo\x12\x1f.memos.api.v1.CreateMemoRequest\x1a\x12.memos.api.v1.Memo\"\"\xdaA\x04memo\x82\xd3\xe4\x93\x02\x15:\x04memo\"\r/api/v1/memos\x12f\n" + @@ -2663,6 +2739,10 @@ func file_api_v1_memo_service_proto_init() { file_api_v1_attachment_service_proto_init() file_api_v1_common_proto_init() file_api_v1_memo_service_proto_msgTypes[1].OneofWrappers = []any{} + file_api_v1_memo_service_proto_msgTypes[4].OneofWrappers = []any{ + (*ListMemosRequest_Space)(nil), + (*ListMemosRequest_Unassigned)(nil), + } file_api_v1_memo_service_proto_msgTypes[23].OneofWrappers = []any{} type x struct{} out := protoimpl.TypeBuilder{ diff --git a/proto/gen/api/v1/memo_service_grpc.pb.go b/proto/gen/api/v1/memo_service_grpc.pb.go index e0029ef4..a6d5ed83 100644 --- a/proto/gen/api/v1/memo_service_grpc.pb.go +++ b/proto/gen/api/v1/memo_service_grpc.pb.go @@ -47,16 +47,18 @@ const ( // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. type MemoServiceClient interface { // CreateMemo creates a memo. The request body is a Memo; set its content - // (Markdown) and visibility (PRIVATE | PROTECTED | PUBLIC, default PRIVATE). + // (Markdown) and visibility (PRIVATE | PROTECTED | PUBLIC | SPACE, + // default PRIVATE). // The memo is owned by the authenticated user; requires authentication. CreateMemo(ctx context.Context, in *CreateMemoRequest, opts ...grpc.CallOption) (*Memo, error) - // ListMemos lists memos with pagination and filter. + // ListMemos lists readable non-comment memos with pagination and filter. ListMemos(ctx context.Context, in *ListMemosRequest, opts ...grpc.CallOption) (*ListMemosResponse, error) // GetMemo gets a memo. GetMemo(ctx context.Context, in *GetMemoRequest, opts ...grpc.CallOption) (*Memo, error) // UpdateMemo updates a memo. UpdateMemo(ctx context.Context, in *UpdateMemoRequest, opts ...grpc.CallOption) (*Memo, error) - // DeleteMemo deletes a memo. + // DeleteMemo deletes only the named memo and its owned resources. It removes + // incident relations but never deletes another memo. DeleteMemo(ctx context.Context, in *DeleteMemoRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) // SetMemoAttachments replaces the full set of attachments on a memo with the // provided list (not an append). Pass the complete desired set; an empty list @@ -64,13 +66,15 @@ type MemoServiceClient interface { SetMemoAttachments(ctx context.Context, in *SetMemoAttachmentsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) // ListMemoAttachments lists attachments for a memo. ListMemoAttachments(ctx context.Context, in *ListMemoAttachmentsRequest, opts ...grpc.CallOption) (*ListMemoAttachmentsResponse, error) - // SetMemoRelations replaces the full set of relations on a memo with the - // provided list (not an append). Pass the complete desired set; an empty list - // clears all relations. Idempotent. + // SetMemoRelations replaces the full set of mutable REFERENCE relations on a + // memo. COMMENT relations are immutable creation context and are rejected by + // this RPC. An empty list clears references without changing COMMENT. SetMemoRelations(ctx context.Context, in *SetMemoRelationsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) // ListMemoRelations lists relations for a memo. ListMemoRelations(ctx context.Context, in *ListMemoRelationsRequest, opts ...grpc.CallOption) (*ListMemoRelationsResponse, error) - // CreateMemoComment creates a comment for a memo. + // CreateMemoComment atomically creates an independent memo plus one immutable + // COMMENT context relation to the named memo. The new memo keeps its own + // placement, visibility, authorship, and lifecycle. CreateMemoComment(ctx context.Context, in *CreateMemoCommentRequest, opts ...grpc.CallOption) (*Memo, error) // ListMemoComments lists comments for a memo. ListMemoComments(ctx context.Context, in *ListMemoCommentsRequest, opts ...grpc.CallOption) (*ListMemoCommentsResponse, error) @@ -308,16 +312,18 @@ func (c *memoServiceClient) BatchGetLinkMetadata(ctx context.Context, in *BatchG // for forward compatibility. type MemoServiceServer interface { // CreateMemo creates a memo. The request body is a Memo; set its content - // (Markdown) and visibility (PRIVATE | PROTECTED | PUBLIC, default PRIVATE). + // (Markdown) and visibility (PRIVATE | PROTECTED | PUBLIC | SPACE, + // default PRIVATE). // The memo is owned by the authenticated user; requires authentication. CreateMemo(context.Context, *CreateMemoRequest) (*Memo, error) - // ListMemos lists memos with pagination and filter. + // ListMemos lists readable non-comment memos with pagination and filter. ListMemos(context.Context, *ListMemosRequest) (*ListMemosResponse, error) // GetMemo gets a memo. GetMemo(context.Context, *GetMemoRequest) (*Memo, error) // UpdateMemo updates a memo. UpdateMemo(context.Context, *UpdateMemoRequest) (*Memo, error) - // DeleteMemo deletes a memo. + // DeleteMemo deletes only the named memo and its owned resources. It removes + // incident relations but never deletes another memo. DeleteMemo(context.Context, *DeleteMemoRequest) (*emptypb.Empty, error) // SetMemoAttachments replaces the full set of attachments on a memo with the // provided list (not an append). Pass the complete desired set; an empty list @@ -325,13 +331,15 @@ type MemoServiceServer interface { SetMemoAttachments(context.Context, *SetMemoAttachmentsRequest) (*emptypb.Empty, error) // ListMemoAttachments lists attachments for a memo. ListMemoAttachments(context.Context, *ListMemoAttachmentsRequest) (*ListMemoAttachmentsResponse, error) - // SetMemoRelations replaces the full set of relations on a memo with the - // provided list (not an append). Pass the complete desired set; an empty list - // clears all relations. Idempotent. + // SetMemoRelations replaces the full set of mutable REFERENCE relations on a + // memo. COMMENT relations are immutable creation context and are rejected by + // this RPC. An empty list clears references without changing COMMENT. SetMemoRelations(context.Context, *SetMemoRelationsRequest) (*emptypb.Empty, error) // ListMemoRelations lists relations for a memo. ListMemoRelations(context.Context, *ListMemoRelationsRequest) (*ListMemoRelationsResponse, error) - // CreateMemoComment creates a comment for a memo. + // CreateMemoComment atomically creates an independent memo plus one immutable + // COMMENT context relation to the named memo. The new memo keeps its own + // placement, visibility, authorship, and lifecycle. CreateMemoComment(context.Context, *CreateMemoCommentRequest) (*Memo, error) // ListMemoComments lists comments for a memo. ListMemoComments(context.Context, *ListMemoCommentsRequest) (*ListMemoCommentsResponse, error) diff --git a/proto/gen/api/v1/memo_view_service.pb.go b/proto/gen/api/v1/memo_view_service.pb.go index 646f1b63..a1a4e21a 100644 --- a/proto/gen/api/v1/memo_view_service.pb.go +++ b/proto/gen/api/v1/memo_view_service.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.12 // protoc (unknown) // source: api/v1/memo_view_service.proto diff --git a/proto/gen/api/v1/space_service.pb.go b/proto/gen/api/v1/space_service.pb.go new file mode 100644 index 00000000..a025d99f --- /dev/null +++ b/proto/gen/api/v1/space_service.pb.go @@ -0,0 +1,990 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.12 +// protoc (unknown) +// source: api/v1/space_service.proto + +package apiv1 + +import ( + _ "google.golang.org/genproto/googleapis/api/annotations" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + emptypb "google.golang.org/protobuf/types/known/emptypb" + fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type SpaceMember_Role int32 + +const ( + SpaceMember_ROLE_UNSPECIFIED SpaceMember_Role = 0 + SpaceMember_ADMIN SpaceMember_Role = 1 + SpaceMember_USER SpaceMember_Role = 2 +) + +// Enum value maps for SpaceMember_Role. +var ( + SpaceMember_Role_name = map[int32]string{ + 0: "ROLE_UNSPECIFIED", + 1: "ADMIN", + 2: "USER", + } + SpaceMember_Role_value = map[string]int32{ + "ROLE_UNSPECIFIED": 0, + "ADMIN": 1, + "USER": 2, + } +) + +func (x SpaceMember_Role) Enum() *SpaceMember_Role { + p := new(SpaceMember_Role) + *p = x + return p +} + +func (x SpaceMember_Role) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (SpaceMember_Role) Descriptor() protoreflect.EnumDescriptor { + return file_api_v1_space_service_proto_enumTypes[0].Descriptor() +} + +func (SpaceMember_Role) Type() protoreflect.EnumType { + return &file_api_v1_space_service_proto_enumTypes[0] +} + +func (x SpaceMember_Role) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use SpaceMember_Role.Descriptor instead. +func (SpaceMember_Role) EnumDescriptor() ([]byte, []int) { + return file_api_v1_space_service_proto_rawDescGZIP(), []int{1, 0} +} + +// Space is a collaboration boundary for placed memos. +type Space struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The resource name of the space. Format: spaces/{space}. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Required. The human-readable title. + Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"` + // Optional. A description of the space. + Description string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Space) Reset() { + *x = Space{} + mi := &file_api_v1_space_service_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Space) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Space) ProtoMessage() {} + +func (x *Space) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_space_service_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Space.ProtoReflect.Descriptor instead. +func (*Space) Descriptor() ([]byte, []int) { + return file_api_v1_space_service_proto_rawDescGZIP(), []int{0} +} + +func (x *Space) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *Space) GetTitle() string { + if x != nil { + return x.Title + } + return "" +} + +func (x *Space) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +// SpaceMember is a user's membership and governance role in a space. +type SpaceMember struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The resource name. Format: spaces/{space}/members/{username}. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Required. The member user. Format: users/{username}. + User string `protobuf:"bytes,2,opt,name=user,proto3" json:"user,omitempty"` + // Required. The member's role within this space. + Role SpaceMember_Role `protobuf:"varint,3,opt,name=role,proto3,enum=memos.api.v1.SpaceMember_Role" json:"role,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *SpaceMember) Reset() { + *x = SpaceMember{} + mi := &file_api_v1_space_service_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *SpaceMember) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*SpaceMember) ProtoMessage() {} + +func (x *SpaceMember) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_space_service_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use SpaceMember.ProtoReflect.Descriptor instead. +func (*SpaceMember) Descriptor() ([]byte, []int) { + return file_api_v1_space_service_proto_rawDescGZIP(), []int{1} +} + +func (x *SpaceMember) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *SpaceMember) GetUser() string { + if x != nil { + return x.User + } + return "" +} + +func (x *SpaceMember) GetRole() SpaceMember_Role { + if x != nil { + return x.Role + } + return SpaceMember_ROLE_UNSPECIFIED +} + +type CreateSpaceRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. The space to create. + Space *Space `protobuf:"bytes,1,opt,name=space,proto3" json:"space,omitempty"` + // Optional. The resource ID to use. If empty, one is generated. + SpaceId string `protobuf:"bytes,2,opt,name=space_id,json=spaceId,proto3" json:"space_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CreateSpaceRequest) Reset() { + *x = CreateSpaceRequest{} + mi := &file_api_v1_space_service_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CreateSpaceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateSpaceRequest) ProtoMessage() {} + +func (x *CreateSpaceRequest) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_space_service_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateSpaceRequest.ProtoReflect.Descriptor instead. +func (*CreateSpaceRequest) Descriptor() ([]byte, []int) { + return file_api_v1_space_service_proto_rawDescGZIP(), []int{2} +} + +func (x *CreateSpaceRequest) GetSpace() *Space { + if x != nil { + return x.Space + } + return nil +} + +func (x *CreateSpaceRequest) GetSpaceId() string { + if x != nil { + return x.SpaceId + } + return "" +} + +type ListSpacesRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Optional. The maximum number of spaces to return. + PageSize int32 `protobuf:"varint,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"` + // Optional. A token from a previous ListSpaces response. + PageToken string `protobuf:"bytes,2,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListSpacesRequest) Reset() { + *x = ListSpacesRequest{} + mi := &file_api_v1_space_service_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListSpacesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListSpacesRequest) ProtoMessage() {} + +func (x *ListSpacesRequest) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_space_service_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListSpacesRequest.ProtoReflect.Descriptor instead. +func (*ListSpacesRequest) Descriptor() ([]byte, []int) { + return file_api_v1_space_service_proto_rawDescGZIP(), []int{3} +} + +func (x *ListSpacesRequest) GetPageSize() int32 { + if x != nil { + return x.PageSize + } + return 0 +} + +func (x *ListSpacesRequest) GetPageToken() string { + if x != nil { + return x.PageToken + } + return "" +} + +type ListSpacesResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Spaces []*Space `protobuf:"bytes,1,rep,name=spaces,proto3" json:"spaces,omitempty"` + NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListSpacesResponse) Reset() { + *x = ListSpacesResponse{} + mi := &file_api_v1_space_service_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListSpacesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListSpacesResponse) ProtoMessage() {} + +func (x *ListSpacesResponse) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_space_service_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListSpacesResponse.ProtoReflect.Descriptor instead. +func (*ListSpacesResponse) Descriptor() ([]byte, []int) { + return file_api_v1_space_service_proto_rawDescGZIP(), []int{4} +} + +func (x *ListSpacesResponse) GetSpaces() []*Space { + if x != nil { + return x.Spaces + } + return nil +} + +func (x *ListSpacesResponse) GetNextPageToken() string { + if x != nil { + return x.NextPageToken + } + return "" +} + +type GetSpaceRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. The resource name of the space. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetSpaceRequest) Reset() { + *x = GetSpaceRequest{} + mi := &file_api_v1_space_service_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetSpaceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSpaceRequest) ProtoMessage() {} + +func (x *GetSpaceRequest) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_space_service_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSpaceRequest.ProtoReflect.Descriptor instead. +func (*GetSpaceRequest) Descriptor() ([]byte, []int) { + return file_api_v1_space_service_proto_rawDescGZIP(), []int{5} +} + +func (x *GetSpaceRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type UpdateSpaceRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. The space with updated values. + Space *Space `protobuf:"bytes,1,opt,name=space,proto3" json:"space,omitempty"` + // Required. The fields to update: title or description. + UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UpdateSpaceRequest) Reset() { + *x = UpdateSpaceRequest{} + mi := &file_api_v1_space_service_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UpdateSpaceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateSpaceRequest) ProtoMessage() {} + +func (x *UpdateSpaceRequest) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_space_service_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateSpaceRequest.ProtoReflect.Descriptor instead. +func (*UpdateSpaceRequest) Descriptor() ([]byte, []int) { + return file_api_v1_space_service_proto_rawDescGZIP(), []int{6} +} + +func (x *UpdateSpaceRequest) GetSpace() *Space { + if x != nil { + return x.Space + } + return nil +} + +func (x *UpdateSpaceRequest) GetUpdateMask() *fieldmaskpb.FieldMask { + if x != nil { + return x.UpdateMask + } + return nil +} + +type DeleteSpaceRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. The resource name of the space. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DeleteSpaceRequest) Reset() { + *x = DeleteSpaceRequest{} + mi := &file_api_v1_space_service_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteSpaceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteSpaceRequest) ProtoMessage() {} + +func (x *DeleteSpaceRequest) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_space_service_proto_msgTypes[7] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteSpaceRequest.ProtoReflect.Descriptor instead. +func (*DeleteSpaceRequest) Descriptor() ([]byte, []int) { + return file_api_v1_space_service_proto_rawDescGZIP(), []int{7} +} + +func (x *DeleteSpaceRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type CreateSpaceMemberRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. The parent space. Format: spaces/{space}. + Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"` + // Required. The membership to create. + SpaceMember *SpaceMember `protobuf:"bytes,2,opt,name=space_member,json=spaceMember,proto3" json:"space_member,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *CreateSpaceMemberRequest) Reset() { + *x = CreateSpaceMemberRequest{} + mi := &file_api_v1_space_service_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *CreateSpaceMemberRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*CreateSpaceMemberRequest) ProtoMessage() {} + +func (x *CreateSpaceMemberRequest) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_space_service_proto_msgTypes[8] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use CreateSpaceMemberRequest.ProtoReflect.Descriptor instead. +func (*CreateSpaceMemberRequest) Descriptor() ([]byte, []int) { + return file_api_v1_space_service_proto_rawDescGZIP(), []int{8} +} + +func (x *CreateSpaceMemberRequest) GetParent() string { + if x != nil { + return x.Parent + } + return "" +} + +func (x *CreateSpaceMemberRequest) GetSpaceMember() *SpaceMember { + if x != nil { + return x.SpaceMember + } + return nil +} + +type ListSpaceMembersRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. The parent space. Format: spaces/{space}. + Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"` + // Optional. The maximum number of members to return. + PageSize int32 `protobuf:"varint,2,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"` + // Optional. A token from a previous ListSpaceMembers response. + PageToken string `protobuf:"bytes,3,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListSpaceMembersRequest) Reset() { + *x = ListSpaceMembersRequest{} + mi := &file_api_v1_space_service_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListSpaceMembersRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListSpaceMembersRequest) ProtoMessage() {} + +func (x *ListSpaceMembersRequest) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_space_service_proto_msgTypes[9] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListSpaceMembersRequest.ProtoReflect.Descriptor instead. +func (*ListSpaceMembersRequest) Descriptor() ([]byte, []int) { + return file_api_v1_space_service_proto_rawDescGZIP(), []int{9} +} + +func (x *ListSpaceMembersRequest) GetParent() string { + if x != nil { + return x.Parent + } + return "" +} + +func (x *ListSpaceMembersRequest) GetPageSize() int32 { + if x != nil { + return x.PageSize + } + return 0 +} + +func (x *ListSpaceMembersRequest) GetPageToken() string { + if x != nil { + return x.PageToken + } + return "" +} + +type ListSpaceMembersResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + SpaceMembers []*SpaceMember `protobuf:"bytes,1,rep,name=space_members,json=spaceMembers,proto3" json:"space_members,omitempty"` + NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListSpaceMembersResponse) Reset() { + *x = ListSpaceMembersResponse{} + mi := &file_api_v1_space_service_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListSpaceMembersResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListSpaceMembersResponse) ProtoMessage() {} + +func (x *ListSpaceMembersResponse) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_space_service_proto_msgTypes[10] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListSpaceMembersResponse.ProtoReflect.Descriptor instead. +func (*ListSpaceMembersResponse) Descriptor() ([]byte, []int) { + return file_api_v1_space_service_proto_rawDescGZIP(), []int{10} +} + +func (x *ListSpaceMembersResponse) GetSpaceMembers() []*SpaceMember { + if x != nil { + return x.SpaceMembers + } + return nil +} + +func (x *ListSpaceMembersResponse) GetNextPageToken() string { + if x != nil { + return x.NextPageToken + } + return "" +} + +type GetSpaceMemberRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. Format: spaces/{space}/members/{username}. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetSpaceMemberRequest) Reset() { + *x = GetSpaceMemberRequest{} + mi := &file_api_v1_space_service_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetSpaceMemberRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetSpaceMemberRequest) ProtoMessage() {} + +func (x *GetSpaceMemberRequest) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_space_service_proto_msgTypes[11] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetSpaceMemberRequest.ProtoReflect.Descriptor instead. +func (*GetSpaceMemberRequest) Descriptor() ([]byte, []int) { + return file_api_v1_space_service_proto_rawDescGZIP(), []int{11} +} + +func (x *GetSpaceMemberRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +type UpdateSpaceMemberRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. The membership with the new role. + SpaceMember *SpaceMember `protobuf:"bytes,1,opt,name=space_member,json=spaceMember,proto3" json:"space_member,omitempty"` + // Required. Only role is supported. + UpdateMask *fieldmaskpb.FieldMask `protobuf:"bytes,2,opt,name=update_mask,json=updateMask,proto3" json:"update_mask,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *UpdateSpaceMemberRequest) Reset() { + *x = UpdateSpaceMemberRequest{} + mi := &file_api_v1_space_service_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *UpdateSpaceMemberRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*UpdateSpaceMemberRequest) ProtoMessage() {} + +func (x *UpdateSpaceMemberRequest) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_space_service_proto_msgTypes[12] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use UpdateSpaceMemberRequest.ProtoReflect.Descriptor instead. +func (*UpdateSpaceMemberRequest) Descriptor() ([]byte, []int) { + return file_api_v1_space_service_proto_rawDescGZIP(), []int{12} +} + +func (x *UpdateSpaceMemberRequest) GetSpaceMember() *SpaceMember { + if x != nil { + return x.SpaceMember + } + return nil +} + +func (x *UpdateSpaceMemberRequest) GetUpdateMask() *fieldmaskpb.FieldMask { + if x != nil { + return x.UpdateMask + } + return nil +} + +type DeleteSpaceMemberRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Required. Format: spaces/{space}/members/{username}. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DeleteSpaceMemberRequest) Reset() { + *x = DeleteSpaceMemberRequest{} + mi := &file_api_v1_space_service_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteSpaceMemberRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteSpaceMemberRequest) ProtoMessage() {} + +func (x *DeleteSpaceMemberRequest) ProtoReflect() protoreflect.Message { + mi := &file_api_v1_space_service_proto_msgTypes[13] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use DeleteSpaceMemberRequest.ProtoReflect.Descriptor instead. +func (*DeleteSpaceMemberRequest) Descriptor() ([]byte, []int) { + return file_api_v1_space_service_proto_rawDescGZIP(), []int{13} +} + +func (x *DeleteSpaceMemberRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +var File_api_v1_space_service_proto protoreflect.FileDescriptor + +const file_api_v1_space_service_proto_rawDesc = "" + + "\n" + + "\x1aapi/v1/space_service.proto\x12\fmemos.api.v1\x1a\x1cgoogle/api/annotations.proto\x1a\x17google/api/client.proto\x1a\x1fgoogle/api/field_behavior.proto\x1a\x19google/api/resource.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a google/protobuf/field_mask.proto\"\xa0\x01\n" + + "\x05Space\x12\x17\n" + + "\x04name\x18\x01 \x01(\tB\x03\xe0A\bR\x04name\x12\x19\n" + + "\x05title\x18\x02 \x01(\tB\x03\xe0A\x02R\x05title\x12%\n" + + "\vdescription\x18\x03 \x01(\tB\x03\xe0A\x01R\vdescription:<\xeaA9\n" + + "\x12memos.api.v1/Space\x12\x0espaces/{space}\x1a\x04name*\x06spaces2\x05space\"\xa2\x02\n" + + "\vSpaceMember\x12\x17\n" + + "\x04name\x18\x01 \x01(\tB\x03\xe0A\bR\x04name\x12-\n" + + "\x04user\x18\x02 \x01(\tB\x19\xe0A\x02\xfaA\x13\n" + + "\x11memos.api.v1/UserR\x04user\x127\n" + + "\x04role\x18\x03 \x01(\x0e2\x1e.memos.api.v1.SpaceMember.RoleB\x03\xe0A\x02R\x04role\"1\n" + + "\x04Role\x12\x14\n" + + "\x10ROLE_UNSPECIFIED\x10\x00\x12\t\n" + + "\x05ADMIN\x10\x01\x12\b\n" + + "\x04USER\x10\x02:_\xeaA\\\n" + + "\x18memos.api.v1/SpaceMember\x12\x1fspaces/{space}/members/{member}\x1a\x04name*\fspaceMembers2\vspaceMember\"d\n" + + "\x12CreateSpaceRequest\x12.\n" + + "\x05space\x18\x01 \x01(\v2\x13.memos.api.v1.SpaceB\x03\xe0A\x02R\x05space\x12\x1e\n" + + "\bspace_id\x18\x02 \x01(\tB\x03\xe0A\x01R\aspaceId\"Y\n" + + "\x11ListSpacesRequest\x12 \n" + + "\tpage_size\x18\x01 \x01(\x05B\x03\xe0A\x01R\bpageSize\x12\"\n" + + "\n" + + "page_token\x18\x02 \x01(\tB\x03\xe0A\x01R\tpageToken\"i\n" + + "\x12ListSpacesResponse\x12+\n" + + "\x06spaces\x18\x01 \x03(\v2\x13.memos.api.v1.SpaceR\x06spaces\x12&\n" + + "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"A\n" + + "\x0fGetSpaceRequest\x12.\n" + + "\x04name\x18\x01 \x01(\tB\x1a\xe0A\x02\xfaA\x14\n" + + "\x12memos.api.v1/SpaceR\x04name\"\x86\x01\n" + + "\x12UpdateSpaceRequest\x12.\n" + + "\x05space\x18\x01 \x01(\v2\x13.memos.api.v1.SpaceB\x03\xe0A\x02R\x05space\x12@\n" + + "\vupdate_mask\x18\x02 \x01(\v2\x1a.google.protobuf.FieldMaskB\x03\xe0A\x02R\n" + + "updateMask\"D\n" + + "\x12DeleteSpaceRequest\x12.\n" + + "\x04name\x18\x01 \x01(\tB\x1a\xe0A\x02\xfaA\x14\n" + + "\x12memos.api.v1/SpaceR\x04name\"\x97\x01\n" + + "\x18CreateSpaceMemberRequest\x128\n" + + "\x06parent\x18\x01 \x01(\tB \xe0A\x02\xfaA\x1a\x12\x18memos.api.v1/SpaceMemberR\x06parent\x12A\n" + + "\fspace_member\x18\x02 \x01(\v2\x19.memos.api.v1.SpaceMemberB\x03\xe0A\x02R\vspaceMember\"\x99\x01\n" + + "\x17ListSpaceMembersRequest\x128\n" + + "\x06parent\x18\x01 \x01(\tB \xe0A\x02\xfaA\x1a\x12\x18memos.api.v1/SpaceMemberR\x06parent\x12 \n" + + "\tpage_size\x18\x02 \x01(\x05B\x03\xe0A\x01R\bpageSize\x12\"\n" + + "\n" + + "page_token\x18\x03 \x01(\tB\x03\xe0A\x01R\tpageToken\"\x82\x01\n" + + "\x18ListSpaceMembersResponse\x12>\n" + + "\rspace_members\x18\x01 \x03(\v2\x19.memos.api.v1.SpaceMemberR\fspaceMembers\x12&\n" + + "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"M\n" + + "\x15GetSpaceMemberRequest\x124\n" + + "\x04name\x18\x01 \x01(\tB \xe0A\x02\xfaA\x1a\n" + + "\x18memos.api.v1/SpaceMemberR\x04name\"\x9f\x01\n" + + "\x18UpdateSpaceMemberRequest\x12A\n" + + "\fspace_member\x18\x01 \x01(\v2\x19.memos.api.v1.SpaceMemberB\x03\xe0A\x02R\vspaceMember\x12@\n" + + "\vupdate_mask\x18\x02 \x01(\v2\x1a.google.protobuf.FieldMaskB\x03\xe0A\x02R\n" + + "updateMask\"P\n" + + "\x18DeleteSpaceMemberRequest\x124\n" + + "\x04name\x18\x01 \x01(\tB \xe0A\x02\xfaA\x1a\n" + + "\x18memos.api.v1/SpaceMemberR\x04name2\xd0\n" + + "\n" + + "\fSpaceService\x12k\n" + + "\vCreateSpace\x12 .memos.api.v1.CreateSpaceRequest\x1a\x13.memos.api.v1.Space\"%\xdaA\x05space\x82\xd3\xe4\x93\x02\x17:\x05space\"\x0e/api/v1/spaces\x12j\n" + + "\n" + + "ListSpaces\x12\x1f.memos.api.v1.ListSpacesRequest\x1a .memos.api.v1.ListSpacesResponse\"\x19\xdaA\x00\x82\xd3\xe4\x93\x02\x10\x12\x0e/api/v1/spaces\x12f\n" + + "\bGetSpace\x12\x1d.memos.api.v1.GetSpaceRequest\x1a\x13.memos.api.v1.Space\"&\xdaA\x04name\x82\xd3\xe4\x93\x02\x19\x12\x17/api/v1/{name=spaces/*}\x12\x86\x01\n" + + "\vUpdateSpace\x12 .memos.api.v1.UpdateSpaceRequest\x1a\x13.memos.api.v1.Space\"@\xdaA\x11space,update_mask\x82\xd3\xe4\x93\x02&:\x05space2\x1d/api/v1/{space.name=spaces/*}\x12o\n" + + "\vDeleteSpace\x12 .memos.api.v1.DeleteSpaceRequest\x1a\x16.google.protobuf.Empty\"&\xdaA\x04name\x82\xd3\xe4\x93\x02\x19*\x17/api/v1/{name=spaces/*}\x12\xa5\x01\n" + + "\x11CreateSpaceMember\x12&.memos.api.v1.CreateSpaceMemberRequest\x1a\x19.memos.api.v1.SpaceMember\"M\xdaA\x13parent,space_member\x82\xd3\xe4\x93\x021:\fspace_member\"!/api/v1/{parent=spaces/*}/members\x12\x95\x01\n" + + "\x10ListSpaceMembers\x12%.memos.api.v1.ListSpaceMembersRequest\x1a&.memos.api.v1.ListSpaceMembersResponse\"2\xdaA\x06parent\x82\xd3\xe4\x93\x02#\x12!/api/v1/{parent=spaces/*}/members\x12\x82\x01\n" + + "\x0eGetSpaceMember\x12#.memos.api.v1.GetSpaceMemberRequest\x1a\x19.memos.api.v1.SpaceMember\"0\xdaA\x04name\x82\xd3\xe4\x93\x02#\x12!/api/v1/{name=spaces/*/members/*}\x12\xb7\x01\n" + + "\x11UpdateSpaceMember\x12&.memos.api.v1.UpdateSpaceMemberRequest\x1a\x19.memos.api.v1.SpaceMember\"_\xdaA\x18space_member,update_mask\x82\xd3\xe4\x93\x02>:\fspace_member2./api/v1/{space_member.name=spaces/*/members/*}\x12\x85\x01\n" + + "\x11DeleteSpaceMember\x12&.memos.api.v1.DeleteSpaceMemberRequest\x1a\x16.google.protobuf.Empty\"0\xdaA\x04name\x82\xd3\xe4\x93\x02#*!/api/v1/{name=spaces/*/members/*}B\xa9\x01\n" + + "\x10com.memos.api.v1B\x11SpaceServiceProtoP\x01Z0github.com/usememos/memos/proto/gen/api/v1;apiv1\xa2\x02\x03MAX\xaa\x02\fMemos.Api.V1\xca\x02\fMemos\\Api\\V1\xe2\x02\x18Memos\\Api\\V1\\GPBMetadata\xea\x02\x0eMemos::Api::V1b\x06proto3" + +var ( + file_api_v1_space_service_proto_rawDescOnce sync.Once + file_api_v1_space_service_proto_rawDescData []byte +) + +func file_api_v1_space_service_proto_rawDescGZIP() []byte { + file_api_v1_space_service_proto_rawDescOnce.Do(func() { + file_api_v1_space_service_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_api_v1_space_service_proto_rawDesc), len(file_api_v1_space_service_proto_rawDesc))) + }) + return file_api_v1_space_service_proto_rawDescData +} + +var file_api_v1_space_service_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_api_v1_space_service_proto_msgTypes = make([]protoimpl.MessageInfo, 14) +var file_api_v1_space_service_proto_goTypes = []any{ + (SpaceMember_Role)(0), // 0: memos.api.v1.SpaceMember.Role + (*Space)(nil), // 1: memos.api.v1.Space + (*SpaceMember)(nil), // 2: memos.api.v1.SpaceMember + (*CreateSpaceRequest)(nil), // 3: memos.api.v1.CreateSpaceRequest + (*ListSpacesRequest)(nil), // 4: memos.api.v1.ListSpacesRequest + (*ListSpacesResponse)(nil), // 5: memos.api.v1.ListSpacesResponse + (*GetSpaceRequest)(nil), // 6: memos.api.v1.GetSpaceRequest + (*UpdateSpaceRequest)(nil), // 7: memos.api.v1.UpdateSpaceRequest + (*DeleteSpaceRequest)(nil), // 8: memos.api.v1.DeleteSpaceRequest + (*CreateSpaceMemberRequest)(nil), // 9: memos.api.v1.CreateSpaceMemberRequest + (*ListSpaceMembersRequest)(nil), // 10: memos.api.v1.ListSpaceMembersRequest + (*ListSpaceMembersResponse)(nil), // 11: memos.api.v1.ListSpaceMembersResponse + (*GetSpaceMemberRequest)(nil), // 12: memos.api.v1.GetSpaceMemberRequest + (*UpdateSpaceMemberRequest)(nil), // 13: memos.api.v1.UpdateSpaceMemberRequest + (*DeleteSpaceMemberRequest)(nil), // 14: memos.api.v1.DeleteSpaceMemberRequest + (*fieldmaskpb.FieldMask)(nil), // 15: google.protobuf.FieldMask + (*emptypb.Empty)(nil), // 16: google.protobuf.Empty +} +var file_api_v1_space_service_proto_depIdxs = []int32{ + 0, // 0: memos.api.v1.SpaceMember.role:type_name -> memos.api.v1.SpaceMember.Role + 1, // 1: memos.api.v1.CreateSpaceRequest.space:type_name -> memos.api.v1.Space + 1, // 2: memos.api.v1.ListSpacesResponse.spaces:type_name -> memos.api.v1.Space + 1, // 3: memos.api.v1.UpdateSpaceRequest.space:type_name -> memos.api.v1.Space + 15, // 4: memos.api.v1.UpdateSpaceRequest.update_mask:type_name -> google.protobuf.FieldMask + 2, // 5: memos.api.v1.CreateSpaceMemberRequest.space_member:type_name -> memos.api.v1.SpaceMember + 2, // 6: memos.api.v1.ListSpaceMembersResponse.space_members:type_name -> memos.api.v1.SpaceMember + 2, // 7: memos.api.v1.UpdateSpaceMemberRequest.space_member:type_name -> memos.api.v1.SpaceMember + 15, // 8: memos.api.v1.UpdateSpaceMemberRequest.update_mask:type_name -> google.protobuf.FieldMask + 3, // 9: memos.api.v1.SpaceService.CreateSpace:input_type -> memos.api.v1.CreateSpaceRequest + 4, // 10: memos.api.v1.SpaceService.ListSpaces:input_type -> memos.api.v1.ListSpacesRequest + 6, // 11: memos.api.v1.SpaceService.GetSpace:input_type -> memos.api.v1.GetSpaceRequest + 7, // 12: memos.api.v1.SpaceService.UpdateSpace:input_type -> memos.api.v1.UpdateSpaceRequest + 8, // 13: memos.api.v1.SpaceService.DeleteSpace:input_type -> memos.api.v1.DeleteSpaceRequest + 9, // 14: memos.api.v1.SpaceService.CreateSpaceMember:input_type -> memos.api.v1.CreateSpaceMemberRequest + 10, // 15: memos.api.v1.SpaceService.ListSpaceMembers:input_type -> memos.api.v1.ListSpaceMembersRequest + 12, // 16: memos.api.v1.SpaceService.GetSpaceMember:input_type -> memos.api.v1.GetSpaceMemberRequest + 13, // 17: memos.api.v1.SpaceService.UpdateSpaceMember:input_type -> memos.api.v1.UpdateSpaceMemberRequest + 14, // 18: memos.api.v1.SpaceService.DeleteSpaceMember:input_type -> memos.api.v1.DeleteSpaceMemberRequest + 1, // 19: memos.api.v1.SpaceService.CreateSpace:output_type -> memos.api.v1.Space + 5, // 20: memos.api.v1.SpaceService.ListSpaces:output_type -> memos.api.v1.ListSpacesResponse + 1, // 21: memos.api.v1.SpaceService.GetSpace:output_type -> memos.api.v1.Space + 1, // 22: memos.api.v1.SpaceService.UpdateSpace:output_type -> memos.api.v1.Space + 16, // 23: memos.api.v1.SpaceService.DeleteSpace:output_type -> google.protobuf.Empty + 2, // 24: memos.api.v1.SpaceService.CreateSpaceMember:output_type -> memos.api.v1.SpaceMember + 11, // 25: memos.api.v1.SpaceService.ListSpaceMembers:output_type -> memos.api.v1.ListSpaceMembersResponse + 2, // 26: memos.api.v1.SpaceService.GetSpaceMember:output_type -> memos.api.v1.SpaceMember + 2, // 27: memos.api.v1.SpaceService.UpdateSpaceMember:output_type -> memos.api.v1.SpaceMember + 16, // 28: memos.api.v1.SpaceService.DeleteSpaceMember:output_type -> google.protobuf.Empty + 19, // [19:29] is the sub-list for method output_type + 9, // [9:19] is the sub-list for method input_type + 9, // [9:9] is the sub-list for extension type_name + 9, // [9:9] is the sub-list for extension extendee + 0, // [0:9] is the sub-list for field type_name +} + +func init() { file_api_v1_space_service_proto_init() } +func file_api_v1_space_service_proto_init() { + if File_api_v1_space_service_proto != nil { + return + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_api_v1_space_service_proto_rawDesc), len(file_api_v1_space_service_proto_rawDesc)), + NumEnums: 1, + NumMessages: 14, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_api_v1_space_service_proto_goTypes, + DependencyIndexes: file_api_v1_space_service_proto_depIdxs, + EnumInfos: file_api_v1_space_service_proto_enumTypes, + MessageInfos: file_api_v1_space_service_proto_msgTypes, + }.Build() + File_api_v1_space_service_proto = out.File + file_api_v1_space_service_proto_goTypes = nil + file_api_v1_space_service_proto_depIdxs = nil +} diff --git a/proto/gen/api/v1/space_service.pb.gw.go b/proto/gen/api/v1/space_service.pb.gw.go new file mode 100644 index 00000000..29338c8d --- /dev/null +++ b/proto/gen/api/v1/space_service.pb.gw.go @@ -0,0 +1,973 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: api/v1/space_service.proto + +/* +Package apiv1 is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package apiv1 + +import ( + "context" + "errors" + "io" + "net/http" + + "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" + "github.com/grpc-ecosystem/grpc-gateway/v2/utilities" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/metadata" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/proto" +) + +// Suppress "imported and not used" errors +var ( + _ codes.Code + _ io.Reader + _ status.Status + _ = errors.New + _ = runtime.String + _ = utilities.NewDoubleArray + _ = metadata.Join +) + +var filter_SpaceService_CreateSpace_0 = &utilities.DoubleArray{Encoding: map[string]int{"space": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} + +func request_SpaceService_CreateSpace_0(ctx context.Context, marshaler runtime.Marshaler, client SpaceServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq CreateSpaceRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Space); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SpaceService_CreateSpace_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if req.Body != nil { + _, _ = io.Copy(io.Discard, req.Body) + } + msg, err := client.CreateSpace(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_SpaceService_CreateSpace_0(ctx context.Context, marshaler runtime.Marshaler, server SpaceServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq CreateSpaceRequest + metadata runtime.ServerMetadata + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Space); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SpaceService_CreateSpace_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + msg, err := server.CreateSpace(ctx, &protoReq) + return msg, metadata, err +} + +var filter_SpaceService_ListSpaces_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} + +func request_SpaceService_ListSpaces_0(ctx context.Context, marshaler runtime.Marshaler, client SpaceServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq ListSpacesRequest + metadata runtime.ServerMetadata + ) + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SpaceService_ListSpaces_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if req.Body != nil { + _, _ = io.Copy(io.Discard, req.Body) + } + msg, err := client.ListSpaces(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_SpaceService_ListSpaces_0(ctx context.Context, marshaler runtime.Marshaler, server SpaceServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq ListSpacesRequest + metadata runtime.ServerMetadata + ) + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SpaceService_ListSpaces_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + msg, err := server.ListSpaces(ctx, &protoReq) + return msg, metadata, err +} + +func request_SpaceService_GetSpace_0(ctx context.Context, marshaler runtime.Marshaler, client SpaceServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq GetSpaceRequest + metadata runtime.ServerMetadata + err error + ) + val, ok := pathParams["name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") + } + protoReq.Name, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) + } + if req.Body != nil { + _, _ = io.Copy(io.Discard, req.Body) + } + msg, err := client.GetSpace(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_SpaceService_GetSpace_0(ctx context.Context, marshaler runtime.Marshaler, server SpaceServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq GetSpaceRequest + metadata runtime.ServerMetadata + err error + ) + val, ok := pathParams["name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") + } + protoReq.Name, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) + } + msg, err := server.GetSpace(ctx, &protoReq) + return msg, metadata, err +} + +var filter_SpaceService_UpdateSpace_0 = &utilities.DoubleArray{Encoding: map[string]int{"space": 0, "name": 1}, Base: []int{1, 2, 1, 0, 0}, Check: []int{0, 1, 2, 3, 2}} + +func request_SpaceService_UpdateSpace_0(ctx context.Context, marshaler runtime.Marshaler, client SpaceServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq UpdateSpaceRequest + metadata runtime.ServerMetadata + err error + ) + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Space); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if protoReq.UpdateMask == nil || len(protoReq.UpdateMask.GetPaths()) == 0 { + if fieldMask, err := runtime.FieldMaskFromRequestBody(newReader(), protoReq.Space); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } else { + protoReq.UpdateMask = fieldMask + } + } + val, ok := pathParams["space.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "space.name") + } + err = runtime.PopulateFieldFromPath(&protoReq, "space.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "space.name", err) + } + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SpaceService_UpdateSpace_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if req.Body != nil { + _, _ = io.Copy(io.Discard, req.Body) + } + msg, err := client.UpdateSpace(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_SpaceService_UpdateSpace_0(ctx context.Context, marshaler runtime.Marshaler, server SpaceServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq UpdateSpaceRequest + metadata runtime.ServerMetadata + err error + ) + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.Space); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if protoReq.UpdateMask == nil || len(protoReq.UpdateMask.GetPaths()) == 0 { + if fieldMask, err := runtime.FieldMaskFromRequestBody(newReader(), protoReq.Space); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } else { + protoReq.UpdateMask = fieldMask + } + } + val, ok := pathParams["space.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "space.name") + } + err = runtime.PopulateFieldFromPath(&protoReq, "space.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "space.name", err) + } + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SpaceService_UpdateSpace_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + msg, err := server.UpdateSpace(ctx, &protoReq) + return msg, metadata, err +} + +func request_SpaceService_DeleteSpace_0(ctx context.Context, marshaler runtime.Marshaler, client SpaceServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq DeleteSpaceRequest + metadata runtime.ServerMetadata + err error + ) + val, ok := pathParams["name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") + } + protoReq.Name, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) + } + if req.Body != nil { + _, _ = io.Copy(io.Discard, req.Body) + } + msg, err := client.DeleteSpace(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_SpaceService_DeleteSpace_0(ctx context.Context, marshaler runtime.Marshaler, server SpaceServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq DeleteSpaceRequest + metadata runtime.ServerMetadata + err error + ) + val, ok := pathParams["name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") + } + protoReq.Name, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) + } + msg, err := server.DeleteSpace(ctx, &protoReq) + return msg, metadata, err +} + +func request_SpaceService_CreateSpaceMember_0(ctx context.Context, marshaler runtime.Marshaler, client SpaceServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq CreateSpaceMemberRequest + metadata runtime.ServerMetadata + err error + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.SpaceMember); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["parent"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "parent") + } + protoReq.Parent, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "parent", err) + } + if req.Body != nil { + _, _ = io.Copy(io.Discard, req.Body) + } + msg, err := client.CreateSpaceMember(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_SpaceService_CreateSpaceMember_0(ctx context.Context, marshaler runtime.Marshaler, server SpaceServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq CreateSpaceMemberRequest + metadata runtime.ServerMetadata + err error + ) + if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.SpaceMember); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + val, ok := pathParams["parent"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "parent") + } + protoReq.Parent, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "parent", err) + } + msg, err := server.CreateSpaceMember(ctx, &protoReq) + return msg, metadata, err +} + +var filter_SpaceService_ListSpaceMembers_0 = &utilities.DoubleArray{Encoding: map[string]int{"parent": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} + +func request_SpaceService_ListSpaceMembers_0(ctx context.Context, marshaler runtime.Marshaler, client SpaceServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq ListSpaceMembersRequest + metadata runtime.ServerMetadata + err error + ) + val, ok := pathParams["parent"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "parent") + } + protoReq.Parent, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "parent", err) + } + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SpaceService_ListSpaceMembers_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if req.Body != nil { + _, _ = io.Copy(io.Discard, req.Body) + } + msg, err := client.ListSpaceMembers(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_SpaceService_ListSpaceMembers_0(ctx context.Context, marshaler runtime.Marshaler, server SpaceServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq ListSpaceMembersRequest + metadata runtime.ServerMetadata + err error + ) + val, ok := pathParams["parent"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "parent") + } + protoReq.Parent, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "parent", err) + } + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SpaceService_ListSpaceMembers_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + msg, err := server.ListSpaceMembers(ctx, &protoReq) + return msg, metadata, err +} + +func request_SpaceService_GetSpaceMember_0(ctx context.Context, marshaler runtime.Marshaler, client SpaceServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq GetSpaceMemberRequest + metadata runtime.ServerMetadata + err error + ) + val, ok := pathParams["name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") + } + protoReq.Name, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) + } + if req.Body != nil { + _, _ = io.Copy(io.Discard, req.Body) + } + msg, err := client.GetSpaceMember(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_SpaceService_GetSpaceMember_0(ctx context.Context, marshaler runtime.Marshaler, server SpaceServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq GetSpaceMemberRequest + metadata runtime.ServerMetadata + err error + ) + val, ok := pathParams["name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") + } + protoReq.Name, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) + } + msg, err := server.GetSpaceMember(ctx, &protoReq) + return msg, metadata, err +} + +var filter_SpaceService_UpdateSpaceMember_0 = &utilities.DoubleArray{Encoding: map[string]int{"space_member": 0, "name": 1}, Base: []int{1, 2, 1, 0, 0}, Check: []int{0, 1, 2, 3, 2}} + +func request_SpaceService_UpdateSpaceMember_0(ctx context.Context, marshaler runtime.Marshaler, client SpaceServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq UpdateSpaceMemberRequest + metadata runtime.ServerMetadata + err error + ) + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.SpaceMember); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if protoReq.UpdateMask == nil || len(protoReq.UpdateMask.GetPaths()) == 0 { + if fieldMask, err := runtime.FieldMaskFromRequestBody(newReader(), protoReq.SpaceMember); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } else { + protoReq.UpdateMask = fieldMask + } + } + val, ok := pathParams["space_member.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "space_member.name") + } + err = runtime.PopulateFieldFromPath(&protoReq, "space_member.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "space_member.name", err) + } + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SpaceService_UpdateSpaceMember_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if req.Body != nil { + _, _ = io.Copy(io.Discard, req.Body) + } + msg, err := client.UpdateSpaceMember(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_SpaceService_UpdateSpaceMember_0(ctx context.Context, marshaler runtime.Marshaler, server SpaceServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq UpdateSpaceMemberRequest + metadata runtime.ServerMetadata + err error + ) + newReader, berr := utilities.IOReaderFactory(req.Body) + if berr != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr) + } + if err := marshaler.NewDecoder(newReader()).Decode(&protoReq.SpaceMember); err != nil && !errors.Is(err, io.EOF) { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if protoReq.UpdateMask == nil || len(protoReq.UpdateMask.GetPaths()) == 0 { + if fieldMask, err := runtime.FieldMaskFromRequestBody(newReader(), protoReq.SpaceMember); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } else { + protoReq.UpdateMask = fieldMask + } + } + val, ok := pathParams["space_member.name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "space_member.name") + } + err = runtime.PopulateFieldFromPath(&protoReq, "space_member.name", val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "space_member.name", err) + } + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_SpaceService_UpdateSpaceMember_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + msg, err := server.UpdateSpaceMember(ctx, &protoReq) + return msg, metadata, err +} + +func request_SpaceService_DeleteSpaceMember_0(ctx context.Context, marshaler runtime.Marshaler, client SpaceServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq DeleteSpaceMemberRequest + metadata runtime.ServerMetadata + err error + ) + val, ok := pathParams["name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") + } + protoReq.Name, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) + } + if req.Body != nil { + _, _ = io.Copy(io.Discard, req.Body) + } + msg, err := client.DeleteSpaceMember(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err +} + +func local_request_SpaceService_DeleteSpaceMember_0(ctx context.Context, marshaler runtime.Marshaler, server SpaceServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var ( + protoReq DeleteSpaceMemberRequest + metadata runtime.ServerMetadata + err error + ) + val, ok := pathParams["name"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "name") + } + protoReq.Name, err = runtime.String(val) + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err) + } + msg, err := server.DeleteSpaceMember(ctx, &protoReq) + return msg, metadata, err +} + +// RegisterSpaceServiceHandlerServer registers the http handlers for service SpaceService to "mux". +// UnaryRPC :call SpaceServiceServer directly. +// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. +// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterSpaceServiceHandlerFromEndpoint instead. +// GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call. +func RegisterSpaceServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server SpaceServiceServer) error { + mux.Handle(http.MethodPost, pattern_SpaceService_CreateSpace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/memos.api.v1.SpaceService/CreateSpace", runtime.WithHTTPPathPattern("/api/v1/spaces")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SpaceService_CreateSpace_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_CreateSpace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodGet, pattern_SpaceService_ListSpaces_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/memos.api.v1.SpaceService/ListSpaces", runtime.WithHTTPPathPattern("/api/v1/spaces")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SpaceService_ListSpaces_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_ListSpaces_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodGet, pattern_SpaceService_GetSpace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/memos.api.v1.SpaceService/GetSpace", runtime.WithHTTPPathPattern("/api/v1/{name=spaces/*}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SpaceService_GetSpace_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_GetSpace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodPatch, pattern_SpaceService_UpdateSpace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/memos.api.v1.SpaceService/UpdateSpace", runtime.WithHTTPPathPattern("/api/v1/{space.name=spaces/*}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SpaceService_UpdateSpace_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_UpdateSpace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodDelete, pattern_SpaceService_DeleteSpace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/memos.api.v1.SpaceService/DeleteSpace", runtime.WithHTTPPathPattern("/api/v1/{name=spaces/*}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SpaceService_DeleteSpace_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_DeleteSpace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodPost, pattern_SpaceService_CreateSpaceMember_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/memos.api.v1.SpaceService/CreateSpaceMember", runtime.WithHTTPPathPattern("/api/v1/{parent=spaces/*}/members")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SpaceService_CreateSpaceMember_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_CreateSpaceMember_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodGet, pattern_SpaceService_ListSpaceMembers_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/memos.api.v1.SpaceService/ListSpaceMembers", runtime.WithHTTPPathPattern("/api/v1/{parent=spaces/*}/members")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SpaceService_ListSpaceMembers_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_ListSpaceMembers_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodGet, pattern_SpaceService_GetSpaceMember_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/memos.api.v1.SpaceService/GetSpaceMember", runtime.WithHTTPPathPattern("/api/v1/{name=spaces/*/members/*}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SpaceService_GetSpaceMember_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_GetSpaceMember_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodPatch, pattern_SpaceService_UpdateSpaceMember_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/memos.api.v1.SpaceService/UpdateSpaceMember", runtime.WithHTTPPathPattern("/api/v1/{space_member.name=spaces/*/members/*}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SpaceService_UpdateSpaceMember_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_UpdateSpaceMember_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodDelete, pattern_SpaceService_DeleteSpaceMember_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/memos.api.v1.SpaceService/DeleteSpaceMember", runtime.WithHTTPPathPattern("/api/v1/{name=spaces/*/members/*}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_SpaceService_DeleteSpaceMember_0(annotatedContext, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_DeleteSpaceMember_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + + return nil +} + +// RegisterSpaceServiceHandlerFromEndpoint is same as RegisterSpaceServiceHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterSpaceServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.NewClient(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + return RegisterSpaceServiceHandler(ctx, mux, conn) +} + +// RegisterSpaceServiceHandler registers the http handlers for service SpaceService to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterSpaceServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterSpaceServiceHandlerClient(ctx, mux, NewSpaceServiceClient(conn)) +} + +// RegisterSpaceServiceHandlerClient registers the http handlers for service SpaceService +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "SpaceServiceClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "SpaceServiceClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "SpaceServiceClient" to call the correct interceptors. This client ignores the HTTP middlewares. +func RegisterSpaceServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client SpaceServiceClient) error { + mux.Handle(http.MethodPost, pattern_SpaceService_CreateSpace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/memos.api.v1.SpaceService/CreateSpace", runtime.WithHTTPPathPattern("/api/v1/spaces")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SpaceService_CreateSpace_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_CreateSpace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodGet, pattern_SpaceService_ListSpaces_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/memos.api.v1.SpaceService/ListSpaces", runtime.WithHTTPPathPattern("/api/v1/spaces")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SpaceService_ListSpaces_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_ListSpaces_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodGet, pattern_SpaceService_GetSpace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/memos.api.v1.SpaceService/GetSpace", runtime.WithHTTPPathPattern("/api/v1/{name=spaces/*}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SpaceService_GetSpace_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_GetSpace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodPatch, pattern_SpaceService_UpdateSpace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/memos.api.v1.SpaceService/UpdateSpace", runtime.WithHTTPPathPattern("/api/v1/{space.name=spaces/*}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SpaceService_UpdateSpace_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_UpdateSpace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodDelete, pattern_SpaceService_DeleteSpace_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/memos.api.v1.SpaceService/DeleteSpace", runtime.WithHTTPPathPattern("/api/v1/{name=spaces/*}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SpaceService_DeleteSpace_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_DeleteSpace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodPost, pattern_SpaceService_CreateSpaceMember_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/memos.api.v1.SpaceService/CreateSpaceMember", runtime.WithHTTPPathPattern("/api/v1/{parent=spaces/*}/members")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SpaceService_CreateSpaceMember_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_CreateSpaceMember_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodGet, pattern_SpaceService_ListSpaceMembers_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/memos.api.v1.SpaceService/ListSpaceMembers", runtime.WithHTTPPathPattern("/api/v1/{parent=spaces/*}/members")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SpaceService_ListSpaceMembers_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_ListSpaceMembers_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodGet, pattern_SpaceService_GetSpaceMember_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/memos.api.v1.SpaceService/GetSpaceMember", runtime.WithHTTPPathPattern("/api/v1/{name=spaces/*/members/*}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SpaceService_GetSpaceMember_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_GetSpaceMember_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodPatch, pattern_SpaceService_UpdateSpaceMember_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/memos.api.v1.SpaceService/UpdateSpaceMember", runtime.WithHTTPPathPattern("/api/v1/{space_member.name=spaces/*/members/*}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SpaceService_UpdateSpaceMember_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_UpdateSpaceMember_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + mux.Handle(http.MethodDelete, pattern_SpaceService_DeleteSpaceMember_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/memos.api.v1.SpaceService/DeleteSpaceMember", runtime.WithHTTPPathPattern("/api/v1/{name=spaces/*/members/*}")) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_SpaceService_DeleteSpaceMember_0(annotatedContext, inboundMarshaler, client, req, pathParams) + annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md) + if err != nil { + runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err) + return + } + forward_SpaceService_DeleteSpaceMember_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + }) + return nil +} + +var ( + pattern_SpaceService_CreateSpace_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "v1", "spaces"}, "")) + pattern_SpaceService_ListSpaces_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "v1", "spaces"}, "")) + pattern_SpaceService_GetSpace_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 2, 5, 3}, []string{"api", "v1", "spaces", "name"}, "")) + pattern_SpaceService_UpdateSpace_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 2, 5, 3}, []string{"api", "v1", "spaces", "space.name"}, "")) + pattern_SpaceService_DeleteSpace_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 2, 5, 3}, []string{"api", "v1", "spaces", "name"}, "")) + pattern_SpaceService_CreateSpaceMember_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 2, 5, 3, 2, 4}, []string{"api", "v1", "spaces", "parent", "members"}, "")) + pattern_SpaceService_ListSpaceMembers_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 2, 5, 3, 2, 4}, []string{"api", "v1", "spaces", "parent", "members"}, "")) + pattern_SpaceService_GetSpaceMember_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 2, 3, 1, 0, 4, 4, 5, 4}, []string{"api", "v1", "spaces", "members", "name"}, "")) + pattern_SpaceService_UpdateSpaceMember_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 2, 3, 1, 0, 4, 4, 5, 4}, []string{"api", "v1", "spaces", "members", "space_member.name"}, "")) + pattern_SpaceService_DeleteSpaceMember_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 2, 3, 1, 0, 4, 4, 5, 4}, []string{"api", "v1", "spaces", "members", "name"}, "")) +) + +var ( + forward_SpaceService_CreateSpace_0 = runtime.ForwardResponseMessage + forward_SpaceService_ListSpaces_0 = runtime.ForwardResponseMessage + forward_SpaceService_GetSpace_0 = runtime.ForwardResponseMessage + forward_SpaceService_UpdateSpace_0 = runtime.ForwardResponseMessage + forward_SpaceService_DeleteSpace_0 = runtime.ForwardResponseMessage + forward_SpaceService_CreateSpaceMember_0 = runtime.ForwardResponseMessage + forward_SpaceService_ListSpaceMembers_0 = runtime.ForwardResponseMessage + forward_SpaceService_GetSpaceMember_0 = runtime.ForwardResponseMessage + forward_SpaceService_UpdateSpaceMember_0 = runtime.ForwardResponseMessage + forward_SpaceService_DeleteSpaceMember_0 = runtime.ForwardResponseMessage +) diff --git a/proto/gen/api/v1/space_service_grpc.pb.go b/proto/gen/api/v1/space_service_grpc.pb.go new file mode 100644 index 00000000..e084f184 --- /dev/null +++ b/proto/gen/api/v1/space_service_grpc.pb.go @@ -0,0 +1,494 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.6.2 +// - protoc (unknown) +// source: api/v1/space_service.proto + +package apiv1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + emptypb "google.golang.org/protobuf/types/known/emptypb" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + SpaceService_CreateSpace_FullMethodName = "/memos.api.v1.SpaceService/CreateSpace" + SpaceService_ListSpaces_FullMethodName = "/memos.api.v1.SpaceService/ListSpaces" + SpaceService_GetSpace_FullMethodName = "/memos.api.v1.SpaceService/GetSpace" + SpaceService_UpdateSpace_FullMethodName = "/memos.api.v1.SpaceService/UpdateSpace" + SpaceService_DeleteSpace_FullMethodName = "/memos.api.v1.SpaceService/DeleteSpace" + SpaceService_CreateSpaceMember_FullMethodName = "/memos.api.v1.SpaceService/CreateSpaceMember" + SpaceService_ListSpaceMembers_FullMethodName = "/memos.api.v1.SpaceService/ListSpaceMembers" + SpaceService_GetSpaceMember_FullMethodName = "/memos.api.v1.SpaceService/GetSpaceMember" + SpaceService_UpdateSpaceMember_FullMethodName = "/memos.api.v1.SpaceService/UpdateSpaceMember" + SpaceService_DeleteSpaceMember_FullMethodName = "/memos.api.v1.SpaceService/DeleteSpaceMember" +) + +// SpaceServiceClient is the client API for SpaceService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +// +// SpaceService manages collaborative spaces and their memberships. +type SpaceServiceClient interface { + // CreateSpace creates a space and makes the authenticated caller its first + // administrator. + CreateSpace(ctx context.Context, in *CreateSpaceRequest, opts ...grpc.CallOption) (*Space, error) + // ListSpaces lists spaces of which the authenticated caller is a member. + ListSpaces(ctx context.Context, in *ListSpacesRequest, opts ...grpc.CallOption) (*ListSpacesResponse, error) + // GetSpace gets a space of which the authenticated caller is a member. + GetSpace(ctx context.Context, in *GetSpaceRequest, opts ...grpc.CallOption) (*Space, error) + // UpdateSpace updates space metadata. + UpdateSpace(ctx context.Context, in *UpdateSpaceRequest, opts ...grpc.CallOption) (*Space, error) + // DeleteSpace permanently deletes a space and every memo currently placed + // in it. It never follows memo relations to other memos. + DeleteSpace(ctx context.Context, in *DeleteSpaceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) + // CreateSpaceMember directly adds an existing active user to a space. + CreateSpaceMember(ctx context.Context, in *CreateSpaceMemberRequest, opts ...grpc.CallOption) (*SpaceMember, error) + // ListSpaceMembers lists the members of a space. + ListSpaceMembers(ctx context.Context, in *ListSpaceMembersRequest, opts ...grpc.CallOption) (*ListSpaceMembersResponse, error) + // GetSpaceMember gets one membership in a space. + GetSpaceMember(ctx context.Context, in *GetSpaceMemberRequest, opts ...grpc.CallOption) (*SpaceMember, error) + // UpdateSpaceMember changes a member's space role. + UpdateSpaceMember(ctx context.Context, in *UpdateSpaceMemberRequest, opts ...grpc.CallOption) (*SpaceMember, error) + // DeleteSpaceMember removes a member. A member may delete their own + // membership to leave the space. + DeleteSpaceMember(ctx context.Context, in *DeleteSpaceMemberRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) +} + +type spaceServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewSpaceServiceClient(cc grpc.ClientConnInterface) SpaceServiceClient { + return &spaceServiceClient{cc} +} + +func (c *spaceServiceClient) CreateSpace(ctx context.Context, in *CreateSpaceRequest, opts ...grpc.CallOption) (*Space, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Space) + err := c.cc.Invoke(ctx, SpaceService_CreateSpace_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *spaceServiceClient) ListSpaces(ctx context.Context, in *ListSpacesRequest, opts ...grpc.CallOption) (*ListSpacesResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ListSpacesResponse) + err := c.cc.Invoke(ctx, SpaceService_ListSpaces_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *spaceServiceClient) GetSpace(ctx context.Context, in *GetSpaceRequest, opts ...grpc.CallOption) (*Space, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Space) + err := c.cc.Invoke(ctx, SpaceService_GetSpace_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *spaceServiceClient) UpdateSpace(ctx context.Context, in *UpdateSpaceRequest, opts ...grpc.CallOption) (*Space, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Space) + err := c.cc.Invoke(ctx, SpaceService_UpdateSpace_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *spaceServiceClient) DeleteSpace(ctx context.Context, in *DeleteSpaceRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, SpaceService_DeleteSpace_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *spaceServiceClient) CreateSpaceMember(ctx context.Context, in *CreateSpaceMemberRequest, opts ...grpc.CallOption) (*SpaceMember, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SpaceMember) + err := c.cc.Invoke(ctx, SpaceService_CreateSpaceMember_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *spaceServiceClient) ListSpaceMembers(ctx context.Context, in *ListSpaceMembersRequest, opts ...grpc.CallOption) (*ListSpaceMembersResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ListSpaceMembersResponse) + err := c.cc.Invoke(ctx, SpaceService_ListSpaceMembers_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *spaceServiceClient) GetSpaceMember(ctx context.Context, in *GetSpaceMemberRequest, opts ...grpc.CallOption) (*SpaceMember, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SpaceMember) + err := c.cc.Invoke(ctx, SpaceService_GetSpaceMember_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *spaceServiceClient) UpdateSpaceMember(ctx context.Context, in *UpdateSpaceMemberRequest, opts ...grpc.CallOption) (*SpaceMember, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(SpaceMember) + err := c.cc.Invoke(ctx, SpaceService_UpdateSpaceMember_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *spaceServiceClient) DeleteSpaceMember(ctx context.Context, in *DeleteSpaceMemberRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(emptypb.Empty) + err := c.cc.Invoke(ctx, SpaceService_DeleteSpaceMember_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// SpaceServiceServer is the server API for SpaceService service. +// All implementations must embed UnimplementedSpaceServiceServer +// for forward compatibility. +// +// SpaceService manages collaborative spaces and their memberships. +type SpaceServiceServer interface { + // CreateSpace creates a space and makes the authenticated caller its first + // administrator. + CreateSpace(context.Context, *CreateSpaceRequest) (*Space, error) + // ListSpaces lists spaces of which the authenticated caller is a member. + ListSpaces(context.Context, *ListSpacesRequest) (*ListSpacesResponse, error) + // GetSpace gets a space of which the authenticated caller is a member. + GetSpace(context.Context, *GetSpaceRequest) (*Space, error) + // UpdateSpace updates space metadata. + UpdateSpace(context.Context, *UpdateSpaceRequest) (*Space, error) + // DeleteSpace permanently deletes a space and every memo currently placed + // in it. It never follows memo relations to other memos. + DeleteSpace(context.Context, *DeleteSpaceRequest) (*emptypb.Empty, error) + // CreateSpaceMember directly adds an existing active user to a space. + CreateSpaceMember(context.Context, *CreateSpaceMemberRequest) (*SpaceMember, error) + // ListSpaceMembers lists the members of a space. + ListSpaceMembers(context.Context, *ListSpaceMembersRequest) (*ListSpaceMembersResponse, error) + // GetSpaceMember gets one membership in a space. + GetSpaceMember(context.Context, *GetSpaceMemberRequest) (*SpaceMember, error) + // UpdateSpaceMember changes a member's space role. + UpdateSpaceMember(context.Context, *UpdateSpaceMemberRequest) (*SpaceMember, error) + // DeleteSpaceMember removes a member. A member may delete their own + // membership to leave the space. + DeleteSpaceMember(context.Context, *DeleteSpaceMemberRequest) (*emptypb.Empty, error) + mustEmbedUnimplementedSpaceServiceServer() +} + +// UnimplementedSpaceServiceServer must be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedSpaceServiceServer struct{} + +func (UnimplementedSpaceServiceServer) CreateSpace(context.Context, *CreateSpaceRequest) (*Space, error) { + return nil, status.Error(codes.Unimplemented, "method CreateSpace not implemented") +} +func (UnimplementedSpaceServiceServer) ListSpaces(context.Context, *ListSpacesRequest) (*ListSpacesResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ListSpaces not implemented") +} +func (UnimplementedSpaceServiceServer) GetSpace(context.Context, *GetSpaceRequest) (*Space, error) { + return nil, status.Error(codes.Unimplemented, "method GetSpace not implemented") +} +func (UnimplementedSpaceServiceServer) UpdateSpace(context.Context, *UpdateSpaceRequest) (*Space, error) { + return nil, status.Error(codes.Unimplemented, "method UpdateSpace not implemented") +} +func (UnimplementedSpaceServiceServer) DeleteSpace(context.Context, *DeleteSpaceRequest) (*emptypb.Empty, error) { + return nil, status.Error(codes.Unimplemented, "method DeleteSpace not implemented") +} +func (UnimplementedSpaceServiceServer) CreateSpaceMember(context.Context, *CreateSpaceMemberRequest) (*SpaceMember, error) { + return nil, status.Error(codes.Unimplemented, "method CreateSpaceMember not implemented") +} +func (UnimplementedSpaceServiceServer) ListSpaceMembers(context.Context, *ListSpaceMembersRequest) (*ListSpaceMembersResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ListSpaceMembers not implemented") +} +func (UnimplementedSpaceServiceServer) GetSpaceMember(context.Context, *GetSpaceMemberRequest) (*SpaceMember, error) { + return nil, status.Error(codes.Unimplemented, "method GetSpaceMember not implemented") +} +func (UnimplementedSpaceServiceServer) UpdateSpaceMember(context.Context, *UpdateSpaceMemberRequest) (*SpaceMember, error) { + return nil, status.Error(codes.Unimplemented, "method UpdateSpaceMember not implemented") +} +func (UnimplementedSpaceServiceServer) DeleteSpaceMember(context.Context, *DeleteSpaceMemberRequest) (*emptypb.Empty, error) { + return nil, status.Error(codes.Unimplemented, "method DeleteSpaceMember not implemented") +} +func (UnimplementedSpaceServiceServer) mustEmbedUnimplementedSpaceServiceServer() {} +func (UnimplementedSpaceServiceServer) testEmbeddedByValue() {} + +// UnsafeSpaceServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to SpaceServiceServer will +// result in compilation errors. +type UnsafeSpaceServiceServer interface { + mustEmbedUnimplementedSpaceServiceServer() +} + +func RegisterSpaceServiceServer(s grpc.ServiceRegistrar, srv SpaceServiceServer) { + // If the following call panics, it indicates UnimplementedSpaceServiceServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } + s.RegisterService(&SpaceService_ServiceDesc, srv) +} + +func _SpaceService_CreateSpace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CreateSpaceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SpaceServiceServer).CreateSpace(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SpaceService_CreateSpace_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SpaceServiceServer).CreateSpace(ctx, req.(*CreateSpaceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SpaceService_ListSpaces_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListSpacesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SpaceServiceServer).ListSpaces(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SpaceService_ListSpaces_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SpaceServiceServer).ListSpaces(ctx, req.(*ListSpacesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SpaceService_GetSpace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetSpaceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SpaceServiceServer).GetSpace(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SpaceService_GetSpace_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SpaceServiceServer).GetSpace(ctx, req.(*GetSpaceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SpaceService_UpdateSpace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateSpaceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SpaceServiceServer).UpdateSpace(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SpaceService_UpdateSpace_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SpaceServiceServer).UpdateSpace(ctx, req.(*UpdateSpaceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SpaceService_DeleteSpace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteSpaceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SpaceServiceServer).DeleteSpace(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SpaceService_DeleteSpace_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SpaceServiceServer).DeleteSpace(ctx, req.(*DeleteSpaceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SpaceService_CreateSpaceMember_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CreateSpaceMemberRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SpaceServiceServer).CreateSpaceMember(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SpaceService_CreateSpaceMember_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SpaceServiceServer).CreateSpaceMember(ctx, req.(*CreateSpaceMemberRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SpaceService_ListSpaceMembers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListSpaceMembersRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SpaceServiceServer).ListSpaceMembers(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SpaceService_ListSpaceMembers_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SpaceServiceServer).ListSpaceMembers(ctx, req.(*ListSpaceMembersRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SpaceService_GetSpaceMember_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetSpaceMemberRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SpaceServiceServer).GetSpaceMember(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SpaceService_GetSpaceMember_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SpaceServiceServer).GetSpaceMember(ctx, req.(*GetSpaceMemberRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SpaceService_UpdateSpaceMember_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateSpaceMemberRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SpaceServiceServer).UpdateSpaceMember(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SpaceService_UpdateSpaceMember_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SpaceServiceServer).UpdateSpaceMember(ctx, req.(*UpdateSpaceMemberRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _SpaceService_DeleteSpaceMember_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteSpaceMemberRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(SpaceServiceServer).DeleteSpaceMember(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: SpaceService_DeleteSpaceMember_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(SpaceServiceServer).DeleteSpaceMember(ctx, req.(*DeleteSpaceMemberRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// SpaceService_ServiceDesc is the grpc.ServiceDesc for SpaceService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var SpaceService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "memos.api.v1.SpaceService", + HandlerType: (*SpaceServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "CreateSpace", + Handler: _SpaceService_CreateSpace_Handler, + }, + { + MethodName: "ListSpaces", + Handler: _SpaceService_ListSpaces_Handler, + }, + { + MethodName: "GetSpace", + Handler: _SpaceService_GetSpace_Handler, + }, + { + MethodName: "UpdateSpace", + Handler: _SpaceService_UpdateSpace_Handler, + }, + { + MethodName: "DeleteSpace", + Handler: _SpaceService_DeleteSpace_Handler, + }, + { + MethodName: "CreateSpaceMember", + Handler: _SpaceService_CreateSpaceMember_Handler, + }, + { + MethodName: "ListSpaceMembers", + Handler: _SpaceService_ListSpaceMembers_Handler, + }, + { + MethodName: "GetSpaceMember", + Handler: _SpaceService_GetSpaceMember_Handler, + }, + { + MethodName: "UpdateSpaceMember", + Handler: _SpaceService_UpdateSpaceMember_Handler, + }, + { + MethodName: "DeleteSpaceMember", + Handler: _SpaceService_DeleteSpaceMember_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "api/v1/space_service.proto", +} diff --git a/proto/gen/api/v1/user_service.pb.go b/proto/gen/api/v1/user_service.pb.go index b1883e70..86e2d453 100644 --- a/proto/gen/api/v1/user_service.pb.go +++ b/proto/gen/api/v1/user_service.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.12 // protoc (unknown) // source: api/v1/user_service.proto diff --git a/proto/gen/openapi.yaml b/proto/gen/openapi.yaml index a4be7414..5e88bd59 100644 --- a/proto/gen/openapi.yaml +++ b/proto/gen/openapi.yaml @@ -611,7 +611,7 @@ paths: get: tags: - MemoService - description: ListMemos lists memos with pagination and filter. + description: ListMemos lists readable non-comment memos with pagination and filter. operationId: MemoService_ListMemos parameters: - name: pageSize @@ -662,7 +662,7 @@ paths: Available fields: content (string), creator (string, e.g. "users/1"), created_ts / updated_ts (timestamp), pinned (bool), - visibility (string: PRIVATE | PROTECTED | PUBLIC), + visibility (string: PRIVATE | PROTECTED | PUBLIC | SPACE), tags (list; match with `"work" in tags`, not `tag == "work"`), has_task_list / has_link / has_code / has_incomplete_tasks (bool), has_location (bool; true when the memo has a location attached). @@ -679,6 +679,18 @@ paths: description: Optional. If true, show deleted memos in the response. schema: type: boolean + - name: space + in: query + description: |- + Optional. Limit results to readable non-comment memos in a space of + which the caller is an active member. + schema: + type: string + - name: unassigned + in: query + description: Optional. Limit results to memos with no space. Must be true when set. + schema: + type: boolean responses: "200": description: OK @@ -697,7 +709,8 @@ paths: - MemoService description: |- CreateMemo creates a memo. The request body is a Memo; set its content - (Markdown) and visibility (PRIVATE | PROTECTED | PUBLIC, default PRIVATE). + (Markdown) and visibility (PRIVATE | PROTECTED | PUBLIC | SPACE, + default PRIVATE). The memo is owned by the authenticated user; requires authentication. operationId: MemoService_CreateMemo parameters: @@ -807,7 +820,9 @@ paths: delete: tags: - MemoService - description: DeleteMemo deletes a memo. + description: |- + DeleteMemo deletes only the named memo and its owned resources. It removes + incident relations but never deletes another memo. operationId: MemoService_DeleteMemo parameters: - name: memo @@ -981,7 +996,10 @@ paths: post: tags: - MemoService - description: CreateMemoComment creates a comment for a memo. + description: |- + CreateMemoComment atomically creates an independent memo plus one immutable + COMMENT context relation to the named memo. The new memo keeps its own + placement, visibility, authorship, and lifecycle. operationId: MemoService_CreateMemoComment parameters: - name: memo @@ -1152,9 +1170,9 @@ paths: tags: - MemoService description: |- - SetMemoRelations replaces the full set of relations on a memo with the - provided list (not an append). Pass the complete desired set; an empty list - clears all relations. Idempotent. + SetMemoRelations replaces the full set of mutable REFERENCE relations on a + memo. COMMENT relations are immutable creation context and are rejected by + this RPC. An empty list clears references without changing COMMENT. operationId: MemoService_SetMemoRelations parameters: - name: memo @@ -1293,6 +1311,329 @@ paths: application/json: schema: $ref: '#/components/schemas/Status' + /api/v1/spaces: + get: + tags: + - SpaceService + description: ListSpaces lists spaces of which the authenticated caller is a member. + operationId: SpaceService_ListSpaces + parameters: + - name: pageSize + in: query + description: Optional. The maximum number of spaces to return. + schema: + type: integer + format: int32 + - name: pageToken + in: query + description: Optional. A token from a previous ListSpaces response. + schema: + type: string + responses: + "200": + description: OK + content: + application/json: + schema: + $ref: '#/components/schemas/ListSpacesResponse' + default: + description: Default error response + content: + application/json: + schema: + $ref: '#/components/schemas/Status' + post: + tags: + - SpaceService + description: |- + CreateSpace creates a space and makes the authenticated caller its first + administrator. + operationId: SpaceService_CreateSpace + parameters: + - name: spaceId + in: query + description: Optional. The resource ID to use. If empty, one is generated. + schema: + type: string + requestBody: + content: + application/json: + schema: + $ref: '#/components/schemas/Space' + required: true + responses: + "200": + description: OK + content: + application/json: + schema: + $ref: '#/components/schemas/Space' + default: + description: Default error response + content: + application/json: + schema: + $ref: '#/components/schemas/Status' + /api/v1/spaces/{space}: + get: + tags: + - SpaceService + description: GetSpace gets a space of which the authenticated caller is a member. + operationId: SpaceService_GetSpace + parameters: + - name: space + in: path + description: The space id. + required: true + schema: + type: string + responses: + "200": + description: OK + content: + application/json: + schema: + $ref: '#/components/schemas/Space' + default: + description: Default error response + content: + application/json: + schema: + $ref: '#/components/schemas/Status' + delete: + tags: + - SpaceService + description: |- + DeleteSpace permanently deletes a space and every memo currently placed + in it. It never follows memo relations to other memos. + operationId: SpaceService_DeleteSpace + parameters: + - name: space + in: path + description: The space id. + required: true + schema: + type: string + responses: + "200": + description: OK + content: {} + default: + description: Default error response + content: + application/json: + schema: + $ref: '#/components/schemas/Status' + patch: + tags: + - SpaceService + description: UpdateSpace updates space metadata. + operationId: SpaceService_UpdateSpace + parameters: + - name: space + in: path + description: The space id. + required: true + schema: + type: string + - name: updateMask + in: query + description: 'Required. The fields to update: title or description.' + schema: + type: string + format: field-mask + requestBody: + content: + application/json: + schema: + $ref: '#/components/schemas/Space' + required: true + responses: + "200": + description: OK + content: + application/json: + schema: + $ref: '#/components/schemas/Space' + default: + description: Default error response + content: + application/json: + schema: + $ref: '#/components/schemas/Status' + /api/v1/spaces/{space}/members: + get: + tags: + - SpaceService + description: ListSpaceMembers lists the members of a space. + operationId: SpaceService_ListSpaceMembers + parameters: + - name: space + in: path + description: The space id. + required: true + schema: + type: string + - name: pageSize + in: query + description: Optional. The maximum number of members to return. + schema: + type: integer + format: int32 + - name: pageToken + in: query + description: Optional. A token from a previous ListSpaceMembers response. + schema: + type: string + responses: + "200": + description: OK + content: + application/json: + schema: + $ref: '#/components/schemas/ListSpaceMembersResponse' + default: + description: Default error response + content: + application/json: + schema: + $ref: '#/components/schemas/Status' + post: + tags: + - SpaceService + description: CreateSpaceMember directly adds an existing active user to a space. + operationId: SpaceService_CreateSpaceMember + parameters: + - name: space + in: path + description: The space id. + required: true + schema: + type: string + requestBody: + content: + application/json: + schema: + $ref: '#/components/schemas/SpaceMember' + required: true + responses: + "200": + description: OK + content: + application/json: + schema: + $ref: '#/components/schemas/SpaceMember' + default: + description: Default error response + content: + application/json: + schema: + $ref: '#/components/schemas/Status' + /api/v1/spaces/{space}/members/{member}: + get: + tags: + - SpaceService + description: GetSpaceMember gets one membership in a space. + operationId: SpaceService_GetSpaceMember + parameters: + - name: space + in: path + description: The space id. + required: true + schema: + type: string + - name: member + in: path + description: The member id. + required: true + schema: + type: string + responses: + "200": + description: OK + content: + application/json: + schema: + $ref: '#/components/schemas/SpaceMember' + default: + description: Default error response + content: + application/json: + schema: + $ref: '#/components/schemas/Status' + delete: + tags: + - SpaceService + description: |- + DeleteSpaceMember removes a member. A member may delete their own + membership to leave the space. + operationId: SpaceService_DeleteSpaceMember + parameters: + - name: space + in: path + description: The space id. + required: true + schema: + type: string + - name: member + in: path + description: The member id. + required: true + schema: + type: string + responses: + "200": + description: OK + content: {} + default: + description: Default error response + content: + application/json: + schema: + $ref: '#/components/schemas/Status' + patch: + tags: + - SpaceService + description: UpdateSpaceMember changes a member's space role. + operationId: SpaceService_UpdateSpaceMember + parameters: + - name: space + in: path + description: The space id. + required: true + schema: + type: string + - name: member + in: path + description: The member id. + required: true + schema: + type: string + - name: updateMask + in: query + description: Required. Only role is supported. + schema: + type: string + format: field-mask + requestBody: + content: + application/json: + schema: + $ref: '#/components/schemas/SpaceMember' + required: true + responses: + "200": + description: OK + content: + application/json: + schema: + $ref: '#/components/schemas/SpaceMember' + default: + description: Default error response + content: + application/json: + schema: + $ref: '#/components/schemas/Status' /api/v1/users: get: tags: @@ -3213,6 +3554,24 @@ components: nextPageToken: type: string description: A token for the next page of results. + ListSpaceMembersResponse: + type: object + properties: + spaceMembers: + type: array + items: + $ref: '#/components/schemas/SpaceMember' + nextPageToken: + type: string + ListSpacesResponse: + type: object + properties: + spaces: + type: array + items: + $ref: '#/components/schemas/Space' + nextPageToken: + type: string ListUserNotificationsResponse: type: object properties: @@ -3350,11 +3709,13 @@ components: - PRIVATE - PROTECTED - PUBLIC + - SPACE type: string description: |- The visibility of the memo. - One of PRIVATE (creator only), PROTECTED (signed-in users), or - PUBLIC (anyone). Defaults to PRIVATE on creation when unspecified. + One of PRIVATE (creator only), PROTECTED (signed-in users), PUBLIC + (anonymous-eligible), or SPACE (active space members). Defaults to + PRIVATE on creation when unspecified. format: enum tags: readOnly: true @@ -3390,7 +3751,8 @@ components: readOnly: true type: string description: |- - Output only. The name of the parent memo. + Output only. The readable context memo of this COMMENT relation, if any. + This is omitted unless the caller may independently read both memos. Format: memos/{memo} snippet: readOnly: true @@ -3400,6 +3762,11 @@ components: allOf: - $ref: '#/components/schemas/Location' description: Optional. The location of the memo. + space: + type: string + description: |- + Optional. The space in which this memo is placed. Format: spaces/{space}. + Every memo, including a comment, owns its placement independently. MemoRelation: required: - memo @@ -3686,7 +4053,7 @@ components: type: array items: $ref: '#/components/schemas/MemoRelation' - description: Required. The relations to set for the memo. + description: Required. The REFERENCE relations to set for the memo. COMMENT is invalid. SignInRequest: type: object properties: @@ -3753,6 +4120,42 @@ components: When the access token expires. Client should call RefreshToken before this time. format: date-time + Space: + required: + - title + type: object + properties: + name: + type: string + description: 'The resource name of the space. Format: spaces/{space}.' + title: + type: string + description: Required. The human-readable title. + description: + type: string + description: Optional. A description of the space. + description: Space is a collaboration boundary for placed memos. + SpaceMember: + required: + - user + - role + type: object + properties: + name: + type: string + description: 'The resource name. Format: spaces/{space}/members/{username}.' + user: + type: string + description: 'Required. The member user. Format: users/{username}.' + role: + enum: + - ROLE_UNSPECIFIED + - ADMIN + - USER + type: string + description: Required. The member's role within this space. + format: enum + description: SpaceMember is a user's membership and governance role in a space. Status: type: object properties: @@ -4198,4 +4601,6 @@ tags: - name: InstanceService - name: MemoService - name: MemoViewService + - name: SpaceService + description: SpaceService manages collaborative spaces and their memberships. - name: UserService diff --git a/proto/gen/store/idp.pb.go b/proto/gen/store/idp.pb.go index 6791ce1c..21d91e29 100644 --- a/proto/gen/store/idp.pb.go +++ b/proto/gen/store/idp.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.12 // protoc (unknown) // source: store/idp.proto diff --git a/proto/gen/store/inbox.pb.go b/proto/gen/store/inbox.pb.go index 147cfceb..ac797c95 100644 --- a/proto/gen/store/inbox.pb.go +++ b/proto/gen/store/inbox.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.12 // protoc (unknown) // source: store/inbox.proto diff --git a/proto/gen/store/memo.pb.go b/proto/gen/store/memo.pb.go index 2d9cf07b..1b966952 100644 --- a/proto/gen/store/memo.pb.go +++ b/proto/gen/store/memo.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.12 // protoc (unknown) // source: store/memo.proto diff --git a/proto/gen/store/user_setting.pb.go b/proto/gen/store/user_setting.pb.go index 165f1ed3..0d777a9f 100644 --- a/proto/gen/store/user_setting.pb.go +++ b/proto/gen/store/user_setting.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.36.11 +// protoc-gen-go v1.36.12 // protoc (unknown) // source: store/user_setting.proto diff --git a/server/access/memo.go b/server/access/memo.go index 18ac182d..3faed855 100644 --- a/server/access/memo.go +++ b/server/access/memo.go @@ -22,7 +22,7 @@ const ( type MemoReadClass int const ( - // MemoReadClassPrivate is for owner, authenticated, or share-token reads. + // MemoReadClassPrivate is for author, authenticated, member, or share-token reads. MemoReadClassPrivate MemoReadClass = iota // MemoReadClassPublic is for resources currently readable without credentials. MemoReadClassPublic @@ -34,97 +34,85 @@ type MemoReadDecision struct { Class MemoReadClass } +// MemoReadContext contains the fully resolved authorization context for one +// memo. Relations never contribute authorization; callers evaluate each +// relation endpoint independently. +type MemoReadContext struct { + Memo *store.Memo + Viewer *store.User + AllowAnonymous bool + SharedMemoID *int32 + CreatorValid bool + SpaceValid bool + ViewerSpaceMember bool +} + // Allowed reports whether the read is permitted. func (d MemoReadDecision) Allowed() bool { return d.Denial == MemoReadDenialNone } -// CheckMemoRead evaluates access to memo. If parent is non-nil, both the comment -// memo and its parent must be readable. A share grants access only to the exact, -// non-comment memo identified by sharedMemoID. -func CheckMemoRead(memo, parent *store.Memo, viewer *store.User, allowAnonymous bool, sharedMemoID *int32) MemoReadDecision { - if memo == nil { +// CheckMemoReadContext evaluates access to exactly one memo. Unknown audience, +// invalid lifecycle state, and a missing or invalid creator fail closed. A +// dangling placement only invalidates SPACE reads; other audiences +// remain memo-local. A share applies only to the exact memo and never to either +// endpoint of a relation. +func CheckMemoReadContext(ctx MemoReadContext) MemoReadDecision { + memo := ctx.Memo + if memo == nil || !ctx.CreatorValid { + return MemoReadDecision{Denial: MemoReadDenialNotFound} + } + if memo.Visibility != store.Public && memo.Visibility != store.Protected && memo.Visibility != store.Private && memo.Visibility != store.SpaceAudience { + return MemoReadDecision{Denial: MemoReadDenialNotFound} + } + if memo.Visibility == store.SpaceAudience && (memo.SpaceID == nil || !ctx.SpaceValid) { return MemoReadDecision{Denial: MemoReadDenialNotFound} } - if parent == nil { - shareApplies := sharedMemoID != nil && memo.ParentUID == nil && memo.ID == *sharedMemoID - return checkMemo(memo, viewer, allowAnonymous, shareApplies) + viewerActive := ctx.Viewer != nil && ctx.Viewer.RowStatus == store.Normal + viewerIsAuthor := viewerActive && ctx.Viewer.ID == memo.CreatorID + if memo.RowStatus == store.Archived && !viewerIsAuthor { + return MemoReadDecision{Denial: MemoReadDenialNotFound} + } + if memo.RowStatus != store.Normal && memo.RowStatus != store.Archived { + return MemoReadDecision{Denial: MemoReadDenialNotFound} } - // A token for a parent never grants access to its comments, and legacy - // comment shares never bypass the parent policy. A comment's visibility is - // derived from its parent so stale denormalized visibility values cannot - // leak or hide comments after the parent visibility changes. - commentState := checkCommentState(memo, viewer) - if !commentState.Allowed() { - return commentState - } - parentDecision := checkMemo(parent, viewer, allowAnonymous, false) - if !parentDecision.Allowed() { - return parentDecision - } - if commentState.Class == MemoReadClassPrivate { - return MemoReadDecision{Class: MemoReadClassPrivate} - } - return parentDecision -} - -func checkCommentState(memo *store.Memo, viewer *store.User) MemoReadDecision { - if memo == nil { - return MemoReadDecision{Denial: MemoReadDenialNotFound} - } - if memo.RowStatus == store.Archived { - if viewer != nil && viewer.ID == memo.CreatorID { - return MemoReadDecision{Class: MemoReadClassPrivate} - } - return MemoReadDecision{Denial: MemoReadDenialNotFound} - } - if memo.RowStatus != store.Normal { - return MemoReadDecision{Denial: MemoReadDenialNotFound} - } - return MemoReadDecision{Class: MemoReadClassPublic} -} - -func checkMemo(memo *store.Memo, viewer *store.User, allowAnonymous, shareApplies bool) MemoReadDecision { - if memo == nil { - return MemoReadDecision{Denial: MemoReadDenialNotFound} - } - if memo.RowStatus == store.Archived { - if viewer != nil && viewer.ID == memo.CreatorID { - return MemoReadDecision{Class: MemoReadClassPrivate} - } - return MemoReadDecision{Denial: MemoReadDenialNotFound} - } - if memo.RowStatus != store.Normal { - return MemoReadDecision{Denial: MemoReadDenialNotFound} - } + shareApplies := ctx.SharedMemoID != nil && memo.ID == *ctx.SharedMemoID && memo.Visibility != store.SpaceAudience if shareApplies { return MemoReadDecision{Class: MemoReadClassPrivate} } switch memo.Visibility { case store.Public: - if allowAnonymous { + if ctx.AllowAnonymous { return MemoReadDecision{Class: MemoReadClassPublic} } - if viewer != nil { + if viewerActive { return MemoReadDecision{Class: MemoReadClassPrivate} } return MemoReadDecision{Denial: MemoReadDenialUnauthenticated} case store.Protected: - if viewer != nil { + if viewerActive { return MemoReadDecision{Class: MemoReadClassPrivate} } return MemoReadDecision{Denial: MemoReadDenialUnauthenticated} case store.Private: - if viewer == nil { + if !viewerActive { return MemoReadDecision{Denial: MemoReadDenialUnauthenticated} } - if viewer.ID != memo.CreatorID { + if !viewerIsAuthor { return MemoReadDecision{Denial: MemoReadDenialPermission} } return MemoReadDecision{Class: MemoReadClassPrivate} + case store.SpaceAudience: + if !viewerActive { + return MemoReadDecision{Denial: MemoReadDenialUnauthenticated} + } + if ctx.ViewerSpaceMember { + return MemoReadDecision{Class: MemoReadClassPrivate} + } + return MemoReadDecision{Denial: MemoReadDenialPermission} default: return MemoReadDecision{Denial: MemoReadDenialNotFound} } diff --git a/server/access/memo_resolve.go b/server/access/memo_resolve.go new file mode 100644 index 00000000..15036d5b --- /dev/null +++ b/server/access/memo_resolve.go @@ -0,0 +1,89 @@ +package access + +import ( + "context" + + "github.com/usememos/memos/store" +) + +// MemoReadStore is the store subset needed to resolve a memo read context. +// *store.Store satisfies it. +type MemoReadStore interface { + GetUser(ctx context.Context, find *store.FindUser) (*store.User, error) + GetSpace(ctx context.Context, find *store.FindSpace) (*store.Space, error) + GetSpaceMember(ctx context.Context, find *store.FindSpaceMember) (*store.SpaceMember, error) +} + +// MemoReadFacts holds the viewer-independent authorization inputs for one memo. +// They are resolved once and reused across every viewer evaluated against the +// same memo. +type MemoReadFacts struct { + Memo *store.Memo + CreatorValid bool + SpaceValid bool +} + +// ResolveMemoReadFacts resolves the memo-local authorization inputs that do not +// depend on who is reading: whether the memo has a valid creator and, when it is +// assigned, whether its placement still exists. SpaceValid is authorization +// input only for SPACE reads and placement-dependent projection and +// writes; other audiences remain readable through their own memo-local rules. +func ResolveMemoReadFacts(ctx context.Context, s MemoReadStore, memo *store.Memo) (MemoReadFacts, error) { + facts := MemoReadFacts{Memo: memo} + if memo == nil { + return facts, nil + } + creatorID := memo.CreatorID + creator, err := s.GetUser(ctx, &store.FindUser{ID: &creatorID}) + if err != nil { + return MemoReadFacts{}, err + } + facts.CreatorValid = creator != nil && creator.ID == creatorID && + (creator.RowStatus == store.Normal || creator.RowStatus == store.Archived) + + facts.SpaceValid = memo.SpaceID == nil + if memo.SpaceID != nil { + space, err := s.GetSpace(ctx, &store.FindSpace{ID: memo.SpaceID}) + if err != nil { + return MemoReadFacts{}, err + } + facts.SpaceValid = space != nil + } + return facts, nil +} + +// WithViewer completes the read context for one viewer. Only the membership +// lookup is viewer-dependent, so evaluating additional viewers against the same +// memo costs at most one query each. +func (f MemoReadFacts) WithViewer(ctx context.Context, s MemoReadStore, viewer *store.User, allowAnonymous bool, sharedMemoID *int32) (MemoReadContext, error) { + readContext := MemoReadContext{ + Memo: f.Memo, + Viewer: viewer, + AllowAnonymous: allowAnonymous, + SharedMemoID: sharedMemoID, + CreatorValid: f.CreatorValid, + SpaceValid: f.SpaceValid, + } + if f.Memo == nil || f.Memo.SpaceID == nil || !f.SpaceValid { + return readContext, nil + } + if viewer == nil || viewer.RowStatus != store.Normal { + return readContext, nil + } + membership, err := s.GetSpaceMember(ctx, &store.FindSpaceMember{SpaceID: f.Memo.SpaceID, UserID: &viewer.ID}) + if err != nil { + return MemoReadContext{}, err + } + readContext.ViewerSpaceMember = membership != nil && membership.Role.IsActiveMember() + return readContext, nil +} + +// ResolveMemoReadContext resolves a complete read context for one memo and one +// viewer. +func ResolveMemoReadContext(ctx context.Context, s MemoReadStore, memo *store.Memo, viewer *store.User, allowAnonymous bool, sharedMemoID *int32) (MemoReadContext, error) { + facts, err := ResolveMemoReadFacts(ctx, s, memo) + if err != nil { + return MemoReadContext{}, err + } + return facts.WithViewer(ctx, s, viewer, allowAnonymous, sharedMemoID) +} diff --git a/server/access/memo_test.go b/server/access/memo_test.go index 73a19b52..2185401d 100644 --- a/server/access/memo_test.go +++ b/server/access/memo_test.go @@ -8,48 +8,139 @@ import ( "github.com/usememos/memos/store" ) -func TestCheckMemoRead(t *testing.T) { - owner := &store.User{ID: 1} - other := &store.User{ID: 2, Role: store.RoleAdmin} +func TestCheckMemoReadMemoLocalAudiences(t *testing.T) { + owner := &store.User{ID: 1, RowStatus: store.Normal} + other := &store.User{ID: 2, RowStatus: store.Normal, Role: store.RoleAdmin} public := &store.Memo{ID: 1, CreatorID: owner.ID, RowStatus: store.Normal, Visibility: store.Public} - private := &store.Memo{ID: 2, CreatorID: owner.ID, RowStatus: store.Normal, Visibility: store.Private} + protected := &store.Memo{ID: 2, CreatorID: owner.ID, RowStatus: store.Normal, Visibility: store.Protected} + private := &store.Memo{ID: 3, CreatorID: owner.ID, RowStatus: store.Normal, Visibility: store.Private} - require.Equal(t, MemoReadDecision{Class: MemoReadClassPublic}, CheckMemoRead(public, nil, nil, true, nil)) - require.Equal(t, MemoReadDenialUnauthenticated, CheckMemoRead(public, nil, nil, false, nil).Denial) - require.Equal(t, MemoReadDecision{Class: MemoReadClassPrivate}, CheckMemoRead(private, nil, owner, true, nil)) - require.Equal(t, MemoReadDenialPermission, CheckMemoRead(private, nil, other, true, nil).Denial) + require.Equal(t, MemoReadDecision{Class: MemoReadClassPublic}, CheckMemoReadContext(MemoReadContext{Memo: public, AllowAnonymous: true, CreatorValid: true, SpaceValid: true})) + require.Equal(t, MemoReadDenialUnauthenticated, CheckMemoReadContext(MemoReadContext{Memo: public, CreatorValid: true, SpaceValid: true}).Denial) + require.True(t, CheckMemoReadContext(MemoReadContext{Memo: protected, Viewer: other, CreatorValid: true, SpaceValid: true}).Allowed()) + require.True(t, CheckMemoReadContext(MemoReadContext{Memo: private, Viewer: owner, CreatorValid: true, SpaceValid: true}).Allowed()) + require.Equal(t, MemoReadDenialPermission, CheckMemoReadContext(MemoReadContext{Memo: private, Viewer: other, CreatorValid: true, SpaceValid: true}).Denial) shareID := private.ID - require.Equal(t, MemoReadDecision{Class: MemoReadClassPrivate}, CheckMemoRead(private, nil, nil, false, &shareID)) + require.True(t, CheckMemoReadContext(MemoReadContext{Memo: private, SharedMemoID: &shareID, CreatorValid: true, SpaceValid: true}).Allowed()) } -func TestCheckMemoReadCommentRequiresParentAndRejectsShares(t *testing.T) { - owner := &store.User{ID: 1} - parentUID := "parent" - comment := &store.Memo{ID: 2, CreatorID: owner.ID, RowStatus: store.Normal, Visibility: store.Public, ParentUID: &parentUID} - parent := &store.Memo{ID: 1, CreatorID: owner.ID, RowStatus: store.Normal, Visibility: store.Private} +func TestCheckMemoReadCommentDoesNotInheritContext(t *testing.T) { + const ownerID int32 = 1 + parentUID := "context-memo" + comment := &store.Memo{ + ID: 2, + CreatorID: ownerID, + RowStatus: store.Normal, + Visibility: store.Public, + ParentUID: &parentUID, + } - require.Equal(t, MemoReadDenialUnauthenticated, CheckMemoRead(comment, parent, nil, true, nil).Denial) - - commentShareID := comment.ID - require.Equal(t, MemoReadDenialUnauthenticated, CheckMemoRead(comment, parent, nil, true, &commentShareID).Denial) - parentShareID := parent.ID - require.Equal(t, MemoReadDenialUnauthenticated, CheckMemoRead(comment, parent, nil, true, &parentShareID).Denial) - require.True(t, CheckMemoRead(comment, parent, owner, true, nil).Allowed()) - - // Parent visibility is authoritative even if the denormalized comment value - // has not been synchronized yet. + require.Equal(t, MemoReadDecision{Class: MemoReadClassPublic}, CheckMemoReadContext(MemoReadContext{Memo: comment, AllowAnonymous: true, CreatorValid: true, SpaceValid: true})) comment.Visibility = store.Private - parent.Visibility = store.Public - require.Equal(t, MemoReadDecision{Class: MemoReadClassPublic}, CheckMemoRead(comment, parent, nil, true, nil)) + require.Equal(t, MemoReadDenialUnauthenticated, CheckMemoReadContext(MemoReadContext{Memo: comment, AllowAnonymous: true, CreatorValid: true, SpaceValid: true}).Denial) + + shareID := comment.ID + require.True(t, CheckMemoReadContext(MemoReadContext{Memo: comment, SharedMemoID: &shareID, CreatorValid: true, SpaceValid: true}).Allowed()) } -func TestCheckMemoReadArchivedAndUnknownStateFailClosed(t *testing.T) { +func TestCheckMemoReadSpaceAudience(t *testing.T) { + owner := &store.User{ID: 1, RowStatus: store.Normal} + member := &store.User{ID: 2, RowStatus: store.Normal} + appAdmin := &store.User{ID: 3, RowStatus: store.Normal, Role: store.RoleAdmin} + spaceID := int32(7) + memo := &store.Memo{ID: 10, CreatorID: owner.ID, RowStatus: store.Normal, Visibility: store.SpaceAudience, SpaceID: &spaceID} + + base := MemoReadContext{Memo: memo, CreatorValid: true, SpaceValid: true} + require.Equal(t, MemoReadDenialUnauthenticated, CheckMemoReadContext(base).Denial) + + base.Viewer = owner + require.Equal(t, MemoReadDenialPermission, CheckMemoReadContext(base).Denial) + + base.ViewerSpaceMember = true + require.True(t, CheckMemoReadContext(base).Allowed()) + + base.Viewer = member + base.ViewerSpaceMember = true + require.True(t, CheckMemoReadContext(base).Allowed()) + + base.Viewer = appAdmin + base.ViewerSpaceMember = false + require.Equal(t, MemoReadDenialPermission, CheckMemoReadContext(base).Denial) + + shareID := memo.ID + base.Viewer = nil + base.SharedMemoID = &shareID + require.Equal(t, MemoReadDenialUnauthenticated, CheckMemoReadContext(base).Denial) + + memo.SpaceID = nil + base.Viewer = member + base.ViewerSpaceMember = true + require.Equal(t, MemoReadDenialNotFound, CheckMemoReadContext(base).Denial) +} + +func TestCheckMemoReadInvalidStateFailsClosed(t *testing.T) { + owner := &store.User{ID: 1, RowStatus: store.Normal} + spaceID := int32(7) + memo := &store.Memo{ID: 10, CreatorID: owner.ID, RowStatus: store.Normal, Visibility: store.Public, SpaceID: &spaceID} + + require.Equal(t, MemoReadDecision{Class: MemoReadClassPublic}, CheckMemoReadContext(MemoReadContext{ + Memo: memo, Viewer: owner, AllowAnonymous: true, CreatorValid: true, SpaceValid: false, + }), "a dangling placement does not override a non-Space audience") + memo.Visibility = store.Protected + require.True(t, CheckMemoReadContext(MemoReadContext{ + Memo: memo, Viewer: owner, CreatorValid: true, SpaceValid: false, + }).Allowed(), "PROTECTED remains readable through its own audience") + memo.Visibility = store.Private + require.True(t, CheckMemoReadContext(MemoReadContext{ + Memo: memo, Viewer: owner, CreatorValid: true, SpaceValid: false, + }).Allowed(), "PRIVATE remains readable by its active author") + memo.Visibility = store.SpaceAudience + require.Equal(t, MemoReadDenialNotFound, CheckMemoReadContext(MemoReadContext{ + Memo: memo, Viewer: owner, CreatorValid: true, SpaceValid: false, ViewerSpaceMember: true, + }).Denial, "SPACE depends on a valid assigned Space") + + memo.SpaceID = nil + memo.Visibility = store.Visibility("FUTURE_AUDIENCE") + shareID := memo.ID + require.Equal(t, MemoReadDenialNotFound, CheckMemoReadContext(MemoReadContext{ + Memo: memo, Viewer: owner, AllowAnonymous: true, SharedMemoID: &shareID, CreatorValid: true, SpaceValid: true, + }).Denial) + + memo.Visibility = store.Public + memo.RowStatus = store.Archived + require.True(t, CheckMemoReadContext(MemoReadContext{Memo: memo, Viewer: owner, CreatorValid: true, SpaceValid: true}).Allowed()) + require.Equal(t, MemoReadDenialNotFound, CheckMemoReadContext(MemoReadContext{Memo: memo, AllowAnonymous: true, CreatorValid: true, SpaceValid: true}).Denial) + memo.Visibility = store.SpaceAudience + memo.SpaceID = &spaceID + require.Equal(t, MemoReadDenialPermission, CheckMemoReadContext(MemoReadContext{ + Memo: memo, Viewer: owner, CreatorValid: true, SpaceValid: true, + }).Denial, "an archived SPACE memo still requires active membership") + require.True(t, CheckMemoReadContext(MemoReadContext{ + Memo: memo, Viewer: owner, CreatorValid: true, SpaceValid: true, ViewerSpaceMember: true, + }).Allowed()) + + memo.RowStatus = store.RowStatus("UNKNOWN") + require.Equal(t, MemoReadDenialNotFound, CheckMemoReadContext(MemoReadContext{Memo: memo, Viewer: owner, CreatorValid: true, SpaceValid: true}).Denial) + + memo.RowStatus = store.Normal + memo.Visibility = store.Public + memo.SpaceID = nil + require.Equal(t, MemoReadDenialNotFound, CheckMemoReadContext(MemoReadContext{ + Memo: memo, Viewer: owner, AllowAnonymous: true, SpaceValid: true, + }).Denial, "a missing or invalid creator fails closed before audience evaluation") +} + +func TestCheckMemoReadAssignedPublicHasNoMembershipGate(t *testing.T) { owner := &store.User{ID: 1} - archived := &store.Memo{ID: 1, CreatorID: owner.ID, RowStatus: store.Archived, Visibility: store.Public} - require.Equal(t, MemoReadDenialNotFound, CheckMemoRead(archived, nil, nil, true, nil).Denial) - require.Equal(t, MemoReadDecision{Class: MemoReadClassPrivate}, CheckMemoRead(archived, nil, owner, true, nil)) + other := &store.User{ID: 2, RowStatus: store.Normal} + spaceID := int32(7) + assigned := &store.Memo{ID: 10, CreatorID: owner.ID, RowStatus: store.Normal, Visibility: store.Public, SpaceID: &spaceID} - unknown := &store.Memo{ID: 2, CreatorID: owner.ID, RowStatus: store.RowStatus("UNKNOWN"), Visibility: store.Public} - require.Equal(t, MemoReadDenialNotFound, CheckMemoRead(unknown, nil, owner, true, nil).Denial) + require.Equal(t, MemoReadDecision{Class: MemoReadClassPublic}, CheckMemoReadContext(MemoReadContext{ + Memo: assigned, AllowAnonymous: true, CreatorValid: true, SpaceValid: true, + })) + require.True(t, CheckMemoReadContext(MemoReadContext{ + Memo: assigned, Viewer: other, CreatorValid: true, SpaceValid: true, + }).Allowed(), "placement does not add a read gate to PUBLIC memos") } diff --git a/server/notification/email.go b/server/notification/email.go index a353155a..541768ab 100644 --- a/server/notification/email.go +++ b/server/notification/email.go @@ -73,7 +73,7 @@ func (d *EmailDispatcher) DispatchInboxEmail(ctx context.Context, inbox *store.I return nil } - memosByID, err := d.listMemosByID(ctx, collectInboxMemoIDs([]*store.Inbox{inbox})) + memosByID, err := d.listMemosByID(ctx, collectInboxMemoIDs([]*store.Inbox{inbox}), receiver.ID) if err != nil { return errors.Wrap(err, "failed to get notification memos") } @@ -187,6 +187,14 @@ func (d *EmailDispatcher) buildMemoMentionEmailMessage(message *storepb.InboxMes if !canViewerAccessMemo(receiver, memo) { return nil, nil } + // A mention created from a comment carries its conversational context in + // RelatedMemoId. The notification represents that relation, so suppress the + // complete email unless the receiver can still read both endpoints. + if payload.RelatedMemoId > 0 { + if !canViewerAccessMemo(receiver, memosByID[payload.RelatedMemoId]) { + return nil, nil + } + } url := d.memoURL(memo) if url == "" { return nil, nil @@ -210,7 +218,7 @@ func (d *EmailDispatcher) buildMemoMentionEmailMessage(message *storepb.InboxMes }, nil } -func (d *EmailDispatcher) listMemosByID(ctx context.Context, memoIDs []int32) (map[int32]*store.Memo, error) { +func (d *EmailDispatcher) listMemosByID(ctx context.Context, memoIDs []int32, viewerID int32) (map[int32]*store.Memo, error) { if len(memoIDs) == 0 { return map[int32]*store.Memo{}, nil } @@ -231,7 +239,10 @@ func (d *EmailDispatcher) listMemosByID(ctx context.Context, memoIDs []int32) (m return map[int32]*store.Memo{}, nil } - memos, err := d.store.ListMemos(ctx, &store.FindMemo{IDList: uniqueMemoIDs}) + memos, err := d.store.ListMemos(ctx, &store.FindMemo{ + IDList: uniqueMemoIDs, + Access: &store.MemoAccessScope{UserID: &viewerID, AllowPublic: true, AllowProtected: true}, + }) if err != nil { return nil, err } @@ -307,14 +318,8 @@ func canViewerAccessMemo(viewer *store.User, memo *store.Memo) bool { if memo == nil { return false } - if viewer != nil && viewer.Role == store.RoleAdmin { - return true - } if memo.Visibility == store.Private { return viewer != nil && viewer.ID == memo.CreatorID } - if memo.Visibility == store.Protected { - return viewer != nil - } return true } diff --git a/server/notification/email_test.go b/server/notification/email_test.go new file mode 100644 index 00000000..85fc74b3 --- /dev/null +++ b/server/notification/email_test.go @@ -0,0 +1,45 @@ +package notification + +import ( + "context" + "fmt" + "testing" + + "github.com/stretchr/testify/require" + + "github.com/usememos/memos/store" + teststore "github.com/usememos/memos/store/test" +) + +func TestEmailMemoReadCreatorLifecycle(t *testing.T) { + ctx := context.Background() + st := teststore.NewTestingStore(ctx, t) + defer st.Close() + dispatcher := NewEmailDispatcher(nil, st, nil) + + creator, err := st.CreateUser(ctx, &store.User{Username: "email-memo-creator", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + viewer, err := st.CreateUser(ctx, &store.User{Username: "email-memo-viewer", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + memo, err := st.CreateMemo(ctx, &store.Memo{ + UID: "email-memo-creator-lifecycle", CreatorID: creator.ID, Content: "memo", Visibility: store.Protected, + }) + require.NoError(t, err) + archived := store.Archived + _, err = st.UpdateUser(ctx, &store.UpdateUser{ID: creator.ID, RowStatus: &archived}) + require.NoError(t, err) + + readable, err := dispatcher.listMemosByID(ctx, []int32{memo.ID}, viewer.ID) + require.NoError(t, err) + require.Contains(t, readable, memo.ID, "archiving the creator must not narrow an active PROTECTED memo") + + _, err = st.GetDriver().GetDB().ExecContext(ctx, + fmt.Sprintf("UPDATE memo SET creator_id = 2147483000 WHERE id = %d", memo.ID)) + require.NoError(t, err) + danglingMemo, err := st.GetMemo(ctx, &store.FindMemo{ID: &memo.ID}) + require.NoError(t, err) + require.NotNil(t, danglingMemo) + readable, err = dispatcher.listMemosByID(ctx, []int32{danglingMemo.ID}, viewer.ID) + require.NoError(t, err) + require.NotContains(t, readable, danglingMemo.ID, "email rendering must fail closed for a missing memo creator") +} diff --git a/server/router/api/v1/acl_config.go b/server/router/api/v1/acl_config.go index 791882f5..f0e69ab0 100644 --- a/server/router/api/v1/acl_config.go +++ b/server/router/api/v1/acl_config.go @@ -34,6 +34,8 @@ var PublicMethods = map[string]struct{}{ "/memos.api.v1.MemoService/ListMemos": {}, "/memos.api.v1.MemoService/ListMemoComments": {}, "/memos.api.v1.MemoService/ListMemoAttachments": {}, + "/memos.api.v1.MemoService/ListMemoReactions": {}, + "/memos.api.v1.MemoService/ListMemoRelations": {}, "/memos.api.v1.MemoService/GetLinkMetadata": {}, "/memos.api.v1.MemoService/BatchGetLinkMetadata": {}, diff --git a/server/router/api/v1/acl_config_test.go b/server/router/api/v1/acl_config_test.go index ee3a016d..220a2320 100644 --- a/server/router/api/v1/acl_config_test.go +++ b/server/router/api/v1/acl_config_test.go @@ -30,6 +30,8 @@ func TestPublicMethodsArePublic(t *testing.T) { "/memos.api.v1.MemoService/ListMemos", "/memos.api.v1.MemoService/ListMemoComments", "/memos.api.v1.MemoService/ListMemoAttachments", + "/memos.api.v1.MemoService/ListMemoReactions", + "/memos.api.v1.MemoService/ListMemoRelations", "/memos.api.v1.MemoService/GetLinkMetadata", "/memos.api.v1.MemoService/BatchGetLinkMetadata", // Attachment Service metadata follows linked memo visibility. @@ -60,6 +62,17 @@ func TestProtectedMethodsRequireAuth(t *testing.T) { "/memos.api.v1.MemoService/CreateMemo", "/memos.api.v1.MemoService/UpdateMemo", "/memos.api.v1.MemoService/DeleteMemo", + // Space Service - every operation requires an authenticated member. + "/memos.api.v1.SpaceService/CreateSpace", + "/memos.api.v1.SpaceService/ListSpaces", + "/memos.api.v1.SpaceService/GetSpace", + "/memos.api.v1.SpaceService/UpdateSpace", + "/memos.api.v1.SpaceService/DeleteSpace", + "/memos.api.v1.SpaceService/CreateSpaceMember", + "/memos.api.v1.SpaceService/ListSpaceMembers", + "/memos.api.v1.SpaceService/GetSpaceMember", + "/memos.api.v1.SpaceService/UpdateSpaceMember", + "/memos.api.v1.SpaceService/DeleteSpaceMember", // Attachment Service - write operations "/memos.api.v1.AttachmentService/CreateAttachment", "/memos.api.v1.AttachmentService/DeleteAttachment", @@ -131,6 +144,8 @@ func TestAuthBootstrapClassification(t *testing.T) { "/memos.api.v1.MemoService/GetMemo", "/memos.api.v1.MemoService/ListMemoComments", "/memos.api.v1.MemoService/ListMemoAttachments", + "/memos.api.v1.MemoService/ListMemoReactions", + "/memos.api.v1.MemoService/ListMemoRelations", "/memos.api.v1.AttachmentService/GetAttachment", "/memos.api.v1.UserService/GetUser", "/memos.api.v1.UserService/ListAllUserStats", diff --git a/server/router/api/v1/attachment_service.go b/server/router/api/v1/attachment_service.go index 02e8504e..cc3aee8f 100644 --- a/server/router/api/v1/attachment_service.go +++ b/server/router/api/v1/attachment_service.go @@ -143,10 +143,11 @@ func (s *APIV1Service) CreateAttachment(ctx context.Context, request *v1pb.Creat if !canModifyMemo(user, memo) { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } - if memo.CreatorID != user.ID { - return nil, status.Errorf(codes.PermissionDenied, "attachments linked at creation must be owned by the memo creator") + if err := s.requireAssignedMemoWritable(ctx, memo, user.ID); err != nil { + return nil, err } create.MemoID = &memo.ID + create.Policy = memoWritePolicy(user.ID, false) } if create.Payload == nil || create.Payload.MotionMedia == nil { @@ -177,13 +178,30 @@ func (s *APIV1Service) CreateAttachment(ctx context.Context, request *v1pb.Creat } } - if err := SaveAttachmentBlob(ctx, s.Profile, s.Store, create); err != nil { + if err := saveAttachmentBlobWithInstanceStorageSetting(ctx, s.Profile, s.Store, create, instanceStorageSetting); err != nil { return nil, status.Errorf(codes.Internal, "failed to save attachment blob: %v", err) } attachment, err := s.Store.CreateAttachment(ctx, create) if err != nil { - return nil, status.Errorf(codes.Internal, "failed to create attachment: %v", err) + createErr := mapMemoWriteError(err, "failed to create attachment") + persistedObject, cleanupErr := cleanupSavedAttachmentBlob(ctx, s.Store, create, instanceStorageSetting) + if cleanupErr != nil { + slog.Error("failed to compensate attachment storage after database create failure", + slog.String("attachment_uid", create.UID), + slog.String("storage_type", create.StorageType.String()), + slog.Any("error", cleanupErr), + ) + } else if persistedObject { + slog.Warn("attachment create returned an error after its storage object was persisted in the database; skipping compensation", + slog.String("attachment_uid", create.UID), + slog.String("storage_type", create.StorageType.String()), + ) + } + return nil, createErr + } + if create.MemoID != nil { + s.SSEHub.publishMemoChanged() } return convertAttachmentFromStore(attachment), nil @@ -212,6 +230,7 @@ func (s *APIV1Service) ListAttachments(ctx context.Context, request *v1pb.ListAt findAttachment := &store.FindAttachment{ CreatorID: &user.ID, + Access: newMemoAccessScope(user, true), Limit: &pageSize, Offset: &offset, } @@ -286,15 +305,16 @@ func (s *APIV1Service) UpdateAttachment(ctx context.Context, request *v1pb.Updat if attachment == nil { return nil, status.Errorf(codes.NotFound, "attachment not found") } - // Only the creator or admin can update the attachment. - if attachment.CreatorID != user.ID && !isSuperUser(user) { + // Only the creator can update the attachment. + if attachment.CreatorID != user.ID { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } - currentTs := time.Now().Unix() + currentTsSec := time.Now().Unix() update := &store.UpdateAttachment{ ID: attachment.ID, - UpdatedTs: ¤tTs, + UpdatedTs: ¤tTsSec, + Policy: memoWritePolicy(user.ID, false), } for _, field := range request.UpdateMask.Paths { if field == "filename" { @@ -306,11 +326,23 @@ func (s *APIV1Service) UpdateAttachment(ctx context.Context, request *v1pb.Updat } if err := s.Store.UpdateAttachment(ctx, update); err != nil { - return nil, status.Errorf(codes.Internal, "failed to update attachment: %v", err) + return nil, mapMemoWriteError(err, "failed to update attachment") } - return s.GetAttachment(ctx, &v1pb.GetAttachmentRequest{ - Name: request.Attachment.Name, - }) + updatedAttachment, err := s.Store.GetAttachment(ctx, &store.FindAttachment{UID: &attachmentUID}) + if err != nil { + // The update already committed, and the current memo binding is unknown. + // Publish conservatively so clients do not retain stale memo state. + s.SSEHub.publishMemoChanged() + return nil, status.Errorf(codes.Internal, "attachment was updated but failed to reload: %v", err) + } + if updatedAttachment == nil { + s.SSEHub.publishMemoChanged() + return nil, status.Error(codes.Internal, "attachment was updated but no longer exists") + } + if updatedAttachment.MemoID != nil { + s.SSEHub.publishMemoChanged() + } + return convertAttachmentFromStore(updatedAttachment), nil } func (s *APIV1Service) DeleteAttachment(ctx context.Context, request *v1pb.DeleteAttachmentRequest) (*emptypb.Empty, error) { @@ -335,18 +367,10 @@ func (s *APIV1Service) DeleteAttachment(ctx context.Context, request *v1pb.Delet if attachment == nil { return nil, status.Errorf(codes.NotFound, "attachment not found") } - if err := s.validateAttachmentDeletions(ctx, []*store.Attachment{attachment}); err != nil { + attachments := []*store.Attachment{attachment} + if err := s.deleteAttachmentsAtomically(ctx, user, attachments); err != nil { return nil, err } - if err := s.detachAttachmentsForDeletion(ctx, []*store.Attachment{attachment}); err != nil { - return nil, err - } - // Delete the attachment from the database. - if err := s.Store.DeleteAttachment(ctx, &store.DeleteAttachment{ - ID: attachment.ID, - }); err != nil { - return nil, status.Errorf(codes.Internal, "failed to delete attachment: %v", err) - } return &emptypb.Empty{}, nil } @@ -387,34 +411,22 @@ func (s *APIV1Service) BatchDeleteAttachments(ctx context.Context, request *v1pb if attachment == nil { return nil, status.Errorf(codes.NotFound, "attachment not found") } - if attachment.CreatorID != user.ID && !isSuperUser(user) { + if attachment.CreatorID != user.ID { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } attachments = append(attachments, attachment) } - if err := s.validateAttachmentDeletions(ctx, attachments); err != nil { + if err := s.deleteAttachmentsAtomically(ctx, user, attachments); err != nil { return nil, err } - if err := s.detachAttachmentsForDeletion(ctx, attachments); err != nil { - return nil, err - } - for _, attachment := range attachments { - if err := s.Store.DeleteAttachment(ctx, &store.DeleteAttachment{ID: attachment.ID}); err != nil { - return nil, status.Errorf(codes.Internal, "failed to delete attachment: %v", err) - } - } return &emptypb.Empty{}, nil } -func (s *APIV1Service) validateAttachmentDeletions(ctx context.Context, attachments []*store.Attachment) error { - deletingUIDs := make(map[string]struct{}, len(attachments)) - creatorIDs := make(map[int32]struct{}) - for _, attachment := range attachments { - deletingUIDs[attachment.UID] = struct{}{} - if motion := getAttachmentMotionMedia(attachment); motion != nil && motion.GroupId != "" { - creatorIDs[attachment.CreatorID] = struct{}{} - } +func (s *APIV1Service) validateAttachmentDeletionPreflight(ctx context.Context, user *store.User, attachments []*store.Attachment) (map[int32]string, error) { + deletingUIDs, err := s.validateAttachmentMotionGroupDeletion(ctx, user, attachments) + if err != nil { + return nil, err } memos := make(map[int32]*store.Memo) @@ -427,100 +439,110 @@ func (s *APIV1Service) validateAttachmentDeletions(ctx context.Context, attachme var err error memo, err = s.Store.GetMemo(ctx, &store.FindMemo{ID: attachment.MemoID}) if err != nil { - return status.Errorf(codes.Internal, "failed to get attachment memo: %v", err) + return nil, status.Errorf(codes.Internal, "failed to get attachment memo: %v", err) } if memo == nil { - return status.Errorf(codes.FailedPrecondition, "attachment memo no longer exists") + return nil, status.Errorf(codes.FailedPrecondition, "attachment memo no longer exists") } memos[memo.ID] = memo } - + if memo.CreatorID != user.ID { + return nil, status.Error(codes.PermissionDenied, "permission denied") + } + } + expectedMemoContents := make(map[int32]string, len(memos)) + for _, memo := range memos { + expectedMemoContents[memo.ID] = memo.Content references, err := s.extractManagedAttachmentReferences(memo.Content) if err != nil { - return status.Errorf(codes.FailedPrecondition, "memo contains an invalid managed attachment reference: %v", err) + return nil, status.Errorf(codes.FailedPrecondition, "memo contains an invalid managed attachment reference: %v", err) } for _, reference := range references { - if _, ok := deletingUIDs[reference.UID]; ok { - return status.Errorf(codes.FailedPrecondition, "attachment %s is referenced by memo content", reference.UID) + if _, deleting := deletingUIDs[reference.UID]; deleting { + return nil, status.Errorf(codes.FailedPrecondition, "attachment %s is referenced by memo content", reference.UID) } } } - for creatorID := range creatorIDs { - creatorAttachments, err := s.Store.ListAttachments(ctx, &store.FindAttachment{CreatorID: &creatorID, SkipDefaultLimit: true}) - if err != nil { - return status.Errorf(codes.Internal, "failed to list motion media group: %v", err) + return expectedMemoContents, nil +} + +func (s *APIV1Service) validateAttachmentMotionGroupDeletion( + ctx context.Context, + user *store.User, + attachments []*store.Attachment, +) (map[string]struct{}, error) { + if user == nil || len(attachments) == 0 { + return nil, status.Error(codes.InvalidArgument, "attachments are required") + } + deletingUIDs := make(map[string]struct{}, len(attachments)) + motionGroupIDs := make(map[string]struct{}) + for _, attachment := range attachments { + if attachment == nil || attachment.ID <= 0 || attachment.UID == "" { + return nil, status.Error(codes.InvalidArgument, "invalid attachment") } - groups := make(map[string][]*store.Attachment) - for _, attachment := range creatorAttachments { - motion := getAttachmentMotionMedia(attachment) - if motion != nil && motion.GroupId != "" { - groups[motion.GroupId] = append(groups[motion.GroupId], attachment) - } + if attachment.CreatorID != user.ID { + return nil, status.Error(codes.PermissionDenied, "permission denied") } - for _, attachment := range attachments { - if attachment.CreatorID != creatorID { - continue - } - motion := getAttachmentMotionMedia(attachment) - if motion == nil || motion.GroupId == "" || len(groups[motion.GroupId]) < 2 { - continue - } - for _, groupAttachment := range groups[motion.GroupId] { - if _, ok := deletingUIDs[groupAttachment.UID]; !ok { - return status.Errorf(codes.FailedPrecondition, "motion media group %s must be deleted together", motion.GroupId) - } - } + deletingUIDs[attachment.UID] = struct{}{} + if motion := getAttachmentMotionMedia(attachment); motion != nil && motion.GroupId != "" { + motionGroupIDs[motion.GroupId] = struct{}{} } } + if len(motionGroupIDs) == 0 { + return deletingUIDs, nil + } + creatorAttachments, err := s.Store.ListAttachments(ctx, &store.FindAttachment{CreatorID: &user.ID, SkipDefaultLimit: true}) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to list motion media group: %v", err) + } + for _, candidate := range creatorAttachments { + motion := getAttachmentMotionMedia(candidate) + if motion == nil { + continue + } + if _, selectedGroup := motionGroupIDs[motion.GroupId]; !selectedGroup { + continue + } + if _, deleting := deletingUIDs[candidate.UID]; !deleting { + return nil, status.Errorf(codes.FailedPrecondition, "motion media group %s must be deleted together", motion.GroupId) + } + } + return deletingUIDs, nil +} + +func (s *APIV1Service) deleteAttachmentsAtomically(ctx context.Context, user *store.User, attachments []*store.Attachment) error { + expectedMemoContents, err := s.validateAttachmentDeletionPreflight(ctx, user, attachments) + if err != nil { + return err + } + attachmentIDs := make([]int32, 0, len(attachments)) + for _, attachment := range attachments { + attachmentIDs = append(attachmentIDs, attachment.ID) + } + if err := s.Store.DeleteAttachmentsWithPolicy(ctx, &store.AttachmentDeletionPolicy{ + ActorUserID: user.ID, + ExpectedMemoContents: expectedMemoContents, + }, attachmentIDs); err != nil { + return mapMemoWriteError(err, "failed to delete attachments") + } + if attachmentsIncludeMemo(attachments) { + s.SSEHub.publishMemoChanged() + } + if err := s.cleanupDeletedAttachmentStorage(ctx, attachments); err != nil { + return status.Errorf(codes.Internal, "attachments were deleted but storage cleanup failed: %v", err) + } return nil } -func (s *APIV1Service) detachAttachmentsForDeletion(ctx context.Context, attachments []*store.Attachment) error { - deletingUIDs := make(map[string]struct{}, len(attachments)) - attachmentsByMemoID := make(map[int32][]*store.Attachment) +func attachmentsIncludeMemo(attachments []*store.Attachment) bool { for _, attachment := range attachments { - deletingUIDs[attachment.UID] = struct{}{} - if attachment.MemoID != nil { - attachmentsByMemoID[*attachment.MemoID] = append(attachmentsByMemoID[*attachment.MemoID], attachment) + if attachment != nil && attachment.MemoID != nil { + return true } } - - for memoID, memoAttachments := range attachmentsByMemoID { - memo, err := s.Store.GetMemo(ctx, &store.FindMemo{ID: &memoID}) - if err != nil { - return status.Errorf(codes.Internal, "failed to recheck attachment memo: %v", err) - } - if memo == nil { - return status.Errorf(codes.FailedPrecondition, "attachment memo no longer exists") - } - references, err := s.extractManagedAttachmentReferences(memo.Content) - if err != nil { - return status.Errorf(codes.FailedPrecondition, "memo contains an invalid managed attachment reference: %v", err) - } - for _, reference := range references { - if _, ok := deletingUIDs[reference.UID]; ok { - return status.Errorf(codes.FailedPrecondition, "attachment %s is referenced by memo content", reference.UID) - } - } - removedIDs := make([]int32, 0, len(memoAttachments)) - for _, attachment := range memoAttachments { - removedIDs = append(removedIDs, attachment.ID) - } - if err := s.Store.ApplyMemoMutation(ctx, &store.MemoMutation{ - MemoID: memo.ID, - MemoCreatorID: memo.CreatorID, - ExpectedMemoContent: memo.Content, - RemovedAttachmentIDs: removedIDs, - }); err != nil { - if errors.Is(err, store.ErrMemoMutationConflict) { - return status.Errorf(codes.FailedPrecondition, "memo state changed: %v", err) - } - return status.Errorf(codes.Internal, "failed to detach attachments: %v", err) - } - } - return nil + return false } func (s *APIV1Service) validateAttachmentFilter(ctx context.Context, filterStr string) error { @@ -552,7 +574,7 @@ func (s *APIV1Service) checkAttachmentAccess(ctx context.Context, attachment *st if user == nil { return status.Errorf(codes.Unauthenticated, "user not authenticated") } - if attachment.CreatorID != user.ID && !isSuperUser(user) { + if attachment.CreatorID != user.ID { return status.Errorf(codes.PermissionDenied, "permission denied") } return nil @@ -567,5 +589,5 @@ func (s *APIV1Service) checkAttachmentAccess(ctx context.Context, attachment *st return status.Errorf(codes.NotFound, "memo not found") } - return s.checkMemoAndParentReadAccess(ctx, memo) + return s.checkMemoReadAccess(ctx, memo) } diff --git a/server/router/api/v1/attachment_service_storage.go b/server/router/api/v1/attachment_service_storage.go index a4baa298..0aa41fa9 100644 --- a/server/router/api/v1/attachment_service_storage.go +++ b/server/router/api/v1/attachment_service_storage.go @@ -52,7 +52,16 @@ func SaveAttachmentBlob(ctx context.Context, profile *profile.Profile, stores *s if err != nil { return errors.Wrap(err, "Failed to find instance storage setting") } + return saveAttachmentBlobWithInstanceStorageSetting(ctx, profile, stores, create, instanceStorageSetting) +} +func saveAttachmentBlobWithInstanceStorageSetting( + ctx context.Context, + profile *profile.Profile, + stores *store.Store, + create *store.Attachment, + instanceStorageSetting *storepb.InstanceStorageSetting, +) error { defaultStorage := store.GetDefaultStorage(instanceStorageSetting) if defaultStorage == nil { return errors.New("default storage is not configured") @@ -79,14 +88,14 @@ func SaveAttachmentBlob(ctx context.Context, profile *profile.Profile, stores *s osPath = ensureUniqueLocalAttachmentPath(osPath, create.UID) internalPath = filepath.ToSlash(osPath) if !filepath.IsAbs(filepath.FromSlash(internalPath)) { - internalPath, err = filepath.Rel(profile.Data, osPath) + relativePath, err := filepath.Rel(profile.Data, osPath) if err != nil { return errors.Wrap(err, "Failed to get relative path") } - internalPath = filepath.ToSlash(internalPath) + internalPath = filepath.ToSlash(relativePath) } dir := filepath.Dir(osPath) - if err = os.MkdirAll(dir, os.ModePerm); err != nil { + if err := os.MkdirAll(dir, os.ModePerm); err != nil { return errors.Wrap(err, "Failed to create directory") } @@ -129,6 +138,71 @@ func SaveAttachmentBlob(ctx context.Context, profile *profile.Profile, stores *s return nil } +func cleanupSavedAttachmentBlob( + ctx context.Context, + stores *store.Store, + attachment *store.Attachment, + instanceStorageSetting *storepb.InstanceStorageSetting, +) (bool, error) { + if attachment == nil || (attachment.StorageType != storepb.AttachmentStorageType_LOCAL && attachment.StorageType != storepb.AttachmentStorageType_S3) { + return false, nil + } + + cleanupCtx, cancelCleanup := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second) + defer cancelCleanup() + persisted, err := stores.GetAttachment(cleanupCtx, &store.FindAttachment{UID: &attachment.UID}) + if err != nil { + return false, errors.Wrap(err, "failed to verify attachment create outcome") + } + if hasSameManagedStorageObject(persisted, attachment) { + return true, nil + } + return false, stores.DeleteAttachmentStorageWithInstanceSetting(cleanupCtx, attachment, instanceStorageSetting) +} + +func hasSameManagedStorageObject(left, right *store.Attachment) bool { + if left == nil || right == nil || left.StorageType != right.StorageType { + return false + } + switch left.StorageType { + case storepb.AttachmentStorageType_LOCAL: + return left.Reference != "" && left.Reference == right.Reference + case storepb.AttachmentStorageType_S3: + leftObject, rightObject := left.Payload.GetS3Object(), right.Payload.GetS3Object() + return leftObject != nil && rightObject != nil && leftObject.Key != "" && leftObject.Key == rightObject.Key && leftObject.StorageId == rightObject.StorageId + default: + return false + } +} + +func (s *APIV1Service) cleanupDeletedAttachmentStorage(ctx context.Context, attachments []*store.Attachment) error { + var instanceStorageSetting *storepb.InstanceStorageSetting + var instanceStorageSettingErr error + for _, attachment := range attachments { + if store.AttachmentNeedsInstanceStorageSetting(attachment) { + instanceStorageSetting, instanceStorageSettingErr = s.Store.GetInstanceStorageSetting(ctx) + break + } + } + + var firstErr error + for _, attachment := range attachments { + if attachment == nil { + continue + } + var err error + if instanceStorageSettingErr != nil && store.AttachmentNeedsInstanceStorageSetting(attachment) { + err = errors.Wrap(instanceStorageSettingErr, "failed to get instance storage setting") + } else { + err = s.Store.DeleteAttachmentStorageWithInstanceSetting(ctx, attachment, instanceStorageSetting) + } + if err != nil && firstErr == nil { + firstErr = errors.Wrapf(err, "attachment %d", attachment.ID) + } + } + return firstErr +} + // GetAttachmentBlob reads an attachment from its configured storage. func (s *APIV1Service) GetAttachmentBlob(ctx context.Context, attachment *store.Attachment) ([]byte, error) { // For local storage, read the file from the local disk. diff --git a/server/router/api/v1/auth_service_session.go b/server/router/api/v1/auth_service_session.go index e41c33ca..51139408 100644 --- a/server/router/api/v1/auth_service_session.go +++ b/server/router/api/v1/auth_service_session.go @@ -257,12 +257,16 @@ func (s *APIV1Service) fetchCurrentUser(ctx context.Context) (*store.User, error if user == nil { return nil, errors.Errorf("user %d not found", userID) } - if user.RowStatus == store.Archived { + if !isActiveCurrentUser(user) { return nil, nil } return user, nil } +func isActiveCurrentUser(user *store.User) bool { + return user != nil && user.RowStatus == store.Normal +} + // extractClientInfo extracts comprehensive client information from the request context. // // This function parses metadata from the gRPC context to extract: diff --git a/server/router/api/v1/auth_service_session_status_test.go b/server/router/api/v1/auth_service_session_status_test.go new file mode 100644 index 00000000..f557c1ba --- /dev/null +++ b/server/router/api/v1/auth_service_session_status_test.go @@ -0,0 +1,27 @@ +package v1 + +import ( + "testing" + + "github.com/stretchr/testify/require" + + "github.com/usememos/memos/store" +) + +func TestIsActiveCurrentUserFailsClosed(t *testing.T) { + tests := []struct { + name string + user *store.User + active bool + }{ + {name: "missing"}, + {name: "normal", user: &store.User{RowStatus: store.Normal}, active: true}, + {name: "archived", user: &store.User{RowStatus: store.Archived}}, + {name: "unknown", user: &store.User{RowStatus: store.RowStatus("UNKNOWN")}}, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + require.Equal(t, test.active, isActiveCurrentUser(test.user)) + }) + } +} diff --git a/server/router/api/v1/authz_test.go b/server/router/api/v1/authz_test.go index 3272d682..700ada59 100644 --- a/server/router/api/v1/authz_test.go +++ b/server/router/api/v1/authz_test.go @@ -45,6 +45,8 @@ func TestAuthorizerCheckAccess(t *testing.T) { const ( protectedMethod = "/memos.api.v1.MemoService/CreateMemo" publicMethod = "/memos.api.v1.MemoService/ListMemos" + listReactions = "/memos.api.v1.MemoService/ListMemoReactions" + listRelations = "/memos.api.v1.MemoService/ListMemoRelations" bootstrapMethod = "/memos.api.v1.AuthService/SignIn" createUser = "/memos.api.v1.UserService/CreateUser" shareMethod = "/memos.api.v1.MemoService/GetSharedMemo" @@ -61,7 +63,11 @@ func TestAuthorizerCheckAccess(t *testing.T) { {"authenticated reaches public method on private instance", privateInstance, publicMethod, authenticated, nil}, {"anonymous denied on protected method", publicInstance, protectedMethod, nil, ErrUnauthenticated}, {"anonymous allowed on public method, public instance", publicInstance, publicMethod, nil, nil}, + {"anonymous allowed to list public memo reactions", publicInstance, listReactions, nil, nil}, + {"anonymous allowed to list public memo relations", publicInstance, listRelations, nil, nil}, {"anonymous denied on public method, private instance", privateInstance, publicMethod, nil, ErrUnauthenticated}, + {"anonymous denied memo reactions on private instance", privateInstance, listReactions, nil, ErrUnauthenticated}, + {"anonymous denied memo relations on private instance", privateInstance, listRelations, nil, ErrUnauthenticated}, {"anonymous allowed on bootstrap method, private instance", privateInstance, bootstrapMethod, nil, nil}, {"anonymous allowed to register on private instance", privateInstance, createUser, nil, nil}, {"anonymous allowed on share access, private instance", privateInstance, shareMethod, nil, nil}, diff --git a/server/router/api/v1/common.go b/server/router/api/v1/common.go index cc413b22..ce129628 100644 --- a/server/router/api/v1/common.go +++ b/server/router/api/v1/common.go @@ -74,10 +74,6 @@ func unmarshalPageToken(s string, pageToken *v1pb.PageToken) error { return nil } -func isSuperUser(user *store.User) bool { - return user.Role == store.RoleAdmin -} - func canModifyMemo(user *store.User, memo *store.Memo) bool { - return user != nil && memo != nil && (memo.CreatorID == user.ID || isSuperUser(user)) + return user != nil && memo != nil && memo.CreatorID == user.ID } diff --git a/server/router/api/v1/connect_handler.go b/server/router/api/v1/connect_handler.go index 2965967d..055b0b02 100644 --- a/server/router/api/v1/connect_handler.go +++ b/server/router/api/v1/connect_handler.go @@ -39,6 +39,7 @@ func (s *ConnectServiceHandler) RegisterConnectHandlers(mux *http.ServeMux, opts wrap(apiv1connect.NewAuthServiceHandler(s, opts...)), wrap(apiv1connect.NewUserServiceHandler(s, opts...)), wrap(apiv1connect.NewMemoServiceHandler(s, opts...)), + wrap(apiv1connect.NewSpaceServiceHandler(s, opts...)), wrap(apiv1connect.NewAttachmentServiceHandler(s, opts...)), wrap(apiv1connect.NewAIServiceHandler(s, opts...)), wrap(apiv1connect.NewMemoViewServiceHandler(s, opts...)), diff --git a/server/router/api/v1/connect_interceptors.go b/server/router/api/v1/connect_interceptors.go index 555cc649..b04e542a 100644 --- a/server/router/api/v1/connect_interceptors.go +++ b/server/router/api/v1/connect_interceptors.go @@ -65,9 +65,7 @@ func (*MetadataInterceptor) WrapUnary(next connect.UnaryFunc) connect.UnaryFunc // Prevent browser caching of API responses to avoid stale data issues // See: https://github.com/usememos/memos/issues/5470 if !isNilAnyResponse(resp) && resp.Header() != nil { - resp.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate") - resp.Header().Set("Pragma", "no-cache") - resp.Header().Set("Expires", "0") + setAPIResponseNoStoreHeaders(resp.Header()) } return resp, err diff --git a/server/router/api/v1/connect_interceptors_test.go b/server/router/api/v1/connect_interceptors_test.go index 3ab010ff..4c2555d4 100644 --- a/server/router/api/v1/connect_interceptors_test.go +++ b/server/router/api/v1/connect_interceptors_test.go @@ -34,9 +34,19 @@ func TestMetadataInterceptorForwardsSecurityHeaders(t *testing.T) { return connect.NewResponse(&emptypb.Empty{}), nil }) - if _, err := handler(context.Background(), req); err != nil { + response, err := handler(context.Background(), req) + if err != nil { t.Fatalf("metadata interceptor returned error: %v", err) } + if got := response.Header().Get("Cache-Control"); got != "no-cache, no-store, must-revalidate" { + t.Fatalf("unexpected Cache-Control header: %q", got) + } + if got := response.Header().Get("Pragma"); got != "no-cache" { + t.Fatalf("unexpected Pragma header: %q", got) + } + if got := response.Header().Get("Expires"); got != "0" { + t.Fatalf("unexpected Expires header: %q", got) + } } func TestNewAuthorizationConnectErrorMapsFailureClass(t *testing.T) { diff --git a/server/router/api/v1/connect_services.go b/server/router/api/v1/connect_services.go index e45c054e..dea5936e 100644 --- a/server/router/api/v1/connect_services.go +++ b/server/router/api/v1/connect_services.go @@ -463,6 +463,88 @@ func (s *ConnectServiceHandler) BatchGetLinkMetadata(ctx context.Context, req *c return connect.NewResponse(resp), nil } +// SpaceService + +func (s *ConnectServiceHandler) CreateSpace(ctx context.Context, req *connect.Request[v1pb.CreateSpaceRequest]) (*connect.Response[v1pb.Space], error) { + resp, err := s.APIV1Service.CreateSpace(ctx, req.Msg) + if err != nil { + return nil, convertGRPCError(err) + } + return connect.NewResponse(resp), nil +} + +func (s *ConnectServiceHandler) ListSpaces(ctx context.Context, req *connect.Request[v1pb.ListSpacesRequest]) (*connect.Response[v1pb.ListSpacesResponse], error) { + resp, err := s.APIV1Service.ListSpaces(ctx, req.Msg) + if err != nil { + return nil, convertGRPCError(err) + } + return connect.NewResponse(resp), nil +} + +func (s *ConnectServiceHandler) GetSpace(ctx context.Context, req *connect.Request[v1pb.GetSpaceRequest]) (*connect.Response[v1pb.Space], error) { + resp, err := s.APIV1Service.GetSpace(ctx, req.Msg) + if err != nil { + return nil, convertGRPCError(err) + } + return connect.NewResponse(resp), nil +} + +func (s *ConnectServiceHandler) UpdateSpace(ctx context.Context, req *connect.Request[v1pb.UpdateSpaceRequest]) (*connect.Response[v1pb.Space], error) { + resp, err := s.APIV1Service.UpdateSpace(ctx, req.Msg) + if err != nil { + return nil, convertGRPCError(err) + } + return connect.NewResponse(resp), nil +} + +func (s *ConnectServiceHandler) DeleteSpace(ctx context.Context, req *connect.Request[v1pb.DeleteSpaceRequest]) (*connect.Response[emptypb.Empty], error) { + resp, err := s.APIV1Service.DeleteSpace(ctx, req.Msg) + if err != nil { + return nil, convertGRPCError(err) + } + return connect.NewResponse(resp), nil +} + +func (s *ConnectServiceHandler) CreateSpaceMember(ctx context.Context, req *connect.Request[v1pb.CreateSpaceMemberRequest]) (*connect.Response[v1pb.SpaceMember], error) { + resp, err := s.APIV1Service.CreateSpaceMember(ctx, req.Msg) + if err != nil { + return nil, convertGRPCError(err) + } + return connect.NewResponse(resp), nil +} + +func (s *ConnectServiceHandler) ListSpaceMembers(ctx context.Context, req *connect.Request[v1pb.ListSpaceMembersRequest]) (*connect.Response[v1pb.ListSpaceMembersResponse], error) { + resp, err := s.APIV1Service.ListSpaceMembers(ctx, req.Msg) + if err != nil { + return nil, convertGRPCError(err) + } + return connect.NewResponse(resp), nil +} + +func (s *ConnectServiceHandler) GetSpaceMember(ctx context.Context, req *connect.Request[v1pb.GetSpaceMemberRequest]) (*connect.Response[v1pb.SpaceMember], error) { + resp, err := s.APIV1Service.GetSpaceMember(ctx, req.Msg) + if err != nil { + return nil, convertGRPCError(err) + } + return connect.NewResponse(resp), nil +} + +func (s *ConnectServiceHandler) UpdateSpaceMember(ctx context.Context, req *connect.Request[v1pb.UpdateSpaceMemberRequest]) (*connect.Response[v1pb.SpaceMember], error) { + resp, err := s.APIV1Service.UpdateSpaceMember(ctx, req.Msg) + if err != nil { + return nil, convertGRPCError(err) + } + return connect.NewResponse(resp), nil +} + +func (s *ConnectServiceHandler) DeleteSpaceMember(ctx context.Context, req *connect.Request[v1pb.DeleteSpaceMemberRequest]) (*connect.Response[emptypb.Empty], error) { + resp, err := s.APIV1Service.DeleteSpaceMember(ctx, req.Msg) + if err != nil { + return nil, convertGRPCError(err) + } + return connect.NewResponse(resp), nil +} + // AttachmentService func (s *ConnectServiceHandler) CreateAttachment(ctx context.Context, req *connect.Request[v1pb.CreateAttachmentRequest]) (*connect.Response[v1pb.Attachment], error) { diff --git a/server/router/api/v1/gateway_route_resolver_test.go b/server/router/api/v1/gateway_route_resolver_test.go index 05cf7120..6712666c 100644 --- a/server/router/api/v1/gateway_route_resolver_test.go +++ b/server/router/api/v1/gateway_route_resolver_test.go @@ -92,6 +92,10 @@ func TestGatewayRouteResolverResolvesKnownRoutes(t *testing.T) { {http.MethodGet, "/api/v1/memos", "/api/v1/memos", "/memos.api.v1.MemoService/ListMemos"}, {http.MethodGet, "/api/v1/{name=memos/*}", "/api/v1/memos/abc", "/memos.api.v1.MemoService/GetMemo"}, {http.MethodPost, "/api/v1/memos", "/api/v1/memos", "/memos.api.v1.MemoService/CreateMemo"}, + {http.MethodPost, "/api/v1/spaces", "/api/v1/spaces", "/memos.api.v1.SpaceService/CreateSpace"}, + {http.MethodGet, "/api/v1/{name=spaces/*}", "/api/v1/spaces/team", "/memos.api.v1.SpaceService/GetSpace"}, + {http.MethodDelete, "/api/v1/{name=spaces/*}", "/api/v1/spaces/team", "/memos.api.v1.SpaceService/DeleteSpace"}, + {http.MethodGet, "/api/v1/{name=spaces/*/members/*}", "/api/v1/spaces/team/members/alice", "/memos.api.v1.SpaceService/GetSpaceMember"}, { http.MethodGet, "/api/v1/shares/{share_token}/memo", diff --git a/server/router/api/v1/memo_access.go b/server/router/api/v1/memo_access.go new file mode 100644 index 00000000..325ebd4b --- /dev/null +++ b/server/router/api/v1/memo_access.go @@ -0,0 +1,183 @@ +package v1 + +import ( + "context" + stderrors "errors" + + "github.com/pkg/errors" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "github.com/usememos/memos/server/access" + "github.com/usememos/memos/store" +) + +// buildMemoReadContext resolves authorization inputs for exactly one memo. +// Relations never contribute access to either endpoint. +func (s *APIV1Service) buildMemoReadContext(ctx context.Context, memo *store.Memo, sharedMemoID *int32) (access.MemoReadContext, error) { + viewer, err := s.fetchCurrentUser(ctx) + if err != nil { + return access.MemoReadContext{}, status.Errorf(codes.Internal, "failed to get user") + } + allowAnonymous := false + if viewer == nil { + allowAnonymous, err = s.Store.AllowsAnonymousAccess(ctx) + if err != nil { + return access.MemoReadContext{}, status.Errorf(codes.Internal, "failed to resolve instance access policy") + } + } + return s.buildMemoReadContextForViewer(ctx, memo, viewer, allowAnonymous, sharedMemoID) +} + +func (s *APIV1Service) buildMemoReadContextForViewer(ctx context.Context, memo *store.Memo, viewer *store.User, allowAnonymous bool, sharedMemoID *int32) (access.MemoReadContext, error) { + if memo == nil { + return access.MemoReadContext{}, status.Error(codes.NotFound, "memo not found") + } + readContext, err := access.ResolveMemoReadContext(ctx, s.Store, memo, viewer, allowAnonymous, sharedMemoID) + if err != nil { + return access.MemoReadContext{}, status.Errorf(codes.Internal, "failed to resolve memo access") + } + return readContext, nil +} + +func (s *APIV1Service) checkMemoReadAccess(ctx context.Context, memo *store.Memo) error { + readContext, err := s.buildMemoReadContext(ctx, memo, nil) + if err != nil { + return err + } + return memoAccessDecisionError(access.CheckMemoReadContext(readContext)) +} + +func memoAccessDecisionError(decision access.MemoReadDecision) error { + switch decision.Denial { + case access.MemoReadDenialNone: + return nil + case access.MemoReadDenialNotFound: + return status.Error(codes.NotFound, "memo not found") + case access.MemoReadDenialUnauthenticated: + return status.Error(codes.Unauthenticated, "user not authenticated") + default: + return status.Error(codes.PermissionDenied, "permission denied") + } +} + +// newMemoAccessScope returns the memo-local authorization predicate for a +// caller. Drivers apply it as a database predicate before LIMIT/OFFSET so +// inaccessible rows can neither leak nor skew counts and pagination. +func newMemoAccessScope(currentUser *store.User, allowPublic bool) *store.MemoAccessScope { + accessScope := &store.MemoAccessScope{AllowPublic: allowPublic, AllowProtected: currentUser != nil} + if currentUser != nil { + accessScope.UserID = ¤tUser.ID + } + return accessScope +} + +// resolveMemoAccessScope resolves the caller and builds their memo access +// scope. For an anonymous caller the instance access policy decides whether +// PUBLIC memos are readable at all. Callers map the returned error to their own +// transport representation. +func (s *APIV1Service) resolveMemoAccessScope(ctx context.Context) (*store.MemoAccessScope, *store.User, error) { + currentUser, err := s.fetchCurrentUser(ctx) + if err != nil { + return nil, nil, errors.Wrap(err, "failed to get current user") + } + allowPublic := currentUser != nil + if currentUser == nil { + allowPublic, err = s.Store.AllowsAnonymousAccess(ctx) + if err != nil { + return nil, nil, errors.Wrap(err, "failed to resolve instance access policy") + } + } + return newMemoAccessScope(currentUser, allowPublic), currentUser, nil +} + +// resolveWritableSpaceByName resolves a space resource name and requires the +// caller to be an active member of it. A non-member receives NotFound so that +// an existing collaboration boundary stays indistinguishable from a missing +// resource. +func (s *APIV1Service) resolveWritableSpaceByName(ctx context.Context, name string, userID int32) (*store.Space, error) { + spaceUID, err := ExtractSpaceUIDFromName(name) + if err != nil { + return nil, status.Errorf(codes.InvalidArgument, "invalid space name: %v", err) + } + space, err := s.Store.GetSpace(ctx, &store.FindSpace{UID: &spaceUID}) + if err != nil { + return nil, status.Error(codes.Internal, "failed to get space") + } + if space == nil { + return nil, status.Error(codes.NotFound, "space not found") + } + active, err := s.isActiveSpaceMember(ctx, space.ID, userID) + if err != nil { + return nil, status.Error(codes.Internal, "failed to resolve space membership") + } + if !active { + return nil, status.Error(codes.NotFound, "space not found") + } + return space, nil +} + +func (s *APIV1Service) isActiveSpaceMember(ctx context.Context, spaceID, userID int32) (bool, error) { + user, err := s.Store.GetUser(ctx, &store.FindUser{ID: &userID}) + if err != nil { + return false, err + } + if user == nil || user.RowStatus != store.Normal { + return false, nil + } + membership, err := s.Store.GetSpaceMember(ctx, &store.FindSpaceMember{SpaceID: &spaceID, UserID: &userID}) + if err != nil { + return false, err + } + return membership != nil && membership.Role.IsActiveMember(), nil +} + +func sameOptionalInt32(left, right *int32) bool { + if left == nil || right == nil { + return left == nil && right == nil + } + return *left == *right +} + +func memoWritePolicy(actorUserID int32, lifecycleOnly bool) *store.MemoWritePolicy { + return &store.MemoWritePolicy{ + ActorUserID: actorUserID, + LifecycleOnly: lifecycleOnly, + } +} + +func mapMemoWriteError(err error, operation string) error { + switch { + case stderrors.Is(err, store.ErrMemoMutationConflict): + return status.Errorf(codes.FailedPrecondition, "memo state changed: %v", err) + case stderrors.Is(err, store.ErrMemoSpaceNotWritable): + return status.Error(codes.FailedPrecondition, "memo space is no longer writable") + case stderrors.Is(err, store.ErrMemoSpaceMembershipRequired), stderrors.Is(err, store.ErrMemoPermissionDenied): + return status.Error(codes.PermissionDenied, "permission denied") + case stderrors.Is(err, store.ErrMemoShareConflict): + return status.Error(codes.FailedPrecondition, "revoke active shares before using the SPACE audience") + default: + return status.Errorf(codes.Internal, "%s: %v", operation, err) + } +} + +func (s *APIV1Service) requireAssignedMemoWritable(ctx context.Context, memo *store.Memo, userID int32) error { + if memo.SpaceID == nil { + return nil + } + space, err := s.Store.GetSpace(ctx, &store.FindSpace{ID: memo.SpaceID}) + if err != nil { + return status.Errorf(codes.Internal, "failed to get memo space") + } + if space == nil { + return status.Errorf(codes.FailedPrecondition, "memo has invalid space placement") + } + active, err := s.isActiveSpaceMember(ctx, space.ID, userID) + if err != nil { + return status.Errorf(codes.Internal, "failed to resolve space membership") + } + if !active { + return status.Errorf(codes.PermissionDenied, "active space membership is required") + } + return nil +} diff --git a/server/router/api/v1/memo_attachment_service.go b/server/router/api/v1/memo_attachment_service.go index 110acdbd..181769e7 100644 --- a/server/router/api/v1/memo_attachment_service.go +++ b/server/router/api/v1/memo_attachment_service.go @@ -2,7 +2,6 @@ package v1 import ( "context" - stderrors "errors" "net/url" "slices" "strings" @@ -48,15 +47,15 @@ func (s *APIV1Service) SetMemoAttachments(ctx context.Context, request *v1pb.Set if err != nil { return nil, err } - updatedTs := time.Now().Unix() - if err := s.applyMemoMutation(ctx, memo, prepared, &store.UpdateMemo{ID: memo.ID, UpdatedTs: &updatedTs}, requiredAttachmentIDs, nil); err != nil { + updatedTsSec := time.Now().Unix() + if err := s.applyMemoMutation(ctx, memo, prepared, &store.UpdateMemo{ID: memo.ID, UpdatedTs: &updatedTsSec}, requiredAttachmentIDs, nil); err != nil { return nil, err } - updatedMemo, parentMemo, memoMessage, err := s.buildUpdatedMemoState(ctx, memo.ID) + _, _, memoMessage, err := s.buildUpdatedMemoState(ctx, memo.ID) if err != nil { return nil, status.Errorf(codes.Internal, "failed to build updated memo state") } - s.dispatchMemoUpdatedSideEffects(ctx, updatedMemo, parentMemo, memoMessage) + s.dispatchMemoUpdatedSideEffects(ctx, memoMessage) return &emptypb.Empty{}, nil } @@ -73,11 +72,15 @@ func (s *APIV1Service) prepareMemoAttachments( memo *store.Memo, requestAttachments []*v1pb.Attachment, ) (*preparedMemoAttachments, error) { - currentAttachments, err := s.Store.ListAttachments(ctx, &store.FindAttachment{ - MemoID: &memo.ID, - }) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to list attachments") + currentAttachments := []*store.Attachment{} + if memo.ID > 0 { + var err error + currentAttachments, err = s.Store.ListAttachments(ctx, &store.FindAttachment{ + MemoID: &memo.ID, + }) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to list attachments") + } } normalizedAttachments, err := s.normalizeMemoAttachmentRequest(ctx, memo, currentAttachments, requestAttachments) @@ -96,7 +99,7 @@ func (s *APIV1Service) prepareMemoAttachments( if attachment.CreatorID != memo.CreatorID { return nil, status.Errorf(codes.FailedPrecondition, "cannot remove another user's attachment from this memo") } - if attachment.CreatorID != user.ID && !isSuperUser(user) { + if attachment.CreatorID != user.ID { return nil, status.Errorf(codes.PermissionDenied, "cannot remove another user's attachment") } removedAttachments = append(removedAttachments, attachment) @@ -110,16 +113,9 @@ func (s *APIV1Service) prepareMemoAttachments( }, nil } -func (s *APIV1Service) applyMemoMutation( - ctx context.Context, - memo *store.Memo, - prepared *preparedMemoAttachments, - memoUpdate *store.UpdateMemo, - requiredAttachmentIDs []int32, - referenceRelations *[]*store.MemoRelation, -) error { +func buildMemoAttachmentMutationBindings(prepared *preparedMemoAttachments) ([]*store.MemoAttachmentBinding, []int32) { if prepared == nil { - prepared = &preparedMemoAttachments{} + return nil, nil } currentIDs := make(map[int32]struct{}, len(prepared.current)) for _, attachment := range prepared.current { @@ -130,12 +126,11 @@ func (s *APIV1Service) applyMemoMutation( slices.Reverse(normalizedAttachments) bindings := make([]*store.MemoAttachmentBinding, 0, len(normalizedAttachments)) for index, attachment := range normalizedAttachments { - updatedTs := time.Now().Unix() + int64(index) _, wasBoundToMemo := currentIDs[attachment.ID] bindings = append(bindings, &store.MemoAttachmentBinding{ ID: attachment.ID, UID: attachment.UID, - UpdatedTs: updatedTs, + UpdatedTs: time.Now().Unix() + int64(index), WasBoundToMemo: wasBoundToMemo, }) } @@ -148,10 +143,85 @@ func (s *APIV1Service) applyMemoMutation( } return 0 }) + removedAttachmentIDs := make([]int32, 0, len(prepared.removed)) for _, attachment := range prepared.removed { removedAttachmentIDs = append(removedAttachmentIDs, attachment.ID) } + return bindings, removedAttachmentIDs +} + +// createMemoWithMutation creates the memo row, binds attachments, and writes +// reference relations in one database transaction. A failure in any dependent +// write therefore cannot leave an orphan memo behind. +func (s *APIV1Service) createMemoWithMutation( + ctx context.Context, + user *store.User, + create *store.Memo, + commentContextMemoID *int32, + prepared *preparedMemoAttachments, + requiredAttachmentIDs []int32, + referenceRelations []*store.MemoRelation, +) error { + if user == nil || create == nil || create.CreatorID != user.ID { + return store.ErrMemoPermissionDenied + } + bindings, _ := buildMemoAttachmentMutationBindings(prepared) + relations := make([]*store.MemoRelation, 0, len(referenceRelations)) + for _, relation := range referenceRelations { + if relation == nil { + continue + } + relations = append(relations, &store.MemoRelation{ + RelatedMemoID: relation.RelatedMemoID, + Type: relation.Type, + }) + } + return s.Store.ApplyMemoMutation(ctx, &store.MemoMutation{ + MemoCreate: create, + CommentContextMemoID: commentContextMemoID, + MemoCreatorID: create.CreatorID, + ExpectedMemoContent: create.Content, + Bindings: bindings, + RequiredAttachmentIDs: requiredAttachmentIDs, + ReplaceReferenceRelations: len(relations) > 0, + ReferenceRelations: relations, + }) +} + +func (s *APIV1Service) applyMemoMutation( + ctx context.Context, + memo *store.Memo, + prepared *preparedMemoAttachments, + memoUpdate *store.UpdateMemo, + requiredAttachmentIDs []int32, + referenceRelations *[]*store.MemoRelation, +) error { + user, err := s.fetchCurrentUser(ctx) + if err != nil { + return status.Error(codes.Internal, "failed to get current user") + } + if user == nil { + return status.Error(codes.Unauthenticated, "user not authenticated") + } + if memo.CreatorID != user.ID { + return status.Error(codes.PermissionDenied, "permission denied") + } + policy := memoWritePolicy(user.ID, false) + if memoUpdate != nil && memoUpdate.Policy != nil { + policy = memoUpdate.Policy + } else if memoUpdate != nil { + memoUpdate.Policy = policy + } + if prepared == nil { + prepared = &preparedMemoAttachments{} + } + if len(prepared.removed) > 0 { + if _, err := s.validateAttachmentMotionGroupDeletion(ctx, user, prepared.removed); err != nil { + return err + } + } + bindings, removedAttachmentIDs := buildMemoAttachmentMutationBindings(prepared) if referenceRelations != nil { relations := make([]*store.MemoRelation, 0, len(*referenceRelations)) for _, relation := range *referenceRelations { @@ -172,26 +242,17 @@ func (s *APIV1Service) applyMemoMutation( RemovedAttachmentIDs: removedAttachmentIDs, RequiredAttachmentIDs: requiredAttachmentIDs, ReplaceReferenceRelations: referenceRelations != nil, + Policy: policy, } if referenceRelations != nil { mutation.ReferenceRelations = *referenceRelations } if err := s.Store.ApplyMemoMutation(ctx, mutation); err != nil { - if stderrors.Is(err, store.ErrMemoMutationConflict) { - return status.Errorf(codes.FailedPrecondition, "memo state changed: %v", err) - } - return status.Errorf(codes.Internal, "failed to apply memo mutation: %v", err) + return mapMemoWriteError(err, "failed to apply memo mutation") } - - // Rows are detached in the transaction above. Delete storage one at a time so - // local cleanup remains storage-first; on failure the unlinked row remains and - // the owner can safely retry deletion. - for _, attachment := range prepared.removed { - if err := s.Store.DeleteAttachment(ctx, &store.DeleteAttachment{ID: attachment.ID}); err != nil { - return status.Errorf(codes.Internal, "failed to delete attachment: %v", err) - } + if err := s.cleanupDeletedAttachmentStorage(ctx, prepared.removed); err != nil { + return status.Errorf(codes.Internal, "memo was updated but attachment storage cleanup failed: %v", err) } - return nil } @@ -437,7 +498,7 @@ func (s *APIV1Service) ListMemoAttachments(ctx context.Context, request *v1pb.Li return nil, status.Errorf(codes.NotFound, "memo not found") } - if err := s.checkMemoAndParentReadAccess(ctx, memo); err != nil { + if err := s.checkMemoReadAccess(ctx, memo); err != nil { return nil, err } diff --git a/server/router/api/v1/memo_create_helpers.go b/server/router/api/v1/memo_create_helpers.go new file mode 100644 index 00000000..47102c0a --- /dev/null +++ b/server/router/api/v1/memo_create_helpers.go @@ -0,0 +1,97 @@ +package v1 + +import ( + "context" + "strings" + + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + v1pb "github.com/usememos/memos/proto/gen/api/v1" + "github.com/usememos/memos/server/runner/memopayload" + "github.com/usememos/memos/store" +) + +func mapMemoCreateError(err error, uid, operation string) error { + errMessage := err.Error() + if strings.Contains(errMessage, "UNIQUE constraint failed") || + strings.Contains(errMessage, "duplicate key") || + strings.Contains(errMessage, "Duplicate entry") { + return status.Errorf(codes.AlreadyExists, "memo with ID %q already exists", uid) + } + return mapMemoWriteError(err, operation) +} + +type preparedMemoCreate struct { + memo *store.Memo + attachments *preparedMemoAttachments + requiredAttachmentIDs []int32 + referenceRelations []*store.MemoRelation +} + +// prepareMemoCreate validates and prepares the fields shared by top-level +// memo and comment creation. It does not write database or external state. +func (s *APIV1Service) prepareMemoCreate(ctx context.Context, user *store.User, input *v1pb.Memo, uid string) (*preparedMemoCreate, error) { + if user == nil || input == nil { + return nil, status.Error(codes.InvalidArgument, "memo is required") + } + visibility, err := validateCreateMemoVisibility(input.Visibility) + if err != nil { + return nil, err + } + memo := &store.Memo{ + UID: uid, + CreatorID: user.ID, + Content: input.Content, + Visibility: visibility, + } + if input.Space != nil && input.GetSpace() != "" { + space, err := s.resolveWritableSpaceByName(ctx, input.GetSpace(), user.ID) + if err != nil { + return nil, err + } + memo.SpaceID = &space.ID + } + if memo.Visibility == store.SpaceAudience && memo.SpaceID == nil { + return nil, status.Error(codes.InvalidArgument, "SPACE visibility requires a space") + } + if input.CreateTime != nil && input.CreateTime.IsValid() { + memo.CreatedTs = input.CreateTime.AsTime().Unix() + } + if input.UpdateTime != nil && input.UpdateTime.IsValid() { + memo.UpdatedTs = input.UpdateTime.AsTime().Unix() + } + + contentLengthLimit, err := s.getContentLengthLimit(ctx) + if err != nil { + return nil, status.Error(codes.Internal, "failed to get content length limit") + } + if len(memo.Content) > contentLengthLimit { + return nil, status.Errorf(codes.InvalidArgument, "content too long (max %d characters)", contentLengthLimit) + } + if err := memopayload.RebuildMemoPayload(ctx, memo, s.MarkdownService); err != nil { + return nil, status.Errorf(codes.Internal, "failed to rebuild memo payload: %v", err) + } + if input.Location != nil { + memo.Payload.Location = convertLocationToStore(input.Location) + } + + attachments, err := s.prepareMemoAttachments(ctx, user, memo, input.Attachments) + if err != nil { + return nil, err + } + requiredAttachmentIDs, err := s.resolveMemoAttachmentReferences(memo.Content, attachments.normalized) + if err != nil { + return nil, err + } + relations, err := s.prepareMemoRelations(ctx, memo, input.Relations) + if err != nil { + return nil, err + } + return &preparedMemoCreate{ + memo: memo, + attachments: attachments, + requiredAttachmentIDs: requiredAttachmentIDs, + referenceRelations: relations, + }, nil +} diff --git a/server/router/api/v1/memo_create_helpers_test.go b/server/router/api/v1/memo_create_helpers_test.go new file mode 100644 index 00000000..24ade512 --- /dev/null +++ b/server/router/api/v1/memo_create_helpers_test.go @@ -0,0 +1,147 @@ +package v1 + +import ( + "context" + "fmt" + "strings" + "testing" + "time" + + "github.com/stretchr/testify/require" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/types/known/timestamppb" + + v1pb "github.com/usememos/memos/proto/gen/api/v1" + "github.com/usememos/memos/store" +) + +func TestMemoCreateSharedPreparationPreservesFields(t *testing.T) { + ctx := context.Background() + service := newIntegrationService(t) + user := createSpaceTestUser(ctx, t, service, "memo-create-fields", store.RoleUser) + userCtx := userCtx(ctx, user.ID) + + referenceTarget, err := service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{ + MemoId: "create-fields-reference", + Memo: &v1pb.Memo{Content: "reference target", Visibility: v1pb.Visibility_PRIVATE}, + }) + require.NoError(t, err) + + createAttachment := func(id string) *v1pb.Attachment { + t.Helper() + attachment, err := service.CreateAttachment(userCtx, &v1pb.CreateAttachmentRequest{ + AttachmentId: id, + Attachment: &v1pb.Attachment{ + Filename: id + ".png", + Type: "image/png", + Content: []byte("test image"), + }, + }) + require.NoError(t, err) + return attachment + } + createReference := func() *v1pb.MemoRelation { + return &v1pb.MemoRelation{ + RelatedMemo: &v1pb.MemoRelation_Memo{Name: referenceTarget.Name}, + Type: v1pb.MemoRelation_REFERENCE, + } + } + + topAttachment := createAttachment("create-fields-top-image") + topAttachmentUID := strings.TrimPrefix(topAttachment.Name, "attachments/") + topCreateTime := time.Date(2022, time.March, 4, 5, 6, 7, 0, time.UTC) + topUpdateTime := topCreateTime.Add(2 * time.Hour) + topLocation := &v1pb.Location{Placeholder: "top location", Latitude: 1.25, Longitude: 2.5} + topMemo, err := service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{ + MemoId: "create-fields-top", + Memo: &v1pb.Memo{ + Content: fmt.Sprintf("![top](/file/attachments/%s)", topAttachmentUID), + Visibility: v1pb.Visibility_PRIVATE, + CreateTime: timestamppb.New(topCreateTime), + UpdateTime: timestamppb.New(topUpdateTime), + Attachments: []*v1pb.Attachment{{Name: topAttachment.Name}}, + Relations: []*v1pb.MemoRelation{createReference()}, + Location: topLocation, + }, + }) + require.NoError(t, err) + require.Equal(t, topCreateTime.Unix(), topMemo.CreateTime.AsTime().Unix()) + require.Equal(t, topUpdateTime.Unix(), topMemo.UpdateTime.AsTime().Unix()) + require.Equal(t, topLocation.Placeholder, topMemo.Location.Placeholder) + require.Equal(t, topLocation.Latitude, topMemo.Location.Latitude) + require.Equal(t, topLocation.Longitude, topMemo.Location.Longitude) + require.Len(t, topMemo.Attachments, 1) + require.Equal(t, topAttachment.Name, topMemo.Attachments[0].Name) + requireMemoCreateRelation(t, topMemo, v1pb.MemoRelation_REFERENCE, referenceTarget.Name) + + commentAttachment := createAttachment("create-fields-comment-image") + commentAttachmentUID := strings.TrimPrefix(commentAttachment.Name, "attachments/") + commentCreateTime := time.Date(2023, time.April, 5, 6, 7, 8, 0, time.UTC) + commentUpdateTime := commentCreateTime.Add(3 * time.Hour) + commentLocation := &v1pb.Location{Placeholder: "comment location", Latitude: 3.75, Longitude: 4.5} + comment, err := service.CreateMemoComment(userCtx, &v1pb.CreateMemoCommentRequest{ + Name: topMemo.Name, + CommentId: "create-fields-comment", + Comment: &v1pb.Memo{ + Content: fmt.Sprintf("![comment](/file/attachments/%s)", commentAttachmentUID), + Visibility: v1pb.Visibility_PROTECTED, + CreateTime: timestamppb.New(commentCreateTime), + UpdateTime: timestamppb.New(commentUpdateTime), + Attachments: []*v1pb.Attachment{{Name: commentAttachment.Name}}, + Relations: []*v1pb.MemoRelation{createReference()}, + Location: commentLocation, + }, + }) + require.NoError(t, err) + require.Equal(t, commentCreateTime.Unix(), comment.CreateTime.AsTime().Unix()) + require.Equal(t, commentUpdateTime.Unix(), comment.UpdateTime.AsTime().Unix()) + require.Equal(t, commentLocation.Placeholder, comment.Location.Placeholder) + require.Equal(t, commentLocation.Latitude, comment.Location.Latitude) + require.Equal(t, commentLocation.Longitude, comment.Location.Longitude) + require.Equal(t, v1pb.Visibility_PROTECTED, comment.Visibility) + require.Len(t, comment.Attachments, 1) + require.Equal(t, commentAttachment.Name, comment.Attachments[0].Name) + requireMemoCreateRelation(t, comment, v1pb.MemoRelation_COMMENT, topMemo.Name) + requireMemoCreateRelation(t, comment, v1pb.MemoRelation_REFERENCE, referenceTarget.Name) +} + +func TestMemoCreateDuplicateIDsUseAlreadyExists(t *testing.T) { + ctx := context.Background() + service := newIntegrationService(t) + user := createSpaceTestUser(ctx, t, service, "memo-create-duplicates", store.RoleUser) + userCtx := userCtx(ctx, user.ID) + + parent, err := service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{ + MemoId: "duplicate-parent", + Memo: &v1pb.Memo{Content: "parent", Visibility: v1pb.Visibility_PRIVATE}, + }) + require.NoError(t, err) + _, err = service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{ + MemoId: "duplicate-parent", + Memo: &v1pb.Memo{Content: "duplicate", Visibility: v1pb.Visibility_PRIVATE}, + }) + require.Equal(t, codes.AlreadyExists, status.Code(err)) + + createComment := func() error { + _, err := service.CreateMemoComment(userCtx, &v1pb.CreateMemoCommentRequest{ + Name: parent.Name, + CommentId: "duplicate-comment", + Comment: &v1pb.Memo{Content: "comment", Visibility: v1pb.Visibility_PRIVATE}, + }) + return err + } + require.NoError(t, createComment()) + require.Equal(t, codes.AlreadyExists, status.Code(createComment())) +} + +func requireMemoCreateRelation(t *testing.T, memo *v1pb.Memo, relationType v1pb.MemoRelation_Type, relatedMemoName string) { + t.Helper() + for _, relation := range memo.Relations { + if relation.Type == relationType && relation.GetRelatedMemo().GetName() == relatedMemoName { + require.Equal(t, memo.Name, relation.GetMemo().GetName()) + return + } + } + require.Failf(t, "memo relation not found", "missing %s relation from %s to %s", relationType, memo.Name, relatedMemoName) +} diff --git a/server/router/api/v1/memo_delete_webhook_test.go b/server/router/api/v1/memo_delete_webhook_test.go new file mode 100644 index 00000000..0f18208c --- /dev/null +++ b/server/router/api/v1/memo_delete_webhook_test.go @@ -0,0 +1,125 @@ +package v1 + +import ( + "context" + "encoding/json" + "io" + "net" + "net/http" + "net/http/httptest" + "testing" + "time" + + "github.com/stretchr/testify/require" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "github.com/usememos/memos/internal/webhook" + v1pb "github.com/usememos/memos/proto/gen/api/v1" + "github.com/usememos/memos/store" +) + +func TestDeleteMemoWebhooksRespectCurrentReadAccess(t *testing.T) { + ctx := context.Background() + service := newIntegrationService(t) + owner := createSpaceTestUser(ctx, t, service, "delete-webhook-owner", store.RoleUser) + successor := createSpaceTestUser(ctx, t, service, "delete-webhook-successor", store.RoleUser) + ownerCtx := userCtx(ctx, owner.ID) + successorCtx := userCtx(ctx, successor.ID) + + space, err := service.CreateSpace(ownerCtx, &v1pb.CreateSpaceRequest{ + SpaceId: "delete-webhook-space", + Space: &v1pb.Space{Title: "Delete webhook space"}, + }) + require.NoError(t, err) + _, err = service.CreateSpaceMember(ownerCtx, &v1pb.CreateSpaceMemberRequest{ + Parent: space.Name, + SpaceMember: &v1pb.SpaceMember{ + User: BuildUserName(successor.Username), + Role: v1pb.SpaceMember_ADMIN, + }, + }) + require.NoError(t, err) + + assignedSpace := space.Name + hiddenMemo, err := service.CreateMemo(ownerCtx, &v1pb.CreateMemoRequest{ + Memo: &v1pb.Memo{ + Content: "must not leave through a webhook", + Visibility: v1pb.Visibility_SPACE, + Space: &assignedSpace, + }, + }) + require.NoError(t, err) + readableMemo, err := service.CreateMemo(ownerCtx, &v1pb.CreateMemoRequest{ + Memo: &v1pb.Memo{ + Content: "readable deletion payload", + Visibility: v1pb.Visibility_PRIVATE, + }, + }) + require.NoError(t, err) + + _, err = service.DeleteSpaceMember(successorCtx, &v1pb.DeleteSpaceMemberRequest{ + Name: buildSpaceMemberName("delete-webhook-space", owner.Username), + }) + require.NoError(t, err) + _, err = service.GetMemo(ownerCtx, &v1pb.GetMemoRequest{Name: hiddenMemo.Name}) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + + received := make(chan []byte, 4) + receiver := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + body, readErr := io.ReadAll(r.Body) + if readErr != nil { + http.Error(w, readErr.Error(), http.StatusBadRequest) + return + } + received <- body + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{"code":0}`)) + })) + defer receiver.Close() + + receiverHost, _, err := net.SplitHostPort(receiver.Listener.Addr().String()) + require.NoError(t, err) + require.NoError(t, webhook.ConfigurePrivateDestinationAllowlist([]string{receiverHost})) + defer func() { + require.NoError(t, webhook.ConfigurePrivateDestinationAllowlist(nil)) + }() + _, err = service.CreateUserWebhook(ownerCtx, &v1pb.CreateUserWebhookRequest{ + Parent: BuildUserName(owner.Username), + Webhook: &v1pb.UserWebhook{ + DisplayName: "delete-capture", + Url: receiver.URL, + }, + }) + require.NoError(t, err) + + _, err = service.DeleteMemo(ownerCtx, &v1pb.DeleteMemoRequest{Name: hiddenMemo.Name}) + require.NoError(t, err, "the author retains narrow lifecycle authority after losing membership") + select { + case body := <-received: + require.Failf(t, "unreadable memo leaked through webhook", "received %s", body) + case <-time.After(500 * time.Millisecond): + } + + _, err = service.DeleteMemo(ownerCtx, &v1pb.DeleteMemoRequest{Name: readableMemo.Name}) + require.NoError(t, err) + var body []byte + select { + case body = <-received: + case <-time.After(3 * time.Second): + require.FailNow(t, "readable memo deletion webhook was not delivered") + } + payload := &webhook.WebhookRequestPayload{} + require.NoError(t, json.Unmarshal(body, payload)) + require.Equal(t, "memos.memo.deleted", payload.ActivityType) + require.NotNil(t, payload.Memo) + require.Equal(t, readableMemo.Name, payload.Memo.Name) + require.Equal(t, "readable deletion payload", payload.Memo.Content) + require.NotContains(t, string(body), hiddenMemo.Content) + + select { + case extra := <-received: + require.Failf(t, "unexpected additional deletion webhook", "received %s", extra) + case <-time.After(200 * time.Millisecond): + } +} diff --git a/server/router/api/v1/memo_mention_helpers.go b/server/router/api/v1/memo_mention_helpers.go index 15263dce..f00a0b11 100644 --- a/server/router/api/v1/memo_mention_helpers.go +++ b/server/router/api/v1/memo_mention_helpers.go @@ -7,22 +7,10 @@ import ( "github.com/pkg/errors" storepb "github.com/usememos/memos/proto/gen/store" + "github.com/usememos/memos/server/access" "github.com/usememos/memos/store" ) -// suppressMentionKey is a context key used to suppress mention notification side effects -// when CreateMemo is called internally from CreateMemoComment. -type suppressMentionKey struct{} - -func withSuppressMentionNotifications(ctx context.Context) context.Context { - return context.WithValue(ctx, suppressMentionKey{}, true) -} - -func isMentionNotificationSuppressed(ctx context.Context) bool { - v, ok := ctx.Value(suppressMentionKey{}).(bool) - return ok && v -} - func (s *APIV1Service) resolveMentionTargets(ctx context.Context, content string) (map[int32]*store.User, error) { targets := make(map[int32]*store.User) if content == "" { @@ -53,25 +41,59 @@ func (s *APIV1Service) resolveMentionTargets(ctx context.Context, content string return targets, nil } -func canUserAccessMentionContext(target *store.User, memo *store.Memo, relatedMemo *store.Memo) bool { - if target == nil || memo == nil { - return false - } - - if relatedMemo != nil { - if relatedMemo.Visibility == store.Private && target.ID != relatedMemo.CreatorID { - return false - } - } - - if memo.Visibility == store.Private && target.ID != memo.CreatorID { - return false - } - - return true +// mentionContextFacts holds the viewer-independent authorization facts for a +// mention's memo and its optional context memo. They are resolved once per +// dispatch and reused for every mentioned user. +type mentionContextFacts struct { + memo access.MemoReadFacts + related *access.MemoReadFacts } -func shouldSkipMentionInbox(target *store.User, memo *store.Memo, relatedMemo *store.Memo) bool { +func (s *APIV1Service) resolveMentionContextFacts(ctx context.Context, memo *store.Memo, relatedMemo *store.Memo) (*mentionContextFacts, error) { + memoFacts, err := access.ResolveMemoReadFacts(ctx, s.Store, memo) + if err != nil { + return nil, err + } + facts := &mentionContextFacts{memo: memoFacts} + if relatedMemo != nil { + relatedFacts, err := access.ResolveMemoReadFacts(ctx, s.Store, relatedMemo) + if err != nil { + return nil, err + } + facts.related = &relatedFacts + } + return facts, nil +} + +func (s *APIV1Service) canUserAccessMentionContext(ctx context.Context, facts *mentionContextFacts, target *store.User) bool { + if target == nil || facts == nil || facts.memo.Memo == nil { + return false + } + readContext, err := facts.memo.WithViewer(ctx, s.Store, target, false, nil) + if err != nil || !access.CheckMemoReadContext(readContext).Allowed() { + return false + } + if facts.related == nil { + return true + } + relatedContext, err := facts.related.WithViewer(ctx, s.Store, target, false, nil) + if err != nil { + return false + } + return access.CheckMemoReadContext(relatedContext).Allowed() +} + +// canUserAccessMentionMemos is the one-shot form for a single target, where +// there is no fan-out to amortize the fact resolution over. +func (s *APIV1Service) canUserAccessMentionMemos(ctx context.Context, target *store.User, memo *store.Memo, relatedMemo *store.Memo) bool { + facts, err := s.resolveMentionContextFacts(ctx, memo, relatedMemo) + if err != nil { + return false + } + return s.canUserAccessMentionContext(ctx, facts, target) +} + +func (s *APIV1Service) shouldSkipMentionInbox(ctx context.Context, facts *mentionContextFacts, target *store.User, memo *store.Memo, relatedMemo *store.Memo) bool { if target == nil || memo == nil { return true } @@ -81,11 +103,11 @@ func shouldSkipMentionInbox(target *store.User, memo *store.Memo, relatedMemo *s } // Comment creation already generates a memo-comment inbox item for the parent creator. - if relatedMemo != nil && target.ID == relatedMemo.CreatorID && memo.Visibility != store.Private && memo.CreatorID != relatedMemo.CreatorID { + if relatedMemo != nil && target.ID == relatedMemo.CreatorID && memo.CreatorID != relatedMemo.CreatorID { return true } - return !canUserAccessMentionContext(target, memo, relatedMemo) + return !s.canUserAccessMentionContext(ctx, facts, target) } func (s *APIV1Service) dispatchMemoMentionNotifications(ctx context.Context, memo *store.Memo, relatedMemo *store.Memo, previousContent string) error { @@ -106,11 +128,16 @@ func (s *APIV1Service) dispatchMemoMentionNotifications(ctx context.Context, mem return err } + facts, err := s.resolveMentionContextFacts(ctx, memo, relatedMemo) + if err != nil { + return errors.Wrap(err, "failed to resolve mention context") + } + for userID, target := range currentTargets { if _, exists := previousTargets[userID]; exists { continue } - if shouldSkipMentionInbox(target, memo, relatedMemo) { + if s.shouldSkipMentionInbox(ctx, facts, target, memo, relatedMemo) { continue } diff --git a/server/router/api/v1/memo_relation_service.go b/server/router/api/v1/memo_relation_service.go index 7607f37d..7cf261e1 100644 --- a/server/router/api/v1/memo_relation_service.go +++ b/server/router/api/v1/memo_relation_service.go @@ -2,10 +2,8 @@ package v1 import ( "context" - "fmt" "time" - "github.com/pkg/errors" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" "google.golang.org/protobuf/types/known/emptypb" @@ -33,22 +31,22 @@ func (s *APIV1Service) SetMemoRelations(ctx context.Context, request *v1pb.SetMe if memo == nil { return nil, status.Errorf(codes.NotFound, "memo not found") } - if memo.CreatorID != user.ID && !isSuperUser(user) { + if memo.CreatorID != user.ID { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } relations, err := s.prepareMemoRelations(ctx, memo, request.Relations) if err != nil { return nil, err } - updatedTs := time.Now().Unix() - if err := s.applyMemoMutation(ctx, memo, nil, &store.UpdateMemo{ID: memo.ID, UpdatedTs: &updatedTs}, nil, &relations); err != nil { + updatedTsSec := time.Now().Unix() + if err := s.applyMemoMutation(ctx, memo, nil, &store.UpdateMemo{ID: memo.ID, UpdatedTs: &updatedTsSec}, nil, &relations); err != nil { return nil, err } - updatedMemo, parentMemo, memoMessage, err := s.buildUpdatedMemoState(ctx, memo.ID) + _, _, memoMessage, err := s.buildUpdatedMemoState(ctx, memo.ID) if err != nil { return nil, status.Errorf(codes.Internal, "failed to build updated memo state") } - s.dispatchMemoUpdatedSideEffects(ctx, updatedMemo, parentMemo, memoMessage) + s.dispatchMemoUpdatedSideEffects(ctx, memoMessage) return &emptypb.Empty{}, nil } @@ -60,15 +58,20 @@ func (s *APIV1Service) prepareMemoRelations(ctx context.Context, memo *store.Mem if relation == nil || relation.RelatedMemo == nil { return nil, status.Errorf(codes.InvalidArgument, "related memo is required") } + switch relation.Type { + case v1pb.MemoRelation_REFERENCE: + // REFERENCE is the only client-mutable relation type. + case v1pb.MemoRelation_COMMENT: + // COMMENT context is immutable and may only be created atomically with a + // new memo through CreateMemoComment. + return nil, status.Errorf(codes.InvalidArgument, "COMMENT relations are output only") + default: + return nil, status.Errorf(codes.InvalidArgument, "relation type must be REFERENCE") + } // Ignore reflexive relations. if buildMemoName(memo.UID) == relation.RelatedMemo.Name { continue } - // Ignore comment relations as there's no need to update a comment's relation. - // Inserting/Deleting a comment is handled elsewhere. - if relation.Type == v1pb.MemoRelation_COMMENT { - continue - } relatedMemoUID, err := ExtractMemoUIDFromName(relation.RelatedMemo.Name) if err != nil { return nil, status.Errorf(codes.InvalidArgument, "invalid related memo name: %v", err) @@ -80,6 +83,9 @@ func (s *APIV1Service) prepareMemoRelations(ctx context.Context, memo *store.Mem if relatedMemo == nil { return nil, status.Errorf(codes.NotFound, "related memo not found") } + if err := s.checkMemoReadAccess(ctx, relatedMemo); err != nil { + return nil, err + } if _, ok := seenRelatedMemoIDs[relatedMemo.ID]; ok { continue } @@ -102,83 +108,49 @@ func (s *APIV1Service) ListMemoRelations(ctx context.Context, request *v1pb.List if err != nil { return nil, status.Errorf(codes.Internal, "failed to get memo") } - - currentUser, err := s.fetchCurrentUser(ctx) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to get user") + if memo == nil { + return nil, status.Errorf(codes.NotFound, "memo not found") } - var memoFilter string - if currentUser == nil { - memoFilter = `visibility == "PUBLIC"` - } else { - memoFilter = fmt.Sprintf(`creator_id == %d || visibility in ["PUBLIC", "PROTECTED"]`, currentUser.ID) + if err := s.checkMemoReadAccess(ctx, memo); err != nil { + return nil, err } - relationList := []*v1pb.MemoRelation{} - tempList, err := s.Store.ListMemoRelations(ctx, &store.FindMemoRelation{ - MemoID: &memo.ID, - MemoFilter: &memoFilter, - }) + relationMap, err := s.batchConvertMemoRelations(ctx, []*store.Memo{memo}, true) if err != nil { return nil, status.Errorf(codes.Internal, "failed to list memo relations: %v", err) } - for _, raw := range tempList { - relation, err := s.convertMemoRelationFromStore(ctx, raw) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to convert memo relation") - } - relationList = append(relationList, relation) + relationList := relationMap[memo.ID] + if relationList == nil { + relationList = []*v1pb.MemoRelation{} } - tempList, err = s.Store.ListMemoRelations(ctx, &store.FindMemoRelation{ - RelatedMemoID: &memo.ID, - MemoFilter: &memoFilter, - }) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to list related memo relations: %v", err) - } - for _, raw := range tempList { - relation, err := s.convertMemoRelationFromStore(ctx, raw) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to convert memo relation") + limit := normalizePageSize(request.PageSize) + offset := 0 + if request.PageToken != "" { + var token v1pb.PageToken + if err := unmarshalPageToken(request.PageToken, &token); err != nil { + return nil, status.Errorf(codes.InvalidArgument, "invalid page token: %v", err) + } + limit = normalizePageSize(token.Limit) + offset = max(int(token.Offset), 0) + } + end := min(offset+limit, len(relationList)) + if offset > len(relationList) { + offset = len(relationList) + } + nextPageToken := "" + if end < len(relationList) { + nextPageToken, err = getPageToken(limit, end) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to create page token") } - relationList = append(relationList, relation) } response := &v1pb.ListMemoRelationsResponse{ - Relations: relationList, + Relations: relationList[offset:end], + NextPageToken: nextPageToken, } return response, nil } -func (s *APIV1Service) convertMemoRelationFromStore(ctx context.Context, memoRelation *store.MemoRelation) (*v1pb.MemoRelation, error) { - memo, err := s.Store.GetMemo(ctx, &store.FindMemo{ID: &memoRelation.MemoID}) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to get memo: %v", err) - } - memoSnippet, err := s.getMemoContentSnippet(memo.Content) - if err != nil { - return nil, errors.Wrap(err, "failed to get memo content snippet") - } - relatedMemo, err := s.Store.GetMemo(ctx, &store.FindMemo{ID: &memoRelation.RelatedMemoID}) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to get related memo: %v", err) - } - relatedMemoSnippet, err := s.getMemoContentSnippet(relatedMemo.Content) - if err != nil { - return nil, errors.Wrap(err, "failed to get related memo content snippet") - } - return &v1pb.MemoRelation{ - Memo: &v1pb.MemoRelation_Memo{ - Name: fmt.Sprintf("%s%s", MemoNamePrefix, memo.UID), - Snippet: memoSnippet, - }, - RelatedMemo: &v1pb.MemoRelation_Memo{ - Name: fmt.Sprintf("%s%s", MemoNamePrefix, relatedMemo.UID), - Snippet: relatedMemoSnippet, - }, - Type: convertMemoRelationTypeFromStore(memoRelation.Type), - }, nil -} - func convertMemoRelationTypeFromStore(relationType store.MemoRelationType) v1pb.MemoRelation_Type { switch relationType { case store.MemoRelationReference: diff --git a/server/router/api/v1/memo_service.go b/server/router/api/v1/memo_service.go index 267a1da2..b76a3f45 100644 --- a/server/router/api/v1/memo_service.go +++ b/server/router/api/v1/memo_service.go @@ -3,9 +3,7 @@ package v1 import ( "context" stderrors "errors" - "fmt" "log/slog" - "strings" "time" "github.com/pkg/errors" @@ -16,73 +14,12 @@ import ( v1pb "github.com/usememos/memos/proto/gen/api/v1" storepb "github.com/usememos/memos/proto/gen/store" - "github.com/usememos/memos/server/access" "github.com/usememos/memos/server/runner/memopayload" "github.com/usememos/memos/store" ) -// suppressSSEKey is a context key used to suppress the SSE broadcast from -// CreateMemo when it is called internally (e.g., from CreateMemoComment). -type suppressSSEKey struct{} - const maxBatchGetLinkMetadata = 10 -func withSuppressSSE(ctx context.Context) context.Context { - return context.WithValue(ctx, suppressSSEKey{}, true) -} - -func isSSESuppressed(ctx context.Context) bool { - v, ok := ctx.Value(suppressSSEKey{}).(bool) - return ok && v -} - -func (s *APIV1Service) checkMemoReadAccess(ctx context.Context, memo *store.Memo) error { - return s.checkMemoReadAccessWithParent(ctx, memo, nil) -} - -func (s *APIV1Service) checkMemoAndParentReadAccess(ctx context.Context, memo *store.Memo) error { - var parent *store.Memo - if memo != nil && memo.ParentUID != nil { - var err error - parent, err = s.Store.GetMemo(ctx, &store.FindMemo{UID: memo.ParentUID}) - if err != nil { - return status.Errorf(codes.Internal, "failed to get parent memo") - } - if parent == nil { - return status.Errorf(codes.NotFound, "memo not found") - } - } - return s.checkMemoReadAccessWithParent(ctx, memo, parent) -} - -func (s *APIV1Service) checkMemoReadAccessWithParent(ctx context.Context, memo, parent *store.Memo) error { - user, err := s.fetchCurrentUser(ctx) - if err != nil { - return status.Errorf(codes.Internal, "failed to get user") - } - allowAnonymous := false - if user == nil { - allowAnonymous, err = s.Store.AllowsAnonymousAccess(ctx) - if err != nil { - return status.Errorf(codes.Internal, "failed to resolve instance access policy") - } - } - return memoAccessDecisionError(access.CheckMemoRead(memo, parent, user, allowAnonymous, nil)) -} - -func memoAccessDecisionError(decision access.MemoReadDecision) error { - switch decision.Denial { - case access.MemoReadDenialNone: - return nil - case access.MemoReadDenialNotFound: - return status.Errorf(codes.NotFound, "memo not found") - case access.MemoReadDenialUnauthenticated: - return status.Errorf(codes.Unauthenticated, "user not authenticated") - default: - return status.Errorf(codes.PermissionDenied, "permission denied") - } -} - func (s *APIV1Service) CreateMemo(ctx context.Context, request *v1pb.CreateMemoRequest) (*v1pb.Memo, error) { user, err := s.fetchCurrentUser(ctx) if err != nil { @@ -100,78 +37,21 @@ func (s *APIV1Service) CreateMemo(ctx context.Context, request *v1pb.CreateMemoR return nil, err } - create := &store.Memo{ - UID: memoUID, - CreatorID: user.ID, - Content: request.Memo.Content, - Visibility: convertVisibilityToStore(request.Memo.Visibility), - } - - // Set custom timestamps if provided in the request. - if request.Memo.CreateTime != nil && request.Memo.CreateTime.IsValid() { - createdTs := request.Memo.CreateTime.AsTime().Unix() - create.CreatedTs = createdTs - } - if request.Memo.UpdateTime != nil && request.Memo.UpdateTime.IsValid() { - updatedTs := request.Memo.UpdateTime.AsTime().Unix() - create.UpdatedTs = updatedTs - } - - contentLengthLimit, err := s.getContentLengthLimit(ctx) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to get content length limit") - } - if len(create.Content) > contentLengthLimit { - return nil, status.Errorf(codes.InvalidArgument, "content too long (max %d characters)", contentLengthLimit) - } - if err := memopayload.RebuildMemoPayload(ctx, create, s.MarkdownService); err != nil { - return nil, status.Errorf(codes.Internal, "failed to rebuild memo payload: %v", err) - } - if request.Memo.Location != nil { - create.Payload.Location = convertLocationToStore(request.Memo.Location) - } - - preparedAttachments, err := s.prepareMemoAttachments(ctx, user, create, request.Memo.Attachments) - if err != nil { - return nil, err - } - requiredAttachmentIDs, err := s.resolveMemoAttachmentReferences(create.Content, preparedAttachments.normalized) - if err != nil { - return nil, err - } - preparedRelations, err := s.prepareMemoRelations(ctx, create, request.Memo.Relations) + prepared, err := s.prepareMemoCreate(ctx, user, request.Memo, memoUID) if err != nil { return nil, err } - memo, err := s.Store.CreateMemo(ctx, create) - if err != nil { - // Check for unique constraint violation (AIP-133 compliance) - errMsg := err.Error() - if strings.Contains(errMsg, "UNIQUE constraint failed") || - strings.Contains(errMsg, "duplicate key") || - strings.Contains(errMsg, "Duplicate entry") { - return nil, status.Errorf(codes.AlreadyExists, "memo with ID %q already exists", memoUID) - } - return nil, err + if err := s.createMemoWithMutation(ctx, user, prepared.memo, nil, prepared.attachments, prepared.requiredAttachmentIDs, prepared.referenceRelations); err != nil { + return nil, mapMemoCreateError(err, memoUID, "failed to create memo") } + memo := prepared.memo - attachments := []*store.Attachment{} - if len(preparedAttachments.normalized) > 0 || len(preparedRelations) > 0 { - var relations *[]*store.MemoRelation - if len(preparedRelations) > 0 { - relations = &preparedRelations - } - if err := s.applyMemoMutation(ctx, memo, preparedAttachments, nil, requiredAttachmentIDs, relations); err != nil { - return nil, err - } - a, err := s.Store.ListAttachments(ctx, &store.FindAttachment{ - MemoID: &memo.ID, - }) - if err != nil { - return nil, errors.Wrap(err, "failed to get memo attachments") - } - attachments = a + attachments, err := s.Store.ListAttachments(ctx, &store.FindAttachment{ + MemoID: &memo.ID, + }) + if err != nil { + return nil, errors.Wrap(err, "failed to get memo attachments") } relations, err := s.loadMemoRelations(ctx, memo) @@ -187,19 +67,9 @@ func (s *APIV1Service) CreateMemo(ctx context.Context, request *v1pb.CreateMemoR slog.Warn("Failed to dispatch memo created webhook", slog.Any("err", err)) } - // Broadcast live refresh event (skipped when called from CreateMemoComment). - if !isSSESuppressed(ctx) { - s.SSEHub.Broadcast(&SSEEvent{ - Type: SSEEventMemoCreated, - Name: memoMessage.Name, - Visibility: memo.Visibility, - CreatorID: resolveSSECreatorID(memo, nil), - }) - } + s.SSEHub.publishMemoChanged() - if !isMentionNotificationSuppressed(ctx) { - s.dispatchMemoMentionNotificationsBestEffort(ctx, memo, nil, "") - } + s.dispatchMemoMentionNotificationsBestEffort(ctx, memo, nil, "") return memoMessage, nil } @@ -209,17 +79,34 @@ func (s *APIV1Service) ListMemos(ctx context.Context, request *v1pb.ListMemosReq // Exclude comments by default. ExcludeComments: true, } - currentUser, err := s.fetchCurrentUser(ctx) + accessScope, currentUser, err := s.resolveMemoAccessScope(ctx) if err != nil { - return nil, status.Errorf(codes.Internal, "failed to get user") + return nil, status.Errorf(codes.Internal, "%v", err) } - if currentUser == nil { - allowAnonymous, err := s.Store.AllowsAnonymousAccess(ctx) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to resolve instance access policy") - } - if !allowAnonymous { - return nil, status.Errorf(codes.Unauthenticated, "user not authenticated") + // An anonymous caller may only list at all when the instance permits it. + if currentUser == nil && !accessScope.AllowPublic { + return nil, status.Errorf(codes.Unauthenticated, "user not authenticated") + } + memoFind.Access = accessScope + + if request.Scope != nil { + switch scope := request.Scope.(type) { + case *v1pb.ListMemosRequest_Space: + if currentUser == nil { + return nil, status.Errorf(codes.Unauthenticated, "user not authenticated") + } + space, err := s.resolveWritableSpaceByName(ctx, scope.Space, currentUser.ID) + if err != nil { + return nil, err + } + memoFind.SpaceID = &space.ID + case *v1pb.ListMemosRequest_Unassigned: + if !scope.Unassigned { + return nil, status.Errorf(codes.InvalidArgument, "unassigned scope must be true") + } + memoFind.Unassigned = true + default: + return nil, status.Errorf(codes.InvalidArgument, "unsupported memo scope") } } @@ -253,17 +140,6 @@ func (s *APIV1Service) ListMemos(ctx context.Context, request *v1pb.ListMemosReq memoFind.Filters = append(memoFind.Filters, request.Filter) } - if currentUser == nil { - memoFind.VisibilityList = []store.Visibility{store.Public} - } else { - if memoFind.CreatorID == nil { - filter := fmt.Sprintf(`creator_id == %d || visibility in ["PUBLIC", "PROTECTED"]`, currentUser.ID) - memoFind.Filters = append(memoFind.Filters, filter) - } else if *memoFind.CreatorID != currentUser.ID { - memoFind.VisibilityList = []store.Visibility{store.Public, store.Protected} - } - } - var limit, offset int if request.PageToken != "" { var pageToken v1pb.PageToken @@ -388,7 +264,7 @@ func (s *APIV1Service) GetMemo(ctx context.Context, request *v1pb.GetMemoRequest return nil, status.Errorf(codes.NotFound, "memo not found") } - if err := s.checkMemoAndParentReadAccess(ctx, memo); err != nil { + if err := s.checkMemoReadAccess(ctx, memo); err != nil { return nil, err } @@ -417,16 +293,6 @@ func (s *APIV1Service) GetMemo(ctx context.Context, request *v1pb.GetMemoRequest } return nil, errors.Wrap(err, "failed to convert memo") } - if memo.ParentUID != nil { - parent, err := s.Store.GetMemo(ctx, &store.FindMemo{UID: memo.ParentUID}) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to get parent memo") - } - if parent == nil { - return nil, status.Errorf(codes.NotFound, "memo not found") - } - memoMessage.Visibility = convertVisibilityFromStore(parent.Visibility) - } return memoMessage, nil } @@ -458,14 +324,64 @@ func (s *APIV1Service) UpdateMemo(ctx context.Context, request *v1pb.UpdateMemoR if user == nil { return nil, status.Errorf(codes.Unauthenticated, "user not authenticated") } - // Only the creator or admin can update the memo. - if memo.CreatorID != user.ID && !isSuperUser(user) { + // Application administrators are not implicit memo collaborators. Ordinary + // content updates remain author-controlled. + if memo.CreatorID != user.ID { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } update := &store.UpdateMemo{ ID: memo.ID, } + updatePaths := make(map[string]bool, len(request.UpdateMask.Paths)) + for _, path := range request.UpdateMask.Paths { + updatePaths[path] = true + } + lifecycleOnly := updatePaths["space"] + for path := range updatePaths { + if path != "space" && path != "visibility" { + lifecycleOnly = false + } + } + nextSpaceID := memo.SpaceID + if updatePaths["space"] { + if request.Memo.Space == nil || request.Memo.GetSpace() == "" { + nextSpaceID = nil + update.ClearSpace = true + } else { + target, err := s.resolveWritableSpaceByName(ctx, request.Memo.GetSpace(), user.ID) + if err != nil { + return nil, err + } + nextSpaceID = &target.ID + update.SpaceID = &target.ID + update.ClearSpace = false + } + } + + nextVisibility := memo.Visibility + if updatePaths["visibility"] { + nextVisibility, err = validateUpdateMemoVisibility(request.Memo.Visibility) + if err != nil { + return nil, err + } + update.Visibility = &nextVisibility + } + spaceChanged := !sameOptionalInt32(memo.SpaceID, nextSpaceID) + // A removed author receives a lifecycle exception only for a real withdraw + // or move. Merely including the current Space in the mask must not smuggle + // an audience-only mutation past membership checks. + lifecycleOnly = lifecycleOnly && spaceChanged + if nextVisibility == store.SpaceAudience && nextSpaceID == nil { + return nil, status.Errorf(codes.InvalidArgument, "SPACE visibility requires a space") + } + if memo.Visibility == store.SpaceAudience && spaceChanged && !updatePaths["visibility"] { + return nil, status.Errorf(codes.InvalidArgument, "moving a memo with SPACE visibility requires an explicit visibility update") + } + if memo.Visibility == store.SpaceAudience && nextSpaceID == nil && nextVisibility == store.SpaceAudience { + return nil, status.Errorf(codes.InvalidArgument, "unassigning a memo with SPACE visibility requires a replacement visibility") + } + update.Policy = memoWritePolicy(user.ID, lifecycleOnly) previousContent := memo.Content contentUpdated := false attachmentsUpdated := false @@ -477,6 +393,11 @@ func (s *APIV1Service) UpdateMemo(ctx context.Context, request *v1pb.UpdateMemoR } for _, path := range request.UpdateMask.Paths { + // Collaboration fields were validated together above so placement and + // audience transitions cannot be observed independently. + if path == "visibility" || path == "space" { + continue + } if path == "content" { contentUpdated = true contentLengthLimit, err := s.getContentLengthLimit(ctx) @@ -492,19 +413,6 @@ func (s *APIV1Service) UpdateMemo(ctx context.Context, request *v1pb.UpdateMemoR } update.Content = &nextMemo.Content update.Payload = nextMemo.Payload - } else if path == "visibility" { - visibility := convertVisibilityToStore(request.Memo.Visibility) - if memo.ParentUID != nil { - parentMemo, err := s.Store.GetMemo(ctx, &store.FindMemo{UID: memo.ParentUID}) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to get parent memo") - } - if parentMemo == nil { - return nil, status.Errorf(codes.NotFound, "memo not found") - } - visibility = parentMemo.Visibility - } - update.Visibility = &visibility } else if path == "pinned" { update.Pinned = &request.Memo.Pinned } else if path == "state" { @@ -517,11 +425,11 @@ func (s *APIV1Service) UpdateMemo(ctx context.Context, request *v1pb.UpdateMemoR createdTs := request.Memo.CreateTime.AsTime().Unix() update.CreatedTs = &createdTs } else if path == "update_time" { - updatedTs := time.Now().Unix() + updatedTsSec := time.Now().Unix() if request.Memo.UpdateTime != nil { - updatedTs = request.Memo.UpdateTime.AsTime().Unix() + updatedTsSec = request.Memo.UpdateTime.AsTime().Unix() } - update.UpdatedTs = &updatedTs + update.UpdatedTs = &updatedTsSec } else if path == "display_time" { return nil, status.Errorf(codes.InvalidArgument, "display_time is not supported") } else if path == "location" { @@ -534,6 +442,8 @@ func (s *APIV1Service) UpdateMemo(ctx context.Context, request *v1pb.UpdateMemoR attachmentsUpdated = true } else if path == "relations" { relationsUpdated = true + } else { + return nil, status.Errorf(codes.InvalidArgument, "invalid update path: %s", path) } } @@ -577,23 +487,17 @@ func (s *APIV1Service) UpdateMemo(ctx context.Context, request *v1pb.UpdateMemoR return nil, err } } else if err = s.Store.UpdateMemo(ctx, update); err != nil { - return nil, status.Errorf(codes.Internal, "failed to update memo") + return nil, mapMemoWriteError(err, "failed to update memo") } - memo, err = s.Store.GetMemo(ctx, &store.FindMemo{ - ID: &memo.ID, - }) - if err != nil { - return nil, errors.Wrap(err, "failed to get memo") - } - memo, parentMemo, memoMessage, err := s.buildUpdatedMemoState(ctx, memo.ID) + memo, commentContext, memoMessage, err := s.buildUpdatedMemoState(ctx, memo.ID) if err != nil { return nil, errors.Wrap(err, "failed to build updated memo state") } if contentUpdated { - s.dispatchMemoMentionNotificationsBestEffort(ctx, memo, parentMemo, previousContent) + s.dispatchMemoMentionNotificationsBestEffort(ctx, memo, commentContext, previousContent) } - s.dispatchMemoUpdatedSideEffects(ctx, memo, parentMemo, memoMessage) + s.dispatchMemoUpdatedSideEffects(ctx, memoMessage) return memoMessage, nil } @@ -620,57 +524,55 @@ func (s *APIV1Service) DeleteMemo(ctx context.Context, request *v1pb.DeleteMemoR if user == nil { return nil, status.Errorf(codes.Unauthenticated, "user not authenticated") } - // Only the creator or admin can update the memo. - if memo.CreatorID != user.ID && !isSuperUser(user) { + // Application administrators do not receive ordinary content-deletion + // authority merely from their instance role. + if memo.CreatorID != user.ID { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } - - reactions, err := s.Store.ListReactions(ctx, &store.FindReaction{ - MemoID: &memo.ID, - }) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to list reactions") + var deletedMemoMessage *v1pb.Memo + // Deletion is a narrow author lifecycle capability and may remain available + // after the author loses read access to a memo with the SPACE audience. Only + // build a content-bearing webhook payload when the author can still read the + // memo immediately before deletion. + if s.checkMemoReadAccess(ctx, memo) == nil { + reactions, err := s.Store.ListReactions(ctx, &store.FindReaction{MemoID: &memo.ID}) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to list reactions") + } + attachments, err := s.Store.ListAttachments(ctx, &store.FindAttachment{MemoID: &memo.ID}) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to list attachments") + } + deleteRelations, _ := s.loadMemoRelations(ctx, memo) + if memoMessage, err := s.convertMemoFromStore(ctx, memo, reactions, attachments, deleteRelations); err == nil { + deletedMemoMessage = memoMessage + } } - attachments, err := s.Store.ListAttachments(ctx, &store.FindAttachment{ - MemoID: &memo.ID, - }) + deleteResult, err := s.Store.DeleteMemoWithPolicy(ctx, &store.DeleteMemoWithPolicy{MemoID: memo.ID, ActorUserID: user.ID}) if err != nil { - return nil, status.Errorf(codes.Internal, "failed to list attachments") + switch { + case stderrors.Is(err, store.ErrMemoPermissionDenied): + return nil, status.Error(codes.PermissionDenied, "permission denied") + case stderrors.Is(err, store.ErrMemoMutationConflict): + return nil, status.Error(codes.FailedPrecondition, "memo changed or no longer exists") + default: + return nil, status.Errorf(codes.Internal, "failed to delete memo: %v", err) + } + } + if deleteResult == nil { + return nil, status.Error(codes.Internal, "memo was deleted without authorization state") } - deleteRelations, _ := s.loadMemoRelations(ctx, memo) - if memoMessage, err := s.convertMemoFromStore(ctx, memo, reactions, attachments, deleteRelations); err == nil { - // Try to dispatch webhook when memo is deleted. - if err := s.DispatchMemoDeletedWebhook(ctx, memoMessage); err != nil { + s.SSEHub.publishMemoChanged() + if deletedMemoMessage != nil && deleteResult.ActorCanRead { + if err := s.DispatchMemoDeletedWebhook(ctx, deletedMemoMessage); err != nil { slog.Warn("Failed to dispatch memo deleted webhook", slog.Any("err", err)) } } - - // Delete memo comments first (store.DeleteMemo handles their reactions, relations and attachments) - commentType := store.MemoRelationComment - relations, err := s.Store.ListMemoRelations(ctx, &store.FindMemoRelation{RelatedMemoID: &memo.ID, Type: &commentType}) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to list memo comments") + if err := s.cleanupDeletedAttachmentStorage(ctx, deleteResult.Attachments); err != nil { + return nil, status.Errorf(codes.Internal, "memo was deleted but attachment storage cleanup failed: %v", err) } - for _, relation := range relations { - if err := s.Store.DeleteMemo(ctx, &store.DeleteMemo{ID: relation.MemoID}); err != nil { - return nil, status.Errorf(codes.Internal, "failed to delete memo comment") - } - } - - // Delete the memo (store.DeleteMemo handles reaction, relation and attachment cleanup) - if err = s.Store.DeleteMemo(ctx, &store.DeleteMemo{ID: memo.ID}); err != nil { - return nil, status.Errorf(codes.Internal, "failed to delete memo") - } - - // Broadcast live refresh event. - s.SSEHub.Broadcast(&SSEEvent{ - Type: SSEEventMemoDeleted, - Name: request.Name, - Visibility: memo.Visibility, - CreatorID: resolveSSECreatorID(memo, nil), - }) return &emptypb.Empty{}, nil } diff --git a/server/router/api/v1/memo_service_comments.go b/server/router/api/v1/memo_service_comments.go index fb3827fd..1fdd64ba 100644 --- a/server/router/api/v1/memo_service_comments.go +++ b/server/router/api/v1/memo_service_comments.go @@ -8,7 +8,6 @@ import ( "github.com/pkg/errors" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" - "google.golang.org/protobuf/proto" v1pb "github.com/usememos/memos/proto/gen/api/v1" storepb "github.com/usememos/memos/proto/gen/store" @@ -37,7 +36,7 @@ func (s *APIV1Service) CreateMemoComment(ctx context.Context, request *v1pb.Crea if user == nil { return nil, status.Errorf(codes.Unauthenticated, "user not authenticated") } - if err := s.checkMemoAndParentReadAccess(ctx, relatedMemo); err != nil { + if err := s.checkMemoReadAccess(ctx, relatedMemo); err != nil { return nil, err } if relatedMemo.RowStatus != store.Normal { @@ -47,59 +46,41 @@ func (s *APIV1Service) CreateMemoComment(ctx context.Context, request *v1pb.Crea return nil, status.Errorf(codes.InvalidArgument, "comment is required") } - comment, ok := proto.Clone(request.Comment).(*v1pb.Memo) - if !ok { - return nil, status.Errorf(codes.Internal, "failed to clone memo comment") - } - comment.Visibility = convertVisibilityFromStore(relatedMemo.Visibility) - - // Create the memo comment first; suppress the generic memo.created SSE event - // since CreateMemoComment broadcasts memo.comment.created for the parent instead. - memoComment, err := s.CreateMemo(withSuppressMentionNotifications(withSuppressSSE(ctx)), &v1pb.CreateMemoRequest{ - Memo: comment, - MemoId: request.CommentId, - }) + memoUID, err = ValidateAndGenerateUID(request.CommentId) if err != nil { - return nil, status.Errorf(codes.Internal, "failed to create memo") + return nil, err } - memoUID, err = ExtractMemoUIDFromName(memoComment.Name) + if memoUID == relatedMemo.UID { + return nil, status.Error(codes.InvalidArgument, "a memo cannot comment on itself") + } + prepared, err := s.prepareMemoCreate(ctx, user, request.Comment, memoUID) if err != nil { - return nil, status.Errorf(codes.InvalidArgument, "invalid memo name: %v", err) + return nil, err } - memo, err := s.Store.GetMemo(ctx, &store.FindMemo{UID: &memoUID}) + if err := s.createMemoWithMutation(ctx, user, prepared.memo, &relatedMemo.ID, prepared.attachments, prepared.requiredAttachmentIDs, prepared.referenceRelations); err != nil { + return nil, mapMemoCreateError(err, memoUID, "failed to create memo comment") + } + memo := prepared.memo + attachments, err := s.Store.ListAttachments(ctx, &store.FindAttachment{MemoID: &memo.ID}) if err != nil { - return nil, status.Errorf(codes.Internal, "failed to get memo") + return nil, status.Errorf(codes.Internal, "failed to load memo comment attachments") } - - // Build the relation between the comment memo and the original memo. - _, err = s.Store.UpsertMemoRelation(ctx, &store.MemoRelation{ - MemoID: memo.ID, - RelatedMemoID: relatedMemo.ID, - Type: store.MemoRelationComment, - }) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to create memo relation") - } - - // The comment memo was converted before the relation above existed, so its - // Relations slice is empty. Reload the relations now so that both the API - // response and the memo.comment.created webhook payload carry the relation - // to the parent memo. relations, err := s.loadMemoRelations(ctx, memo) if err != nil { return nil, status.Errorf(codes.Internal, "failed to load memo relations") } - memoComment.Relations = relations - - creator, err := ResolveUserByName(ctx, s.Store, memoComment.Creator) + memoComment, err := s.convertMemoFromStore(ctx, memo, nil, attachments, relations) if err != nil { - return nil, status.Errorf(codes.InvalidArgument, "invalid memo creator") + return nil, status.Errorf(codes.Internal, "failed to convert memo comment") } - if creator == nil { - return nil, status.Errorf(codes.NotFound, "memo creator not found") + + creatorID := user.ID + relatedCreator, err := s.Store.GetUser(ctx, &store.FindUser{ID: &relatedMemo.CreatorID}) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to get related memo creator") } - creatorID := creator.ID - if memoComment.Visibility != v1pb.Visibility_PRIVATE && creatorID != relatedMemo.CreatorID { + if creatorID != relatedMemo.CreatorID && + s.canUserAccessMentionMemos(ctx, relatedCreator, memo, relatedMemo) { if _, err := s.createInboxWithEmailNotification(ctx, &store.Inbox{ SenderID: creatorID, ReceiverID: relatedMemo.CreatorID, @@ -118,19 +99,13 @@ func (s *APIV1Service) CreateMemoComment(ctx context.Context, request *v1pb.Crea } } - if err := s.DispatchMemoCommentCreatedWebhook(ctx, memoComment, relatedMemo.CreatorID); err != nil { + if err := s.DispatchMemoCommentCreatedWebhook(ctx, memo, relatedMemo, relatedMemo.CreatorID); err != nil { slog.Warn("Failed to dispatch memo comment created webhook", slog.Any("err", err)) } s.dispatchMemoMentionNotificationsBestEffort(ctx, memo, relatedMemo, "") - // Broadcast live refresh event for the parent memo so subscribers see the new comment. - s.SSEHub.Broadcast(&SSEEvent{ - Type: SSEEventMemoCommentCreated, - Name: request.Name, - Visibility: relatedMemo.Visibility, - CreatorID: relatedMemo.CreatorID, - }) + s.SSEHub.publishMemoChanged() return memoComment, nil } @@ -150,8 +125,11 @@ func (s *APIV1Service) ListMemoComments(ctx context.Context, request *v1pb.ListM if err := s.checkMemoReadAccess(ctx, memo); err != nil { return nil, err } + accessScope, _, err := s.resolveMemoAccessScope(ctx) + if err != nil { + return nil, status.Errorf(codes.Internal, "%v", err) + } - memoRelationComment := store.MemoRelationComment var limit, offset int if request.PageToken != "" { var pageToken v1pb.PageToken @@ -165,27 +143,27 @@ func (s *APIV1Service) ListMemoComments(ctx context.Context, request *v1pb.ListM } limitPlusOne := limit + 1 normal := store.Normal - memoRelations, err := s.Store.ListMemoRelations(ctx, &store.FindMemoRelation{ - RelatedMemoID: &memo.ID, - Type: &memoRelationComment, - SourceMemoRowStatus: &normal, - Limit: &limitPlusOne, - Offset: &offset, + memos, err := s.Store.ListMemos(ctx, &store.FindMemo{ + CommentContextMemoID: &memo.ID, + RowStatus: &normal, + Access: accessScope, + Limit: &limitPlusOne, + Offset: &offset, }) if err != nil { - return nil, status.Errorf(codes.Internal, "failed to list memo relations") + return nil, status.Errorf(codes.Internal, "failed to list memo comments") } nextPageToken := "" - if len(memoRelations) == limitPlusOne { - memoRelations = memoRelations[:limit] + if len(memos) == limitPlusOne { + memos = memos[:limit] nextPageToken, err = getPageToken(limit, offset+limit) if err != nil { return nil, status.Errorf(codes.Internal, "failed to get next page token, error: %v", err) } } - if len(memoRelations) == 0 { + if len(memos) == 0 { response := &v1pb.ListMemoCommentsResponse{ Memos: []*v1pb.Memo{}, NextPageToken: nextPageToken, @@ -193,15 +171,6 @@ func (s *APIV1Service) ListMemoComments(ctx context.Context, request *v1pb.ListM return response, nil } - memoRelationIDs := make([]int32, 0, len(memoRelations)) - for _, m := range memoRelations { - memoRelationIDs = append(memoRelationIDs, m.MemoID) - } - memos, err := s.Store.ListMemos(ctx, &store.FindMemo{IDList: memoRelationIDs, RowStatus: &normal}) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to list memos") - } - memoIDs := make([]int32, 0, len(memos)) for _, memo := range memos { @@ -261,7 +230,6 @@ func (s *APIV1Service) ListMemoComments(ctx context.Context, request *v1pb.ListM } return nil, errors.Wrap(err, "failed to convert memo") } - memoMessage.Visibility = convertVisibilityFromStore(memo.Visibility) memosResponse = append(memosResponse, memoMessage) } diff --git a/server/router/api/v1/memo_service_converter.go b/server/router/api/v1/memo_service_converter.go index 6ca6593b..988c26f7 100644 --- a/server/router/api/v1/memo_service_converter.go +++ b/server/router/api/v1/memo_service_converter.go @@ -8,10 +8,13 @@ import ( "time" "github.com/pkg/errors" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" "google.golang.org/protobuf/types/known/timestamppb" v1pb "github.com/usememos/memos/proto/gen/api/v1" storepb "github.com/usememos/memos/proto/gen/store" + "github.com/usememos/memos/server/access" "github.com/usememos/memos/store" ) @@ -44,6 +47,19 @@ func (s *APIV1Service) convertMemoFromStoreWithCreators(ctx context.Context, mem Visibility: convertVisibilityFromStore(memo.Visibility), Pinned: memo.Pinned, } + // An assigned memo needs a read context for its placement projection; an + // unassigned memo needs none. + var readContext access.MemoReadContext + if memo.SpaceID != nil { + resolved, err := s.buildMemoReadContext(ctx, memo, nil) + if err != nil { + return nil, errors.Wrap(err, "failed to resolve memo access") + } + readContext = resolved + } + if err := s.projectMemoCollaborationContext(ctx, memo, memoMessage, readContext); err != nil { + return nil, errors.Wrap(err, "failed to project memo collaboration context") + } if memo.Payload != nil { memoMessage.Tags = memo.Payload.Tags memoMessage.Property = convertMemoPropertyFromStore(memo.Payload.Property) @@ -51,10 +67,18 @@ func (s *APIV1Service) convertMemoFromStoreWithCreators(ctx context.Context, mem } if memo.ParentUID != nil { - parentName := buildMemoName(*memo.ParentUID) - memoMessage.Parent = &parentName + contextMemo, err := s.Store.GetMemo(ctx, &store.FindMemo{UID: memo.ParentUID}) + if err != nil { + return nil, errors.Wrap(err, "failed to resolve comment context") + } + if contextMemo != nil && s.checkMemoReadAccess(ctx, contextMemo) == nil { + parentName := buildMemoName(*memo.ParentUID) + memoMessage.Parent = &parentName + } } + // Reactions have no independent audience and are readable whenever this + // memo is readable. Conversion is reached only after memo authorization. reactionMessages, err := s.convertReactionsFromStoreWithCreators(ctx, reactions, creatorMap, name) if err != nil { return nil, errors.Wrap(err, "failed to convert reactions") @@ -82,6 +106,40 @@ func (s *APIV1Service) convertMemoFromStoreWithCreators(ctx context.Context, mem return memoMessage, nil } +func (s *APIV1Service) projectMemoCollaborationContext(ctx context.Context, memo *store.Memo, message *v1pb.Memo, readContext access.MemoReadContext) error { + if memo.SpaceID == nil { + return nil + } + if !readContext.SpaceValid { + // Placement is not an additional read gate for PRIVATE, PROTECTED, or + // PUBLIC. Omit a dangling placement rather than turning it into a second + // audience restriction. SPACE already failed closed in the read policy. + if memo.Visibility == store.SpaceAudience { + return errors.New("memo has invalid space placement") + } + return nil + } + // Placement is visible to the author and to active members only; a + // non-member reading an assigned PUBLIC memo learns nothing about its Space. + viewer := readContext.Viewer + if viewer == nil || (viewer.ID != memo.CreatorID && !readContext.ViewerSpaceMember) { + return nil + } + space, err := s.Store.GetSpace(ctx, &store.FindSpace{ID: memo.SpaceID}) + if err != nil { + return err + } + if space == nil { + if memo.Visibility == store.SpaceAudience { + return errors.New("memo has invalid space placement") + } + return nil + } + spaceName := buildSpaceName(space.UID) + message.Space = &spaceName + return nil +} + func (s *APIV1Service) listUsersByIDWithExisting(ctx context.Context, userIDs []int32, existing map[int32]*store.User) (map[int32]*store.User, error) { usersByID := make(map[int32]*store.User, len(existing)+len(userIDs)) for userID, user := range existing { @@ -174,15 +232,9 @@ func (s *APIV1Service) batchConvertMemoRelations(ctx context.Context, memos []*s return map[int32][]*v1pb.MemoRelation{}, nil } - currentUser, err := s.fetchCurrentUser(ctx) + accessScope, _, err := s.resolveMemoAccessScope(ctx) if err != nil { - return nil, errors.Wrap(err, "failed to get user") - } - var memoFilter string - if currentUser == nil { - memoFilter = `visibility == "PUBLIC"` - } else { - memoFilter = fmt.Sprintf(`creator_id == %d || visibility in ["PUBLIC", "PROTECTED"]`, currentUser.ID) + return nil, err } memoIDs := make([]int32, len(memos)) @@ -194,14 +246,12 @@ func (s *APIV1Service) batchConvertMemoRelations(ctx context.Context, memos []*s outgoingRelations, err := s.Store.ListMemoRelations(ctx, &store.FindMemoRelation{ SourceMemoIDList: memoIDs, - MemoFilter: &memoFilter, }) if err != nil { return nil, errors.Wrap(err, "failed to batch list outgoing memo relations") } incomingRelations, err := s.Store.ListMemoRelations(ctx, &store.FindMemoRelation{ RelatedMemoIDList: memoIDs, - MemoFilter: &memoFilter, }) if err != nil { return nil, errors.Wrap(err, "failed to batch list incoming memo relations") @@ -236,7 +286,7 @@ func (s *APIV1Service) batchConvertMemoRelations(ctx context.Context, memos []*s for id := range neededIDs { extraIDs = append(extraIDs, id) } - extraFind := &store.FindMemo{IDList: extraIDs, ExcludeContent: !includeSnippets} + extraFind := &store.FindMemo{IDList: extraIDs, ExcludeContent: !includeSnippets, Access: accessScope} extraMemos, err := s.Store.ListMemos(ctx, extraFind) if err != nil { return nil, errors.Wrap(err, "failed to batch fetch related memos") @@ -354,18 +404,31 @@ func convertVisibilityFromStore(visibility store.Visibility) v1pb.Visibility { return v1pb.Visibility_PROTECTED case store.Public: return v1pb.Visibility_PUBLIC + case store.SpaceAudience: + return v1pb.Visibility_SPACE default: return v1pb.Visibility_VISIBILITY_UNSPECIFIED } } -func convertVisibilityToStore(visibility v1pb.Visibility) store.Visibility { +func validateCreateMemoVisibility(visibility v1pb.Visibility) (store.Visibility, error) { switch visibility { + case v1pb.Visibility_VISIBILITY_UNSPECIFIED, v1pb.Visibility_PRIVATE: + return store.Private, nil case v1pb.Visibility_PROTECTED: - return store.Protected + return store.Protected, nil case v1pb.Visibility_PUBLIC: - return store.Public + return store.Public, nil + case v1pb.Visibility_SPACE: + return store.SpaceAudience, nil default: - return store.Private + return "", status.Errorf(codes.InvalidArgument, "invalid memo visibility") } } + +func validateUpdateMemoVisibility(visibility v1pb.Visibility) (store.Visibility, error) { + if visibility == v1pb.Visibility_VISIBILITY_UNSPECIFIED { + return "", status.Errorf(codes.InvalidArgument, "visibility must be specified") + } + return validateCreateMemoVisibility(visibility) +} diff --git a/server/router/api/v1/memo_service_webhooks.go b/server/router/api/v1/memo_service_webhooks.go index 40fbb4e2..dd441910 100644 --- a/server/router/api/v1/memo_service_webhooks.go +++ b/server/router/api/v1/memo_service_webhooks.go @@ -9,6 +9,9 @@ import ( "github.com/usememos/memos/internal/webhook" v1pb "github.com/usememos/memos/proto/gen/api/v1" + "github.com/usememos/memos/server/access" + "github.com/usememos/memos/server/auth" + "github.com/usememos/memos/store" ) // DispatchMemoCreatedWebhook dispatches a webhook when a memo is created. @@ -27,13 +30,54 @@ func (s *APIV1Service) DispatchMemoDeletedWebhook(ctx context.Context, memo *v1p } // DispatchMemoCommentCreatedWebhook dispatches webhook to the related memo owner when a comment is created. -func (s *APIV1Service) DispatchMemoCommentCreatedWebhook(ctx context.Context, commentMemo *v1pb.Memo, relatedMemoCreatorID int32) error { +func (s *APIV1Service) DispatchMemoCommentCreatedWebhook( + ctx context.Context, + comment, relatedMemo *store.Memo, + relatedMemoCreatorID int32, +) error { + receiver, err := s.Store.GetUser(ctx, &store.FindUser{ID: &relatedMemoCreatorID}) + if err != nil { + return err + } + if receiver == nil || receiver.RowStatus != store.Normal { + return nil + } + for _, subject := range []*store.Memo{comment, relatedMemo} { + readContext, err := s.buildMemoReadContextForViewer(ctx, subject, receiver, false, nil) + if err != nil { + return errors.Wrap(err, "failed to resolve webhook subject access") + } + decision := access.CheckMemoReadContext(readContext) + if !decision.Allowed() { + return nil + } + } + // The request context belongs to the comment author, but the webhook belongs + // to the context memo's author. Build the prepared payload under the receiver's + // identity before it enters the existing asynchronous delivery queue. + receiverCtx := auth.SetUserInContext(ctx, receiver, "") + reactions, err := s.Store.ListReactions(receiverCtx, &store.FindReaction{MemoID: &comment.ID}) + if err != nil { + return err + } + attachments, err := s.Store.ListAttachments(receiverCtx, &store.FindAttachment{MemoID: &comment.ID}) + if err != nil { + return err + } + relations, err := s.loadMemoRelations(receiverCtx, comment) + if err != nil { + return err + } + commentMessage, err := s.convertMemoFromStore(receiverCtx, comment, reactions, attachments, relations) + if err != nil { + return err + } webhooks, err := s.Store.GetUserWebhooks(ctx, relatedMemoCreatorID) if err != nil { return err } for _, hook := range webhooks { - payload, err := convertMemoToWebhookPayload(commentMemo) + payload, err := convertMemoToWebhookPayload(commentMessage) if err != nil { return errors.Wrap(err, "failed to convert memo to webhook payload") } @@ -66,8 +110,6 @@ func (s *APIV1Service) dispatchMemoRelatedWebhook(ctx context.Context, memo *v1p payload.ActivityType = activityType payload.URL = hook.Url payload.SigningSecret = hook.SigningSecret - - // Use asynchronous webhook dispatch webhook.PostAsync(payload) } return nil diff --git a/server/router/api/v1/memo_share_service.go b/server/router/api/v1/memo_share_service.go index 81387099..9771819d 100644 --- a/server/router/api/v1/memo_share_service.go +++ b/server/router/api/v1/memo_share_service.go @@ -15,11 +15,12 @@ import ( "github.com/pkg/errors" v1pb "github.com/usememos/memos/proto/gen/api/v1" + "github.com/usememos/memos/server/access" "github.com/usememos/memos/store" ) // CreateMemoShare creates an opaque share link for a memo. -// Only the memo's creator or an admin may call this. +// Only the memo's creator may call this. func (s *APIV1Service) CreateMemoShare(ctx context.Context, request *v1pb.CreateMemoShareRequest) (*v1pb.MemoShare, error) { user, err := s.fetchCurrentUser(ctx) if err != nil { @@ -40,16 +41,15 @@ func (s *APIV1Service) CreateMemoShare(ctx context.Context, request *v1pb.Create if memo == nil { return nil, status.Errorf(codes.NotFound, "memo not found") } - if memo.ParentUID != nil { - return nil, status.Errorf(codes.FailedPrecondition, "comments cannot be shared independently") - } if memo.RowStatus != store.Normal { return nil, status.Errorf(codes.FailedPrecondition, "only active memos can be shared") } - if memo.CreatorID != user.ID && !isSuperUser(user) { + if memo.CreatorID != user.ID { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } - + if memo.Visibility == store.SpaceAudience { + return nil, status.Errorf(codes.FailedPrecondition, "SPACE audience memos cannot be shared") + } var expiresTs *int64 if request.MemoShare != nil && request.MemoShare.ExpireTime != nil { ts := request.MemoShare.ExpireTime.AsTime().Unix() @@ -60,21 +60,24 @@ func (s *APIV1Service) CreateMemoShare(ctx context.Context, request *v1pb.Create } // Generate a URL-safe token using shortuuid (base57-encoded UUID v4, 22 chars, 122-bit entropy). + policy := memoWritePolicy(user.ID, false) + policy.CreatingShare = true ms, err := s.Store.CreateMemoShare(ctx, &store.MemoShare{ UID: shortuuid.New(), MemoID: memo.ID, CreatorID: user.ID, ExpiresTs: expiresTs, + Policy: policy, }) if err != nil { - return nil, status.Errorf(codes.Internal, "failed to create memo share") + return nil, mapMemoWriteError(err, "failed to create memo share") } return convertMemoShareFromStore(ms, memo.UID), nil } // ListMemoShares lists all share links for a memo. -// Only the memo's creator or an admin may call this. +// Only the memo's creator may call this. func (s *APIV1Service) ListMemoShares(ctx context.Context, request *v1pb.ListMemoSharesRequest) (*v1pb.ListMemoSharesResponse, error) { user, err := s.fetchCurrentUser(ctx) if err != nil { @@ -95,9 +98,12 @@ func (s *APIV1Service) ListMemoShares(ctx context.Context, request *v1pb.ListMem if memo == nil { return nil, status.Errorf(codes.NotFound, "memo not found") } - if memo.CreatorID != user.ID && !isSuperUser(user) { + if memo.CreatorID != user.ID { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } + if err := s.requireAssignedMemoWritable(ctx, memo, user.ID); err != nil { + return nil, err + } shares, err := s.Store.ListMemoShares(ctx, &store.FindMemoShare{MemoID: &memo.ID}) if err != nil { @@ -112,7 +118,7 @@ func (s *APIV1Service) ListMemoShares(ctx context.Context, request *v1pb.ListMem } // DeleteMemoShare revokes a share link. -// Only the memo's creator or an admin may call this. +// Only the memo's creator may call this. func (s *APIV1Service) DeleteMemoShare(ctx context.Context, request *v1pb.DeleteMemoShareRequest) (*emptypb.Empty, error) { user, err := s.fetchCurrentUser(ctx) if err != nil { @@ -136,10 +142,9 @@ func (s *APIV1Service) DeleteMemoShare(ctx context.Context, request *v1pb.Delete if memo == nil { return nil, status.Errorf(codes.NotFound, "memo not found") } - if memo.CreatorID != user.ID && !isSuperUser(user) { + if memo.CreatorID != user.ID { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } - ms, err := s.Store.GetMemoShare(ctx, &store.FindMemoShare{UID: &shareToken}) if err != nil { return nil, status.Errorf(codes.Internal, "failed to get memo share") @@ -148,8 +153,12 @@ func (s *APIV1Service) DeleteMemoShare(ctx context.Context, request *v1pb.Delete return nil, status.Errorf(codes.NotFound, "memo share not found") } - if err := s.Store.DeleteMemoShare(ctx, &store.DeleteMemoShare{UID: &shareToken}); err != nil { - return nil, status.Errorf(codes.Internal, "failed to delete memo share") + if err := s.Store.DeleteMemoShare(ctx, &store.DeleteMemoShare{ + UID: &shareToken, + MemoID: &memo.ID, + Policy: memoWritePolicy(user.ID, false), + }); err != nil { + return nil, mapMemoWriteError(err, "failed to delete memo share") } return &emptypb.Empty{}, nil } @@ -167,9 +176,13 @@ func (s *APIV1Service) GetSharedMemo(ctx context.Context, request *v1pb.GetShare return nil, status.Errorf(codes.Internal, "failed to get memo") } // Treat archived or missing memos the same as an invalid token — no information leakage. - if memo == nil || memo.RowStatus != store.Normal || memo.ParentUID != nil { + if memo == nil || memo.RowStatus != store.Normal || memo.Visibility == store.SpaceAudience { return nil, status.Errorf(codes.NotFound, "not found") } + readContext, err := s.buildMemoReadContext(ctx, memo, &ms.MemoID) + if err != nil || !access.CheckMemoReadContext(readContext).Allowed() { + return nil, status.Error(codes.NotFound, "not found") + } reactions, err := s.Store.ListReactions(ctx, &store.FindReaction{ MemoID: &memo.ID, diff --git a/server/router/api/v1/memo_update_helpers.go b/server/router/api/v1/memo_update_helpers.go index 646ebea7..456a8d02 100644 --- a/server/router/api/v1/memo_update_helpers.go +++ b/server/router/api/v1/memo_update_helpers.go @@ -40,35 +40,24 @@ func (s *APIV1Service) buildUpdatedMemoState(ctx context.Context, memoID int32) return nil, nil, nil, errors.Wrap(err, "failed to convert memo") } - var parentMemo *store.Memo + var commentContext *store.Memo if memo.ParentUID != nil { - parentMemo, err = s.Store.GetMemo(ctx, &store.FindMemo{UID: memo.ParentUID}) + commentContext, err = s.Store.GetMemo(ctx, &store.FindMemo{UID: memo.ParentUID}) if err != nil { - return nil, nil, nil, errors.Wrap(err, "failed to get parent memo") + return nil, nil, nil, errors.Wrap(err, "failed to get comment context") } - if parentMemo == nil { - return nil, nil, nil, errors.New("parent memo not found") - } - memoMessage.Visibility = convertVisibilityFromStore(parentMemo.Visibility) } - return memo, parentMemo, memoMessage, nil + return memo, commentContext, memoMessage, nil } -func (s *APIV1Service) dispatchMemoUpdatedSideEffects(ctx context.Context, memo *store.Memo, parentMemo *store.Memo, memoMessage *v1pb.Memo) { +func (s *APIV1Service) dispatchMemoUpdatedSideEffects( + ctx context.Context, + memoMessage *v1pb.Memo, +) { if err := s.DispatchMemoUpdatedWebhook(ctx, memoMessage); err != nil { slog.Warn("Failed to dispatch memo updated webhook", slog.Any("err", err)) } - visibility := memo.Visibility - if parentMemo != nil { - visibility = parentMemo.Visibility - } - s.SSEHub.Broadcast(&SSEEvent{ - Type: SSEEventMemoUpdated, - Name: memoMessage.Name, - Parent: memoMessage.GetParent(), - Visibility: visibility, - CreatorID: resolveSSECreatorID(memo, parentMemo), - }) + s.SSEHub.publishMemoChanged() } diff --git a/server/router/api/v1/reaction_service.go b/server/router/api/v1/reaction_service.go index 64574573..9ac74438 100644 --- a/server/router/api/v1/reaction_service.go +++ b/server/router/api/v1/reaction_service.go @@ -27,18 +27,8 @@ func (s *APIV1Service) ListMemoReactions(ctx context.Context, request *v1pb.List return nil, status.Errorf(codes.NotFound, "memo not found") } - // Check memo visibility. - if memo.Visibility != store.Public { - user, err := s.fetchCurrentUser(ctx) - if err != nil { - return nil, status.Errorf(codes.Internal, "failed to get user") - } - if user == nil { - return nil, status.Errorf(codes.Unauthenticated, "user not authenticated") - } - if memo.Visibility == store.Private && memo.CreatorID != user.ID && !isSuperUser(user) { - return nil, status.Errorf(codes.PermissionDenied, "permission denied") - } + if err := s.checkMemoReadAccess(ctx, memo); err != nil { + return nil, err } reactions, err := s.Store.ListReactions(ctx, &store.FindReaction{ @@ -66,6 +56,9 @@ func (s *APIV1Service) UpsertMemoReaction(ctx context.Context, request *v1pb.Ups if user == nil { return nil, status.Errorf(codes.Unauthenticated, "user not authenticated") } + if request.GetReaction() == nil { + return nil, status.Error(codes.InvalidArgument, "reaction is required") + } // Extract memo UID and check visibility before allowing reaction. memoUID, err := ExtractMemoUIDFromName(request.Name) @@ -80,21 +73,17 @@ func (s *APIV1Service) UpsertMemoReaction(ctx context.Context, request *v1pb.Ups return nil, status.Errorf(codes.NotFound, "memo not found") } - // Check memo visibility. - if memo.Visibility == store.Private && memo.CreatorID != user.ID && !isSuperUser(user) { - return nil, status.Errorf(codes.PermissionDenied, "permission denied") + if err := s.checkMemoReadAccess(ctx, memo); err != nil { + return nil, err } - reaction, err := s.Store.UpsertReaction(ctx, &store.Reaction{ CreatorID: user.ID, MemoID: memo.ID, ReactionType: request.Reaction.ReactionType, + Policy: reactionWritePolicy(user.ID), }) if err != nil { - if stderrors.Is(err, store.ErrReactionMemoNotFound) { - return nil, status.Errorf(codes.NotFound, "memo not found") - } - return nil, status.Errorf(codes.Internal, "failed to upsert reaction") + return nil, mapReactionMutationError(err, "failed to upsert reaction") } memoName := buildMemoName(memo.UID) @@ -103,12 +92,7 @@ func (s *APIV1Service) UpsertMemoReaction(ctx context.Context, request *v1pb.Ups return nil, status.Errorf(codes.Internal, "failed to convert reaction") } - // Broadcast live refresh event (reaction belongs to a memo). - var parentMemo *store.Memo - if memo.ParentUID != nil { - parentMemo, _ = s.Store.GetMemo(ctx, &store.FindMemo{UID: memo.ParentUID}) - } - s.SSEHub.Broadcast(buildMemoReactionSSEEvent(SSEEventReactionUpserted, memoName, memo, parentMemo)) + s.SSEHub.publishMemoChanged() return reactionMessage, nil } @@ -122,7 +106,7 @@ func (s *APIV1Service) DeleteMemoReaction(ctx context.Context, request *v1pb.Del return nil, status.Errorf(codes.Unauthenticated, "user not authenticated") } - _, reactionID, err := ExtractMemoReactionIDFromName(request.Name) + memoUID, reactionID, err := ExtractMemoReactionIDFromName(request.Name) if err != nil { return nil, status.Errorf(codes.InvalidArgument, "invalid reaction name: %v", err) } @@ -139,32 +123,45 @@ func (s *APIV1Service) DeleteMemoReaction(ctx context.Context, request *v1pb.Del return nil, status.Errorf(codes.PermissionDenied, "permission denied") } - if reaction.CreatorID != user.ID && !isSuperUser(user) { + if reaction.CreatorID != user.ID { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } memo, err := s.Store.GetMemo(ctx, &store.FindMemo{ID: &reaction.MemoID}) if err != nil { return nil, status.Errorf(codes.Internal, "failed to get memo") } - - if err := s.Store.DeleteReaction(ctx, &store.DeleteReaction{ID: &reactionID}); err != nil { - return nil, status.Errorf(codes.Internal, "failed to delete reaction") + if memo == nil || memo.UID != memoUID { + return nil, status.Errorf(codes.PermissionDenied, "permission denied") + } + if err := s.Store.DeleteReaction(ctx, &store.DeleteReaction{ + ID: &reactionID, + MemoID: &reaction.MemoID, + ActorUserID: &user.ID, + Policy: reactionWritePolicy(user.ID), + }); err != nil { + return nil, mapReactionMutationError(err, "failed to delete reaction") } - // A concurrent memo deletion also removes its reactions, so the delete above - // stays idempotent. There is no memo left to broadcast a refresh for. - if memo != nil { - // Broadcast live refresh event (reaction belongs to a memo). - var parentMemo *store.Memo - if memo.ParentUID != nil { - parentMemo, _ = s.Store.GetMemo(ctx, &store.FindMemo{UID: memo.ParentUID}) - } - s.SSEHub.Broadcast(buildMemoReactionSSEEvent(SSEEventReactionDeleted, buildMemoName(memo.UID), memo, parentMemo)) - } + s.SSEHub.publishMemoChanged() return &emptypb.Empty{}, nil } +func reactionWritePolicy(actorUserID int32) *store.ReactionWritePolicy { + return &store.ReactionWritePolicy{ActorUserID: actorUserID} +} + +func mapReactionMutationError(err error, operation string) error { + switch { + case stderrors.Is(err, store.ErrReactionMemoNotFound): + return status.Error(codes.NotFound, "memo not found") + case stderrors.Is(err, store.ErrReactionPermissionDenied): + return status.Error(codes.PermissionDenied, "permission denied") + default: + return mapMemoWriteError(err, operation) + } +} + func (s *APIV1Service) convertReactionFromStore(ctx context.Context, reaction *store.Reaction, memoName string) (*v1pb.Reaction, error) { creatorsByID, err := s.listUsersByIDWithExisting(ctx, []int32{reaction.CreatorID}, nil) if err != nil { diff --git a/server/router/api/v1/reaction_service_policy_test.go b/server/router/api/v1/reaction_service_policy_test.go new file mode 100644 index 00000000..39589c44 --- /dev/null +++ b/server/router/api/v1/reaction_service_policy_test.go @@ -0,0 +1,39 @@ +package v1 + +import ( + "errors" + "testing" + + "github.com/stretchr/testify/require" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + "github.com/usememos/memos/store" +) + +func TestReactionWritePolicy(t *testing.T) { + policy := reactionWritePolicy(7) + require.Equal(t, int32(7), policy.ActorUserID) +} + +func TestMapReactionMutationError(t *testing.T) { + tests := []struct { + name string + err error + code codes.Code + }{ + {name: "missing memo", err: store.ErrReactionMemoNotFound, code: codes.NotFound}, + {name: "reaction ownership", err: store.ErrReactionPermissionDenied, code: codes.PermissionDenied}, + {name: "space membership", err: store.ErrMemoSpaceMembershipRequired, code: codes.PermissionDenied}, + {name: "private memo", err: store.ErrMemoPermissionDenied, code: codes.PermissionDenied}, + {name: "stale memo snapshot", err: store.ErrMemoMutationConflict, code: codes.FailedPrecondition}, + {name: "invalid space", err: store.ErrMemoSpaceNotWritable, code: codes.FailedPrecondition}, + {name: "unexpected storage failure", err: errors.New("database unavailable"), code: codes.Internal}, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + require.Equal(t, test.code, status.Code(mapReactionMutationError(test.err, "mutate reaction"))) + }) + } +} diff --git a/server/router/api/v1/resource_name.go b/server/router/api/v1/resource_name.go index bc362dc1..5a774001 100644 --- a/server/router/api/v1/resource_name.go +++ b/server/router/api/v1/resource_name.go @@ -23,6 +23,8 @@ const ( InboxNamePrefix = "inboxes/" IdentityProviderNamePrefix = "identity-providers/" WebhookNamePrefix = "webhooks/" + SpaceNamePrefix = "spaces/" + SpaceMemberNamePrefix = "members/" ) // GetNameParentTokens returns the tokens from a resource name. @@ -88,6 +90,29 @@ func ExtractMemoUIDFromName(name string) (string, error) { return id, nil } +func buildMemoName(uid string) string { + return MemoNamePrefix + uid +} + +// ExtractSpaceUIDFromName returns the UID from a Space resource name. +func ExtractSpaceUIDFromName(name string) (string, error) { + tokens, err := GetNameParentTokens(name, SpaceNamePrefix) + if err != nil { + return "", err + } + return tokens[0], nil +} + +// ExtractSpaceMemberTokensFromName returns the Space UID and username from a +// SpaceMember resource name. +func ExtractSpaceMemberTokensFromName(name string) (string, string, error) { + tokens, err := GetNameParentTokens(name, SpaceNamePrefix, SpaceMemberNamePrefix) + if err != nil { + return "", "", err + } + return tokens[0], tokens[1], nil +} + // ExtractAttachmentUIDFromName returns the attachment UID from a resource name. func ExtractAttachmentUIDFromName(name string) (string, error) { tokens, err := GetNameParentTokens(name, AttachmentNamePrefix) diff --git a/server/router/api/v1/resource_name_test.go b/server/router/api/v1/resource_name_test.go index ec0dbc81..8b8b4300 100644 --- a/server/router/api/v1/resource_name_test.go +++ b/server/router/api/v1/resource_name_test.go @@ -37,3 +37,33 @@ func TestValidateAndGenerateUIDValidatesUserProvidedResourceIDs(t *testing.T) { }) } } + +func TestExtractSpaceUIDFromName(t *testing.T) { + uid, err := ExtractSpaceUIDFromName("spaces/team-notes") + if err != nil { + t.Fatalf("ExtractSpaceUIDFromName() returned error: %v", err) + } + if uid != "team-notes" { + t.Fatalf("ExtractSpaceUIDFromName() = %q, want %q", uid, "team-notes") + } + for _, name := range []string{"", "spaces/", "memos/team-notes", "spaces/team/members/alice"} { + if _, err := ExtractSpaceUIDFromName(name); err == nil { + t.Errorf("ExtractSpaceUIDFromName(%q) succeeded, want error", name) + } + } +} + +func TestExtractSpaceMemberTokensFromName(t *testing.T) { + spaceUID, username, err := ExtractSpaceMemberTokensFromName("spaces/team-notes/members/alice") + if err != nil { + t.Fatalf("ExtractSpaceMemberTokensFromName() returned error: %v", err) + } + if spaceUID != "team-notes" || username != "alice" { + t.Fatalf("ExtractSpaceMemberTokensFromName() = (%q, %q)", spaceUID, username) + } + for _, name := range []string{"spaces/team-notes", "spaces/team-notes/users/alice", "spaces//members/alice", "spaces/team-notes/members/"} { + if _, _, err := ExtractSpaceMemberTokensFromName(name); err == nil { + t.Errorf("ExtractSpaceMemberTokensFromName(%q) succeeded, want error", name) + } + } +} diff --git a/server/router/api/v1/space_service.go b/server/router/api/v1/space_service.go new file mode 100644 index 00000000..0122ffc3 --- /dev/null +++ b/server/router/api/v1/space_service.go @@ -0,0 +1,485 @@ +package v1 + +import ( + "context" + "database/sql" + "strings" + + "github.com/pkg/errors" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/types/known/emptypb" + + v1pb "github.com/usememos/memos/proto/gen/api/v1" + "github.com/usememos/memos/store" +) + +func (s *APIV1Service) requireCurrentSpaceUser(ctx context.Context) (*store.User, error) { + user, err := s.fetchCurrentUser(ctx) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to get current user: %v", err) + } + if user == nil { + return nil, status.Error(codes.Unauthenticated, "user not authenticated") + } + return user, nil +} + +func (s *APIV1Service) resolveMemberSpace(ctx context.Context, name string, currentUser *store.User) (*store.Space, *store.SpaceMember, error) { + uid, err := ExtractSpaceUIDFromName(name) + if err != nil { + return nil, nil, status.Errorf(codes.InvalidArgument, "invalid space name: %v", err) + } + space, err := s.Store.GetSpace(ctx, &store.FindSpace{UID: &uid, MemberUserID: ¤tUser.ID}) + if err != nil { + return nil, nil, status.Errorf(codes.Internal, "failed to get space: %v", err) + } + if space == nil { + return nil, nil, status.Error(codes.NotFound, "space not found") + } + member, err := s.Store.GetSpaceMember(ctx, &store.FindSpaceMember{SpaceID: &space.ID, UserID: ¤tUser.ID}) + if err != nil { + return nil, nil, status.Errorf(codes.Internal, "failed to get space membership: %v", err) + } + if member == nil || !member.Role.IsActiveMember() { + // A non-member must not be able to distinguish an existing private + // collaboration boundary from a missing resource. + return nil, nil, status.Error(codes.NotFound, "space not found") + } + return space, member, nil +} + +func requireSpaceAdministrator(member *store.SpaceMember) error { + if member == nil || member.Role != store.SpaceMemberRoleAdmin { + return status.Error(codes.PermissionDenied, "space administrator permission required") + } + return nil +} + +func mapSpaceMutationError(err error, operation string) error { + switch { + case err == nil: + return nil + case errors.Is(err, store.ErrLastSpaceAdmin): + return status.Error(codes.FailedPrecondition, "a space must retain an active administrator") + case errors.Is(err, store.ErrSpacePermissionDenied): + return status.Error(codes.NotFound, "space not found") + case errors.Is(err, store.ErrSpaceMemberNotActive): + return status.Error(codes.FailedPrecondition, "space members must be active users") + case errors.Is(err, store.ErrSpaceAlreadyExists): + return status.Error(codes.AlreadyExists, "space already exists") + case errors.Is(err, store.ErrSpaceMemberAlreadyExists): + return status.Error(codes.AlreadyExists, "space member already exists") + case errors.Is(err, store.ErrSpaceNotFound), errors.Is(err, store.ErrSpaceMemberNotFound): + return status.Error(codes.NotFound, "space or membership not found") + case errors.Is(err, sql.ErrNoRows): + return status.Error(codes.NotFound, "space or membership not found") + default: + return status.Errorf(codes.Internal, "%s: %v", operation, err) + } +} + +// CreateSpace creates a space with the caller as its first administrator. +func (s *APIV1Service) CreateSpace(ctx context.Context, request *v1pb.CreateSpaceRequest) (*v1pb.Space, error) { + currentUser, err := s.requireCurrentSpaceUser(ctx) + if err != nil { + return nil, err + } + if request.GetSpace() == nil { + return nil, status.Error(codes.InvalidArgument, "space is required") + } + title := strings.TrimSpace(request.Space.Title) + if title == "" { + return nil, status.Error(codes.InvalidArgument, "space title is required") + } + uid, err := ValidateAndGenerateUID(request.SpaceId) + if err != nil { + return nil, err + } + created, err := s.Store.CreateSpace(ctx, &store.Space{ + UID: uid, + Title: title, + Description: strings.TrimSpace(request.Space.Description), + }, currentUser.ID) + if err != nil { + return nil, mapSpaceMutationError(err, "failed to create space") + } + s.SSEHub.publishMemoChanged() + return convertSpaceFromStore(created), nil +} + +// ListSpaces lists only spaces with a membership for the caller. +func (s *APIV1Service) ListSpaces(ctx context.Context, request *v1pb.ListSpacesRequest) (*v1pb.ListSpacesResponse, error) { + currentUser, err := s.requireCurrentSpaceUser(ctx) + if err != nil { + return nil, err + } + limit, offset, err := listSpacePage(request.PageSize, request.PageToken) + if err != nil { + return nil, err + } + limitPlusOne := limit + 1 + spaces, err := s.Store.ListSpaces(ctx, &store.FindSpace{ + MemberUserID: ¤tUser.ID, + Limit: &limitPlusOne, + Offset: &offset, + }) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to list spaces: %v", err) + } + + nextPageToken := "" + if len(spaces) == limitPlusOne { + spaces = spaces[:limit] + nextPageToken, err = getPageToken(limit, offset+limit) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to create next page token: %v", err) + } + } + response := &v1pb.ListSpacesResponse{Spaces: make([]*v1pb.Space, 0, len(spaces)), NextPageToken: nextPageToken} + for _, space := range spaces { + response.Spaces = append(response.Spaces, convertSpaceFromStore(space)) + } + return response, nil +} + +func listSpacePage(pageSize int32, pageToken string) (int, int, error) { + if pageToken == "" { + return normalizePageSize(pageSize), 0, nil + } + var token v1pb.PageToken + if err := unmarshalPageToken(pageToken, &token); err != nil { + return 0, 0, status.Errorf(codes.InvalidArgument, "invalid page token: %v", err) + } + return normalizePageSize(token.Limit), max(int(token.Offset), 0), nil +} + +// GetSpace gets a space visible to the caller through membership. +func (s *APIV1Service) GetSpace(ctx context.Context, request *v1pb.GetSpaceRequest) (*v1pb.Space, error) { + currentUser, err := s.requireCurrentSpaceUser(ctx) + if err != nil { + return nil, err + } + space, _, err := s.resolveMemberSpace(ctx, request.Name, currentUser) + if err != nil { + return nil, err + } + return convertSpaceFromStore(space), nil +} + +// UpdateSpace updates Space metadata. +func (s *APIV1Service) UpdateSpace(ctx context.Context, request *v1pb.UpdateSpaceRequest) (*v1pb.Space, error) { + currentUser, err := s.requireCurrentSpaceUser(ctx) + if err != nil { + return nil, err + } + if request.GetSpace() == nil { + return nil, status.Error(codes.InvalidArgument, "space is required") + } + if request.UpdateMask == nil || len(request.UpdateMask.Paths) == 0 { + return nil, status.Error(codes.InvalidArgument, "update mask is required") + } + space, membership, err := s.resolveMemberSpace(ctx, request.Space.Name, currentUser) + if err != nil { + return nil, err + } + if err := requireSpaceAdministrator(membership); err != nil { + return nil, err + } + + update := &store.UpdateSpace{ID: space.ID} + for _, path := range request.UpdateMask.Paths { + switch path { + case "title": + title := strings.TrimSpace(request.Space.Title) + if title == "" { + return nil, status.Error(codes.InvalidArgument, "space title is required") + } + update.Title = &title + case "description": + description := strings.TrimSpace(request.Space.Description) + update.Description = &description + default: + return nil, status.Errorf(codes.InvalidArgument, "unsupported update mask path: %s", path) + } + } + updated, err := s.Store.UpdateSpace(ctx, update, currentUser.ID) + if err != nil { + return nil, mapSpaceMutationError(err, "failed to update space") + } + if updated == nil { + return nil, status.Error(codes.NotFound, "space not found") + } + s.SSEHub.publishMemoChanged() + return convertSpaceFromStore(updated), nil +} + +// DeleteSpace permanently deletes the Space and every memo directly placed +// in it. The result deliberately exposes no memo inventory to the administrator. +func (s *APIV1Service) DeleteSpace(ctx context.Context, request *v1pb.DeleteSpaceRequest) (*emptypb.Empty, error) { + currentUser, err := s.requireCurrentSpaceUser(ctx) + if err != nil { + return nil, err + } + space, membership, err := s.resolveMemberSpace(ctx, request.Name, currentUser) + if err != nil { + return nil, err + } + if err := requireSpaceAdministrator(membership); err != nil { + return nil, err + } + deleteResult, err := s.Store.DeleteSpace(ctx, &store.DeleteSpace{ID: space.ID, ActorUserID: currentUser.ID}) + if err != nil { + return nil, mapSpaceMutationError(err, "failed to delete space") + } + s.SSEHub.publishMemoChanged() + if err := s.cleanupDeletedAttachmentStorage(ctx, deleteResult.Attachments); err != nil { + return nil, status.Errorf(codes.Internal, "space was deleted but attachment storage cleanup failed: %v", err) + } + return &emptypb.Empty{}, nil +} + +// CreateSpaceMember directly adds an active user to a Space. +func (s *APIV1Service) CreateSpaceMember(ctx context.Context, request *v1pb.CreateSpaceMemberRequest) (*v1pb.SpaceMember, error) { + currentUser, err := s.requireCurrentSpaceUser(ctx) + if err != nil { + return nil, err + } + if request.GetSpaceMember() == nil { + return nil, status.Error(codes.InvalidArgument, "space member is required") + } + space, callerMembership, err := s.resolveMemberSpace(ctx, request.Parent, currentUser) + if err != nil { + return nil, err + } + if err := requireSpaceAdministrator(callerMembership); err != nil { + return nil, err + } + targetUsername, err := parseUsernameFromName(request.SpaceMember.User) + if err != nil { + return nil, status.Errorf(codes.InvalidArgument, "invalid member user: %v", err) + } + targetUser, err := s.Store.GetUser(ctx, &store.FindUser{Username: &targetUsername}) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to get member user: %v", err) + } + if targetUser == nil { + return nil, status.Error(codes.NotFound, "user not found") + } + if targetUser.RowStatus != store.Normal { + return nil, status.Error(codes.FailedPrecondition, "only active users can be added to a space") + } + role, ok := convertSpaceMemberRoleToStore(request.SpaceMember.Role) + if !ok { + return nil, status.Error(codes.InvalidArgument, "space member role must be ADMIN or USER") + } + expectedName := buildSpaceMemberName(space.UID, targetUser.Username) + if request.SpaceMember.Name != "" && request.SpaceMember.Name != expectedName { + return nil, status.Error(codes.InvalidArgument, "space member name does not match parent and user") + } + created, err := s.Store.CreateSpaceMember(ctx, &store.SpaceMember{ + SpaceID: space.ID, + UserID: targetUser.ID, + Role: role, + }, currentUser.ID) + if err != nil { + return nil, mapSpaceMutationError(err, "failed to create space member") + } + s.SSEHub.publishMemoChanged() + return convertSpaceMemberFromStore(space, targetUser, created), nil +} + +// ListSpaceMembers lists memberships after authorizing the caller's own +// membership before applying pagination. +func (s *APIV1Service) ListSpaceMembers(ctx context.Context, request *v1pb.ListSpaceMembersRequest) (*v1pb.ListSpaceMembersResponse, error) { + currentUser, err := s.requireCurrentSpaceUser(ctx) + if err != nil { + return nil, err + } + space, _, err := s.resolveMemberSpace(ctx, request.Parent, currentUser) + if err != nil { + return nil, err + } + limit, offset, err := listSpacePage(request.PageSize, request.PageToken) + if err != nil { + return nil, err + } + limitPlusOne := limit + 1 + members, err := s.Store.ListSpaceMembers(ctx, &store.FindSpaceMember{ + SpaceID: &space.ID, + ViewerUserID: ¤tUser.ID, + Limit: &limitPlusOne, + Offset: &offset, + }) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to list space members: %v", err) + } + nextPageToken := "" + if len(members) == limitPlusOne { + members = members[:limit] + nextPageToken, err = getPageToken(limit, offset+limit) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to create next page token: %v", err) + } + } + response := &v1pb.ListSpaceMembersResponse{SpaceMembers: make([]*v1pb.SpaceMember, 0, len(members)), NextPageToken: nextPageToken} + if len(members) == 0 { + return response, nil + } + + userIDs := make([]int32, 0, len(members)) + for _, member := range members { + userIDs = append(userIDs, member.UserID) + } + users, err := s.Store.ListUsers(ctx, &store.FindUser{IDList: userIDs}) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to resolve space members: %v", err) + } + usersByID := make(map[int32]*store.User, len(users)) + for _, user := range users { + usersByID[user.ID] = user + } + for _, member := range members { + user := usersByID[member.UserID] + if user == nil || user.RowStatus != store.Normal || convertSpaceMemberRoleFromStore(member.Role) == v1pb.SpaceMember_ROLE_UNSPECIFIED { + // Malformed/dangling memberships are never exposed as active access. + continue + } + response.SpaceMembers = append(response.SpaceMembers, convertSpaceMemberFromStore(space, user, member)) + } + return response, nil +} + +func (s *APIV1Service) resolveSpaceMemberResource(ctx context.Context, name string, currentUser *store.User) (*store.Space, *store.User, *store.SpaceMember, *store.SpaceMember, error) { + spaceUID, username, err := ExtractSpaceMemberTokensFromName(name) + if err != nil { + return nil, nil, nil, nil, status.Errorf(codes.InvalidArgument, "invalid space member name: %v", err) + } + space, callerMembership, err := s.resolveMemberSpace(ctx, buildSpaceName(spaceUID), currentUser) + if err != nil { + return nil, nil, nil, nil, err + } + targetUser, err := ResolveUserByName(ctx, s.Store, BuildUserName(username)) + if err != nil { + return nil, nil, nil, nil, status.Errorf(codes.Internal, "failed to resolve member user: %v", err) + } + if targetUser == nil { + return nil, nil, nil, nil, status.Error(codes.NotFound, "space member not found") + } + if targetUser.RowStatus != store.Normal { + return nil, nil, nil, nil, status.Error(codes.NotFound, "space member not found") + } + targetMembership, err := s.Store.GetSpaceMember(ctx, &store.FindSpaceMember{ + SpaceID: &space.ID, + UserID: &targetUser.ID, + ViewerUserID: ¤tUser.ID, + }) + if err != nil { + return nil, nil, nil, nil, status.Errorf(codes.Internal, "failed to get space membership: %v", err) + } + if targetMembership == nil || !targetMembership.Role.IsActiveMember() { + return nil, nil, nil, nil, status.Error(codes.NotFound, "space member not found") + } + return space, targetUser, callerMembership, targetMembership, nil +} + +// GetSpaceMember gets one membership visible to another member of the space. +func (s *APIV1Service) GetSpaceMember(ctx context.Context, request *v1pb.GetSpaceMemberRequest) (*v1pb.SpaceMember, error) { + currentUser, err := s.requireCurrentSpaceUser(ctx) + if err != nil { + return nil, err + } + space, targetUser, _, membership, err := s.resolveSpaceMemberResource(ctx, request.Name, currentUser) + if err != nil { + return nil, err + } + return convertSpaceMemberFromStore(space, targetUser, membership), nil +} + +// UpdateSpaceMember changes a member's role in a Space. +func (s *APIV1Service) UpdateSpaceMember(ctx context.Context, request *v1pb.UpdateSpaceMemberRequest) (*v1pb.SpaceMember, error) { + currentUser, err := s.requireCurrentSpaceUser(ctx) + if err != nil { + return nil, err + } + if request.GetSpaceMember() == nil { + return nil, status.Error(codes.InvalidArgument, "space member is required") + } + if request.UpdateMask == nil || len(request.UpdateMask.Paths) == 0 { + return nil, status.Error(codes.InvalidArgument, "update mask must include role") + } + roleIncluded := false + userIncluded := false + for _, path := range request.UpdateMask.Paths { + switch path { + case "role": + roleIncluded = true + case "user": + // grpc-gateway infers user from the schema-required REST body. It is + // accepted as immutable identity context, never as a mutable field. + userIncluded = true + default: + return nil, status.Errorf(codes.InvalidArgument, "unsupported update mask path: %s", path) + } + } + if !roleIncluded { + return nil, status.Error(codes.InvalidArgument, "update mask must include role") + } + space, targetUser, callerMembership, targetMembership, err := s.resolveSpaceMemberResource(ctx, request.SpaceMember.Name, currentUser) + if err != nil { + return nil, err + } + expectedUser := BuildUserName(targetUser.Username) + if userIncluded && request.SpaceMember.User == "" { + return nil, status.Error(codes.InvalidArgument, "space member user is required when included in the update mask") + } + if request.SpaceMember.User != "" && request.SpaceMember.User != expectedUser { + return nil, status.Error(codes.InvalidArgument, "space member user does not match name") + } + if err := requireSpaceAdministrator(callerMembership); err != nil { + return nil, err + } + role, ok := convertSpaceMemberRoleToStore(request.SpaceMember.Role) + if !ok { + return nil, status.Error(codes.InvalidArgument, "space member role must be ADMIN or USER") + } + updated, err := s.Store.UpdateSpaceMember(ctx, &store.UpdateSpaceMember{ + SpaceID: targetMembership.SpaceID, + UserID: targetMembership.UserID, + Role: &role, + }, currentUser.ID) + if err != nil { + return nil, mapSpaceMutationError(err, "failed to update space member") + } + if updated == nil { + return nil, status.Error(codes.NotFound, "space member not found") + } + s.SSEHub.publishMemoChanged() + return convertSpaceMemberFromStore(space, targetUser, updated), nil +} + +// DeleteSpaceMember removes a membership or lets a member leave a space. +func (s *APIV1Service) DeleteSpaceMember(ctx context.Context, request *v1pb.DeleteSpaceMemberRequest) (*emptypb.Empty, error) { + currentUser, err := s.requireCurrentSpaceUser(ctx) + if err != nil { + return nil, err + } + _, targetUser, callerMembership, targetMembership, err := s.resolveSpaceMemberResource(ctx, request.Name, currentUser) + if err != nil { + return nil, err + } + isSelf := targetUser.ID == currentUser.ID + if !isSelf { + if err := requireSpaceAdministrator(callerMembership); err != nil { + return nil, err + } + } + if err := s.Store.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{ + SpaceID: targetMembership.SpaceID, + UserID: targetMembership.UserID, + }, currentUser.ID); err != nil { + return nil, mapSpaceMutationError(err, "failed to delete space member") + } + s.SSEHub.publishMemoChanged() + return &emptypb.Empty{}, nil +} diff --git a/server/router/api/v1/space_service_converters.go b/server/router/api/v1/space_service_converters.go new file mode 100644 index 00000000..5bd3388c --- /dev/null +++ b/server/router/api/v1/space_service_converters.go @@ -0,0 +1,58 @@ +package v1 + +import ( + v1pb "github.com/usememos/memos/proto/gen/api/v1" + "github.com/usememos/memos/store" +) + +func buildSpaceName(uid string) string { + return SpaceNamePrefix + uid +} + +func buildSpaceMemberName(spaceUID, username string) string { + return buildSpaceName(spaceUID) + "/" + SpaceMemberNamePrefix + username +} + +func convertSpaceFromStore(space *store.Space) *v1pb.Space { + if space == nil { + return nil + } + return &v1pb.Space{ + Name: buildSpaceName(space.UID), + Title: space.Title, + Description: space.Description, + } +} + +func convertSpaceMemberRoleFromStore(role store.SpaceMemberRole) v1pb.SpaceMember_Role { + switch role { + case store.SpaceMemberRoleAdmin: + return v1pb.SpaceMember_ADMIN + case store.SpaceMemberRoleUser: + return v1pb.SpaceMember_USER + default: + return v1pb.SpaceMember_ROLE_UNSPECIFIED + } +} + +func convertSpaceMemberRoleToStore(role v1pb.SpaceMember_Role) (store.SpaceMemberRole, bool) { + switch role { + case v1pb.SpaceMember_ADMIN: + return store.SpaceMemberRoleAdmin, true + case v1pb.SpaceMember_USER: + return store.SpaceMemberRoleUser, true + default: + return "", false + } +} + +func convertSpaceMemberFromStore(space *store.Space, user *store.User, member *store.SpaceMember) *v1pb.SpaceMember { + if space == nil || user == nil || member == nil { + return nil + } + return &v1pb.SpaceMember{ + Name: buildSpaceMemberName(space.UID, user.Username), + User: BuildUserName(user.Username), + Role: convertSpaceMemberRoleFromStore(member.Role), + } +} diff --git a/server/router/api/v1/space_service_test.go b/server/router/api/v1/space_service_test.go new file mode 100644 index 00000000..688a0423 --- /dev/null +++ b/server/router/api/v1/space_service_test.go @@ -0,0 +1,272 @@ +package v1 + +import ( + "context" + "net/http" + "net/http/httptest" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/grpc-ecosystem/grpc-gateway/v2/runtime" + "github.com/stretchr/testify/require" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/types/known/fieldmaskpb" + + v1pb "github.com/usememos/memos/proto/gen/api/v1" + storepb "github.com/usememos/memos/proto/gen/store" + "github.com/usememos/memos/store" +) + +func createSpaceTestUser(ctx context.Context, t *testing.T, service *APIV1Service, username string, role store.Role) *store.User { + t.Helper() + user, err := service.Store.CreateUser(ctx, &store.User{ + Username: username, + Role: role, + Email: username + "@example.com", + }) + require.NoError(t, err) + return user +} + +func TestSpaceServiceMembershipVisibilityAndGovernance(t *testing.T) { + ctx := context.Background() + service := newIntegrationService(t) + owner := createSpaceTestUser(ctx, t, service, "space-owner", store.RoleUser) + member := createSpaceTestUser(ctx, t, service, "space-member", store.RoleUser) + applicationAdmin := createSpaceTestUser(ctx, t, service, "application-admin", store.RoleAdmin) + + space, err := service.CreateSpace(userCtx(ctx, owner.ID), &v1pb.CreateSpaceRequest{ + SpaceId: "team-notes", + Space: &v1pb.Space{Title: " Team notes ", Description: " Shared work "}, + }) + require.NoError(t, err) + require.Equal(t, "spaces/team-notes", space.Name) + require.Equal(t, "Team notes", space.Title) + _, err = service.CreateSpace(userCtx(ctx, owner.ID), &v1pb.CreateSpaceRequest{ + SpaceId: "team-notes", + Space: &v1pb.Space{Title: "Duplicate"}, + }) + require.Equal(t, codes.AlreadyExists, status.Code(err)) + + members, err := service.ListSpaceMembers(userCtx(ctx, owner.ID), &v1pb.ListSpaceMembersRequest{Parent: space.Name}) + require.NoError(t, err) + require.Len(t, members.SpaceMembers, 1) + require.Equal(t, v1pb.SpaceMember_ADMIN, members.SpaceMembers[0].Role) + + _, err = service.GetSpace(userCtx(ctx, applicationAdmin.ID), &v1pb.GetSpaceRequest{Name: space.Name}) + require.Equal(t, codes.NotFound, status.Code(err), "application ADMIN must not bypass space membership") + adminSpaces, err := service.ListSpaces(userCtx(ctx, applicationAdmin.ID), &v1pb.ListSpacesRequest{}) + require.NoError(t, err) + require.Empty(t, adminSpaces.Spaces) + + createdMember, err := service.CreateSpaceMember(userCtx(ctx, owner.ID), &v1pb.CreateSpaceMemberRequest{ + Parent: space.Name, + SpaceMember: &v1pb.SpaceMember{ + User: BuildUserName(member.Username), + Role: v1pb.SpaceMember_USER, + }, + }) + require.NoError(t, err) + require.Equal(t, "spaces/team-notes/members/space-member", createdMember.Name) + _, err = service.CreateSpaceMember(userCtx(ctx, owner.ID), &v1pb.CreateSpaceMemberRequest{ + Parent: space.Name, + SpaceMember: &v1pb.SpaceMember{User: BuildUserName(member.Username), Role: v1pb.SpaceMember_USER}, + }) + require.Equal(t, codes.AlreadyExists, status.Code(err)) + + _, err = service.GetSpace(userCtx(ctx, member.ID), &v1pb.GetSpaceRequest{Name: space.Name}) + require.NoError(t, err) + _, err = service.UpdateSpace(userCtx(ctx, member.ID), &v1pb.UpdateSpaceRequest{ + Space: &v1pb.Space{Name: space.Name, Title: "not allowed"}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"title"}}, + }) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + + _, err = service.UpdateSpaceMember(userCtx(ctx, owner.ID), &v1pb.UpdateSpaceMemberRequest{ + SpaceMember: &v1pb.SpaceMember{Name: "spaces/team-notes/members/space-owner", Role: v1pb.SpaceMember_USER}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"role"}}, + }) + require.Equal(t, codes.FailedPrecondition, status.Code(err), "the last active ADMIN cannot be demoted") +} + +func TestSpaceServiceHardDeleteLifecycle(t *testing.T) { + ctx := context.Background() + service := newIntegrationService(t) + owner := createSpaceTestUser(ctx, t, service, "delete-owner", store.RoleUser) + target := createSpaceTestUser(ctx, t, service, "delete-target", store.RoleUser) + applicationAdmin := createSpaceTestUser(ctx, t, service, "delete-application-admin", store.RoleAdmin) + + space, err := service.CreateSpace(userCtx(ctx, owner.ID), &v1pb.CreateSpaceRequest{ + SpaceId: "delete-space", + Space: &v1pb.Space{Title: "Delete me"}, + }) + require.NoError(t, err) + spaceUID, err := ExtractSpaceUIDFromName(space.Name) + require.NoError(t, err) + storedSpace, err := service.Store.GetSpace(ctx, &store.FindSpace{UID: &spaceUID}) + require.NoError(t, err) + require.NotNil(t, storedSpace) + assignedMemo, err := service.Store.CreateMemo(ctx, &store.Memo{ + UID: "delete-space-memo", + CreatorID: owner.ID, + Content: "delete with Space", + Visibility: store.Private, + SpaceID: &storedSpace.ID, + }) + require.NoError(t, err) + attachmentPath := filepath.Join(t.TempDir(), "space-delete-attachment.txt") + require.NoError(t, os.WriteFile(attachmentPath, []byte("delete me"), 0o600)) + _, err = service.Store.CreateAttachment(ctx, &store.Attachment{ + UID: "delete-space-attachment", + CreatorID: owner.ID, + Filename: "space-delete-attachment.txt", + MemoID: &assignedMemo.ID, + StorageType: storepb.AttachmentStorageType_LOCAL, + Reference: attachmentPath, + Payload: &storepb.AttachmentPayload{}, + }) + require.NoError(t, err) + _, err = service.CreateSpaceMember(userCtx(ctx, owner.ID), &v1pb.CreateSpaceMemberRequest{ + Parent: space.Name, + SpaceMember: &v1pb.SpaceMember{User: BuildUserName(target.Username), Role: v1pb.SpaceMember_USER}, + }) + require.NoError(t, err) + + _, err = service.UpdateSpace(userCtx(ctx, owner.ID), &v1pb.UpdateSpaceRequest{ + Space: &v1pb.Space{Name: space.Name}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"state"}}, + }) + require.Equal(t, codes.InvalidArgument, status.Code(err), "Space has no archive or restore state") + + _, err = service.DeleteSpace(userCtx(ctx, target.ID), &v1pb.DeleteSpaceRequest{Name: space.Name}) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + _, err = service.DeleteSpace(userCtx(ctx, applicationAdmin.ID), &v1pb.DeleteSpaceRequest{Name: space.Name}) + require.Equal(t, codes.NotFound, status.Code(err), "application ADMIN must not bypass Space membership") + + _, err = service.DeleteSpace(userCtx(ctx, owner.ID), &v1pb.DeleteSpaceRequest{Name: space.Name}) + require.NoError(t, err) + require.NoFileExists(t, attachmentPath) + _, err = service.GetSpace(userCtx(ctx, owner.ID), &v1pb.GetSpaceRequest{Name: space.Name}) + require.Equal(t, codes.NotFound, status.Code(err)) + spaces, err := service.ListSpaces(userCtx(ctx, owner.ID), &v1pb.ListSpacesRequest{}) + require.NoError(t, err) + require.Empty(t, spaces.Spaces) +} + +func TestSpaceServiceHidesMembershipForInactiveUser(t *testing.T) { + ctx := context.Background() + service := newIntegrationService(t) + owner := createSpaceTestUser(ctx, t, service, "inactive-member-owner", store.RoleUser) + member := createSpaceTestUser(ctx, t, service, "inactive-member", store.RoleUser) + + space, err := service.CreateSpace(userCtx(ctx, owner.ID), &v1pb.CreateSpaceRequest{ + SpaceId: "inactive-member-space", + Space: &v1pb.Space{Title: "Inactive member space"}, + }) + require.NoError(t, err) + _, err = service.CreateSpaceMember(userCtx(ctx, owner.ID), &v1pb.CreateSpaceMemberRequest{ + Parent: space.Name, + SpaceMember: &v1pb.SpaceMember{User: BuildUserName(member.Username), Role: v1pb.SpaceMember_USER}, + }) + require.NoError(t, err) + + // The normal archive path rejects users with memberships. Simulate an + // inconsistent row to verify that membership reads still fail closed. + _, err = service.Store.GetDriver().GetDB().ExecContext(ctx, "UPDATE user SET row_status = 'ARCHIVED' WHERE id = ?", member.ID) + require.NoError(t, err) + + members, err := service.ListSpaceMembers(userCtx(ctx, owner.ID), &v1pb.ListSpaceMembersRequest{Parent: space.Name}) + require.NoError(t, err) + require.Len(t, members.SpaceMembers, 1) + require.Equal(t, BuildUserName(owner.Username), members.SpaceMembers[0].User) + + _, err = service.GetSpaceMember(userCtx(ctx, owner.ID), &v1pb.GetSpaceMemberRequest{ + Name: buildSpaceMemberName("inactive-member-space", member.Username), + }) + require.Equal(t, codes.NotFound, status.Code(err)) +} + +func TestUpdateSpaceMemberAcceptsGatewayInferredIdentityMask(t *testing.T) { + ctx := context.Background() + service := newIntegrationService(t) + owner := createSpaceTestUser(ctx, t, service, "gateway-owner", store.RoleUser) + member := createSpaceTestUser(ctx, t, service, "gateway-member", store.RoleUser) + + space, err := service.CreateSpace(userCtx(ctx, owner.ID), &v1pb.CreateSpaceRequest{ + SpaceId: "gateway-space", + Space: &v1pb.Space{Title: "Gateway Space"}, + }) + require.NoError(t, err) + createdMember, err := service.CreateSpaceMember(userCtx(ctx, owner.ID), &v1pb.CreateSpaceMemberRequest{ + Parent: space.Name, + SpaceMember: &v1pb.SpaceMember{ + User: BuildUserName(member.Username), + Role: v1pb.SpaceMember_USER, + }, + }) + require.NoError(t, err) + + mux := runtime.NewServeMux() + require.NoError(t, v1pb.RegisterSpaceServiceHandlerServer(ctx, mux, service)) + patchMember := func(body string) *httptest.ResponseRecorder { + t.Helper() + request := httptest.NewRequest(http.MethodPatch, "/api/v1/"+createdMember.Name, strings.NewReader(body)) + request.Header.Set("Content-Type", "application/json") + request = request.WithContext(userCtx(request.Context(), owner.ID)) + response := httptest.NewRecorder() + mux.ServeHTTP(response, request) + return response + } + + response := patchMember(`{"user":"users/gateway-member","role":"ADMIN"}`) + require.Equal(t, http.StatusOK, response.Code, response.Body.String()) + + spaceUID, err := ExtractSpaceUIDFromName(space.Name) + require.NoError(t, err) + storedSpace, err := service.Store.GetSpace(ctx, &store.FindSpace{UID: &spaceUID}) + require.NoError(t, err) + require.NotNil(t, storedSpace) + storedMember, err := service.Store.GetSpaceMember(ctx, &store.FindSpaceMember{SpaceID: &storedSpace.ID, UserID: &member.ID}) + require.NoError(t, err) + require.NotNil(t, storedMember) + require.Equal(t, store.SpaceMemberRoleAdmin, storedMember.Role) + + response = patchMember(`{"user":"users/gateway-owner","role":"USER"}`) + require.Equal(t, http.StatusBadRequest, response.Code, response.Body.String()) + storedMember, err = service.Store.GetSpaceMember(ctx, &store.FindSpaceMember{SpaceID: &storedSpace.ID, UserID: &member.ID}) + require.NoError(t, err) + require.NotNil(t, storedMember) + require.Equal(t, store.SpaceMemberRoleAdmin, storedMember.Role, "a mismatched immutable user must not update the membership") +} + +func TestCreateSpaceMemberClassifiesTargetUserErrors(t *testing.T) { + ctx := context.Background() + service := newIntegrationService(t) + owner := createSpaceTestUser(ctx, t, service, "lookup-owner", store.RoleUser) + target := createSpaceTestUser(ctx, t, service, "lookup-target", store.RoleUser) + space, err := service.CreateSpace(userCtx(ctx, owner.ID), &v1pb.CreateSpaceRequest{ + SpaceId: "lookup-space", + Space: &v1pb.Space{Title: "Lookup Space"}, + }) + require.NoError(t, err) + + _, err = service.CreateSpaceMember(userCtx(ctx, owner.ID), &v1pb.CreateSpaceMemberRequest{ + Parent: space.Name, + SpaceMember: &v1pb.SpaceMember{User: "invalid-user-name", Role: v1pb.SpaceMember_USER}, + }) + require.Equal(t, codes.InvalidArgument, status.Code(err)) + + // SQLite permits a text value in this integer column. Corrupt only the + // target row so authentication and Space authorization still succeed, then + // require the target lookup failure to remain a server error. + _, err = service.Store.GetDriver().GetDB().ExecContext(ctx, "UPDATE user SET created_ts = ? WHERE id = ?", "not-an-integer", target.ID) + require.NoError(t, err) + _, err = service.CreateSpaceMember(userCtx(ctx, owner.ID), &v1pb.CreateSpaceMemberRequest{ + Parent: space.Name, + SpaceMember: &v1pb.SpaceMember{User: BuildUserName(target.Username), Role: v1pb.SpaceMember_USER}, + }) + require.Equal(t, codes.Internal, status.Code(err)) +} diff --git a/server/router/api/v1/sse_event_helpers.go b/server/router/api/v1/sse_event_helpers.go deleted file mode 100644 index 38456aef..00000000 --- a/server/router/api/v1/sse_event_helpers.go +++ /dev/null @@ -1,40 +0,0 @@ -package v1 - -import "github.com/usememos/memos/store" - -func buildMemoName(uid string) string { - return MemoNamePrefix + uid -} - -// resolveSSECreatorID returns the CreatorID used for SSE delivery filtering. -// For a comment memo, it returns the parent memo's CreatorID so that private -// parent-memo events are scoped to the parent owner. -func resolveSSECreatorID(memo *store.Memo, parentMemo *store.Memo) int32 { - if memo == nil { - return 0 - } - if parentMemo != nil { - return parentMemo.CreatorID - } - return memo.CreatorID -} - -// buildMemoReactionSSEEvent constructs an SSEEvent for a reaction on a memo. -// Pass parentMemo when the memo is a comment (memo.ParentUID != nil). -func buildMemoReactionSSEEvent(eventType SSEEventType, memoName string, memo *store.Memo, parentMemo *store.Memo) *SSEEvent { - parent := "" - if memo != nil && memo.ParentUID != nil { - parent = buildMemoName(*memo.ParentUID) - } - visibility := store.Visibility("") - if memo != nil { - visibility = memo.Visibility - } - return &SSEEvent{ - Type: eventType, - Name: memoName, - Parent: parent, - Visibility: visibility, - CreatorID: resolveSSECreatorID(memo, parentMemo), - } -} diff --git a/server/router/api/v1/sse_handler.go b/server/router/api/v1/sse_handler.go index ded2fcd4..274f2827 100644 --- a/server/router/api/v1/sse_handler.go +++ b/server/router/api/v1/sse_handler.go @@ -40,7 +40,7 @@ func handleSSE(c *echo.Context, hub *SSEHub, authenticator *auth.Authenticator) if result == nil { return c.JSON(http.StatusUnauthorized, map[string]string{"error": "authentication required"}) } - userID, role := getSSEClientIdentity(result) + userID := getSSEClientUserID(result) if userID == 0 { return c.JSON(http.StatusUnauthorized, map[string]string{"error": "authentication required"}) } @@ -64,7 +64,7 @@ func handleSSE(c *echo.Context, hub *SSEHub, authenticator *auth.Authenticator) } // Subscribe to the hub. - client := hub.Subscribe(userID, role) + client := hub.Subscribe() defer hub.Unsubscribe(client) ctx := c.Request().Context() @@ -137,15 +137,15 @@ func resetSSETimer(timer *time.Timer) { timer.Reset(sseHeartbeatInterval) } -func getSSEClientIdentity(result *auth.AuthResult) (int32, store.Role) { +func getSSEClientUserID(result *auth.AuthResult) int32 { if result == nil { - return 0, store.RoleUser + return 0 } if result.Claims != nil { - return result.Claims.UserID, store.Role(result.Claims.Role) + return result.Claims.UserID } if result.User != nil { - return result.User.ID, result.User.Role + return result.User.ID } - return 0, store.RoleUser + return 0 } diff --git a/server/router/api/v1/sse_hub.go b/server/router/api/v1/sse_hub.go index e66f7f3f..765a585d 100644 --- a/server/router/api/v1/sse_hub.go +++ b/server/router/api/v1/sse_hub.go @@ -1,73 +1,16 @@ package v1 -import ( - "encoding/json" - "log/slog" - "sync" - - "github.com/usememos/memos/store" -) +import "sync" const ( - sseDataPrefix = "data: " sseClientEventBufferSize = 32 + memoChangedSSEFrame = "data: {\"type\":\"memo.changed\"}\n\n" ) -// SSEEventType represents the type of change event. -type SSEEventType string - -const ( - SSEEventMemoCreated SSEEventType = "memo.created" - SSEEventMemoUpdated SSEEventType = "memo.updated" - SSEEventMemoDeleted SSEEventType = "memo.deleted" - SSEEventMemoCommentCreated SSEEventType = "memo.comment.created" - SSEEventReactionUpserted SSEEventType = "reaction.upserted" - SSEEventReactionDeleted SSEEventType = "reaction.deleted" -) - -// SSEEvent represents a change event sent to SSE clients. -type SSEEvent struct { - Type SSEEventType `json:"type"` - // Name is the affected resource name (e.g., "memos/xxxx"). - // For reaction events, this is the memo resource name that the reaction belongs to. - Name string `json:"name"` - // Parent is the parent memo resource name when the affected resource is a comment. - Parent string `json:"parent,omitempty"` - // Visibility and CreatorID are used only for server-side delivery filtering. - Visibility store.Visibility `json:"-"` - CreatorID int32 `json:"-"` -} - -// JSON returns the JSON representation of the event. -// Returns nil if marshaling fails (error is logged). -func (e *SSEEvent) JSON() []byte { - data, err := json.Marshal(e) - if err != nil { - slog.Error("failed to marshal SSE event", "err", err, "event", e) - return nil - } - return data -} - -// Frame returns the event encoded as a complete SSE data frame. -func (e *SSEEvent) Frame() []byte { - data := e.JSON() - if len(data) == 0 { - return nil - } - frame := make([]byte, 0, len(sseDataPrefix)+len(data)+2) - frame = append(frame, sseDataPrefix...) - frame = append(frame, data...) - frame = append(frame, '\n', '\n') - return frame -} - // SSEClient represents a single SSE connection. type SSEClient struct { events chan []byte done chan struct{} - userID int32 - role store.Role } // SSEHub manages SSE client connections and broadcasts events. @@ -87,13 +30,11 @@ func NewSSEHub() *SSEHub { // Subscribe registers a new client and returns it. // The caller must call Unsubscribe when done. -func (h *SSEHub) Subscribe(userID int32, role store.Role) *SSEClient { +func (h *SSEHub) Subscribe() *SSEClient { c := &SSEClient{ // Buffer a few events so a slow client doesn't block broadcasting. events: make(chan []byte, sseClientEventBufferSize), done: make(chan struct{}), - userID: userID, - role: role, } h.mu.Lock() if h.closed { @@ -132,24 +73,16 @@ func (h *SSEHub) Close() { } } -// Broadcast sends an event to all connected clients. +// publishMemoChanged tells connected clients to refresh memo-backed caches. +// The event deliberately carries no subject or authorization-sensitive data. // Slow clients with a full buffer are disconnected so they can reconnect and // resynchronize instead of silently missing an event. -func (h *SSEHub) Broadcast(event *SSEEvent) { - if event == nil || !event.hasKnownVisibility() { - return - } - frame := event.Frame() - if len(frame) == 0 { - return - } +func (h *SSEHub) publishMemoChanged() { + frame := []byte(memoChangedSSEFrame) var slowClients []*SSEClient h.mu.RLock() for c := range h.clients { - if !c.canReceive(event) { - continue - } select { case c.events <- frame: default: @@ -162,24 +95,3 @@ func (h *SSEHub) Broadcast(event *SSEEvent) { h.Unsubscribe(c) } } - -func (e *SSEEvent) hasKnownVisibility() bool { - switch e.Visibility { - case store.Private, store.Public, store.Protected, "": - return true - default: - slog.Warn("SSE event has unknown visibility; denying broadcast", "visibility", string(e.Visibility)) - return false - } -} - -func (c *SSEClient) canReceive(event *SSEEvent) bool { - switch event.Visibility { - case store.Private: - return c.userID == event.CreatorID || c.role == store.RoleAdmin - case store.Public, store.Protected, "": - return true - default: - return false - } -} diff --git a/server/router/api/v1/sse_hub_test.go b/server/router/api/v1/sse_hub_test.go index e3c0da7f..5e25976a 100644 --- a/server/router/api/v1/sse_hub_test.go +++ b/server/router/api/v1/sse_hub_test.go @@ -1,23 +1,19 @@ package v1 import ( - "fmt" "sync" "testing" "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - - "github.com/usememos/memos/store" ) -// helpers shared by multiple tests in this file. - func mustReceive(t *testing.T, ch <-chan []byte, within time.Duration) []byte { t.Helper() select { - case data := <-ch: + case data, ok := <-ch: + require.True(t, ok, "SSE event channel closed before an event arrived") return data case <-time.After(within): t.Fatal("timed out waiting for SSE event") @@ -28,167 +24,72 @@ func mustReceive(t *testing.T, ch <-chan []byte, within time.Duration) []byte { func mustNotReceive(t *testing.T, ch <-chan []byte, within time.Duration) { t.Helper() select { - case data := <-ch: - t.Fatalf("unexpected SSE event received: %s", data) + case data, ok := <-ch: + if ok { + t.Fatalf("unexpected SSE event received: %s", data) + } case <-time.After(within): } } -func TestSSEHub_SubscribeUnsubscribe(t *testing.T) { +func TestSSEHubSubscribeUnsubscribe(t *testing.T) { hub := NewSSEHub() - - client := hub.Subscribe(1, store.RoleUser) + client := hub.Subscribe() require.NotNil(t, client) require.NotNil(t, client.events) - // Unsubscribe removes the client and closes the channel. hub.Unsubscribe(client) - // Channel should be closed. _, ok := <-client.events - assert.False(t, ok, "channel should be closed after Unsubscribe") + assert.False(t, ok, "event channel should be closed after unsubscribe") _, ok = <-client.done - assert.False(t, ok, "done channel should be closed after Unsubscribe") + assert.False(t, ok, "done channel should be closed after unsubscribe") } -func TestSSEHub_Close(t *testing.T) { +func TestSSEHubClose(t *testing.T) { hub := NewSSEHub() - c1 := hub.Subscribe(1, store.RoleUser) - c2 := hub.Subscribe(2, store.RoleAdmin) + first := hub.Subscribe() + second := hub.Subscribe() hub.Close() hub.Close() - for _, ch := range []chan []byte{c1.events, c2.events} { + for _, ch := range []chan []byte{first.events, second.events} { _, ok := <-ch - assert.False(t, ok, "channel should be closed after hub close") + assert.False(t, ok, "event channel should be closed after hub close") } - for _, ch := range []chan struct{}{c1.done, c2.done} { + for _, ch := range []chan struct{}{first.done, second.done} { _, ok := <-ch assert.False(t, ok, "done channel should be closed after hub close") } - late := hub.Subscribe(3, store.RoleUser) + late := hub.Subscribe() _, ok := <-late.events assert.False(t, ok, "late subscriber should be closed immediately") - - hub.Broadcast(&SSEEvent{Type: SSEEventMemoCreated, Name: "memos/123"}) - hub.Unsubscribe(c1) - hub.Unsubscribe(late) + hub.publishMemoChanged() } -func TestSSEHub_Broadcast(t *testing.T) { +func TestSSEHubPublishMemoChangedBroadcastsToSubscribers(t *testing.T) { hub := NewSSEHub() - client := hub.Subscribe(1, store.RoleUser) - defer hub.Unsubscribe(client) + first := hub.Subscribe() + defer hub.Unsubscribe(first) + second := hub.Subscribe() + defer hub.Unsubscribe(second) - event := &SSEEvent{Type: SSEEventMemoCreated, Name: "memos/123"} - hub.Broadcast(event) + hub.publishMemoChanged() - select { - case data := <-client.events: - assert.Contains(t, string(data), `"type":"memo.created"`) - assert.Contains(t, string(data), `"name":"memos/123"`) - case <-time.After(time.Second): - t.Fatal("expected to receive event within 1s") + for _, client := range []*SSEClient{first, second} { + assert.Equal(t, memoChangedSSEFrame, string(mustReceive(t, client.events, time.Second))) } } -func TestSSEHub_BroadcastMultipleClients(t *testing.T) { +func TestSSEHubSlowClientIsDisconnected(t *testing.T) { hub := NewSSEHub() - c1 := hub.Subscribe(1, store.RoleUser) - defer hub.Unsubscribe(c1) - c2 := hub.Subscribe(2, store.RoleUser) - defer hub.Unsubscribe(c2) - - event := &SSEEvent{Type: SSEEventMemoDeleted, Name: "memos/456"} - hub.Broadcast(event) - - for _, ch := range []chan []byte{c1.events, c2.events} { - select { - case data := <-ch: - assert.Contains(t, string(data), "memo.deleted") - assert.Contains(t, string(data), "memos/456") - case <-time.After(time.Second): - t.Fatal("expected to receive event within 1s") - } - } -} - -func TestSSEEvent_JSON(t *testing.T) { - e := &SSEEvent{Type: SSEEventMemoUpdated, Name: "memos/789", Parent: "memos/123"} - data := e.JSON() - require.NotEmpty(t, data) - assert.Contains(t, string(data), `"type":"memo.updated"`) - assert.Contains(t, string(data), `"name":"memos/789"`) - assert.Contains(t, string(data), `"parent":"memos/123"`) -} - -func TestSSEEvent_Frame(t *testing.T) { - e := &SSEEvent{Type: SSEEventMemoUpdated, Name: "memos/789"} - assert.Equal(t, "data: {\"type\":\"memo.updated\",\"name\":\"memos/789\"}\n\n", string(e.Frame())) -} - -func TestSSEHub_PrivateEventsAreScoped(t *testing.T) { - hub := NewSSEHub() - owner := hub.Subscribe(1, store.RoleUser) - defer hub.Unsubscribe(owner) - other := hub.Subscribe(2, store.RoleUser) - defer hub.Unsubscribe(other) - admin := hub.Subscribe(3, store.RoleAdmin) - defer hub.Unsubscribe(admin) - - hub.Broadcast(&SSEEvent{ - Type: SSEEventMemoUpdated, - Name: "memos/private", - Visibility: store.Private, - CreatorID: 1, - }) - - select { - case <-owner.events: - case <-time.After(time.Second): - t.Fatal("owner should receive private event") - } - - select { - case <-admin.events: - case <-time.After(time.Second): - t.Fatal("admin should receive private event") - } - - select { - case <-other.events: - t.Fatal("non-owner should not receive private event") - case <-time.After(100 * time.Millisecond): - } -} - -func TestSSEHub_UnknownVisibilityDenied(t *testing.T) { - hub := NewSSEHub() - client := hub.Subscribe(1, store.RoleUser) - defer hub.Unsubscribe(client) - - // An event with an unrecognised visibility value should be denied (safe default). - hub.Broadcast(&SSEEvent{ - Type: SSEEventMemoUpdated, - Name: "memos/unknown-vis", - Visibility: store.Visibility("CUSTOM"), - }) - - mustNotReceive(t, client.events, 100*time.Millisecond) -} - -func TestSSEHub_SlowClientDisconnected(t *testing.T) { - hub := NewSSEHub() - // Subscribe but never read, so the channel fills up. - slow := hub.Subscribe(1, store.RoleUser) + slow := hub.Subscribe() defer hub.Unsubscribe(slow) - event := &SSEEvent{Type: SSEEventMemoCreated, Name: "memos/x"} - // Send more events than the buffer capacity. - for range sseClientEventBufferSize + 8 { - hub.Broadcast(event) // must not block + for range sseClientEventBufferSize + 1 { + hub.publishMemoChanged() } select { @@ -204,24 +105,19 @@ func TestSSEHub_SlowClientDisconnected(t *testing.T) { assert.Equal(t, sseClientEventBufferSize, received) } -func TestSSEHub_ConcurrentAccess(t *testing.T) { - hub := NewSSEHub() +func TestSSEHubConcurrentAccess(t *testing.T) { const ( workers = 16 iterations = 100 ) + hub := NewSSEHub() var wg sync.WaitGroup - for workerID := range workers { + for range workers { wg.Go(func() { - for iteration := range iterations { - client := hub.Subscribe(int32(workerID+1), store.RoleUser) - hub.Broadcast(&SSEEvent{ - Type: SSEEventMemoUpdated, - Name: fmt.Sprintf("memos/%d-%d", workerID, iteration), - Visibility: store.Private, - CreatorID: int32(workerID + 1), - }) + for range iterations { + client := hub.Subscribe() + hub.publishMemoChanged() select { case <-client.events: default: @@ -236,122 +132,3 @@ func TestSSEHub_ConcurrentAccess(t *testing.T) { defer hub.mu.RUnlock() assert.Empty(t, hub.clients) } - -func BenchmarkSSEHubBroadcast(b *testing.B) { - for _, clientCount := range []int{100, 1_000, 10_000} { - b.Run(fmt.Sprintf("public/%d", clientCount), func(b *testing.B) { - hub, clients := newBenchmarkSSEHub(clientCount) - defer hub.Close() - event := &SSEEvent{Type: SSEEventMemoUpdated, Name: "memos/benchmark", Visibility: store.Public} - - b.ReportAllocs() - b.ResetTimer() - for b.Loop() { - hub.Broadcast(event) - for _, client := range clients { - <-client.events - } - } - }) - - b.Run(fmt.Sprintf("private/%d", clientCount), func(b *testing.B) { - hub, clients := newBenchmarkSSEHub(clientCount) - defer hub.Close() - event := &SSEEvent{ - Type: SSEEventMemoUpdated, - Name: "memos/benchmark", - Visibility: store.Private, - CreatorID: 1, - } - - b.ReportAllocs() - b.ResetTimer() - for b.Loop() { - hub.Broadcast(event) - <-clients[0].events - <-clients[1].events - } - }) - } -} - -func newBenchmarkSSEHub(clientCount int) (*SSEHub, []*SSEClient) { - hub := NewSSEHub() - clients := make([]*SSEClient, 0, clientCount) - for i := range clientCount { - role := store.RoleUser - if i == 1 { - role = store.RoleAdmin - } - clients = append(clients, hub.Subscribe(int32(i+1), role)) - } - return hub, clients -} - -func TestResolveSSECreatorID(t *testing.T) { - tests := []struct { - name string - memo *store.Memo - parentMemo *store.Memo - want int32 - }{ - { - name: "nil memo returns 0", - memo: nil, parentMemo: nil, - want: 0, - }, - { - name: "memo without parent returns memo CreatorID", - memo: &store.Memo{CreatorID: 5}, - parentMemo: nil, - want: 5, - }, - { - name: "memo with parent returns parent CreatorID", - memo: &store.Memo{CreatorID: 5}, - parentMemo: &store.Memo{CreatorID: 9}, - want: 9, - }, - } - for _, tc := range tests { - t.Run(tc.name, func(t *testing.T) { - assert.Equal(t, tc.want, resolveSSECreatorID(tc.memo, tc.parentMemo)) - }) - } -} - -func TestBuildMemoReactionSSEEvent(t *testing.T) { - parentUID := "parent-uid" - - t.Run("top-level memo reaction", func(t *testing.T) { - memo := &store.Memo{CreatorID: 10, Visibility: store.Public} - event := buildMemoReactionSSEEvent(SSEEventReactionUpserted, "memos/abc", memo, nil) - assert.Equal(t, SSEEventReactionUpserted, event.Type) - assert.Equal(t, "memos/abc", event.Name) - assert.Equal(t, "", event.Parent) - assert.Equal(t, store.Public, event.Visibility) - assert.Equal(t, int32(10), event.CreatorID) - }) - - t.Run("reaction on comment is scoped to parent owner", func(t *testing.T) { - memo := &store.Memo{ - CreatorID: 10, - Visibility: store.Private, - ParentUID: &parentUID, - } - parentMemo := &store.Memo{CreatorID: 7} - event := buildMemoReactionSSEEvent(SSEEventReactionDeleted, "memos/abc", memo, parentMemo) - assert.Equal(t, SSEEventReactionDeleted, event.Type) - assert.Equal(t, MemoNamePrefix+parentUID, event.Parent) - assert.Equal(t, store.Private, event.Visibility) - assert.Equal(t, int32(7), event.CreatorID) - }) - - t.Run("nil memo produces a safe zero-value event", func(t *testing.T) { - event := buildMemoReactionSSEEvent(SSEEventReactionUpserted, "memos/abc", nil, nil) - assert.Equal(t, "memos/abc", event.Name) - assert.Equal(t, "", event.Parent) - assert.Equal(t, store.Visibility(""), event.Visibility) - assert.Equal(t, int32(0), event.CreatorID) - }) -} diff --git a/server/router/api/v1/sse_service_test.go b/server/router/api/v1/sse_service_test.go index 2c1e33c7..5964230e 100644 --- a/server/router/api/v1/sse_service_test.go +++ b/server/router/api/v1/sse_service_test.go @@ -2,15 +2,21 @@ package v1 import ( "context" - "strings" + "fmt" + "os" + "path/filepath" "testing" "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/types/known/fieldmaskpb" "github.com/usememos/memos/internal/profile" v1pb "github.com/usememos/memos/proto/gen/api/v1" + storepb "github.com/usememos/memos/proto/gen/store" "github.com/usememos/memos/server/auth" "github.com/usememos/memos/store" teststore "github.com/usememos/memos/store/test" @@ -46,24 +52,334 @@ func collectEventsFor(ch <-chan []byte, d time.Duration) []string { } } -// ---- context suppression ---- +func requireMemoChanged(t *testing.T, ch <-chan []byte) { + t.Helper() + require.Equal(t, memoChangedSSEFrame, string(mustReceive(t, ch, time.Second))) +} -func TestSuppressSSEContext(t *testing.T) { +func requireNoMemoChanged(t *testing.T, ch <-chan []byte) { + t.Helper() + select { + case event := <-ch: + require.Failf(t, "unexpected SSE event", "received %q", event) + default: + } +} + +func TestAttachmentMutationsPublishMemoChangedOnlyWhenBound(t *testing.T) { ctx := context.Background() - - t.Run("default context is not suppressed", func(t *testing.T) { - assert.False(t, isSSESuppressed(ctx)) + svc := newIntegrationService(t) + owner := createSpaceTestUser(ctx, t, svc, "sse-attachment-owner", store.RoleUser) + ownerCtx := userCtx(ctx, owner.ID) + memo, err := svc.CreateMemo(ownerCtx, &v1pb.CreateMemoRequest{ + Memo: &v1pb.Memo{Content: "attachment event memo", Visibility: v1pb.Visibility_PRIVATE}, }) + require.NoError(t, err) - t.Run("withSuppressSSE marks context as suppressed", func(t *testing.T) { - assert.True(t, isSSESuppressed(withSuppressSSE(ctx))) - }) + client := svc.SSEHub.Subscribe() + defer svc.SSEHub.Unsubscribe(client) + createAttachment := func(filename string, memoName *string) *v1pb.Attachment { + t.Helper() + attachment, err := svc.CreateAttachment(ownerCtx, &v1pb.CreateAttachmentRequest{Attachment: &v1pb.Attachment{ + Filename: filename, + Type: "text/plain", + Content: []byte(filename), + Memo: memoName, + }}) + require.NoError(t, err) + return attachment + } - t.Run("suppression does not bleed into parent context", func(t *testing.T) { - suppressed := withSuppressSSE(ctx) - _ = suppressed - assert.False(t, isSSESuppressed(ctx)) + unbound := createAttachment("sse-unbound.txt", nil) + requireNoMemoChanged(t, client.events) + _, err = svc.UpdateAttachment(ownerCtx, &v1pb.UpdateAttachmentRequest{ + Attachment: &v1pb.Attachment{Name: unbound.Name, Filename: "sse-unbound-renamed.txt"}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"filename"}}, }) + require.NoError(t, err) + requireNoMemoChanged(t, client.events) + _, err = svc.DeleteAttachment(ownerCtx, &v1pb.DeleteAttachmentRequest{Name: unbound.Name}) + require.NoError(t, err) + requireNoMemoChanged(t, client.events) + + bound := createAttachment("sse-bound.txt", &memo.Name) + requireMemoChanged(t, client.events) + _, err = svc.UpdateAttachment(ownerCtx, &v1pb.UpdateAttachmentRequest{ + Attachment: &v1pb.Attachment{Name: bound.Name, Filename: "sse-bound-renamed.txt"}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"filename"}}, + }) + require.NoError(t, err) + requireMemoChanged(t, client.events) + _, err = svc.DeleteAttachment(ownerCtx, &v1pb.DeleteAttachmentRequest{Name: bound.Name}) + require.NoError(t, err) + requireMemoChanged(t, client.events) + + firstUnbound := createAttachment("sse-batch-unbound-first.txt", nil) + secondUnbound := createAttachment("sse-batch-unbound-second.txt", nil) + requireNoMemoChanged(t, client.events) + _, err = svc.BatchDeleteAttachments(ownerCtx, &v1pb.BatchDeleteAttachmentsRequest{ + Names: []string{firstUnbound.Name, secondUnbound.Name}, + }) + require.NoError(t, err) + requireNoMemoChanged(t, client.events) + + mixedUnbound := createAttachment("sse-batch-mixed-unbound.txt", nil) + mixedBound := createAttachment("sse-batch-mixed-bound.txt", &memo.Name) + requireMemoChanged(t, client.events) + _, err = svc.BatchDeleteAttachments(ownerCtx, &v1pb.BatchDeleteAttachmentsRequest{ + Names: []string{mixedUnbound.Name, mixedBound.Name}, + }) + require.NoError(t, err) + requireMemoChanged(t, client.events) +} + +func TestUpdateAttachmentPublishesAfterCommittedAccessChange(t *testing.T) { + ctx := context.Background() + svc := newIntegrationService(t) + owner := createSpaceTestUser(ctx, t, svc, "sse-attachment-access-owner", store.RoleUser) + ownerCtx := userCtx(ctx, owner.ID) + space, err := svc.CreateSpace(ownerCtx, &v1pb.CreateSpaceRequest{ + SpaceId: "sse-attachment-access-space", + Space: &v1pb.Space{Title: "Attachment access space"}, + }) + require.NoError(t, err) + spaceName := space.Name + memo, err := svc.CreateMemo(ownerCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{ + Content: "attachment access changed during update", + Visibility: v1pb.Visibility_SPACE, + Space: &spaceName, + }}) + require.NoError(t, err) + attachment, err := svc.CreateAttachment(ownerCtx, &v1pb.CreateAttachmentRequest{Attachment: &v1pb.Attachment{ + Filename: "before.txt", + Type: "text/plain", + Content: []byte("attachment"), + Memo: &memo.Name, + }}) + require.NoError(t, err) + attachmentUID, err := ExtractAttachmentUIDFromName(attachment.Name) + require.NoError(t, err) + storedAttachment, err := svc.Store.GetAttachment(ctx, &store.FindAttachment{UID: &attachmentUID}) + require.NoError(t, err) + require.NotNil(t, storedAttachment) + + // Authorization is checked before the attachment update. Simulate membership + // changing in the same transaction so the committed response can no longer be + // built through the read-authorized GetAttachment service method. + trigger := fmt.Sprintf(` + CREATE TRIGGER revoke_attachment_owner_membership + AFTER UPDATE OF filename ON attachment + WHEN NEW.id = %d + BEGIN + DELETE FROM space_member WHERE user_id = %d; + END`, storedAttachment.ID, owner.ID) + _, err = svc.Store.GetDriver().GetDB().ExecContext(ctx, trigger) + require.NoError(t, err) + + client := svc.SSEHub.Subscribe() + defer svc.SSEHub.Unsubscribe(client) + updated, err := svc.UpdateAttachment(ownerCtx, &v1pb.UpdateAttachmentRequest{ + Attachment: &v1pb.Attachment{Name: attachment.Name, Filename: "after.txt"}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"filename"}}, + }) + require.NoError(t, err) + require.Equal(t, "after.txt", updated.Filename) + requireMemoChanged(t, client.events) + requireNoMemoChanged(t, client.events) + + _, err = svc.GetAttachment(ownerCtx, &v1pb.GetAttachmentRequest{Name: attachment.Name}) + require.Equal(t, codes.PermissionDenied, status.Code(err), "the authorized read would fail after the committed membership change") +} + +func TestDeleteAttachmentPublishesBeforeStorageCleanupFailure(t *testing.T) { + ctx := context.Background() + svc := newIntegrationService(t) + owner := createSpaceTestUser(ctx, t, svc, "sse-attachment-cleanup-owner", store.RoleUser) + ownerCtx := userCtx(ctx, owner.ID) + memo, err := svc.CreateMemo(ownerCtx, &v1pb.CreateMemoRequest{ + Memo: &v1pb.Memo{Content: "attachment cleanup failure", Visibility: v1pb.Visibility_PRIVATE}, + }) + require.NoError(t, err) + attachment, err := svc.CreateAttachment(ownerCtx, &v1pb.CreateAttachmentRequest{Attachment: &v1pb.Attachment{ + Filename: "cleanup.txt", + Type: "text/plain", + Content: []byte("attachment"), + Memo: &memo.Name, + }}) + require.NoError(t, err) + + client := svc.SSEHub.Subscribe() + defer svc.SSEHub.Unsubscribe(client) + _, err = svc.DeleteAttachment(store.WithDeleteAttachmentStorageFailpoint(ownerCtx), &v1pb.DeleteAttachmentRequest{Name: attachment.Name}) + require.Equal(t, codes.Internal, status.Code(err)) + require.ErrorContains(t, err, "attachments were deleted but storage cleanup failed") + requireMemoChanged(t, client.events) + requireNoMemoChanged(t, client.events) + + attachmentUID, err := ExtractAttachmentUIDFromName(attachment.Name) + require.NoError(t, err) + storedAttachment, err := svc.Store.GetAttachment(ctx, &store.FindAttachment{UID: &attachmentUID}) + require.NoError(t, err) + require.Nil(t, storedAttachment, "the database deletion must remain committed") +} + +func TestSpaceMutationsPublishMemoChanged(t *testing.T) { + ctx := context.Background() + svc := newIntegrationService(t) + owner := createSpaceTestUser(ctx, t, svc, "sse-space-owner", store.RoleAdmin) + member := createSpaceTestUser(ctx, t, svc, "sse-space-member", store.RoleUser) + ownerCtx := userCtx(ctx, owner.ID) + client := svc.SSEHub.Subscribe() + defer svc.SSEHub.Unsubscribe(client) + + space, err := svc.CreateSpace(ownerCtx, &v1pb.CreateSpaceRequest{ + SpaceId: "sse-space", + Space: &v1pb.Space{Title: "SSE Space"}, + }) + require.NoError(t, err) + requireMemoChanged(t, client.events) + + space.Title = "Renamed SSE Space" + _, err = svc.UpdateSpace(ownerCtx, &v1pb.UpdateSpaceRequest{ + Space: space, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"title"}}, + }) + require.NoError(t, err) + requireMemoChanged(t, client.events) + + membership, err := svc.CreateSpaceMember(ownerCtx, &v1pb.CreateSpaceMemberRequest{ + Parent: space.Name, + SpaceMember: &v1pb.SpaceMember{ + User: BuildUserName(member.Username), + Role: v1pb.SpaceMember_USER, + }, + }) + require.NoError(t, err) + requireMemoChanged(t, client.events) + + membership.Role = v1pb.SpaceMember_ADMIN + _, err = svc.UpdateSpaceMember(ownerCtx, &v1pb.UpdateSpaceMemberRequest{ + SpaceMember: membership, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"role"}}, + }) + require.NoError(t, err) + requireMemoChanged(t, client.events) + + _, err = svc.DeleteSpaceMember(ownerCtx, &v1pb.DeleteSpaceMemberRequest{Name: membership.Name}) + require.NoError(t, err) + requireMemoChanged(t, client.events) + + _, err = svc.DeleteSpace(ownerCtx, &v1pb.DeleteSpaceRequest{Name: space.Name}) + require.NoError(t, err) + requireMemoChanged(t, client.events) +} + +func TestUpdateMemoSSEBroadcastsToAllSubscribers(t *testing.T) { + ctx := context.Background() + svc := newIntegrationService(t) + owner, err := svc.Store.CreateUser(ctx, &store.User{ + Username: "audience-owner", Role: store.RoleAdmin, Email: "audience-owner@example.com", + }) + require.NoError(t, err) + ownerCtx := userCtx(ctx, owner.ID) + memo, err := svc.CreateMemo(ownerCtx, &v1pb.CreateMemoRequest{ + Memo: &v1pb.Memo{Content: "public before update", Visibility: v1pb.Visibility_PUBLIC}, + }) + require.NoError(t, err) + + ownerClient := svc.SSEHub.Subscribe() + defer svc.SSEHub.Unsubscribe(ownerClient) + otherClient := svc.SSEHub.Subscribe() + defer svc.SSEHub.Unsubscribe(otherClient) + + _, err = svc.UpdateMemo(ownerCtx, &v1pb.UpdateMemoRequest{ + Memo: &v1pb.Memo{Name: memo.Name, Visibility: v1pb.Visibility_PRIVATE}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"visibility"}}, + }) + require.NoError(t, err) + requireMemoChanged(t, ownerClient.events) + requireMemoChanged(t, otherClient.events) + + _, err = svc.UpdateMemo(ownerCtx, &v1pb.UpdateMemoRequest{ + Memo: &v1pb.Memo{Name: memo.Name, Content: "private after update"}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"content"}}, + }) + require.NoError(t, err) + requireMemoChanged(t, ownerClient.events) + requireMemoChanged(t, otherClient.events) +} + +func TestMoveSpaceAudienceMemoSSEBroadcastsWithoutAudienceCalculation(t *testing.T) { + ctx := context.Background() + svc := newIntegrationService(t) + owner := createSpaceTestUser(ctx, t, svc, "move-audience-owner", store.RoleAdmin) + sourceMember := createSpaceTestUser(ctx, t, svc, "move-source-member", store.RoleUser) + targetMember := createSpaceTestUser(ctx, t, svc, "move-target-member", store.RoleUser) + ownerCtx := userCtx(ctx, owner.ID) + + source, err := svc.CreateSpace(ownerCtx, &v1pb.CreateSpaceRequest{ + SpaceId: "move-source-space", + Space: &v1pb.Space{Title: "Source"}, + }) + require.NoError(t, err) + target, err := svc.CreateSpace(ownerCtx, &v1pb.CreateSpaceRequest{ + SpaceId: "move-target-space", + Space: &v1pb.Space{Title: "Target"}, + }) + require.NoError(t, err) + _, err = svc.CreateSpaceMember(ownerCtx, &v1pb.CreateSpaceMemberRequest{ + Parent: source.Name, + SpaceMember: &v1pb.SpaceMember{ + User: BuildUserName(sourceMember.Username), + Role: v1pb.SpaceMember_USER, + }, + }) + require.NoError(t, err) + _, err = svc.CreateSpaceMember(ownerCtx, &v1pb.CreateSpaceMemberRequest{ + Parent: target.Name, + SpaceMember: &v1pb.SpaceMember{ + User: BuildUserName(targetMember.Username), + Role: v1pb.SpaceMember_USER, + }, + }) + require.NoError(t, err) + + sourceName := source.Name + memo, err := svc.CreateMemo(ownerCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{ + Content: "move between spaces", + Visibility: v1pb.Visibility_SPACE, + Space: &sourceName, + }}) + require.NoError(t, err) + sourceClient := svc.SSEHub.Subscribe() + defer svc.SSEHub.Unsubscribe(sourceClient) + targetClient := svc.SSEHub.Subscribe() + defer svc.SSEHub.Unsubscribe(targetClient) + outsiderClient := svc.SSEHub.Subscribe() + defer svc.SSEHub.Unsubscribe(outsiderClient) + + targetName := target.Name + _, err = svc.UpdateMemo(ownerCtx, &v1pb.UpdateMemoRequest{ + Memo: &v1pb.Memo{ + Name: memo.Name, + Visibility: v1pb.Visibility_SPACE, + Space: &targetName, + }, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"space", "visibility"}}, + }) + require.NoError(t, err) + requireMemoChanged(t, sourceClient.events) + requireMemoChanged(t, targetClient.events) + requireMemoChanged(t, outsiderClient.events) + + _, err = svc.UpdateMemo(ownerCtx, &v1pb.UpdateMemoRequest{ + Memo: &v1pb.Memo{Name: memo.Name, Content: "target only now"}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"content"}}, + }) + require.NoError(t, err) + requireMemoChanged(t, sourceClient.events) + requireMemoChanged(t, targetClient.events) + requireMemoChanged(t, outsiderClient.events) } // ---- CreateMemoComment double-broadcast fix ---- @@ -91,13 +407,12 @@ func TestCreateMemoComment_NoDuplicateSSEBroadcast(t *testing.T) { }) require.NoError(t, err) - // Subscribe after the parent memo is created so the memo.created event - // for the parent does not pollute the assertion window. - client := svc.SSEHub.Subscribe(author.ID, store.RoleAdmin) + // Subscribe after the parent memo is created so its change event does not + // pollute the assertion window. + client := svc.SSEHub.Subscribe() defer svc.SSEHub.Unsubscribe(client) - // Create a comment. Before the fix, this fired both memo.created (for the - // comment memo) and memo.comment.created (for the parent). + // Comment creation is one mutation and emits one invalidation event. _, err = svc.CreateMemoComment(commenterCtx, &v1pb.CreateMemoCommentRequest{ Name: parent.Name, Comment: &v1pb.Memo{Content: "a comment", Visibility: v1pb.Visibility_PUBLIC}, @@ -109,8 +424,40 @@ func TestCreateMemoComment_NoDuplicateSSEBroadcast(t *testing.T) { events := collectEventsFor(client.events, 150*time.Millisecond) require.Len(t, events, 1, "expected exactly one SSE event for a comment creation, got: %v", events) - assert.True(t, strings.Contains(events[0], `"memo.comment.created"`), - "expected memo.comment.created, got: %s", events[0]) + assert.Equal(t, memoChangedSSEFrame, events[0]) +} + +func TestCreateMemoComment_SSEBroadcastContainsNoSubject(t *testing.T) { + ctx := context.Background() + svc := newIntegrationService(t) + author, err := svc.Store.CreateUser(ctx, &store.User{ + Username: "comment-context-author", Role: store.RoleAdmin, Email: "comment-context-author@example.com", + }) + require.NoError(t, err) + commenter, err := svc.Store.CreateUser(ctx, &store.User{ + Username: "private-comment-author", Role: store.RoleUser, Email: "private-comment-author@example.com", + }) + require.NoError(t, err) + + parent, err := svc.CreateMemo(userCtx(ctx, author.ID), &v1pb.CreateMemoRequest{ + Memo: &v1pb.Memo{Content: "public context", Visibility: v1pb.Visibility_PUBLIC}, + }) + require.NoError(t, err) + authorClient := svc.SSEHub.Subscribe() + defer svc.SSEHub.Unsubscribe(authorClient) + commenterClient := svc.SSEHub.Subscribe() + defer svc.SSEHub.Unsubscribe(commenterClient) + + _, err = svc.CreateMemoComment(userCtx(ctx, commenter.ID), &v1pb.CreateMemoCommentRequest{ + Name: parent.Name, + Comment: &v1pb.Memo{ + Content: "private reply", + Visibility: v1pb.Visibility_PRIVATE, + }, + }) + require.NoError(t, err) + requireMemoChanged(t, commenterClient.events) + requireMemoChanged(t, authorClient.events) } func TestCreateMemoWithAttachment_NoDuplicateUpdatedSSEBroadcast(t *testing.T) { @@ -133,10 +480,10 @@ func TestCreateMemoWithAttachment_NoDuplicateUpdatedSSEBroadcast(t *testing.T) { }) require.NoError(t, err) - client := svc.SSEHub.Subscribe(user.ID, store.RoleAdmin) + client := svc.SSEHub.Subscribe() defer svc.SSEHub.Unsubscribe(client) - memo, err := svc.CreateMemo(uctx, &v1pb.CreateMemoRequest{ + _, err = svc.CreateMemo(uctx, &v1pb.CreateMemoRequest{ Memo: &v1pb.Memo{ Content: "memo with initial attachment", Visibility: v1pb.Visibility_PUBLIC, @@ -150,14 +497,10 @@ func TestCreateMemoWithAttachment_NoDuplicateUpdatedSSEBroadcast(t *testing.T) { events := collectEventsFor(client.events, 150*time.Millisecond) require.Len(t, events, 1, "expected exactly one SSE event for memo creation with attachment, got: %v", events) - assert.Contains(t, events[0], `"memo.created"`) - assert.Contains(t, events[0], memo.Name) - assert.NotContains(t, events[0], `"memo.updated"`) + assert.Equal(t, memoChangedSSEFrame, events[0]) } -// ---- Reaction SSE events carry correct visibility / parent fields ---- - -func TestUpsertMemoReaction_SSEEvent(t *testing.T) { +func TestUpsertMemoReactionPublishesMemoChanged(t *testing.T) { ctx := context.Background() svc := newIntegrationService(t) @@ -172,7 +515,7 @@ func TestUpsertMemoReaction_SSEEvent(t *testing.T) { }) require.NoError(t, err) - client := svc.SSEHub.Subscribe(user.ID, store.RoleAdmin) + client := svc.SSEHub.Subscribe() defer svc.SSEHub.Unsubscribe(client) _, err = svc.UpsertMemoReaction(uctx, &v1pb.UpsertMemoReactionRequest{ @@ -183,14 +526,11 @@ func TestUpsertMemoReaction_SSEEvent(t *testing.T) { }) require.NoError(t, err) - data := mustReceive(t, client.events, time.Second) - payload := string(data) - assert.Contains(t, payload, `"reaction.upserted"`) - assert.Contains(t, payload, memo.Name) + requireMemoChanged(t, client.events) mustNotReceive(t, client.events, 100*time.Millisecond) } -func TestDeleteMemoReaction_SSEEvent(t *testing.T) { +func TestDeleteMemoReactionPublishesMemoChanged(t *testing.T) { ctx := context.Background() svc := newIntegrationService(t) @@ -213,7 +553,7 @@ func TestDeleteMemoReaction_SSEEvent(t *testing.T) { }) require.NoError(t, err) - client := svc.SSEHub.Subscribe(user.ID, store.RoleAdmin) + client := svc.SSEHub.Subscribe() defer svc.SSEHub.Unsubscribe(client) _, err = svc.DeleteMemoReaction(uctx, &v1pb.DeleteMemoReactionRequest{ @@ -221,14 +561,113 @@ func TestDeleteMemoReaction_SSEEvent(t *testing.T) { }) require.NoError(t, err) - data := mustReceive(t, client.events, time.Second) - payload := string(data) - assert.Contains(t, payload, `"reaction.deleted"`) - assert.Contains(t, payload, memo.Name) + requireMemoChanged(t, client.events) mustNotReceive(t, client.events, 100*time.Millisecond) } -func TestSetMemoAttachments_EmitsMemoUpdatedSSEEvent(t *testing.T) { +func TestDeleteMemo_DeletesOnlyRequestedMemo(t *testing.T) { + ctx := context.Background() + svc := newIntegrationService(t) + rootAuthor, err := svc.Store.CreateUser(ctx, &store.User{ + Username: "delete-root-author", Role: store.RoleAdmin, Email: "delete-root-author@example.com", + }) + require.NoError(t, err) + commentAuthor, err := svc.Store.CreateUser(ctx, &store.User{ + Username: "delete-comment-author", Role: store.RoleUser, Email: "delete-comment-author@example.com", + }) + require.NoError(t, err) + replyAuthor, err := svc.Store.CreateUser(ctx, &store.User{ + Username: "delete-reply-author", Role: store.RoleUser, Email: "delete-reply-author@example.com", + }) + require.NoError(t, err) + + root, err := svc.CreateMemo(userCtx(ctx, rootAuthor.ID), &v1pb.CreateMemoRequest{ + Memo: &v1pb.Memo{Content: "context memo", Visibility: v1pb.Visibility_PUBLIC}, + }) + require.NoError(t, err) + comment, err := svc.CreateMemoComment(userCtx(ctx, commentAuthor.ID), &v1pb.CreateMemoCommentRequest{ + Name: root.Name, + Comment: &v1pb.Memo{Content: "branch", Visibility: v1pb.Visibility_PUBLIC}, + }) + require.NoError(t, err) + reply, err := svc.CreateMemoComment(userCtx(ctx, replyAuthor.ID), &v1pb.CreateMemoCommentRequest{ + Name: comment.Name, + Comment: &v1pb.Memo{Content: "nested reply"}, + }) + require.NoError(t, err) + + replyClient := svc.SSEHub.Subscribe() + defer svc.SSEHub.Unsubscribe(replyClient) + _, err = svc.DeleteMemo(userCtx(ctx, commentAuthor.ID), &v1pb.DeleteMemoRequest{Name: comment.Name}) + require.NoError(t, err) + requireMemoChanged(t, replyClient.events) + + commentUID, err := ExtractMemoUIDFromName(comment.Name) + require.NoError(t, err) + storedComment, err := svc.Store.GetMemo(ctx, &store.FindMemo{UID: &commentUID}) + require.NoError(t, err) + require.Nil(t, storedComment) + replyUID, err := ExtractMemoUIDFromName(reply.Name) + require.NoError(t, err) + storedReply, err := svc.Store.GetMemo(ctx, &store.FindMemo{UID: &replyUID}) + require.NoError(t, err) + require.NotNil(t, storedReply, "deleting a COMMENT endpoint must not cascade to the replying memo") + rootUID, err := ExtractMemoUIDFromName(root.Name) + require.NoError(t, err) + storedRoot, err := svc.Store.GetMemo(ctx, &store.FindMemo{UID: &rootUID}) + require.NoError(t, err) + require.NotNil(t, storedRoot) +} + +func TestDeleteMemoCleansAttachmentStorage(t *testing.T) { + ctx := context.Background() + svc := newIntegrationService(t) + owner, err := svc.Store.CreateUser(ctx, &store.User{ + Username: "delete-cleanup-owner", Role: store.RoleAdmin, Email: "delete-cleanup-owner@example.com", + }) + require.NoError(t, err) + ownerCtx := userCtx(ctx, owner.ID) + memo, err := svc.CreateMemo(ownerCtx, &v1pb.CreateMemoRequest{ + Memo: &v1pb.Memo{Content: "attachment cleanup", Visibility: v1pb.Visibility_PRIVATE}, + }) + require.NoError(t, err) + memoUID, err := ExtractMemoUIDFromName(memo.Name) + require.NoError(t, err) + storedMemo, err := svc.Store.GetMemo(ctx, &store.FindMemo{UID: &memoUID}) + require.NoError(t, err) + require.NotNil(t, storedMemo) + attachmentPath := filepath.Join(t.TempDir(), "sse-delete-cleanup.txt") + require.NoError(t, os.WriteFile(attachmentPath, []byte("cleanup"), 0o600)) + attachment, err := svc.Store.CreateAttachment(ctx, &store.Attachment{ + UID: "sse-delete-cleanup", + CreatorID: owner.ID, + Filename: "cleanup.txt", + Type: "text/plain", + Size: 7, + Blob: []byte("cleanup"), + StorageType: storepb.AttachmentStorageType_LOCAL, + Reference: attachmentPath, + MemoID: &storedMemo.ID, + }) + require.NoError(t, err) + + client := svc.SSEHub.Subscribe() + defer svc.SSEHub.Unsubscribe(client) + _, err = svc.DeleteMemo(ownerCtx, &v1pb.DeleteMemoRequest{Name: memo.Name}) + require.NoError(t, err, "committed deletion must not be reported as a failure") + requireMemoChanged(t, client.events) + + deletedMemo, err := svc.Store.GetMemo(ctx, &store.FindMemo{UID: &memoUID}) + require.NoError(t, err) + require.Nil(t, deletedMemo) + deletedAttachment, err := svc.Store.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID}) + require.NoError(t, err) + require.Nil(t, deletedAttachment) + _, err = os.Stat(attachmentPath) + require.ErrorIs(t, err, os.ErrNotExist) +} + +func TestSetMemoAttachmentsPublishesMemoChanged(t *testing.T) { ctx := context.Background() svc := newIntegrationService(t) @@ -253,7 +692,7 @@ func TestSetMemoAttachments_EmitsMemoUpdatedSSEEvent(t *testing.T) { }) require.NoError(t, err) - client := svc.SSEHub.Subscribe(user.ID, store.RoleAdmin) + client := svc.SSEHub.Subscribe() defer svc.SSEHub.Unsubscribe(client) _, err = svc.SetMemoAttachments(uctx, &v1pb.SetMemoAttachmentsRequest{ @@ -264,14 +703,11 @@ func TestSetMemoAttachments_EmitsMemoUpdatedSSEEvent(t *testing.T) { }) require.NoError(t, err) - data := mustReceive(t, client.events, time.Second) - payload := string(data) - assert.Contains(t, payload, `"memo.updated"`) - assert.Contains(t, payload, memo.Name) + requireMemoChanged(t, client.events) mustNotReceive(t, client.events, 100*time.Millisecond) } -func TestSetMemoRelations_EmitsMemoUpdatedSSEEvent(t *testing.T) { +func TestSetMemoRelationsPublishesMemoChanged(t *testing.T) { ctx := context.Background() svc := newIntegrationService(t) @@ -290,7 +726,7 @@ func TestSetMemoRelations_EmitsMemoUpdatedSSEEvent(t *testing.T) { }) require.NoError(t, err) - client := svc.SSEHub.Subscribe(user.ID, store.RoleAdmin) + client := svc.SSEHub.Subscribe() defer svc.SSEHub.Unsubscribe(client) _, err = svc.SetMemoRelations(uctx, &v1pb.SetMemoRelationsRequest{ @@ -304,9 +740,6 @@ func TestSetMemoRelations_EmitsMemoUpdatedSSEEvent(t *testing.T) { }) require.NoError(t, err) - data := mustReceive(t, client.events, time.Second) - payload := string(data) - assert.Contains(t, payload, `"memo.updated"`) - assert.Contains(t, payload, memo1.Name) + requireMemoChanged(t, client.events) mustNotReceive(t, client.events, 100*time.Millisecond) } diff --git a/server/router/api/v1/test/attachment_service_test.go b/server/router/api/v1/test/attachment_service_test.go index 1dd6361f..d9ad2df4 100644 --- a/server/router/api/v1/test/attachment_service_test.go +++ b/server/router/api/v1/test/attachment_service_test.go @@ -11,6 +11,7 @@ import ( "google.golang.org/grpc/codes" "google.golang.org/grpc/status" "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/types/known/fieldmaskpb" "github.com/usememos/memos/internal/testutil" v1pb "github.com/usememos/memos/proto/gen/api/v1" @@ -144,6 +145,109 @@ func TestCreateAttachment(t *testing.T) { }) } +func TestCreateAttachmentCleansSavedBlobWhenStoreCreateFails(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + ctx := context.Background() + + user, err := ts.CreateRegularUser(ctx, "attachment-create-compensation") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + _, err = ts.Store.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{ + Key: storepb.InstanceSettingKey_STORAGE, + Value: &storepb.InstanceSetting_StorageSetting{ + StorageSetting: &storepb.InstanceStorageSetting{ + StorageType: storepb.InstanceStorageSetting_LOCAL, + FilepathTemplate: "assets/{filename}", + }, + }, + }) + require.NoError(t, err) + + const attachmentID = "attachment-create-failure" + _, err = ts.Service.CreateAttachment(userCtx, &v1pb.CreateAttachmentRequest{ + AttachmentId: attachmentID, + Attachment: &v1pb.Attachment{ + Filename: "kept.txt", + Type: "text/plain", + Content: []byte("kept"), + }, + }) + require.NoError(t, err) + keptPath := filepath.Join(ts.Profile.Data, "assets", "kept.txt") + require.FileExists(t, keptPath) + + _, err = ts.Service.CreateAttachment(userCtx, &v1pb.CreateAttachmentRequest{ + AttachmentId: attachmentID, + Attachment: &v1pb.Attachment{ + Filename: "orphan.txt", + Type: "text/plain", + Content: []byte("must be removed"), + }, + }) + require.Equal(t, codes.Internal, status.Code(err)) + require.Contains(t, err.Error(), "failed to create attachment") + _, statErr := os.Stat(filepath.Join(ts.Profile.Data, "assets", "orphan.txt")) + require.ErrorIs(t, statErr, os.ErrNotExist) + kept, err := os.ReadFile(keptPath) + require.NoError(t, err) + require.Equal(t, []byte("kept"), kept) + + memo, err := ts.Service.CreateMemo(userCtx, &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{Content: "attachment compensation policy"}}) + require.NoError(t, err) + policyRejectionPath := filepath.Join(ts.Profile.Data, "assets", "policy-rejected.txt") + _, err = ts.Service.CreateAttachment(store.WithCreateAttachmentPolicyFailpoint(userCtx), &v1pb.CreateAttachmentRequest{ + AttachmentId: "attachment-policy-rejection", + Attachment: &v1pb.Attachment{ + Filename: "policy-rejected.txt", + Type: "text/plain", + Content: []byte("must be removed"), + Memo: &memo.Name, + }, + }) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + _, statErr = os.Stat(policyRejectionPath) + require.ErrorIs(t, statErr, os.ErrNotExist) + policyRejectionUID := "attachment-policy-rejection" + persistedPolicyRejection, err := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &policyRejectionUID}) + require.NoError(t, err) + require.Nil(t, persistedPolicyRejection) + + postCommitPath := filepath.Join(ts.Profile.Data, "assets", "post-commit.txt") + _, err = ts.Service.CreateAttachment(store.WithCreateAttachmentPostCommitFailpoint(userCtx), &v1pb.CreateAttachmentRequest{ + AttachmentId: "attachment-post-commit", + Attachment: &v1pb.Attachment{ + Filename: "post-commit.txt", + Type: "text/plain", + Content: []byte("must be preserved"), + }, + }) + require.Equal(t, codes.Internal, status.Code(err)) + require.Contains(t, err.Error(), store.ErrCreateAttachmentPostCommitFailpoint.Error()) + require.FileExists(t, postCommitPath, "a matching persisted row must suppress compensation") + postCommitUID := "attachment-post-commit" + persistedPostCommit, err := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &postCommitUID}) + require.NoError(t, err) + require.NotNil(t, persistedPostCommit) + require.Equal(t, postCommitPath, filepath.FromSlash(persistedPostCommit.Reference)) + + cleanupFailurePath := filepath.Join(ts.Profile.Data, "assets", "cleanup-failure.txt") + t.Cleanup(func() { _ = os.Remove(cleanupFailurePath) }) + cleanupFailureCtx := store.WithDeleteAttachmentStorageFailpoint(store.WithCreateAttachmentPolicyFailpoint(userCtx)) + _, err = ts.Service.CreateAttachment(cleanupFailureCtx, &v1pb.CreateAttachmentRequest{ + AttachmentId: "attachment-cleanup-failure", + Attachment: &v1pb.Attachment{ + Filename: "cleanup-failure.txt", + Type: "text/plain", + Content: []byte("cleanup failure"), + Memo: &memo.Name, + }, + }) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + require.NotContains(t, err.Error(), store.ErrDeleteAttachmentStorageFailpoint.Error()) + require.FileExists(t, cleanupFailurePath, "the failpoint must prove compensation was attempted") +} + func TestAttachmentMetadataFollowsMemoVisibility(t *testing.T) { ctx := context.Background() ts := NewTestService(t) @@ -288,6 +392,94 @@ func TestCreateAttachmentMemoPermission(t *testing.T) { }) } +func TestLinkedAttachmentMutationsRevalidateMemoSpaceMembership(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + owner, err := ts.CreateRegularUser(ctx, "attachment-lifecycle-owner") + require.NoError(t, err) + member, err := ts.CreateRegularUser(ctx, "attachment-lifecycle-member") + require.NoError(t, err) + memberCtx := ts.CreateUserContext(ctx, member.ID) + space, err := ts.Store.CreateSpace(ctx, &store.Space{UID: "attachment-lifecycle-space", Title: "Attachment Lifecycle"}, owner.ID) + require.NoError(t, err) + _, err = ts.Store.CreateSpaceMember(ctx, &store.SpaceMember{ + SpaceID: space.ID, UserID: member.ID, Role: store.SpaceMemberRoleUser, + }, owner.ID) + require.NoError(t, err) + root, err := ts.Store.CreateMemo(ctx, &store.Memo{ + UID: "attachment-lifecycle-root", CreatorID: member.ID, Content: "root", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }) + require.NoError(t, err) + comment, err := ts.Store.CreateMemoComment(ctx, &store.Memo{ + UID: "attachment-lifecycle-comment", CreatorID: member.ID, Content: "comment", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }, root.ID, member.ID) + require.NoError(t, err) + memoName := apiv1.MemoNamePrefix + comment.UID + + createLinked := func(filename string) *v1pb.Attachment { + t.Helper() + attachment, createErr := ts.Service.CreateAttachment(memberCtx, &v1pb.CreateAttachmentRequest{Attachment: &v1pb.Attachment{ + Filename: filename, + Type: "text/plain", + Content: []byte(filename), + Memo: &memoName, + }}) + require.NoError(t, createErr) + return attachment + } + updateTarget := createLinked("update-before-revoke.txt") + deleteTarget := createLinked("delete-after-revoke.txt") + batchTarget := createLinked("batch-after-revoke.txt") + + _, err = ts.Service.UpdateAttachment(memberCtx, &v1pb.UpdateAttachmentRequest{ + Attachment: &v1pb.Attachment{Name: updateTarget.Name, Filename: "updated-before-revoke.txt"}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"filename"}}, + }) + require.NoError(t, err) + require.NoError(t, ts.Store.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: member.ID}, owner.ID)) + + _, err = ts.Service.CreateAttachment(memberCtx, &v1pb.CreateAttachmentRequest{Attachment: &v1pb.Attachment{ + Filename: "create-after-revoke.txt", Type: "text/plain", Content: []byte("blocked"), Memo: &memoName, + }}) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + _, err = ts.Service.UpdateAttachment(memberCtx, &v1pb.UpdateAttachmentRequest{ + Attachment: &v1pb.Attachment{Name: updateTarget.Name, Filename: "must-not-rename.txt"}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"filename"}}, + }) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + _, err = ts.Service.DeleteAttachment(memberCtx, &v1pb.DeleteAttachmentRequest{Name: deleteTarget.Name}) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + _, err = ts.Service.BatchDeleteAttachments(memberCtx, &v1pb.BatchDeleteAttachmentsRequest{Names: []string{batchTarget.Name}}) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + + for _, attachment := range []*v1pb.Attachment{updateTarget, deleteTarget, batchTarget} { + uid, extractErr := apiv1.ExtractAttachmentUIDFromName(attachment.Name) + require.NoError(t, extractErr) + stored, getErr := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid}) + require.NoError(t, getErr) + require.NotNil(t, stored) + require.NotNil(t, stored.MemoID) + require.Equal(t, comment.ID, *stored.MemoID) + } + updateUID, err := apiv1.ExtractAttachmentUIDFromName(updateTarget.Name) + require.NoError(t, err) + storedUpdate, err := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &updateUID}) + require.NoError(t, err) + require.Equal(t, "updated-before-revoke.txt", storedUpdate.Filename) + + _, err = ts.Store.CreateSpaceMember(ctx, &store.SpaceMember{ + SpaceID: space.ID, UserID: member.ID, Role: store.SpaceMemberRoleUser, + }, owner.ID) + require.NoError(t, err) + _, err = ts.Service.UpdateAttachment(memberCtx, &v1pb.UpdateAttachmentRequest{ + Attachment: &v1pb.Attachment{Name: updateTarget.Name, Filename: "renamed-after-rejoin.txt"}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"filename"}}, + }) + require.NoError(t, err) +} + func memoIDFromName(ctx context.Context, t *testing.T, ts *TestService, name string) int32 { t.Helper() memoUID, err := apiv1.ExtractMemoUIDFromName(name) @@ -519,7 +711,7 @@ func TestBatchDeleteAttachments(t *testing.T) { }) } -func TestBatchDeleteAttachmentsStorageFailureIsRetriable(t *testing.T) { +func TestBatchDeleteAttachmentsReportsPostCommitStorageCleanupFailure(t *testing.T) { ts := NewTestService(t) defer ts.Cleanup() ctx := context.Background() @@ -564,23 +756,21 @@ func TestBatchDeleteAttachmentsStorageFailureIsRetriable(t *testing.T) { names := []string{attachments[0].Name, attachments[1].Name} _, err = ts.Service.BatchDeleteAttachments(store.WithDeleteAttachmentStorageFailpoint(userCtx), &v1pb.BatchDeleteAttachmentsRequest{Names: names}) require.Equal(t, codes.Internal, status.Code(err)) + require.ErrorContains(t, err, "attachments were deleted but storage cleanup failed") + require.ErrorContains(t, err, store.ErrDeleteAttachmentStorageFailpoint.Error()) for _, attachment := range attachments { uid, err := apiv1.ExtractAttachmentUIDFromName(attachment.Name) require.NoError(t, err) stored, err := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid}) require.NoError(t, err) - require.NotNil(t, stored) - require.Nil(t, stored.MemoID) + require.Nil(t, stored) } listed, err := ts.Service.ListMemoAttachments(userCtx, &v1pb.ListMemoAttachmentsRequest{Name: memo.Name}) require.NoError(t, err) require.Empty(t, listed.Attachments) - - _, err = ts.Service.BatchDeleteAttachments(userCtx, &v1pb.BatchDeleteAttachmentsRequest{Names: names}) - require.NoError(t, err) for _, path := range localPaths { _, err := os.Stat(path) - require.ErrorIs(t, err, os.ErrNotExist) + require.NoError(t, err, "storage cleanup failure happens after the database deletion commits") } } diff --git a/server/router/api/v1/test/authz_test.go b/server/router/api/v1/test/authz_test.go index 8881b450..ea5e7f6e 100644 --- a/server/router/api/v1/test/authz_test.go +++ b/server/router/api/v1/test/authz_test.go @@ -28,6 +28,8 @@ func TestAuthorizerPrivateInstanceRegistration(t *testing.T) { createUser = "/memos.api.v1.UserService/CreateUser" signIn = "/memos.api.v1.AuthService/SignIn" listMemos = "/memos.api.v1.MemoService/ListMemos" + listReactions = "/memos.api.v1.MemoService/ListMemoReactions" + listRelations = "/memos.api.v1.MemoService/ListMemoRelations" getSharedMemo = "/memos.api.v1.MemoService/GetSharedMemo" ) @@ -39,10 +41,15 @@ func TestAuthorizerPrivateInstanceRegistration(t *testing.T) { require.NoError(t, authorizer.CheckAccess(ctx, signIn, nil)) require.NoError(t, authorizer.CheckAccess(ctx, getSharedMemo, nil)) require.ErrorIs(t, authorizer.CheckAccess(ctx, listMemos, nil), apiv1.ErrUnauthenticated) + require.ErrorIs(t, authorizer.CheckAccess(ctx, listReactions, nil), apiv1.ErrUnauthenticated) + require.ErrorIs(t, authorizer.CheckAccess(ctx, listRelations, nil), apiv1.ErrUnauthenticated) // Policy reads are fresh: changing to PUBLIC immediately opens browsing. require.NoError(t, ts.SetInstanceAccessMode(ctx, storepb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PUBLIC)) require.NoError(t, authorizer.CheckAccess(ctx, listMemos, nil)) + require.NoError(t, authorizer.CheckAccess(ctx, listReactions, nil)) + require.NoError(t, authorizer.CheckAccess(ctx, listRelations, nil)) + require.NoError(t, ts.SetInstanceAccessMode(ctx, storepb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PRIVATE)) // Once a user exists, CreateUser remains reachable so UserService can enforce // disallow_user_registration and disallow_password_auth. diff --git a/server/router/api/v1/test/memo_attachment_markdown_test.go b/server/router/api/v1/test/memo_attachment_markdown_test.go index 14ff9ac7..8da2cd71 100644 --- a/server/router/api/v1/test/memo_attachment_markdown_test.go +++ b/server/router/api/v1/test/memo_attachment_markdown_test.go @@ -236,7 +236,7 @@ func TestMemoManagedAttachmentImages(t *testing.T) { require.Nil(t, stored) }) - t.Run("local deletion failure leaves a detached row that can be retried", func(t *testing.T) { + t.Run("local deletion failure reports committed row deletion", func(t *testing.T) { ts := NewTestService(t) defer ts.Cleanup() user, err := ts.CreateRegularUser(ctx, "managed-delete-retry") @@ -260,24 +260,21 @@ func TestMemoManagedAttachmentImages(t *testing.T) { "LOCAL", localReference, storedImage.ID, ) require.NoError(t, err) - _, err = ts.Service.UpdateMemo(store.WithDeleteAttachmentStorageFailpoint(userCtx), &v1pb.UpdateMemoRequest{ Memo: &v1pb.Memo{Name: memo.Name, Content: "attachment removed", Attachments: []*v1pb.Attachment{}}, UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"content", "attachments"}}, }) require.Equal(t, codes.Internal, status.Code(err)) + require.ErrorContains(t, err, "memo was updated but attachment storage cleanup failed") + require.ErrorContains(t, err, store.ErrDeleteAttachmentStorageFailpoint.Error()) storedMemo, getErr := ts.Service.GetMemo(userCtx, &v1pb.GetMemoRequest{Name: memo.Name}) require.NoError(t, getErr) require.Equal(t, "attachment removed", storedMemo.Content) storedImage, getErr = ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &uid}) require.NoError(t, getErr) - require.NotNil(t, storedImage) - require.Nil(t, storedImage.MemoID) - - _, err = ts.Service.DeleteAttachment(userCtx, &v1pb.DeleteAttachmentRequest{Name: image.Name}) - require.NoError(t, err) + require.Nil(t, storedImage) _, statErr := os.Stat(localPath) - require.ErrorIs(t, statErr, os.ErrNotExist) + require.NoError(t, statErr) }) t.Run("failed content validation does not mutate the memo", func(t *testing.T) { diff --git a/server/router/api/v1/test/memo_attachment_service_test.go b/server/router/api/v1/test/memo_attachment_service_test.go index 752cc349..211c4f1c 100644 --- a/server/router/api/v1/test/memo_attachment_service_test.go +++ b/server/router/api/v1/test/memo_attachment_service_test.go @@ -57,7 +57,7 @@ func TestSetMemoAttachments(t *testing.T) { require.NoError(t, err) }) - t.Run("SetMemoAttachments success by host user", func(t *testing.T) { + t.Run("SetMemoAttachments host user has no ownership bypass", func(t *testing.T) { ts := NewTestService(t) defer ts.Cleanup() @@ -81,12 +81,12 @@ func TestSetMemoAttachments(t *testing.T) { require.NoError(t, err) require.NotNil(t, memo) - // Host user can modify attachments - should succeed + // Application ADMIN is an instance role, not memo authorship. _, err = ts.Service.SetMemoAttachments(hostCtx, &apiv1.SetMemoAttachmentsRequest{ Name: memo.Name, Attachments: []*apiv1.Attachment{}, }) - require.NoError(t, err) + require.Equal(t, codes.PermissionDenied, status.Code(err)) }) t.Run("SetMemoAttachments permission denied for non-owner", func(t *testing.T) { @@ -226,6 +226,74 @@ func TestSetMemoAttachments(t *testing.T) { response, err := ts.Service.ListMemoAttachments(userCtx, &apiv1.ListMemoAttachmentsRequest{Name: memo.Name}) require.NoError(t, err) require.Len(t, response.Attachments, 0) + for _, attachmentName := range []string{still.Name, video.Name} { + attachmentUID := strings.TrimPrefix(attachmentName, "attachments/") + stored, getErr := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &attachmentUID}) + require.NoError(t, getErr) + require.Nil(t, stored, "removed motion-media attachment row must be deleted") + } + }) + + t.Run("SetMemoAttachments rejection leaves an incomplete external motion group unchanged", func(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + + user, err := ts.CreateRegularUser(ctx, "partial_motion_group_user") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + still, err := ts.Service.CreateAttachment(userCtx, &apiv1.CreateAttachmentRequest{Attachment: &apiv1.Attachment{ + Filename: "partial.heic", + Type: "image/heic", + Content: []byte("still"), + MotionMedia: &apiv1.MotionMedia{ + Family: apiv1.MotionMediaFamily_APPLE_LIVE_PHOTO, + Role: apiv1.MotionMediaRole_STILL, + GroupId: "partial-motion-group", + }, + }}) + require.NoError(t, err) + video, err := ts.Service.CreateAttachment(userCtx, &apiv1.CreateAttachmentRequest{Attachment: &apiv1.Attachment{ + Filename: "partial.mov", + Type: "video/quicktime", + Content: []byte("video"), + MotionMedia: &apiv1.MotionMedia{ + Family: apiv1.MotionMediaFamily_APPLE_LIVE_PHOTO, + Role: apiv1.MotionMediaRole_VIDEO, + GroupId: "partial-motion-group", + }, + }}) + require.NoError(t, err) + + memo, err := ts.Service.CreateMemo(userCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "memo with one motion-group member", + Visibility: apiv1.Visibility_PRIVATE, + Attachments: []*apiv1.Attachment{{Name: still.Name}}, + }}) + require.NoError(t, err) + memoUID := strings.TrimPrefix(memo.Name, "memos/") + storedMemo, err := ts.Store.GetMemo(ctx, &store.FindMemo{UID: &memoUID}) + require.NoError(t, err) + require.NotNil(t, storedMemo) + initialUpdatedTs := int64(1) + require.NoError(t, ts.Store.UpdateMemo(ctx, &store.UpdateMemo{ID: storedMemo.ID, UpdatedTs: &initialUpdatedTs})) + + _, err = ts.Service.SetMemoAttachments(userCtx, &apiv1.SetMemoAttachmentsRequest{Name: memo.Name}) + require.Equal(t, codes.FailedPrecondition, status.Code(err)) + + stillUID := strings.TrimPrefix(still.Name, "attachments/") + storedStill, err := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &stillUID}) + require.NoError(t, err) + require.NotNil(t, storedStill) + require.NotNil(t, storedStill.MemoID) + require.Equal(t, storedMemo.ID, *storedStill.MemoID) + videoUID := strings.TrimPrefix(video.Name, "attachments/") + storedVideo, err := ts.Store.GetAttachment(ctx, &store.FindAttachment{UID: &videoUID}) + require.NoError(t, err) + require.NotNil(t, storedVideo) + require.Nil(t, storedVideo.MemoID) + storedMemo, err = ts.Store.GetMemo(ctx, &store.FindMemo{ID: &storedMemo.ID}) + require.NoError(t, err) + require.Equal(t, initialUpdatedTs, storedMemo.UpdatedTs) }) t.Run("SetMemoAttachments denies attaching another user's attachment", func(t *testing.T) { diff --git a/server/router/api/v1/test/memo_relation_service_test.go b/server/router/api/v1/test/memo_relation_service_test.go index a0092b22..e0636923 100644 --- a/server/router/api/v1/test/memo_relation_service_test.go +++ b/server/router/api/v1/test/memo_relation_service_test.go @@ -59,7 +59,7 @@ func TestSetMemoRelations(t *testing.T) { require.NoError(t, err) }) - t.Run("SetMemoRelations success by host user", func(t *testing.T) { + t.Run("SetMemoRelations host user has no ownership bypass", func(t *testing.T) { ts := NewTestService(t) defer ts.Cleanup() @@ -83,12 +83,12 @@ func TestSetMemoRelations(t *testing.T) { require.NoError(t, err) require.NotNil(t, memo) - // Host user can modify relations - should succeed + // Application ADMIN is an instance role, not memo authorship. _, err = ts.Service.SetMemoRelations(hostCtx, &apiv1.SetMemoRelationsRequest{ Name: memo.Name, Relations: []*apiv1.MemoRelation{}, }) - require.NoError(t, err) + require.Equal(t, codes.PermissionDenied, status.Code(err)) }) t.Run("SetMemoRelations permission denied for non-owner", func(t *testing.T) { @@ -211,3 +211,45 @@ func TestUpdateMemoValidatesAllRelationsBeforeMutation(t *testing.T) { require.Len(t, stored.Relations, 1) require.Equal(t, target.Name, stored.Relations[0].RelatedMemo.Name) } + +func TestSetMemoRelationsRejectsNonReferenceTypes(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + user, err := ts.CreateRegularUser(ctx, "relation-type-owner") + require.NoError(t, err) + userCtx := ts.CreateUserContext(ctx, user.ID) + source, err := ts.Service.CreateMemo(userCtx, &apiv1.CreateMemoRequest{ + Memo: &apiv1.Memo{Content: "source", Visibility: apiv1.Visibility_PRIVATE}, + }) + require.NoError(t, err) + target, err := ts.Service.CreateMemo(userCtx, &apiv1.CreateMemoRequest{ + Memo: &apiv1.Memo{Content: "target", Visibility: apiv1.Visibility_PRIVATE}, + }) + require.NoError(t, err) + + for _, test := range []struct { + name string + relationType apiv1.MemoRelation_Type + }{ + {name: "unspecified", relationType: apiv1.MemoRelation_TYPE_UNSPECIFIED}, + {name: "comment", relationType: apiv1.MemoRelation_COMMENT}, + {name: "unknown", relationType: apiv1.MemoRelation_Type(999)}, + } { + t.Run(test.name, func(t *testing.T) { + _, err := ts.Service.SetMemoRelations(userCtx, &apiv1.SetMemoRelationsRequest{ + Name: source.Name, + Relations: []*apiv1.MemoRelation{{ + RelatedMemo: &apiv1.MemoRelation_Memo{Name: target.Name}, + Type: test.relationType, + }}, + }) + require.Equal(t, codes.InvalidArgument, status.Code(err)) + + stored, err := ts.Service.GetMemo(userCtx, &apiv1.GetMemoRequest{Name: source.Name}) + require.NoError(t, err) + require.Empty(t, stored.Relations) + }) + } +} diff --git a/server/router/api/v1/test/memo_service_benchmark_test.go b/server/router/api/v1/test/memo_service_benchmark_test.go index 2c5bc048..e81de48c 100644 --- a/server/router/api/v1/test/memo_service_benchmark_test.go +++ b/server/router/api/v1/test/memo_service_benchmark_test.go @@ -161,22 +161,15 @@ func seedListMemosBenchmarkData(ctx context.Context, stores *store.Store, hostUs } if i%6 == 0 { - commentMemo, err := stores.CreateMemo(ctx, &store.Memo{ + _, err := stores.CreateMemoComment(ctx, &store.Memo{ UID: fmt.Sprintf("comment-%06d", i), CreatorID: hostUser.ID, Content: fmt.Sprintf("Comment for memo %06d", i), Visibility: store.Private, - }) + }, memo.ID, hostUser.ID) if err != nil { return "", err } - if _, err := stores.UpsertMemoRelation(ctx, &store.MemoRelation{ - MemoID: commentMemo.ID, - RelatedMemoID: memo.ID, - Type: store.MemoRelationComment, - }); err != nil { - return "", err - } if commentParentName == "" { commentParentName = "memos/" + memo.UID } diff --git a/server/router/api/v1/test/memo_service_test.go b/server/router/api/v1/test/memo_service_test.go index d73cdfa3..183237b6 100644 --- a/server/router/api/v1/test/memo_service_test.go +++ b/server/router/api/v1/test/memo_service_test.go @@ -51,6 +51,125 @@ func TestAnonymousMemoAccessFollowsInstanceAccessSetting(t *testing.T) { require.NoError(t, err) } +func TestMemoReadAllowsArchivedCreatorAccordingToAudience(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + creator, err := ts.CreateRegularUser(ctx, "archived-memo-creator") + require.NoError(t, err) + viewer, err := ts.CreateRegularUser(ctx, "archived-memo-viewer") + require.NoError(t, err) + creatorCtx := ts.CreateUserContext(ctx, creator.ID) + viewerCtx := ts.CreateUserContext(ctx, viewer.ID) + publicMemo, err := ts.Service.CreateMemo(creatorCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "public memo by archived creator", Visibility: apiv1.Visibility_PUBLIC, + }}) + require.NoError(t, err) + protectedMemo, err := ts.Service.CreateMemo(creatorCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "protected memo by archived creator", Visibility: apiv1.Visibility_PROTECTED, + }}) + require.NoError(t, err) + archived := store.Archived + _, err = ts.Store.UpdateUser(ctx, &store.UpdateUser{ID: creator.ID, RowStatus: &archived}) + require.NoError(t, err) + + _, err = ts.Service.GetMemo(ctx, &apiv1.GetMemoRequest{Name: publicMemo.Name}) + require.NoError(t, err, "creator archive must not narrow a PUBLIC memo") + _, err = ts.Service.GetMemo(viewerCtx, &apiv1.GetMemoRequest{Name: protectedMemo.Name}) + require.NoError(t, err, "creator archive must not narrow a PROTECTED memo") +} + +func TestDanglingPlacementDoesNotOverrideNonSpaceAudience(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + creator, err := ts.CreateRegularUser(ctx, "dangling-placement-creator") + require.NoError(t, err) + creatorCtx := ts.CreateUserContext(ctx, creator.ID) + memo, err := ts.Service.CreateMemo(creatorCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "public memo with corrupt placement", Visibility: apiv1.Visibility_PUBLIC, + }}) + require.NoError(t, err) + memoID := parseMemoIDFromNameForTest(t, ts, memo.Name) + _, err = ts.Store.GetDriver().GetDB().ExecContext(ctx, + fmt.Sprintf("UPDATE memo SET space_id = 2147483000 WHERE id = %d", memoID)) + require.NoError(t, err) + + got, err := ts.Service.GetMemo(ctx, &apiv1.GetMemoRequest{Name: memo.Name}) + require.NoError(t, err) + require.Nil(t, got.Space, "an invalid placement must be omitted") + + listed, err := ts.Service.ListMemos(ctx, &apiv1.ListMemosRequest{}) + require.NoError(t, err) + require.Len(t, listed.Memos, 1) + require.Equal(t, memo.Name, listed.Memos[0].Name) + require.Nil(t, listed.Memos[0].Space) + + _, err = ts.Service.CreateMemoComment(creatorCtx, &apiv1.CreateMemoCommentRequest{ + Name: memo.Name, Comment: &apiv1.Memo{Content: "must not participate", Visibility: apiv1.Visibility_PUBLIC}, + }) + require.Equal(t, codes.FailedPrecondition, status.Code(err), "placement-dependent participation must fail closed") +} + +func TestMemoReadFailsClosedForMissingCreatorBeforePaginationAndChildren(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + creator, err := ts.CreateRegularUser(ctx, "missing-memo-creator") + require.NoError(t, err) + creatorCtx := ts.CreateUserContext(ctx, creator.ID) + first, err := ts.Service.CreateMemo(creatorCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "first valid", Visibility: apiv1.Visibility_PUBLIC, + }}) + require.NoError(t, err) + second, err := ts.Service.CreateMemo(creatorCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "second valid", Visibility: apiv1.Visibility_PUBLIC, + }}) + require.NoError(t, err) + corrupt, err := ts.Service.CreateMemo(creatorCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "dangling creator", Visibility: apiv1.Visibility_PUBLIC, + }}) + require.NoError(t, err) + _, err = ts.Service.UpsertMemoReaction(creatorCtx, &apiv1.UpsertMemoReactionRequest{ + Name: corrupt.Name, Reaction: &apiv1.Reaction{ReactionType: "eyes"}, + }) + require.NoError(t, err) + _, err = ts.Service.CreateMemoComment(creatorCtx, &apiv1.CreateMemoCommentRequest{ + Name: corrupt.Name, Comment: &apiv1.Memo{Content: "existing comment", Visibility: apiv1.Visibility_PUBLIC}, + }) + require.NoError(t, err) + corruptID := parseMemoIDFromNameForTest(t, ts, corrupt.Name) + _, err = ts.Store.CreateAttachment(ctx, &store.Attachment{ + UID: "missing-memo-creator-attachment", CreatorID: creator.ID, Filename: "secret.txt", Type: "text/plain", MemoID: &corruptID, + }) + require.NoError(t, err) + _, err = ts.Store.GetDriver().GetDB().ExecContext(ctx, + fmt.Sprintf("UPDATE memo SET creator_id = 2147483000 WHERE id = %d", corruptID)) + require.NoError(t, err) + + _, err = ts.Service.GetMemo(ctx, &apiv1.GetMemoRequest{Name: corrupt.Name}) + require.Equal(t, codes.NotFound, status.Code(err)) + _, err = ts.Service.ListMemoReactions(ctx, &apiv1.ListMemoReactionsRequest{Name: corrupt.Name}) + require.Equal(t, codes.NotFound, status.Code(err)) + _, err = ts.Service.ListMemoAttachments(ctx, &apiv1.ListMemoAttachmentsRequest{Name: corrupt.Name}) + require.Equal(t, codes.NotFound, status.Code(err)) + _, err = ts.Service.ListMemoComments(ctx, &apiv1.ListMemoCommentsRequest{Name: corrupt.Name}) + require.Equal(t, codes.NotFound, status.Code(err)) + _, err = ts.Service.CreateMemoComment(creatorCtx, &apiv1.CreateMemoCommentRequest{ + Name: corrupt.Name, Comment: &apiv1.Memo{Content: "must not be created", Visibility: apiv1.Visibility_PUBLIC}, + }) + require.Equal(t, codes.NotFound, status.Code(err)) + + listed, err := ts.Service.ListMemos(ctx, &apiv1.ListMemosRequest{PageSize: 2}) + require.NoError(t, err) + require.Len(t, listed.Memos, 2) + require.ElementsMatch(t, []string{first.Name, second.Name}, []string{listed.Memos[0].Name, listed.Memos[1].Name}, + "a newer dangling-creator row must be filtered before the page limit") +} + func TestCreateMemoAcceptsUUID(t *testing.T) { ctx := context.Background() ts := NewTestService(t) @@ -188,6 +307,7 @@ func TestListMemos(t *testing.T) { RelatedMemo: &apiv1.MemoRelation_Memo{ Name: memoOne.Name, }, + Type: apiv1.MemoRelation_REFERENCE, }, }, }, @@ -575,6 +695,164 @@ func TestListMemoCommentsSkipsCommentsWithMissingCreators(t *testing.T) { require.Empty(t, resp.Memos) } +func TestCreateMemoCommentRejectsSelfReference(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + owner, err := ts.CreateRegularUser(ctx, "comment-self-reference-owner") + require.NoError(t, err) + ownerCtx := ts.CreateUserContext(ctx, owner.ID) + memo, err := ts.Service.CreateMemo(ownerCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "comment context", Visibility: apiv1.Visibility_PUBLIC, + }}) + require.NoError(t, err) + + _, err = ts.Service.CreateMemoComment(ownerCtx, &apiv1.CreateMemoCommentRequest{ + Name: memo.Name, + CommentId: memo.Name[len("memos/"):], + Comment: &apiv1.Memo{Content: "self reference", Visibility: apiv1.Visibility_PUBLIC}, + }) + require.Equal(t, codes.InvalidArgument, status.Code(err)) + comments, err := ts.Service.ListMemoComments(ownerCtx, &apiv1.ListMemoCommentsRequest{Name: memo.Name}) + require.NoError(t, err) + require.Empty(t, comments.Memos) +} + +func TestUpdateMemoPlacementAndAudienceContract(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + sourceAdmin, err := ts.CreateRegularUser(ctx, "placement-source-admin") + require.NoError(t, err) + author, err := ts.CreateRegularUser(ctx, "placement-author") + require.NoError(t, err) + sourceAdminCtx := ts.CreateUserContext(ctx, sourceAdmin.ID) + authorCtx := ts.CreateUserContext(ctx, author.ID) + + source, err := ts.Service.CreateSpace(sourceAdminCtx, &apiv1.CreateSpaceRequest{ + SpaceId: "placement-source", + Space: &apiv1.Space{Title: "Placement Source"}, + }) + require.NoError(t, err) + target, err := ts.Service.CreateSpace(authorCtx, &apiv1.CreateSpaceRequest{ + SpaceId: "placement-target", + Space: &apiv1.Space{Title: "Placement Target"}, + }) + require.NoError(t, err) + _, err = ts.Service.CreateSpaceMember(sourceAdminCtx, &apiv1.CreateSpaceMemberRequest{ + Parent: source.Name, + SpaceMember: &apiv1.SpaceMember{ + User: "users/" + author.Username, + Role: apiv1.SpaceMember_USER, + }, + }) + require.NoError(t, err) + + protectedMemo, err := ts.Service.CreateMemo(authorCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "assign without audience change", Visibility: apiv1.Visibility_PROTECTED, + }}) + require.NoError(t, err) + sourceName := source.Name + protectedMemo, err = ts.Service.UpdateMemo(authorCtx, &apiv1.UpdateMemoRequest{ + Memo: &apiv1.Memo{Name: protectedMemo.Name, Space: &sourceName}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"space"}}, + }) + require.NoError(t, err) + require.Equal(t, source.Name, protectedMemo.GetSpace()) + require.Equal(t, apiv1.Visibility_PROTECTED, protectedMemo.Visibility, "assigning must preserve the memo audience") + + _, err = ts.Service.UpdateMemo(sourceAdminCtx, &apiv1.UpdateMemoRequest{ + Memo: &apiv1.Memo{Name: protectedMemo.Name}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"space"}}, + }) + require.Equal(t, codes.PermissionDenied, status.Code(err), "Space administrators cannot change another author's memo placement") + protectedMemo, err = ts.Service.GetMemo(authorCtx, &apiv1.GetMemoRequest{Name: protectedMemo.Name}) + require.NoError(t, err) + require.Equal(t, source.Name, protectedMemo.GetSpace()) + + unassigned, err := ts.Service.CreateMemo(authorCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "unassigned", Visibility: apiv1.Visibility_PRIVATE, + }}) + require.NoError(t, err) + _, err = ts.Service.UpdateMemo(authorCtx, &apiv1.UpdateMemoRequest{ + Memo: &apiv1.Memo{Name: unassigned.Name, Visibility: apiv1.Visibility_SPACE}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"visibility"}}, + }) + require.Equal(t, codes.InvalidArgument, status.Code(err), "SPACE visibility requires an assigned Space") + + spaceMembersMemo, err := ts.Service.CreateMemo(authorCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "members audience", Visibility: apiv1.Visibility_SPACE, Space: &sourceName, + }}) + require.NoError(t, err) + targetName := target.Name + _, err = ts.Service.UpdateMemo(authorCtx, &apiv1.UpdateMemoRequest{ + Memo: &apiv1.Memo{Name: spaceMembersMemo.Name, Space: &targetName}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"space"}}, + }) + require.Equal(t, codes.InvalidArgument, status.Code(err), "moving SPACE visibility requires an explicit audience confirmation") + _, err = ts.Service.UpdateMemo(authorCtx, &apiv1.UpdateMemoRequest{ + Memo: &apiv1.Memo{Name: spaceMembersMemo.Name}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"space"}}, + }) + require.Equal(t, codes.InvalidArgument, status.Code(err), "unassigning SPACE visibility requires a replacement audience") + spaceMembersMemo, err = ts.Service.UpdateMemo(authorCtx, &apiv1.UpdateMemoRequest{ + Memo: &apiv1.Memo{Name: spaceMembersMemo.Name, Visibility: apiv1.Visibility_PRIVATE}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"space", "visibility"}}, + }) + require.NoError(t, err) + require.Nil(t, spaceMembersMemo.Space) + require.Equal(t, apiv1.Visibility_PRIVATE, spaceMembersMemo.Visibility) + + moveMemo, err := ts.Service.CreateMemo(authorCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "move original", Visibility: apiv1.Visibility_PUBLIC, Space: &sourceName, + }}) + require.NoError(t, err) + withdrawMemo, err := ts.Service.CreateMemo(authorCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "withdraw original", Visibility: apiv1.Visibility_PUBLIC, Space: &sourceName, + }}) + require.NoError(t, err) + membersOnlyMemo, err := ts.Service.CreateMemo(authorCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "members only", Visibility: apiv1.Visibility_SPACE, Space: &sourceName, + }}) + require.NoError(t, err) + _, err = ts.Service.DeleteSpaceMember(sourceAdminCtx, &apiv1.DeleteSpaceMemberRequest{ + Name: source.Name + "/members/" + author.Username, + }) + require.NoError(t, err) + _, err = ts.Service.GetMemo(authorCtx, &apiv1.GetMemoRequest{Name: membersOnlyMemo.Name}) + require.Equal(t, codes.PermissionDenied, status.Code(err), "the author loses SPACE audience read access after leaving the Space") + + _, err = ts.Service.UpdateMemo(authorCtx, &apiv1.UpdateMemoRequest{ + Memo: &apiv1.Memo{Name: moveMemo.Name, Space: &targetName, Content: "smuggled content"}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"space", "content"}}, + }) + require.Equal(t, codes.PermissionDenied, status.Code(err), "a removed author cannot smuggle content into a lifecycle move") + unchangedMove, err := ts.Service.GetMemo(authorCtx, &apiv1.GetMemoRequest{Name: moveMemo.Name}) + require.NoError(t, err) + require.Equal(t, "move original", unchangedMove.Content) + require.Equal(t, source.Name, unchangedMove.GetSpace()) + + moved, err := ts.Service.UpdateMemo(authorCtx, &apiv1.UpdateMemoRequest{ + Memo: &apiv1.Memo{Name: moveMemo.Name, Space: &targetName}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"space"}}, + }) + require.NoError(t, err) + require.Equal(t, target.Name, moved.GetSpace()) + require.Equal(t, "move original", moved.Content) + require.Equal(t, apiv1.Visibility_PUBLIC, moved.Visibility) + + withdrawn, err := ts.Service.UpdateMemo(authorCtx, &apiv1.UpdateMemoRequest{ + Memo: &apiv1.Memo{Name: withdrawMemo.Name}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"space"}}, + }) + require.NoError(t, err) + require.Nil(t, withdrawn.Space) + require.Equal(t, "withdraw original", withdrawn.Content) + require.Equal(t, apiv1.Visibility_PUBLIC, withdrawn.Visibility) +} + func TestListMemoCommentsPaginates(t *testing.T) { ctx := context.Background() @@ -656,7 +934,7 @@ func TestListMemoCommentsFiltersArchivedBeforePagination(t *testing.T) { require.Empty(t, secondPage.NextPageToken) } -func TestCreateMemoCommentInheritsParentVisibility(t *testing.T) { +func TestMemoCommentKeepsIndependentVisibilityAndAllowsAudienceUpdates(t *testing.T) { ctx := context.Background() ts := NewTestService(t) @@ -682,20 +960,24 @@ func TestCreateMemoCommentInheritsParentVisibility(t *testing.T) { }, }) require.NoError(t, err) - require.Equal(t, apiv1.Visibility_PRIVATE, comment.Visibility) + require.Equal(t, apiv1.Visibility_PUBLIC, comment.Visibility) - updatedComment, err := ts.Service.UpdateMemo(ownerCtx, &apiv1.UpdateMemoRequest{ + _, err = ts.Service.UpdateMemo(ownerCtx, &apiv1.UpdateMemoRequest{ Memo: &apiv1.Memo{ Name: comment.Name, - Visibility: apiv1.Visibility_PUBLIC, + Visibility: apiv1.Visibility_PROTECTED, }, UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"visibility"}}, }) require.NoError(t, err) - require.Equal(t, apiv1.Visibility_PRIVATE, updatedComment.Visibility) - _, err = ts.Service.GetMemo(ctx, &apiv1.GetMemoRequest{Name: comment.Name}) - require.Equal(t, codes.Unauthenticated, status.Code(err)) + updatedComment, err := ts.Service.GetMemo(ownerCtx, &apiv1.GetMemoRequest{Name: comment.Name}) + require.NoError(t, err) + require.Equal(t, apiv1.Visibility_PROTECTED, updatedComment.Visibility) + + unchangedParent, err := ts.Service.GetMemo(ownerCtx, &apiv1.GetMemoRequest{Name: parent.Name}) + require.NoError(t, err) + require.Equal(t, apiv1.Visibility_PRIVATE, unchangedParent.Visibility) } func TestCreateMemoCommentDoesNotRevealArchivedPrivateMemo(t *testing.T) { @@ -733,7 +1015,7 @@ func TestCreateMemoCommentDoesNotRevealArchivedPrivateMemo(t *testing.T) { require.Equal(t, codes.FailedPrecondition, status.Code(err)) } -func TestGetMemoCommentRequiresParentReadAccess(t *testing.T) { +func TestGetMemoCommentUsesMemoLocalReadAccessAndConcealsContext(t *testing.T) { ctx := context.Background() ts := NewTestService(t) @@ -755,32 +1037,23 @@ func TestGetMemoCommentRequiresParentReadAccess(t *testing.T) { }) require.NoError(t, err) - legacyComment, err := ts.Store.CreateMemo(ctx, &store.Memo{ - UID: "legacy-public-comment", - CreatorID: owner.ID, - Content: "legacy public comment under private parent", - Visibility: store.Public, + createdComment, err := ts.Service.CreateMemoComment(ownerCtx, &apiv1.CreateMemoCommentRequest{ + Name: parent.Name, + Comment: &apiv1.Memo{ + Content: "public comment with private context", + Visibility: apiv1.Visibility_PUBLIC, + }, }) require.NoError(t, err) - parentUID := parent.Name[len("memos/"):] - parentMemo, err := ts.Store.GetMemo(ctx, &store.FindMemo{UID: &parentUID}) + commentName := createdComment.Name + publicComment, err := ts.Service.GetMemo(ctx, &apiv1.GetMemoRequest{Name: commentName}) require.NoError(t, err) - require.NotNil(t, parentMemo) + require.Empty(t, publicComment.GetParent(), "unreadable context must not be exposed") - _, err = ts.Store.UpsertMemoRelation(ctx, &store.MemoRelation{ - MemoID: legacyComment.ID, - RelatedMemoID: parentMemo.ID, - Type: store.MemoRelationComment, - }) + otherComment, err := ts.Service.GetMemo(otherCtx, &apiv1.GetMemoRequest{Name: commentName}) require.NoError(t, err) - - commentName := "memos/" + legacyComment.UID - _, err = ts.Service.GetMemo(ctx, &apiv1.GetMemoRequest{Name: commentName}) - require.Equal(t, codes.Unauthenticated, status.Code(err)) - - _, err = ts.Service.GetMemo(otherCtx, &apiv1.GetMemoRequest{Name: commentName}) - require.Equal(t, codes.PermissionDenied, status.Code(err)) + require.Empty(t, otherComment.GetParent(), "relation context requires both endpoints to be readable") comment, err := ts.Service.GetMemo(ownerCtx, &apiv1.GetMemoRequest{Name: commentName}) require.NoError(t, err) @@ -798,7 +1071,66 @@ func TestGetMemoCommentRequiresParentReadAccess(t *testing.T) { require.Equal(t, commentName, comments.Memos[0].Name) } -func TestMemoCommentUsesCurrentParentVisibility(t *testing.T) { +func TestAssignedMemoCommentListingUsesMemoLocalReadAccess(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + owner, err := ts.CreateRegularUser(ctx, "assigned-comment-owner") + require.NoError(t, err) + member, err := ts.CreateRegularUser(ctx, "assigned-comment-member") + require.NoError(t, err) + outsider, err := ts.CreateRegularUser(ctx, "assigned-comment-outsider") + require.NoError(t, err) + ownerCtx := ts.CreateUserContext(ctx, owner.ID) + memberCtx := ts.CreateUserContext(ctx, member.ID) + outsiderCtx := ts.CreateUserContext(ctx, outsider.ID) + + space, err := ts.Store.CreateSpace(ctx, &store.Space{UID: "assigned-comment-space", Title: "Assigned comments"}, owner.ID) + require.NoError(t, err) + _, err = ts.Store.CreateSpaceMember(ctx, &store.SpaceMember{ + SpaceID: space.ID, + UserID: member.ID, + Role: store.SpaceMemberRoleAdmin, + }, owner.ID) + require.NoError(t, err) + contextMemo, err := ts.Service.CreateMemo(ownerCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "assigned public comment context", + Visibility: apiv1.Visibility_PUBLIC, + Space: ptr("spaces/" + space.UID), + }}) + require.NoError(t, err) + comment, err := ts.Service.CreateMemoComment(memberCtx, &apiv1.CreateMemoCommentRequest{ + Name: contextMemo.Name, + Comment: &apiv1.Memo{ + Content: "public independently readable comment", + Visibility: apiv1.Visibility_PUBLIC, + }, + }) + require.NoError(t, err) + + comments, err := ts.Service.ListMemoComments(memberCtx, &apiv1.ListMemoCommentsRequest{Name: contextMemo.Name}) + require.NoError(t, err) + require.Len(t, comments.Memos, 1) + require.Equal(t, comment.Name, comments.Memos[0].Name) + + comments, err = ts.Service.ListMemoComments(ctx, &apiv1.ListMemoCommentsRequest{Name: contextMemo.Name}) + require.NoError(t, err) + require.Len(t, comments.Memos, 1, "anonymous access follows the PUBLIC context and comment audiences") + comments, err = ts.Service.ListMemoComments(outsiderCtx, &apiv1.ListMemoCommentsRequest{Name: contextMemo.Name}) + require.NoError(t, err) + require.Len(t, comments.Memos, 1, "Space placement adds no read gate for a signed-in non-member") + directComment, err := ts.Service.GetMemo(outsiderCtx, &apiv1.GetMemoRequest{Name: comment.Name}) + require.NoError(t, err, "the comment memo remains independently readable") + require.Equal(t, contextMemo.Name, directComment.GetParent(), "two-endpoint relation projection remains memo-local") + + require.NoError(t, ts.Store.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: owner.ID}, owner.ID)) + comments, err = ts.Service.ListMemoComments(ownerCtx, &apiv1.ListMemoCommentsRequest{Name: contextMemo.Name}) + require.NoError(t, err) + require.Len(t, comments.Memos, 1, "the removed author still reads PUBLIC memos through their audience") +} + +func TestMemoCommentDoesNotFollowParentVisibilityChanges(t *testing.T) { ctx := context.Background() ts := NewTestService(t) defer ts.Cleanup() @@ -813,7 +1145,7 @@ func TestMemoCommentUsesCurrentParentVisibility(t *testing.T) { require.NoError(t, err) comment, err := ts.Service.CreateMemoComment(ownerCtx, &apiv1.CreateMemoCommentRequest{ Name: parent.Name, - Comment: &apiv1.Memo{Content: "inherits private"}, + Comment: &apiv1.Memo{Content: "independently private"}, }) require.NoError(t, err) require.Equal(t, apiv1.Visibility_PRIVATE, comment.Visibility) @@ -824,13 +1156,45 @@ func TestMemoCommentUsesCurrentParentVisibility(t *testing.T) { }) require.NoError(t, err) - visibleComment, err := ts.Service.GetMemo(ctx, &apiv1.GetMemoRequest{Name: comment.Name}) - require.NoError(t, err) - require.Equal(t, comment.Name, visibleComment.Name) + _, err = ts.Service.GetMemo(ctx, &apiv1.GetMemoRequest{Name: comment.Name}) + require.Equal(t, codes.Unauthenticated, status.Code(err)) comments, err := ts.Service.ListMemoComments(ctx, &apiv1.ListMemoCommentsRequest{Name: parent.Name}) require.NoError(t, err) - require.Len(t, comments.Memos, 1) - require.Equal(t, comment.Name, comments.Memos[0].Name) + require.Empty(t, comments.Memos, "context visibility must not expand a private comment") +} + +func TestGlobalFeedExcludesCommentsUntilContextIsDeleted(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + owner, err := ts.CreateRegularUser(ctx, "comment-feed-owner") + require.NoError(t, err) + ownerCtx := ts.CreateUserContext(ctx, owner.ID) + contextMemo, err := ts.Service.CreateMemo(ownerCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "context", Visibility: apiv1.Visibility_PUBLIC, + }}) + require.NoError(t, err) + comment, err := ts.Service.CreateMemoComment(ownerCtx, &apiv1.CreateMemoCommentRequest{ + Name: contextMemo.Name, Comment: &apiv1.Memo{Content: "independent comment", Visibility: apiv1.Visibility_PUBLIC}, + }) + require.NoError(t, err) + + feed, err := ts.Service.ListMemos(ownerCtx, &apiv1.ListMemosRequest{PageSize: 20}) + require.NoError(t, err) + require.Len(t, feed.Memos, 1) + require.Equal(t, contextMemo.Name, feed.Memos[0].Name) + + _, err = ts.Service.DeleteMemo(ownerCtx, &apiv1.DeleteMemoRequest{Name: contextMemo.Name}) + require.NoError(t, err) + survivor, err := ts.Service.GetMemo(ownerCtx, &apiv1.GetMemoRequest{Name: comment.Name}) + require.NoError(t, err) + require.Empty(t, survivor.GetParent()) + + feed, err = ts.Service.ListMemos(ownerCtx, &apiv1.ListMemosRequest{PageSize: 20}) + require.NoError(t, err) + require.Len(t, feed.Memos, 1) + require.Equal(t, comment.Name, feed.Memos[0].Name) } // TestCreateMemoWithCustomTimestamps tests that custom timestamps can be set when creating memos and comments. diff --git a/server/router/api/v1/test/memo_share_service_test.go b/server/router/api/v1/test/memo_share_service_test.go index 36b34878..ee0bcb08 100644 --- a/server/router/api/v1/test/memo_share_service_test.go +++ b/server/router/api/v1/test/memo_share_service_test.go @@ -66,6 +66,87 @@ func TestDeleteMemoShare_VerifiesShareBelongsToMemo(t *testing.T) { require.Equal(t, memoTwo.Name, sharedMemo.Name) } +func TestDeleteMemoShare_RevalidatesSpaceWriteAuthority(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + owner, err := ts.CreateRegularUser(ctx, "share-space-owner") + require.NoError(t, err) + admin, err := ts.CreateRegularUser(ctx, "share-space-admin") + require.NoError(t, err) + ownerCtx := ts.CreateUserContext(ctx, owner.ID) + space, err := ts.Store.CreateSpace(ctx, &store.Space{UID: "share-space", Title: "Share Space"}, owner.ID) + require.NoError(t, err) + _, err = ts.Store.CreateSpaceMember(ctx, &store.SpaceMember{ + SpaceID: space.ID, UserID: admin.ID, Role: store.SpaceMemberRoleAdmin, + }, owner.ID) + require.NoError(t, err) + memo, err := ts.Service.CreateMemo(ownerCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "assigned share", Visibility: apiv1.Visibility_PUBLIC, Space: ptr("spaces/" + space.UID), + }}) + require.NoError(t, err) + share, err := ts.Service.CreateMemoShare(ownerCtx, &apiv1.CreateMemoShareRequest{Parent: memo.Name, MemoShare: &apiv1.MemoShare{}}) + require.NoError(t, err) + shareToken := share.Name[strings.LastIndex(share.Name, "/")+1:] + + require.NoError(t, ts.Store.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: owner.ID}, admin.ID)) + _, err = ts.Service.DeleteMemoShare(ownerCtx, &apiv1.DeleteMemoShareRequest{Name: share.Name}) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + requireSharePresent(ctx, t, ts, shareToken) + + _, err = ts.Store.CreateSpaceMember(ctx, &store.SpaceMember{ + SpaceID: space.ID, UserID: owner.ID, Role: store.SpaceMemberRoleUser, + }, admin.ID) + require.NoError(t, err) + _, err = ts.Service.DeleteMemoShare(ownerCtx, &apiv1.DeleteMemoShareRequest{Name: share.Name}) + require.NoError(t, err) + storedShare, err := ts.Store.GetMemoShare(ctx, &store.FindMemoShare{UID: &shareToken}) + require.NoError(t, err) + require.Nil(t, storedShare) +} + +func TestDeleteMemoShare_OwnerCanRevokeLegacyAdminShare(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + owner, err := ts.CreateRegularUser(ctx, "legacy-share-owner") + require.NoError(t, err) + legacyAdmin, err := ts.CreateHostUser(ctx, "legacy-share-admin") + require.NoError(t, err) + ownerCtx := ts.CreateUserContext(ctx, owner.ID) + + memo, err := ts.Service.CreateMemo(ownerCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "memo with a legacy admin share", + Visibility: apiv1.Visibility_PRIVATE, + }}) + require.NoError(t, err) + memoUID := strings.TrimPrefix(memo.Name, "memos/") + storedMemo, err := ts.Store.GetMemo(ctx, &store.FindMemo{UID: &memoUID}) + require.NoError(t, err) + require.NotNil(t, storedMemo) + + const shareToken = "legacy-admin-created-share" + _, err = ts.Store.CreateMemoShare(ctx, &store.MemoShare{ + UID: shareToken, + MemoID: storedMemo.ID, + CreatorID: legacyAdmin.ID, + }) + require.NoError(t, err) + + _, err = ts.Service.DeleteMemoShare(ownerCtx, &apiv1.DeleteMemoShareRequest{ + Name: memo.Name + "/shares/" + shareToken, + }) + require.NoError(t, err) + + share, err := ts.Store.GetMemoShare(ctx, &store.FindMemoShare{UID: ptr(shareToken)}) + require.NoError(t, err) + require.Nil(t, share) + _, err = ts.Service.GetSharedMemo(ctx, &apiv1.GetSharedMemoRequest{ShareToken: shareToken}) + require.Equal(t, codes.NotFound, status.Code(err)) +} + func TestGetSharedMemo_IncludesReactions(t *testing.T) { ctx := context.Background() @@ -109,7 +190,7 @@ func TestGetSharedMemo_IncludesReactions(t *testing.T) { require.Equal(t, reaction.Name, sharedMemo.Reactions[0].Name) } -func TestCreateMemoShare_RejectsComment(t *testing.T) { +func TestCreateMemoShare_SharesOnlyTheCommentMemo(t *testing.T) { ctx := context.Background() ts := NewTestService(t) @@ -142,21 +223,18 @@ func TestCreateMemoShare_RejectsComment(t *testing.T) { require.NotEmpty(t, regularMemo.GetParent()) require.NotEmpty(t, regularMemo.Relations) - _, err = ts.Service.CreateMemoShare(userCtx, &apiv1.CreateMemoShareRequest{ + share, err := ts.Service.CreateMemoShare(userCtx, &apiv1.CreateMemoShareRequest{ Parent: comment.Name, MemoShare: &apiv1.MemoShare{}, }) - require.Equal(t, codes.FailedPrecondition, status.Code(err)) - - // Legacy rows created before this rule must not remain a bypass. - legacyShare, err := ts.Store.CreateMemoShare(ctx, &store.MemoShare{ - UID: "legacy-comment-share", - MemoID: parseMemoIDFromNameForTest(t, ts, comment.Name), - CreatorID: user.ID, - }) require.NoError(t, err) - _, err = ts.Service.GetSharedMemo(ctx, &apiv1.GetSharedMemoRequest{ShareToken: legacyShare.UID}) - require.Equal(t, codes.NotFound, status.Code(err)) + shareToken := share.Name[strings.LastIndex(share.Name, "/")+1:] + sharedComment, err := ts.Service.GetSharedMemo(ctx, &apiv1.GetSharedMemoRequest{ShareToken: shareToken}) + require.NoError(t, err) + require.Equal(t, comment.Name, sharedComment.Name) + require.Equal(t, "only this memo is shared", sharedComment.Content) + require.Empty(t, sharedComment.GetParent()) + require.Empty(t, sharedComment.Relations) } func TestGetSharedMemo_SkipsReactionsWithMissingCreators(t *testing.T) { @@ -237,12 +315,12 @@ func TestGetSharedMemo_ReturnsNotFoundForExpiredShare(t *testing.T) { }) require.NoError(t, err) - expiredTs := time.Now().Add(-time.Hour).Unix() + expiredTsSec := time.Now().Add(-time.Hour).Unix() expiredShare, err := ts.Store.CreateMemoShare(ctx, &store.MemoShare{ UID: "expired-share-token", MemoID: parseMemoIDFromNameForTest(t, ts, memo.Name), CreatorID: user.ID, - ExpiresTs: &expiredTs, + ExpiresTs: &expiredTsSec, }) require.NoError(t, err) @@ -309,3 +387,10 @@ func parseMemoIDFromNameForTest(t *testing.T, ts *TestService, memoName string) return memo.ID } + +func requireSharePresent(ctx context.Context, t *testing.T, ts *TestService, token string) { + t.Helper() + share, err := ts.Store.GetMemoShare(ctx, &store.FindMemoShare{UID: &token}) + require.NoError(t, err) + require.NotNil(t, share) +} diff --git a/server/router/api/v1/test/reaction_service_test.go b/server/router/api/v1/test/reaction_service_test.go index aff97d56..692c3fb3 100644 --- a/server/router/api/v1/test/reaction_service_test.go +++ b/server/router/api/v1/test/reaction_service_test.go @@ -6,6 +6,8 @@ import ( "testing" "github.com/stretchr/testify/require" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" apiv1 "github.com/usememos/memos/proto/gen/api/v1" "github.com/usememos/memos/store" @@ -54,6 +56,19 @@ func TestMemoReactionResourceNames(t *testing.T) { require.Equal(t, reaction.Name, fetchedMemo.Reactions[0].Name) } +func TestUpsertMemoReactionRequiresReaction(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + user, err := ts.CreateRegularUser(ctx, "reaction-required-user") + require.NoError(t, err) + _, err = ts.Service.UpsertMemoReaction(ts.CreateUserContext(ctx, user.ID), &apiv1.UpsertMemoReactionRequest{ + Name: "memos/missing", + }) + require.Equal(t, codes.InvalidArgument, status.Code(err)) +} + func TestListMemoCommentsIncludesReactionResourceNames(t *testing.T) { ctx := context.Background() ts := NewTestService(t) @@ -87,6 +102,151 @@ func TestListMemoCommentsIncludesReactionResourceNames(t *testing.T) { require.True(t, strings.HasPrefix(comments.Memos[0].Reactions[0].Name, comment.Name+"/reactions/")) } +func TestUpsertMemoReactionRevalidatesSpaceParticipation(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + owner, err := ts.CreateRegularUser(ctx, "reaction-space-owner") + require.NoError(t, err) + member, err := ts.CreateRegularUser(ctx, "reaction-space-member") + require.NoError(t, err) + applicationAdmin, err := ts.CreateHostUser(ctx, "reaction-space-application-admin") + require.NoError(t, err) + memberCtx := ts.CreateUserContext(ctx, member.ID) + adminCtx := ts.CreateUserContext(ctx, applicationAdmin.ID) + + space, err := ts.Store.CreateSpace(ctx, &store.Space{UID: "reaction-space", Title: "Reaction Space"}, owner.ID) + require.NoError(t, err) + _, err = ts.Store.CreateSpaceMember(ctx, &store.SpaceMember{ + SpaceID: space.ID, + UserID: member.ID, + Role: store.SpaceMemberRoleUser, + }, owner.ID) + require.NoError(t, err) + root, err := ts.Store.CreateMemo(ctx, &store.Memo{ + UID: "reaction-space-root", + CreatorID: owner.ID, + Content: "assigned public memo", + Visibility: store.Public, + SpaceID: &space.ID, + }) + require.NoError(t, err) + memoName := "memos/" + root.UID + + memberReaction, err := ts.Service.UpsertMemoReaction(memberCtx, &apiv1.UpsertMemoReactionRequest{ + Name: memoName, + Reaction: &apiv1.Reaction{ReactionType: "👍"}, + }) + require.NoError(t, err) + + // An application ADMIN has no Space participation bypass. + _, err = ts.Service.UpsertMemoReaction(adminCtx, &apiv1.UpsertMemoReactionRequest{ + Name: memoName, + Reaction: &apiv1.Reaction{ReactionType: "🔥"}, + }) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + + require.NoError(t, ts.Store.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: member.ID}, owner.ID)) + _, err = ts.Service.DeleteMemoReaction(memberCtx, &apiv1.DeleteMemoReactionRequest{Name: memberReaction.Name}) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + _, err = ts.Service.UpsertMemoReaction(memberCtx, &apiv1.UpsertMemoReactionRequest{ + Name: memoName, + Reaction: &apiv1.Reaction{ReactionType: "🔥"}, + }) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + + _, err = ts.Store.CreateSpaceMember(ctx, &store.SpaceMember{ + SpaceID: space.ID, + UserID: member.ID, + Role: store.SpaceMemberRoleUser, + }, owner.ID) + require.NoError(t, err) + _, err = ts.Service.DeleteMemoReaction(memberCtx, &apiv1.DeleteMemoReactionRequest{Name: memberReaction.Name}) + require.NoError(t, err) + _, err = ts.Service.UpsertMemoReaction(memberCtx, &apiv1.UpsertMemoReactionRequest{ + Name: memoName, + Reaction: &apiv1.Reaction{ReactionType: "🔥"}, + }) + require.NoError(t, err) + + reactions, err := ts.Store.ListReactions(ctx, &store.FindReaction{MemoID: &root.ID}) + require.NoError(t, err) + require.Len(t, reactions, 1) +} + +func TestAssignedMemoReactionsFollowMemoReadAccess(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + owner, err := ts.CreateRegularUser(ctx, "assigned-reaction-owner") + require.NoError(t, err) + member, err := ts.CreateRegularUser(ctx, "assigned-reaction-member") + require.NoError(t, err) + outsider, err := ts.CreateHostUser(ctx, "assigned-reaction-app-admin") + require.NoError(t, err) + ownerCtx := ts.CreateUserContext(ctx, owner.ID) + memberCtx := ts.CreateUserContext(ctx, member.ID) + outsiderCtx := ts.CreateUserContext(ctx, outsider.ID) + + space, err := ts.Store.CreateSpace(ctx, &store.Space{UID: "assigned-reaction-space", Title: "Assigned reactions"}, owner.ID) + require.NoError(t, err) + _, err = ts.Store.CreateSpaceMember(ctx, &store.SpaceMember{ + SpaceID: space.ID, + UserID: member.ID, + Role: store.SpaceMemberRoleAdmin, + }, owner.ID) + require.NoError(t, err) + memo, err := ts.Service.CreateMemo(ownerCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "assigned public memo with reactions", + Visibility: apiv1.Visibility_PUBLIC, + Space: ptr("spaces/" + space.UID), + }}) + require.NoError(t, err) + _, err = ts.Service.UpsertMemoReaction(ownerCtx, &apiv1.UpsertMemoReactionRequest{ + Name: memo.Name, + Reaction: &apiv1.Reaction{ReactionType: "👍"}, + }) + require.NoError(t, err) + + listed, err := ts.Service.ListMemoReactions(memberCtx, &apiv1.ListMemoReactionsRequest{Name: memo.Name}) + require.NoError(t, err) + require.Len(t, listed.Reactions, 1) + + listed, err = ts.Service.ListMemoReactions(ctx, &apiv1.ListMemoReactionsRequest{Name: memo.Name}) + require.NoError(t, err) + require.Len(t, listed.Reactions, 1, "anonymous reaction reads follow the PUBLIC memo audience") + listed, err = ts.Service.ListMemoReactions(outsiderCtx, &apiv1.ListMemoReactionsRequest{Name: memo.Name}) + require.NoError(t, err) + require.Len(t, listed.Reactions, 1, "Space placement adds no reaction read gate") + + got, err := ts.Service.GetMemo(outsiderCtx, &apiv1.GetMemoRequest{Name: memo.Name}) + require.NoError(t, err, "a non-member may still read an assigned PUBLIC memo") + require.Empty(t, got.GetSpace()) + require.Len(t, got.Reactions, 1, "embedded reactions follow the readable memo") + feed, err := ts.Service.ListMemos(outsiderCtx, &apiv1.ListMemosRequest{PageSize: 20}) + require.NoError(t, err) + var listedMemo *apiv1.Memo + for _, candidate := range feed.Memos { + if candidate.Name == memo.Name { + listedMemo = candidate + break + } + } + require.NotNil(t, listedMemo) + require.Len(t, listedMemo.Reactions, 1) + + require.NoError(t, ts.Store.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: owner.ID}, owner.ID)) + listed, err = ts.Service.ListMemoReactions(ownerCtx, &apiv1.ListMemoReactionsRequest{Name: memo.Name}) + require.NoError(t, err) + require.Len(t, listed.Reactions, 1, "the removed author still reads a PUBLIC memo and its reactions") + got, err = ts.Service.GetMemo(ownerCtx, &apiv1.GetMemoRequest{Name: memo.Name}) + require.NoError(t, err) + require.Equal(t, "spaces/"+space.UID, got.GetSpace(), "the author may still see placement") + require.Len(t, got.Reactions, 1) +} + func TestDeleteMemoReaction(t *testing.T) { ctx := context.Background() @@ -127,7 +287,7 @@ func TestDeleteMemoReaction(t *testing.T) { require.NoError(t, err) }) - t.Run("DeleteMemoReaction succeeds when memo was concurrently deleted", func(t *testing.T) { + t.Run("DeleteMemoReaction fails closed when memo was concurrently deleted", func(t *testing.T) { ts := NewTestService(t) defer ts.Cleanup() @@ -156,13 +316,13 @@ func TestDeleteMemoReaction(t *testing.T) { require.NoError(t, err) _, err = ts.Service.DeleteMemoReaction(userCtx, &apiv1.DeleteMemoReactionRequest{Name: reaction.Name}) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + remainingReaction, err := ts.Store.GetReaction(ctx, &store.FindReaction{ID: &storedReaction.ID}) require.NoError(t, err) - deletedReaction, err := ts.Store.GetReaction(ctx, &store.FindReaction{ID: &storedReaction.ID}) - require.NoError(t, err) - require.Nil(t, deletedReaction) + require.NotNil(t, remainingReaction, "a missing direct memo must not authorize a reaction mutation") }) - t.Run("DeleteMemoReaction success by host user", func(t *testing.T) { + t.Run("DeleteMemoReaction host user has no ownership bypass", func(t *testing.T) { ts := NewTestService(t) defer ts.Cleanup() @@ -196,11 +356,15 @@ func TestDeleteMemoReaction(t *testing.T) { require.NoError(t, err) require.NotNil(t, reaction) - // Host user can delete reaction - should succeed + // Application ADMIN is an instance role, not reaction ownership. _, err = ts.Service.DeleteMemoReaction(hostCtx, &apiv1.DeleteMemoReactionRequest{ Name: reaction.Name, }) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + memoID := parseMemoIDFromNameForTest(t, ts, memo.Name) + remainingReaction, err := ts.Store.GetReaction(ctx, &store.FindReaction{MemoID: &memoID, CreatorID: ®ularUser.ID}) require.NoError(t, err) + require.NotNil(t, remainingReaction) }) t.Run("DeleteMemoReaction permission denied for non-owner", func(t *testing.T) { diff --git a/server/router/api/v1/test/sse_handler_test.go b/server/router/api/v1/test/sse_handler_test.go index 0f5cd896..d698c67d 100644 --- a/server/router/api/v1/test/sse_handler_test.go +++ b/server/router/api/v1/test/sse_handler_test.go @@ -12,6 +12,7 @@ import ( "github.com/labstack/echo/v5" "github.com/stretchr/testify/require" + v1pb "github.com/usememos/memos/proto/gen/api/v1" "github.com/usememos/memos/server/auth" apiv1 "github.com/usememos/memos/server/router/api/v1" ) @@ -103,14 +104,18 @@ func TestSSEHandler_Authentication(t *testing.T) { require.NoError(t, err) require.Equal(t, "\n", line) - ts.Service.SSEHub.Broadcast(&apiv1.SSEEvent{ - Type: apiv1.SSEEventMemoUpdated, - Name: "memos/streamed", + _, err = ts.Service.CreateMemo(ts.CreateUserContext(ctx, user.ID), &v1pb.CreateMemoRequest{ + MemoId: "streamed", + Memo: &v1pb.Memo{ + Content: "streamed memo", + Visibility: v1pb.Visibility_PUBLIC, + }, }) + require.NoError(t, err) line, err = reader.ReadString('\n') require.NoError(t, err) - require.Equal(t, "data: {\"type\":\"memo.updated\",\"name\":\"memos/streamed\"}\n", line) + require.Equal(t, "data: {\"type\":\"memo.changed\"}\n", line) line, err = reader.ReadString('\n') require.NoError(t, err) require.Equal(t, "\n", line) diff --git a/server/router/api/v1/test/user_notification_test.go b/server/router/api/v1/test/user_notification_test.go index f2e8b3d4..a36025c0 100644 --- a/server/router/api/v1/test/user_notification_test.go +++ b/server/router/api/v1/test/user_notification_test.go @@ -107,6 +107,96 @@ func TestListUserNotificationsStoresMemoCommentPayloadInInbox(t *testing.T) { require.NotZero(t, inboxes[0].Message.GetMemoComment().RelatedMemoId) } +func TestAssignedPublicMemoCommentNotifiesReadableRemovedAuthor(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + var sentMessage *email.Message + ts.Service.NotificationEmailSender = func(_ *email.Config, message *email.Message) { + sentMessage = message + } + _, err := ts.Store.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{ + Key: storepb.InstanceSettingKey_NOTIFICATION, + Value: &storepb.InstanceSetting_NotificationSetting{ + NotificationSetting: &storepb.InstanceNotificationSetting{ + Email: &storepb.InstanceNotificationSetting_EmailSetting{ + Enabled: true, + SmtpHost: "smtp.example.com", + SmtpPort: 587, + FromEmail: "bot@example.com", + }, + }, + }, + }) + require.NoError(t, err) + + owner, err := ts.CreateRegularUser(ctx, "removed-comment-owner") + require.NoError(t, err) + commenter, err := ts.CreateRegularUser(ctx, "remaining-comment-member") + require.NoError(t, err) + ownerCtx := ts.CreateUserContext(ctx, owner.ID) + commenterCtx := ts.CreateUserContext(ctx, commenter.ID) + space, err := ts.Store.CreateSpace(ctx, &store.Space{UID: "removed-owner-comments", Title: "Removed owner comments"}, owner.ID) + require.NoError(t, err) + _, err = ts.Store.CreateSpaceMember(ctx, &store.SpaceMember{ + SpaceID: space.ID, + UserID: commenter.ID, + Role: store.SpaceMemberRoleAdmin, + }, owner.ID) + require.NoError(t, err) + memo, err := ts.Service.CreateMemo(ownerCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "assigned public memo", + Visibility: apiv1.Visibility_PUBLIC, + Space: ptr("spaces/" + space.UID), + }}) + require.NoError(t, err) + require.NoError(t, ts.Store.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: owner.ID}, owner.ID)) + + _, err = ts.Service.CreateMemoComment(commenterCtx, &apiv1.CreateMemoCommentRequest{ + Name: memo.Name, + Comment: &apiv1.Memo{ + Content: "public comment visible to removed owner", + Visibility: apiv1.Visibility_PUBLIC, + }, + }) + require.NoError(t, err) + require.NotNil(t, sentMessage, "membership does not add a read gate to PUBLIC memo endpoints") + + messageType := storepb.InboxMessage_MEMO_COMMENT + inboxes, err := ts.Store.ListInboxes(ctx, &store.FindInbox{ReceiverID: &owner.ID, MessageType: &messageType}) + require.NoError(t, err) + require.Len(t, inboxes, 1) + response, err := ts.Service.ListUserNotifications(ownerCtx, &apiv1.ListUserNotificationsRequest{Parent: "users/" + owner.Username}) + require.NoError(t, err) + require.Len(t, response.Notifications, 1) + + _, err = ts.Store.CreateSpaceMember(ctx, &store.SpaceMember{ + SpaceID: space.ID, + UserID: owner.ID, + Role: store.SpaceMemberRoleUser, + }, commenter.ID) + require.NoError(t, err) + sentMessage = nil + _, err = ts.Service.CreateMemoComment(commenterCtx, &apiv1.CreateMemoCommentRequest{ + Name: memo.Name, + Comment: &apiv1.Memo{ + Content: "comment visible while owner is a member", + Visibility: apiv1.Visibility_PUBLIC, + }, + }) + require.NoError(t, err) + require.NotNil(t, sentMessage) + inboxes, err = ts.Store.ListInboxes(ctx, &store.FindInbox{ReceiverID: &owner.ID, MessageType: &messageType}) + require.NoError(t, err) + require.Len(t, inboxes, 2) + + require.NoError(t, ts.Store.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: owner.ID}, commenter.ID)) + response, err = ts.Service.ListUserNotifications(ownerCtx, &apiv1.ListUserNotificationsRequest{Parent: "users/" + owner.Username}) + require.NoError(t, err) + require.Len(t, response.Notifications, 2, "both PUBLIC endpoints remain readable after membership revocation") +} + func TestCreateMemoCommentSendsEmailNotificationWhenEnabled(t *testing.T) { ctx := context.Background() ts := NewTestService(t) @@ -286,7 +376,7 @@ func TestCreateMemoCommentSkipsEmailNotificationWithoutInstanceURL(t *testing.T) require.Nil(t, sentMessage) } -func TestListUserNotificationsOmitsPayloadWhenMemosDeleted(t *testing.T) { +func TestListUserNotificationsOmitsNotificationWhenMemoDeleted(t *testing.T) { ctx := context.Background() ts := NewTestService(t) defer ts.Cleanup() @@ -325,9 +415,7 @@ func TestListUserNotificationsOmitsPayloadWhenMemosDeleted(t *testing.T) { Parent: fmt.Sprintf("users/%s", owner.Username), }) require.NoError(t, err) - require.Len(t, resp.Notifications, 1) - require.Equal(t, apiv1.UserNotification_MEMO_COMMENT, resp.Notifications[0].Type) - require.Nil(t, resp.Notifications[0].GetMemoComment()) + require.Empty(t, resp.Notifications, "a notification whose memo subject is no longer readable must be omitted in full") } func TestListUserNotificationsSkipsNotificationsWithMissingUsers(t *testing.T) { diff --git a/server/router/api/v1/test/user_service_delete_test.go b/server/router/api/v1/test/user_service_delete_test.go index d805615c..bd26cc0d 100644 --- a/server/router/api/v1/test/user_service_delete_test.go +++ b/server/router/api/v1/test/user_service_delete_test.go @@ -9,6 +9,8 @@ import ( "time" "github.com/stretchr/testify/require" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" "google.golang.org/protobuf/types/known/timestamppb" v1pb "github.com/usememos/memos/proto/gen/api/v1" @@ -68,7 +70,7 @@ func TestDeleteUserSelfDeleteCleansAccountDataAndAuthCookies(t *testing.T) { require.Contains(t, strings.ToLower(carrier.Get("Set-Cookie")), "memos_refresh=") } -func TestDeleteUserSelfDeleteRemovesOwnedResourcesAndMemoSubtrees(t *testing.T) { +func TestDeleteUserSelfDeleteRemovesOnlyOwnedMemosAndResources(t *testing.T) { t.Parallel() ts := NewTestService(t) @@ -125,7 +127,6 @@ func TestDeleteUserSelfDeleteRemovesOwnedResourcesAndMemoSubtrees(t *testing.T) }, }) require.NoError(t, err) - peerReplyToUserComment, err := ts.Service.CreateMemoComment(peerCtx, &v1pb.CreateMemoCommentRequest{ Name: userCommentOnForeignMemo.Name, Comment: &v1pb.Memo{ @@ -146,7 +147,10 @@ func TestDeleteUserSelfDeleteRemovesOwnedResourcesAndMemoSubtrees(t *testing.T) foreignMemoStore, err := ts.Store.GetMemo(ctx, &store.FindMemo{UID: &foreignMemoUID}) require.NoError(t, err) require.NotNil(t, foreignMemoStore) + peerCommentOnOwnMemoID := parseMemoIDFromNameForTest(t, ts, peerCommentOnOwnMemo.Name) + peerNestedCommentOnOwnMemoID := parseMemoIDFromNameForTest(t, ts, peerNestedCommentOnOwnMemo.Name) userCommentOnForeignMemoID := parseMemoIDFromNameForTest(t, ts, userCommentOnForeignMemo.Name) + peerReplyToUserCommentID := parseMemoIDFromNameForTest(t, ts, peerReplyToUserComment.Name) attachedAttachment, err := ts.Store.CreateAttachment(ctx, &store.Attachment{ UID: "attach-owner-memo", @@ -256,10 +260,7 @@ func TestDeleteUserSelfDeleteRemovesOwnedResourcesAndMemoSubtrees(t *testing.T) for _, memoName := range []string{ ownMemo.Name, - peerCommentOnOwnMemo.Name, - peerNestedCommentOnOwnMemo.Name, userCommentOnForeignMemo.Name, - peerReplyToUserComment.Name, } { memoUID, extractErr := apiv1.ExtractMemoUIDFromName(memoName) require.NoError(t, extractErr) @@ -267,10 +268,33 @@ func TestDeleteUserSelfDeleteRemovesOwnedResourcesAndMemoSubtrees(t *testing.T) require.NoError(t, getErr) require.Nil(t, memo, memoName) } + for _, memoName := range []string{ + peerCommentOnOwnMemo.Name, + peerNestedCommentOnOwnMemo.Name, + peerReplyToUserComment.Name, + } { + memoUID, extractErr := apiv1.ExtractMemoUIDFromName(memoName) + require.NoError(t, extractErr) + memo, getErr := ts.Store.GetMemo(ctx, &store.FindMemo{UID: &memoUID}) + require.NoError(t, getErr) + require.NotNil(t, memo, memoName) + } foreignMemoAfterDelete, err := ts.Store.GetMemo(ctx, &store.FindMemo{UID: &foreignMemoUID}) require.NoError(t, err) require.NotNil(t, foreignMemoAfterDelete) + nestedRelations, err := ts.Store.ListMemoRelations(ctx, &store.FindMemoRelation{MemoID: &peerNestedCommentOnOwnMemoID}) + require.NoError(t, err) + require.Len(t, nestedRelations, 1) + require.Equal(t, peerCommentOnOwnMemoID, nestedRelations[0].RelatedMemoID) + for _, memoID := range []int32{ownMemoStore.ID, userCommentOnForeignMemoID} { + incidentRelations, listErr := ts.Store.ListMemoRelations(ctx, &store.FindMemoRelation{MemoIDList: []int32{memoID}}) + require.NoError(t, listErr) + require.Empty(t, incidentRelations) + } + contextlessReplyRelations, err := ts.Store.ListMemoRelations(ctx, &store.FindMemoRelation{MemoID: &peerReplyToUserCommentID}) + require.NoError(t, err) + require.Empty(t, contextlessReplyRelations) for _, attachmentID := range []int32{attachedAttachment.ID, unattachedAttachment.ID} { attachment, getErr := ts.Store.GetAttachment(ctx, &store.FindAttachment{ID: &attachmentID}) @@ -326,6 +350,52 @@ func TestDeleteUserSelfDeleteRemovesOwnedResourcesAndMemoSubtrees(t *testing.T) require.Nil(t, patSetting) } +func TestDeleteUserSpaceMembershipGuardIgnoresForce(t *testing.T) { + for _, tc := range []struct { + name string + force bool + suffix string + }{ + {name: "without force", suffix: "normal"}, + {name: "with force", force: true, suffix: "force"}, + } { + t.Run(tc.name, func(t *testing.T) { + ts := NewTestService(t) + defer ts.Cleanup() + + ctx := context.Background() + user, err := ts.CreateRegularUser(ctx, "membership-delete-"+tc.suffix) + require.NoError(t, err) + space, err := ts.Store.CreateSpace(ctx, &store.Space{UID: "membership-delete-" + tc.suffix, Title: "Membership guard"}, user.ID) + require.NoError(t, err) + memo, err := ts.Service.CreateMemo(ts.CreateUserContext(ctx, user.ID), &v1pb.CreateMemoRequest{Memo: &v1pb.Memo{ + Content: "must survive failed account deletion", + Visibility: v1pb.Visibility_PUBLIC, + }}) + require.NoError(t, err) + + _, err = ts.Service.DeleteUser(ts.CreateUserContext(ctx, user.ID), &v1pb.DeleteUserRequest{ + Name: apiv1.BuildUserName(user.Username), + Force: tc.force, + }) + require.Equal(t, codes.FailedPrecondition, status.Code(err)) + require.ErrorContains(t, err, "leave all spaces") + + remainingUser, err := ts.Store.GetUser(ctx, &store.FindUser{ID: &user.ID}) + require.NoError(t, err) + require.NotNil(t, remainingUser) + membership, err := ts.Store.GetSpaceMember(ctx, &store.FindSpaceMember{SpaceID: &space.ID, UserID: &user.ID, ViewerUserID: &user.ID}) + require.NoError(t, err) + require.NotNil(t, membership) + memoUID, err := apiv1.ExtractMemoUIDFromName(memo.Name) + require.NoError(t, err) + remainingMemo, err := ts.Store.GetMemo(ctx, &store.FindMemo{UID: &memoUID}) + require.NoError(t, err) + require.NotNil(t, remainingMemo) + }) + } +} + func TestDeleteUserRollbackPreservesAllResources(t *testing.T) { t.Parallel() @@ -451,7 +521,7 @@ func TestDeleteUserRollbackPreservesAllResources(t *testing.T) { require.NotNil(t, patSetting) } -func TestDeleteUserReturnsErrorWhenAttachmentStorageCleanupFails(t *testing.T) { +func TestDeleteUserReportsPostCommitAttachmentStorageCleanupFailure(t *testing.T) { t.Parallel() ts := NewTestService(t) @@ -472,19 +542,20 @@ func TestDeleteUserReturnsErrorWhenAttachmentStorageCleanupFails(t *testing.T) { Reference: "cleanup-failure.txt", }) require.NoError(t, err) + attachmentPath := filepath.Join(ts.Profile.Data, "cleanup-failure.txt") + require.NoError(t, os.WriteFile(attachmentPath, []byte("failure"), 0o600)) headerCtx := apiv1.WithHeaderCarrier(ctx) - failCtx := store.WithDeleteAttachmentStorageFailpoint(headerCtx) - authCtx := ts.CreateUserContext(failCtx, user.ID) + authCtx := ts.CreateUserContext(store.WithDeleteAttachmentStorageFailpoint(headerCtx), user.ID) _, err = ts.Service.DeleteUser(authCtx, &v1pb.DeleteUserRequest{ Name: apiv1.BuildUserName(user.Username), }) - require.Error(t, err) - require.ErrorContains(t, err, "attachment storage cleanup failed") - require.ErrorContains(t, err, "attachment_id=") + require.Equal(t, codes.Internal, status.Code(err)) + require.ErrorContains(t, err, "user was deleted but attachment storage cleanup failed") require.ErrorContains(t, err, store.ErrDeleteAttachmentStorageFailpoint.Error()) deletedUser, err := ts.Store.GetUser(ctx, &store.FindUser{ID: &user.ID}) require.NoError(t, err) require.Nil(t, deletedUser) + require.FileExists(t, attachmentPath, "storage cleanup failure happens after the database deletion commits") } diff --git a/server/router/api/v1/test/user_service_stats_test.go b/server/router/api/v1/test/user_service_stats_test.go index 321a7879..20f02d1e 100644 --- a/server/router/api/v1/test/user_service_stats_test.go +++ b/server/router/api/v1/test/user_service_stats_test.go @@ -262,3 +262,103 @@ func TestListAllUserStats_FilterExcludesPrivateMemos(t *testing.T) { require.Equal(t, int32(1), filteredResp.Stats[0].TagCount["public"]) require.NotContains(t, filteredResp.Stats[0].TagCount, "private") } + +func TestUserStatsUseMemoLocalAccess(t *testing.T) { + ctx := context.Background() + ts := NewTestService(t) + defer ts.Cleanup() + + owner, err := ts.CreateRegularUser(ctx, "stats-access-owner") + require.NoError(t, err) + member, err := ts.CreateRegularUser(ctx, "stats-access-member") + require.NoError(t, err) + applicationAdmin, err := ts.CreateHostUser(ctx, "stats-access-app-admin") + require.NoError(t, err) + + space, err := ts.Store.CreateSpace(ctx, &store.Space{ + UID: "stats-access-space", + Title: "Stats access", + }, owner.ID) + require.NoError(t, err) + _, err = ts.Store.CreateSpaceMember(ctx, &store.SpaceMember{ + SpaceID: space.ID, + UserID: member.ID, + Role: store.SpaceMemberRoleUser, + }, owner.ID) + require.NoError(t, err) + + fixtures := []struct { + uid string + visibility store.Visibility + spaceID *int32 + tag string + }{ + {uid: "stats-access-public", visibility: store.Public, tag: "public"}, + {uid: "stats-access-protected", visibility: store.Protected, tag: "protected"}, + {uid: "stats-access-private", visibility: store.Private, tag: "private"}, + {uid: "stats-access-members", visibility: store.SpaceAudience, spaceID: &space.ID, tag: "space"}, + } + for _, fixture := range fixtures { + _, err := ts.Store.CreateMemo(ctx, &store.Memo{ + UID: fixture.uid, + CreatorID: owner.ID, + Content: fixture.tag, + Visibility: fixture.visibility, + SpaceID: fixture.spaceID, + Payload: &storepb.MemoPayload{Tags: []string{fixture.tag}}, + }) + require.NoError(t, err) + } + + ownerName := fmt.Sprintf("users/%s", owner.Username) + tests := []struct { + name string + requestCtx context.Context + wantTags []string + denyTags []string + }{ + { + name: "owner", + requestCtx: ts.CreateUserContext(ctx, owner.ID), + wantTags: []string{"public", "protected", "private", "space"}, + }, + { + name: "space member", + requestCtx: ts.CreateUserContext(ctx, member.ID), + wantTags: []string{"public", "protected", "space"}, + denyTags: []string{"private"}, + }, + { + name: "nonmember application admin", + requestCtx: ts.CreateUserContext(ctx, applicationAdmin.ID), + wantTags: []string{"public", "protected"}, + denyTags: []string{"private", "space"}, + }, + { + name: "anonymous", + requestCtx: ctx, + wantTags: []string{"public"}, + denyTags: []string{"protected", "private", "space"}, + }, + } + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + response, err := ts.Service.GetUserStats(test.requestCtx, &v1pb.GetUserStatsRequest{Name: ownerName}) + require.NoError(t, err) + require.Equal(t, int32(len(test.wantTags)), response.TotalMemoCount) + for _, tag := range test.wantTags { + require.Equal(t, int32(1), response.TagCount[tag], "expected tag %q to be visible", tag) + } + for _, tag := range test.denyTags { + require.NotContains(t, response.TagCount, tag) + } + }) + } + + memberStats, err := ts.Service.ListAllUserStats(ts.CreateUserContext(ctx, member.ID), &v1pb.ListAllUserStatsRequest{}) + require.NoError(t, err) + require.Len(t, memberStats.Stats, 1) + require.Equal(t, int32(3), memberStats.Stats[0].TotalMemoCount) + require.Contains(t, memberStats.Stats[0].TagCount, "space") + require.NotContains(t, memberStats.Stats[0].TagCount, "private") +} diff --git a/server/router/api/v1/user_service.go b/server/router/api/v1/user_service.go index d313c57a..72482fce 100644 --- a/server/router/api/v1/user_service.go +++ b/server/router/api/v1/user_service.go @@ -2,6 +2,7 @@ package v1 import ( "context" + stderrors "errors" "fmt" "log/slog" "regexp" @@ -16,7 +17,6 @@ import ( "google.golang.org/protobuf/types/known/emptypb" v1pb "github.com/usememos/memos/proto/gen/api/v1" - storepb "github.com/usememos/memos/proto/gen/store" "github.com/usememos/memos/store" ) @@ -308,10 +308,10 @@ func (s *APIV1Service) UpdateUser(ctx context.Context, request *v1pb.UpdateUserR return nil, status.Errorf(codes.PermissionDenied, "permission denied") } - currentTs := time.Now().Unix() + currentTsSec := time.Now().Unix() update := &store.UpdateUser{ ID: user.ID, - UpdatedTs: ¤tTs, + UpdatedTs: ¤tTsSec, } instanceGeneralSetting, err := s.Store.GetInstanceGeneralSetting(ctx) if err != nil { @@ -386,6 +386,9 @@ func (s *APIV1Service) UpdateUser(ctx context.Context, request *v1pb.UpdateUserR updatedUser, err := s.Store.UpdateUser(ctx, update) if err != nil { + if stderrors.Is(err, store.ErrLastSpaceAdmin) { + return nil, status.Error(codes.FailedPrecondition, "an active space must retain an active administrator") + } return nil, status.Errorf(codes.Internal, "failed to update user: %v", err) } @@ -417,58 +420,23 @@ func (s *APIV1Service) DeleteUser(ctx context.Context, request *v1pb.DeleteUserR ID: user.ID, }) if err != nil { + if stderrors.Is(err, store.ErrUserHasSpaceMembership) { + return nil, status.Error(codes.FailedPrecondition, "leave all spaces before deleting this account") + } return nil, status.Errorf(codes.Internal, "failed to delete user: %v", err) } - attachments := deleteResult.Attachments - var attachmentCleanupErr error - failedAttachmentIDs := make([]int32, 0) - attachmentStorageSetting, attachmentStorageSettingErr := getDeleteUserAttachmentStorageSetting(ctx, s.Store, attachments) - for _, attachment := range attachments { - var err error - if attachmentStorageSettingErr != nil && store.AttachmentNeedsInstanceStorageSetting(attachment) { - err = attachmentStorageSettingErr - } else { - err = s.Store.DeleteAttachmentStorageWithInstanceSetting(ctx, attachment, attachmentStorageSetting) - } - if err != nil { - slog.Warn("failed to delete attachment storage after deleting user", "user_id", userID, "attachment_id", attachment.ID, "error", err) - failedAttachmentIDs = append(failedAttachmentIDs, attachment.ID) - if attachmentCleanupErr == nil { - attachmentCleanupErr = err - } - } - } if isSelfDelete { if err := s.clearAuthCookies(ctx); err != nil { slog.Warn("failed to clear auth cookies after self delete", "user_id", userID, "error", err) } } - if attachmentCleanupErr != nil { - return nil, status.Errorf( - codes.Internal, - "user was deleted but attachment storage cleanup failed for %d attachment(s), first attachment_id=%d: %v", - len(failedAttachmentIDs), - failedAttachmentIDs[0], - attachmentCleanupErr, - ) + if err := s.cleanupDeletedAttachmentStorage(ctx, deleteResult.Attachments); err != nil { + return nil, status.Errorf(codes.Internal, "user was deleted but attachment storage cleanup failed: %v", err) } return &emptypb.Empty{}, nil } -func getDeleteUserAttachmentStorageSetting(ctx context.Context, stores *store.Store, attachments []*store.Attachment) (*storepb.InstanceStorageSetting, error) { - for _, attachment := range attachments { - if store.AttachmentNeedsInstanceStorageSetting(attachment) { - instanceStorageSetting, err := stores.GetInstanceStorageSetting(ctx) - if err != nil { - return nil, errors.Wrap(err, "failed to get instance storage setting") - } - return instanceStorageSetting, nil - } - } - return nil, nil -} - func getDefaultUserGeneralSetting() *v1pb.UserSetting_GeneralSetting { return &v1pb.UserSetting_GeneralSetting{ Locale: "en", diff --git a/server/router/api/v1/user_service_notifications.go b/server/router/api/v1/user_service_notifications.go index 27a7b9a9..41051bb7 100644 --- a/server/router/api/v1/user_service_notifications.go +++ b/server/router/api/v1/user_service_notifications.go @@ -14,6 +14,7 @@ import ( v1pb "github.com/usememos/memos/proto/gen/api/v1" storepb "github.com/usememos/memos/proto/gen/store" + "github.com/usememos/memos/server/access" "github.com/usememos/memos/store" ) @@ -60,7 +61,7 @@ func (s *APIV1Service) ListUserNotifications(ctx context.Context, request *v1pb. notifications := []*v1pb.UserNotification{} for _, inbox := range inboxes { - notification, err := s.convertInboxToUserNotificationWithUsersAndMemos(inbox, currentUser, usersByID, memosByID) + notification, err := s.convertInboxToUserNotificationWithUsersAndMemos(ctx, inbox, currentUser, usersByID, memosByID) if err != nil { if status.Code(err) == codes.NotFound { slog.Warn("Skipping notification with missing user", @@ -72,7 +73,7 @@ func (s *APIV1Service) ListUserNotifications(ctx context.Context, request *v1pb. } return nil, status.Errorf(codes.Internal, "failed to convert inbox: %v", err) } - if notification.Type == v1pb.UserNotification_TYPE_UNSPECIFIED { + if notification == nil || notification.Type == v1pb.UserNotification_TYPE_UNSPECIFIED { continue } notifications = append(notifications, notification) @@ -120,6 +121,17 @@ func (s *APIV1Service) UpdateUserNotification(ctx context.Context, request *v1pb if inbox.ReceiverID != currentUser.ID { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } + memosByID, err := s.listMemosByID(ctx, collectInboxMemoIDs([]*store.Inbox{inbox})) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to list notification memos: %v", err) + } + accessible, err := s.canAccessNotificationMemos(ctx, currentUser, inbox, memosByID) + if err != nil { + return nil, status.Errorf(codes.Internal, "failed to authorize notification: %v", err) + } + if !accessible { + return nil, status.Errorf(codes.NotFound, "notification not found") + } // Build update request based on field mask update := &store.UpdateInbox{ @@ -154,6 +166,9 @@ func (s *APIV1Service) UpdateUserNotification(ctx context.Context, request *v1pb if err != nil { return nil, status.Errorf(codes.Internal, "failed to convert inbox: %v", err) } + if notification == nil { + return nil, status.Errorf(codes.NotFound, "notification not found") + } return notification, nil } @@ -212,7 +227,7 @@ func (s *APIV1Service) convertInboxToUserNotification(ctx context.Context, inbox if err != nil { return nil, status.Errorf(codes.Internal, "failed to list notification memos: %v", err) } - return s.convertInboxToUserNotificationWithUsersAndMemos(inbox, viewer, usersByID, memosByID) + return s.convertInboxToUserNotificationWithUsersAndMemos(ctx, inbox, viewer, usersByID, memosByID) } func collectInboxMemoIDs(inboxes []*store.Inbox) []int32 { @@ -225,12 +240,22 @@ func collectInboxMemoIDs(inboxes []*store.Inbox) []int32 { case storepb.InboxMessage_MEMO_COMMENT: payload := inbox.Message.GetMemoComment() if payload != nil { - memoIDs = append(memoIDs, payload.MemoId, payload.RelatedMemoId) + if payload.MemoId > 0 { + memoIDs = append(memoIDs, payload.MemoId) + } + if payload.RelatedMemoId > 0 { + memoIDs = append(memoIDs, payload.RelatedMemoId) + } } case storepb.InboxMessage_MEMO_MENTION: payload := inbox.Message.GetMemoMention() if payload != nil { - memoIDs = append(memoIDs, payload.MemoId, payload.RelatedMemoId) + if payload.MemoId > 0 { + memoIDs = append(memoIDs, payload.MemoId) + } + if payload.RelatedMemoId > 0 { + memoIDs = append(memoIDs, payload.RelatedMemoId) + } } default: // Ignore notification types without memo references. @@ -239,7 +264,14 @@ func collectInboxMemoIDs(inboxes []*store.Inbox) []int32 { return memoIDs } -func (s *APIV1Service) convertInboxToUserNotificationWithUsersAndMemos(inbox *store.Inbox, viewer *store.User, usersByID map[int32]*store.User, memosByID map[int32]*store.Memo) (*v1pb.UserNotification, error) { +func (s *APIV1Service) convertInboxToUserNotificationWithUsersAndMemos(ctx context.Context, inbox *store.Inbox, viewer *store.User, usersByID map[int32]*store.User, memosByID map[int32]*store.Memo) (*v1pb.UserNotification, error) { + accessible, err := s.canAccessNotificationMemos(ctx, viewer, inbox, memosByID) + if err != nil { + return nil, err + } + if !accessible { + return nil, nil + } receiver := usersByID[inbox.ReceiverID] if receiver == nil { return nil, status.Errorf(codes.NotFound, "notification receiver not found") @@ -271,7 +303,7 @@ func (s *APIV1Service) convertInboxToUserNotificationWithUsersAndMemos(inbox *st switch inbox.Message.Type { case storepb.InboxMessage_MEMO_COMMENT: notification.Type = v1pb.UserNotification_MEMO_COMMENT - payload, err := s.convertMemoCommentNotificationPayload(viewer, inbox.Message, memosByID) + payload, err := s.convertMemoCommentNotificationPayload(inbox.Message, memosByID) if err != nil { return nil, err } @@ -282,7 +314,7 @@ func (s *APIV1Service) convertInboxToUserNotificationWithUsersAndMemos(inbox *st } case storepb.InboxMessage_MEMO_MENTION: notification.Type = v1pb.UserNotification_MEMO_MENTION - payload, err := s.convertMemoMentionNotificationPayload(viewer, inbox.Message, memosByID) + payload, err := s.convertMemoMentionNotificationPayload(inbox.Message, memosByID) if err != nil { return nil, err } @@ -299,20 +331,55 @@ func (s *APIV1Service) convertInboxToUserNotificationWithUsersAndMemos(inbox *st return notification, nil } -func canViewerAccessMemo(viewer *store.User, memo *store.Memo) bool { - if memo == nil { - return false +func (s *APIV1Service) canAccessNotificationMemos(ctx context.Context, viewer *store.User, inbox *store.Inbox, memosByID map[int32]*store.Memo) (bool, error) { + if viewer == nil || viewer.RowStatus != store.Normal { + return false, nil } - if viewer != nil && isSuperUser(viewer) { - return true + if inbox == nil || inbox.Message == nil { + return true, nil } - if memo.Visibility == store.Private { - return viewer != nil && viewer.ID == memo.CreatorID + check := func(id int32) (bool, error) { + if id <= 0 { + return false, nil + } + memo := memosByID[id] + if memo == nil { + return false, nil + } + readContext, err := s.buildMemoReadContextForViewer(ctx, memo, viewer, false, nil) + if err != nil { + if status.Code(err) == codes.NotFound { + return false, nil + } + return false, err + } + return access.CheckMemoReadContext(readContext).Allowed(), nil } - if memo.Visibility == store.Protected { - return viewer != nil + + switch inbox.Message.Type { + case storepb.InboxMessage_MEMO_COMMENT: + payload := inbox.Message.GetMemoComment() + if payload == nil { + return false, nil + } + canReadComment, err := check(payload.MemoId) + if err != nil || !canReadComment { + return canReadComment, err + } + return check(payload.RelatedMemoId) + case storepb.InboxMessage_MEMO_MENTION: + payload := inbox.Message.GetMemoMention() + if payload == nil { + return false, nil + } + canReadMemo, err := check(payload.MemoId) + if err != nil || !canReadMemo || payload.RelatedMemoId <= 0 { + return canReadMemo, err + } + return check(payload.RelatedMemoId) + default: + return true, nil } - return true } func (s *APIV1Service) memoNotificationSnippet(memo *store.Memo) (string, error) { @@ -327,21 +394,14 @@ func (s *APIV1Service) memoNotificationSnippet(memo *store.Memo) (string, error) return snippet, nil } -func (s *APIV1Service) convertMemoCommentNotificationPayload(viewer *store.User, message *storepb.InboxMessage, memosByID map[int32]*store.Memo) (*v1pb.UserNotification_MemoCommentPayload, error) { +func (s *APIV1Service) convertMemoCommentNotificationPayload(message *storepb.InboxMessage, memosByID map[int32]*store.Memo) (*v1pb.UserNotification_MemoCommentPayload, error) { memoComment := message.GetMemoComment() if message == nil || message.Type != storepb.InboxMessage_MEMO_COMMENT || memoComment == nil { return nil, nil } commentMemo := memosByID[memoComment.MemoId] - if !canViewerAccessMemo(viewer, commentMemo) { - return nil, nil - } - relatedMemo := memosByID[memoComment.RelatedMemoId] - if !canViewerAccessMemo(viewer, relatedMemo) { - return nil, nil - } memoSnippet, err := s.memoNotificationSnippet(commentMemo) if err != nil { @@ -360,16 +420,13 @@ func (s *APIV1Service) convertMemoCommentNotificationPayload(viewer *store.User, }, nil } -func (s *APIV1Service) convertMemoMentionNotificationPayload(viewer *store.User, message *storepb.InboxMessage, memosByID map[int32]*store.Memo) (*v1pb.UserNotification_MemoMentionPayload, error) { +func (s *APIV1Service) convertMemoMentionNotificationPayload(message *storepb.InboxMessage, memosByID map[int32]*store.Memo) (*v1pb.UserNotification_MemoMentionPayload, error) { memoMention := message.GetMemoMention() if message == nil || message.Type != storepb.InboxMessage_MEMO_MENTION || memoMention == nil { return nil, nil } memo := memosByID[memoMention.MemoId] - if !canViewerAccessMemo(viewer, memo) { - return nil, nil - } memoSnippet, err := s.memoNotificationSnippet(memo) if err != nil { @@ -382,7 +439,7 @@ func (s *APIV1Service) convertMemoMentionNotificationPayload(viewer *store.User, } if memoMention.RelatedMemoId != 0 { relatedMemo := memosByID[memoMention.RelatedMemoId] - if canViewerAccessMemo(viewer, relatedMemo) { + if relatedMemo != nil { payload.RelatedMemo = fmt.Sprintf("%s%s", MemoNamePrefix, relatedMemo.UID) relatedMemoSnippet, err := s.memoNotificationSnippet(relatedMemo) if err != nil { diff --git a/server/router/api/v1/user_service_settings.go b/server/router/api/v1/user_service_settings.go index e659cfa1..fe300e32 100644 --- a/server/router/api/v1/user_service_settings.go +++ b/server/router/api/v1/user_service_settings.go @@ -103,6 +103,11 @@ func (s *APIV1Service) UpdateUserSetting(ctx context.Context, request *v1pb.Upda for _, field := range request.UpdateMask.Paths { switch field { case "memo_visibility": + switch incomingGeneral.MemoVisibility { + case store.Private.String(), store.Protected.String(), store.Public.String(): + default: + return nil, status.Errorf(codes.InvalidArgument, "memo_visibility must be PRIVATE, PROTECTED, or PUBLIC") + } updatedGeneral.MemoVisibility = incomingGeneral.MemoVisibility case "theme": updatedGeneral.Theme = incomingGeneral.Theme diff --git a/server/router/api/v1/user_service_stats.go b/server/router/api/v1/user_service_stats.go index d321af48..511a3757 100644 --- a/server/router/api/v1/user_service_stats.go +++ b/server/router/api/v1/user_service_stats.go @@ -62,9 +62,9 @@ func (s *APIV1Service) ListAllUserStats(ctx context.Context, request *v1pb.ListA RowStatus: &rowStatus, } - currentUser, err := s.fetchCurrentUser(ctx) + accessScope, currentUser, err := s.resolveMemoAccessScope(ctx) if err != nil { - return nil, status.Errorf(codes.Internal, "failed to get user: %v", err) + return nil, status.Errorf(codes.Internal, "%v", err) } if request.Filter != "" { @@ -80,16 +80,8 @@ func (s *APIV1Service) ListAllUserStats(ctx context.Context, request *v1pb.ListA return &v1pb.ListAllUserStatsResponse{}, nil } memoFind.CreatorID = ¤tUser.ID - } else if currentUser == nil { - memoFind.VisibilityList = []store.Visibility{store.Public} - } else { - if memoFind.CreatorID == nil { - filter := fmt.Sprintf(`creator_id == %d || visibility in ["PUBLIC", "PROTECTED"]`, currentUser.ID) - memoFind.Filters = append(memoFind.Filters, filter) - } else if *memoFind.CreatorID != currentUser.ID { - memoFind.VisibilityList = []store.Visibility{store.Public, store.Protected} - } } + memoFind.Access = accessScope userMemoStatMap := make(map[int32]*v1pb.UserStats) pinnedMemoUIDsByUserID := make(map[int32][]string) @@ -198,9 +190,9 @@ func (s *APIV1Service) GetUserStats(ctx context.Context, request *v1pb.GetUserSt } userID := user.ID - currentUser, err := s.fetchCurrentUser(ctx) + accessScope, _, err := s.resolveMemoAccessScope(ctx) if err != nil { - return nil, status.Errorf(codes.Internal, "failed to get user: %v", err) + return nil, status.Errorf(codes.Internal, "%v", err) } normalStatus := store.Normal @@ -212,11 +204,7 @@ func (s *APIV1Service) GetUserStats(ctx context.Context, request *v1pb.GetUserSt RowStatus: &normalStatus, } - if currentUser == nil { - memoFind.VisibilityList = []store.Visibility{store.Public} - } else if currentUser.ID != userID { - memoFind.VisibilityList = []store.Visibility{store.Public, store.Protected} - } + memoFind.Access = accessScope createdTimestamps := []*timestamppb.Timestamp{} updatedTimestamps := []*timestamppb.Timestamp{} diff --git a/server/router/api/v1/user_service_webhooks.go b/server/router/api/v1/user_service_webhooks.go index 4733f128..3b5956d8 100644 --- a/server/router/api/v1/user_service_webhooks.go +++ b/server/router/api/v1/user_service_webhooks.go @@ -31,7 +31,7 @@ func (s *APIV1Service) ListUserWebhooks(ctx context.Context, request *v1pb.ListU if currentUser == nil { return nil, status.Errorf(codes.Unauthenticated, "user not authenticated") } - if currentUser.ID != userID && currentUser.Role != store.RoleAdmin { + if currentUser.ID != userID { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } @@ -64,7 +64,7 @@ func (s *APIV1Service) CreateUserWebhook(ctx context.Context, request *v1pb.Crea if currentUser == nil { return nil, status.Errorf(codes.Unauthenticated, "user not authenticated") } - if currentUser.ID != userID && currentUser.Role != store.RoleAdmin { + if currentUser.ID != userID { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } @@ -121,7 +121,7 @@ func (s *APIV1Service) UpdateUserWebhook(ctx context.Context, request *v1pb.Upda if currentUser == nil { return nil, status.Errorf(codes.Unauthenticated, "user not authenticated") } - if currentUser.ID != userID && currentUser.Role != store.RoleAdmin { + if currentUser.ID != userID { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } @@ -216,7 +216,7 @@ func (s *APIV1Service) DeleteUserWebhook(ctx context.Context, request *v1pb.Dele if currentUser == nil { return nil, status.Errorf(codes.Unauthenticated, "user not authenticated") } - if currentUser.ID != userID && currentUser.Role != store.RoleAdmin { + if currentUser.ID != userID { return nil, status.Errorf(codes.PermissionDenied, "permission denied") } @@ -249,7 +249,7 @@ func (s *APIV1Service) DeleteUserWebhook(ctx context.Context, request *v1pb.Dele // GetUserWebhookSigningSecret reveals the signing secret for a single webhook. // This is the only endpoint that returns the secret value; it is gated to the -// webhook owner (or an admin) and the secret is never included in list/create/update responses. +// webhook owner and the secret is never included in list/create/update responses. func (s *APIV1Service) GetUserWebhookSigningSecret(ctx context.Context, request *v1pb.GetUserWebhookSigningSecretRequest) (*v1pb.GetUserWebhookSigningSecretResponse, error) { user, webhookID, err := s.resolveUserAndWebhookIDFromName(ctx, request.Name) if err != nil { @@ -257,7 +257,7 @@ func (s *APIV1Service) GetUserWebhookSigningSecret(ctx context.Context, request } userID := user.ID - if _, err := s.authorizeUserResourceAccess(ctx, userID, true); err != nil { + if _, err := s.authorizeUserResourceAccess(ctx, userID, false); err != nil { return nil, err } diff --git a/server/router/api/v1/user_webhook_test.go b/server/router/api/v1/user_webhook_test.go index 0f59116b..7586b579 100644 --- a/server/router/api/v1/user_webhook_test.go +++ b/server/router/api/v1/user_webhook_test.go @@ -42,7 +42,7 @@ func TestUserWebhookSigningSecretLifecycle(t *testing.T) { ctx := context.Background() // First user initializes the store as host/admin; the test actors are regular users. - _, err := svc.Store.CreateUser(ctx, &store.User{Username: "host", Role: store.RoleAdmin, Email: "host@example.com"}) + host, err := svc.Store.CreateUser(ctx, &store.User{Username: "host", Role: store.RoleAdmin, Email: "host@example.com"}) require.NoError(t, err) owner, err := svc.Store.CreateUser(ctx, &store.User{Username: "owner", Role: store.RoleUser, Email: "owner@example.com"}) require.NoError(t, err) @@ -51,6 +51,7 @@ func TestUserWebhookSigningSecretLifecycle(t *testing.T) { ownerCtx := userCtx(ctx, owner.ID) otherCtx := userCtx(ctx, other.ID) + hostCtx := userCtx(ctx, host.ID) // Create without supplying a secret -> the server generates one. created, err := svc.CreateUserWebhook(ownerCtx, &v1pb.CreateUserWebhookRequest{ @@ -70,4 +71,20 @@ func TestUserWebhookSigningSecretLifecycle(t *testing.T) { _, err = svc.GetUserWebhookSigningSecret(otherCtx, &v1pb.GetUserWebhookSigningSecretRequest{Name: created.Name}) require.Error(t, err) require.Equal(t, codes.PermissionDenied, status.Code(err), "non-owner must be denied") + + // Application administration is a control-plane role, not an implicit way + // to install an exfiltration endpoint or reveal another user's webhook secret. + _, err = svc.ListUserWebhooks(hostCtx, &v1pb.ListUserWebhooksRequest{Parent: "users/owner"}) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + _, err = svc.CreateUserWebhook(hostCtx, &v1pb.CreateUserWebhookRequest{ + Parent: "users/owner", + Webhook: &v1pb.UserWebhook{DisplayName: "admin-installed", Url: "https://example.com/exfiltrate"}, + }) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + _, err = svc.UpdateUserWebhook(hostCtx, &v1pb.UpdateUserWebhookRequest{Webhook: &v1pb.UserWebhook{Name: created.Name}}) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + _, err = svc.DeleteUserWebhook(hostCtx, &v1pb.DeleteUserWebhookRequest{Name: created.Name}) + require.Equal(t, codes.PermissionDenied, status.Code(err)) + _, err = svc.GetUserWebhookSigningSecret(hostCtx, &v1pb.GetUserWebhookSigningSecretRequest{Name: created.Name}) + require.Equal(t, codes.PermissionDenied, status.Code(err)) } diff --git a/server/router/api/v1/v1.go b/server/router/api/v1/v1.go index 94389a15..47178ea9 100644 --- a/server/router/api/v1/v1.go +++ b/server/router/api/v1/v1.go @@ -30,6 +30,7 @@ type APIV1Service struct { v1pb.UnimplementedAuthServiceServer v1pb.UnimplementedUserServiceServer v1pb.UnimplementedMemoServiceServer + v1pb.UnimplementedSpaceServiceServer v1pb.UnimplementedAttachmentServiceServer v1pb.UnimplementedAIServiceServer v1pb.UnimplementedMemoViewServiceServer @@ -108,6 +109,10 @@ func (s *APIV1Service) RegisterGateway(ctx context.Context, echoServer *echo.Ech gatewayAuthMiddleware := func(next runtime.HandlerFunc) runtime.HandlerFunc { return func(w http.ResponseWriter, r *http.Request, pathParams map[string]string) { + // grpc-gateway does not pass through the Connect metadata interceptor. + // Apply the same no-store policy here so a memo that later loses access + // cannot remain readable from a browser or intermediary response cache. + setAPIResponseNoStoreHeaders(w.Header()) ctx := r.Context() authHeader := r.Header.Get("Authorization") @@ -149,6 +154,9 @@ func (s *APIV1Service) RegisterGateway(ctx context.Context, echoServer *echo.Ech if err := v1pb.RegisterMemoServiceHandlerServer(ctx, gwMux, s); err != nil { return err } + if err := v1pb.RegisterSpaceServiceHandlerServer(ctx, gwMux, s); err != nil { + return err + } if err := v1pb.RegisterAttachmentServiceHandlerServer(ctx, gwMux, s); err != nil { return err } @@ -187,6 +195,12 @@ func (s *APIV1Service) RegisterGateway(ctx context.Context, echoServer *echo.Ech return nil } +func setAPIResponseNoStoreHeaders(header http.Header) { + header.Set("Cache-Control", "no-cache, no-store, must-revalidate") + header.Set("Pragma", "no-cache") + header.Set("Expires", "0") +} + func writeGatewayAuthorizationError(w http.ResponseWriter, err error) { if errors.Is(err, ErrUnauthenticated) { http.Error(w, `{"code": 16, "message": "authentication required"}`, http.StatusUnauthorized) diff --git a/server/router/fileserver/fileserver.go b/server/router/fileserver/fileserver.go index 7e972791..da3e8c18 100644 --- a/server/router/fileserver/fileserver.go +++ b/server/router/fileserver/fileserver.go @@ -607,7 +607,7 @@ func (s *FileServerService) checkAttachmentPermission(ctx context.Context, c *ec if user == nil { return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusUnauthorized, "unauthorized access") } - if user.ID != attachment.CreatorID && user.Role != store.RoleAdmin { + if user.ID != attachment.CreatorID { return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusForbidden, "forbidden access") } return access.MemoReadClassPrivate, nil @@ -621,25 +621,10 @@ func (s *FileServerService) checkAttachmentPermission(ctx context.Context, c *ec return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusNotFound, "memo not found") } - var parent *store.Memo - if memo.ParentUID != nil { - parent, err = s.Store.GetMemo(ctx, &store.FindMemo{UID: memo.ParentUID}) - if err != nil { - return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to find parent memo").Wrap(err) - } - if parent == nil { - return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusNotFound, "memo not found") - } - } - allowAnonymous, err := s.Store.AllowsAnonymousAccess(ctx) if err != nil { return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to get instance access policy").Wrap(err) } - if decision := access.CheckMemoRead(memo, parent, nil, allowAnonymous, nil); decision.Allowed() { - return decision.Class, nil - } - var sharedMemoID *int32 if shareToken := (*c).QueryParam("share_token"); shareToken != "" { ms, err := s.Store.GetMemoShare(ctx, &store.FindMemoShare{UID: &shareToken}) @@ -648,17 +633,33 @@ func (s *FileServerService) checkAttachmentPermission(ctx context.Context, c *ec } if ms != nil && !isMemoShareExpired(ms) { sharedMemoID = &ms.MemoID - if decision := access.CheckMemoRead(memo, parent, nil, allowAnonymous, sharedMemoID); decision.Allowed() { - return decision.Class, nil - } } } + facts, err := access.ResolveMemoReadFacts(ctx, s.Store, memo) + if err != nil { + return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to resolve memo access").Wrap(err) + } + // Public and exact share-token reads do not depend on browser credentials. + // Decide those first so an expired cookie cannot turn an otherwise valid + // anonymous file request into a server error. + anonymousContext, err := facts.WithViewer(ctx, s.Store, nil, allowAnonymous, sharedMemoID) + if err != nil { + return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to resolve memo access").Wrap(err) + } + if anonymousDecision := access.CheckMemoReadContext(anonymousContext); anonymousDecision.Allowed() { + return anonymousDecision.Class, nil + } + user, err := s.getCurrentUser(ctx, c) if err != nil { return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to get current user").Wrap(err) } - decision := access.CheckMemoRead(memo, parent, user, allowAnonymous, sharedMemoID) + readContext, err := facts.WithViewer(ctx, s.Store, user, allowAnonymous, sharedMemoID) + if err != nil { + return access.MemoReadClassPrivate, echo.NewHTTPError(http.StatusInternalServerError, "failed to find space membership").Wrap(err) + } + decision := access.CheckMemoReadContext(readContext) switch decision.Denial { case access.MemoReadDenialNone: return decision.Class, nil diff --git a/server/router/fileserver/fileserver_test.go b/server/router/fileserver/fileserver_test.go index 5730cd7d..94e1dc5d 100644 --- a/server/router/fileserver/fileserver_test.go +++ b/server/router/fileserver/fileserver_test.go @@ -314,7 +314,48 @@ func TestServeAttachmentFile_CanonicalRouteAndVisibilityAwareCache(t *testing.T) require.Equal(t, privateAttachmentCacheControl, rec.Header().Get(echo.HeaderCacheControl)) } -func TestServeAttachmentFile_CommentFollowsCurrentParentVisibility(t *testing.T) { +func TestServeAttachmentFileMemoCreatorLifecycle(t *testing.T) { + ctx := context.Background() + svc, fs, stores, cleanup := newShareAttachmentTestServices(ctx, t) + defer cleanup() + + creator, err := stores.CreateUser(ctx, &store.User{ + Username: "file-memo-creator-lifecycle", Role: store.RoleUser, Email: "file-creator@example.com", + }) + require.NoError(t, err) + creatorCtx := context.WithValue(ctx, auth.UserIDContextKey, creator.ID) + attachment, err := svc.CreateAttachment(creatorCtx, &apiv1.CreateAttachmentRequest{Attachment: &apiv1.Attachment{ + Filename: "creator-lifecycle.txt", Type: "text/plain", Content: []byte("creator lifecycle"), + }}) + require.NoError(t, err) + memo, err := svc.CreateMemo(creatorCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{ + Content: "public file", Visibility: apiv1.Visibility_PUBLIC, Attachments: []*apiv1.Attachment{{Name: attachment.Name}}, + }}) + require.NoError(t, err) + + e := echo.New() + fs.RegisterRoutes(e) + url := fmt.Sprintf("/file/%s/%s", attachment.Name, attachment.Filename) + archived := store.Archived + _, err = stores.UpdateUser(ctx, &store.UpdateUser{ID: creator.ID, RowStatus: &archived}) + require.NoError(t, err) + recorder := httptest.NewRecorder() + e.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, url, nil)) + require.Equal(t, http.StatusOK, recorder.Code, "an archived creator does not invalidate the memo's PUBLIC audience") + + memoUID := strings.TrimPrefix(memo.Name, "memos/") + storedMemo, err := stores.GetMemo(ctx, &store.FindMemo{UID: &memoUID}) + require.NoError(t, err) + require.NotNil(t, storedMemo) + _, err = stores.GetDriver().GetDB().ExecContext(ctx, + fmt.Sprintf("UPDATE memo SET creator_id = 2147483000 WHERE id = %d", storedMemo.ID)) + require.NoError(t, err) + recorder = httptest.NewRecorder() + e.ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, url, nil)) + require.Equal(t, http.StatusNotFound, recorder.Code, "a dangling memo creator must fail closed for files") +} + +func TestServeAttachmentFile_CommentUsesOwnVisibility(t *testing.T) { ctx := context.Background() svc, fs, _, cleanup := newShareAttachmentTestServices(ctx, t) defer cleanup() @@ -333,10 +374,11 @@ func TestServeAttachmentFile_CommentFollowsCurrentParentVisibility(t *testing.T) Content: []byte("comment image"), }}) require.NoError(t, err) - _, err = svc.CreateMemoComment(commenterCtx, &apiv1.CreateMemoCommentRequest{ + comment, err := svc.CreateMemoComment(commenterCtx, &apiv1.CreateMemoCommentRequest{ Name: parent.Name, Comment: &apiv1.Memo{ Content: "comment", + Visibility: apiv1.Visibility_PUBLIC, Attachments: []*apiv1.Attachment{{Name: attachment.Name}}, }, }) @@ -356,6 +398,16 @@ func TestServeAttachmentFile_CommentFollowsCurrentParentVisibility(t *testing.T) require.NoError(t, err) rec = httptest.NewRecorder() e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil)) + require.Equal(t, http.StatusOK, rec.Code, "changing the context memo must not change attachment access") + require.Equal(t, publicAttachmentCacheControl, rec.Header().Get(echo.HeaderCacheControl)) + + _, err = svc.UpdateMemo(commenterCtx, &apiv1.UpdateMemoRequest{ + Memo: &apiv1.Memo{Name: comment.Name, Visibility: apiv1.Visibility_PROTECTED}, + UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"visibility"}}, + }) + require.NoError(t, err) + rec = httptest.NewRecorder() + e.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, url, nil)) require.Equal(t, http.StatusUnauthorized, rec.Code) require.Equal(t, privateAttachmentCacheControl, rec.Header().Get(echo.HeaderCacheControl)) } diff --git a/server/router/frontend/frontend.go b/server/router/frontend/frontend.go index 98e7ac74..e8769f5f 100644 --- a/server/router/frontend/frontend.go +++ b/server/router/frontend/frontend.go @@ -152,12 +152,19 @@ func (s *FrontendService) getSitemapXML(c *echo.Context) error { return err } + normal := store.Normal memos, err := s.Store.ListMemos(c.Request().Context(), &store.FindMemo{ - VisibilityList: []store.Visibility{store.Public}, + RowStatus: &normal, + VisibilityList: []store.Visibility{store.Public}, + Access: &store.MemoAccessScope{AllowPublic: true}, + ExcludeComments: true, }) if err != nil { return errors.Wrap(err, "failed to list public memos for sitemap") } + // The set of public memo URLs changes with audience updates. Require + // revalidation so a revoked URL is not retained by an intermediary cache. + c.Response().Header().Set(echo.HeaderCacheControl, "public, no-cache") urls := make([]sitemapURL, 0, len(memos)) for _, memo := range memos { diff --git a/server/router/frontend/frontend_test.go b/server/router/frontend/frontend_test.go index 0c110d6c..593a1168 100644 --- a/server/router/frontend/frontend_test.go +++ b/server/router/frontend/frontend_test.go @@ -215,6 +215,7 @@ func TestFrontendService_SitemapXML(t *testing.T) { require.Equal(t, http.StatusOK, rec.Code) require.Contains(t, rec.Header().Get("Content-Type"), "application/xml") + require.Equal(t, "public, no-cache", rec.Header().Get(echo.HeaderCacheControl)) require.Contains(t, rec.Body.String(), `https://demo.usememos.com/memos/publicmemo`) require.NotContains(t, rec.Body.String(), "privatememo") } diff --git a/server/router/rss/rss.go b/server/router/rss/rss.go index 88602c57..3784cd1f 100644 --- a/server/router/rss/rss.go +++ b/server/router/rss/rss.go @@ -8,7 +8,6 @@ import ( "regexp" "strconv" "strings" - "sync" "time" "github.com/gorilla/feeds" @@ -20,9 +19,7 @@ import ( ) const ( - maxRSSItemCount = 100 - defaultCacheDuration = 1 * time.Hour - maxCacheSize = 50 // Maximum number of cached feeds + maxRSSItemCount = 100 ) var ( @@ -30,21 +27,9 @@ var ( markdownHeadingRegex = regexp.MustCompile(`^#{1,6}\s*`) ) -// cacheEntry represents a cached RSS feed with expiration. -type cacheEntry struct { - content string - etag string - lastModified time.Time - createdAt time.Time -} - type RSSService struct { Store *store.Store MarkdownService markdown.Service - - // Cache for RSS feeds - cache map[string]*cacheEntry - cacheMutex sync.RWMutex } type RSSHeading struct { @@ -58,7 +43,6 @@ func NewRSSService(store *store.Store, markdownService markdown.Service) *RSSSer return &RSSService{ Store: store, MarkdownService: markdownService, - cache: make(map[string]*cacheEntry), } } @@ -77,23 +61,12 @@ func (s *RSSService) GetExploreRSS(c *echo.Context) error { return echo.NewHTTPError(http.StatusNotFound, "RSS is unavailable") } - cacheKey := "explore" - - // Check cache first - if cached := s.getFromCache(cacheKey); cached != nil { - // Check ETag for conditional request - if c.Request().Header.Get("If-None-Match") == cached.etag { - return c.NoContent(http.StatusNotModified) - } - s.setRSSHeaders(c, cached.etag, cached.lastModified) - return c.String(http.StatusOK, cached.content) - } - normalStatus := store.Normal limit := maxRSSItemCount memoFind := store.FindMemo{ RowStatus: &normalStatus, VisibilityList: []store.Visibility{store.Public}, + Access: &store.MemoAccessScope{AllowPublic: true}, ExcludeComments: true, Limit: &limit, } @@ -108,9 +81,11 @@ func (s *RSSService) GetExploreRSS(c *echo.Context) error { return echo.NewHTTPError(http.StatusInternalServerError, "Failed to generate rss").Wrap(err) } - // Cache the result - etag := s.putInCache(cacheKey, rss, lastModified) + etag := rssETag(rss) s.setRSSHeaders(c, etag, lastModified) + if c.Request().Header.Get("If-None-Match") == etag { + return c.NoContent(http.StatusNotModified) + } return c.String(http.StatusOK, rss) } @@ -125,18 +100,6 @@ func (s *RSSService) GetUserRSS(c *echo.Context) error { } username := c.Param("username") - cacheKey := "user:" + username - - // Check cache first - if cached := s.getFromCache(cacheKey); cached != nil { - // Check ETag for conditional request - if c.Request().Header.Get("If-None-Match") == cached.etag { - return c.NoContent(http.StatusNotModified) - } - s.setRSSHeaders(c, cached.etag, cached.lastModified) - return c.String(http.StatusOK, cached.content) - } - user, err := s.Store.GetUser(ctx, &store.FindUser{ Username: &username, }) @@ -153,6 +116,7 @@ func (s *RSSService) GetUserRSS(c *echo.Context) error { CreatorID: &user.ID, RowStatus: &normalStatus, VisibilityList: []store.Visibility{store.Public}, + Access: &store.MemoAccessScope{AllowPublic: true}, ExcludeComments: true, Limit: &limit, } @@ -167,9 +131,11 @@ func (s *RSSService) GetUserRSS(c *echo.Context) error { return echo.NewHTTPError(http.StatusInternalServerError, "Failed to generate rss").Wrap(err) } - // Cache the result - etag := s.putInCache(cacheKey, rss, lastModified) + etag := rssETag(rss) s.setRSSHeaders(c, etag, lastModified) + if c.Request().Header.Get("If-None-Match") == etag { + return c.NoContent(http.StatusNotModified) + } return c.String(http.StatusOK, rss) } @@ -179,26 +145,29 @@ func (s *RSSService) generateRSSFromMemoList(ctx context.Context, memoList []*st return "", time.Time{}, err } + itemCountLimit := min(len(memoList), maxRSSItemCount) + // Derive channel timestamps only from feed data. Using the request time here + // changes an otherwise identical body and defeats ETag revalidation. + var lastModified time.Time + for _, memo := range memoList[:itemCountLimit] { + if updated := time.Unix(memo.UpdatedTs, 0); updated.After(lastModified) { + lastModified = updated + } + } feed := &feeds.Feed{ Title: rssHeading.Title, Link: &feeds.Link{Href: baseURL}, Description: rssHeading.Description, - Created: time.Now(), + Created: lastModified, + Updated: lastModified, } - var itemCountLimit = min(len(memoList), maxRSSItemCount) if itemCountLimit == 0 { // Return empty feed if no memos rss, err := feed.ToRss() return rss, time.Time{}, err } - // Track the most recent update time for Last-Modified header - var lastModified time.Time - if len(memoList) > 0 { - lastModified = time.Unix(memoList[0].UpdatedTs, 0) - } - // Batch load all attachments for all memos to avoid N+1 query problem memoIDs := make([]int32, itemCountLimit) for i := 0; i < itemCountLimit; i++ { @@ -357,66 +326,17 @@ func (s *RSSService) getRSSItemDescription(content string) (string, error) { return html, nil } -// getFromCache retrieves a cached feed entry if it exists and is not expired. -func (s *RSSService) getFromCache(key string) *cacheEntry { - s.cacheMutex.RLock() - entry, exists := s.cache[key] - s.cacheMutex.RUnlock() - - if !exists { - return nil - } - - // Check if cache entry is still valid - if time.Since(entry.createdAt) > defaultCacheDuration { - // Entry is expired, remove it - s.cacheMutex.Lock() - delete(s.cache, key) - s.cacheMutex.Unlock() - return nil - } - - return entry -} - -// putInCache stores a feed in the cache and returns its ETag. -func (s *RSSService) putInCache(key, content string, lastModified time.Time) string { - s.cacheMutex.Lock() - defer s.cacheMutex.Unlock() - - // Generate ETag from content hash +func rssETag(content string) string { hash := sha256.Sum256([]byte(content)) - etag := fmt.Sprintf(`"%x"`, hash[:8]) - - // Implement simple LRU: if cache is too large, remove oldest entries - if len(s.cache) >= maxCacheSize { - var oldestKey string - var oldestTime time.Time - for k, v := range s.cache { - if oldestKey == "" || v.createdAt.Before(oldestTime) { - oldestKey = k - oldestTime = v.createdAt - } - } - if oldestKey != "" { - delete(s.cache, oldestKey) - } - } - - s.cache[key] = &cacheEntry{ - content: content, - etag: etag, - lastModified: lastModified, - createdAt: time.Now(), - } - - return etag + return fmt.Sprintf(`"%x"`, hash[:8]) } // setRSSHeaders sets appropriate HTTP headers for RSS responses. func (*RSSService) setRSSHeaders(c *echo.Context, etag string, lastModified time.Time) { c.Response().Header().Set(echo.HeaderContentType, "application/rss+xml; charset=utf-8") - c.Response().Header().Set(echo.HeaderCacheControl, fmt.Sprintf("public, max-age=%d", int(defaultCacheDuration.Seconds()))) + // Revalidation is mandatory because an audience change must not leave a + // previously PUBLIC memo readable from a stale feed body. + c.Response().Header().Set(echo.HeaderCacheControl, "public, no-cache") c.Response().Header().Set("ETag", etag) if !lastModified.IsZero() { c.Response().Header().Set("Last-Modified", lastModified.UTC().Format(http.TimeFormat)) diff --git a/server/router/rss/rss_test.go b/server/router/rss/rss_test.go index 6b060f12..887990f5 100644 --- a/server/router/rss/rss_test.go +++ b/server/router/rss/rss_test.go @@ -6,6 +6,7 @@ import ( "net/http/httptest" "strings" "testing" + "time" "github.com/labstack/echo/v5" "github.com/stretchr/testify/require" @@ -37,19 +38,12 @@ func TestPublicRSSExcludesComments(t *testing.T) { }) require.NoError(t, err) - comment, err := stores.CreateMemo(ctx, &store.Memo{ + _, err = stores.CreateMemoComment(ctx, &store.Memo{ UID: "rss-public-comment", CreatorID: user.ID, Content: "public comment should not be in rss", - Visibility: store.Public, - }) - require.NoError(t, err) - - _, err = stores.UpsertMemoRelation(ctx, &store.MemoRelation{ - MemoID: comment.ID, - RelatedMemoID: parent.ID, - Type: store.MemoRelationComment, - }) + Visibility: store.Private, + }, parent.ID, user.ID) require.NoError(t, err) service := NewRSSService(stores, markdown.NewService()) @@ -101,6 +95,47 @@ func TestPrivateInstanceDisablesRSS(t *testing.T) { } } +func TestRSSIfNoneMatchRemainsStableAcrossSeconds(t *testing.T) { + ctx := context.Background() + stores := teststore.NewTestingStore(ctx, t) + defer stores.Close() + setInstanceAccessMode(ctx, t, stores, storepb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PUBLIC) + + user, err := stores.CreateUser(ctx, &store.User{ + Username: "rss-etag-owner", + Role: store.RoleUser, + Email: "rss-etag-owner@example.com", + }) + require.NoError(t, err) + _, err = stores.CreateMemo(ctx, &store.Memo{ + UID: "rss-etag-stable", + CreatorID: user.ID, + Content: "stable feed content", + Visibility: store.Public, + }) + require.NoError(t, err) + + service := NewRSSService(stores, markdown.NewService()) + explore := requestRSS(t, service, "/explore/rss.xml", "", "") + userFeed := requestRSS(t, service, "/u/rss-etag-owner/rss.xml", user.Username, "") + require.Equal(t, http.StatusOK, explore.Code) + require.Equal(t, http.StatusOK, userFeed.Code) + exploreETag := explore.Header().Get("ETag") + userETag := userFeed.Header().Get("ETag") + require.NotEmpty(t, exploreETag) + require.NotEmpty(t, userETag) + + // The previous request-time channel timestamp changed once per second even + // when no feed data changed, causing these conditional reads to return 200. + time.Sleep(1100 * time.Millisecond) + explore = requestRSS(t, service, "/explore/rss.xml", "", exploreETag) + userFeed = requestRSS(t, service, "/u/rss-etag-owner/rss.xml", user.Username, userETag) + require.Equal(t, http.StatusNotModified, explore.Code) + require.Equal(t, http.StatusNotModified, userFeed.Code) + require.Equal(t, exploreETag, explore.Header().Get("ETag")) + require.Equal(t, userETag, userFeed.Header().Get("ETag")) +} + func setInstanceAccessMode(ctx context.Context, t *testing.T, stores *store.Store, mode storepb.InstanceAccessMode) { t.Helper() _, err := stores.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{ @@ -114,10 +149,20 @@ func setInstanceAccessMode(ctx context.Context, t *testing.T, stores *store.Stor func renderRSS(t *testing.T, service *RSSService, target string, username string) string { t.Helper() + rec := requestRSS(t, service, target, username, "") + require.Equal(t, http.StatusOK, rec.Code) + return rec.Body.String() +} + +func requestRSS(t *testing.T, service *RSSService, target, username, ifNoneMatch string) *httptest.ResponseRecorder { + t.Helper() e := echo.New() req := httptest.NewRequest(http.MethodGet, target, strings.NewReader("")) req.Host = "example.com" + if ifNoneMatch != "" { + req.Header.Set("If-None-Match", ifNoneMatch) + } rec := httptest.NewRecorder() c := e.NewContext(req, rec) if username != "" { @@ -131,6 +176,5 @@ func renderRSS(t *testing.T, service *RSSService, target string, username string err = service.GetUserRSS(c) } require.NoError(t, err) - require.Equal(t, http.StatusOK, rec.Code) - return rec.Body.String() + return rec } diff --git a/store/attachment.go b/store/attachment.go index 1be6c3d8..18213753 100644 --- a/store/attachment.go +++ b/store/attachment.go @@ -35,22 +35,29 @@ type Attachment struct { // The related memo ID. MemoID *int32 + // Policy is present for transport-facing direct-link mutations. Drivers + // revalidate it in the same transaction as the attachment insert. + Policy *MemoWritePolicy // Composed field MemoUID *string } type FindAttachment struct { - GetBlob bool - ID *int32 - UID *string - CreatorID *int32 - Filename *string - FilenameSearch *string - MemoID *int32 - MemoIDList []int32 - HasRelatedMemo bool - Filters []string + GetBlob bool + ID *int32 + UID *string + CreatorID *int32 + Filename *string + FilenameSearch *string + MemoID *int32 + MemoIDList []int32 + HasRelatedMemo bool + Filters []string + // Access applies memo-local authorization to linked attachments + // before pagination. Unlinked attachments are visible only to the active + // matching creator. Nil is reserved for trusted internal callers. + Access *MemoAccessScope Limit *int Offset *int SkipDefaultLimit bool @@ -63,6 +70,10 @@ type UpdateAttachment struct { Filename *string MemoID *int32 Payload *storepb.AttachmentPayload + // Policy is present for transport-facing updates. Drivers discover the + // current attachment binding and authorize any linked memo in the same + // transaction as the update. + Policy *MemoWritePolicy } type DeleteAttachment struct { @@ -76,20 +87,62 @@ const ( ) type deleteAttachmentStorageFailpointKey struct{} +type createAttachmentPolicyFailpointKey struct{} +type createAttachmentPostCommitFailpointKey struct{} // ErrDeleteAttachmentStorageFailpoint is returned by the test-only attachment storage failpoint. var ErrDeleteAttachmentStorageFailpoint = errors.New("delete attachment storage failpoint") +// ErrCreateAttachmentPostCommitFailpoint is returned after the test-only attachment create failpoint persists a row. +var ErrCreateAttachmentPostCommitFailpoint = errors.New("create attachment post-commit failpoint") + // WithDeleteAttachmentStorageFailpoint forces DeleteAttachmentStorage to return a failpoint error. func WithDeleteAttachmentStorageFailpoint(ctx context.Context) context.Context { return context.WithValue(ctx, deleteAttachmentStorageFailpointKey{}, true) } +// WithCreateAttachmentPolicyFailpoint forces a policy-bearing attachment create to fail before its database insert. +func WithCreateAttachmentPolicyFailpoint(ctx context.Context) context.Context { + return context.WithValue(ctx, createAttachmentPolicyFailpointKey{}, true) +} + +// WithCreateAttachmentPostCommitFailpoint forces CreateAttachment to return an error after its database insert succeeds. +func WithCreateAttachmentPostCommitFailpoint(ctx context.Context) context.Context { + return context.WithValue(ctx, createAttachmentPostCommitFailpointKey{}, true) +} + func (s *Store) CreateAttachment(ctx context.Context, create *Attachment) (*Attachment, error) { if !base.UIDMatcher.MatchString(create.UID) { return nil, errors.New("invalid uid") } - return s.driver.CreateAttachment(ctx, create) + if err := validateMemoWritePolicy(create.Policy); err != nil { + return nil, err + } + var ( + attachment *Attachment + err error + ) + if create.Policy != nil { + if create.MemoID == nil { + return nil, errors.New("attachment write policy requires a memo") + } + if create.CreatorID != create.Policy.ActorUserID { + return nil, ErrMemoPermissionDenied + } + if shouldFailCreateAttachmentPolicy(ctx) { + return nil, ErrMemoSpaceMembershipRequired + } + attachment, err = s.driver.CreateAttachment(ctx, create) + } else { + attachment, err = s.driver.CreateAttachment(ctx, create) + } + if err != nil { + return nil, err + } + if shouldFailCreateAttachmentPostCommit(ctx) { + return nil, ErrCreateAttachmentPostCommitFailpoint + } + return attachment, nil } func (s *Store) ListAttachments(ctx context.Context, find *FindAttachment) ([]*Attachment, error) { @@ -125,6 +178,15 @@ func (s *Store) UpdateAttachment(ctx context.Context, update *UpdateAttachment) if update.UID != nil && !base.UIDMatcher.MatchString(*update.UID) { return errors.New("invalid uid") } + if err := validateMemoWritePolicy(update.Policy); err != nil { + return err + } + if update.Policy != nil { + if update.MemoID != nil { + return errors.New("policy-bearing attachment updates cannot change memo binding") + } + return s.driver.UpdateAttachment(ctx, update) + } return s.driver.UpdateAttachment(ctx, update) } @@ -166,7 +228,10 @@ func (s *Store) DeleteAttachments(ctx context.Context, attachments []*Attachment if err := s.driver.DeleteAttachments(ctx, deletes); err != nil { return err } + return s.deleteAttachmentStorageSnapshots(ctx, attachments) +} +func (s *Store) deleteAttachmentStorageSnapshots(ctx context.Context, attachments []*Attachment) error { instanceStorageSetting, instanceStorageSettingErr := s.getAttachmentStorageCleanupInstanceSetting(ctx, attachments) for _, attachment := range attachments { if attachment == nil { @@ -185,7 +250,6 @@ func (s *Store) DeleteAttachments(ctx context.Context, attachments []*Attachment slog.Warn("Failed to delete attachment storage", slog.Any("err", err)) } } - return nil } @@ -332,3 +396,13 @@ func shouldFailDeleteAttachmentStorage(ctx context.Context) bool { failpoint, ok := ctx.Value(deleteAttachmentStorageFailpointKey{}).(bool) return ok && failpoint } + +func shouldFailCreateAttachmentPolicy(ctx context.Context) bool { + failpoint, ok := ctx.Value(createAttachmentPolicyFailpointKey{}).(bool) + return ok && failpoint +} + +func shouldFailCreateAttachmentPostCommit(ctx context.Context) bool { + failpoint, ok := ctx.Value(createAttachmentPostCommitFailpointKey{}).(bool) + return ok && failpoint +} diff --git a/store/attachment_delete.go b/store/attachment_delete.go new file mode 100644 index 00000000..2b5888d9 --- /dev/null +++ b/store/attachment_delete.go @@ -0,0 +1,113 @@ +package store + +import ( + "context" + "maps" + "slices" + + "github.com/pkg/errors" +) + +// AttachmentDeletionPolicy captures the caller and the memo content observed +// while validating a transport-facing attachment deletion. Drivers compare the +// snapshots with current memo state in the deletion transaction. +type AttachmentDeletionPolicy struct { + ActorUserID int32 + ExpectedMemoContents map[int32]string +} + +// DeleteAttachmentsWithPolicy atomically authorizes and removes the selected +// attachment rows. External object cleanup remains the caller's responsibility +// after the transaction commits. +func (s *Store) DeleteAttachmentsWithPolicy(ctx context.Context, policy *AttachmentDeletionPolicy, attachmentIDs []int32) error { + normalizedPolicy, normalizedIDs, err := normalizeAttachmentDelete(policy, attachmentIDs) + if err != nil { + return err + } + return s.driver.DeleteAttachmentsWithPolicy(ctx, normalizedPolicy, normalizedIDs) +} + +func normalizeAttachmentDelete(policy *AttachmentDeletionPolicy, attachmentIDs []int32) (*AttachmentDeletionPolicy, []int32, error) { + if policy == nil || policy.ActorUserID <= 0 || len(attachmentIDs) == 0 { + return nil, nil, errors.New("attachment deletion requires policy and attachment IDs") + } + ids := slices.Clone(attachmentIDs) + slices.Sort(ids) + for index, id := range ids { + if id <= 0 { + return nil, nil, errors.New("attachment deletion IDs must be positive") + } + if index > 0 && ids[index-1] == id { + return nil, nil, errors.New("duplicate attachment deletion ID") + } + } + expectedMemoContents := maps.Clone(policy.ExpectedMemoContents) + for memoID := range expectedMemoContents { + if memoID <= 0 { + return nil, nil, errors.New("attachment deletion memo IDs must be positive") + } + } + return &AttachmentDeletionPolicy{ + ActorUserID: policy.ActorUserID, + ExpectedMemoContents: expectedMemoContents, + }, ids, nil +} + +// ValidateAttachmentDeletionMemoSnapshots requires exactly one expected +// content snapshot for every memo currently bound to the selected attachments. +func ValidateAttachmentDeletionMemoSnapshots(memoIDs []int32, expectedMemoContents map[int32]string) error { + if len(memoIDs) != len(expectedMemoContents) { + return ErrMemoMutationConflict + } + for _, memoID := range memoIDs { + if _, ok := expectedMemoContents[memoID]; !ok { + return ErrMemoMutationConflict + } + } + return nil +} + +// ValidateAttachmentMutationTargets verifies attachment rows used by a +// transport-facing mutation and returns their distinct memo bindings in +// ascending order. +func ValidateAttachmentMutationTargets(actorUserID int32, attachmentIDs []int32, attachments []*Attachment) ([]int32, error) { + if actorUserID <= 0 || len(attachmentIDs) == 0 || len(attachments) != len(attachmentIDs) { + return nil, ErrMemoMutationConflict + } + expectedIDs := make(map[int32]struct{}, len(attachmentIDs)) + for _, id := range attachmentIDs { + if id <= 0 { + return nil, ErrMemoMutationConflict + } + expectedIDs[id] = struct{}{} + } + memoIDs := make(map[int32]struct{}) + seen := make(map[int32]struct{}, len(attachments)) + for _, attachment := range attachments { + if attachment == nil || attachment.ID <= 0 { + return nil, ErrMemoMutationConflict + } + if _, expected := expectedIDs[attachment.ID]; !expected { + return nil, ErrMemoMutationConflict + } + if _, duplicate := seen[attachment.ID]; duplicate { + return nil, ErrMemoMutationConflict + } + seen[attachment.ID] = struct{}{} + if attachment.CreatorID != actorUserID { + return nil, ErrMemoPermissionDenied + } + if attachment.MemoID != nil { + if *attachment.MemoID <= 0 { + return nil, ErrMemoMutationConflict + } + memoIDs[*attachment.MemoID] = struct{}{} + } + } + result := make([]int32, 0, len(memoIDs)) + for memoID := range memoIDs { + result = append(result, memoID) + } + slices.Sort(result) + return result, nil +} diff --git a/store/db/mysql/attachment.go b/store/db/mysql/attachment.go index d0df2a0e..f065eba0 100644 --- a/store/db/mysql/attachment.go +++ b/store/db/mysql/attachment.go @@ -15,6 +15,35 @@ import ( ) func (d *DB) CreateAttachment(ctx context.Context, create *store.Attachment) (*store.Attachment, error) { + if create.Policy == nil { + id, err := insertMySQLAttachment(ctx, d.db, create) + if err != nil { + return nil, err + } + return d.GetAttachment(ctx, &store.FindAttachment{ID: &id}) + } + if create.MemoID == nil || create.CreatorID != create.Policy.ActorUserID { + return nil, store.ErrMemoPermissionDenied + } + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := validateMySQLMemoWritePolicy(ctx, tx, *create.MemoID, create.Policy, nil); err != nil { + return nil, err + } + id, err := insertMySQLAttachment(ctx, tx, create) + if err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return d.GetAttachment(ctx, &store.FindAttachment{ID: &id}) +} + +func insertMySQLAttachment(ctx context.Context, executor memoUpdateExecer, create *store.Attachment) (int32, error) { fields := []string{"`uid`", "`filename`", "`blob`", "`type`", "`size`", "`creator_id`", "`memo_id`", "`storage_type`", "`reference`", "`payload`"} placeholder := []string{"?", "?", "?", "?", "?", "?", "?", "?", "?", "?"} storageType := "" @@ -25,25 +54,23 @@ func (d *DB) CreateAttachment(ctx context.Context, create *store.Attachment) (*s if create.Payload != nil { bytes, err := protojson.Marshal(create.Payload) if err != nil { - return nil, errors.Wrap(err, "failed to marshal attachment payload") + return 0, errors.Wrap(err, "failed to marshal attachment payload") } payloadString = string(bytes) } args := []any{create.UID, create.Filename, create.Blob, create.Type, create.Size, create.CreatorID, create.MemoID, storageType, create.Reference, payloadString} stmt := "INSERT INTO `attachment` (" + strings.Join(fields, ", ") + ") VALUES (" + strings.Join(placeholder, ", ") + ")" - result, err := d.db.ExecContext(ctx, stmt, args...) + result, err := executor.ExecContext(ctx, stmt, args...) if err != nil { - return nil, err + return 0, err } id, err := result.LastInsertId() if err != nil { - return nil, err + return 0, err } - - id32 := int32(id) - return d.GetAttachment(ctx, &store.FindAttachment{ID: &id32}) + return int32(id), nil } func (d *DB) ListAttachments(ctx context.Context, find *store.FindAttachment) ([]*store.Attachment, error) { @@ -89,6 +116,19 @@ func (d *DB) ListAttachments(ctx context.Context, find *store.FindAttachment) ([ return nil, errors.Wrap(err, "failed to append filter conditions") } } + if access := find.Access; access != nil { + scopeClauses := []string{} + if access.UserID != nil { + scopeClauses = append(scopeClauses, "(`attachment`.`memo_id` IS NULL AND EXISTS (SELECT 1 FROM `user` AS `attachment_user` WHERE `attachment_user`.`id` = ? AND `attachment_user`.`row_status` = 'NORMAL') AND `attachment`.`creator_id` = ?)") + args = append(args, *access.UserID, *access.UserID) + } + scopeClauses = append(scopeClauses, "(`attachment`.`memo_id` IS NOT NULL AND "+mysqlMemoAccessPredicate(access, "`memo`", "`attachment_member`", &args)+")") + if len(scopeClauses) == 0 { + where = append(where, "1 = 0") + } else { + where = append(where, "("+strings.Join(scopeClauses, " OR ")+")") + } + } fields := []string{ "`attachment`.`id` AS `id`", @@ -186,6 +226,36 @@ func (d *DB) GetAttachment(ctx context.Context, find *store.FindAttachment) (*st } func (d *DB) UpdateAttachment(ctx context.Context, update *store.UpdateAttachment) error { + if update.Policy == nil { + return applyMySQLAttachmentUpdate(ctx, d.db, update) + } + if update.MemoID != nil { + return store.ErrMemoMutationConflict + } + attachmentIDs := []int32{update.ID} + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer func() { _ = tx.Rollback() }() + attachments, err := listMySQLAttachmentsByIDs(ctx, tx, attachmentIDs) + if err != nil { + return err + } + memoIDs, err := store.ValidateAttachmentMutationTargets(update.Policy.ActorUserID, attachmentIDs, attachments) + if err != nil { + return err + } + if err := authorizeMySQLAttachmentMutation(ctx, tx, update.Policy.ActorUserID, memoIDs, nil); err != nil { + return err + } + if err := applyMySQLAttachmentUpdate(ctx, tx, update); err != nil { + return err + } + return tx.Commit() +} + +func applyMySQLAttachmentUpdate(ctx context.Context, executor memoUpdateExecer, update *store.UpdateAttachment) error { set, args := []string{}, []any{} if v := update.UID; v != nil { @@ -208,9 +278,12 @@ func (d *DB) UpdateAttachment(ctx context.Context, update *store.UpdateAttachmen set, args = append(set, "`payload` = ?"), append(args, string(bytes)) } + if len(set) == 0 { + return nil + } args = append(args, update.ID) stmt := "UPDATE `attachment` SET " + strings.Join(set, ", ") + " WHERE `id` = ?" - result, err := d.db.ExecContext(ctx, stmt, args...) + result, err := executor.ExecContext(ctx, stmt, args...) if err != nil { return err } @@ -221,16 +294,7 @@ func (d *DB) UpdateAttachment(ctx context.Context, update *store.UpdateAttachmen } func (d *DB) DeleteAttachment(ctx context.Context, delete *store.DeleteAttachment) error { - stmt := "DELETE FROM `attachment` WHERE `id` = ?" - result, err := d.db.ExecContext(ctx, stmt, delete.ID) - if err != nil { - return err - } - if _, err := result.RowsAffected(); err != nil { - return err - } - - return nil + return d.DeleteAttachments(ctx, []*store.DeleteAttachment{delete}) } func (d *DB) DeleteAttachments(ctx context.Context, deletes []*store.DeleteAttachment) error { @@ -242,14 +306,13 @@ func (d *DB) DeleteAttachments(ctx context.Context, deletes []*store.DeleteAttac if err != nil { return errors.Wrap(err, "failed to start attachment delete transaction") } - defer func() { - if tx != nil { - _ = tx.Rollback() - } - }() + defer func() { _ = tx.Rollback() }() stmt := "DELETE FROM `attachment` WHERE `id` = ?" for _, delete := range deletes { + if delete == nil { + continue + } result, err := tx.ExecContext(ctx, stmt, delete.ID) if err != nil { return err @@ -259,9 +322,18 @@ func (d *DB) DeleteAttachments(ctx context.Context, deletes []*store.DeleteAttac } } - if err := tx.Commit(); err != nil { - return err - } - tx = nil - return nil + return tx.Commit() +} + +func listMySQLAttachmentsByIDs(ctx context.Context, tx *sql.Tx, attachmentIDs []int32) ([]*store.Attachment, error) { + attachments := make([]*store.Attachment, 0, len(attachmentIDs)) + seen := make(map[int32]struct{}, len(attachmentIDs)) + for _, batch := range deleteUserBatches(attachmentIDs, deleteUserBatchSize) { + clause, args := deleteUserInClause(1, batch) + if err := appendDeleteUserAttachments(ctx, tx, `SELECT id, uid, creator_id, memo_id, storage_type, reference, payload + FROM attachment WHERE id IN `+clause+` ORDER BY id`, args, seen, &attachments); err != nil { + return nil, err + } + } + return attachments, nil } diff --git a/store/db/mysql/attachment_delete.go b/store/db/mysql/attachment_delete.go new file mode 100644 index 00000000..5861095d --- /dev/null +++ b/store/db/mysql/attachment_delete.go @@ -0,0 +1,111 @@ +package mysql + +import ( + "context" + "database/sql" + + "github.com/pkg/errors" + + "github.com/usememos/memos/store" +) + +func (d *DB) DeleteAttachmentsWithPolicy(ctx context.Context, policy *store.AttachmentDeletionPolicy, attachmentIDs []int32) error { + if policy == nil || policy.ActorUserID <= 0 { + return store.ErrMemoPermissionDenied + } + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return errors.Wrap(err, "failed to begin attachment delete transaction") + } + defer func() { _ = tx.Rollback() }() + + attachments, err := listMySQLAttachmentsByIDs(ctx, tx, attachmentIDs) + if err != nil { + return errors.Wrap(err, "failed to read attachment delete targets") + } + memoIDs, err := store.ValidateAttachmentMutationTargets(policy.ActorUserID, attachmentIDs, attachments) + if err != nil { + return err + } + if err := store.ValidateAttachmentDeletionMemoSnapshots(memoIDs, policy.ExpectedMemoContents); err != nil { + return err + } + if err := authorizeMySQLAttachmentMutation(ctx, tx, policy.ActorUserID, memoIDs, policy.ExpectedMemoContents); err != nil { + return err + } + + for _, attachmentID := range attachmentIDs { + result, err := tx.ExecContext(ctx, "DELETE FROM attachment WHERE id = ?", attachmentID) + if err != nil { + return errors.Wrap(err, "failed to delete attachment") + } + if rows, err := result.RowsAffected(); err != nil { + return errors.Wrap(err, "failed to count deleted attachment") + } else if rows != 1 { + return store.ErrMemoMutationConflict + } + } + if err := tx.Commit(); err != nil { + return errors.Wrap(err, "failed to commit attachment deletion") + } + return nil +} + +func authorizeMySQLAttachmentMutation( + ctx context.Context, + tx *sql.Tx, + actorUserID int32, + memoIDs []int32, + expectedMemoContents map[int32]string, +) error { + var actorStatus store.RowStatus + if err := tx.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", actorUserID).Scan(&actorStatus); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrMemoPermissionDenied + } + return errors.Wrap(err, "failed to read attachment actor") + } + if actorStatus != store.Normal { + return store.ErrMemoPermissionDenied + } + + policy := &store.MemoWritePolicy{ActorUserID: actorUserID} + for _, memoID := range memoIDs { + snapshot := &store.MemoWriteSnapshot{} + var spaceID sql.NullInt64 + var content string + if err := tx.QueryRowContext(ctx, `SELECT creator_id, row_status, space_id, visibility, content + FROM memo WHERE id = ?`, memoID).Scan( + &snapshot.CreatorID, &snapshot.RowStatus, &spaceID, &snapshot.Visibility, &content, + ); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrMemoMutationConflict + } + return errors.Wrap(err, "failed to read attachment memo") + } + snapshot.SpaceID = store.NullInt32Pointer(spaceID) + if snapshot.SpaceID != nil { + var err error + snapshot.SourceSpaceExists, err = mysqlSpaceExists(ctx, tx, *snapshot.SpaceID) + if err != nil { + return errors.Wrap(err, "failed to read attachment memo space") + } + if snapshot.SourceSpaceExists { + snapshot.SourceMemberActive, err = mysqlSpaceMemberActive(ctx, tx, *snapshot.SpaceID, actorUserID) + if err != nil { + return errors.Wrap(err, "failed to read attachment memo membership") + } + } + } + if err := store.ValidateMemoWriteSnapshot(policy, nil, snapshot); err != nil { + return err + } + if expectedMemoContents != nil { + expectedContent, ok := expectedMemoContents[memoID] + if !ok || content != expectedContent { + return store.ErrMemoMutationConflict + } + } + } + return nil +} diff --git a/store/db/mysql/memo.go b/store/db/mysql/memo.go index 8edbe7ff..520d361a 100644 --- a/store/db/mysql/memo.go +++ b/store/db/mysql/memo.go @@ -2,6 +2,7 @@ package mysql import ( "context" + "database/sql" "fmt" "strings" @@ -14,8 +15,27 @@ import ( ) func (d *DB) CreateMemo(ctx context.Context, create *store.Memo) (*store.Memo, error) { - fields := []string{"`uid`", "`creator_id`", "`content`", "`visibility`", "`payload`"} - placeholder := []string{"?", "?", "?", "?", "?"} + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := validateMySQLMemoCreate(ctx, tx, create); err != nil { + return nil, err + } + memo, err := insertMySQLMemo(ctx, tx, create) + if err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return memo, nil +} + +func insertMySQLMemo(ctx context.Context, tx *sql.Tx, create *store.Memo) (*store.Memo, error) { + fields := []string{"`uid`", "`creator_id`", "`content`", "`visibility`", "`payload`", "`space_id`"} + placeholder := []string{"?", "?", "?", "?", "?", "?"} payload := "{}" if create.Payload != nil { payloadBytes, err := protojson.Marshal(create.Payload) @@ -24,7 +44,7 @@ func (d *DB) CreateMemo(ctx context.Context, create *store.Memo) (*store.Memo, e } payload = string(payloadBytes) } - args := []any{create.UID, create.CreatorID, create.Content, create.Visibility, payload} + args := []any{create.UID, create.CreatorID, create.Content, create.Visibility, payload, create.SpaceID} // Add custom timestamps if provided if create.CreatedTs != 0 { @@ -39,7 +59,7 @@ func (d *DB) CreateMemo(ctx context.Context, create *store.Memo) (*store.Memo, e } stmt := "INSERT INTO `memo` (" + strings.Join(fields, ", ") + ") VALUES (" + strings.Join(placeholder, ", ") + ")" - result, err := d.db.ExecContext(ctx, stmt, args...) + result, err := tx.ExecContext(ctx, stmt, args...) if err != nil { return nil, err } @@ -49,16 +69,56 @@ func (d *DB) CreateMemo(ctx context.Context, create *store.Memo) (*store.Memo, e return nil, err } id := int32(rawID) - memo, err := d.GetMemo(ctx, &store.FindMemo{ID: &id}) + memo := &store.Memo{} + var payloadBytes []byte + err = tx.QueryRowContext(ctx, `SELECT id, uid, creator_id, UNIX_TIMESTAMP(created_ts), UNIX_TIMESTAMP(updated_ts), row_status, + content, visibility, pinned, payload, space_id + FROM memo WHERE id = ?`, id).Scan(&memo.ID, &memo.UID, &memo.CreatorID, &memo.CreatedTs, &memo.UpdatedTs, &memo.RowStatus, + &memo.Content, &memo.Visibility, &memo.Pinned, &payloadBytes, &memo.SpaceID) if err != nil { return nil, err } - if memo == nil { - return nil, errors.Errorf("failed to create memo") + memo.Payload = &storepb.MemoPayload{} + if err := protojsonUnmarshaler.Unmarshal(payloadBytes, memo.Payload); err != nil { + return nil, errors.Wrap(err, "failed to unmarshal payload") } return memo, nil } +func validateMySQLMemoCreate(ctx context.Context, tx *sql.Tx, create *store.Memo) error { + var actorStatus store.RowStatus + err := tx.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", create.CreatorID).Scan(&actorStatus) + if errors.Is(err, sql.ErrNoRows) || (err == nil && actorStatus != store.Normal) { + return store.ErrMemoSpaceMembershipRequired + } + if err != nil { + return err + } + if create.SpaceID != nil { + return validateMySQLMemoSpaceMember(ctx, tx, *create.SpaceID, create.CreatorID) + } + return nil +} + +func validateMySQLMemoSpaceMember(ctx context.Context, tx *sql.Tx, spaceID, userID int32) error { + var existingSpaceID int32 + if err := tx.QueryRowContext(ctx, "SELECT id FROM space WHERE id = ?", spaceID).Scan(&existingSpaceID); errors.Is(err, sql.ErrNoRows) { + return store.ErrMemoSpaceNotWritable + } else if err != nil { + return err + } + var exists bool + err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM space_member sm JOIN user u ON u.id = sm.user_id + WHERE sm.space_id = ? AND sm.user_id = ? AND sm.role IN ('ADMIN', 'USER') AND u.row_status = 'NORMAL')`, spaceID, userID).Scan(&exists) + if err != nil { + return err + } + if !exists { + return store.ErrMemoSpaceMembershipRequired + } + return nil +} + func (d *DB) ListMemos(ctx context.Context, find *store.FindMemo) ([]*store.Memo, error) { where, having, args := []string{"1 = 1"}, []string{"1 = 1"}, []any{} @@ -109,8 +169,28 @@ func (d *DB) ListMemos(ctx context.Context, find *store.FindMemo) ([]*store.Memo } where = append(where, fmt.Sprintf("`memo`.`visibility` in (%s)", strings.Join(placeholder, ","))) } + if v := find.SpaceID; v != nil { + where, args = append(where, "`memo`.`space_id` = ?"), append(args, *v) + } + if v := find.CommentContextMemoID; v != nil { + where, args = append(where, `EXISTS ( + SELECT 1 FROM memo_relation AS comment_context + WHERE comment_context.memo_id = memo.id + AND comment_context.related_memo_id = ? + AND comment_context.type = 'COMMENT' + )`), append(args, *v) + } + if find.Unassigned { + where = append(where, "`memo`.`space_id` IS NULL") + } + if access := find.Access; access != nil { + where = append(where, mysqlMemoAccessPredicate(access, "`memo`", "`access_member`", &args)) + } if find.ExcludeComments { - having = append(having, "`parent_uid` IS NULL") + where = append(where, `NOT EXISTS ( + SELECT 1 FROM memo_relation AS comment_relation + WHERE comment_relation.memo_id = memo.id AND comment_relation.type = 'COMMENT' + )`) } order := "DESC" @@ -138,7 +218,12 @@ func (d *DB) ListMemos(ctx context.Context, find *store.FindMemo) ([]*store.Memo "`memo`.`visibility` AS `visibility`", "`memo`.`pinned` AS `pinned`", "`memo`.`payload` AS `payload`", - "CASE WHEN `parent_memo`.`uid` IS NOT NULL THEN `parent_memo`.`uid` ELSE NULL END AS `parent_uid`", + "`memo`.`space_id` AS `space_id`", + `(SELECT parent_memo.uid + FROM memo_relation AS parent_relation + JOIN memo AS parent_memo ON parent_memo.id = parent_relation.related_memo_id + WHERE parent_relation.memo_id = memo.id AND parent_relation.type = 'COMMENT' + ORDER BY parent_memo.id LIMIT 1) AS parent_uid`, } if !find.ExcludeContent { fields = append(fields, "`memo`.`content` AS `content`") @@ -146,8 +231,6 @@ func (d *DB) ListMemos(ctx context.Context, find *store.FindMemo) ([]*store.Memo query := "SELECT " + strings.Join(fields, ", ") + " FROM `memo`" + " " + "LEFT JOIN `user` AS `memo_creator` ON `memo`.`creator_id` = `memo_creator`.`id`" + " " + - "LEFT JOIN `memo_relation` ON `memo`.`id` = `memo_relation`.`memo_id` AND `memo_relation`.`type` = 'COMMENT'" + " " + - "LEFT JOIN `memo` AS `parent_memo` ON `memo_relation`.`related_memo_id` = `parent_memo`.`id`" + " " + "WHERE " + strings.Join(where, " AND ") + " " + "HAVING " + strings.Join(having, " AND ") + " " + "ORDER BY " + strings.Join(orderBy, ", ") @@ -178,6 +261,7 @@ func (d *DB) ListMemos(ctx context.Context, find *store.FindMemo) ([]*store.Memo &memo.Visibility, &memo.Pinned, &payloadBytes, + &memo.SpaceID, &memo.ParentUID, } if !find.ExcludeContent { @@ -215,7 +299,21 @@ func (d *DB) GetMemo(ctx context.Context, find *store.FindMemo) (*store.Memo, er } func (d *DB) UpdateMemo(ctx context.Context, update *store.UpdateMemo) error { - return applyMemoUpdate(ctx, d.db, update) + if update.Policy == nil { + return applyMemoUpdate(ctx, d.db, update) + } + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer func() { _ = tx.Rollback() }() + if err := validateMySQLMemoWritePolicy(ctx, tx, update.ID, update.Policy, update); err != nil { + return err + } + if err := applyMemoUpdate(ctx, tx, update); err != nil { + return err + } + return tx.Commit() } func (d *DB) DeleteMemo(ctx context.Context, delete *store.DeleteMemo) error { diff --git a/store/db/mysql/memo_access.go b/store/db/mysql/memo_access.go new file mode 100644 index 00000000..46f81008 --- /dev/null +++ b/store/db/mysql/memo_access.go @@ -0,0 +1,45 @@ +package mysql + +import ( + "fmt" + "strings" + + "github.com/usememos/memos/store" +) + +// mysqlMemoAccessPredicate builds the canonical memo-local read predicate for +// memoAlias and appends its bind values to args. +func mysqlMemoAccessPredicate(access *store.MemoAccessScope, memoAlias, memberAlias string, args *[]any) string { + clauses := []string{} + if access.AllowPublic { + clauses = append(clauses, memoAlias+".`visibility` = 'PUBLIC'") + } + if access.UserID != nil { + *args = append(*args, *access.UserID) + authenticatedClauses := []string{} + + *args = append(*args, *access.UserID) + authenticatedClauses = append(authenticatedClauses, "("+memoAlias+".`visibility` = 'PRIVATE' AND "+memoAlias+".`creator_id` = ?)") + if access.AllowProtected { + authenticatedClauses = append(authenticatedClauses, memoAlias+".`visibility` = 'PROTECTED'") + } + *args = append(*args, *access.UserID) + authenticatedClauses = append(authenticatedClauses, "("+memoAlias+".`visibility` = 'SPACE' AND EXISTS (SELECT 1 FROM `space_member` AS "+memberAlias+" WHERE "+memberAlias+".`space_id` = "+memoAlias+".`space_id` AND "+memberAlias+".`user_id` = ? AND "+memberAlias+".`role` IN ('ADMIN', 'USER')))") + + clauses = append(clauses, "(EXISTS (SELECT 1 FROM `user` AS `access_user` WHERE `access_user`.`id` = ? AND `access_user`.`row_status` = 'NORMAL') AND ("+strings.Join(authenticatedClauses, " OR ")+"))") + } + if len(clauses) == 0 { + return "1 = 0" + } + + validMemo := "(" + memoAlias + ".`visibility` IN ('PUBLIC', 'PROTECTED', 'PRIVATE', 'SPACE')" + + " AND EXISTS (SELECT 1 FROM `user` AS `valid_creator` WHERE `valid_creator`.`id` = " + memoAlias + ".`creator_id` AND `valid_creator`.`row_status` IN ('NORMAL', 'ARCHIVED'))" + + " AND (" + memoAlias + ".`visibility` <> 'SPACE' OR (" + memoAlias + ".`space_id` IS NOT NULL" + + " AND EXISTS (SELECT 1 FROM `space` AS `valid_space` WHERE `valid_space`.`id` = " + memoAlias + ".`space_id`))))" + validState := memoAlias + ".`row_status` = 'NORMAL'" + if access.UserID != nil { + *args = append(*args, *access.UserID) + validState = fmt.Sprintf("(%s.`row_status` = 'NORMAL' OR (%s.`row_status` = 'ARCHIVED' AND %s.`creator_id` = ?))", memoAlias, memoAlias, memoAlias) + } + return "(" + strings.Join(clauses, " OR ") + ") AND " + validMemo + " AND " + validState +} diff --git a/store/db/mysql/memo_attachment.go b/store/db/mysql/memo_attachment.go index 130112f6..d9e22ff5 100644 --- a/store/db/mysql/memo_attachment.go +++ b/store/db/mysql/memo_attachment.go @@ -20,6 +20,46 @@ func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation defer func() { _ = tx.Rollback() }() + if err := validateMySQLMemoRelationEndpoints(ctx, tx, mutation); err != nil { + return err + } + if create := mutation.MemoCreate; create != nil { + if err := validateMySQLMemoCreate(ctx, tx, create); err != nil { + return err + } + if mutation.CommentContextMemoID != nil { + if err := authorizeMySQLMemoComment(ctx, tx, *mutation.CommentContextMemoID, create.CreatorID); err != nil { + return err + } + } + created, err := insertMySQLMemo(ctx, tx, create) + if err != nil { + return err + } + *create = *created + mutation.MemoID = create.ID + mutation.MemoCreatorID = create.CreatorID + mutation.ExpectedMemoContent = create.Content + for _, relation := range mutation.ReferenceRelations { + if relation != nil { + relation.MemoID = create.ID + } + } + if mutation.CommentContextMemoID != nil { + if err := insertMySQLMemoCommentRelation(ctx, tx, create.ID, *mutation.CommentContextMemoID); err != nil { + return err + } + } + } + policy := mutation.Policy + if policy == nil && mutation.MemoUpdate != nil { + policy = mutation.MemoUpdate.Policy + } + if policy != nil { + if err := validateMySQLMemoWritePolicy(ctx, tx, mutation.MemoID, policy, mutation.MemoUpdate); err != nil { + return err + } + } var creatorID int32 var content string @@ -32,6 +72,18 @@ func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation if creatorID != mutation.MemoCreatorID || content != mutation.ExpectedMemoContent { return errors.Wrap(store.ErrMemoMutationConflict, "memo changed while applying mutation") } + removedAttachments, err := listMySQLAttachmentsByIDs(ctx, tx, mutation.RemovedAttachmentIDs) + if err != nil { + return errors.Wrap(err, "failed to read removed attachments") + } + if len(removedAttachments) != len(mutation.RemovedAttachmentIDs) { + return errors.Wrap(store.ErrMemoMutationConflict, "removed attachment no longer exists") + } + for _, attachment := range removedAttachments { + if attachment.CreatorID != mutation.MemoCreatorID || attachment.MemoID == nil || *attachment.MemoID != mutation.MemoID { + return errors.Wrap(store.ErrMemoMutationConflict, "attachment is no longer removable from the memo") + } + } for _, binding := range mutation.Bindings { var attachmentCreatorID int32 @@ -53,13 +105,14 @@ func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation return errors.Wrap(err, "failed to bind attachment") } } - - for _, attachmentID := range mutation.RemovedAttachmentIDs { - result, err := tx.ExecContext(ctx, "UPDATE `attachment` SET `memo_id` = NULL WHERE `id` = ? AND `memo_id` = ?", attachmentID, mutation.MemoID) + for _, attachment := range removedAttachments { + result, err := tx.ExecContext(ctx, "DELETE FROM `attachment` WHERE `id` = ? AND `memo_id` = ?", attachment.ID, mutation.MemoID) if err != nil { - return errors.Wrap(err, "failed to detach attachment") + return errors.Wrap(err, "failed to delete removed attachment") } - if rows, err := result.RowsAffected(); err != nil || rows != 1 { + if rows, err := result.RowsAffected(); err != nil { + return errors.Wrap(err, "failed to count deleted removed attachment") + } else if rows != 1 { return errors.Wrap(store.ErrMemoMutationConflict, "attachment is no longer bound to the memo") } } @@ -93,6 +146,17 @@ func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation return nil } +func insertMySQLMemoCommentRelation(ctx context.Context, tx *sql.Tx, memoID, contextMemoID int32) error { + if memoID <= 0 || contextMemoID <= 0 || memoID == contextMemoID { + return errors.New("invalid COMMENT relation") + } + if _, err := tx.ExecContext(ctx, "INSERT INTO memo_relation (memo_id, related_memo_id, type) VALUES (?, ?, ?)", + memoID, contextMemoID, store.MemoRelationComment); err != nil { + return errors.Wrap(err, "failed to insert COMMENT relation") + } + return nil +} + func replaceMemoReferenceRelations(ctx context.Context, tx *sql.Tx, memoID int32, relations []*store.MemoRelation) error { if _, err := tx.ExecContext(ctx, "DELETE FROM `memo_relation` WHERE `memo_id` = ? AND `type` = ?", memoID, store.MemoRelationReference); err != nil { return errors.Wrap(err, "failed to delete memo reference relations") @@ -145,6 +209,11 @@ func applyMemoUpdate(ctx context.Context, executor memoUpdateExecer, update *sto } set, args = append(set, "`payload` = ?"), append(args, string(payload)) } + if update.ClearSpace { + set = append(set, "`space_id` = NULL") + } else if v := update.SpaceID; v != nil { + set, args = append(set, "`space_id` = ?"), append(args, *v) + } if len(set) == 0 { return nil } diff --git a/store/db/mysql/memo_comment.go b/store/db/mysql/memo_comment.go new file mode 100644 index 00000000..6201c50c --- /dev/null +++ b/store/db/mysql/memo_comment.go @@ -0,0 +1,57 @@ +package mysql + +import ( + "context" + "database/sql" + stderrors "errors" + + "github.com/usememos/memos/store" +) + +func authorizeMySQLMemoComment(ctx context.Context, tx *sql.Tx, contextMemoID, actorUserID int32) error { + snapshot, err := loadMySQLMemoParticipation(ctx, tx, contextMemoID, actorUserID) + if err != nil { + if stderrors.Is(err, sql.ErrNoRows) || stderrors.Is(err, store.ErrMemoMutationConflict) { + return store.ErrMemoSpaceNotWritable + } + return err + } + return store.ValidateMemoCommentAuthorization(snapshot) +} + +// loadMySQLMemoParticipation resolves the current actor, Space, membership, +// and memo state shared by comment and reaction participation. +func loadMySQLMemoParticipation(ctx context.Context, tx *sql.Tx, memoID, actorUserID int32) (*store.MemoCommentAuthorizationSnapshot, error) { + var actorStatus store.RowStatus + actorErr := tx.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", actorUserID).Scan(&actorStatus) + if actorErr != nil && !stderrors.Is(actorErr, sql.ErrNoRows) { + return nil, actorErr + } + snapshot := &store.MemoCommentAuthorizationSnapshot{ + ActorUserID: actorUserID, + ActorActive: actorErr == nil && actorStatus == store.Normal, + ContextID: memoID, + } + var contextSpace sql.NullInt64 + err := tx.QueryRowContext(ctx, `SELECT creator_id, row_status, visibility, space_id + FROM memo WHERE id = ?`, memoID).Scan( + &snapshot.ContextCreatorID, &snapshot.ContextRowStatus, &snapshot.ContextVisibility, &contextSpace, + ) + if err != nil { + return nil, err + } + snapshot.ContextSpaceID = store.NullInt32Pointer(contextSpace) + if snapshot.ContextSpaceID != nil { + snapshot.ContextSpaceExists, err = mysqlSpaceExists(ctx, tx, *snapshot.ContextSpaceID) + if err != nil { + return nil, err + } + if snapshot.ContextSpaceExists { + snapshot.ContextMemberActive, err = mysqlSpaceMemberActive(ctx, tx, *snapshot.ContextSpaceID, actorUserID) + if err != nil { + return nil, err + } + } + } + return snapshot, nil +} diff --git a/store/db/mysql/memo_delete_policy.go b/store/db/mysql/memo_delete_policy.go new file mode 100644 index 00000000..2ad2b8a5 --- /dev/null +++ b/store/db/mysql/memo_delete_policy.go @@ -0,0 +1,67 @@ +package mysql + +import ( + "context" + "database/sql" + + "github.com/pkg/errors" + + "github.com/usememos/memos/store" +) + +func (d *DB) DeleteMemoWithPolicy(ctx context.Context, delete *store.DeleteMemoWithPolicy) (*store.DeleteMemoWithPolicyResult, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, errors.Wrap(err, "failed to begin memo delete transaction") + } + defer func() { _ = tx.Rollback() }() + + var actorStatus store.RowStatus + if err := tx.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", delete.ActorUserID).Scan(&actorStatus); errors.Is(err, sql.ErrNoRows) { + return nil, store.ErrMemoPermissionDenied + } else if err != nil { + return nil, errors.Wrap(err, "failed to read memo deletion actor") + } else if actorStatus != store.Normal { + return nil, store.ErrMemoPermissionDenied + } + + var creatorID int32 + var rowStatus store.RowStatus + var visibility store.Visibility + var space sql.NullInt64 + if err := tx.QueryRowContext(ctx, "SELECT creator_id, row_status, visibility, space_id FROM memo WHERE id = ?", delete.MemoID).Scan( + &creatorID, &rowStatus, &visibility, &space, + ); errors.Is(err, sql.ErrNoRows) { + return nil, store.ErrMemoMutationConflict + } else if err != nil { + return nil, errors.Wrap(err, "failed to read memo") + } + if creatorID != delete.ActorUserID { + return nil, store.ErrMemoPermissionDenied + } + spaceID := store.NullInt32Pointer(space) + spaceExists := false + actorMember := false + if spaceID != nil { + spaceExists, err = mysqlSpaceExists(ctx, tx, *spaceID) + if err != nil { + return nil, errors.Wrap(err, "failed to read memo space") + } + } + if spaceID != nil && spaceExists { + actorMember, err = mysqlSpaceMemberActive(ctx, tx, *spaceID, delete.ActorUserID) + if err != nil { + return nil, errors.Wrap(err, "failed to read memo membership") + } + } + actorCanRead := store.MemoDeleteActorCanRead(rowStatus, visibility, spaceID, spaceExists, actorMember) + + attachments, err := deleteMySQLMemoSetTx(ctx, tx, []int32{delete.MemoID}) + if err != nil { + return nil, errors.Wrap(err, "failed to delete memo set") + } + if err := tx.Commit(); err != nil { + return nil, errors.Wrap(err, "failed to commit memo delete transaction") + } + return &store.DeleteMemoWithPolicyResult{ActorCanRead: actorCanRead, Attachments: attachments}, nil +} diff --git a/store/db/mysql/memo_policy.go b/store/db/mysql/memo_policy.go new file mode 100644 index 00000000..ab2dab7b --- /dev/null +++ b/store/db/mysql/memo_policy.go @@ -0,0 +1,78 @@ +package mysql + +import ( + "context" + "database/sql" + stderrors "errors" + + "github.com/usememos/memos/store" +) + +func validateMySQLMemoWritePolicy(ctx context.Context, tx *sql.Tx, memoID int32, policy *store.MemoWritePolicy, update *store.UpdateMemo) error { + var actorStatus store.RowStatus + if err := tx.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", policy.ActorUserID).Scan(&actorStatus); stderrors.Is(err, sql.ErrNoRows) { + return store.ErrMemoSpaceMembershipRequired + } else if err != nil { + return err + } else if actorStatus != store.Normal { + return store.ErrMemoSpaceMembershipRequired + } + + snapshot := new(store.MemoWriteSnapshot) + var spaceID sql.NullInt64 + if err := tx.QueryRowContext(ctx, `SELECT creator_id, row_status, space_id, visibility FROM memo WHERE id = ?`, memoID).Scan( + &snapshot.CreatorID, &snapshot.RowStatus, &spaceID, &snapshot.Visibility, + ); err != nil { + if stderrors.Is(err, sql.ErrNoRows) { + return store.ErrMemoMutationConflict + } + return err + } + snapshot.SpaceID = store.NullInt32Pointer(spaceID) + if snapshot.SpaceID != nil { + var err error + snapshot.SourceSpaceExists, err = mysqlSpaceExists(ctx, tx, *snapshot.SpaceID) + if err != nil { + return err + } + if snapshot.SourceSpaceExists { + snapshot.SourceMemberActive, err = mysqlSpaceMemberActive(ctx, tx, *snapshot.SpaceID, policy.ActorUserID) + if err != nil { + return err + } + } + } + if update != nil && update.SpaceID != nil { + var err error + snapshot.TargetSpaceExists, err = mysqlSpaceExists(ctx, tx, *update.SpaceID) + if err != nil { + return err + } + if snapshot.TargetSpaceExists { + snapshot.TargetMemberActive, err = mysqlSpaceMemberActive(ctx, tx, *update.SpaceID, policy.ActorUserID) + if err != nil { + return err + } + } + } + + if update != nil && update.Visibility != nil && *update.Visibility == store.SpaceAudience { + var shareID int32 + err := tx.QueryRowContext(ctx, `SELECT id FROM memo_share + WHERE memo_id = ? AND (expires_ts IS NULL OR expires_ts > UNIX_TIMESTAMP()) + LIMIT 1`, memoID).Scan(&shareID) + snapshot.HasActiveShare = err == nil + if err != nil && !stderrors.Is(err, sql.ErrNoRows) { + return err + } + } + return store.ValidateMemoWriteSnapshot(policy, update, snapshot) +} + +func mysqlSpaceExists(ctx context.Context, tx *sql.Tx, spaceID int32) (bool, error) { + var exists bool + if err := tx.QueryRowContext(ctx, "SELECT EXISTS(SELECT 1 FROM space WHERE id = ?)", spaceID).Scan(&exists); err != nil { + return false, err + } + return exists, nil +} diff --git a/store/db/mysql/memo_relation.go b/store/db/mysql/memo_relation.go index 400422b4..81bb4f72 100644 --- a/store/db/mysql/memo_relation.go +++ b/store/db/mysql/memo_relation.go @@ -128,6 +128,9 @@ func (d *DB) ListMemoRelations(ctx context.Context, find *store.FindMemoRelation } func (d *DB) DeleteMemoRelation(ctx context.Context, delete *store.DeleteMemoRelation) error { + if err := store.ValidateMemoRelationDelete(delete); err != nil { + return err + } where, args := []string{"TRUE"}, []any{} if delete.MemoID != nil { where, args = append(where, "`memo_id` = ?"), append(args, *delete.MemoID) @@ -135,9 +138,7 @@ func (d *DB) DeleteMemoRelation(ctx context.Context, delete *store.DeleteMemoRel if delete.RelatedMemoID != nil { where, args = append(where, "`related_memo_id` = ?"), append(args, *delete.RelatedMemoID) } - if delete.Type != nil { - where, args = append(where, "`type` = ?"), append(args, *delete.Type) - } + where, args = append(where, "`type` = ?"), append(args, *delete.Type) stmt := "DELETE FROM `memo_relation` WHERE " + strings.Join(where, " AND ") result, err := d.db.ExecContext(ctx, stmt, args...) if err != nil { diff --git a/store/db/mysql/memo_relation_policy.go b/store/db/mysql/memo_relation_policy.go new file mode 100644 index 00000000..67a328db --- /dev/null +++ b/store/db/mysql/memo_relation_policy.go @@ -0,0 +1,101 @@ +package mysql + +import ( + "context" + "database/sql" + stderrors "errors" + + "github.com/usememos/memos/store" +) + +type mysqlRelationMemoState struct { + id int32 + creatorID int32 + rowStatus store.RowStatus + visibility store.Visibility + spaceID *int32 +} + +func validateMySQLMemoRelationEndpoints(ctx context.Context, tx *sql.Tx, mutation *store.MemoMutation) error { + if !mutation.ReplaceReferenceRelations && mutation.CommentContextMemoID == nil { + return nil + } + + var actorStatus store.RowStatus + actorErr := tx.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", mutation.MemoCreatorID).Scan(&actorStatus) + if actorErr != nil && !stderrors.Is(actorErr, sql.ErrNoRows) { + return actorErr + } + actorActive := actorErr == nil && actorStatus == store.Normal + + endpointIDs := mysqlRelationAuthorizationEndpointIDs(mutation) + for _, endpointID := range endpointIDs { + state, err := getMySQLRelationMemoState(ctx, tx, endpointID) + if err != nil { + if stderrors.Is(err, sql.ErrNoRows) { + return store.ErrMemoMutationConflict + } + return err + } + snapshot := &store.MemoRelationEndpointSnapshot{ + ActorUserID: mutation.MemoCreatorID, + ActorActive: actorActive, + EndpointID: state.id, + EndpointCreatorID: state.creatorID, + EndpointRowStatus: state.rowStatus, + EndpointVisibility: state.visibility, + EndpointSpaceID: state.spaceID, + } + if state.spaceID != nil { + snapshot.EndpointSpaceExists, err = mysqlSpaceExists(ctx, tx, *state.spaceID) + if err != nil { + return err + } + if snapshot.EndpointSpaceExists { + snapshot.EndpointMemberActive, err = mysqlSpaceMemberActive(ctx, tx, *state.spaceID, mutation.MemoCreatorID) + if err != nil { + return err + } + } + } + if err := store.ValidateMemoRelationEndpointRead(snapshot); err != nil { + return err + } + } + return nil +} + +func getMySQLRelationMemoState(ctx context.Context, tx *sql.Tx, memoID int32) (*mysqlRelationMemoState, error) { + state := &mysqlRelationMemoState{} + var spaceID sql.NullInt64 + if err := tx.QueryRowContext(ctx, `SELECT id, creator_id, row_status, visibility, space_id FROM memo WHERE id = ?`, memoID).Scan( + &state.id, &state.creatorID, &state.rowStatus, &state.visibility, &spaceID, + ); err != nil { + return nil, err + } + state.spaceID = store.NullInt32Pointer(spaceID) + return state, nil +} + +func mysqlRelationAuthorizationEndpointIDs(mutation *store.MemoMutation) []int32 { + ids := make([]int32, 0, len(mutation.ReferenceRelations)+1) + seen := make(map[int32]struct{}, len(mutation.ReferenceRelations)+1) + add := func(id int32) { + if _, ok := seen[id]; ok { + return + } + seen[id] = struct{}{} + ids = append(ids, id) + } + if mutation.MemoCreate == nil && mutation.MemoID > 0 { + add(mutation.MemoID) + } else if mutation.CommentContextMemoID != nil { + add(*mutation.CommentContextMemoID) + } + for _, relation := range mutation.ReferenceRelations { + if relation != nil { + add(relation.RelatedMemoID) + } + } + return ids +} diff --git a/store/db/mysql/memo_share.go b/store/db/mysql/memo_share.go index 29c278d5..41ac7d87 100644 --- a/store/db/mysql/memo_share.go +++ b/store/db/mysql/memo_share.go @@ -2,6 +2,7 @@ package mysql import ( "context" + "database/sql" "strings" "github.com/pkg/errors" @@ -10,6 +11,33 @@ import ( ) func (d *DB) CreateMemoShare(ctx context.Context, create *store.MemoShare) (*store.MemoShare, error) { + if create.Policy == nil { + return createMySQLMemoShare(ctx, d.db, create) + } + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := validateMySQLMemoWritePolicy(ctx, tx, create.MemoID, create.Policy, nil); err != nil { + return nil, err + } + result, err := createMySQLMemoShare(ctx, tx, create) + if err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return result, nil +} + +type mysqlMemoShareCreator interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func createMySQLMemoShare(ctx context.Context, executor mysqlMemoShareCreator, create *store.MemoShare) (*store.MemoShare, error) { fields := []string{"`uid`", "`memo_id`", "`creator_id`"} placeholders := []string{"?", "?", "?"} args := []any{create.UID, create.MemoID, create.CreatorID} @@ -21,7 +49,7 @@ func (d *DB) CreateMemoShare(ctx context.Context, create *store.MemoShare) (*sto } stmt := "INSERT INTO `memo_share` (" + strings.Join(fields, ", ") + ") VALUES (" + strings.Join(placeholders, ", ") + ")" - result, err := d.db.ExecContext(ctx, stmt, args...) + result, err := executor.ExecContext(ctx, stmt, args...) if err != nil { return nil, err } @@ -31,14 +59,13 @@ func (d *DB) CreateMemoShare(ctx context.Context, create *store.MemoShare) (*sto return nil, err } id := int32(rawID) - ms, err := d.GetMemoShare(ctx, &store.FindMemoShare{ID: &id}) - if err != nil { - return nil, err + created := &store.MemoShare{Policy: create.Policy} + if err := executor.QueryRowContext(ctx, `SELECT id, uid, memo_id, creator_id, created_ts, expires_ts FROM memo_share WHERE id = ?`, id).Scan( + &created.ID, &created.UID, &created.MemoID, &created.CreatorID, &created.CreatedTs, &created.ExpiresTs, + ); err != nil { + return nil, errors.Wrap(err, "failed to load created memo share") } - if ms == nil { - return nil, errors.Errorf("failed to create memo share") - } - return ms, nil + return created, nil } func (d *DB) ListMemoShares(ctx context.Context, find *store.FindMemoShare) ([]*store.MemoShare, error) { @@ -109,6 +136,35 @@ func (d *DB) GetMemoShare(ctx context.Context, find *store.FindMemoShare) (*stor } func (d *DB) DeleteMemoShare(ctx context.Context, delete *store.DeleteMemoShare) error { + if delete.Policy != nil { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer func() { _ = tx.Rollback() }() + if err := validateMySQLMemoWritePolicy(ctx, tx, *delete.MemoID, delete.Policy, nil); err != nil { + return err + } + where, args := mysqlMemoShareDeleteWhere(delete) + where = append(where, "`memo_id` = ?") + args = append(args, *delete.MemoID) + result, err := tx.ExecContext(ctx, "DELETE FROM `memo_share` WHERE "+strings.Join(where, " AND "), args...) + if err != nil { + return err + } + if rows, err := result.RowsAffected(); err != nil { + return err + } else if rows != 1 { + return store.ErrMemoMutationConflict + } + return tx.Commit() + } + where, args := mysqlMemoShareDeleteWhere(delete) + _, err := d.db.ExecContext(ctx, "DELETE FROM `memo_share` WHERE "+strings.Join(where, " AND "), args...) + return err +} + +func mysqlMemoShareDeleteWhere(delete *store.DeleteMemoShare) ([]string, []any) { where, args := []string{"1 = 1"}, []any{} if delete.ID != nil { where, args = append(where, "`id` = ?"), append(args, *delete.ID) @@ -116,6 +172,5 @@ func (d *DB) DeleteMemoShare(ctx context.Context, delete *store.DeleteMemoShare) if delete.UID != nil { where, args = append(where, "`uid` = ?"), append(args, *delete.UID) } - _, err := d.db.ExecContext(ctx, "DELETE FROM `memo_share` WHERE "+strings.Join(where, " AND "), args...) - return err + return where, args } diff --git a/store/db/mysql/reaction.go b/store/db/mysql/reaction.go index a18fcc35..195ecd92 100644 --- a/store/db/mysql/reaction.go +++ b/store/db/mysql/reaction.go @@ -2,6 +2,7 @@ package mysql import ( "context" + "database/sql" "strings" "github.com/pkg/errors" @@ -19,6 +20,11 @@ func (d *DB) UpsertReaction(ctx context.Context, upsert *store.Reaction) (*store defer func() { _ = tx.Rollback() }() + if upsert.Policy != nil { + if err := validateMySQLReactionWritePolicy(ctx, tx, upsert); err != nil { + return nil, err + } + } result, err := tx.ExecContext(ctx, ` INSERT INTO reaction (creator_id, memo_id, reaction_type) @@ -126,6 +132,9 @@ func (d *DB) GetReaction(ctx context.Context, find *store.FindReaction) (*store. } func (d *DB) DeleteReaction(ctx context.Context, delete *store.DeleteReaction) error { + if delete.ActorUserID != nil { + return d.deleteReactionAsCreator(ctx, delete) + } where, args := []string{}, []any{} if delete.ID != nil { where, args = append(where, "`id` = ?"), append(args, *delete.ID) @@ -140,3 +149,38 @@ func (d *DB) DeleteReaction(ctx context.Context, delete *store.DeleteReaction) e _, err := d.db.ExecContext(ctx, "DELETE FROM `reaction` WHERE "+strings.Join(where, " AND "), args...) return err } + +func (d *DB) deleteReactionAsCreator(ctx context.Context, delete *store.DeleteReaction) error { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return errors.Wrap(err, "failed to begin authorized reaction delete transaction") + } + defer func() { _ = tx.Rollback() }() + if delete.Policy != nil { + if err := validateMySQLReactionWritePolicy(ctx, tx, &store.Reaction{ + CreatorID: *delete.ActorUserID, + MemoID: *delete.MemoID, + Policy: delete.Policy, + }); err != nil { + return err + } + } + + var creatorID, memoID int32 + if err := tx.QueryRowContext(ctx, "SELECT creator_id, memo_id FROM reaction WHERE id = ?", *delete.ID).Scan(&creatorID, &memoID); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return nil + } + return errors.Wrap(err, "failed to read reaction for deletion") + } + if creatorID != *delete.ActorUserID || (delete.MemoID != nil && memoID != *delete.MemoID) { + return store.ErrReactionPermissionDenied + } + if _, err := tx.ExecContext(ctx, "DELETE FROM reaction WHERE id = ?", *delete.ID); err != nil { + return errors.Wrap(err, "failed to delete reaction") + } + if err := tx.Commit(); err != nil { + return errors.Wrap(err, "failed to commit authorized reaction delete transaction") + } + return nil +} diff --git a/store/db/mysql/reaction_policy.go b/store/db/mysql/reaction_policy.go new file mode 100644 index 00000000..8f9767cd --- /dev/null +++ b/store/db/mysql/reaction_policy.go @@ -0,0 +1,35 @@ +package mysql + +import ( + "context" + "database/sql" + + "github.com/pkg/errors" + + "github.com/usememos/memos/store" +) + +func validateMySQLReactionWritePolicy(ctx context.Context, tx *sql.Tx, reaction *store.Reaction) error { + policy := reaction.Policy + participation, err := loadMySQLMemoParticipation(ctx, tx, reaction.MemoID, policy.ActorUserID) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrReactionMemoNotFound + } + return errors.Wrap(err, "failed to read reaction participation") + } + return store.ValidateReactionWriteParticipation(reaction, participation) +} + +func mysqlSpaceMemberActive(ctx context.Context, tx *sql.Tx, spaceID, userID int32) (bool, error) { + var role store.SpaceMemberRole + err := tx.QueryRowContext(ctx, `SELECT role FROM space_member + WHERE space_id = ? AND user_id = ? AND role IN ('ADMIN', 'USER')`, spaceID, userID).Scan(&role) + if errors.Is(err, sql.ErrNoRows) { + return false, nil + } + if err != nil { + return false, err + } + return role.IsActiveMember(), nil +} diff --git a/store/db/mysql/space.go b/store/db/mysql/space.go new file mode 100644 index 00000000..5ae07fe3 --- /dev/null +++ b/store/db/mysql/space.go @@ -0,0 +1,359 @@ +package mysql + +import ( + "context" + "database/sql" + "fmt" + "strings" + + mysqldriver "github.com/go-sql-driver/mysql" + "github.com/pkg/errors" + + "github.com/usememos/memos/store" +) + +func (d *DB) CreateSpace(ctx context.Context, create *store.Space, creatorID int32) (*store.Space, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, errors.Wrap(err, "failed to start space create transaction") + } + defer func() { _ = tx.Rollback() }() + if err := requireMySQLActiveUser(ctx, tx, creatorID); err != nil { + return nil, err + } + fields := []string{"uid", "title", "description"} + values := []string{"?", "?", "?"} + args := []any{create.UID, create.Title, create.Description} + result, err := tx.ExecContext(ctx, "INSERT INTO space ("+strings.Join(fields, ", ")+") VALUES ("+strings.Join(values, ", ")+")", args...) + if err != nil { + if isMySQLUniqueViolation(err) { + return nil, store.ErrSpaceAlreadyExists + } + return nil, errors.Wrap(err, "failed to create space") + } + rawID, err := result.LastInsertId() + if err != nil { + return nil, err + } + spaceID := int32(rawID) + if _, err := tx.ExecContext(ctx, "INSERT INTO space_member (space_id, user_id, role) VALUES (?, ?, ?)", spaceID, creatorID, store.SpaceMemberRoleAdmin); err != nil { + return nil, errors.Wrap(err, "failed to create initial space admin") + } + space, err := getMySQLSpace(ctx, tx, spaceID) + if err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return space, nil +} + +func (d *DB) ListSpaces(ctx context.Context, find *store.FindSpace) ([]*store.Space, error) { + where, args := []string{"1 = 1"}, []any{} + if find.ID != nil { + where, args = append(where, "space.id = ?"), append(args, *find.ID) + } + if find.UID != nil { + where, args = append(where, "space.uid = ?"), append(args, *find.UID) + } + if find.MemberUserID != nil { + where, args = append(where, "EXISTS (SELECT 1 FROM space_member sm JOIN user u ON u.id = sm.user_id WHERE sm.space_id = space.id AND sm.user_id = ? AND sm.role IN ('ADMIN', 'USER') AND u.row_status = 'NORMAL')"), append(args, *find.MemberUserID) + } + query := `SELECT space.id, space.uid, space.title, space.description + FROM space WHERE ` + strings.Join(where, " AND ") + ` ORDER BY space.id DESC` + query = appendMySQLLimit(query, find.Limit, find.Offset) + rows, err := d.db.QueryContext(ctx, query, args...) + if err != nil { + return nil, err + } + defer rows.Close() + spaces := []*store.Space{} + for rows.Next() { + space := &store.Space{} + if err := scanMySQLSpace(rows, space); err != nil { + return nil, err + } + spaces = append(spaces, space) + } + return spaces, rows.Err() +} + +func (d *DB) UpdateSpace(ctx context.Context, update *store.UpdateSpace, actorUserID int32) (*store.Space, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := requireMySQLActiveUsers(ctx, tx, actorUserID); err != nil { + return nil, err + } + if err := authorizeMySQLSpaceAdmin(ctx, tx, update.ID, actorUserID); err != nil { + return nil, err + } + sets, args := []string{}, []any{} + if update.Title != nil { + sets, args = append(sets, "title = ?"), append(args, *update.Title) + } + if update.Description != nil { + sets, args = append(sets, "description = ?"), append(args, *update.Description) + } + args = append(args, update.ID) + if _, err := tx.ExecContext(ctx, "UPDATE space SET "+strings.Join(sets, ", ")+" WHERE id = ?", args...); err != nil { + return nil, err + } + space, err := getMySQLSpace(ctx, tx, update.ID) + if err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return space, nil +} + +func (d *DB) CreateSpaceMember(ctx context.Context, create *store.SpaceMember, actorUserID int32) (*store.SpaceMember, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := requireMySQLActiveUsers(ctx, tx, actorUserID, create.UserID); err != nil { + return nil, err + } + if err := authorizeMySQLSpaceAdmin(ctx, tx, create.SpaceID, actorUserID); err != nil { + return nil, err + } + if _, err := tx.ExecContext(ctx, "INSERT INTO space_member (space_id, user_id, role) VALUES (?, ?, ?)", create.SpaceID, create.UserID, create.Role); err != nil { + if isMySQLUniqueViolation(err) { + return nil, store.ErrSpaceMemberAlreadyExists + } + return nil, err + } + member, err := getMySQLSpaceMember(ctx, tx, create.SpaceID, create.UserID) + if err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return member, nil +} + +func (d *DB) ListSpaceMembers(ctx context.Context, find *store.FindSpaceMember) ([]*store.SpaceMember, error) { + where, args := []string{ + "space_member.role IN ('ADMIN', 'USER')", + "EXISTS (SELECT 1 FROM space member_space WHERE member_space.id = space_member.space_id)", + "EXISTS (SELECT 1 FROM user member_user WHERE member_user.id = space_member.user_id AND member_user.row_status = 'NORMAL')", + }, []any{} + if find.SpaceID != nil { + where, args = append(where, "space_id = ?"), append(args, *find.SpaceID) + } + if find.UserID != nil { + where, args = append(where, "user_id = ?"), append(args, *find.UserID) + } + if find.ViewerUserID != nil { + where, args = append(where, "EXISTS (SELECT 1 FROM space_member viewer JOIN user viewer_user ON viewer_user.id = viewer.user_id WHERE viewer.space_id = space_member.space_id AND viewer.user_id = ? AND viewer.role IN ('ADMIN', 'USER') AND viewer_user.row_status = 'NORMAL')"), append(args, *find.ViewerUserID) + } + query := `SELECT space_id, user_id, role FROM space_member + WHERE ` + strings.Join(where, " AND ") + ` ORDER BY user_id ASC` + query = appendMySQLLimit(query, find.Limit, find.Offset) + rows, err := d.db.QueryContext(ctx, query, args...) + if err != nil { + return nil, err + } + defer rows.Close() + members := []*store.SpaceMember{} + for rows.Next() { + member := &store.SpaceMember{} + if err := rows.Scan(&member.SpaceID, &member.UserID, &member.Role); err != nil { + return nil, err + } + members = append(members, member) + } + return members, rows.Err() +} + +func (d *DB) UpdateSpaceMember(ctx context.Context, update *store.UpdateSpaceMember, actorUserID int32) (*store.SpaceMember, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := requireMySQLActiveUsers(ctx, tx, actorUserID, update.UserID); err != nil { + return nil, err + } + if err := authorizeMySQLSpaceAdmin(ctx, tx, update.SpaceID, actorUserID); err != nil { + return nil, err + } + current, err := getMySQLSpaceMember(ctx, tx, update.SpaceID, update.UserID) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return nil, store.ErrSpaceMemberNotFound + } + return nil, err + } + if current.Role == store.SpaceMemberRoleAdmin && update.Role != nil && *update.Role != store.SpaceMemberRoleAdmin { + var count int + if err := tx.QueryRowContext(ctx, "SELECT COUNT(*) FROM space_member sm JOIN user u ON u.id = sm.user_id WHERE sm.space_id = ? AND sm.role = ? AND u.row_status = 'NORMAL'", update.SpaceID, store.SpaceMemberRoleAdmin).Scan(&count); err != nil { + return nil, err + } + if count <= 1 { + return nil, store.ErrLastSpaceAdmin + } + } + sets, args := []string{}, []any{} + if update.Role != nil { + sets, args = append(sets, "role = ?"), append(args, *update.Role) + } + args = append(args, update.SpaceID, update.UserID) + if _, err := tx.ExecContext(ctx, "UPDATE space_member SET "+strings.Join(sets, ", ")+" WHERE space_id = ? AND user_id = ?", args...); err != nil { + return nil, err + } + member, err := getMySQLSpaceMember(ctx, tx, update.SpaceID, update.UserID) + if err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return member, nil +} + +func (d *DB) DeleteSpaceMember(ctx context.Context, delete *store.DeleteSpaceMember, actorUserID int32) error { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer func() { _ = tx.Rollback() }() + userStatuses, err := readMySQLUserStatuses(ctx, tx, actorUserID, delete.UserID) + if err != nil { + return err + } + if actorUserID != delete.UserID && userStatuses[actorUserID] != store.Normal { + return store.ErrSpacePermissionDenied + } + var spaceID int32 + if err := tx.QueryRowContext(ctx, "SELECT id FROM space WHERE id = ?", delete.SpaceID).Scan(&spaceID); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrSpaceNotFound + } + return err + } + if actorUserID != delete.UserID { + var role store.SpaceMemberRole + if err := tx.QueryRowContext(ctx, "SELECT role FROM space_member WHERE space_id = ? AND user_id = ?", delete.SpaceID, actorUserID).Scan(&role); errors.Is(err, sql.ErrNoRows) { + return store.ErrSpacePermissionDenied + } else if err != nil { + return err + } else if role != store.SpaceMemberRoleAdmin { + return store.ErrSpacePermissionDenied + } + } + member, err := getMySQLSpaceMember(ctx, tx, delete.SpaceID, delete.UserID) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrSpaceMemberNotFound + } + return err + } + if member.Role == store.SpaceMemberRoleAdmin && userStatuses[delete.UserID] == store.Normal { + var count int + if err := tx.QueryRowContext(ctx, "SELECT COUNT(*) FROM space_member sm JOIN user u ON u.id = sm.user_id WHERE sm.space_id = ? AND sm.role = ? AND u.row_status = 'NORMAL'", delete.SpaceID, store.SpaceMemberRoleAdmin).Scan(&count); err != nil { + return err + } + if count <= 1 { + return store.ErrLastSpaceAdmin + } + } + if _, err := tx.ExecContext(ctx, "DELETE FROM space_member WHERE space_id = ? AND user_id = ?", delete.SpaceID, delete.UserID); err != nil { + return err + } + return tx.Commit() +} + +type mysqlRowScanner interface{ Scan(...any) error } + +func scanMySQLSpace(row mysqlRowScanner, space *store.Space) error { + return row.Scan(&space.ID, &space.UID, &space.Title, &space.Description) +} + +func getMySQLSpace(ctx context.Context, tx *sql.Tx, id int32) (*store.Space, error) { + space := &store.Space{} + return space, scanMySQLSpace(tx.QueryRowContext(ctx, `SELECT id, uid, title, description FROM space WHERE id = ?`, id), space) +} + +func getMySQLSpaceMember(ctx context.Context, tx *sql.Tx, spaceID, userID int32) (*store.SpaceMember, error) { + member := &store.SpaceMember{} + err := tx.QueryRowContext(ctx, `SELECT space_id, user_id, role FROM space_member WHERE space_id = ? AND user_id = ?`, spaceID, userID).Scan(&member.SpaceID, &member.UserID, &member.Role) + return member, err +} + +func authorizeMySQLSpaceAdmin(ctx context.Context, tx *sql.Tx, spaceID, actorUserID int32) error { + var existingSpaceID int32 + if err := tx.QueryRowContext(ctx, "SELECT id FROM space WHERE id = ?", spaceID).Scan(&existingSpaceID); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrSpaceNotFound + } + return err + } + var role store.SpaceMemberRole + if err := tx.QueryRowContext(ctx, "SELECT role FROM space_member WHERE space_id = ? AND user_id = ?", spaceID, actorUserID).Scan(&role); errors.Is(err, sql.ErrNoRows) { + return store.ErrSpacePermissionDenied + } else if err != nil { + return err + } else if role != store.SpaceMemberRoleAdmin { + return store.ErrSpacePermissionDenied + } + return nil +} + +func requireMySQLActiveUser(ctx context.Context, tx *sql.Tx, userID int32) error { + return requireMySQLActiveUsers(ctx, tx, userID) +} + +func requireMySQLActiveUsers(ctx context.Context, tx *sql.Tx, userIDs ...int32) error { + statuses, err := readMySQLUserStatuses(ctx, tx, userIDs...) + if err != nil { + return err + } + for _, userID := range userIDs { + if statuses[userID] != store.Normal { + return store.ErrSpaceMemberNotActive + } + } + return nil +} + +func readMySQLUserStatuses(ctx context.Context, tx *sql.Tx, userIDs ...int32) (map[int32]store.RowStatus, error) { + statuses := make(map[int32]store.RowStatus, len(userIDs)) + for _, userID := range userIDs { + if _, ok := statuses[userID]; ok { + continue + } + var status store.RowStatus + if err := tx.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", userID).Scan(&status); err != nil { + if errors.Is(err, sql.ErrNoRows) { + continue + } + return nil, err + } + statuses[userID] = status + } + return statuses, nil +} + +func appendMySQLLimit(query string, limit, offset *int) string { + if limit != nil { + query = fmt.Sprintf("%s LIMIT %d", query, *limit) + if offset != nil { + query = fmt.Sprintf("%s OFFSET %d", query, *offset) + } + } + return query +} + +func isMySQLUniqueViolation(err error) bool { + var mysqlErr *mysqldriver.MySQLError + return errors.As(err, &mysqlErr) && mysqlErr.Number == 1062 +} diff --git a/store/db/mysql/space_delete.go b/store/db/mysql/space_delete.go new file mode 100644 index 00000000..29a798f5 --- /dev/null +++ b/store/db/mysql/space_delete.go @@ -0,0 +1,137 @@ +package mysql + +import ( + "context" + "database/sql" + + "github.com/pkg/errors" + + "github.com/usememos/memos/store" +) + +// DeleteSpace hard-deletes only memos directly placed in the Space. Relations +// are removed when either endpoint is deleted, but are never traversed. +func (d *DB) DeleteSpace(ctx context.Context, delete *store.DeleteSpace) (*store.DeleteSpaceResult, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, errors.Wrap(err, "failed to begin space delete transaction") + } + defer func() { _ = tx.Rollback() }() + + if err := requireMySQLSpaceDeleteAdmin(ctx, tx, delete); err != nil { + return nil, err + } + memoIDs, err := listMySQLSpaceDeleteMemoIDs(ctx, tx, delete.ID) + if err != nil { + return nil, errors.Wrap(err, "failed to collect assigned memos") + } + attachments, err := deleteMySQLMemoSetTx(ctx, tx, memoIDs) + if err != nil { + return nil, errors.Wrap(err, "failed to delete assigned memo set") + } + if _, err := tx.ExecContext(ctx, "DELETE FROM space_member WHERE space_id = ?", delete.ID); err != nil { + return nil, errors.Wrap(err, "failed to delete space memberships") + } + result, err := tx.ExecContext(ctx, "DELETE FROM space WHERE id = ?", delete.ID) + if err != nil { + return nil, errors.Wrap(err, "failed to delete space") + } + if count, err := result.RowsAffected(); err != nil { + return nil, errors.Wrap(err, "failed to count deleted spaces") + } else if count != 1 { + return nil, store.ErrSpaceNotFound + } + if err := tx.Commit(); err != nil { + return nil, errors.Wrap(err, "failed to commit space deletion") + } + return &store.DeleteSpaceResult{Attachments: attachments}, nil +} + +func requireMySQLSpaceDeleteAdmin(ctx context.Context, tx *sql.Tx, delete *store.DeleteSpace) error { + statuses, err := readMySQLUserStatuses(ctx, tx, delete.ActorUserID) + if err != nil { + return err + } + if statuses[delete.ActorUserID] != store.Normal { + return store.ErrSpacePermissionDenied + } + var spaceID int32 + if err := tx.QueryRowContext(ctx, "SELECT id FROM space WHERE id = ?", delete.ID).Scan(&spaceID); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrSpaceNotFound + } + return err + } + var role store.SpaceMemberRole + if err := tx.QueryRowContext(ctx, "SELECT role FROM space_member WHERE space_id = ? AND user_id = ?", delete.ID, delete.ActorUserID).Scan(&role); errors.Is(err, sql.ErrNoRows) { + return store.ErrSpacePermissionDenied + } else if err != nil { + return errors.Wrap(err, "failed to read space administrator membership") + } else if role != store.SpaceMemberRoleAdmin { + return store.ErrSpacePermissionDenied + } + return nil +} + +func listMySQLSpaceDeleteMemoIDs(ctx context.Context, tx *sql.Tx, spaceID int32) ([]int32, error) { + rows, err := tx.QueryContext(ctx, "SELECT id FROM memo WHERE space_id = ? ORDER BY id", spaceID) + if err != nil { + return nil, err + } + defer rows.Close() + ids := make([]int32, 0) + for rows.Next() { + var id int32 + if err := rows.Scan(&id); err != nil { + return nil, err + } + ids = append(ids, id) + } + return ids, rows.Err() +} + +func deleteMySQLMemoSetTx(ctx context.Context, tx *sql.Tx, memoIDs []int32) ([]*store.Attachment, error) { + attachments, err := listMySQLMemoSetAttachments(ctx, tx, memoIDs) + if err != nil { + return nil, errors.Wrap(err, "failed to collect memo attachments") + } + if err := deleteMySQLMemoSetShares(ctx, tx, memoIDs); err != nil { + return nil, errors.Wrap(err, "failed to delete memo shares") + } + if err := deleteMemosTx(ctx, tx, memoIDs); err != nil { + return nil, errors.Wrap(err, "failed to delete memos") + } + if err := deleteReactionsByMemoIDsTx(ctx, tx, memoIDs); err != nil { + return nil, errors.Wrap(err, "failed to delete memo reactions") + } + if err := deleteAttachmentsByIDsTx(ctx, tx, attachmentIDsFromList(attachments)); err != nil { + return nil, errors.Wrap(err, "failed to delete memo attachments") + } + if err := deleteMemoRelationsTx(ctx, tx, memoIDs); err != nil { + return nil, errors.Wrap(err, "failed to delete incident memo relations") + } + return attachments, nil +} + +func listMySQLMemoSetAttachments(ctx context.Context, tx *sql.Tx, memoIDs []int32) ([]*store.Attachment, error) { + attachments := make([]*store.Attachment, 0) + seen := make(map[int32]struct{}) + for _, batch := range deleteUserBatches(memoIDs, deleteUserBatchSize) { + clause, args := deleteUserInClause(1, batch) + if err := appendDeleteUserAttachments(ctx, tx, `SELECT id, uid, creator_id, memo_id, storage_type, reference, payload + FROM attachment WHERE memo_id IN `+clause+` ORDER BY id`, args, seen, &attachments); err != nil { + return nil, err + } + } + return attachments, nil +} + +func deleteMySQLMemoSetShares(ctx context.Context, tx *sql.Tx, memoIDs []int32) error { + for _, batch := range deleteUserBatches(memoIDs, deleteUserBatchSize) { + clause, args := deleteUserInClause(1, batch) + if _, err := tx.ExecContext(ctx, "DELETE FROM memo_share WHERE memo_id IN "+clause, args...); err != nil { + return err + } + } + return nil +} diff --git a/store/db/mysql/user.go b/store/db/mysql/user.go index 128d1a6d..4afce884 100644 --- a/store/db/mysql/user.go +++ b/store/db/mysql/user.go @@ -2,6 +2,7 @@ package mysql import ( "context" + "database/sql" "fmt" "strings" @@ -34,6 +35,16 @@ func (d *DB) CreateUser(ctx context.Context, create *store.User) (*store.User, e } func (d *DB) UpdateUser(ctx context.Context, update *store.UpdateUser) (*store.User, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if update.RowStatus != nil && *update.RowStatus == store.Archived { + if err := validateMySQLUserArchive(ctx, tx, update.ID); err != nil { + return nil, err + } + } set, args := []string{}, []any{} if v := update.UpdatedTs; v != nil { set, args = append(set, "`updated_ts` = FROM_UNIXTIME(?)"), append(args, *v) @@ -65,17 +76,49 @@ func (d *DB) UpdateUser(ctx context.Context, update *store.UpdateUser) (*store.U args = append(args, update.ID) query := "UPDATE `user` SET " + strings.Join(set, ", ") + " WHERE `id` = ?" - if _, err := d.db.ExecContext(ctx, query, args...); err != nil { + if _, err := tx.ExecContext(ctx, query, args...); err != nil { return nil, err } - - user, err := d.GetUser(ctx, &store.FindUser{ID: &update.ID}) - if err != nil { + user := &store.User{} + if err := tx.QueryRowContext(ctx, `SELECT id, username, role, email, nickname, password_hash, avatar_url, description, + UNIX_TIMESTAMP(created_ts), UNIX_TIMESTAMP(updated_ts), row_status FROM user WHERE id = ?`, update.ID).Scan( + &user.ID, &user.Username, &user.Role, &user.Email, &user.Nickname, &user.PasswordHash, &user.AvatarURL, + &user.Description, &user.CreatedTs, &user.UpdatedTs, &user.RowStatus, + ); err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { return nil, err } return user, nil } +func validateMySQLUserArchive(ctx context.Context, tx *sql.Tx, userID int32) error { + var current store.RowStatus + if err := tx.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", userID).Scan(¤t); err != nil { + return err + } + if current != store.Normal { + return nil + } + var wouldLoseAdmin bool + if err := tx.QueryRowContext(ctx, `SELECT EXISTS( + SELECT 1 FROM space_member target + JOIN space s ON s.id = target.space_id + WHERE target.user_id = ? AND target.role = 'ADMIN' + AND NOT EXISTS ( + SELECT 1 FROM space_member other JOIN user u ON u.id = other.user_id + WHERE other.space_id = target.space_id AND other.user_id <> ? + AND other.role = 'ADMIN' AND u.row_status = 'NORMAL' + ))`, userID, userID).Scan(&wouldLoseAdmin); err != nil { + return err + } + if wouldLoseAdmin { + return store.ErrLastSpaceAdmin + } + return nil +} + func (d *DB) ListUsers(ctx context.Context, find *store.FindUser) ([]*store.User, error) { where, args := []string{"1 = 1"}, []any{} orderBy := []string{"`created_ts` DESC", "`row_status` DESC", "`id` DESC"} diff --git a/store/db/mysql/user_delete.go b/store/db/mysql/user_delete.go index e103941a..310d6dc0 100644 --- a/store/db/mysql/user_delete.go +++ b/store/db/mysql/user_delete.go @@ -29,6 +29,19 @@ func (d *DB) DeleteUser(ctx context.Context, delete *store.DeleteUser) (*store.D defer func() { _ = tx.Rollback() }() + var userID int32 + if err := tx.QueryRowContext(ctx, "SELECT id FROM user WHERE id = ?", delete.ID).Scan(&userID); errors.Is(err, sql.ErrNoRows) { + return &store.DeleteUserResult{}, nil + } else if err != nil { + return nil, errors.Wrap(err, "failed to read user") + } + var membershipCount int + if err := tx.QueryRowContext(ctx, "SELECT COUNT(*) FROM space_member WHERE user_id = ?", delete.ID).Scan(&membershipCount); err != nil { + return nil, errors.Wrap(err, "failed to check user space memberships") + } + if membershipCount != 0 { + return nil, store.ErrUserHasSpaceMembership + } targets, err := collectDeleteUserTargets(ctx, tx, delete.ID) if err != nil { @@ -56,7 +69,7 @@ func (d *DB) DeleteUser(ctx context.Context, delete *store.DeleteUser) (*store.D func collectDeleteUserTargets(ctx context.Context, tx *sql.Tx, userID int32) (*deleteUserTargetSet, error) { targets := &deleteUserTargetSet{} - memoIDs, err := listDeleteUserMemoTree(ctx, tx, userID) + memoIDs, err := listDeleteUserMemos(ctx, tx, userID) if err != nil { return nil, err } @@ -75,7 +88,7 @@ func collectDeleteUserTargets(ctx context.Context, tx *sql.Tx, userID int32) (*d } targets.userSettingKeys = userSettingKeys - inboxIDs, err := listDeleteUserInboxIDs(ctx, tx, userID, memoIDSet(memoIDs)) + inboxIDs, err := listDeleteUserInboxIDs(ctx, tx, userID) if err != nil { return nil, err } @@ -123,58 +136,8 @@ func deleteUserTargetsTx(ctx context.Context, tx *sql.Tx, userID int32, targets return nil } -func listDeleteUserMemoTree(ctx context.Context, tx *sql.Tx, userID int32) ([]int32, error) { - return listDeleteUserMemoTreeIterative(ctx, tx, userID) -} - -func listDeleteUserMemoTreeIterative(ctx context.Context, tx *sql.Tx, userID int32) ([]int32, error) { - roots, err := queryDeleteUserMemoIDs(ctx, tx, ` - SELECT id - FROM memo - WHERE creator_id = `+deleteUserPlaceholder(1), userID) - if err != nil { - return nil, err - } - - memoIDs := make([]int32, 0, len(roots)) - seen := make(map[int32]struct{}) - frontier := make([]int32, 0, len(roots)) - for _, id := range roots { - if _, exists := seen[id]; exists { - continue - } - seen[id] = struct{}{} - memoIDs = append(memoIDs, id) - frontier = append(frontier, id) - } - - for len(frontier) > 0 { - currentFrontier := frontier - nextFrontier := make([]int32, 0) - for _, batch := range deleteUserBatches(currentFrontier, deleteUserBatchSize) { - clause, args := deleteUserInClause(1, batch) - children, err := queryDeleteUserMemoIDs(ctx, tx, ` - SELECT child.id - FROM memo child - JOIN memo_relation rel ON rel.memo_id = child.id AND rel.type = 'COMMENT' - WHERE rel.related_memo_id IN `+clause, args...) - if err != nil { - return nil, err - } - - for _, id := range children { - if _, exists := seen[id]; exists { - continue - } - seen[id] = struct{}{} - memoIDs = append(memoIDs, id) - nextFrontier = append(nextFrontier, id) - } - } - frontier = nextFrontier - } - - return memoIDs, nil +func listDeleteUserMemos(ctx context.Context, tx *sql.Tx, userID int32) ([]int32, error) { + return queryDeleteUserMemoIDs(ctx, tx, `SELECT id FROM memo WHERE creator_id = ? ORDER BY id`, userID) } func queryDeleteUserMemoIDs(ctx context.Context, tx *sql.Tx, query string, args ...any) ([]int32, error) { @@ -298,24 +261,7 @@ func deleteUserSettingKeysQuery() string { return "SELECT `key` FROM `user_setting` WHERE user_id = " + deleteUserPlaceholder(1) } -func listDeleteUserInboxIDs(ctx context.Context, tx *sql.Tx, userID int32, memoIDSet map[int32]struct{}) ([]int32, error) { - directIDs, err := listDeleteUserDirectInboxIDs(ctx, tx, userID) - if err != nil { - return nil, err - } - inboxIDs := append([]int32{}, directIDs...) - if len(memoIDSet) == 0 { - return inboxIDs, nil - } - - memoIDs, err := listDeleteUserMemoReferencedInboxIDs(ctx, tx, userID, memoIDSet) - if err != nil { - return nil, err - } - return append(inboxIDs, memoIDs...), nil -} - -func listDeleteUserDirectInboxIDs(ctx context.Context, tx *sql.Tx, userID int32) ([]int32, error) { +func listDeleteUserInboxIDs(ctx context.Context, tx *sql.Tx, userID int32) ([]int32, error) { rows, err := tx.QueryContext(ctx, ` SELECT id FROM inbox @@ -341,76 +287,6 @@ func listDeleteUserDirectInboxIDs(ctx context.Context, tx *sql.Tx, userID int32) return inboxIDs, nil } -func listDeleteUserMemoReferencedInboxIDs(ctx context.Context, tx *sql.Tx, userID int32, memoIDSet map[int32]struct{}) ([]int32, error) { - rows, err := tx.QueryContext(ctx, ` - SELECT id, message - FROM inbox - WHERE sender_id <> `+deleteUserPlaceholder(1)+` - AND receiver_id <> `+deleteUserPlaceholder(2), userID, userID) - if err != nil { - return nil, err - } - defer rows.Close() - - inboxIDs := make([]int32, 0) - for rows.Next() { - var ( - inboxID int32 - messageRaw []byte - ) - if err := rows.Scan(&inboxID, &messageRaw); err != nil { - return nil, err - } - if len(messageRaw) == 0 { - continue - } - - message := &storepb.InboxMessage{} - if err := protojsonUnmarshaler.Unmarshal(messageRaw, message); err != nil { - return nil, err - } - if inboxMessageTouchesMemoSet(message, memoIDSet) { - inboxIDs = append(inboxIDs, inboxID) - } - } - if err := rows.Err(); err != nil { - return nil, err - } - - return inboxIDs, nil -} - -func inboxMessageTouchesMemoSet(message *storepb.InboxMessage, memoIDSet map[int32]struct{}) bool { - if message == nil { - return false - } - - switch message.Type { - case storepb.InboxMessage_MEMO_COMMENT: - payload := message.GetMemoComment() - if payload == nil { - return false - } - return memoIDInSet(payload.MemoId, memoIDSet) || memoIDInSet(payload.RelatedMemoId, memoIDSet) - case storepb.InboxMessage_MEMO_MENTION: - payload := message.GetMemoMention() - if payload == nil { - return false - } - return memoIDInSet(payload.MemoId, memoIDSet) || memoIDInSet(payload.RelatedMemoId, memoIDSet) - default: - return false - } -} - -func memoIDInSet(id int32, memoIDSet map[int32]struct{}) bool { - if id == 0 { - return false - } - _, exists := memoIDSet[id] - return exists -} - func deleteReactionsByMemoIDsTx(ctx context.Context, tx *sql.Tx, memoIDs []int32) error { for _, batch := range deleteUserBatches(memoIDs, deleteUserBatchSize) { clause, args := deleteUserInClause(1, batch) @@ -527,14 +403,6 @@ func deleteUserBatches[T any](values []T, size int) [][]T { return batches } -func memoIDSet(memoIDs []int32) map[int32]struct{} { - idSet := make(map[int32]struct{}, len(memoIDs)) - for _, id := range memoIDs { - idSet[id] = struct{}{} - } - return idSet -} - func attachmentIDsFromList(attachments []*store.Attachment) []int32 { ids := make([]int32, 0, len(attachments)) for _, attachment := range attachments { diff --git a/store/db/postgres/attachment.go b/store/db/postgres/attachment.go index 828e7f35..10507470 100644 --- a/store/db/postgres/attachment.go +++ b/store/db/postgres/attachment.go @@ -15,6 +15,35 @@ import ( ) func (d *DB) CreateAttachment(ctx context.Context, create *store.Attachment) (*store.Attachment, error) { + if create.Policy == nil { + return insertPostgresAttachment(ctx, d.db, create) + } + if create.MemoID == nil || create.CreatorID != create.Policy.ActorUserID { + return nil, store.ErrMemoPermissionDenied + } + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := validatePostgresMemoWritePolicy(ctx, tx, *create.MemoID, create.Policy, nil); err != nil { + return nil, err + } + attachment, err := insertPostgresAttachment(ctx, tx, create) + if err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return attachment, nil +} + +type postgresAttachmentQueryRower interface { + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func insertPostgresAttachment(ctx context.Context, executor postgresAttachmentQueryRower, create *store.Attachment) (*store.Attachment, error) { fields := []string{"uid", "filename", "blob", "type", "size", "creator_id", "memo_id", "storage_type", "reference", "payload"} storageType := "" if create.StorageType != storepb.AttachmentStorageType_ATTACHMENT_STORAGE_TYPE_UNSPECIFIED { @@ -31,7 +60,7 @@ func (d *DB) CreateAttachment(ctx context.Context, create *store.Attachment) (*s args := []any{create.UID, create.Filename, create.Blob, create.Type, create.Size, create.CreatorID, create.MemoID, storageType, create.Reference, payloadString} stmt := "INSERT INTO attachment (" + strings.Join(fields, ", ") + ") VALUES (" + placeholders(len(args)) + ") RETURNING id, created_ts, updated_ts" - if err := d.db.QueryRowContext(ctx, stmt, args...).Scan(&create.ID, &create.CreatedTs, &create.UpdatedTs); err != nil { + if err := executor.QueryRowContext(ctx, stmt, args...).Scan(&create.ID, &create.CreatedTs, &create.UpdatedTs); err != nil { return nil, err } return create, nil @@ -78,6 +107,22 @@ func (d *DB) ListAttachments(ctx context.Context, find *store.FindAttachment) ([ return nil, errors.Wrap(err, "failed to append filter conditions") } } + if access := find.Access; access != nil { + scopeClauses := []string{} + if access.UserID != nil { + activeHolder := placeholder(len(args) + 1) + args = append(args, *access.UserID) + creatorHolder := placeholder(len(args) + 1) + args = append(args, *access.UserID) + scopeClauses = append(scopeClauses, `(attachment.memo_id IS NULL AND EXISTS (SELECT 1 FROM "user" AS attachment_user WHERE attachment_user.id = `+activeHolder+` AND attachment_user.row_status = 'NORMAL') AND attachment.creator_id = `+creatorHolder+`)`) + } + scopeClauses = append(scopeClauses, "(attachment.memo_id IS NOT NULL AND "+postgresMemoAccessPredicate(access, "memo", "attachment_member", &args)+")") + if len(scopeClauses) == 0 { + where = append(where, "1 = 0") + } else { + where = append(where, "("+strings.Join(scopeClauses, " OR ")+")") + } + } fields := []string{ "attachment.id AS id", @@ -167,6 +212,36 @@ func (d *DB) ListAttachments(ctx context.Context, find *store.FindAttachment) ([ } func (d *DB) UpdateAttachment(ctx context.Context, update *store.UpdateAttachment) error { + if update.Policy == nil { + return applyPostgresAttachmentUpdate(ctx, d.db, update) + } + if update.MemoID != nil { + return store.ErrMemoMutationConflict + } + attachmentIDs := []int32{update.ID} + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer func() { _ = tx.Rollback() }() + attachments, err := listPostgresAttachmentSnapshots(ctx, tx, attachmentIDs) + if err != nil { + return err + } + memoIDs, err := store.ValidateAttachmentMutationTargets(update.Policy.ActorUserID, attachmentIDs, attachments) + if err != nil { + return err + } + if err := authorizePostgresAttachmentMutation(ctx, tx, update.Policy.ActorUserID, memoIDs, nil); err != nil { + return err + } + if err := applyPostgresAttachmentUpdate(ctx, tx, update); err != nil { + return err + } + return tx.Commit() +} + +func applyPostgresAttachmentUpdate(ctx context.Context, executor memoUpdateExecer, update *store.UpdateAttachment) error { set, args := []string{}, []any{} if v := update.UID; v != nil { @@ -189,9 +264,12 @@ func (d *DB) UpdateAttachment(ctx context.Context, update *store.UpdateAttachmen set, args = append(set, "payload = "+placeholder(len(args)+1)), append(args, string(bytes)) } + if len(set) == 0 { + return nil + } stmt := `UPDATE attachment SET ` + strings.Join(set, ", ") + ` WHERE id = ` + placeholder(len(args)+1) args = append(args, update.ID) - result, err := d.db.ExecContext(ctx, stmt, args...) + result, err := executor.ExecContext(ctx, stmt, args...) if err != nil { return err } @@ -202,15 +280,7 @@ func (d *DB) UpdateAttachment(ctx context.Context, update *store.UpdateAttachmen } func (d *DB) DeleteAttachment(ctx context.Context, delete *store.DeleteAttachment) error { - stmt := `DELETE FROM attachment WHERE id = $1` - result, err := d.db.ExecContext(ctx, stmt, delete.ID) - if err != nil { - return err - } - if _, err := result.RowsAffected(); err != nil { - return err - } - return nil + return d.DeleteAttachments(ctx, []*store.DeleteAttachment{delete}) } func (d *DB) DeleteAttachments(ctx context.Context, deletes []*store.DeleteAttachment) error { @@ -227,7 +297,6 @@ func (d *DB) DeleteAttachments(ctx context.Context, deletes []*store.DeleteAttac _ = tx.Rollback() } }() - stmt := `DELETE FROM attachment WHERE id = $1` for _, delete := range deletes { result, err := tx.ExecContext(ctx, stmt, delete.ID) diff --git a/store/db/postgres/attachment_delete.go b/store/db/postgres/attachment_delete.go new file mode 100644 index 00000000..9a2637a4 --- /dev/null +++ b/store/db/postgres/attachment_delete.go @@ -0,0 +1,118 @@ +package postgres + +import ( + "context" + "database/sql" + + "github.com/pkg/errors" + + "github.com/usememos/memos/store" +) + +func (d *DB) DeleteAttachmentsWithPolicy(ctx context.Context, policy *store.AttachmentDeletionPolicy, attachmentIDs []int32) error { + if policy == nil || policy.ActorUserID <= 0 { + return store.ErrMemoPermissionDenied + } + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return errors.Wrap(err, "failed to begin attachment delete transaction") + } + defer func() { _ = tx.Rollback() }() + + attachments, err := listPostgresAttachmentSnapshots(ctx, tx, attachmentIDs) + if err != nil { + return errors.Wrap(err, "failed to read attachment delete targets") + } + memoIDs, err := store.ValidateAttachmentMutationTargets(policy.ActorUserID, attachmentIDs, attachments) + if err != nil { + return err + } + if err := store.ValidateAttachmentDeletionMemoSnapshots(memoIDs, policy.ExpectedMemoContents); err != nil { + return err + } + if err := authorizePostgresAttachmentMutation(ctx, tx, policy.ActorUserID, memoIDs, policy.ExpectedMemoContents); err != nil { + return err + } + + for _, attachmentID := range attachmentIDs { + result, err := tx.ExecContext(ctx, "DELETE FROM attachment WHERE id = $1", attachmentID) + if err != nil { + return errors.Wrap(err, "failed to delete attachment") + } + if rows, err := result.RowsAffected(); err != nil { + return errors.Wrap(err, "failed to count deleted attachment") + } else if rows != 1 { + return store.ErrMemoMutationConflict + } + } + if err := tx.Commit(); err != nil { + return errors.Wrap(err, "failed to commit attachment deletion") + } + return nil +} + +func listPostgresAttachmentSnapshots(ctx context.Context, tx *sql.Tx, attachmentIDs []int32) ([]*store.Attachment, error) { + attachments := make([]*store.Attachment, 0, len(attachmentIDs)) + seen := make(map[int32]struct{}, len(attachmentIDs)) + for _, batch := range deleteUserBatches(attachmentIDs, deleteUserBatchSize) { + clause, args := deleteUserInClause(1, batch) + if err := appendDeleteUserAttachments(ctx, tx, `SELECT id, uid, creator_id, memo_id, storage_type, reference, payload + FROM attachment WHERE id IN `+clause+` ORDER BY id`, args, seen, &attachments); err != nil { + return nil, err + } + } + return attachments, nil +} + +func authorizePostgresAttachmentMutation( + ctx context.Context, + tx *sql.Tx, + actorUserID int32, + memoIDs []int32, + expectedMemoContents map[int32]string, +) error { + var actorStatus store.RowStatus + if err := tx.QueryRowContext(ctx, `SELECT row_status FROM "user" WHERE id = $1`, actorUserID).Scan(&actorStatus); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrMemoPermissionDenied + } + return errors.Wrap(err, "failed to read attachment actor") + } + if actorStatus != store.Normal { + return store.ErrMemoPermissionDenied + } + + writePolicy := &store.MemoWritePolicy{ActorUserID: actorUserID} + for _, memoID := range memoIDs { + snapshot := &store.MemoWriteSnapshot{} + var memoSpace sql.NullInt64 + var content string + if err := tx.QueryRowContext(ctx, `SELECT creator_id, row_status, space_id, visibility, content + FROM memo WHERE id = $1`, memoID).Scan( + &snapshot.CreatorID, &snapshot.RowStatus, &memoSpace, &snapshot.Visibility, &content, + ); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrMemoMutationConflict + } + return errors.Wrap(err, "failed to read attachment memo") + } + snapshot.SpaceID = store.NullInt32Pointer(memoSpace) + if snapshot.SpaceID != nil { + var err error + snapshot.SourceSpaceExists, snapshot.SourceMemberActive, err = readPostgresMemoSpaceState(ctx, tx, *snapshot.SpaceID, actorUserID) + if err != nil { + return errors.Wrap(err, "failed to read attachment memo space state") + } + } + if err := store.ValidateMemoWriteSnapshot(writePolicy, nil, snapshot); err != nil { + return err + } + if expectedMemoContents != nil { + expectedContent, ok := expectedMemoContents[memoID] + if !ok || content != expectedContent { + return store.ErrMemoMutationConflict + } + } + } + return nil +} diff --git a/store/db/postgres/memo.go b/store/db/postgres/memo.go index 0e4d614f..dfcadb3b 100644 --- a/store/db/postgres/memo.go +++ b/store/db/postgres/memo.go @@ -2,6 +2,7 @@ package postgres import ( "context" + "database/sql" "fmt" "strings" @@ -14,16 +15,34 @@ import ( ) func (d *DB) CreateMemo(ctx context.Context, create *store.Memo) (*store.Memo, error) { - fields := []string{"uid", "creator_id", "content", "visibility", "payload"} + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := validatePostgresMemoCreate(ctx, tx, create); err != nil { + return nil, err + } + if err := insertPostgresMemo(ctx, tx, create); err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return create, nil +} + +func insertPostgresMemo(ctx context.Context, tx *sql.Tx, create *store.Memo) error { + fields := []string{"uid", "creator_id", "content", "visibility", "payload", "space_id"} payload := "{}" if create.Payload != nil { payloadBytes, err := protojson.Marshal(create.Payload) if err != nil { - return nil, err + return err } payload = string(payloadBytes) } - args := []any{create.UID, create.CreatorID, create.Content, create.Visibility, payload} + args := []any{create.UID, create.CreatorID, create.Content, create.Visibility, payload, create.SpaceID} // Add custom timestamps if provided if create.CreatedTs != 0 { @@ -36,16 +55,49 @@ func (d *DB) CreateMemo(ctx context.Context, create *store.Memo) (*store.Memo, e } stmt := "INSERT INTO memo (" + strings.Join(fields, ", ") + ") VALUES (" + placeholders(len(args)) + ") RETURNING id, created_ts, updated_ts, row_status" - if err := d.db.QueryRowContext(ctx, stmt, args...).Scan( + if err := tx.QueryRowContext(ctx, stmt, args...).Scan( &create.ID, &create.CreatedTs, &create.UpdatedTs, &create.RowStatus, ); err != nil { - return nil, err + return err } + return nil +} - return create, nil +func validatePostgresMemoCreate(ctx context.Context, tx *sql.Tx, create *store.Memo) error { + var actorStatus store.RowStatus + err := tx.QueryRowContext(ctx, `SELECT row_status FROM "user" WHERE id = $1`, create.CreatorID).Scan(&actorStatus) + if errors.Is(err, sql.ErrNoRows) || (err == nil && actorStatus != store.Normal) { + return store.ErrMemoSpaceMembershipRequired + } + if err != nil { + return err + } + if create.SpaceID != nil { + return validatePostgresMemoSpaceMember(ctx, tx, *create.SpaceID, create.CreatorID) + } + return nil +} + +func validatePostgresMemoSpaceMember(ctx context.Context, tx *sql.Tx, spaceID, userID int32) error { + var spaceExists, memberActive bool + err := tx.QueryRowContext(ctx, `SELECT + EXISTS(SELECT 1 FROM space WHERE id = $1), + EXISTS(SELECT 1 FROM space_member sm JOIN "user" u ON u.id = sm.user_id + WHERE sm.space_id = $1 AND sm.user_id = $2 AND sm.role IN ('ADMIN', 'USER') AND u.row_status = 'NORMAL')`, + spaceID, userID).Scan(&spaceExists, &memberActive) + if err != nil { + return err + } + if !spaceExists { + return store.ErrMemoSpaceNotWritable + } + if !memberActive { + return store.ErrMemoSpaceMembershipRequired + } + return nil } func (d *DB) ListMemos(ctx context.Context, find *store.FindMemo) ([]*store.Memo, error) { @@ -94,8 +146,30 @@ func (d *DB) ListMemos(ctx context.Context, find *store.FindMemo) ([]*store.Memo } where = append(where, fmt.Sprintf("memo.visibility in (%s)", strings.Join(holders, ", "))) } + if v := find.SpaceID; v != nil { + where, args = append(where, "memo.space_id = "+placeholder(len(args)+1)), append(args, *v) + } + if v := find.CommentContextMemoID; v != nil { + contextHolder := placeholder(len(args) + 1) + args = append(args, *v) + where = append(where, `EXISTS ( + SELECT 1 FROM memo_relation AS comment_context + WHERE comment_context.memo_id = memo.id + AND comment_context.related_memo_id = `+contextHolder+` + AND comment_context.type = 'COMMENT' + )`) + } + if find.Unassigned { + where = append(where, "memo.space_id IS NULL") + } + if access := find.Access; access != nil { + where = append(where, postgresMemoAccessPredicate(access, "memo", "access_member", &args)) + } if find.ExcludeComments { - where = append(where, "memo_relation.related_memo_id IS NULL") + where = append(where, `NOT EXISTS ( + SELECT 1 FROM memo_relation AS comment_relation + WHERE comment_relation.memo_id = memo.id AND comment_relation.type = 'COMMENT' + )`) } order := "DESC" @@ -123,7 +197,12 @@ func (d *DB) ListMemos(ctx context.Context, find *store.FindMemo) ([]*store.Memo `memo.visibility AS visibility`, `memo.pinned AS pinned`, `memo.payload AS payload`, - `CASE WHEN parent_memo.uid IS NOT NULL THEN parent_memo.uid ELSE NULL END AS parent_uid`, + `memo.space_id AS space_id`, + `(SELECT parent_memo.uid + FROM memo_relation AS parent_relation + JOIN memo AS parent_memo ON parent_memo.id = parent_relation.related_memo_id + WHERE parent_relation.memo_id = memo.id AND parent_relation.type = 'COMMENT' + ORDER BY parent_memo.id LIMIT 1) AS parent_uid`, } if !find.ExcludeContent { fields = append(fields, `memo.content AS content`) @@ -132,8 +211,6 @@ func (d *DB) ListMemos(ctx context.Context, find *store.FindMemo) ([]*store.Memo query := `SELECT ` + strings.Join(fields, ", ") + ` FROM memo LEFT JOIN "user" AS memo_creator ON memo.creator_id = memo_creator.id - LEFT JOIN memo_relation ON memo.id = memo_relation.memo_id AND memo_relation.type = 'COMMENT' - LEFT JOIN memo AS parent_memo ON memo_relation.related_memo_id = parent_memo.id WHERE ` + strings.Join(where, " AND ") + ` ORDER BY ` + strings.Join(orderBy, ", ") if find.Limit != nil { @@ -163,6 +240,7 @@ func (d *DB) ListMemos(ctx context.Context, find *store.FindMemo) ([]*store.Memo &memo.Visibility, &memo.Pinned, &payloadBytes, + &memo.SpaceID, &memo.ParentUID, } if !find.ExcludeContent { @@ -200,7 +278,21 @@ func (d *DB) GetMemo(ctx context.Context, find *store.FindMemo) (*store.Memo, er } func (d *DB) UpdateMemo(ctx context.Context, update *store.UpdateMemo) error { - return applyMemoUpdate(ctx, d.db, update) + if update.Policy == nil { + return applyMemoUpdate(ctx, d.db, update) + } + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer func() { _ = tx.Rollback() }() + if err := validatePostgresMemoWritePolicy(ctx, tx, update.ID, update.Policy, update); err != nil { + return err + } + if err := applyMemoUpdate(ctx, tx, update); err != nil { + return err + } + return tx.Commit() } func (d *DB) DeleteMemo(ctx context.Context, delete *store.DeleteMemo) error { diff --git a/store/db/postgres/memo_access.go b/store/db/postgres/memo_access.go new file mode 100644 index 00000000..bae03dfb --- /dev/null +++ b/store/db/postgres/memo_access.go @@ -0,0 +1,50 @@ +package postgres + +import ( + "fmt" + "strings" + + "github.com/usememos/memos/store" +) + +// postgresMemoAccessPredicate builds the canonical memo-local read predicate +// for memoAlias and appends its bind values to args. Callers supply distinct +// aliases when the predicate is embedded more than once in a query. +func postgresMemoAccessPredicate(access *store.MemoAccessScope, memoAlias, memberAlias string, args *[]any) string { + clauses := []string{} + if access.AllowPublic { + clauses = append(clauses, memoAlias+".visibility = 'PUBLIC'") + } + if access.UserID != nil { + activeHolder := placeholder(len(*args) + 1) + *args = append(*args, *access.UserID) + authenticatedClauses := []string{} + + privateHolder := placeholder(len(*args) + 1) + *args = append(*args, *access.UserID) + authenticatedClauses = append(authenticatedClauses, "("+memoAlias+".visibility = 'PRIVATE' AND "+memoAlias+".creator_id = "+privateHolder+")") + if access.AllowProtected { + authenticatedClauses = append(authenticatedClauses, memoAlias+".visibility = 'PROTECTED'") + } + memberHolder := placeholder(len(*args) + 1) + *args = append(*args, *access.UserID) + authenticatedClauses = append(authenticatedClauses, "("+memoAlias+".visibility = 'SPACE' AND EXISTS (SELECT 1 FROM space_member AS "+memberAlias+" WHERE "+memberAlias+".space_id = "+memoAlias+".space_id AND "+memberAlias+".user_id = "+memberHolder+" AND "+memberAlias+".role IN ('ADMIN', 'USER')))") + + clauses = append(clauses, `(EXISTS (SELECT 1 FROM "user" AS access_user WHERE access_user.id = `+activeHolder+` AND access_user.row_status = 'NORMAL') AND (`+strings.Join(authenticatedClauses, " OR ")+`))`) + } + if len(clauses) == 0 { + return "1 = 0" + } + + validMemo := "(" + memoAlias + ".visibility IN ('PUBLIC', 'PROTECTED', 'PRIVATE', 'SPACE')" + + ` AND EXISTS (SELECT 1 FROM "user" AS valid_creator WHERE valid_creator.id = ` + memoAlias + `.creator_id AND valid_creator.row_status IN ('NORMAL', 'ARCHIVED'))` + + " AND (" + memoAlias + ".visibility <> 'SPACE' OR (" + memoAlias + ".space_id IS NOT NULL" + + " AND EXISTS (SELECT 1 FROM space AS valid_space WHERE valid_space.id = " + memoAlias + ".space_id))))" + validState := memoAlias + ".row_status = 'NORMAL'" + if access.UserID != nil { + targetStateHolder := placeholder(len(*args) + 1) + *args = append(*args, *access.UserID) + validState = fmt.Sprintf("(%s.row_status = 'NORMAL' OR (%s.row_status = 'ARCHIVED' AND %s.creator_id = %s))", memoAlias, memoAlias, memoAlias, targetStateHolder) + } + return "(" + strings.Join(clauses, " OR ") + ") AND " + validMemo + " AND " + validState +} diff --git a/store/db/postgres/memo_attachment.go b/store/db/postgres/memo_attachment.go index 7b3b195f..3ef8edf8 100644 --- a/store/db/postgres/memo_attachment.go +++ b/store/db/postgres/memo_attachment.go @@ -20,6 +20,44 @@ func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation defer func() { _ = tx.Rollback() }() + if err := validatePostgresMemoRelationEndpoints(ctx, tx, mutation); err != nil { + return err + } + if create := mutation.MemoCreate; create != nil { + if err := validatePostgresMemoCreate(ctx, tx, create); err != nil { + return err + } + if mutation.CommentContextMemoID != nil { + if err := authorizePostgresMemoComment(ctx, tx, *mutation.CommentContextMemoID, create.CreatorID); err != nil { + return err + } + } + if err := insertPostgresMemo(ctx, tx, create); err != nil { + return err + } + mutation.MemoID = create.ID + mutation.MemoCreatorID = create.CreatorID + mutation.ExpectedMemoContent = create.Content + for _, relation := range mutation.ReferenceRelations { + if relation != nil { + relation.MemoID = create.ID + } + } + if mutation.CommentContextMemoID != nil { + if err := insertPostgresMemoCommentRelation(ctx, tx, create.ID, *mutation.CommentContextMemoID); err != nil { + return err + } + } + } + policy := mutation.Policy + if policy == nil && mutation.MemoUpdate != nil { + policy = mutation.MemoUpdate.Policy + } + if policy != nil { + if err := validatePostgresMemoWritePolicy(ctx, tx, mutation.MemoID, policy, mutation.MemoUpdate); err != nil { + return err + } + } var creatorID int32 var content string @@ -32,6 +70,18 @@ func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation if creatorID != mutation.MemoCreatorID || content != mutation.ExpectedMemoContent { return errors.Wrap(store.ErrMemoMutationConflict, "memo changed while applying mutation") } + removedAttachments, err := listPostgresAttachmentSnapshots(ctx, tx, mutation.RemovedAttachmentIDs) + if err != nil { + return errors.Wrap(err, "failed to read removed attachments") + } + if len(removedAttachments) != len(mutation.RemovedAttachmentIDs) { + return errors.Wrap(store.ErrMemoMutationConflict, "removed attachment no longer exists") + } + for _, attachment := range removedAttachments { + if attachment.CreatorID != mutation.MemoCreatorID || attachment.MemoID == nil || *attachment.MemoID != mutation.MemoID { + return errors.Wrap(store.ErrMemoMutationConflict, "attachment is no longer removable from the memo") + } + } for _, binding := range mutation.Bindings { var attachmentCreatorID int32 @@ -53,13 +103,14 @@ func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation return errors.Wrap(err, "failed to bind attachment") } } - - for _, attachmentID := range mutation.RemovedAttachmentIDs { - result, err := tx.ExecContext(ctx, `UPDATE attachment SET memo_id = NULL WHERE id = $1 AND memo_id = $2`, attachmentID, mutation.MemoID) + for _, attachment := range removedAttachments { + result, err := tx.ExecContext(ctx, `DELETE FROM attachment WHERE id = $1 AND memo_id = $2`, attachment.ID, mutation.MemoID) if err != nil { - return errors.Wrap(err, "failed to detach attachment") + return errors.Wrap(err, "failed to delete removed attachment") } - if rows, err := result.RowsAffected(); err != nil || rows != 1 { + if rows, err := result.RowsAffected(); err != nil { + return errors.Wrap(err, "failed to count deleted removed attachment") + } else if rows != 1 { return errors.Wrap(store.ErrMemoMutationConflict, "attachment is no longer bound to the memo") } } @@ -93,6 +144,17 @@ func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation return nil } +func insertPostgresMemoCommentRelation(ctx context.Context, tx *sql.Tx, memoID, contextMemoID int32) error { + if memoID <= 0 || contextMemoID <= 0 || memoID == contextMemoID { + return errors.New("invalid COMMENT relation") + } + if _, err := tx.ExecContext(ctx, `INSERT INTO memo_relation (memo_id, related_memo_id, type) VALUES ($1, $2, $3)`, + memoID, contextMemoID, store.MemoRelationComment); err != nil { + return errors.Wrap(err, "failed to insert COMMENT relation") + } + return nil +} + func replaceMemoReferenceRelations(ctx context.Context, tx *sql.Tx, memoID int32, relations []*store.MemoRelation) error { if _, err := tx.ExecContext(ctx, `DELETE FROM memo_relation WHERE memo_id = $1 AND type = $2`, memoID, store.MemoRelationReference); err != nil { return errors.Wrap(err, "failed to delete memo reference relations") @@ -150,6 +212,11 @@ func applyMemoUpdate(ctx context.Context, executor memoUpdateExecer, update *sto } appendValue("payload", string(payload)) } + if update.ClearSpace { + set = append(set, "space_id = NULL") + } else if v := update.SpaceID; v != nil { + appendValue("space_id", *v) + } if len(set) == 0 { return nil } diff --git a/store/db/postgres/memo_comment.go b/store/db/postgres/memo_comment.go new file mode 100644 index 00000000..853cbf7e --- /dev/null +++ b/store/db/postgres/memo_comment.go @@ -0,0 +1,53 @@ +package postgres + +import ( + "context" + "database/sql" + stderrors "errors" + + "github.com/usememos/memos/store" +) + +func authorizePostgresMemoComment(ctx context.Context, tx *sql.Tx, contextMemoID, actorUserID int32) error { + snapshot, err := readPostgresMemoParticipation(ctx, tx, contextMemoID, actorUserID) + if err != nil { + if stderrors.Is(err, sql.ErrNoRows) || stderrors.Is(err, store.ErrMemoMutationConflict) { + return store.ErrMemoSpaceNotWritable + } + return err + } + return store.ValidateMemoCommentAuthorization(snapshot) +} + +// readPostgresMemoParticipation resolves the current actor, Space, membership, +// and memo state shared by comment and reaction participation. +func readPostgresMemoParticipation(ctx context.Context, tx *sql.Tx, memoID, actorUserID int32) (*store.MemoCommentAuthorizationSnapshot, error) { + userStatuses, err := readPostgresUserStatuses(ctx, tx, actorUserID) + if err != nil { + return nil, err + } + + snapshot := &store.MemoCommentAuthorizationSnapshot{ + ActorUserID: actorUserID, + ActorActive: userStatuses[actorUserID] == store.Normal, + ContextID: memoID, + } + var contextSpace sql.NullInt64 + err = tx.QueryRowContext(ctx, `SELECT creator_id, row_status, visibility, space_id + FROM memo WHERE id = $1`, memoID).Scan( + &snapshot.ContextCreatorID, &snapshot.ContextRowStatus, &snapshot.ContextVisibility, &contextSpace, + ) + if err != nil { + return nil, err + } + snapshot.ContextSpaceID = store.NullInt32Pointer(contextSpace) + if snapshot.ContextSpaceID != nil { + if err := tx.QueryRowContext(ctx, `SELECT + EXISTS(SELECT 1 FROM space WHERE id = $1), + EXISTS(SELECT 1 FROM space_member WHERE space_id = $1 AND user_id = $2 AND role IN ('ADMIN', 'USER'))`, + *snapshot.ContextSpaceID, actorUserID).Scan(&snapshot.ContextSpaceExists, &snapshot.ContextMemberActive); err != nil { + return nil, err + } + } + return snapshot, nil +} diff --git a/store/db/postgres/memo_delete_policy.go b/store/db/postgres/memo_delete_policy.go new file mode 100644 index 00000000..96e26bab --- /dev/null +++ b/store/db/postgres/memo_delete_policy.go @@ -0,0 +1,60 @@ +package postgres + +import ( + "context" + "database/sql" + + "github.com/pkg/errors" + + "github.com/usememos/memos/store" +) + +func (d *DB) DeleteMemoWithPolicy(ctx context.Context, delete *store.DeleteMemoWithPolicy) (*store.DeleteMemoWithPolicyResult, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, errors.Wrap(err, "failed to begin memo delete transaction") + } + defer func() { _ = tx.Rollback() }() + + var actorStatus store.RowStatus + if err := tx.QueryRowContext(ctx, `SELECT row_status FROM "user" WHERE id = $1`, delete.ActorUserID).Scan(&actorStatus); errors.Is(err, sql.ErrNoRows) { + return nil, store.ErrMemoPermissionDenied + } else if err != nil { + return nil, errors.Wrap(err, "failed to read memo deletion actor") + } else if actorStatus != store.Normal { + return nil, store.ErrMemoPermissionDenied + } + + var creatorID int32 + var rowStatus store.RowStatus + var visibility store.Visibility + var memoSpace sql.NullInt64 + if err := tx.QueryRowContext(ctx, `SELECT creator_id, row_status, visibility, space_id FROM memo WHERE id = $1`, delete.MemoID).Scan( + &creatorID, &rowStatus, &visibility, &memoSpace, + ); errors.Is(err, sql.ErrNoRows) { + return nil, store.ErrMemoMutationConflict + } else if err != nil { + return nil, errors.Wrap(err, "failed to read memo") + } + if creatorID != delete.ActorUserID { + return nil, store.ErrMemoPermissionDenied + } + memoSpaceID := store.NullInt32Pointer(memoSpace) + spaceExists, actorMember := false, false + if memoSpaceID != nil { + spaceExists, actorMember, err = readPostgresMemoSpaceState(ctx, tx, *memoSpaceID, delete.ActorUserID) + if err != nil { + return nil, errors.Wrap(err, "failed to read memo space state") + } + } + actorCanRead := store.MemoDeleteActorCanRead(rowStatus, visibility, memoSpaceID, spaceExists, actorMember) + + attachments, err := deletePostgresMemoSetTx(ctx, tx, []int32{delete.MemoID}) + if err != nil { + return nil, errors.Wrap(err, "failed to delete memo set") + } + if err := tx.Commit(); err != nil { + return nil, errors.Wrap(err, "failed to commit memo delete transaction") + } + return &store.DeleteMemoWithPolicyResult{ActorCanRead: actorCanRead, Attachments: attachments}, nil +} diff --git a/store/db/postgres/memo_policy.go b/store/db/postgres/memo_policy.go new file mode 100644 index 00000000..6bc1b5c3 --- /dev/null +++ b/store/db/postgres/memo_policy.go @@ -0,0 +1,87 @@ +package postgres + +import ( + "context" + "database/sql" + stderrors "errors" + + "github.com/usememos/memos/store" +) + +func validatePostgresMemoWritePolicy(ctx context.Context, tx *sql.Tx, memoID int32, policy *store.MemoWritePolicy, update *store.UpdateMemo) error { + var actorStatus store.RowStatus + if err := tx.QueryRowContext(ctx, `SELECT row_status FROM "user" WHERE id = $1`, policy.ActorUserID).Scan(&actorStatus); stderrors.Is(err, sql.ErrNoRows) { + return store.ErrMemoSpaceMembershipRequired + } else if err != nil { + return err + } else if actorStatus != store.Normal { + return store.ErrMemoSpaceMembershipRequired + } + + snapshot := new(store.MemoWriteSnapshot) + var sourceSpace sql.NullInt64 + if err := tx.QueryRowContext(ctx, `SELECT creator_id, row_status, space_id, visibility FROM memo WHERE id = $1`, memoID).Scan( + &snapshot.CreatorID, &snapshot.RowStatus, &sourceSpace, &snapshot.Visibility, + ); err != nil { + if stderrors.Is(err, sql.ErrNoRows) { + return store.ErrMemoMutationConflict + } + return err + } + snapshot.SpaceID = store.NullInt32Pointer(sourceSpace) + if err := populatePostgresMemoPolicySpaceState(ctx, tx, policy.ActorUserID, update, snapshot); err != nil { + return err + } + + if update != nil && update.Visibility != nil && *update.Visibility == store.SpaceAudience { + var shareID int32 + err := tx.QueryRowContext(ctx, `SELECT id FROM memo_share + WHERE memo_id = $1 AND (expires_ts IS NULL OR expires_ts > EXTRACT(EPOCH FROM NOW())) + LIMIT 1`, memoID).Scan(&shareID) + snapshot.HasActiveShare = err == nil + if err != nil && !stderrors.Is(err, sql.ErrNoRows) { + return err + } + } + return store.ValidateMemoWriteSnapshot(policy, update, snapshot) +} + +func populatePostgresMemoPolicySpaceState( + ctx context.Context, + tx *sql.Tx, + actorUserID int32, + update *store.UpdateMemo, + snapshot *store.MemoWriteSnapshot, +) error { + if snapshot.SpaceID != nil { + var err error + snapshot.SourceSpaceExists, snapshot.SourceMemberActive, err = readPostgresMemoSpaceState(ctx, tx, *snapshot.SpaceID, actorUserID) + if err != nil { + return err + } + } + if update != nil && update.SpaceID != nil { + if snapshot.SpaceID != nil && *snapshot.SpaceID == *update.SpaceID { + snapshot.TargetSpaceExists = snapshot.SourceSpaceExists + snapshot.TargetMemberActive = snapshot.SourceMemberActive + return nil + } + var err error + snapshot.TargetSpaceExists, snapshot.TargetMemberActive, err = readPostgresMemoSpaceState(ctx, tx, *update.SpaceID, actorUserID) + if err != nil { + return err + } + } + return nil +} + +func readPostgresMemoSpaceState(ctx context.Context, tx *sql.Tx, spaceID, actorUserID int32) (bool, bool, error) { + var spaceExists, memberActive bool + if err := tx.QueryRowContext(ctx, `SELECT + EXISTS(SELECT 1 FROM space WHERE id = $1), + EXISTS(SELECT 1 FROM space_member WHERE space_id = $1 AND user_id = $2 AND role IN ('ADMIN', 'USER'))`, + spaceID, actorUserID).Scan(&spaceExists, &memberActive); err != nil { + return false, false, err + } + return spaceExists, memberActive, nil +} diff --git a/store/db/postgres/memo_relation.go b/store/db/postgres/memo_relation.go index 68bd2216..6cff5cac 100644 --- a/store/db/postgres/memo_relation.go +++ b/store/db/postgres/memo_relation.go @@ -155,6 +155,9 @@ func (d *DB) ListMemoRelations(ctx context.Context, find *store.FindMemoRelation } func (d *DB) DeleteMemoRelation(ctx context.Context, delete *store.DeleteMemoRelation) error { + if err := store.ValidateMemoRelationDelete(delete); err != nil { + return err + } where, args := []string{"1 = 1"}, []any{} if delete.MemoID != nil { where, args = append(where, "memo_id = "+placeholder(len(args)+1)), append(args, *delete.MemoID) @@ -162,9 +165,7 @@ func (d *DB) DeleteMemoRelation(ctx context.Context, delete *store.DeleteMemoRel if delete.RelatedMemoID != nil { where, args = append(where, "related_memo_id = "+placeholder(len(args)+1)), append(args, *delete.RelatedMemoID) } - if delete.Type != nil { - where, args = append(where, "type = "+placeholder(len(args)+1)), append(args, *delete.Type) - } + where, args = append(where, "type = "+placeholder(len(args)+1)), append(args, *delete.Type) stmt := `DELETE FROM memo_relation WHERE ` + strings.Join(where, " AND ") result, err := d.db.ExecContext(ctx, stmt, args...) if err != nil { diff --git a/store/db/postgres/memo_relation_policy.go b/store/db/postgres/memo_relation_policy.go new file mode 100644 index 00000000..fd2ce7d9 --- /dev/null +++ b/store/db/postgres/memo_relation_policy.go @@ -0,0 +1,96 @@ +package postgres + +import ( + "context" + "database/sql" + stderrors "errors" + + "github.com/usememos/memos/store" +) + +type postgresRelationMemoState struct { + id int32 + creatorID int32 + rowStatus store.RowStatus + visibility store.Visibility + spaceID *int32 +} + +func validatePostgresMemoRelationEndpoints(ctx context.Context, tx *sql.Tx, mutation *store.MemoMutation) error { + if !mutation.ReplaceReferenceRelations && mutation.CommentContextMemoID == nil { + return nil + } + + userStatuses, err := readPostgresUserStatuses(ctx, tx, mutation.MemoCreatorID) + if err != nil { + return err + } + actorActive := userStatuses[mutation.MemoCreatorID] == store.Normal + + endpointIDs := postgresRelationAuthorizationEndpointIDs(mutation) + for _, endpointID := range endpointIDs { + state, err := getPostgresRelationMemoState(ctx, tx, endpointID) + if err != nil { + if stderrors.Is(err, sql.ErrNoRows) { + return store.ErrMemoMutationConflict + } + return err + } + snapshot := &store.MemoRelationEndpointSnapshot{ + ActorUserID: mutation.MemoCreatorID, + ActorActive: actorActive, + EndpointID: state.id, + EndpointCreatorID: state.creatorID, + EndpointRowStatus: state.rowStatus, + EndpointVisibility: state.visibility, + EndpointSpaceID: state.spaceID, + } + if state.spaceID != nil { + snapshot.EndpointSpaceExists, snapshot.EndpointMemberActive, err = readPostgresMemoSpaceState( + ctx, tx, *state.spaceID, mutation.MemoCreatorID, + ) + if err != nil { + return err + } + } + if err := store.ValidateMemoRelationEndpointRead(snapshot); err != nil { + return err + } + } + return nil +} + +func getPostgresRelationMemoState(ctx context.Context, tx *sql.Tx, memoID int32) (*postgresRelationMemoState, error) { + state := &postgresRelationMemoState{} + var spaceID sql.NullInt64 + if err := tx.QueryRowContext(ctx, `SELECT id, creator_id, row_status, visibility, space_id FROM memo WHERE id = $1`, memoID).Scan( + &state.id, &state.creatorID, &state.rowStatus, &state.visibility, &spaceID, + ); err != nil { + return nil, err + } + state.spaceID = store.NullInt32Pointer(spaceID) + return state, nil +} + +func postgresRelationAuthorizationEndpointIDs(mutation *store.MemoMutation) []int32 { + ids := make([]int32, 0, len(mutation.ReferenceRelations)+1) + seen := make(map[int32]struct{}, len(mutation.ReferenceRelations)+1) + add := func(id int32) { + if _, ok := seen[id]; ok { + return + } + seen[id] = struct{}{} + ids = append(ids, id) + } + if mutation.MemoCreate == nil && mutation.MemoID > 0 { + add(mutation.MemoID) + } else if mutation.CommentContextMemoID != nil { + add(*mutation.CommentContextMemoID) + } + for _, relation := range mutation.ReferenceRelations { + if relation != nil { + add(relation.RelatedMemoID) + } + } + return ids +} diff --git a/store/db/postgres/memo_share.go b/store/db/postgres/memo_share.go index a802d3e2..a7befba3 100644 --- a/store/db/postgres/memo_share.go +++ b/store/db/postgres/memo_share.go @@ -10,6 +10,32 @@ import ( ) func (d *DB) CreateMemoShare(ctx context.Context, create *store.MemoShare) (*store.MemoShare, error) { + if create.Policy == nil { + return createPostgresMemoShare(ctx, d.db, create) + } + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := validatePostgresMemoWritePolicy(ctx, tx, create.MemoID, create.Policy, nil); err != nil { + return nil, err + } + result, err := createPostgresMemoShare(ctx, tx, create) + if err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return result, nil +} + +type postgresMemoShareCreator interface { + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func createPostgresMemoShare(ctx context.Context, executor postgresMemoShareCreator, create *store.MemoShare) (*store.MemoShare, error) { fields := []string{"uid", "memo_id", "creator_id"} args := []any{create.UID, create.MemoID, create.CreatorID} @@ -19,7 +45,7 @@ func (d *DB) CreateMemoShare(ctx context.Context, create *store.MemoShare) (*sto } stmt := "INSERT INTO memo_share (" + strings.Join(fields, ", ") + ") VALUES (" + placeholders(len(args)) + ") RETURNING id, created_ts" - if err := d.db.QueryRowContext(ctx, stmt, args...).Scan( + if err := executor.QueryRowContext(ctx, stmt, args...).Scan( &create.ID, &create.CreatedTs, ); err != nil { @@ -130,6 +156,35 @@ func (d *DB) GetMemoShare(ctx context.Context, find *store.FindMemoShare) (*stor } func (d *DB) DeleteMemoShare(ctx context.Context, delete *store.DeleteMemoShare) error { + if delete.Policy != nil { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer func() { _ = tx.Rollback() }() + if err := validatePostgresMemoWritePolicy(ctx, tx, *delete.MemoID, delete.Policy, nil); err != nil { + return err + } + where, args := postgresMemoShareDeleteWhere(delete) + where = append(where, "memo_id = "+placeholder(len(args)+1)) + args = append(args, *delete.MemoID) + result, err := tx.ExecContext(ctx, "DELETE FROM memo_share WHERE "+strings.Join(where, " AND "), args...) + if err != nil { + return err + } + if rows, err := result.RowsAffected(); err != nil { + return err + } else if rows != 1 { + return store.ErrMemoMutationConflict + } + return tx.Commit() + } + where, args := postgresMemoShareDeleteWhere(delete) + _, err := d.db.ExecContext(ctx, "DELETE FROM memo_share WHERE "+strings.Join(where, " AND "), args...) + return err +} + +func postgresMemoShareDeleteWhere(delete *store.DeleteMemoShare) ([]string, []any) { where, args := []string{"1 = 1"}, []any{} if delete.ID != nil { where, args = append(where, "id = "+placeholder(len(args)+1)), append(args, *delete.ID) @@ -137,6 +192,5 @@ func (d *DB) DeleteMemoShare(ctx context.Context, delete *store.DeleteMemoShare) if delete.UID != nil { where, args = append(where, "uid = "+placeholder(len(args)+1)), append(args, *delete.UID) } - _, err := d.db.ExecContext(ctx, "DELETE FROM memo_share WHERE "+strings.Join(where, " AND "), args...) - return err + return where, args } diff --git a/store/db/postgres/reaction.go b/store/db/postgres/reaction.go index acaf4e12..c4e7d17f 100644 --- a/store/db/postgres/reaction.go +++ b/store/db/postgres/reaction.go @@ -11,7 +11,33 @@ import ( ) func (d *DB) UpsertReaction(ctx context.Context, upsert *store.Reaction) (*store.Reaction, error) { - if err := d.db.QueryRowContext(ctx, ` + if upsert.Policy == nil { + return upsertPostgresReaction(ctx, d.db, upsert) + } + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, errors.Wrap(err, "failed to begin reaction upsert transaction") + } + defer func() { _ = tx.Rollback() }() + if err := validatePostgresReactionWritePolicy(ctx, tx, upsert); err != nil { + return nil, err + } + reaction, err := upsertPostgresReaction(ctx, tx, upsert) + if err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, errors.Wrap(err, "failed to commit reaction upsert transaction") + } + return reaction, nil +} + +type postgresReactionUpsertQuerier interface { + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func upsertPostgresReaction(ctx context.Context, querier postgresReactionUpsertQuerier, upsert *store.Reaction) (*store.Reaction, error) { + if err := querier.QueryRowContext(ctx, ` INSERT INTO reaction (creator_id, memo_id, reaction_type) SELECT $1, memo.id, $2 FROM memo @@ -28,8 +54,7 @@ func (d *DB) UpsertReaction(ctx context.Context, upsert *store.Reaction) (*store return nil, err } - reaction := upsert - return reaction, nil + return upsert, nil } func (d *DB) ListReactions(ctx context.Context, find *store.FindReaction) ([]*store.Reaction, error) { @@ -106,6 +131,9 @@ func (d *DB) GetReaction(ctx context.Context, find *store.FindReaction) (*store. } func (d *DB) DeleteReaction(ctx context.Context, delete *store.DeleteReaction) error { + if delete.ActorUserID != nil { + return d.deleteReactionAsCreator(ctx, delete) + } where, args := []string{}, []any{} if delete.ID != nil { where, args = append(where, "id = "+placeholder(len(args)+1)), append(args, *delete.ID) @@ -120,3 +148,38 @@ func (d *DB) DeleteReaction(ctx context.Context, delete *store.DeleteReaction) e _, err := d.db.ExecContext(ctx, "DELETE FROM reaction WHERE "+strings.Join(where, " AND "), args...) return err } + +func (d *DB) deleteReactionAsCreator(ctx context.Context, delete *store.DeleteReaction) error { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return errors.Wrap(err, "failed to begin authorized reaction delete transaction") + } + defer func() { _ = tx.Rollback() }() + if delete.Policy != nil { + if err := validatePostgresReactionWritePolicy(ctx, tx, &store.Reaction{ + CreatorID: *delete.ActorUserID, + MemoID: *delete.MemoID, + Policy: delete.Policy, + }); err != nil { + return err + } + } + + var creatorID, memoID int32 + if err := tx.QueryRowContext(ctx, "SELECT creator_id, memo_id FROM reaction WHERE id = $1", *delete.ID).Scan(&creatorID, &memoID); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return nil + } + return errors.Wrap(err, "failed to read reaction for deletion") + } + if creatorID != *delete.ActorUserID || (delete.MemoID != nil && memoID != *delete.MemoID) { + return store.ErrReactionPermissionDenied + } + if _, err := tx.ExecContext(ctx, "DELETE FROM reaction WHERE id = $1", *delete.ID); err != nil { + return errors.Wrap(err, "failed to delete reaction") + } + if err := tx.Commit(); err != nil { + return errors.Wrap(err, "failed to commit authorized reaction delete transaction") + } + return nil +} diff --git a/store/db/postgres/reaction_policy.go b/store/db/postgres/reaction_policy.go new file mode 100644 index 00000000..29273212 --- /dev/null +++ b/store/db/postgres/reaction_policy.go @@ -0,0 +1,22 @@ +package postgres + +import ( + "context" + "database/sql" + + "github.com/pkg/errors" + + "github.com/usememos/memos/store" +) + +func validatePostgresReactionWritePolicy(ctx context.Context, tx *sql.Tx, reaction *store.Reaction) error { + policy := reaction.Policy + participation, err := readPostgresMemoParticipation(ctx, tx, reaction.MemoID, policy.ActorUserID) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrReactionMemoNotFound + } + return errors.Wrap(err, "failed to read reaction participation") + } + return store.ValidateReactionWriteParticipation(reaction, participation) +} diff --git a/store/db/postgres/space.go b/store/db/postgres/space.go new file mode 100644 index 00000000..71521a3d --- /dev/null +++ b/store/db/postgres/space.go @@ -0,0 +1,349 @@ +package postgres + +import ( + "context" + "database/sql" + "fmt" + "strings" + + "github.com/lib/pq" + "github.com/pkg/errors" + + "github.com/usememos/memos/store" +) + +func (d *DB) CreateSpace(ctx context.Context, create *store.Space, creatorID int32) (*store.Space, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := requirePostgresActiveUser(ctx, tx, creatorID); err != nil { + return nil, err + } + fields := []string{"uid", "title", "description"} + args := []any{create.UID, create.Title, create.Description} + space := &store.Space{} + query := "INSERT INTO space (" + strings.Join(fields, ", ") + ") VALUES (" + placeholders(len(args)) + ") RETURNING id, uid, title, description" + if err := tx.QueryRowContext(ctx, query, args...).Scan(&space.ID, &space.UID, &space.Title, &space.Description); err != nil { + if isPostgresUniqueViolation(err) { + return nil, store.ErrSpaceAlreadyExists + } + return nil, err + } + if _, err := tx.ExecContext(ctx, "INSERT INTO space_member (space_id, user_id, role) VALUES ($1, $2, $3)", space.ID, creatorID, store.SpaceMemberRoleAdmin); err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return space, nil +} + +func (d *DB) ListSpaces(ctx context.Context, find *store.FindSpace) ([]*store.Space, error) { + where, args := []string{"1 = 1"}, []any{} + add := func(condition string, value any) { + args = append(args, value) + where = append(where, fmt.Sprintf(condition, placeholder(len(args)))) + } + if find.ID != nil { + add("space.id = %s", *find.ID) + } + if find.UID != nil { + add("space.uid = %s", *find.UID) + } + if find.MemberUserID != nil { + add(`EXISTS (SELECT 1 FROM space_member sm JOIN "user" u ON u.id = sm.user_id WHERE sm.space_id = space.id AND sm.user_id = %s AND sm.role IN ('ADMIN', 'USER') AND u.row_status = 'NORMAL')`, *find.MemberUserID) + } + query := `SELECT space.id, space.uid, space.title, space.description + FROM space WHERE ` + strings.Join(where, " AND ") + ` ORDER BY space.id DESC` + query = appendPostgresLimit(query, find.Limit, find.Offset) + rows, err := d.db.QueryContext(ctx, query, args...) + if err != nil { + return nil, err + } + defer rows.Close() + spaces := []*store.Space{} + for rows.Next() { + space := &store.Space{} + if err := rows.Scan(&space.ID, &space.UID, &space.Title, &space.Description); err != nil { + return nil, err + } + spaces = append(spaces, space) + } + return spaces, rows.Err() +} + +func (d *DB) UpdateSpace(ctx context.Context, update *store.UpdateSpace, actorUserID int32) (*store.Space, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := requirePostgresActiveUsers(ctx, tx, actorUserID); err != nil { + return nil, err + } + if err := authorizePostgresSpaceAdmin(ctx, tx, update.ID, actorUserID); err != nil { + return nil, err + } + sets, args := []string{}, []any{} + add := func(field string, value any) { + args = append(args, value) + sets = append(sets, field+" = "+placeholder(len(args))) + } + if update.Title != nil { + add("title", *update.Title) + } + if update.Description != nil { + add("description", *update.Description) + } + args = append(args, update.ID) + space := &store.Space{} + query := "UPDATE space SET " + strings.Join(sets, ", ") + " WHERE id = " + placeholder(len(args)) + " RETURNING id, uid, title, description" + if err := tx.QueryRowContext(ctx, query, args...).Scan(&space.ID, &space.UID, &space.Title, &space.Description); err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return space, nil +} + +func (d *DB) CreateSpaceMember(ctx context.Context, create *store.SpaceMember, actorUserID int32) (*store.SpaceMember, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := requirePostgresActiveUsers(ctx, tx, actorUserID, create.UserID); err != nil { + return nil, err + } + if err := authorizePostgresSpaceAdmin(ctx, tx, create.SpaceID, actorUserID); err != nil { + return nil, err + } + member := &store.SpaceMember{} + err = tx.QueryRowContext(ctx, `INSERT INTO space_member (space_id, user_id, role) VALUES ($1, $2, $3) + RETURNING space_id, user_id, role`, create.SpaceID, create.UserID, create.Role).Scan(&member.SpaceID, &member.UserID, &member.Role) + if err != nil { + if isPostgresUniqueViolation(err) { + return nil, store.ErrSpaceMemberAlreadyExists + } + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return member, nil +} + +func (d *DB) ListSpaceMembers(ctx context.Context, find *store.FindSpaceMember) ([]*store.SpaceMember, error) { + where, args := []string{ + "space_member.role IN ('ADMIN', 'USER')", + "EXISTS (SELECT 1 FROM space member_space WHERE member_space.id = space_member.space_id)", + `EXISTS (SELECT 1 FROM "user" member_user WHERE member_user.id = space_member.user_id AND member_user.row_status = 'NORMAL')`, + }, []any{} + add := func(condition string, value any) { + args = append(args, value) + where = append(where, fmt.Sprintf(condition, placeholder(len(args)))) + } + if find.SpaceID != nil { + add("space_id = %s", *find.SpaceID) + } + if find.UserID != nil { + add("user_id = %s", *find.UserID) + } + if find.ViewerUserID != nil { + add(`EXISTS (SELECT 1 FROM space_member viewer JOIN "user" viewer_user ON viewer_user.id = viewer.user_id WHERE viewer.space_id = space_member.space_id AND viewer.user_id = %s AND viewer.role IN ('ADMIN', 'USER') AND viewer_user.row_status = 'NORMAL')`, *find.ViewerUserID) + } + query := `SELECT space_id, user_id, role FROM space_member WHERE ` + strings.Join(where, " AND ") + ` ORDER BY user_id ASC` + query = appendPostgresLimit(query, find.Limit, find.Offset) + rows, err := d.db.QueryContext(ctx, query, args...) + if err != nil { + return nil, err + } + defer rows.Close() + members := []*store.SpaceMember{} + for rows.Next() { + member := &store.SpaceMember{} + if err := rows.Scan(&member.SpaceID, &member.UserID, &member.Role); err != nil { + return nil, err + } + members = append(members, member) + } + return members, rows.Err() +} + +func (d *DB) UpdateSpaceMember(ctx context.Context, update *store.UpdateSpaceMember, actorUserID int32) (*store.SpaceMember, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := requirePostgresActiveUsers(ctx, tx, actorUserID, update.UserID); err != nil { + return nil, err + } + if err := authorizePostgresSpaceAdmin(ctx, tx, update.SpaceID, actorUserID); err != nil { + return nil, err + } + current, err := getPostgresSpaceMember(ctx, tx, update.SpaceID, update.UserID) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return nil, store.ErrSpaceMemberNotFound + } + return nil, err + } + if current.Role == store.SpaceMemberRoleAdmin && update.Role != nil && *update.Role != store.SpaceMemberRoleAdmin { + var count int + if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM space_member sm JOIN "user" u ON u.id = sm.user_id WHERE sm.space_id = $1 AND sm.role = $2 AND u.row_status = 'NORMAL'`, update.SpaceID, store.SpaceMemberRoleAdmin).Scan(&count); err != nil { + return nil, err + } + if count <= 1 { + return nil, store.ErrLastSpaceAdmin + } + } + sets, args := []string{}, []any{} + add := func(field string, value any) { + args = append(args, value) + sets = append(sets, field+" = "+placeholder(len(args))) + } + if update.Role != nil { + add("role", *update.Role) + } + args = append(args, update.SpaceID, update.UserID) + member := &store.SpaceMember{} + query := "UPDATE space_member SET " + strings.Join(sets, ", ") + " WHERE space_id = " + placeholder(len(args)-1) + " AND user_id = " + placeholder(len(args)) + " RETURNING space_id, user_id, role" + if err := tx.QueryRowContext(ctx, query, args...).Scan(&member.SpaceID, &member.UserID, &member.Role); err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return member, nil +} + +func (d *DB) DeleteSpaceMember(ctx context.Context, delete *store.DeleteSpaceMember, actorUserID int32) error { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer func() { _ = tx.Rollback() }() + userStatuses, err := readPostgresUserStatuses(ctx, tx, actorUserID, delete.UserID) + if err != nil { + return err + } + if actorUserID != delete.UserID && userStatuses[actorUserID] != store.Normal { + return store.ErrSpacePermissionDenied + } + var spaceID int32 + if err := tx.QueryRowContext(ctx, "SELECT id FROM space WHERE id = $1", delete.SpaceID).Scan(&spaceID); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrSpaceNotFound + } + return err + } + if actorUserID != delete.UserID { + var role store.SpaceMemberRole + if err := tx.QueryRowContext(ctx, "SELECT role FROM space_member WHERE space_id = $1 AND user_id = $2", delete.SpaceID, actorUserID).Scan(&role); errors.Is(err, sql.ErrNoRows) { + return store.ErrSpacePermissionDenied + } else if err != nil { + return err + } else if role != store.SpaceMemberRoleAdmin { + return store.ErrSpacePermissionDenied + } + } + member, err := getPostgresSpaceMember(ctx, tx, delete.SpaceID, delete.UserID) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrSpaceMemberNotFound + } + return err + } + if member.Role == store.SpaceMemberRoleAdmin && userStatuses[delete.UserID] == store.Normal { + var count int + if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM space_member sm JOIN "user" u ON u.id = sm.user_id WHERE sm.space_id = $1 AND sm.role = $2 AND u.row_status = 'NORMAL'`, delete.SpaceID, store.SpaceMemberRoleAdmin).Scan(&count); err != nil { + return err + } + if count <= 1 { + return store.ErrLastSpaceAdmin + } + } + if _, err := tx.ExecContext(ctx, "DELETE FROM space_member WHERE space_id = $1 AND user_id = $2", delete.SpaceID, delete.UserID); err != nil { + return err + } + return tx.Commit() +} + +func authorizePostgresSpaceAdmin(ctx context.Context, tx *sql.Tx, spaceID, actorUserID int32) error { + var storedSpaceID int32 + if err := tx.QueryRowContext(ctx, "SELECT id FROM space WHERE id = $1", spaceID).Scan(&storedSpaceID); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrSpaceNotFound + } + return err + } + var role store.SpaceMemberRole + if err := tx.QueryRowContext(ctx, "SELECT role FROM space_member WHERE space_id = $1 AND user_id = $2", spaceID, actorUserID).Scan(&role); errors.Is(err, sql.ErrNoRows) { + return store.ErrSpacePermissionDenied + } else if err != nil { + return err + } else if role != store.SpaceMemberRoleAdmin { + return store.ErrSpacePermissionDenied + } + return nil +} + +func requirePostgresActiveUser(ctx context.Context, tx *sql.Tx, userID int32) error { + return requirePostgresActiveUsers(ctx, tx, userID) +} + +func getPostgresSpaceMember(ctx context.Context, tx *sql.Tx, spaceID, userID int32) (*store.SpaceMember, error) { + member := &store.SpaceMember{} + err := tx.QueryRowContext(ctx, `SELECT space_id, user_id, role FROM space_member WHERE space_id = $1 AND user_id = $2`, spaceID, userID).Scan(&member.SpaceID, &member.UserID, &member.Role) + return member, err +} + +func requirePostgresActiveUsers(ctx context.Context, tx *sql.Tx, userIDs ...int32) error { + statuses, err := readPostgresUserStatuses(ctx, tx, userIDs...) + if err != nil { + return err + } + for _, userID := range userIDs { + if statuses[userID] != store.Normal { + return store.ErrSpaceMemberNotActive + } + } + return nil +} + +func readPostgresUserStatuses(ctx context.Context, tx *sql.Tx, userIDs ...int32) (map[int32]store.RowStatus, error) { + statuses := make(map[int32]store.RowStatus, len(userIDs)) + for _, userID := range userIDs { + if _, ok := statuses[userID]; ok { + continue + } + var status store.RowStatus + if err := tx.QueryRowContext(ctx, `SELECT row_status FROM "user" WHERE id = $1`, userID).Scan(&status); err != nil { + if errors.Is(err, sql.ErrNoRows) { + continue + } + return nil, err + } + statuses[userID] = status + } + return statuses, nil +} + +func appendPostgresLimit(query string, limit, offset *int) string { + if limit != nil { + query = fmt.Sprintf("%s LIMIT %d", query, *limit) + if offset != nil { + query = fmt.Sprintf("%s OFFSET %d", query, *offset) + } + } + return query +} + +func isPostgresUniqueViolation(err error) bool { + var pqErr *pq.Error + return errors.As(err, &pqErr) && pqErr.Code == "23505" +} diff --git a/store/db/postgres/space_delete.go b/store/db/postgres/space_delete.go new file mode 100644 index 00000000..cc9a7d99 --- /dev/null +++ b/store/db/postgres/space_delete.go @@ -0,0 +1,138 @@ +package postgres + +import ( + "context" + "database/sql" + + "github.com/pkg/errors" + + "github.com/usememos/memos/store" +) + +// DeleteSpace hard-deletes only memos directly placed in the Space. Relations +// are removed when either endpoint is deleted, but are never traversed. +func (d *DB) DeleteSpace(ctx context.Context, delete *store.DeleteSpace) (*store.DeleteSpaceResult, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, errors.Wrap(err, "failed to begin space delete transaction") + } + defer func() { _ = tx.Rollback() }() + + if err := requirePostgresSpaceDeleteAdmin(ctx, tx, delete); err != nil { + return nil, err + } + memoIDs, err := listPostgresSpaceDeleteMemoIDs(ctx, tx, delete.ID) + if err != nil { + return nil, errors.Wrap(err, "failed to collect assigned memos") + } + attachments, err := deletePostgresMemoSetTx(ctx, tx, memoIDs) + if err != nil { + return nil, errors.Wrap(err, "failed to delete assigned memo set") + } + if _, err := tx.ExecContext(ctx, "DELETE FROM space_member WHERE space_id = $1", delete.ID); err != nil { + return nil, errors.Wrap(err, "failed to delete space memberships") + } + result, err := tx.ExecContext(ctx, "DELETE FROM space WHERE id = $1", delete.ID) + if err != nil { + return nil, errors.Wrap(err, "failed to delete space") + } + if count, err := result.RowsAffected(); err != nil { + return nil, errors.Wrap(err, "failed to count deleted spaces") + } else if count != 1 { + return nil, store.ErrSpaceNotFound + } + if err := tx.Commit(); err != nil { + return nil, errors.Wrap(err, "failed to commit space deletion") + } + return &store.DeleteSpaceResult{Attachments: attachments}, nil +} + +func requirePostgresSpaceDeleteAdmin(ctx context.Context, tx *sql.Tx, delete *store.DeleteSpace) error { + var actorStatus store.RowStatus + if err := tx.QueryRowContext(ctx, `SELECT row_status FROM "user" WHERE id = $1`, delete.ActorUserID).Scan(&actorStatus); errors.Is(err, sql.ErrNoRows) { + return store.ErrSpacePermissionDenied + } else if err != nil { + return errors.Wrap(err, "failed to read space deletion actor") + } else if actorStatus != store.Normal { + return store.ErrSpacePermissionDenied + } + var spaceID int32 + if err := tx.QueryRowContext(ctx, "SELECT id FROM space WHERE id = $1", delete.ID).Scan(&spaceID); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrSpaceNotFound + } + return err + } + var role store.SpaceMemberRole + if err := tx.QueryRowContext(ctx, "SELECT role FROM space_member WHERE space_id = $1 AND user_id = $2", delete.ID, delete.ActorUserID).Scan(&role); errors.Is(err, sql.ErrNoRows) { + return store.ErrSpacePermissionDenied + } else if err != nil { + return errors.Wrap(err, "failed to read space administrator membership") + } else if role != store.SpaceMemberRoleAdmin { + return store.ErrSpacePermissionDenied + } + return nil +} + +func listPostgresSpaceDeleteMemoIDs(ctx context.Context, tx *sql.Tx, spaceID int32) ([]int32, error) { + rows, err := tx.QueryContext(ctx, "SELECT id FROM memo WHERE space_id = $1 ORDER BY id", spaceID) + if err != nil { + return nil, err + } + defer rows.Close() + ids := make([]int32, 0) + for rows.Next() { + var id int32 + if err := rows.Scan(&id); err != nil { + return nil, err + } + ids = append(ids, id) + } + return ids, rows.Err() +} + +func deletePostgresMemoSetTx(ctx context.Context, tx *sql.Tx, memoIDs []int32) ([]*store.Attachment, error) { + attachments, err := listPostgresMemoSetAttachments(ctx, tx, memoIDs) + if err != nil { + return nil, errors.Wrap(err, "failed to collect memo attachments") + } + if err := deletePostgresMemoSetShares(ctx, tx, memoIDs); err != nil { + return nil, errors.Wrap(err, "failed to delete memo shares") + } + if err := deleteMemosTx(ctx, tx, memoIDs); err != nil { + return nil, errors.Wrap(err, "failed to delete memos") + } + if err := deleteReactionsByMemoIDsTx(ctx, tx, memoIDs); err != nil { + return nil, errors.Wrap(err, "failed to delete memo reactions") + } + if err := deleteAttachmentsByIDsTx(ctx, tx, attachmentIDsFromList(attachments)); err != nil { + return nil, errors.Wrap(err, "failed to delete memo attachments") + } + if err := deleteMemoRelationsTx(ctx, tx, memoIDs); err != nil { + return nil, errors.Wrap(err, "failed to delete incident memo relations") + } + return attachments, nil +} + +func listPostgresMemoSetAttachments(ctx context.Context, tx *sql.Tx, memoIDs []int32) ([]*store.Attachment, error) { + attachments := make([]*store.Attachment, 0) + seen := make(map[int32]struct{}) + for _, batch := range deleteUserBatches(memoIDs, deleteUserBatchSize) { + clause, args := deleteUserInClause(1, batch) + if err := appendDeleteUserAttachments(ctx, tx, `SELECT id, uid, creator_id, memo_id, storage_type, reference, payload + FROM attachment WHERE memo_id IN `+clause+` ORDER BY id`, args, seen, &attachments); err != nil { + return nil, err + } + } + return attachments, nil +} + +func deletePostgresMemoSetShares(ctx context.Context, tx *sql.Tx, memoIDs []int32) error { + for _, batch := range deleteUserBatches(memoIDs, deleteUserBatchSize) { + clause, args := deleteUserInClause(1, batch) + if _, err := tx.ExecContext(ctx, "DELETE FROM memo_share WHERE memo_id IN "+clause, args...); err != nil { + return err + } + } + return nil +} diff --git a/store/db/postgres/user.go b/store/db/postgres/user.go index eec831df..f933f598 100644 --- a/store/db/postgres/user.go +++ b/store/db/postgres/user.go @@ -2,6 +2,7 @@ package postgres import ( "context" + "database/sql" "fmt" "strings" @@ -18,6 +19,16 @@ func (d *DB) CreateUser(ctx context.Context, create *store.User) (*store.User, e } func (d *DB) UpdateUser(ctx context.Context, update *store.UpdateUser) (*store.User, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if update.RowStatus != nil && *update.RowStatus == store.Archived { + if err := validatePostgresUserArchive(ctx, tx, update.ID); err != nil { + return nil, err + } + } set, args := []string{}, []any{} if v := update.UpdatedTs; v != nil { set, args = append(set, "updated_ts = "+placeholder(len(args)+1)), append(args, *v) @@ -55,7 +66,7 @@ func (d *DB) UpdateUser(ctx context.Context, update *store.UpdateUser) (*store.U ` args = append(args, update.ID) user := &store.User{} - if err := d.db.QueryRowContext(ctx, query, args...).Scan( + if err := tx.QueryRowContext(ctx, query, args...).Scan( &user.ID, &user.Username, &user.Role, @@ -70,10 +81,39 @@ func (d *DB) UpdateUser(ctx context.Context, update *store.UpdateUser) (*store.U ); err != nil { return nil, err } - + if err := tx.Commit(); err != nil { + return nil, err + } return user, nil } +func validatePostgresUserArchive(ctx context.Context, tx *sql.Tx, userID int32) error { + var isLastActiveAdmin bool + if err := tx.QueryRowContext(ctx, `SELECT EXISTS ( + SELECT 1 + FROM "user" target_user + JOIN space_member target ON target.user_id = target_user.id AND target.role = 'ADMIN' + JOIN space ON space.id = target.space_id + WHERE target_user.id = $1 + AND target_user.row_status = 'NORMAL' + AND NOT EXISTS ( + SELECT 1 + FROM space_member other + JOIN "user" other_user ON other_user.id = other.user_id + WHERE other.space_id = target.space_id + AND other.user_id <> target.user_id + AND other.role = 'ADMIN' + AND other_user.row_status = 'NORMAL' + ) + )`, userID).Scan(&isLastActiveAdmin); err != nil { + return err + } + if isLastActiveAdmin { + return store.ErrLastSpaceAdmin + } + return nil +} + func (d *DB) ListUsers(ctx context.Context, find *store.FindUser) ([]*store.User, error) { where, args := []string{"1 = 1"}, []any{} orderBy := []string{"created_ts DESC", "row_status DESC", "id DESC"} diff --git a/store/db/postgres/user_delete.go b/store/db/postgres/user_delete.go index d4bc8d1f..48401e67 100644 --- a/store/db/postgres/user_delete.go +++ b/store/db/postgres/user_delete.go @@ -29,6 +29,19 @@ func (d *DB) DeleteUser(ctx context.Context, delete *store.DeleteUser) (*store.D defer func() { _ = tx.Rollback() }() + var userID int32 + if err := tx.QueryRowContext(ctx, `SELECT id FROM "user" WHERE id = $1`, delete.ID).Scan(&userID); errors.Is(err, sql.ErrNoRows) { + return &store.DeleteUserResult{}, nil + } else if err != nil { + return nil, errors.Wrap(err, "failed to read user") + } + var membershipCount int + if err := tx.QueryRowContext(ctx, "SELECT COUNT(*) FROM space_member WHERE user_id = $1", delete.ID).Scan(&membershipCount); err != nil { + return nil, errors.Wrap(err, "failed to check user space memberships") + } + if membershipCount != 0 { + return nil, store.ErrUserHasSpaceMembership + } targets, err := collectDeleteUserTargets(ctx, tx, delete.ID) if err != nil { @@ -56,7 +69,7 @@ func (d *DB) DeleteUser(ctx context.Context, delete *store.DeleteUser) (*store.D func collectDeleteUserTargets(ctx context.Context, tx *sql.Tx, userID int32) (*deleteUserTargetSet, error) { targets := &deleteUserTargetSet{} - memoIDs, err := listDeleteUserMemoTree(ctx, tx, userID) + memoIDs, err := listDeleteUserMemos(ctx, tx, userID) if err != nil { return nil, err } @@ -75,7 +88,7 @@ func collectDeleteUserTargets(ctx context.Context, tx *sql.Tx, userID int32) (*d } targets.userSettingKeys = userSettingKeys - inboxIDs, err := listDeleteUserInboxIDs(ctx, tx, userID, memoIDSet(memoIDs)) + inboxIDs, err := listDeleteUserInboxIDs(ctx, tx, userID) if err != nil { return nil, err } @@ -123,25 +136,8 @@ func deleteUserTargetsTx(ctx context.Context, tx *sql.Tx, userID int32, targets return nil } -func listDeleteUserMemoTree(ctx context.Context, tx *sql.Tx, userID int32) ([]int32, error) { - return listDeleteUserMemoTreeRecursive(ctx, tx, userID) -} - -func listDeleteUserMemoTreeRecursive(ctx context.Context, tx *sql.Tx, userID int32) ([]int32, error) { - rows, err := tx.QueryContext(ctx, ` - WITH RECURSIVE memo_tree(id) AS ( - SELECT id - FROM memo - WHERE creator_id = `+deleteUserPlaceholder(1)+` - UNION - SELECT child.id - FROM memo child - JOIN memo_relation rel ON rel.memo_id = child.id AND rel.type = 'COMMENT' - JOIN memo_tree parent ON rel.related_memo_id = parent.id - ) - SELECT id - FROM memo_tree - `, userID) +func listDeleteUserMemos(ctx context.Context, tx *sql.Tx, userID int32) ([]int32, error) { + rows, err := tx.QueryContext(ctx, `SELECT id FROM memo WHERE creator_id = $1 ORDER BY id`, userID) if err != nil { return nil, err } @@ -261,24 +257,7 @@ func deleteUserSettingKeysQuery() string { return `SELECT key FROM user_setting WHERE user_id = ` + deleteUserPlaceholder(1) } -func listDeleteUserInboxIDs(ctx context.Context, tx *sql.Tx, userID int32, memoIDSet map[int32]struct{}) ([]int32, error) { - directIDs, err := listDeleteUserDirectInboxIDs(ctx, tx, userID) - if err != nil { - return nil, err - } - inboxIDs := append([]int32{}, directIDs...) - if len(memoIDSet) == 0 { - return inboxIDs, nil - } - - memoIDs, err := listDeleteUserMemoReferencedInboxIDs(ctx, tx, userID, memoIDSet) - if err != nil { - return nil, err - } - return append(inboxIDs, memoIDs...), nil -} - -func listDeleteUserDirectInboxIDs(ctx context.Context, tx *sql.Tx, userID int32) ([]int32, error) { +func listDeleteUserInboxIDs(ctx context.Context, tx *sql.Tx, userID int32) ([]int32, error) { rows, err := tx.QueryContext(ctx, ` SELECT id FROM inbox @@ -304,76 +283,6 @@ func listDeleteUserDirectInboxIDs(ctx context.Context, tx *sql.Tx, userID int32) return inboxIDs, nil } -func listDeleteUserMemoReferencedInboxIDs(ctx context.Context, tx *sql.Tx, userID int32, memoIDSet map[int32]struct{}) ([]int32, error) { - rows, err := tx.QueryContext(ctx, ` - SELECT id, message - FROM inbox - WHERE sender_id <> `+deleteUserPlaceholder(1)+` - AND receiver_id <> `+deleteUserPlaceholder(2), userID, userID) - if err != nil { - return nil, err - } - defer rows.Close() - - inboxIDs := make([]int32, 0) - for rows.Next() { - var ( - inboxID int32 - messageRaw []byte - ) - if err := rows.Scan(&inboxID, &messageRaw); err != nil { - return nil, err - } - if len(messageRaw) == 0 { - continue - } - - message := &storepb.InboxMessage{} - if err := protojsonUnmarshaler.Unmarshal(messageRaw, message); err != nil { - return nil, err - } - if inboxMessageTouchesMemoSet(message, memoIDSet) { - inboxIDs = append(inboxIDs, inboxID) - } - } - if err := rows.Err(); err != nil { - return nil, err - } - - return inboxIDs, nil -} - -func inboxMessageTouchesMemoSet(message *storepb.InboxMessage, memoIDSet map[int32]struct{}) bool { - if message == nil { - return false - } - - switch message.Type { - case storepb.InboxMessage_MEMO_COMMENT: - payload := message.GetMemoComment() - if payload == nil { - return false - } - return memoIDInSet(payload.MemoId, memoIDSet) || memoIDInSet(payload.RelatedMemoId, memoIDSet) - case storepb.InboxMessage_MEMO_MENTION: - payload := message.GetMemoMention() - if payload == nil { - return false - } - return memoIDInSet(payload.MemoId, memoIDSet) || memoIDInSet(payload.RelatedMemoId, memoIDSet) - default: - return false - } -} - -func memoIDInSet(id int32, memoIDSet map[int32]struct{}) bool { - if id == 0 { - return false - } - _, exists := memoIDSet[id] - return exists -} - func deleteReactionsByMemoIDsTx(ctx context.Context, tx *sql.Tx, memoIDs []int32) error { for _, batch := range deleteUserBatches(memoIDs, deleteUserBatchSize) { clause, args := deleteUserInClause(1, batch) @@ -490,14 +399,6 @@ func deleteUserBatches[T any](values []T, size int) [][]T { return batches } -func memoIDSet(memoIDs []int32) map[int32]struct{} { - idSet := make(map[int32]struct{}, len(memoIDs)) - for _, id := range memoIDs { - idSet[id] = struct{}{} - } - return idSet -} - func attachmentIDsFromList(attachments []*store.Attachment) []int32 { ids := make([]int32, 0, len(attachments)) for _, attachment := range attachments { diff --git a/store/db/sqlite/attachment.go b/store/db/sqlite/attachment.go index b6fcc101..1328305d 100644 --- a/store/db/sqlite/attachment.go +++ b/store/db/sqlite/attachment.go @@ -15,6 +15,31 @@ import ( ) func (d *DB) CreateAttachment(ctx context.Context, create *store.Attachment) (*store.Attachment, error) { + if create.Policy == nil { + return insertSQLiteAttachment(ctx, d.db, create) + } + if create.MemoID == nil || create.CreatorID != create.Policy.ActorUserID { + return nil, store.ErrMemoPermissionDenied + } + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := validateSQLiteMemoWritePolicy(ctx, tx, *create.MemoID, create.Policy, nil); err != nil { + return nil, err + } + attachment, err := insertSQLiteAttachment(ctx, tx, create) + if err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return attachment, nil +} + +func insertSQLiteAttachment(ctx context.Context, executor dbExecutor, create *store.Attachment) (*store.Attachment, error) { fields := []string{"`uid`", "`filename`", "`blob`", "`type`", "`size`", "`creator_id`", "`memo_id`", "`storage_type`", "`reference`", "`payload`"} placeholder := []string{"?", "?", "?", "?", "?", "?", "?", "?", "?", "?"} storageType := "" @@ -32,7 +57,7 @@ func (d *DB) CreateAttachment(ctx context.Context, create *store.Attachment) (*s args := []any{create.UID, create.Filename, create.Blob, create.Type, create.Size, create.CreatorID, create.MemoID, storageType, create.Reference, payloadString} stmt := "INSERT INTO `attachment` (" + strings.Join(fields, ", ") + ") VALUES (" + strings.Join(placeholder, ", ") + ") RETURNING `id`, `created_ts`, `updated_ts`" - if err := d.db.QueryRowContext(ctx, stmt, args...).Scan(&create.ID, &create.CreatedTs, &create.UpdatedTs); err != nil { + if err := executor.QueryRowContext(ctx, stmt, args...).Scan(&create.ID, &create.CreatedTs, &create.UpdatedTs); err != nil { return nil, err } @@ -82,6 +107,19 @@ func (d *DB) ListAttachments(ctx context.Context, find *store.FindAttachment) ([ return nil, errors.Wrap(err, "failed to append filter conditions") } } + if access := find.Access; access != nil { + scopeClauses := []string{} + if access.UserID != nil { + scopeClauses = append(scopeClauses, "(`attachment`.`memo_id` IS NULL AND EXISTS (SELECT 1 FROM `user` AS `attachment_user` WHERE `attachment_user`.`id` = ? AND `attachment_user`.`row_status` = 'NORMAL') AND `attachment`.`creator_id` = ?)") + args = append(args, *access.UserID, *access.UserID) + } + scopeClauses = append(scopeClauses, "(`attachment`.`memo_id` IS NOT NULL AND "+sqliteMemoAccessPredicate(access, "`memo`", "`attachment_member`", &args)+")") + if len(scopeClauses) == 0 { + where = append(where, "1 = 0") + } else { + where = append(where, "("+strings.Join(scopeClauses, " OR ")+")") + } + } fields := []string{ "`attachment`.`id` AS `id`", @@ -167,6 +205,36 @@ func (d *DB) ListAttachments(ctx context.Context, find *store.FindAttachment) ([ } func (d *DB) UpdateAttachment(ctx context.Context, update *store.UpdateAttachment) error { + if update.Policy == nil { + return applySQLiteAttachmentUpdate(ctx, d.db, update) + } + if update.MemoID != nil { + return store.ErrMemoMutationConflict + } + attachmentIDs := []int32{update.ID} + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer func() { _ = tx.Rollback() }() + attachments, err := listSQLiteAttachmentSnapshots(ctx, tx, attachmentIDs) + if err != nil { + return err + } + memoIDs, err := store.ValidateAttachmentMutationTargets(update.Policy.ActorUserID, attachmentIDs, attachments) + if err != nil { + return err + } + if err := authorizeSQLiteAttachmentMutation(ctx, tx, update.Policy.ActorUserID, memoIDs, nil); err != nil { + return err + } + if err := applySQLiteAttachmentUpdate(ctx, tx, update); err != nil { + return err + } + return tx.Commit() +} + +func applySQLiteAttachmentUpdate(ctx context.Context, executor dbExecutor, update *store.UpdateAttachment) error { set, args := []string{}, []any{} if v := update.UID; v != nil { @@ -191,7 +259,10 @@ func (d *DB) UpdateAttachment(ctx context.Context, update *store.UpdateAttachmen args = append(args, update.ID) stmt := "UPDATE `attachment` SET " + strings.Join(set, ", ") + " WHERE `id` = ?" - result, err := d.db.ExecContext(ctx, stmt, args...) + if len(set) == 0 { + return nil + } + result, err := executor.ExecContext(ctx, stmt, args...) if err != nil { return errors.Wrap(err, "failed to update attachment") } @@ -202,15 +273,7 @@ func (d *DB) UpdateAttachment(ctx context.Context, update *store.UpdateAttachmen } func (d *DB) DeleteAttachment(ctx context.Context, delete *store.DeleteAttachment) error { - stmt := "DELETE FROM `attachment` WHERE `id` = ?" - result, err := d.db.ExecContext(ctx, stmt, delete.ID) - if err != nil { - return err - } - if _, err := result.RowsAffected(); err != nil { - return err - } - return nil + return d.DeleteAttachments(ctx, []*store.DeleteAttachment{delete}) } func (d *DB) DeleteAttachments(ctx context.Context, deletes []*store.DeleteAttachment) error { @@ -222,12 +285,7 @@ func (d *DB) DeleteAttachments(ctx context.Context, deletes []*store.DeleteAttac if err != nil { return errors.Wrap(err, "failed to start attachment delete transaction") } - defer func() { - if tx != nil { - _ = tx.Rollback() - } - }() - + defer func() { _ = tx.Rollback() }() stmt := "DELETE FROM `attachment` WHERE `id` = ?" for _, delete := range deletes { result, err := tx.ExecContext(ctx, stmt, delete.ID) @@ -239,9 +297,5 @@ func (d *DB) DeleteAttachments(ctx context.Context, deletes []*store.DeleteAttac } } - if err := tx.Commit(); err != nil { - return err - } - tx = nil - return nil + return tx.Commit() } diff --git a/store/db/sqlite/attachment_delete.go b/store/db/sqlite/attachment_delete.go new file mode 100644 index 00000000..5210219b --- /dev/null +++ b/store/db/sqlite/attachment_delete.go @@ -0,0 +1,120 @@ +package sqlite + +import ( + "context" + "database/sql" + + "github.com/pkg/errors" + + "github.com/usememos/memos/store" +) + +func (d *DB) DeleteAttachmentsWithPolicy(ctx context.Context, policy *store.AttachmentDeletionPolicy, attachmentIDs []int32) error { + if policy == nil || policy.ActorUserID <= 0 { + return store.ErrMemoPermissionDenied + } + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return errors.Wrap(err, "failed to begin attachment delete transaction") + } + defer func() { _ = tx.Rollback() }() + attachments, err := listSQLiteAttachmentSnapshots(ctx, tx, attachmentIDs) + if err != nil { + return errors.Wrap(err, "failed to read attachment delete targets") + } + memoIDs, err := store.ValidateAttachmentMutationTargets(policy.ActorUserID, attachmentIDs, attachments) + if err != nil { + return err + } + if err := store.ValidateAttachmentDeletionMemoSnapshots(memoIDs, policy.ExpectedMemoContents); err != nil { + return err + } + if err := authorizeSQLiteAttachmentMutation(ctx, tx, policy.ActorUserID, memoIDs, policy.ExpectedMemoContents); err != nil { + return err + } + + for _, attachmentID := range attachmentIDs { + result, err := tx.ExecContext(ctx, "DELETE FROM attachment WHERE id = ?", attachmentID) + if err != nil { + return errors.Wrap(err, "failed to delete attachment") + } + if rows, err := result.RowsAffected(); err != nil { + return errors.Wrap(err, "failed to count deleted attachment") + } else if rows != 1 { + return store.ErrMemoMutationConflict + } + } + if err := tx.Commit(); err != nil { + return errors.Wrap(err, "failed to commit attachment deletion") + } + return nil +} + +func listSQLiteAttachmentSnapshots(ctx context.Context, tx dbExecutor, attachmentIDs []int32) ([]*store.Attachment, error) { + attachments := make([]*store.Attachment, 0, len(attachmentIDs)) + seen := make(map[int32]struct{}, len(attachmentIDs)) + for _, batch := range deleteUserBatches(attachmentIDs, deleteUserBatchSize) { + clause, args := deleteUserInClause(1, batch) + if err := appendDeleteUserAttachments(ctx, tx, `SELECT id, uid, creator_id, memo_id, storage_type, reference, payload + FROM attachment WHERE id IN `+clause+` ORDER BY id`, args, seen, &attachments); err != nil { + return nil, err + } + } + return attachments, nil +} + +func authorizeSQLiteAttachmentMutation( + ctx context.Context, + tx dbExecutor, + actorUserID int32, + memoIDs []int32, + expectedMemoContents map[int32]string, +) error { + var actorStatus store.RowStatus + if err := tx.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", actorUserID).Scan(&actorStatus); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrMemoPermissionDenied + } + return errors.Wrap(err, "failed to read attachment actor") + } + if actorStatus != store.Normal { + return store.ErrMemoPermissionDenied + } + + for _, memoID := range memoIDs { + snapshot := &store.MemoWriteSnapshot{} + var currentSpace sql.NullInt64 + var content string + if err := tx.QueryRowContext(ctx, `SELECT creator_id, row_status, space_id, visibility, content + FROM memo WHERE id = ?`, memoID).Scan( + &snapshot.CreatorID, &snapshot.RowStatus, ¤tSpace, &snapshot.Visibility, &content, + ); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrMemoMutationConflict + } + return errors.Wrap(err, "failed to read attachment memo") + } + snapshot.SpaceID = store.NullInt32Pointer(currentSpace) + if expectedMemoContents != nil && content != expectedMemoContents[memoID] { + return store.ErrMemoMutationConflict + } + if snapshot.SpaceID != nil { + var exists bool + if err := tx.QueryRowContext(ctx, "SELECT EXISTS(SELECT 1 FROM space WHERE id = ?)", *snapshot.SpaceID).Scan(&exists); err != nil { + return errors.Wrap(err, "failed to read attachment memo space") + } + snapshot.SourceSpaceExists = exists + if exists { + active, err := sqliteSpaceMemberActive(ctx, tx, *snapshot.SpaceID, actorUserID) + if err != nil { + return errors.Wrap(err, "failed to read attachment memo membership") + } + snapshot.SourceMemberActive = active + } + } + if err := store.ValidateMemoWriteSnapshot(&store.MemoWritePolicy{ActorUserID: actorUserID}, nil, snapshot); err != nil { + return err + } + } + return nil +} diff --git a/store/db/sqlite/executor.go b/store/db/sqlite/executor.go new file mode 100644 index 00000000..f0712785 --- /dev/null +++ b/store/db/sqlite/executor.go @@ -0,0 +1,14 @@ +package sqlite + +import ( + "context" + "database/sql" +) + +// dbExecutor is the common query surface implemented by the database handle +// and its transactions. +type dbExecutor interface { + ExecContext(context.Context, string, ...any) (sql.Result, error) + QueryRowContext(context.Context, string, ...any) *sql.Row + QueryContext(context.Context, string, ...any) (*sql.Rows, error) +} diff --git a/store/db/sqlite/memo.go b/store/db/sqlite/memo.go index afdc3920..3780b44c 100644 --- a/store/db/sqlite/memo.go +++ b/store/db/sqlite/memo.go @@ -2,6 +2,7 @@ package sqlite import ( "context" + "database/sql" "fmt" "strings" @@ -14,17 +15,35 @@ import ( ) func (d *DB) CreateMemo(ctx context.Context, create *store.Memo) (*store.Memo, error) { - fields := []string{"`uid`", "`creator_id`", "`content`", "`visibility`", "`payload`"} - placeholder := []string{"?", "?", "?", "?", "?"} + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := validateSQLiteMemoCreate(ctx, tx, create); err != nil { + return nil, err + } + if err := insertSQLiteMemo(ctx, tx, create); err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return create, nil +} + +func insertSQLiteMemo(ctx context.Context, tx dbExecutor, create *store.Memo) error { + fields := []string{"`uid`", "`creator_id`", "`content`", "`visibility`", "`payload`", "`space_id`"} + placeholder := []string{"?", "?", "?", "?", "?", "?"} payload := "{}" if create.Payload != nil { payloadBytes, err := protojson.Marshal(create.Payload) if err != nil { - return nil, err + return err } payload = string(payloadBytes) } - args := []any{create.UID, create.CreatorID, create.Content, create.Visibility, payload} + args := []any{create.UID, create.CreatorID, create.Content, create.Visibility, payload, create.SpaceID} // Add custom timestamps if provided if create.CreatedTs != 0 { @@ -39,16 +58,50 @@ func (d *DB) CreateMemo(ctx context.Context, create *store.Memo) (*store.Memo, e } stmt := "INSERT INTO `memo` (" + strings.Join(fields, ", ") + ") VALUES (" + strings.Join(placeholder, ", ") + ") RETURNING `id`, `created_ts`, `updated_ts`, `row_status`" - if err := d.db.QueryRowContext(ctx, stmt, args...).Scan( + if err := tx.QueryRowContext(ctx, stmt, args...).Scan( &create.ID, &create.CreatedTs, &create.UpdatedTs, &create.RowStatus, ); err != nil { - return nil, err + return err } + return nil +} - return create, nil +func validateSQLiteMemoCreate(ctx context.Context, tx dbExecutor, create *store.Memo) error { + var actorStatus store.RowStatus + err := tx.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", create.CreatorID).Scan(&actorStatus) + if errors.Is(err, sql.ErrNoRows) || (err == nil && actorStatus != store.Normal) { + return store.ErrMemoSpaceMembershipRequired + } + if err != nil { + return err + } + if create.SpaceID != nil { + return validateSQLiteMemoSpaceMember(ctx, tx, *create.SpaceID, create.CreatorID) + } + return nil +} + +func validateSQLiteMemoSpaceMember(ctx context.Context, tx dbExecutor, spaceID, userID int32) error { + var exists bool + if err := tx.QueryRowContext(ctx, "SELECT EXISTS(SELECT 1 FROM space WHERE id = ?)", spaceID).Scan(&exists); err != nil { + return err + } + if !exists { + return store.ErrMemoSpaceNotWritable + } + err := tx.QueryRowContext(ctx, `SELECT EXISTS( + SELECT 1 FROM space_member sm JOIN user u ON u.id = sm.user_id + WHERE sm.space_id = ? AND sm.user_id = ? AND sm.role IN ('ADMIN', 'USER') AND u.row_status = 'NORMAL')`, spaceID, userID).Scan(&exists) + if err != nil { + return err + } + if !exists { + return store.ErrMemoSpaceMembershipRequired + } + return nil } func (d *DB) ListMemos(ctx context.Context, find *store.FindMemo) ([]*store.Memo, error) { @@ -101,8 +154,28 @@ func (d *DB) ListMemos(ctx context.Context, find *store.FindMemo) ([]*store.Memo } where = append(where, fmt.Sprintf("`memo`.`visibility` IN (%s)", strings.Join(placeholder, ","))) } + if v := find.SpaceID; v != nil { + where, args = append(where, "`memo`.`space_id` = ?"), append(args, *v) + } + if v := find.CommentContextMemoID; v != nil { + where, args = append(where, `EXISTS ( + SELECT 1 FROM memo_relation AS comment_context + WHERE comment_context.memo_id = memo.id + AND comment_context.related_memo_id = ? + AND comment_context.type = 'COMMENT' + )`), append(args, *v) + } + if find.Unassigned { + where = append(where, "`memo`.`space_id` IS NULL") + } + if access := find.Access; access != nil { + where = append(where, sqliteMemoAccessPredicate(access, "`memo`", "`access_member`", &args)) + } if find.ExcludeComments { - where = append(where, "`parent_uid` IS NULL") + where = append(where, `NOT EXISTS ( + SELECT 1 FROM memo_relation AS comment_relation + WHERE comment_relation.memo_id = memo.id AND comment_relation.type = 'COMMENT' + )`) } order := "DESC" @@ -130,16 +203,19 @@ func (d *DB) ListMemos(ctx context.Context, find *store.FindMemo) ([]*store.Memo "`memo`.`visibility` AS `visibility`", "`memo`.`pinned` AS `pinned`", "`memo`.`payload` AS `payload`", - "CASE WHEN `parent_memo`.`uid` IS NOT NULL THEN `parent_memo`.`uid` ELSE NULL END AS `parent_uid`", + "`memo`.`space_id` AS `space_id`", + `(SELECT parent_memo.uid + FROM memo_relation AS parent_relation + JOIN memo AS parent_memo ON parent_memo.id = parent_relation.related_memo_id + WHERE parent_relation.memo_id = memo.id AND parent_relation.type = 'COMMENT' + ORDER BY parent_memo.id LIMIT 1) AS parent_uid`, } if !find.ExcludeContent { fields = append(fields, "`memo`.`content` AS `content`") } - query := "SELECT " + strings.Join(fields, ", ") + "FROM `memo` " + + query := "SELECT " + strings.Join(fields, ", ") + " FROM `memo` " + "LEFT JOIN `user` AS `memo_creator` ON `memo`.`creator_id` = `memo_creator`.`id` " + - "LEFT JOIN `memo_relation` ON `memo`.`id` = `memo_relation`.`memo_id` AND `memo_relation`.`type` = \"COMMENT\" " + - "LEFT JOIN `memo` AS `parent_memo` ON `memo_relation`.`related_memo_id` = `parent_memo`.`id` " + "WHERE " + strings.Join(where, " AND ") + " " + "ORDER BY " + strings.Join(orderBy, ", ") if find.Limit != nil { @@ -169,6 +245,7 @@ func (d *DB) ListMemos(ctx context.Context, find *store.FindMemo) ([]*store.Memo &memo.Visibility, &memo.Pinned, &payloadBytes, + &memo.SpaceID, &memo.ParentUID, } if !find.ExcludeContent { @@ -193,7 +270,21 @@ func (d *DB) ListMemos(ctx context.Context, find *store.FindMemo) ([]*store.Memo } func (d *DB) UpdateMemo(ctx context.Context, update *store.UpdateMemo) error { - return applyMemoUpdate(ctx, d.db, update) + if update.Policy == nil { + return applyMemoUpdate(ctx, d.db, update) + } + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer func() { _ = tx.Rollback() }() + if err := validateSQLiteMemoWritePolicy(ctx, tx, update.ID, update.Policy, update); err != nil { + return err + } + if err := applyMemoUpdate(ctx, tx, update); err != nil { + return err + } + return tx.Commit() } func (d *DB) DeleteMemo(ctx context.Context, delete *store.DeleteMemo) error { diff --git a/store/db/sqlite/memo_access.go b/store/db/sqlite/memo_access.go new file mode 100644 index 00000000..aaf0c849 --- /dev/null +++ b/store/db/sqlite/memo_access.go @@ -0,0 +1,45 @@ +package sqlite + +import ( + "fmt" + "strings" + + "github.com/usememos/memos/store" +) + +// sqliteMemoAccessPredicate builds the canonical memo-local read predicate for +// memoAlias and appends its bind values to args. +func sqliteMemoAccessPredicate(access *store.MemoAccessScope, memoAlias, memberAlias string, args *[]any) string { + clauses := []string{} + if access.AllowPublic { + clauses = append(clauses, memoAlias+".`visibility` = 'PUBLIC'") + } + if access.UserID != nil { + *args = append(*args, *access.UserID) + authenticatedClauses := []string{} + + *args = append(*args, *access.UserID) + authenticatedClauses = append(authenticatedClauses, "("+memoAlias+".`visibility` = 'PRIVATE' AND "+memoAlias+".`creator_id` = ?)") + if access.AllowProtected { + authenticatedClauses = append(authenticatedClauses, memoAlias+".`visibility` = 'PROTECTED'") + } + *args = append(*args, *access.UserID) + authenticatedClauses = append(authenticatedClauses, "("+memoAlias+".`visibility` = 'SPACE' AND EXISTS (SELECT 1 FROM `space_member` AS "+memberAlias+" WHERE "+memberAlias+".`space_id` = "+memoAlias+".`space_id` AND "+memberAlias+".`user_id` = ? AND "+memberAlias+".`role` IN ('ADMIN', 'USER')))") + + clauses = append(clauses, "(EXISTS (SELECT 1 FROM `user` AS `access_user` WHERE `access_user`.`id` = ? AND `access_user`.`row_status` = 'NORMAL') AND ("+strings.Join(authenticatedClauses, " OR ")+"))") + } + if len(clauses) == 0 { + return "1 = 0" + } + + validMemo := "(" + memoAlias + ".`visibility` IN ('PUBLIC', 'PROTECTED', 'PRIVATE', 'SPACE')" + + " AND EXISTS (SELECT 1 FROM `user` AS `valid_creator` WHERE `valid_creator`.`id` = " + memoAlias + ".`creator_id` AND `valid_creator`.`row_status` IN ('NORMAL', 'ARCHIVED'))" + + " AND (" + memoAlias + ".`visibility` <> 'SPACE' OR (" + memoAlias + ".`space_id` IS NOT NULL" + + " AND EXISTS (SELECT 1 FROM `space` AS `valid_space` WHERE `valid_space`.`id` = " + memoAlias + ".`space_id`))))" + validState := memoAlias + ".`row_status` = 'NORMAL'" + if access.UserID != nil { + *args = append(*args, *access.UserID) + validState = fmt.Sprintf("(%s.`row_status` = 'NORMAL' OR (%s.`row_status` = 'ARCHIVED' AND %s.`creator_id` = ?))", memoAlias, memoAlias, memoAlias) + } + return "(" + strings.Join(clauses, " OR ") + ") AND " + validMemo + " AND " + validState +} diff --git a/store/db/sqlite/memo_attachment.go b/store/db/sqlite/memo_attachment.go index 27f39823..82a7354c 100644 --- a/store/db/sqlite/memo_attachment.go +++ b/store/db/sqlite/memo_attachment.go @@ -28,6 +28,44 @@ func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation _, _ = conn.ExecContext(context.WithoutCancel(ctx), "ROLLBACK") } }() + if err := validateSQLiteMemoRelationEndpoints(ctx, conn, mutation); err != nil { + return err + } + if create := mutation.MemoCreate; create != nil { + if err := validateSQLiteMemoCreate(ctx, conn, create); err != nil { + return err + } + if mutation.CommentContextMemoID != nil { + if err := authorizeSQLiteMemoComment(ctx, conn, *mutation.CommentContextMemoID, create.CreatorID); err != nil { + return err + } + } + if err := insertSQLiteMemo(ctx, conn, create); err != nil { + return err + } + mutation.MemoID = create.ID + mutation.MemoCreatorID = create.CreatorID + mutation.ExpectedMemoContent = create.Content + for _, relation := range mutation.ReferenceRelations { + if relation != nil { + relation.MemoID = create.ID + } + } + if mutation.CommentContextMemoID != nil { + if err := insertSQLiteMemoCommentRelation(ctx, conn, create.ID, *mutation.CommentContextMemoID); err != nil { + return err + } + } + } + policy := mutation.Policy + if policy == nil && mutation.MemoUpdate != nil { + policy = mutation.MemoUpdate.Policy + } + if policy != nil { + if err := validateSQLiteMemoWritePolicy(ctx, conn, mutation.MemoID, policy, mutation.MemoUpdate); err != nil { + return err + } + } var creatorID int32 var content string @@ -40,6 +78,18 @@ func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation if creatorID != mutation.MemoCreatorID || content != mutation.ExpectedMemoContent { return errors.Wrap(store.ErrMemoMutationConflict, "memo changed while applying mutation") } + removedAttachments, err := listSQLiteAttachmentSnapshots(ctx, conn, mutation.RemovedAttachmentIDs) + if err != nil { + return errors.Wrap(err, "failed to read removed attachments") + } + if len(removedAttachments) != len(mutation.RemovedAttachmentIDs) { + return errors.Wrap(store.ErrMemoMutationConflict, "removed attachment no longer exists") + } + for _, attachment := range removedAttachments { + if attachment.CreatorID != mutation.MemoCreatorID || attachment.MemoID == nil || *attachment.MemoID != mutation.MemoID { + return errors.Wrap(store.ErrMemoMutationConflict, "attachment is no longer removable from the memo") + } + } for _, binding := range mutation.Bindings { var attachmentCreatorID int32 @@ -61,13 +111,14 @@ func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation return errors.Wrap(err, "failed to bind attachment") } } - - for _, attachmentID := range mutation.RemovedAttachmentIDs { - result, err := conn.ExecContext(ctx, `UPDATE attachment SET memo_id = NULL WHERE id = ? AND memo_id = ?`, attachmentID, mutation.MemoID) + for _, attachment := range removedAttachments { + result, err := conn.ExecContext(ctx, `DELETE FROM attachment WHERE id = ? AND memo_id = ?`, attachment.ID, mutation.MemoID) if err != nil { - return errors.Wrap(err, "failed to detach attachment") + return errors.Wrap(err, "failed to delete removed attachment") } - if rows, err := result.RowsAffected(); err != nil || rows != 1 { + if rows, err := result.RowsAffected(); err != nil { + return errors.Wrap(err, "failed to count deleted removed attachment") + } else if rows != 1 { return errors.Wrap(store.ErrMemoMutationConflict, "attachment is no longer bound to the memo") } } @@ -102,6 +153,17 @@ func (d *DB) ApplyMemoMutation(ctx context.Context, mutation *store.MemoMutation return nil } +func insertSQLiteMemoCommentRelation(ctx context.Context, executor memoUpdateExecer, memoID, contextMemoID int32) error { + if memoID <= 0 || contextMemoID <= 0 || memoID == contextMemoID { + return errors.New("invalid COMMENT relation") + } + if _, err := executor.ExecContext(ctx, `INSERT INTO memo_relation (memo_id, related_memo_id, type) VALUES (?, ?, ?)`, + memoID, contextMemoID, store.MemoRelationComment); err != nil { + return errors.Wrap(err, "failed to insert COMMENT relation") + } + return nil +} + func replaceMemoReferenceRelations(ctx context.Context, executor memoUpdateExecer, memoID int32, relations []*store.MemoRelation) error { if _, err := executor.ExecContext(ctx, `DELETE FROM memo_relation WHERE memo_id = ? AND type = ?`, memoID, store.MemoRelationReference); err != nil { return errors.Wrap(err, "failed to delete memo reference relations") @@ -155,6 +217,11 @@ func applyMemoUpdate(ctx context.Context, executor memoUpdateExecer, update *sto } set, args = append(set, "`payload` = ?"), append(args, string(payload)) } + if update.ClearSpace { + set = append(set, "`space_id` = NULL") + } else if v := update.SpaceID; v != nil { + set, args = append(set, "`space_id` = ?"), append(args, *v) + } if len(set) == 0 { return nil } diff --git a/store/db/sqlite/memo_comment.go b/store/db/sqlite/memo_comment.go new file mode 100644 index 00000000..48d62f86 --- /dev/null +++ b/store/db/sqlite/memo_comment.go @@ -0,0 +1,56 @@ +package sqlite + +import ( + "context" + "database/sql" + stderrors "errors" + + "github.com/usememos/memos/store" +) + +func authorizeSQLiteMemoComment(ctx context.Context, tx dbExecutor, contextMemoID, actorUserID int32) error { + snapshot, err := loadSQLiteMemoParticipation(ctx, tx, contextMemoID, actorUserID) + if err != nil { + if stderrors.Is(err, sql.ErrNoRows) { + return store.ErrMemoSpaceNotWritable + } + return err + } + return store.ValidateMemoCommentAuthorization(snapshot) +} + +// loadSQLiteMemoParticipation resolves the current actor, Space, membership, +// and memo state shared by comment and reaction participation. +func loadSQLiteMemoParticipation(ctx context.Context, tx dbExecutor, memoID, actorUserID int32) (*store.MemoCommentAuthorizationSnapshot, error) { + snapshot := &store.MemoCommentAuthorizationSnapshot{ActorUserID: actorUserID, ContextID: memoID} + var actorStatus store.RowStatus + if err := tx.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", actorUserID).Scan(&actorStatus); err != nil { + if stderrors.Is(err, sql.ErrNoRows) { + return nil, store.ErrMemoPermissionDenied + } + return nil, err + } + snapshot.ActorActive = actorStatus == store.Normal + + var contextSpace sql.NullInt64 + err := tx.QueryRowContext(ctx, `SELECT creator_id, row_status, visibility, space_id FROM memo WHERE id = ?`, memoID).Scan( + &snapshot.ContextCreatorID, &snapshot.ContextRowStatus, &snapshot.ContextVisibility, &contextSpace, + ) + if err != nil { + return nil, err + } + snapshot.ContextSpaceID = store.NullInt32Pointer(contextSpace) + + if snapshot.ContextSpaceID != nil { + var exists bool + if err := tx.QueryRowContext(ctx, "SELECT EXISTS(SELECT 1 FROM space WHERE id = ?)", *snapshot.ContextSpaceID).Scan(&exists); err == nil { + snapshot.ContextSpaceExists = exists + } else if !stderrors.Is(err, sql.ErrNoRows) { + return nil, err + } + if snapshot.ContextMemberActive, err = sqliteSpaceMemberActive(ctx, tx, *snapshot.ContextSpaceID, actorUserID); err != nil { + return nil, err + } + } + return snapshot, nil +} diff --git a/store/db/sqlite/memo_delete_policy.go b/store/db/sqlite/memo_delete_policy.go new file mode 100644 index 00000000..2a3a706f --- /dev/null +++ b/store/db/sqlite/memo_delete_policy.go @@ -0,0 +1,67 @@ +package sqlite + +import ( + "context" + "database/sql" + + "github.com/pkg/errors" + + "github.com/usememos/memos/store" +) + +func (d *DB) DeleteMemoWithPolicy(ctx context.Context, delete *store.DeleteMemoWithPolicy) (*store.DeleteMemoWithPolicyResult, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, errors.Wrap(err, "failed to begin memo delete transaction") + } + defer func() { _ = tx.Rollback() }() + + var actorStatus store.RowStatus + if err := tx.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", delete.ActorUserID).Scan(&actorStatus); errors.Is(err, sql.ErrNoRows) { + return nil, store.ErrMemoPermissionDenied + } else if err != nil { + return nil, errors.Wrap(err, "failed to read memo deletion actor") + } else if actorStatus != store.Normal { + return nil, store.ErrMemoPermissionDenied + } + var creatorID int32 + var rowStatus store.RowStatus + var visibility store.Visibility + var space sql.NullInt64 + if err := tx.QueryRowContext(ctx, "SELECT creator_id, row_status, visibility, space_id FROM memo WHERE id = ?", delete.MemoID).Scan( + &creatorID, &rowStatus, &visibility, &space, + ); errors.Is(err, sql.ErrNoRows) { + return nil, store.ErrMemoMutationConflict + } else if err != nil { + return nil, errors.Wrap(err, "failed to read memo") + } else if creatorID != delete.ActorUserID { + return nil, store.ErrMemoPermissionDenied + } + spaceID := store.NullInt32Pointer(space) + spaceExists := false + actorMember := false + if spaceID != nil { + var existingSpaceID int32 + if err := tx.QueryRowContext(ctx, "SELECT id FROM space WHERE id = ?", *spaceID).Scan(&existingSpaceID); err == nil { + spaceExists = true + } else if !errors.Is(err, sql.ErrNoRows) { + return nil, errors.Wrap(err, "failed to read memo space") + } + if spaceExists { + actorMember, err = sqliteSpaceMemberActive(ctx, tx, *spaceID, delete.ActorUserID) + if err != nil { + return nil, errors.Wrap(err, "failed to read memo membership") + } + } + } + actorCanRead := store.MemoDeleteActorCanRead(rowStatus, visibility, spaceID, spaceExists, actorMember) + + attachments, err := deleteSQLiteMemoSetTx(ctx, tx, []int32{delete.MemoID}) + if err != nil { + return nil, errors.Wrap(err, "failed to delete memo set") + } + if err := tx.Commit(); err != nil { + return nil, errors.Wrap(err, "failed to commit memo delete transaction") + } + return &store.DeleteMemoWithPolicyResult{ActorCanRead: actorCanRead, Attachments: attachments}, nil +} diff --git a/store/db/sqlite/memo_policy.go b/store/db/sqlite/memo_policy.go new file mode 100644 index 00000000..afc6dcef --- /dev/null +++ b/store/db/sqlite/memo_policy.go @@ -0,0 +1,85 @@ +package sqlite + +import ( + "context" + "database/sql" + stderrors "errors" + + "github.com/usememos/memos/store" +) + +func validateSQLiteMemoWritePolicy(ctx context.Context, executor dbExecutor, memoID int32, policy *store.MemoWritePolicy, update *store.UpdateMemo) error { + var actorStatus store.RowStatus + if err := executor.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", policy.ActorUserID).Scan(&actorStatus); stderrors.Is(err, sql.ErrNoRows) { + return store.ErrMemoSpaceMembershipRequired + } else if err != nil { + return err + } else if actorStatus != store.Normal { + return store.ErrMemoSpaceMembershipRequired + } + + snapshot := new(store.MemoWriteSnapshot) + var spaceID sql.NullInt64 + if err := executor.QueryRowContext(ctx, `SELECT creator_id, row_status, space_id, visibility FROM memo WHERE id = ?`, memoID).Scan( + &snapshot.CreatorID, &snapshot.RowStatus, &spaceID, &snapshot.Visibility, + ); err != nil { + if stderrors.Is(err, sql.ErrNoRows) { + return store.ErrMemoMutationConflict + } + return err + } + snapshot.SpaceID = store.NullInt32Pointer(spaceID) + if err := populateSQLiteMemoPolicySpaceState(ctx, executor, policy.ActorUserID, update, snapshot); err != nil { + return err + } + + if update != nil && update.Visibility != nil && *update.Visibility == store.SpaceAudience { + var shareID int32 + err := executor.QueryRowContext(ctx, `SELECT id FROM memo_share + WHERE memo_id = ? AND (expires_ts IS NULL OR expires_ts > CAST(strftime('%s', 'now') AS INTEGER)) + LIMIT 1`, memoID).Scan(&shareID) + snapshot.HasActiveShare = err == nil + if err != nil && !stderrors.Is(err, sql.ErrNoRows) { + return err + } + } + return store.ValidateMemoWriteSnapshot(policy, update, snapshot) +} + +func populateSQLiteMemoPolicySpaceState( + ctx context.Context, + executor dbExecutor, + actorUserID int32, + update *store.UpdateMemo, + snapshot *store.MemoWriteSnapshot, +) error { + if snapshot.SpaceID != nil { + exists, member, err := sqliteMemoPolicySpaceState(ctx, executor, *snapshot.SpaceID, actorUserID) + if err != nil { + return err + } + snapshot.SourceSpaceExists = exists + snapshot.SourceMemberActive = member + } + if update != nil && update.SpaceID != nil { + exists, member, err := sqliteMemoPolicySpaceState(ctx, executor, *update.SpaceID, actorUserID) + if err != nil { + return err + } + snapshot.TargetSpaceExists = exists + snapshot.TargetMemberActive = member + } + return nil +} + +func sqliteMemoPolicySpaceState(ctx context.Context, executor dbExecutor, spaceID, actorUserID int32) (bool, bool, error) { + var exists bool + if err := executor.QueryRowContext(ctx, "SELECT EXISTS(SELECT 1 FROM space WHERE id = ?)", spaceID).Scan(&exists); err != nil { + return false, false, err + } + if !exists { + return false, false, nil + } + member, err := sqliteSpaceMemberActive(ctx, executor, spaceID, actorUserID) + return true, member, err +} diff --git a/store/db/sqlite/memo_relation.go b/store/db/sqlite/memo_relation.go index 16631986..fa251df9 100644 --- a/store/db/sqlite/memo_relation.go +++ b/store/db/sqlite/memo_relation.go @@ -139,6 +139,9 @@ func (d *DB) ListMemoRelations(ctx context.Context, find *store.FindMemoRelation } func (d *DB) DeleteMemoRelation(ctx context.Context, delete *store.DeleteMemoRelation) error { + if err := store.ValidateMemoRelationDelete(delete); err != nil { + return err + } where, args := []string{"TRUE"}, []any{} if delete.MemoID != nil { where, args = append(where, "memo_id = ?"), append(args, *delete.MemoID) @@ -146,9 +149,7 @@ func (d *DB) DeleteMemoRelation(ctx context.Context, delete *store.DeleteMemoRel if delete.RelatedMemoID != nil { where, args = append(where, "related_memo_id = ?"), append(args, *delete.RelatedMemoID) } - if delete.Type != nil { - where, args = append(where, "type = ?"), append(args, *delete.Type) - } + where, args = append(where, "type = ?"), append(args, *delete.Type) stmt := ` DELETE FROM memo_relation WHERE ` + strings.Join(where, " AND ") diff --git a/store/db/sqlite/memo_relation_policy.go b/store/db/sqlite/memo_relation_policy.go new file mode 100644 index 00000000..2d1dc943 --- /dev/null +++ b/store/db/sqlite/memo_relation_policy.go @@ -0,0 +1,101 @@ +package sqlite + +import ( + "context" + "database/sql" + stderrors "errors" + "slices" + + "github.com/usememos/memos/store" +) + +type sqliteRelationMemoState struct { + id int32 + creatorID int32 + rowStatus store.RowStatus + visibility store.Visibility + spaceID *int32 +} + +func validateSQLiteMemoRelationEndpoints(ctx context.Context, executor dbExecutor, mutation *store.MemoMutation) error { + if !mutation.ReplaceReferenceRelations && mutation.CommentContextMemoID == nil { + return nil + } + + var actorStatus store.RowStatus + if err := executor.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", mutation.MemoCreatorID).Scan(&actorStatus); err != nil { + if stderrors.Is(err, sql.ErrNoRows) { + return store.ErrMemoPermissionDenied + } + return err + } + + endpointIDs := sqliteRelationAuthorizationEndpointIDs(mutation) + for _, endpointID := range endpointIDs { + state, err := getSQLiteRelationMemoState(ctx, executor, endpointID) + if err != nil { + if stderrors.Is(err, sql.ErrNoRows) { + return store.ErrMemoMutationConflict + } + return err + } + snapshot := &store.MemoRelationEndpointSnapshot{ + ActorUserID: mutation.MemoCreatorID, + ActorActive: actorStatus == store.Normal, + EndpointID: state.id, + EndpointCreatorID: state.creatorID, + EndpointRowStatus: state.rowStatus, + EndpointVisibility: state.visibility, + EndpointSpaceID: state.spaceID, + } + if state.spaceID != nil { + if err := executor.QueryRowContext(ctx, "SELECT EXISTS(SELECT 1 FROM space WHERE id = ?)", *state.spaceID).Scan(&snapshot.EndpointSpaceExists); err != nil { + return err + } + if snapshot.EndpointSpaceExists { + active, err := sqliteSpaceMemberActive(ctx, executor, *state.spaceID, mutation.MemoCreatorID) + if err != nil { + return err + } + snapshot.EndpointMemberActive = active + } + } + if err := store.ValidateMemoRelationEndpointRead(snapshot); err != nil { + return err + } + } + return nil +} + +func getSQLiteRelationMemoState(ctx context.Context, executor dbExecutor, memoID int32) (*sqliteRelationMemoState, error) { + state := &sqliteRelationMemoState{} + var spaceID sql.NullInt64 + if err := executor.QueryRowContext(ctx, `SELECT id, creator_id, row_status, visibility, space_id + FROM memo WHERE id = ?`, memoID).Scan( + &state.id, &state.creatorID, &state.rowStatus, &state.visibility, &spaceID, + ); err != nil { + return nil, err + } + state.spaceID = store.NullInt32Pointer(spaceID) + return state, nil +} + +func sqliteRelationAuthorizationEndpointIDs(mutation *store.MemoMutation) []int32 { + unique := make(map[int32]struct{}, len(mutation.ReferenceRelations)+1) + if mutation.MemoCreate == nil && mutation.MemoID > 0 { + unique[mutation.MemoID] = struct{}{} + } else if mutation.CommentContextMemoID != nil { + unique[*mutation.CommentContextMemoID] = struct{}{} + } + for _, relation := range mutation.ReferenceRelations { + if relation != nil { + unique[relation.RelatedMemoID] = struct{}{} + } + } + ids := make([]int32, 0, len(unique)) + for id := range unique { + ids = append(ids, id) + } + slices.Sort(ids) + return ids +} diff --git a/store/db/sqlite/memo_share.go b/store/db/sqlite/memo_share.go index ab466799..ad236bcb 100644 --- a/store/db/sqlite/memo_share.go +++ b/store/db/sqlite/memo_share.go @@ -10,6 +10,32 @@ import ( ) func (d *DB) CreateMemoShare(ctx context.Context, create *store.MemoShare) (*store.MemoShare, error) { + if create.Policy == nil { + return createSQLiteMemoShare(ctx, d.db, create) + } + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := validateSQLiteMemoWritePolicy(ctx, tx, create.MemoID, create.Policy, nil); err != nil { + return nil, err + } + result, err := createSQLiteMemoShare(ctx, tx, create) + if err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return result, nil +} + +type sqliteMemoShareCreator interface { + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func createSQLiteMemoShare(ctx context.Context, executor sqliteMemoShareCreator, create *store.MemoShare) (*store.MemoShare, error) { fields := []string{"`uid`", "`memo_id`", "`creator_id`"} placeholders := []string{"?", "?", "?"} args := []any{create.UID, create.MemoID, create.CreatorID} @@ -21,7 +47,7 @@ func (d *DB) CreateMemoShare(ctx context.Context, create *store.MemoShare) (*sto } stmt := "INSERT INTO `memo_share` (" + strings.Join(fields, ", ") + ") VALUES (" + strings.Join(placeholders, ", ") + ") RETURNING `id`, `created_ts`" - if err := d.db.QueryRowContext(ctx, stmt, args...).Scan( + if err := executor.QueryRowContext(ctx, stmt, args...).Scan( &create.ID, &create.CreatedTs, ); err != nil { @@ -132,6 +158,35 @@ func (d *DB) GetMemoShare(ctx context.Context, find *store.FindMemoShare) (*stor } func (d *DB) DeleteMemoShare(ctx context.Context, delete *store.DeleteMemoShare) error { + if delete.Policy != nil { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer func() { _ = tx.Rollback() }() + if err := validateSQLiteMemoWritePolicy(ctx, tx, *delete.MemoID, delete.Policy, nil); err != nil { + return err + } + where, args := sqliteMemoShareDeleteWhere(delete) + where = append(where, "`memo_id` = ?") + args = append(args, *delete.MemoID) + result, err := tx.ExecContext(ctx, "DELETE FROM `memo_share` WHERE "+strings.Join(where, " AND "), args...) + if err != nil { + return err + } + if rows, err := result.RowsAffected(); err != nil { + return err + } else if rows != 1 { + return store.ErrMemoMutationConflict + } + return tx.Commit() + } + where, args := sqliteMemoShareDeleteWhere(delete) + _, err := d.db.ExecContext(ctx, "DELETE FROM `memo_share` WHERE "+strings.Join(where, " AND "), args...) + return err +} + +func sqliteMemoShareDeleteWhere(delete *store.DeleteMemoShare) ([]string, []any) { where, args := []string{"1 = 1"}, []any{} if delete.ID != nil { where, args = append(where, "`id` = ?"), append(args, *delete.ID) @@ -139,6 +194,5 @@ func (d *DB) DeleteMemoShare(ctx context.Context, delete *store.DeleteMemoShare) if delete.UID != nil { where, args = append(where, "`uid` = ?"), append(args, *delete.UID) } - _, err := d.db.ExecContext(ctx, "DELETE FROM `memo_share` WHERE "+strings.Join(where, " AND "), args...) - return err + return where, args } diff --git a/store/db/sqlite/memo_validation_test.go b/store/db/sqlite/memo_validation_test.go new file mode 100644 index 00000000..6558fadc --- /dev/null +++ b/store/db/sqlite/memo_validation_test.go @@ -0,0 +1,39 @@ +package sqlite + +import ( + "context" + "database/sql" + "testing" + + "github.com/stretchr/testify/require" + + "github.com/usememos/memos/store" +) + +func TestValidateSQLiteMemoCreatePreservesQueryErrors(t *testing.T) { + db, err := sql.Open("sqlite", ":memory:") + require.NoError(t, err) + t.Cleanup(func() { require.NoError(t, db.Close()) }) + _, err = db.Exec(` + CREATE TABLE user (id INTEGER PRIMARY KEY, row_status TEXT NOT NULL); + CREATE TABLE space (id INTEGER PRIMARY KEY); + CREATE TABLE space_member (space_id INTEGER, user_id INTEGER, role TEXT); + INSERT INTO user (id, row_status) VALUES (1, 'NORMAL'), (2, 'ARCHIVED'); + `) + require.NoError(t, err) + + canceledContext, cancel := context.WithCancel(context.Background()) + cancel() + err = validateSQLiteMemoCreate(canceledContext, db, &store.Memo{CreatorID: 1}) + require.ErrorIs(t, err, context.Canceled) + + err = validateSQLiteMemoCreate(context.Background(), db, &store.Memo{CreatorID: 99}) + require.ErrorIs(t, err, store.ErrMemoSpaceMembershipRequired) + err = validateSQLiteMemoCreate(context.Background(), db, &store.Memo{CreatorID: 2}) + require.ErrorIs(t, err, store.ErrMemoSpaceMembershipRequired) + + err = validateSQLiteMemoSpaceMember(canceledContext, db, 1, 1) + require.ErrorIs(t, err, context.Canceled) + err = validateSQLiteMemoSpaceMember(context.Background(), db, 99, 1) + require.ErrorIs(t, err, store.ErrMemoSpaceNotWritable) +} diff --git a/store/db/sqlite/reaction.go b/store/db/sqlite/reaction.go index 7e0c0a65..902af571 100644 --- a/store/db/sqlite/reaction.go +++ b/store/db/sqlite/reaction.go @@ -11,7 +11,33 @@ import ( ) func (d *DB) UpsertReaction(ctx context.Context, upsert *store.Reaction) (*store.Reaction, error) { - if err := d.db.QueryRowContext(ctx, ` + if upsert.Policy == nil { + return upsertSQLiteReaction(ctx, d.db, upsert) + } + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, errors.Wrap(err, "failed to begin reaction upsert transaction") + } + defer func() { _ = tx.Rollback() }() + if err := validateSQLiteReactionWritePolicy(ctx, tx, upsert); err != nil { + return nil, err + } + reaction, err := upsertSQLiteReaction(ctx, tx, upsert) + if err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, errors.Wrap(err, "failed to commit reaction upsert transaction") + } + return reaction, nil +} + +type sqliteReactionUpsertQuerier interface { + QueryRowContext(context.Context, string, ...any) *sql.Row +} + +func upsertSQLiteReaction(ctx context.Context, querier sqliteReactionUpsertQuerier, upsert *store.Reaction) (*store.Reaction, error) { + if err := querier.QueryRowContext(ctx, ` INSERT INTO reaction (creator_id, memo_id, reaction_type) SELECT ?, memo.id, ? FROM memo @@ -27,8 +53,7 @@ func (d *DB) UpsertReaction(ctx context.Context, upsert *store.Reaction) (*store return nil, err } - reaction := upsert - return reaction, nil + return upsert, nil } func (d *DB) ListReactions(ctx context.Context, find *store.FindReaction) ([]*store.Reaction, error) { @@ -104,6 +129,9 @@ func (d *DB) GetReaction(ctx context.Context, find *store.FindReaction) (*store. } func (d *DB) DeleteReaction(ctx context.Context, delete *store.DeleteReaction) error { + if delete.ActorUserID != nil { + return d.deleteReactionAsCreator(ctx, delete) + } where, args := []string{}, []any{} if delete.ID != nil { where, args = append(where, "`id` = ?"), append(args, *delete.ID) @@ -118,3 +146,38 @@ func (d *DB) DeleteReaction(ctx context.Context, delete *store.DeleteReaction) e _, err := d.db.ExecContext(ctx, "DELETE FROM `reaction` WHERE "+strings.Join(where, " AND "), args...) return err } + +func (d *DB) deleteReactionAsCreator(ctx context.Context, delete *store.DeleteReaction) error { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return errors.Wrap(err, "failed to begin authorized reaction delete transaction") + } + defer func() { _ = tx.Rollback() }() + if delete.Policy != nil { + if err := validateSQLiteReactionWritePolicy(ctx, tx, &store.Reaction{ + CreatorID: *delete.ActorUserID, + MemoID: *delete.MemoID, + Policy: delete.Policy, + }); err != nil { + return err + } + } + + var creatorID, memoID int32 + if err := tx.QueryRowContext(ctx, "SELECT creator_id, memo_id FROM reaction WHERE id = ?", *delete.ID).Scan(&creatorID, &memoID); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return nil + } + return errors.Wrap(err, "failed to read reaction for deletion") + } + if creatorID != *delete.ActorUserID || (delete.MemoID != nil && memoID != *delete.MemoID) { + return store.ErrReactionPermissionDenied + } + if _, err := tx.ExecContext(ctx, "DELETE FROM reaction WHERE id = ?", *delete.ID); err != nil { + return errors.Wrap(err, "failed to delete reaction") + } + if err := tx.Commit(); err != nil { + return errors.Wrap(err, "failed to commit authorized reaction delete transaction") + } + return nil +} diff --git a/store/db/sqlite/reaction_policy.go b/store/db/sqlite/reaction_policy.go new file mode 100644 index 00000000..f7db7397 --- /dev/null +++ b/store/db/sqlite/reaction_policy.go @@ -0,0 +1,35 @@ +package sqlite + +import ( + "context" + "database/sql" + + "github.com/pkg/errors" + + "github.com/usememos/memos/store" +) + +func validateSQLiteReactionWritePolicy(ctx context.Context, tx dbExecutor, reaction *store.Reaction) error { + policy := reaction.Policy + participation, err := loadSQLiteMemoParticipation(ctx, tx, reaction.MemoID, policy.ActorUserID) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrReactionMemoNotFound + } + return errors.Wrap(err, "failed to read reaction participation") + } + return store.ValidateReactionWriteParticipation(reaction, participation) +} + +func sqliteSpaceMemberActive(ctx context.Context, tx dbExecutor, spaceID, userID int32) (bool, error) { + var role store.SpaceMemberRole + err := tx.QueryRowContext(ctx, `SELECT role FROM space_member + WHERE space_id = ? AND user_id = ? AND role IN ('ADMIN', 'USER')`, spaceID, userID).Scan(&role) + if errors.Is(err, sql.ErrNoRows) { + return false, nil + } + if err != nil { + return false, err + } + return role.IsActiveMember(), nil +} diff --git a/store/db/sqlite/space.go b/store/db/sqlite/space.go new file mode 100644 index 00000000..bb961dcb --- /dev/null +++ b/store/db/sqlite/space.go @@ -0,0 +1,301 @@ +package sqlite + +import ( + "context" + "database/sql" + "fmt" + "strings" + + "github.com/pkg/errors" + msqlite "modernc.org/sqlite" + sqlite3 "modernc.org/sqlite/lib" + + "github.com/usememos/memos/store" +) + +func (d *DB) CreateSpace(ctx context.Context, create *store.Space, creatorID int32) (*store.Space, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, errors.Wrap(err, "failed to start space create transaction") + } + defer func() { _ = tx.Rollback() }() + if err := requireSQLiteActiveUser(ctx, tx, creatorID); err != nil { + return nil, err + } + + fields := []string{"uid", "title", "description"} + values := []string{"?", "?", "?"} + args := []any{create.UID, create.Title, create.Description} + query := "INSERT INTO space (" + strings.Join(fields, ", ") + ") VALUES (" + strings.Join(values, ", ") + ") RETURNING id, uid, title, description" + space := &store.Space{} + if err := tx.QueryRowContext(ctx, query, args...).Scan(&space.ID, &space.UID, &space.Title, &space.Description); err != nil { + if isSQLiteUniqueViolation(err) { + return nil, store.ErrSpaceAlreadyExists + } + return nil, errors.Wrap(err, "failed to create space") + } + if _, err := tx.ExecContext(ctx, "INSERT INTO space_member (space_id, user_id, role) VALUES (?, ?, ?)", space.ID, creatorID, store.SpaceMemberRoleAdmin); err != nil { + return nil, errors.Wrap(err, "failed to create initial space admin") + } + if err := tx.Commit(); err != nil { + return nil, errors.Wrap(err, "failed to commit space create transaction") + } + return space, nil +} + +func (d *DB) ListSpaces(ctx context.Context, find *store.FindSpace) ([]*store.Space, error) { + where, args := []string{"1 = 1"}, []any{} + if find.ID != nil { + where, args = append(where, "space.id = ?"), append(args, *find.ID) + } + if find.UID != nil { + where, args = append(where, "space.uid = ?"), append(args, *find.UID) + } + if find.MemberUserID != nil { + where, args = append(where, "EXISTS (SELECT 1 FROM space_member sm JOIN user u ON u.id = sm.user_id WHERE sm.space_id = space.id AND sm.user_id = ? AND sm.role IN ('ADMIN', 'USER') AND u.row_status = 'NORMAL')"), append(args, *find.MemberUserID) + } + query := `SELECT space.id, space.uid, space.title, space.description + FROM space WHERE ` + strings.Join(where, " AND ") + ` ORDER BY space.id DESC` + query = appendSQLiteLimit(query, find.Limit, find.Offset) + rows, err := d.db.QueryContext(ctx, query, args...) + if err != nil { + return nil, err + } + defer rows.Close() + spaces := []*store.Space{} + for rows.Next() { + space := &store.Space{} + if err := rows.Scan(&space.ID, &space.UID, &space.Title, &space.Description); err != nil { + return nil, err + } + spaces = append(spaces, space) + } + return spaces, rows.Err() +} + +func (d *DB) UpdateSpace(ctx context.Context, update *store.UpdateSpace, actorUserID int32) (*store.Space, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := authorizeSQLiteSpaceAdmin(ctx, tx, update.ID, actorUserID); err != nil { + return nil, err + } + sets, args := []string{}, []any{} + if update.Title != nil { + sets, args = append(sets, "title = ?"), append(args, *update.Title) + } + if update.Description != nil { + sets, args = append(sets, "description = ?"), append(args, *update.Description) + } + args = append(args, update.ID) + query := `UPDATE space SET ` + strings.Join(sets, ", ") + ` WHERE id = ? + RETURNING id, uid, title, description` + space := &store.Space{} + if err := tx.QueryRowContext(ctx, query, args...).Scan(&space.ID, &space.UID, &space.Title, &space.Description); err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return space, nil +} + +func (d *DB) CreateSpaceMember(ctx context.Context, create *store.SpaceMember, actorUserID int32) (*store.SpaceMember, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := authorizeSQLiteSpaceAdmin(ctx, tx, create.SpaceID, actorUserID); err != nil { + return nil, err + } + if err := requireSQLiteActiveUser(ctx, tx, create.UserID); err != nil { + return nil, err + } + query := `INSERT INTO space_member (space_id, user_id, role) VALUES (?, ?, ?) + RETURNING space_id, user_id, role` + member := &store.SpaceMember{} + if err := tx.QueryRowContext(ctx, query, create.SpaceID, create.UserID, create.Role).Scan(&member.SpaceID, &member.UserID, &member.Role); err != nil { + if isSQLiteUniqueViolation(err) { + return nil, store.ErrSpaceMemberAlreadyExists + } + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return member, nil +} + +func (d *DB) ListSpaceMembers(ctx context.Context, find *store.FindSpaceMember) ([]*store.SpaceMember, error) { + where, args := []string{ + "space_member.role IN ('ADMIN', 'USER')", + "EXISTS (SELECT 1 FROM space member_space WHERE member_space.id = space_member.space_id)", + "EXISTS (SELECT 1 FROM user member_user WHERE member_user.id = space_member.user_id AND member_user.row_status = 'NORMAL')", + }, []any{} + if find.SpaceID != nil { + where, args = append(where, "space_id = ?"), append(args, *find.SpaceID) + } + if find.UserID != nil { + where, args = append(where, "user_id = ?"), append(args, *find.UserID) + } + if find.ViewerUserID != nil { + where, args = append(where, "EXISTS (SELECT 1 FROM space_member viewer JOIN user viewer_user ON viewer_user.id = viewer.user_id WHERE viewer.space_id = space_member.space_id AND viewer.user_id = ? AND viewer.role IN ('ADMIN', 'USER') AND viewer_user.row_status = 'NORMAL')"), append(args, *find.ViewerUserID) + } + query := `SELECT space_id, user_id, role FROM space_member + WHERE ` + strings.Join(where, " AND ") + ` ORDER BY user_id ASC` + query = appendSQLiteLimit(query, find.Limit, find.Offset) + rows, err := d.db.QueryContext(ctx, query, args...) + if err != nil { + return nil, err + } + defer rows.Close() + members := []*store.SpaceMember{} + for rows.Next() { + member := &store.SpaceMember{} + if err := rows.Scan(&member.SpaceID, &member.UserID, &member.Role); err != nil { + return nil, err + } + members = append(members, member) + } + return members, rows.Err() +} + +func (d *DB) UpdateSpaceMember(ctx context.Context, update *store.UpdateSpaceMember, actorUserID int32) (*store.SpaceMember, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if err := authorizeSQLiteSpaceAdmin(ctx, tx, update.SpaceID, actorUserID); err != nil { + return nil, err + } + if err := requireSQLiteActiveUser(ctx, tx, update.UserID); err != nil { + return nil, err + } + var currentRole store.SpaceMemberRole + if err := tx.QueryRowContext(ctx, "SELECT role FROM space_member WHERE space_id = ? AND user_id = ?", update.SpaceID, update.UserID).Scan(¤tRole); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return nil, store.ErrSpaceMemberNotFound + } + return nil, err + } + if currentRole == store.SpaceMemberRoleAdmin && update.Role != nil && *update.Role != store.SpaceMemberRoleAdmin { + var count int + if err := tx.QueryRowContext(ctx, "SELECT COUNT(*) FROM space_member sm JOIN user u ON u.id = sm.user_id WHERE sm.space_id = ? AND sm.role = ? AND u.row_status = 'NORMAL'", update.SpaceID, store.SpaceMemberRoleAdmin).Scan(&count); err != nil { + return nil, err + } + if count <= 1 { + return nil, store.ErrLastSpaceAdmin + } + } + sets, args := []string{}, []any{} + if update.Role != nil { + sets, args = append(sets, "role = ?"), append(args, *update.Role) + } + args = append(args, update.SpaceID, update.UserID) + query := `UPDATE space_member SET ` + strings.Join(sets, ", ") + ` WHERE space_id = ? AND user_id = ? + RETURNING space_id, user_id, role` + member := &store.SpaceMember{} + if err := tx.QueryRowContext(ctx, query, args...).Scan(&member.SpaceID, &member.UserID, &member.Role); err != nil { + return nil, err + } + if err := tx.Commit(); err != nil { + return nil, err + } + return member, nil +} + +func (d *DB) DeleteSpaceMember(ctx context.Context, delete *store.DeleteSpaceMember, actorUserID int32) error { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return err + } + defer func() { _ = tx.Rollback() }() + var spaceID int32 + if err := tx.QueryRowContext(ctx, "SELECT id FROM space WHERE id = ?", delete.SpaceID).Scan(&spaceID); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrSpaceNotFound + } + return err + } + if actorUserID != delete.UserID { + var actorRole store.SpaceMemberRole + if err := tx.QueryRowContext(ctx, "SELECT sm.role FROM space_member sm JOIN user u ON u.id = sm.user_id WHERE sm.space_id = ? AND sm.user_id = ? AND u.row_status = 'NORMAL'", delete.SpaceID, actorUserID).Scan(&actorRole); errors.Is(err, sql.ErrNoRows) { + return store.ErrSpacePermissionDenied + } else if err != nil { + return err + } else if actorRole != store.SpaceMemberRoleAdmin { + return store.ErrSpacePermissionDenied + } + } + var role store.SpaceMemberRole + var targetStatus sql.NullString + if err := tx.QueryRowContext(ctx, "SELECT sm.role, u.row_status FROM space_member sm LEFT JOIN user u ON u.id = sm.user_id WHERE sm.space_id = ? AND sm.user_id = ?", delete.SpaceID, delete.UserID).Scan(&role, &targetStatus); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrSpaceMemberNotFound + } + return err + } + if role == store.SpaceMemberRoleAdmin && targetStatus.Valid && store.RowStatus(targetStatus.String) == store.Normal { + var count int + if err := tx.QueryRowContext(ctx, "SELECT COUNT(*) FROM space_member sm JOIN user u ON u.id = sm.user_id WHERE sm.space_id = ? AND sm.role = ? AND u.row_status = 'NORMAL'", delete.SpaceID, store.SpaceMemberRoleAdmin).Scan(&count); err != nil { + return err + } + if count <= 1 { + return store.ErrLastSpaceAdmin + } + } + if _, err := tx.ExecContext(ctx, "DELETE FROM space_member WHERE space_id = ? AND user_id = ?", delete.SpaceID, delete.UserID); err != nil { + return err + } + return tx.Commit() +} + +func appendSQLiteLimit(query string, limit, offset *int) string { + if limit != nil { + query = fmt.Sprintf("%s LIMIT %d", query, *limit) + if offset != nil { + query = fmt.Sprintf("%s OFFSET %d", query, *offset) + } + } + return query +} + +func authorizeSQLiteSpaceAdmin(ctx context.Context, tx dbExecutor, spaceID, actorUserID int32) error { + var existingSpaceID int32 + if err := tx.QueryRowContext(ctx, "SELECT id FROM space WHERE id = ?", spaceID).Scan(&existingSpaceID); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrSpaceNotFound + } + return err + } + var role store.SpaceMemberRole + if err := tx.QueryRowContext(ctx, "SELECT sm.role FROM space_member sm JOIN user u ON u.id = sm.user_id WHERE sm.space_id = ? AND sm.user_id = ? AND u.row_status = 'NORMAL'", spaceID, actorUserID).Scan(&role); errors.Is(err, sql.ErrNoRows) { + return store.ErrSpacePermissionDenied + } else if err != nil { + return err + } else if role != store.SpaceMemberRoleAdmin { + return store.ErrSpacePermissionDenied + } + return nil +} + +func requireSQLiteActiveUser(ctx context.Context, tx dbExecutor, userID int32) error { + var rowStatus store.RowStatus + if err := tx.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", userID).Scan(&rowStatus); errors.Is(err, sql.ErrNoRows) { + return store.ErrSpaceMemberNotActive + } else if err != nil { + return err + } else if rowStatus != store.Normal { + return store.ErrSpaceMemberNotActive + } + return nil +} + +func isSQLiteUniqueViolation(err error) bool { + var sqliteErr *msqlite.Error + return errors.As(err, &sqliteErr) && (sqliteErr.Code() == sqlite3.SQLITE_CONSTRAINT_UNIQUE || sqliteErr.Code() == sqlite3.SQLITE_CONSTRAINT_PRIMARYKEY) +} diff --git a/store/db/sqlite/space_delete.go b/store/db/sqlite/space_delete.go new file mode 100644 index 00000000..df7fa78f --- /dev/null +++ b/store/db/sqlite/space_delete.go @@ -0,0 +1,138 @@ +package sqlite + +import ( + "context" + "database/sql" + + "github.com/pkg/errors" + + "github.com/usememos/memos/store" +) + +// DeleteSpace hard-deletes only memos directly placed in the Space. Relations +// are removed when either endpoint is deleted, but are never traversed. +func (d *DB) DeleteSpace(ctx context.Context, delete *store.DeleteSpace) (*store.DeleteSpaceResult, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, errors.Wrap(err, "failed to begin space delete transaction") + } + defer func() { _ = tx.Rollback() }() + + if err := requireSQLiteSpaceDeleteAdmin(ctx, tx, delete); err != nil { + return nil, err + } + memoIDs, err := listSQLiteSpaceDeleteMemoIDs(ctx, tx, delete.ID) + if err != nil { + return nil, errors.Wrap(err, "failed to collect assigned memos") + } + attachments, err := deleteSQLiteMemoSetTx(ctx, tx, memoIDs) + if err != nil { + return nil, errors.Wrap(err, "failed to delete assigned memo set") + } + if _, err := tx.ExecContext(ctx, "DELETE FROM space_member WHERE space_id = ?", delete.ID); err != nil { + return nil, errors.Wrap(err, "failed to delete space memberships") + } + result, err := tx.ExecContext(ctx, "DELETE FROM space WHERE id = ?", delete.ID) + if err != nil { + return nil, errors.Wrap(err, "failed to delete space") + } + if count, err := result.RowsAffected(); err != nil { + return nil, errors.Wrap(err, "failed to count deleted spaces") + } else if count != 1 { + return nil, store.ErrSpaceNotFound + } + if err := tx.Commit(); err != nil { + return nil, errors.Wrap(err, "failed to commit space deletion") + } + return &store.DeleteSpaceResult{Attachments: attachments}, nil +} + +func requireSQLiteSpaceDeleteAdmin(ctx context.Context, tx dbExecutor, delete *store.DeleteSpace) error { + var actorStatus store.RowStatus + if err := tx.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", delete.ActorUserID).Scan(&actorStatus); errors.Is(err, sql.ErrNoRows) { + return store.ErrSpacePermissionDenied + } else if err != nil { + return errors.Wrap(err, "failed to read space deletion actor") + } else if actorStatus != store.Normal { + return store.ErrSpacePermissionDenied + } + var spaceID int32 + if err := tx.QueryRowContext(ctx, "SELECT id FROM space WHERE id = ?", delete.ID).Scan(&spaceID); err != nil { + if errors.Is(err, sql.ErrNoRows) { + return store.ErrSpaceNotFound + } + return err + } + var role store.SpaceMemberRole + if err := tx.QueryRowContext(ctx, "SELECT role FROM space_member WHERE space_id = ? AND user_id = ?", delete.ID, delete.ActorUserID).Scan(&role); errors.Is(err, sql.ErrNoRows) { + return store.ErrSpacePermissionDenied + } else if err != nil { + return errors.Wrap(err, "failed to read space administrator membership") + } else if role != store.SpaceMemberRoleAdmin { + return store.ErrSpacePermissionDenied + } + return nil +} + +func listSQLiteSpaceDeleteMemoIDs(ctx context.Context, tx dbExecutor, spaceID int32) ([]int32, error) { + rows, err := tx.QueryContext(ctx, "SELECT id FROM memo WHERE space_id = ? ORDER BY id", spaceID) + if err != nil { + return nil, err + } + defer rows.Close() + ids := make([]int32, 0) + for rows.Next() { + var id int32 + if err := rows.Scan(&id); err != nil { + return nil, err + } + ids = append(ids, id) + } + return ids, rows.Err() +} + +func deleteSQLiteMemoSetTx(ctx context.Context, tx dbExecutor, memoIDs []int32) ([]*store.Attachment, error) { + attachments, err := listSQLiteMemoSetAttachments(ctx, tx, memoIDs) + if err != nil { + return nil, errors.Wrap(err, "failed to collect memo attachments") + } + if err := deleteSQLiteMemoSetShares(ctx, tx, memoIDs); err != nil { + return nil, errors.Wrap(err, "failed to delete memo shares") + } + if err := deleteMemosTx(ctx, tx, memoIDs); err != nil { + return nil, errors.Wrap(err, "failed to delete memos") + } + if err := deleteReactionsByMemoIDsTx(ctx, tx, memoIDs); err != nil { + return nil, errors.Wrap(err, "failed to delete memo reactions") + } + if err := deleteAttachmentsByIDsTx(ctx, tx, attachmentIDsFromList(attachments)); err != nil { + return nil, errors.Wrap(err, "failed to delete memo attachments") + } + if err := deleteMemoRelationsTx(ctx, tx, memoIDs); err != nil { + return nil, errors.Wrap(err, "failed to delete incident memo relations") + } + return attachments, nil +} + +func listSQLiteMemoSetAttachments(ctx context.Context, tx dbExecutor, memoIDs []int32) ([]*store.Attachment, error) { + attachments := make([]*store.Attachment, 0) + seen := make(map[int32]struct{}) + for _, batch := range deleteUserBatches(memoIDs, deleteUserBatchSize) { + clause, args := deleteUserInClause(1, batch) + if err := appendDeleteUserAttachments(ctx, tx, `SELECT id, uid, creator_id, memo_id, storage_type, reference, payload + FROM attachment WHERE memo_id IN `+clause+` ORDER BY id`, args, seen, &attachments); err != nil { + return nil, err + } + } + return attachments, nil +} + +func deleteSQLiteMemoSetShares(ctx context.Context, tx dbExecutor, memoIDs []int32) error { + for _, batch := range deleteUserBatches(memoIDs, deleteUserBatchSize) { + clause, args := deleteUserInClause(1, batch) + if _, err := tx.ExecContext(ctx, "DELETE FROM memo_share WHERE memo_id IN "+clause, args...); err != nil { + return err + } + } + return nil +} diff --git a/store/db/sqlite/user.go b/store/db/sqlite/user.go index e6b1d094..28a98b8c 100644 --- a/store/db/sqlite/user.go +++ b/store/db/sqlite/user.go @@ -18,6 +18,16 @@ func (d *DB) CreateUser(ctx context.Context, create *store.User) (*store.User, e } func (d *DB) UpdateUser(ctx context.Context, update *store.UpdateUser) (*store.User, error) { + tx, err := d.db.BeginTx(ctx, nil) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback() }() + if update.RowStatus != nil && *update.RowStatus == store.Archived { + if err := validateSQLiteUserArchive(ctx, tx, update.ID); err != nil { + return nil, err + } + } set, args := []string{}, []any{} if v := update.UpdatedTs; v != nil { set, args = append(set, "updated_ts = ?"), append(args, *v) @@ -55,7 +65,7 @@ func (d *DB) UpdateUser(ctx context.Context, update *store.UpdateUser) (*store.U RETURNING id, username, role, email, nickname, password_hash, avatar_url, description, created_ts, updated_ts, row_status ` user := &store.User{} - if err := d.db.QueryRowContext(ctx, query, args...).Scan( + if err := tx.QueryRowContext(ctx, query, args...).Scan( &user.ID, &user.Username, &user.Role, @@ -70,10 +80,37 @@ func (d *DB) UpdateUser(ctx context.Context, update *store.UpdateUser) (*store.U ); err != nil { return nil, err } - + if err := tx.Commit(); err != nil { + return nil, err + } return user, nil } +func validateSQLiteUserArchive(ctx context.Context, tx dbExecutor, userID int32) error { + var current store.RowStatus + if err := tx.QueryRowContext(ctx, "SELECT row_status FROM user WHERE id = ?", userID).Scan(¤t); err != nil { + return err + } + if current != store.Normal { + return nil + } + var wouldLoseAdmin bool + err := tx.QueryRowContext(ctx, `SELECT EXISTS( + SELECT 1 FROM space_member target + WHERE target.user_id = ? AND target.role = 'ADMIN' + AND NOT EXISTS ( + SELECT 1 FROM space_member other JOIN user u ON u.id = other.user_id + WHERE other.space_id = target.space_id AND other.user_id <> ? AND other.role = 'ADMIN' AND u.row_status = 'NORMAL' + ))`, userID, userID).Scan(&wouldLoseAdmin) + if err != nil { + return err + } + if wouldLoseAdmin { + return store.ErrLastSpaceAdmin + } + return nil +} + func (d *DB) ListUsers(ctx context.Context, find *store.FindUser) ([]*store.User, error) { where, args := []string{"1 = 1"}, []any{} orderBy := []string{"created_ts DESC", "row_status DESC", "id DESC"} diff --git a/store/db/sqlite/user_delete.go b/store/db/sqlite/user_delete.go index f3b43969..e3db2188 100644 --- a/store/db/sqlite/user_delete.go +++ b/store/db/sqlite/user_delete.go @@ -29,6 +29,19 @@ func (d *DB) DeleteUser(ctx context.Context, delete *store.DeleteUser) (*store.D defer func() { _ = tx.Rollback() }() + var userID int32 + if err := tx.QueryRowContext(ctx, "SELECT id FROM user WHERE id = ?", delete.ID).Scan(&userID); errors.Is(err, sql.ErrNoRows) { + return &store.DeleteUserResult{}, nil + } else if err != nil { + return nil, errors.Wrap(err, "failed to read user") + } + var membershipCount int + if err := tx.QueryRowContext(ctx, "SELECT COUNT(*) FROM space_member WHERE user_id = ?", delete.ID).Scan(&membershipCount); err != nil { + return nil, errors.Wrap(err, "failed to check user space memberships") + } + if membershipCount != 0 { + return nil, store.ErrUserHasSpaceMembership + } targets, err := collectDeleteUserTargets(ctx, tx, delete.ID) if err != nil { @@ -53,10 +66,10 @@ func (d *DB) DeleteUser(ctx context.Context, delete *store.DeleteUser) (*store.D }, nil } -func collectDeleteUserTargets(ctx context.Context, tx *sql.Tx, userID int32) (*deleteUserTargetSet, error) { +func collectDeleteUserTargets(ctx context.Context, tx dbExecutor, userID int32) (*deleteUserTargetSet, error) { targets := &deleteUserTargetSet{} - memoIDs, err := listDeleteUserMemoTree(ctx, tx, userID) + memoIDs, err := listDeleteUserMemos(ctx, tx, userID) if err != nil { return nil, err } @@ -75,7 +88,7 @@ func collectDeleteUserTargets(ctx context.Context, tx *sql.Tx, userID int32) (*d } targets.userSettingKeys = userSettingKeys - inboxIDs, err := listDeleteUserInboxIDs(ctx, tx, userID, memoIDSet(memoIDs)) + inboxIDs, err := listDeleteUserInboxIDs(ctx, tx, userID) if err != nil { return nil, err } @@ -84,7 +97,7 @@ func collectDeleteUserTargets(ctx context.Context, tx *sql.Tx, userID int32) (*d return targets, nil } -func deleteUserTargetsTx(ctx context.Context, tx *sql.Tx, userID int32, targets *deleteUserTargetSet) error { +func deleteUserTargetsTx(ctx context.Context, tx dbExecutor, userID int32, targets *deleteUserTargetSet) error { memoIDs := targets.memoIDs // Delete the memo rows before their reactions: a concurrent UpsertReaction @@ -123,25 +136,8 @@ func deleteUserTargetsTx(ctx context.Context, tx *sql.Tx, userID int32, targets return nil } -func listDeleteUserMemoTree(ctx context.Context, tx *sql.Tx, userID int32) ([]int32, error) { - return listDeleteUserMemoTreeRecursive(ctx, tx, userID) -} - -func listDeleteUserMemoTreeRecursive(ctx context.Context, tx *sql.Tx, userID int32) ([]int32, error) { - rows, err := tx.QueryContext(ctx, ` - WITH RECURSIVE memo_tree(id) AS ( - SELECT id - FROM memo - WHERE creator_id = `+deleteUserPlaceholder(1)+` - UNION - SELECT child.id - FROM memo child - JOIN memo_relation rel ON rel.memo_id = child.id AND rel.type = 'COMMENT' - JOIN memo_tree parent ON rel.related_memo_id = parent.id - ) - SELECT id - FROM memo_tree - `, userID) +func listDeleteUserMemos(ctx context.Context, tx dbExecutor, userID int32) ([]int32, error) { + rows, err := tx.QueryContext(ctx, `SELECT id FROM memo WHERE creator_id = ? ORDER BY id`, userID) if err != nil { return nil, err } @@ -162,7 +158,7 @@ func listDeleteUserMemoTreeRecursive(ctx context.Context, tx *sql.Tx, userID int return memoIDs, nil } -func listDeleteUserAttachments(ctx context.Context, tx *sql.Tx, userID int32, memoIDs []int32) ([]*store.Attachment, error) { +func listDeleteUserAttachments(ctx context.Context, tx dbExecutor, userID int32, memoIDs []int32) ([]*store.Attachment, error) { attachments := make([]*store.Attachment, 0) seen := make(map[int32]struct{}) if err := appendDeleteUserAttachments(ctx, tx, ` @@ -199,7 +195,7 @@ func listDeleteUserAttachments(ctx context.Context, tx *sql.Tx, userID int32, me return attachments, nil } -func appendDeleteUserAttachments(ctx context.Context, tx *sql.Tx, query string, args []any, seen map[int32]struct{}, attachments *[]*store.Attachment) error { +func appendDeleteUserAttachments(ctx context.Context, tx dbExecutor, query string, args []any, seen map[int32]struct{}, attachments *[]*store.Attachment) error { rows, err := tx.QueryContext(ctx, query, args...) if err != nil { return err @@ -234,7 +230,7 @@ func appendDeleteUserAttachments(ctx context.Context, tx *sql.Tx, query string, return rows.Err() } -func listDeleteUserSettingKeys(ctx context.Context, tx *sql.Tx, userID int32) ([]storepb.UserSetting_Key, error) { +func listDeleteUserSettingKeys(ctx context.Context, tx dbExecutor, userID int32) ([]storepb.UserSetting_Key, error) { rows, err := tx.QueryContext(ctx, deleteUserSettingKeysQuery(), userID) if err != nil { return nil, err @@ -261,24 +257,7 @@ func deleteUserSettingKeysQuery() string { return `SELECT key FROM user_setting WHERE user_id = ` + deleteUserPlaceholder(1) } -func listDeleteUserInboxIDs(ctx context.Context, tx *sql.Tx, userID int32, memoIDSet map[int32]struct{}) ([]int32, error) { - directIDs, err := listDeleteUserDirectInboxIDs(ctx, tx, userID) - if err != nil { - return nil, err - } - inboxIDs := append([]int32{}, directIDs...) - if len(memoIDSet) == 0 { - return inboxIDs, nil - } - - memoIDs, err := listDeleteUserMemoReferencedInboxIDs(ctx, tx, userID, memoIDSet) - if err != nil { - return nil, err - } - return append(inboxIDs, memoIDs...), nil -} - -func listDeleteUserDirectInboxIDs(ctx context.Context, tx *sql.Tx, userID int32) ([]int32, error) { +func listDeleteUserInboxIDs(ctx context.Context, tx dbExecutor, userID int32) ([]int32, error) { rows, err := tx.QueryContext(ctx, ` SELECT id FROM inbox @@ -304,77 +283,7 @@ func listDeleteUserDirectInboxIDs(ctx context.Context, tx *sql.Tx, userID int32) return inboxIDs, nil } -func listDeleteUserMemoReferencedInboxIDs(ctx context.Context, tx *sql.Tx, userID int32, memoIDSet map[int32]struct{}) ([]int32, error) { - rows, err := tx.QueryContext(ctx, ` - SELECT id, message - FROM inbox - WHERE sender_id <> `+deleteUserPlaceholder(1)+` - AND receiver_id <> `+deleteUserPlaceholder(2), userID, userID) - if err != nil { - return nil, err - } - defer rows.Close() - - inboxIDs := make([]int32, 0) - for rows.Next() { - var ( - inboxID int32 - messageRaw []byte - ) - if err := rows.Scan(&inboxID, &messageRaw); err != nil { - return nil, err - } - if len(messageRaw) == 0 { - continue - } - - message := &storepb.InboxMessage{} - if err := protojsonUnmarshaler.Unmarshal(messageRaw, message); err != nil { - return nil, err - } - if inboxMessageTouchesMemoSet(message, memoIDSet) { - inboxIDs = append(inboxIDs, inboxID) - } - } - if err := rows.Err(); err != nil { - return nil, err - } - - return inboxIDs, nil -} - -func inboxMessageTouchesMemoSet(message *storepb.InboxMessage, memoIDSet map[int32]struct{}) bool { - if message == nil { - return false - } - - switch message.Type { - case storepb.InboxMessage_MEMO_COMMENT: - payload := message.GetMemoComment() - if payload == nil { - return false - } - return memoIDInSet(payload.MemoId, memoIDSet) || memoIDInSet(payload.RelatedMemoId, memoIDSet) - case storepb.InboxMessage_MEMO_MENTION: - payload := message.GetMemoMention() - if payload == nil { - return false - } - return memoIDInSet(payload.MemoId, memoIDSet) || memoIDInSet(payload.RelatedMemoId, memoIDSet) - default: - return false - } -} - -func memoIDInSet(id int32, memoIDSet map[int32]struct{}) bool { - if id == 0 { - return false - } - _, exists := memoIDSet[id] - return exists -} - -func deleteReactionsByMemoIDsTx(ctx context.Context, tx *sql.Tx, memoIDs []int32) error { +func deleteReactionsByMemoIDsTx(ctx context.Context, tx dbExecutor, memoIDs []int32) error { for _, batch := range deleteUserBatches(memoIDs, deleteUserBatchSize) { clause, args := deleteUserInClause(1, batch) if _, err := tx.ExecContext(ctx, `DELETE FROM reaction WHERE memo_id IN `+clause, args...); err != nil { @@ -384,7 +293,7 @@ func deleteReactionsByMemoIDsTx(ctx context.Context, tx *sql.Tx, memoIDs []int32 return nil } -func deleteAttachmentsByIDsTx(ctx context.Context, tx *sql.Tx, attachmentIDs []int32) error { +func deleteAttachmentsByIDsTx(ctx context.Context, tx dbExecutor, attachmentIDs []int32) error { for _, batch := range deleteUserBatches(attachmentIDs, deleteUserBatchSize) { clause, args := deleteUserInClause(1, batch) if _, err := tx.ExecContext(ctx, `DELETE FROM attachment WHERE id IN `+clause, args...); err != nil { @@ -394,12 +303,12 @@ func deleteAttachmentsByIDsTx(ctx context.Context, tx *sql.Tx, attachmentIDs []i return nil } -func deleteReactionsByCreatorTx(ctx context.Context, tx *sql.Tx, userID int32) error { +func deleteReactionsByCreatorTx(ctx context.Context, tx dbExecutor, userID int32) error { _, err := tx.ExecContext(ctx, `DELETE FROM reaction WHERE creator_id = `+deleteUserPlaceholder(1), userID) return err } -func deleteMemoSharesTx(ctx context.Context, tx *sql.Tx, userID int32, memoIDs []int32) error { +func deleteMemoSharesTx(ctx context.Context, tx dbExecutor, userID int32, memoIDs []int32) error { if _, err := tx.ExecContext(ctx, `DELETE FROM memo_share WHERE creator_id = `+deleteUserPlaceholder(1), userID); err != nil { return err } @@ -412,7 +321,7 @@ func deleteMemoSharesTx(ctx context.Context, tx *sql.Tx, userID int32, memoIDs [ return nil } -func deleteInboxesByIDsTx(ctx context.Context, tx *sql.Tx, inboxIDs []int32) error { +func deleteInboxesByIDsTx(ctx context.Context, tx dbExecutor, inboxIDs []int32) error { for _, batch := range deleteUserBatches(inboxIDs, deleteUserBatchSize) { clause, args := deleteUserInClause(1, batch) if _, err := tx.ExecContext(ctx, `DELETE FROM inbox WHERE id IN `+clause, args...); err != nil { @@ -422,17 +331,17 @@ func deleteInboxesByIDsTx(ctx context.Context, tx *sql.Tx, inboxIDs []int32) err return nil } -func deleteUserIdentitiesTx(ctx context.Context, tx *sql.Tx, userID int32) error { +func deleteUserIdentitiesTx(ctx context.Context, tx dbExecutor, userID int32) error { _, err := tx.ExecContext(ctx, `DELETE FROM user_identity WHERE user_id = `+deleteUserPlaceholder(1), userID) return err } -func deleteUserSettingsTx(ctx context.Context, tx *sql.Tx, userID int32) error { +func deleteUserSettingsTx(ctx context.Context, tx dbExecutor, userID int32) error { _, err := tx.ExecContext(ctx, `DELETE FROM user_setting WHERE user_id = `+deleteUserPlaceholder(1), userID) return err } -func deleteMemoRelationsTx(ctx context.Context, tx *sql.Tx, memoIDs []int32) error { +func deleteMemoRelationsTx(ctx context.Context, tx dbExecutor, memoIDs []int32) error { for _, batch := range deleteUserBatches(memoIDs, deleteUserBatchSize) { memoClause, args := deleteUserInClause(1, batch) relatedClause, relatedArgs := deleteUserInClause(len(args)+1, batch) @@ -445,7 +354,7 @@ func deleteMemoRelationsTx(ctx context.Context, tx *sql.Tx, memoIDs []int32) err return nil } -func deleteMemosTx(ctx context.Context, tx *sql.Tx, memoIDs []int32) error { +func deleteMemosTx(ctx context.Context, tx dbExecutor, memoIDs []int32) error { for _, batch := range deleteUserBatches(memoIDs, deleteUserBatchSize) { clause, args := deleteUserInClause(1, batch) if _, err := tx.ExecContext(ctx, `DELETE FROM memo WHERE id IN `+clause, args...); err != nil { @@ -455,7 +364,7 @@ func deleteMemosTx(ctx context.Context, tx *sql.Tx, memoIDs []int32) error { return nil } -func deleteUserRowTx(ctx context.Context, tx *sql.Tx, userID int32) error { +func deleteUserRowTx(ctx context.Context, tx dbExecutor, userID int32) error { _, err := tx.ExecContext(ctx, `DELETE FROM user WHERE id = `+deleteUserPlaceholder(1), userID) return err } @@ -490,14 +399,6 @@ func deleteUserBatches[T any](values []T, size int) [][]T { return batches } -func memoIDSet(memoIDs []int32) map[int32]struct{} { - idSet := make(map[int32]struct{}, len(memoIDs)) - for _, id := range memoIDs { - idSet[id] = struct{}{} - } - return idSet -} - func attachmentIDsFromList(attachments []*store.Attachment) []int32 { ids := make([]int32, 0, len(attachments)) for _, attachment := range attachments { diff --git a/store/driver.go b/store/driver.go index 2e626c9f..0c8f6884 100644 --- a/store/driver.go +++ b/store/driver.go @@ -24,6 +24,7 @@ type Driver interface { UpdateAttachment(ctx context.Context, update *UpdateAttachment) error DeleteAttachment(ctx context.Context, delete *DeleteAttachment) error DeleteAttachments(ctx context.Context, deletes []*DeleteAttachment) error + DeleteAttachmentsWithPolicy(ctx context.Context, policy *AttachmentDeletionPolicy, attachmentIDs []int32) error ApplyMemoMutation(ctx context.Context, mutation *MemoMutation) error // Memo model related methods. @@ -31,6 +32,17 @@ type Driver interface { ListMemos(ctx context.Context, find *FindMemo) ([]*Memo, error) UpdateMemo(ctx context.Context, update *UpdateMemo) error DeleteMemo(ctx context.Context, delete *DeleteMemo) error + DeleteMemoWithPolicy(ctx context.Context, delete *DeleteMemoWithPolicy) (*DeleteMemoWithPolicyResult, error) + + // Space model related methods. + CreateSpace(ctx context.Context, create *Space, creatorID int32) (*Space, error) + ListSpaces(ctx context.Context, find *FindSpace) ([]*Space, error) + UpdateSpace(ctx context.Context, update *UpdateSpace, actorUserID int32) (*Space, error) + DeleteSpace(ctx context.Context, delete *DeleteSpace) (*DeleteSpaceResult, error) + CreateSpaceMember(ctx context.Context, create *SpaceMember, actorUserID int32) (*SpaceMember, error) + ListSpaceMembers(ctx context.Context, find *FindSpaceMember) ([]*SpaceMember, error) + UpdateSpaceMember(ctx context.Context, update *UpdateSpaceMember, actorUserID int32) (*SpaceMember, error) + DeleteSpaceMember(ctx context.Context, delete *DeleteSpaceMember, actorUserID int32) error // MemoRelation model related methods. UpsertMemoRelation(ctx context.Context, create *MemoRelation) (*MemoRelation, error) diff --git a/store/memo.go b/store/memo.go index ce6cde28..266c368b 100644 --- a/store/memo.go +++ b/store/memo.go @@ -2,6 +2,7 @@ package store import ( "context" + "database/sql" "errors" "github.com/usememos/memos/internal/base" @@ -9,6 +10,22 @@ import ( storepb "github.com/usememos/memos/proto/gen/store" ) +// ErrMemoSpaceNotWritable indicates that a memo targets a missing or otherwise +// invalid Space. +var ErrMemoSpaceNotWritable = errors.New("memo space is not writable") + +// ErrMemoSpaceMembershipRequired indicates that the memo creator is not an +// active member of its assigned space. +var ErrMemoSpaceMembershipRequired = errors.New("active space membership required") + +// ErrMemoPermissionDenied indicates that the actor no longer owns the memo +// being mutated. +var ErrMemoPermissionDenied = errors.New("memo mutation permission denied") + +// ErrMemoShareConflict indicates that an active share conflicts with a +// SPACE audience transition. +var ErrMemoShareConflict = errors.New("active memo share conflicts with audience") + // Visibility is the type of a visibility. type Visibility string @@ -19,17 +36,12 @@ const ( Protected Visibility = "PROTECTED" // Private is the PRIVATE visibility. Private Visibility = "PRIVATE" + // SpaceAudience is visible only to active members of its space. + SpaceAudience Visibility = "SPACE" ) func (v Visibility) String() string { - switch v { - case Public: - return "PUBLIC" - case Protected: - return "PROTECTED" - default: - return "PRIVATE" - } + return string(v) } type Memo struct { @@ -49,6 +61,7 @@ type Memo struct { Visibility Visibility Pinned bool Payload *storepb.MemoPayload + SpaceID *int32 // Composed fields ParentUID *string @@ -66,10 +79,14 @@ type FindMemo struct { CreatorID *int32 // Domain specific fields - VisibilityList []Visibility - ExcludeContent bool - ExcludeComments bool - Filters []string + VisibilityList []Visibility + SpaceID *int32 + CommentContextMemoID *int32 + Unassigned bool + Access *MemoAccessScope + ExcludeContent bool + ExcludeComments bool + Filters []string // Pagination Limit *int @@ -100,6 +117,48 @@ type UpdateMemo struct { Visibility *Visibility Pinned *bool Payload *storepb.MemoPayload + SpaceID *int32 + ClearSpace bool + // Policy is set by transport-facing author mutations. Drivers revalidate it + // in the same transaction as the update; nil preserves trusted internal and + // migration callers. + Policy *MemoWritePolicy +} + +// MemoWritePolicy identifies the actor and the intended kind of +// transport-facing mutation. Drivers discover and authorize the current memo, +// Space, membership, and share state in the write transaction. +type MemoWritePolicy struct { + ActorUserID int32 + // LifecycleOnly permits an author who is no longer a member of the source + // Space to move or withdraw the memo. It never permits content, metadata, + // attachment, relation, or share mutations. + LifecycleOnly bool + // CreatingShare rejects a share if the memo's current audience is + // SPACE. Share revocation deliberately leaves this false. + CreatingShare bool +} + +// MemoWriteSnapshot is the current database state used to validate a +// MemoWritePolicy. Driver packages populate it in the mutation transaction. +type MemoWriteSnapshot struct { + CreatorID int32 + RowStatus RowStatus + SpaceID *int32 + Visibility Visibility + SourceSpaceExists bool + SourceMemberActive bool + TargetSpaceExists bool + TargetMemberActive bool + HasActiveShare bool +} + +// MemoAccessScope is a typed, fail-closed read authorization predicate. When +// present on FindMemo, drivers apply it in SQL before pagination. +type MemoAccessScope struct { + UserID *int32 + AllowPublic bool + AllowProtected bool } type DeleteMemo struct { @@ -107,12 +166,48 @@ type DeleteMemo struct { } func (s *Store) CreateMemo(ctx context.Context, create *Memo) (*Memo, error) { - if !base.UIDMatcher.MatchString(create.UID) { - return nil, errors.New("invalid uid") + if err := validateMemoCreate(create); err != nil { + return nil, err } return s.driver.CreateMemo(ctx, create) } +// CreateMemoComment atomically creates one independent memo and its immutable +// COMMENT relation to a context memo. +func (s *Store) CreateMemoComment(ctx context.Context, create *Memo, contextMemoID, actorUserID int32) (*Memo, error) { + if create == nil || contextMemoID <= 0 || actorUserID <= 0 || create.CreatorID != actorUserID { + return nil, errors.New("comment creation requires memo, context, and matching actor") + } + if create.Visibility == "" { + create.Visibility = Private + } + if err := s.ApplyMemoMutation(ctx, &MemoMutation{ + MemoCreate: create, + CommentContextMemoID: &contextMemoID, + MemoCreatorID: actorUserID, + ExpectedMemoContent: create.Content, + }); err != nil { + return nil, err + } + return create, nil +} + +func validateMemoCreate(create *Memo) error { + if create == nil { + return errors.New("memo is required") + } + if !base.UIDMatcher.MatchString(create.UID) { + return errors.New("invalid uid") + } + if !isValidVisibility(create.Visibility) { + return errors.New("invalid visibility") + } + if create.Visibility == SpaceAudience && create.SpaceID == nil { + return errors.New("SPACE visibility requires a space") + } + return nil +} + func (s *Store) ListMemos(ctx context.Context, find *FindMemo) ([]*Memo, error) { return s.driver.ListMemos(ctx, find) } @@ -134,26 +229,160 @@ func (s *Store) UpdateMemo(ctx context.Context, update *UpdateMemo) error { if update.UID != nil && !base.UIDMatcher.MatchString(*update.UID) { return errors.New("invalid uid") } + if update.Visibility != nil && !isValidVisibility(*update.Visibility) { + return errors.New("invalid visibility") + } + if update.ClearSpace && update.Visibility != nil && *update.Visibility == SpaceAudience { + return errors.New("SPACE visibility requires a space") + } + if err := validateMemoWritePolicy(update.Policy); err != nil { + return err + } + if update.Policy == nil { + return s.driver.UpdateMemo(ctx, update) + } return s.driver.UpdateMemo(ctx, update) } +func validateMemoWritePolicy(policy *MemoWritePolicy) error { + if policy == nil { + return nil + } + if policy.ActorUserID <= 0 { + return errors.New("memo write policy requires actor") + } + if policy.LifecycleOnly && policy.CreatingShare { + return errors.New("memo write policy has conflicting actions") + } + return nil +} + +// ValidateMemoWriteSnapshot applies the transport-independent write +// invariants to current database state. +func ValidateMemoWriteSnapshot(policy *MemoWritePolicy, update *UpdateMemo, snapshot *MemoWriteSnapshot) error { + if err := validateMemoWritePolicy(policy); err != nil { + return err + } + if policy == nil || snapshot == nil { + return errors.New("memo write policy snapshot is required") + } + if snapshot.CreatorID != policy.ActorUserID { + return ErrMemoPermissionDenied + } + if snapshot.RowStatus != Normal && snapshot.RowStatus != Archived { + return ErrMemoMutationConflict + } + if policy.CreatingShare && snapshot.RowStatus != Normal { + return ErrMemoMutationConflict + } + if !isValidVisibility(snapshot.Visibility) { + return ErrMemoMutationConflict + } + if policy.LifecycleOnly && !isLifecycleOnlyMemoUpdate(update) { + // The source-writability exception exists only for an author's explicit + // move or withdrawal after membership removal. It must never authorize a + // content or metadata mutation in the same transaction. + return ErrMemoSpaceMembershipRequired + } + if snapshot.SpaceID != nil { + if !snapshot.SourceSpaceExists { + return ErrMemoSpaceNotWritable + } + if !policy.LifecycleOnly && !snapshot.SourceMemberActive { + return ErrMemoSpaceMembershipRequired + } + } + + resultSpaceID := snapshot.SpaceID + resultVisibility := snapshot.Visibility + if update != nil { + if update.SpaceID != nil { + if !snapshot.TargetSpaceExists { + return ErrMemoSpaceNotWritable + } + if !snapshot.TargetMemberActive { + return ErrMemoSpaceMembershipRequired + } + resultSpaceID = update.SpaceID + } else if update.ClearSpace { + resultSpaceID = nil + } + if update.Visibility != nil { + resultVisibility = *update.Visibility + } + } + if !isValidVisibility(resultVisibility) { + return ErrMemoMutationConflict + } + placementChanged := !sameMemoSpace(resultSpaceID, snapshot.SpaceID) + if placementChanged && snapshot.Visibility == SpaceAudience && (update == nil || update.Visibility == nil) { + // Moving a current SPACE memo changes which membership grants + // access. Require the audience to be explicitly confirmed in the same + // mutation, even if a caller read an older audience before the transaction. + return ErrMemoMutationConflict + } + if policy.LifecycleOnly && !placementChanged { + return ErrMemoSpaceMembershipRequired + } + if resultVisibility == SpaceAudience && resultSpaceID == nil { + return ErrMemoSpaceNotWritable + } + if policy.CreatingShare && resultVisibility == SpaceAudience { + return ErrMemoShareConflict + } + if update != nil && update.Visibility != nil && *update.Visibility == SpaceAudience && snapshot.HasActiveShare { + return ErrMemoShareConflict + } + return nil +} + +func isLifecycleOnlyMemoUpdate(update *UpdateMemo) bool { + if update == nil || (!update.ClearSpace && update.SpaceID == nil) || (update.ClearSpace && update.SpaceID != nil) { + return false + } + return update.UID == nil && + update.CreatedTs == nil && + update.UpdatedTs == nil && + update.RowStatus == nil && + update.Content == nil && + update.Pinned == nil && + update.Payload == nil +} + +// NullInt32Pointer converts a nullable SQL integer to an optional int32. +func NullInt32Pointer(value sql.NullInt64) *int32 { + if !value.Valid { + return nil + } + result := int32(value.Int64) + return &result +} + +func sameMemoSpace(left, right *int32) bool { + if left == nil || right == nil { + return left == nil && right == nil + } + return *left == *right +} + +func isValidVisibility(visibility Visibility) bool { + return visibility == Public || visibility == Protected || visibility == Private || visibility == SpaceAudience +} + func (s *Store) DeleteMemo(ctx context.Context, delete *DeleteMemo) error { - // Clean up memo_relation records where this memo is either the source or target. - if err := s.driver.DeleteMemoRelation(ctx, &DeleteMemoRelation{MemoID: &delete.ID}); err != nil { - return err + if delete == nil || delete.ID <= 0 { + return errors.New("memo deletion requires a memo") } - if err := s.driver.DeleteMemoRelation(ctx, &DeleteMemoRelation{RelatedMemoID: &delete.ID}); err != nil { - return err - } - // Clean up attachments linked to this memo. - attachments, err := s.ListAttachments(ctx, &FindAttachment{MemoID: &delete.ID}) + memo, err := s.GetMemo(ctx, &FindMemo{ID: &delete.ID}) if err != nil { return err } - for _, attachment := range attachments { - if err := s.DeleteAttachment(ctx, &DeleteAttachment{ID: attachment.ID}); err != nil { - return err - } + if memo == nil { + return nil } - return s.driver.DeleteMemo(ctx, delete) + result, err := s.DeleteMemoWithPolicy(ctx, &DeleteMemoWithPolicy{MemoID: memo.ID, ActorUserID: memo.CreatorID}) + if err != nil { + return err + } + return s.deleteAttachmentStorageSnapshots(ctx, result.Attachments) } diff --git a/store/memo_attachment.go b/store/memo_attachment.go index 3f9c985b..8fa90a05 100644 --- a/store/memo_attachment.go +++ b/store/memo_attachment.go @@ -3,6 +3,7 @@ package store import ( "context" "errors" + "slices" ) // ErrMemoMutationConflict indicates that memo or attachment state changed @@ -21,10 +22,14 @@ type MemoAttachmentBinding struct { } // MemoMutation atomically updates a memo, its attachment bindings, and its -// reference relations. Removed attachment rows are detached in the transaction -// and are deleted from storage separately, so a storage failure remains -// retriable. +// reference relations. Removed attachment rows are deleted in the same +// transaction; callers may clean up external objects after the commit. type MemoMutation struct { + // MemoCreate requests that the memo row be created in this same transaction + // before attachments and relations are applied. CommentContextMemoID creates + // one immutable COMMENT relation from the new memo to the named context memo. + MemoCreate *Memo + CommentContextMemoID *int32 MemoID int32 MemoCreatorID int32 ExpectedMemoContent string @@ -34,6 +39,7 @@ type MemoMutation struct { RequiredAttachmentIDs []int32 ReplaceReferenceRelations bool ReferenceRelations []*MemoRelation + Policy *MemoWritePolicy } // ApplyMemoMutation atomically applies memo fields, attachment bindings, and @@ -42,5 +48,74 @@ func (s *Store) ApplyMemoMutation(ctx context.Context, mutation *MemoMutation) e if mutation == nil { return errors.New("memo mutation is required") } + if mutation.MemoCreate != nil { + if mutation.MemoUpdate != nil || mutation.Policy != nil || len(mutation.RemovedAttachmentIDs) != 0 { + return errors.New("memo creation mutation cannot update or remove existing state") + } + create := mutation.MemoCreate + if create.CreatorID <= 0 { + return errors.New("memo creation mutation requires creator") + } + if err := validateMemoCreate(create); err != nil { + return err + } + if mutation.CommentContextMemoID != nil && *mutation.CommentContextMemoID <= 0 { + return errors.New("comment creation mutation requires a valid context memo") + } + mutation.MemoCreatorID = create.CreatorID + mutation.ExpectedMemoContent = create.Content + } + if err := validateMemoWritePolicy(mutation.Policy); err != nil { + return err + } + mutation.RemovedAttachmentIDs = slices.Clone(mutation.RemovedAttachmentIDs) + slices.Sort(mutation.RemovedAttachmentIDs) + removedAttachmentIDs := make(map[int32]struct{}, len(mutation.RemovedAttachmentIDs)) + for index, attachmentID := range mutation.RemovedAttachmentIDs { + if attachmentID <= 0 { + return errors.New("removed attachment IDs must be positive") + } + if index > 0 && mutation.RemovedAttachmentIDs[index-1] == attachmentID { + return errors.New("duplicate removed attachment ID") + } + removedAttachmentIDs[attachmentID] = struct{}{} + } + for _, binding := range mutation.Bindings { + if binding != nil { + if _, removed := removedAttachmentIDs[binding.ID]; removed { + return errors.New("attachment cannot be both bound and removed") + } + } + } + for _, attachmentID := range mutation.RequiredAttachmentIDs { + if _, removed := removedAttachmentIDs[attachmentID]; removed { + return errors.New("attachment cannot be both required and removed") + } + } + if mutation.Policy != nil && mutation.Policy.LifecycleOnly && + (len(mutation.Bindings) != 0 || len(mutation.RemovedAttachmentIDs) != 0 || len(mutation.RequiredAttachmentIDs) != 0 || mutation.ReplaceReferenceRelations) { + return ErrMemoSpaceMembershipRequired + } + if mutation.ReplaceReferenceRelations { + if mutation.MemoCreatorID <= 0 { + return errors.New("reference relation mutation requires an actor") + } + seenRelatedMemoIDs := make(map[int32]struct{}, len(mutation.ReferenceRelations)) + for _, relation := range mutation.ReferenceRelations { + if relation == nil || relation.RelatedMemoID <= 0 || relation.Type != MemoRelationReference { + return errors.New("only REFERENCE memo relations may be mutated") + } + if mutation.MemoCreate == nil && relation.MemoID != mutation.MemoID { + return errors.New("reference relation source does not match memo mutation") + } + if mutation.MemoID > 0 && relation.RelatedMemoID == mutation.MemoID { + return errors.New("reflexive memo relations are not allowed") + } + if _, ok := seenRelatedMemoIDs[relation.RelatedMemoID]; ok { + return errors.New("duplicate memo reference relation") + } + seenRelatedMemoIDs[relation.RelatedMemoID] = struct{}{} + } + } return s.driver.ApplyMemoMutation(ctx, mutation) } diff --git a/store/memo_comment.go b/store/memo_comment.go new file mode 100644 index 00000000..56ef0f0e --- /dev/null +++ b/store/memo_comment.go @@ -0,0 +1,56 @@ +package store + +// MemoCommentAuthorizationSnapshot is the memo-local database state read by a +// driver before it creates an immutable COMMENT relation. +type MemoCommentAuthorizationSnapshot struct { + ActorUserID int32 + ActorActive bool + + ContextID int32 + ContextCreatorID int32 + ContextRowStatus RowStatus + ContextVisibility Visibility + ContextSpaceID *int32 + + ContextSpaceExists bool + ContextMemberActive bool +} + +// ValidateMemoCommentAuthorization validates participation in the context +// memo. The replying memo is authorized independently by the normal memo-create +// policy; no placement or audience is inherited from this snapshot. +func ValidateMemoCommentAuthorization(snapshot *MemoCommentAuthorizationSnapshot) error { + if snapshot == nil || snapshot.ActorUserID <= 0 || !snapshot.ActorActive { + return ErrMemoPermissionDenied + } + if snapshot.ContextID <= 0 || snapshot.ContextRowStatus != Normal || !isValidVisibility(snapshot.ContextVisibility) { + return ErrMemoSpaceNotWritable + } + if snapshot.ContextSpaceID == nil { + if snapshot.ContextVisibility == SpaceAudience { + return ErrMemoSpaceNotWritable + } + } else { + if !snapshot.ContextSpaceExists { + return ErrMemoSpaceNotWritable + } + // Participation in an assigned memo is narrower than reading it: active + // membership is required even for PUBLIC and PROTECTED audiences. + if !snapshot.ContextMemberActive { + return ErrMemoSpaceMembershipRequired + } + } + + switch snapshot.ContextVisibility { + case Private: + if snapshot.ContextCreatorID != snapshot.ActorUserID { + return ErrMemoPermissionDenied + } + case Protected, Public, SpaceAudience: + // Any audience-specific placement and membership requirements were + // validated above. + default: + return ErrMemoSpaceNotWritable + } + return nil +} diff --git a/store/memo_delete_policy.go b/store/memo_delete_policy.go new file mode 100644 index 00000000..ebb29424 --- /dev/null +++ b/store/memo_delete_policy.go @@ -0,0 +1,55 @@ +package store + +import ( + "context" + + "github.com/pkg/errors" +) + +// DeleteMemoWithPolicy identifies one author-owned memo to delete atomically. +// Relations do not confer lifecycle authority, so no related memo is deleted. +type DeleteMemoWithPolicy struct { + MemoID int32 + ActorUserID int32 +} + +// DeleteMemoWithPolicyResult contains authorization state captured by the +// deletion transaction. +type DeleteMemoWithPolicyResult struct { + ActorCanRead bool + Attachments []*Attachment +} + +// MemoDeleteActorCanRead applies the memo-local audience matrix after the +// deletion transaction has established that the actor is the active author. +// Invalid lifecycle or audience state fails closed. Placement validity matters +// only for the Space audience; it is not an extra read gate for other values. +func MemoDeleteActorCanRead(rowStatus RowStatus, visibility Visibility, spaceID *int32, spaceExists, actorMember bool) bool { + if rowStatus != Normal && rowStatus != Archived { + return false + } + switch visibility { + case Public, Protected, Private: + return true + case SpaceAudience: + return spaceID != nil && spaceExists && actorMember + default: + return false + } +} + +// DeleteMemoWithPolicy atomically deletes exactly one memo, its owned database +// resources, and relations for which it is an endpoint. +func (s *Store) DeleteMemoWithPolicy(ctx context.Context, delete *DeleteMemoWithPolicy) (*DeleteMemoWithPolicyResult, error) { + if delete == nil || delete.MemoID <= 0 || delete.ActorUserID <= 0 { + return nil, errors.New("memo deletion requires memo and actor") + } + result, err := s.driver.DeleteMemoWithPolicy(ctx, delete) + if err != nil { + return nil, err + } + if result == nil { + return nil, errors.New("unexpected nil memo deletion result") + } + return result, nil +} diff --git a/store/memo_relation.go b/store/memo_relation.go index c6645a64..e45117d7 100644 --- a/store/memo_relation.go +++ b/store/memo_relation.go @@ -2,6 +2,7 @@ package store import ( "context" + "errors" ) type MemoRelationType string @@ -19,6 +20,64 @@ type MemoRelation struct { Type MemoRelationType } +// MemoRelationEndpointSnapshot is the memo-local database state used to +// authorize one endpoint during a reference-relation mutation. +type MemoRelationEndpointSnapshot struct { + ActorUserID int32 + ActorActive bool + + EndpointID int32 + EndpointCreatorID int32 + EndpointRowStatus RowStatus + EndpointVisibility Visibility + EndpointSpaceID *int32 + + EndpointSpaceExists bool + EndpointMemberActive bool +} + +// ValidateMemoRelationEndpointRead applies authenticated memo-local read +// policy to an endpoint. Application roles are deliberately absent: an +// instance administrator has no relation-specific read bypass. +func ValidateMemoRelationEndpointRead(snapshot *MemoRelationEndpointSnapshot) error { + if snapshot == nil || !snapshot.ActorActive { + return ErrMemoPermissionDenied + } + if snapshot.EndpointID <= 0 { + return ErrMemoMutationConflict + } + if snapshot.EndpointRowStatus != Normal && snapshot.EndpointRowStatus != Archived { + return ErrMemoMutationConflict + } + if snapshot.EndpointRowStatus == Archived && snapshot.EndpointCreatorID != snapshot.ActorUserID { + return ErrMemoPermissionDenied + } + if !isValidVisibility(snapshot.EndpointVisibility) { + return ErrMemoMutationConflict + } + if snapshot.EndpointVisibility == SpaceAudience && + (snapshot.EndpointSpaceID == nil || !snapshot.EndpointSpaceExists) { + return ErrMemoMutationConflict + } + + switch snapshot.EndpointVisibility { + case Public, Protected: + return nil + case Private: + if snapshot.EndpointCreatorID != snapshot.ActorUserID { + return ErrMemoPermissionDenied + } + return nil + case SpaceAudience: + if !snapshot.EndpointMemberActive { + return ErrMemoPermissionDenied + } + return nil + default: + return ErrMemoMutationConflict + } +} + type FindMemoRelation struct { MemoID *int32 RelatedMemoID *int32 @@ -42,7 +101,29 @@ type DeleteMemoRelation struct { Type *MemoRelationType } +// ValidateMemoRelationDelete ensures the generic deletion path can only +// mutate reference relations. COMMENT relations are immutable context and are +// removed only as part of the lifecycle of an incident memo. +func ValidateMemoRelationDelete(delete *DeleteMemoRelation) error { + if delete == nil { + return errors.New("memo relation deletion is required") + } + if delete.Type == nil || *delete.Type != MemoRelationReference { + return errors.New("only REFERENCE memo relations may be deleted") + } + if delete.MemoID == nil && delete.RelatedMemoID == nil { + return errors.New("memo relation deletion requires an endpoint") + } + if (delete.MemoID != nil && *delete.MemoID <= 0) || (delete.RelatedMemoID != nil && *delete.RelatedMemoID <= 0) { + return errors.New("memo relation deletion has an invalid endpoint") + } + return nil +} + func (s *Store) UpsertMemoRelation(ctx context.Context, create *MemoRelation) (*MemoRelation, error) { + if create == nil || create.Type != MemoRelationReference { + return nil, errors.New("only REFERENCE memo relations may be persisted") + } return s.driver.UpsertMemoRelation(ctx, create) } @@ -51,5 +132,8 @@ func (s *Store) ListMemoRelations(ctx context.Context, find *FindMemoRelation) ( } func (s *Store) DeleteMemoRelation(ctx context.Context, delete *DeleteMemoRelation) error { + if err := ValidateMemoRelationDelete(delete); err != nil { + return err + } return s.driver.DeleteMemoRelation(ctx, delete) } diff --git a/store/memo_relation_policy_test.go b/store/memo_relation_policy_test.go new file mode 100644 index 00000000..b55b4977 --- /dev/null +++ b/store/memo_relation_policy_test.go @@ -0,0 +1,58 @@ +package store_test + +import ( + "testing" + + "github.com/stretchr/testify/require" + + "github.com/usememos/memos/store" +) + +func TestValidateMemoRelationEndpointReadDanglingPlacement(t *testing.T) { + danglingSpaceID := int32(42) + for _, visibility := range []store.Visibility{store.Public, store.Protected, store.Private} { + t.Run(string(visibility), func(t *testing.T) { + err := store.ValidateMemoRelationEndpointRead(&store.MemoRelationEndpointSnapshot{ + ActorUserID: 1, + ActorActive: true, + EndpointID: 2, + EndpointCreatorID: 1, + EndpointRowStatus: store.Normal, + EndpointVisibility: visibility, + EndpointSpaceID: &danglingSpaceID, + EndpointSpaceExists: false, + EndpointMemberActive: false, + }) + require.NoError(t, err, "a dangling placement must not override a non-Space audience") + }) + } + + err := store.ValidateMemoRelationEndpointRead(&store.MemoRelationEndpointSnapshot{ + ActorUserID: 1, + ActorActive: true, + EndpointID: 2, + EndpointCreatorID: 2, + EndpointRowStatus: store.Normal, + EndpointVisibility: store.SpaceAudience, + EndpointSpaceID: &danglingSpaceID, + EndpointSpaceExists: false, + EndpointMemberActive: true, + }) + require.ErrorIs(t, err, store.ErrMemoMutationConflict, "a Space audience must fail closed when its placement is dangling") +} + +func TestValidateMemoWriteSnapshotRejectsDanglingSourcePlacement(t *testing.T) { + danglingSpaceID := int32(42) + err := store.ValidateMemoWriteSnapshot( + &store.MemoWritePolicy{ActorUserID: 1}, + nil, + &store.MemoWriteSnapshot{ + CreatorID: 1, + RowStatus: store.Normal, + SpaceID: &danglingSpaceID, + Visibility: store.Public, + SourceSpaceExists: false, + }, + ) + require.ErrorIs(t, err, store.ErrMemoSpaceNotWritable) +} diff --git a/store/memo_share.go b/store/memo_share.go index 709da93a..3633b09c 100644 --- a/store/memo_share.go +++ b/store/memo_share.go @@ -1,6 +1,9 @@ package store -import "context" +import ( + "context" + "errors" +) // MemoShare is an access grant that permits read-only access to a memo via a bearer token. type MemoShare struct { @@ -10,6 +13,7 @@ type MemoShare struct { CreatorID int32 CreatedTs int64 ExpiresTs *int64 // nil means the share never expires + Policy *MemoWritePolicy } // FindMemoShare is used to filter memo shares in list/get queries. @@ -22,12 +26,25 @@ type FindMemoShare struct { // DeleteMemoShare identifies a share grant to remove. type DeleteMemoShare struct { - ID *int32 - UID *string + ID *int32 + UID *string + MemoID *int32 + // Policy is required for transport-facing revocation and is revalidated in + // the same transaction as the delete. + Policy *MemoWritePolicy } // CreateMemoShare creates a new share grant. func (s *Store) CreateMemoShare(ctx context.Context, create *MemoShare) (*MemoShare, error) { + if create == nil { + return nil, errors.New("memo share is required") + } + if err := validateMemoWritePolicy(create.Policy); err != nil { + return nil, err + } + if create.Policy == nil { + return s.driver.CreateMemoShare(ctx, create) + } return s.driver.CreateMemoShare(ctx, create) } @@ -43,5 +60,20 @@ func (s *Store) GetMemoShare(ctx context.Context, find *FindMemoShare) (*MemoSha // DeleteMemoShare removes a share grant. func (s *Store) DeleteMemoShare(ctx context.Context, delete *DeleteMemoShare) error { + if delete == nil { + return errors.New("memo share deletion is required") + } + if delete.ID == nil && delete.UID == nil { + return errors.New("memo share deletion requires id or uid") + } + if err := validateMemoWritePolicy(delete.Policy); err != nil { + return err + } + if delete.Policy == nil { + return s.driver.DeleteMemoShare(ctx, delete) + } + if delete.MemoID == nil || *delete.MemoID <= 0 { + return errors.New("authorized memo share deletion requires memo") + } return s.driver.DeleteMemoShare(ctx, delete) } diff --git a/store/migration/mysql/0.31/03__multi_spaces.sql b/store/migration/mysql/0.31/03__multi_spaces.sql new file mode 100644 index 00000000..477f98f7 --- /dev/null +++ b/store/migration/mysql/0.31/03__multi_spaces.sql @@ -0,0 +1,20 @@ +CREATE TABLE `space` ( + `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY, + `uid` VARCHAR(256) NOT NULL UNIQUE, + `title` TEXT NOT NULL, + `description` TEXT NOT NULL +); + +CREATE TABLE `space_member` ( + `space_id` INT NOT NULL, + `user_id` INT NOT NULL, + `role` VARCHAR(256) NOT NULL CHECK (`role` IN ('ADMIN', 'USER')), + PRIMARY KEY (`space_id`, `user_id`) +); + +ALTER TABLE `memo` ADD COLUMN `space_id` INT DEFAULT NULL; + +CREATE INDEX `idx_space_member_user_id` ON `space_member`(`user_id`, `space_id`); +CREATE INDEX `idx_memo_space_id` ON `memo`(`space_id`, `row_status`, `created_ts`, `id`); +CREATE INDEX `idx_memo_relation_related_type_memo` + ON `memo_relation`(`related_memo_id`, `type`, `memo_id`); diff --git a/store/migration/mysql/LATEST.sql b/store/migration/mysql/LATEST.sql index 3a5aef9d..9f6605f8 100644 --- a/store/migration/mysql/LATEST.sql +++ b/store/migration/mysql/LATEST.sql @@ -28,6 +28,24 @@ CREATE TABLE `user_setting` ( UNIQUE(`user_id`,`key`) ); +-- space +CREATE TABLE `space` ( + `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY, + `uid` VARCHAR(256) NOT NULL UNIQUE, + `title` TEXT NOT NULL, + `description` TEXT NOT NULL +); + +-- space membership +CREATE TABLE `space_member` ( + `space_id` INT NOT NULL, + `user_id` INT NOT NULL, + `role` VARCHAR(256) NOT NULL CHECK (`role` IN ('ADMIN', 'USER')), + PRIMARY KEY (`space_id`, `user_id`) +); + +CREATE INDEX `idx_space_member_user_id` ON `space_member`(`user_id`, `space_id`); + -- memo CREATE TABLE `memo` ( `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY, @@ -39,9 +57,12 @@ CREATE TABLE `memo` ( `content` TEXT NOT NULL, `visibility` VARCHAR(256) NOT NULL DEFAULT 'PRIVATE', `pinned` BOOLEAN NOT NULL DEFAULT FALSE, - `payload` JSON NOT NULL + `payload` JSON NOT NULL, + `space_id` INT DEFAULT NULL ); +CREATE INDEX `idx_memo_space_id` ON `memo`(`space_id`, `row_status`, `created_ts`, `id`); + -- memo_relation CREATE TABLE `memo_relation` ( `memo_id` INT NOT NULL, @@ -50,6 +71,9 @@ CREATE TABLE `memo_relation` ( UNIQUE(`memo_id`,`related_memo_id`,`type`) ); +CREATE INDEX `idx_memo_relation_related_type_memo` + ON `memo_relation`(`related_memo_id`, `type`, `memo_id`); + -- attachment CREATE TABLE `attachment` ( `id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY, diff --git a/store/migration/postgres/0.31/03__multi_spaces.sql b/store/migration/postgres/0.31/03__multi_spaces.sql new file mode 100644 index 00000000..dbbbfb22 --- /dev/null +++ b/store/migration/postgres/0.31/03__multi_spaces.sql @@ -0,0 +1,20 @@ +CREATE TABLE space ( + id SERIAL PRIMARY KEY, + uid TEXT NOT NULL UNIQUE, + title TEXT NOT NULL, + description TEXT NOT NULL DEFAULT '' +); + +CREATE TABLE space_member ( + space_id INTEGER NOT NULL, + user_id INTEGER NOT NULL, + role TEXT NOT NULL CHECK (role IN ('ADMIN', 'USER')), + PRIMARY KEY (space_id, user_id) +); + +ALTER TABLE memo ADD COLUMN space_id INTEGER DEFAULT NULL; + +CREATE INDEX idx_space_member_user_id ON space_member(user_id, space_id); +CREATE INDEX idx_memo_space_id ON memo(space_id, row_status, created_ts DESC, id DESC); +CREATE INDEX idx_memo_relation_related_type_memo + ON memo_relation(related_memo_id, type, memo_id); diff --git a/store/migration/postgres/LATEST.sql b/store/migration/postgres/LATEST.sql index afe3b70e..42309704 100644 --- a/store/migration/postgres/LATEST.sql +++ b/store/migration/postgres/LATEST.sql @@ -28,6 +28,24 @@ CREATE TABLE user_setting ( UNIQUE(user_id, key) ); +-- space +CREATE TABLE space ( + id SERIAL PRIMARY KEY, + uid TEXT NOT NULL UNIQUE, + title TEXT NOT NULL, + description TEXT NOT NULL DEFAULT '' +); + +-- space membership +CREATE TABLE space_member ( + space_id INTEGER NOT NULL, + user_id INTEGER NOT NULL, + role TEXT NOT NULL CHECK (role IN ('ADMIN', 'USER')), + PRIMARY KEY (space_id, user_id) +); + +CREATE INDEX idx_space_member_user_id ON space_member(user_id, space_id); + -- memo CREATE TABLE memo ( id SERIAL PRIMARY KEY, @@ -39,9 +57,12 @@ CREATE TABLE memo ( content TEXT NOT NULL, visibility TEXT NOT NULL DEFAULT 'PRIVATE', pinned BOOLEAN NOT NULL DEFAULT FALSE, - payload JSONB NOT NULL DEFAULT '{}' + payload JSONB NOT NULL DEFAULT '{}', + space_id INTEGER DEFAULT NULL ); +CREATE INDEX idx_memo_space_id ON memo(space_id, row_status, created_ts DESC, id DESC); + -- memo_relation CREATE TABLE memo_relation ( memo_id INTEGER NOT NULL, @@ -50,6 +71,9 @@ CREATE TABLE memo_relation ( UNIQUE(memo_id, related_memo_id, type) ); +CREATE INDEX idx_memo_relation_related_type_memo + ON memo_relation(related_memo_id, type, memo_id); + -- attachment CREATE TABLE attachment ( id SERIAL PRIMARY KEY, diff --git a/store/migration/sqlite/0.31/03__multi_spaces.sql b/store/migration/sqlite/0.31/03__multi_spaces.sql new file mode 100644 index 00000000..f5c9f2cf --- /dev/null +++ b/store/migration/sqlite/0.31/03__multi_spaces.sql @@ -0,0 +1,48 @@ +CREATE TABLE space ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + uid TEXT NOT NULL UNIQUE, + title TEXT NOT NULL, + description TEXT NOT NULL DEFAULT '' +); + +CREATE TABLE space_member ( + space_id INTEGER NOT NULL, + user_id INTEGER NOT NULL, + role TEXT NOT NULL CHECK (role IN ('ADMIN', 'USER')), + PRIMARY KEY (space_id, user_id) +); + +-- SQLite requires a table rebuild to extend the visibility CHECK constraint. +-- Copy every existing memo value verbatim; placement starts Unassigned. +CREATE TABLE memo_new ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + uid TEXT NOT NULL UNIQUE, + creator_id INTEGER NOT NULL, + created_ts BIGINT NOT NULL DEFAULT (strftime('%s', 'now')), + updated_ts BIGINT NOT NULL DEFAULT (strftime('%s', 'now')), + row_status TEXT NOT NULL CHECK (row_status IN ('NORMAL', 'ARCHIVED')) DEFAULT 'NORMAL', + content TEXT NOT NULL DEFAULT '', + visibility TEXT NOT NULL CHECK (visibility IN ('PUBLIC', 'PROTECTED', 'PRIVATE', 'SPACE')) DEFAULT 'PRIVATE', + pinned INTEGER NOT NULL CHECK (pinned IN (0, 1)) DEFAULT 0, + payload TEXT NOT NULL DEFAULT '{}', + space_id INTEGER DEFAULT NULL +); + +INSERT INTO memo_new ( + id, uid, creator_id, created_ts, updated_ts, row_status, content, + visibility, pinned, payload, space_id +) +SELECT + id, uid, creator_id, created_ts, updated_ts, row_status, content, + visibility, pinned, payload, NULL +FROM memo; + +DROP TABLE memo; +ALTER TABLE memo_new RENAME TO memo; + +-- Recreate the pre-existing index dropped with the rebuilt memo table. +CREATE INDEX idx_memo_creator_id ON memo(creator_id); +CREATE INDEX idx_space_member_user_id ON space_member(user_id, space_id); +CREATE INDEX idx_memo_space_id ON memo(space_id, row_status, created_ts DESC, id DESC); +CREATE INDEX idx_memo_relation_related_type_memo + ON memo_relation(related_memo_id, type, memo_id); diff --git a/store/migration/sqlite/LATEST.sql b/store/migration/sqlite/LATEST.sql index a773c7d0..c712c9ec 100644 --- a/store/migration/sqlite/LATEST.sql +++ b/store/migration/sqlite/LATEST.sql @@ -29,6 +29,24 @@ CREATE TABLE user_setting ( UNIQUE(user_id, key) ); +-- space +CREATE TABLE space ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + uid TEXT NOT NULL UNIQUE, + title TEXT NOT NULL, + description TEXT NOT NULL DEFAULT '' +); + +-- space membership +CREATE TABLE space_member ( + space_id INTEGER NOT NULL, + user_id INTEGER NOT NULL, + role TEXT NOT NULL CHECK (role IN ('ADMIN', 'USER')), + PRIMARY KEY (space_id, user_id) +); + +CREATE INDEX idx_space_member_user_id ON space_member(user_id, space_id); + -- memo CREATE TABLE memo ( id INTEGER PRIMARY KEY AUTOINCREMENT, @@ -38,11 +56,15 @@ CREATE TABLE memo ( updated_ts BIGINT NOT NULL DEFAULT (strftime('%s', 'now')), row_status TEXT NOT NULL CHECK (row_status IN ('NORMAL', 'ARCHIVED')) DEFAULT 'NORMAL', content TEXT NOT NULL DEFAULT '', - visibility TEXT NOT NULL CHECK (visibility IN ('PUBLIC', 'PROTECTED', 'PRIVATE')) DEFAULT 'PRIVATE', + visibility TEXT NOT NULL CHECK (visibility IN ('PUBLIC', 'PROTECTED', 'PRIVATE', 'SPACE')) DEFAULT 'PRIVATE', pinned INTEGER NOT NULL CHECK (pinned IN (0, 1)) DEFAULT 0, - payload TEXT NOT NULL DEFAULT '{}' + payload TEXT NOT NULL DEFAULT '{}', + space_id INTEGER DEFAULT NULL ); +CREATE INDEX idx_memo_creator_id ON memo(creator_id); +CREATE INDEX idx_memo_space_id ON memo(space_id, row_status, created_ts DESC, id DESC); + -- memo_relation CREATE TABLE memo_relation ( memo_id INTEGER NOT NULL, @@ -51,6 +73,9 @@ CREATE TABLE memo_relation ( UNIQUE(memo_id, related_memo_id, type) ); +CREATE INDEX idx_memo_relation_related_type_memo + ON memo_relation(related_memo_id, type, memo_id); + -- attachment CREATE TABLE attachment ( id INTEGER PRIMARY KEY AUTOINCREMENT, diff --git a/store/reaction.go b/store/reaction.go index 33caadf8..1a79cfdd 100644 --- a/store/reaction.go +++ b/store/reaction.go @@ -2,11 +2,17 @@ package store import ( "context" - "errors" + stderrors "errors" + + "github.com/pkg/errors" ) // ErrReactionMemoNotFound indicates that a reaction's memo no longer exists. -var ErrReactionMemoNotFound = errors.New("reaction memo not found") +var ErrReactionMemoNotFound = stderrors.New("reaction memo not found") + +// ErrReactionPermissionDenied indicates that an actor cannot mutate the +// reaction. +var ErrReactionPermissionDenied = stderrors.New("reaction mutation permission denied") // Reaction is a reaction attached to a memo. type Reaction struct { @@ -16,6 +22,9 @@ type Reaction struct { // MemoID is the ID of the memo that the reaction is for. MemoID int32 ReactionType string + // Policy is required for transport-facing participation mutations. A nil + // policy preserves trusted internal and migration callers. + Policy *ReactionWritePolicy } type FindReaction struct { @@ -26,11 +35,25 @@ type FindReaction struct { } type DeleteReaction struct { - ID *int32 - MemoID *int32 + ID *int32 + MemoID *int32 + ActorUserID *int32 + // Policy is required for transport-facing participation mutations. It is + // revalidated in the same transaction before the reaction row is deleted. + Policy *ReactionWritePolicy } func (s *Store) UpsertReaction(ctx context.Context, upsert *Reaction) (*Reaction, error) { + if upsert == nil { + return nil, errors.New("reaction is required") + } + if err := validateReactionWritePolicy(upsert); err != nil { + return nil, err + } + if upsert.Policy == nil { + return s.driver.UpsertReaction(ctx, upsert) + } + return s.driver.UpsertReaction(ctx, upsert) } @@ -43,5 +66,27 @@ func (s *Store) GetReaction(ctx context.Context, find *FindReaction) (*Reaction, } func (s *Store) DeleteReaction(ctx context.Context, delete *DeleteReaction) error { + if delete == nil { + return errors.New("reaction deletion is required") + } + if delete.ActorUserID == nil { + return s.driver.DeleteReaction(ctx, delete) + } + if *delete.ActorUserID <= 0 || delete.ID == nil || *delete.ID <= 0 { + return errors.New("authorized reaction deletion requires reaction and actor") + } + if delete.Policy != nil { + if delete.MemoID == nil || *delete.MemoID <= 0 { + return errors.New("authorized reaction deletion policy requires memo") + } + if err := validateReactionWritePolicy(&Reaction{ + CreatorID: *delete.ActorUserID, + MemoID: *delete.MemoID, + Policy: delete.Policy, + }); err != nil { + return err + } + } + return s.driver.DeleteReaction(ctx, delete) } diff --git a/store/reaction_policy.go b/store/reaction_policy.go new file mode 100644 index 00000000..1f3ff0a5 --- /dev/null +++ b/store/reaction_policy.go @@ -0,0 +1,44 @@ +package store + +import "github.com/pkg/errors" + +// ReactionWritePolicy identifies the actor for a transport-facing reaction +// mutation. Drivers authorize that actor against the memo's current state. +type ReactionWritePolicy struct { + ActorUserID int32 +} + +func validateReactionWritePolicy(reaction *Reaction) error { + if reaction == nil || reaction.Policy == nil { + return nil + } + policy := reaction.Policy + if reaction.CreatorID <= 0 || reaction.MemoID <= 0 || policy.ActorUserID <= 0 { + return errors.New("reaction write policy requires reaction, actor, and memo") + } + if reaction.CreatorID != policy.ActorUserID { + return ErrReactionPermissionDenied + } + return nil +} + +// ValidateReactionWriteParticipation applies the reaction actor identity and +// memo-local participation rules to state loaded by the write transaction. +func ValidateReactionWriteParticipation(reaction *Reaction, snapshot *MemoCommentAuthorizationSnapshot) error { + if err := validateReactionWritePolicy(reaction); err != nil { + return err + } + if reaction == nil || reaction.Policy == nil || snapshot == nil { + return errors.New("reaction write participation state is required") + } + if snapshot.ActorUserID != reaction.Policy.ActorUserID { + return ErrReactionPermissionDenied + } + if !snapshot.ActorActive { + return ErrReactionPermissionDenied + } + if snapshot.ContextID != reaction.MemoID { + return ErrMemoMutationConflict + } + return ValidateMemoCommentAuthorization(snapshot) +} diff --git a/store/space.go b/store/space.go new file mode 100644 index 00000000..0ff8632f --- /dev/null +++ b/store/space.go @@ -0,0 +1,218 @@ +package store + +import ( + "context" + "errors" + "strings" + + "github.com/usememos/memos/internal/base" +) + +// ErrLastSpaceAdmin indicates that a membership mutation would leave an active +// space without an administrator. +var ErrLastSpaceAdmin = errors.New("cannot remove the last space admin") + +// ErrSpacePermissionDenied indicates that the actor cannot perform a space mutation. +var ErrSpacePermissionDenied = errors.New("space permission denied") + +// ErrSpaceMemberNotActive indicates that a membership target is not an active user. +var ErrSpaceMemberNotActive = errors.New("space member user is not active") + +// ErrSpaceAlreadyExists indicates a duplicate immutable space ID. +var ErrSpaceAlreadyExists = errors.New("space already exists") + +// ErrSpaceMemberAlreadyExists indicates an existing membership. +var ErrSpaceMemberAlreadyExists = errors.New("space member already exists") + +// ErrSpaceNotFound indicates a missing mutation target. +var ErrSpaceNotFound = errors.New("space not found") + +// ErrSpaceMemberNotFound indicates a missing membership mutation target. +var ErrSpaceMemberNotFound = errors.New("space member not found") + +// SpaceMemberRole is the role of a user within a space. +type SpaceMemberRole string + +const ( + // SpaceMemberRoleAdmin can manage the space and its membership. + SpaceMemberRoleAdmin SpaceMemberRole = "ADMIN" + // SpaceMemberRoleUser is a regular space member. + SpaceMemberRoleUser SpaceMemberRole = "USER" +) + +// IsActiveMember reports whether the role grants space membership. It is the +// single definition of membership validity: an unknown role denies the access +// that depends on it. +func (r SpaceMemberRole) IsActiveMember() bool { + return r == SpaceMemberRoleAdmin || r == SpaceMemberRoleUser +} + +// Space groups memos and memberships. +type Space struct { + ID int32 + + UID string + Title string + Description string +} + +// FindSpace selects spaces. MemberUserID restricts results to spaces where the +// user has a membership and is applied before pagination. +type FindSpace struct { + ID *int32 + UID *string + MemberUserID *int32 + Limit *int + Offset *int +} + +// UpdateSpace contains mutable space fields. +type UpdateSpace struct { + ID int32 + Title *string + Description *string +} + +// DeleteSpace identifies a Space to hard-delete. +type DeleteSpace struct { + ID int32 + ActorUserID int32 +} + +// DeleteSpaceResult contains external resources to clean after commit. +type DeleteSpaceResult struct { + Attachments []*Attachment +} + +// SpaceMember associates a user with a space. +type SpaceMember struct { + SpaceID int32 + UserID int32 + Role SpaceMemberRole +} + +// FindSpaceMember selects memberships. +type FindSpaceMember struct { + SpaceID *int32 + UserID *int32 + ViewerUserID *int32 + Limit *int + Offset *int +} + +// UpdateSpaceMember contains mutable membership fields. +type UpdateSpaceMember struct { + SpaceID int32 + UserID int32 + Role *SpaceMemberRole +} + +// DeleteSpaceMember identifies a membership to delete. +type DeleteSpaceMember struct { + SpaceID int32 + UserID int32 +} + +// CreateSpace creates a space and its first ADMIN membership atomically. +func (s *Store) CreateSpace(ctx context.Context, create *Space, creatorID int32) (*Space, error) { + if create == nil { + return nil, errors.New("space is required") + } + if !base.UIDMatcher.MatchString(create.UID) { + return nil, errors.New("invalid uid") + } + if strings.TrimSpace(create.Title) == "" { + return nil, errors.New("space title is required") + } + return s.driver.CreateSpace(ctx, create, creatorID) +} + +// ListSpaces returns spaces matching find. +func (s *Store) ListSpaces(ctx context.Context, find *FindSpace) ([]*Space, error) { + return s.driver.ListSpaces(ctx, find) +} + +// GetSpace returns the first matching space. +func (s *Store) GetSpace(ctx context.Context, find *FindSpace) (*Space, error) { + spaces, err := s.ListSpaces(ctx, find) + if err != nil { + return nil, err + } + if len(spaces) == 0 { + return nil, nil + } + return spaces[0], nil +} + +// UpdateSpace updates and returns a space. +func (s *Store) UpdateSpace(ctx context.Context, update *UpdateSpace, actorUserID int32) (*Space, error) { + if update == nil { + return nil, errors.New("space update is required") + } + if update.Title != nil && strings.TrimSpace(*update.Title) == "" { + return nil, errors.New("space title is required") + } + if update.Title == nil && update.Description == nil { + return nil, errors.New("space update requires at least one field") + } + return s.driver.UpdateSpace(ctx, update, actorUserID) +} + +// DeleteSpace atomically deletes a Space, all directly assigned memos, and +// their owned database resources. Memo relations are not followed. +func (s *Store) DeleteSpace(ctx context.Context, delete *DeleteSpace) (*DeleteSpaceResult, error) { + if delete == nil || delete.ID <= 0 || delete.ActorUserID <= 0 { + return nil, errors.New("space deletion requires space and actor") + } + result, err := s.driver.DeleteSpace(ctx, delete) + if err != nil { + return nil, err + } + if result == nil { + return nil, errors.New("unexpected nil delete space result") + } + return result, nil +} + +// CreateSpaceMember creates a membership. +func (s *Store) CreateSpaceMember(ctx context.Context, create *SpaceMember, actorUserID int32) (*SpaceMember, error) { + if !create.Role.IsActiveMember() { + return nil, errors.New("invalid space member role") + } + return s.driver.CreateSpaceMember(ctx, create, actorUserID) +} + +// ListSpaceMembers returns memberships matching find. +func (s *Store) ListSpaceMembers(ctx context.Context, find *FindSpaceMember) ([]*SpaceMember, error) { + return s.driver.ListSpaceMembers(ctx, find) +} + +// GetSpaceMember returns the first matching membership. +func (s *Store) GetSpaceMember(ctx context.Context, find *FindSpaceMember) (*SpaceMember, error) { + members, err := s.ListSpaceMembers(ctx, find) + if err != nil { + return nil, err + } + if len(members) == 0 { + return nil, nil + } + return members[0], nil +} + +// UpdateSpaceMember updates and returns a membership after checking that the +// change keeps an active ADMIN. +func (s *Store) UpdateSpaceMember(ctx context.Context, update *UpdateSpaceMember, actorUserID int32) (*SpaceMember, error) { + if update == nil || update.Role == nil { + return nil, errors.New("space member role is required") + } + if update.Role != nil && !update.Role.IsActiveMember() { + return nil, errors.New("invalid space member role") + } + return s.driver.UpdateSpaceMember(ctx, update, actorUserID) +} + +// DeleteSpaceMember deletes a membership after checking that the change keeps +// an active ADMIN. +func (s *Store) DeleteSpaceMember(ctx context.Context, delete *DeleteSpaceMember, actorUserID int32) error { + return s.driver.DeleteSpaceMember(ctx, delete, actorUserID) +} diff --git a/store/test/attachment_access_test.go b/store/test/attachment_access_test.go new file mode 100644 index 00000000..bae6685f --- /dev/null +++ b/store/test/attachment_access_test.go @@ -0,0 +1,317 @@ +package test + +import ( + "context" + "fmt" + "testing" + "time" + + "github.com/stretchr/testify/require" + + "github.com/usememos/memos/store" +) + +func TestAttachmentAccessScopeFiltersBeforePagination(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "attachment-space-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + member, err := ts.CreateUser(ctx, &store.User{Username: "attachment-space-member", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + space, err := ts.CreateSpace(ctx, &store.Space{UID: "attachment-space", Title: "Attachments"}, owner.ID) + require.NoError(t, err) + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: member.ID, Role: store.SpaceMemberRoleUser}, owner.ID) + require.NoError(t, err) + root, err := ts.CreateMemo(ctx, &store.Memo{UID: "attachment-space-root", CreatorID: owner.ID, Content: "root", Visibility: store.SpaceAudience, SpaceID: &space.ID}) + require.NoError(t, err) + comment, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: "attachment-space-comment", CreatorID: owner.ID, Content: "comment", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }, root.ID, owner.ID) + require.NoError(t, err) + + unlinked, err := ts.CreateAttachment(ctx, &store.Attachment{UID: "attachment-unlinked", CreatorID: member.ID, Filename: "unlinked.txt", Type: "text/plain", Size: 1, Blob: []byte("u")}) + require.NoError(t, err) + linked, err := ts.CreateAttachment(ctx, &store.Attachment{UID: "attachment-linked", CreatorID: member.ID, Filename: "linked.txt", Type: "text/plain", Size: 1, Blob: []byte("l"), MemoID: &comment.ID}) + require.NoError(t, err) + older, newer := time.Now().Unix()-20, time.Now().Unix()-10 + require.NoError(t, ts.UpdateAttachment(ctx, &store.UpdateAttachment{ID: unlinked.ID, UpdatedTs: &older})) + require.NoError(t, ts.UpdateAttachment(ctx, &store.UpdateAttachment{ID: linked.ID, UpdatedTs: &newer})) + require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: member.ID}, owner.ID)) + + limit, offset := 1, 0 + attachments, err := ts.ListAttachments(ctx, &store.FindAttachment{ + CreatorID: &member.ID, + Access: &store.MemoAccessScope{ + UserID: &member.ID, + AllowPublic: true, + AllowProtected: true, + }, + Limit: &limit, + Offset: &offset, + }) + require.NoError(t, err) + require.Len(t, attachments, 1) + require.Equal(t, unlinked.ID, attachments[0].ID, "the inaccessible newer row must be removed before LIMIT is applied") +} + +func TestAttachmentAccessScopeUsesDirectMemoAudience(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "attachment-local-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + contextMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "attachment-local-context", CreatorID: owner.ID, Content: "private context", Visibility: store.Private, + }) + require.NoError(t, err) + publicComment, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: "attachment-local-public", CreatorID: owner.ID, Content: "public reply", Visibility: store.Public, + }, contextMemo.ID, owner.ID) + require.NoError(t, err) + privateComment, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: "attachment-local-private", CreatorID: owner.ID, Content: "private reply", Visibility: store.Private, + }, contextMemo.ID, owner.ID) + require.NoError(t, err) + publicAttachment, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: "attachment-local-public-file", CreatorID: owner.ID, Filename: "public.txt", Type: "text/plain", MemoID: &publicComment.ID, + }) + require.NoError(t, err) + _, err = ts.CreateAttachment(ctx, &store.Attachment{ + UID: "attachment-local-private-file", CreatorID: owner.ID, Filename: "private.txt", Type: "text/plain", MemoID: &privateComment.ID, + }) + require.NoError(t, err) + + attachments, err := ts.ListAttachments(ctx, &store.FindAttachment{ + Access: &store.MemoAccessScope{AllowPublic: true}, + SkipDefaultLimit: true, + }) + require.NoError(t, err) + require.Len(t, attachments, 1) + require.Equal(t, publicAttachment.ID, attachments[0].ID, "the context memo must not grant or restrict attachment access") +} + +func TestAttachmentAccessScopeSpaceAudienceHasNoMemoAuthorBypass(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + author, err := ts.CreateUser(ctx, &store.User{Username: "attachment-removed-author", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + admin, err := ts.CreateUser(ctx, &store.User{Username: "attachment-remaining-admin", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + space, err := ts.CreateSpace(ctx, &store.Space{UID: "attachment-author-space", Title: "Author attachment access"}, author.ID) + require.NoError(t, err) + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: admin.ID, Role: store.SpaceMemberRoleAdmin}, author.ID) + require.NoError(t, err) + memo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "attachment-author-memo", CreatorID: author.ID, Content: "members", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }) + require.NoError(t, err) + _, err = ts.CreateAttachment(ctx, &store.Attachment{ + UID: "attachment-author-file", CreatorID: author.ID, Filename: "members.txt", Type: "text/plain", MemoID: &memo.ID, + }) + require.NoError(t, err) + require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: author.ID}, admin.ID)) + + attachments, err := ts.ListAttachments(ctx, &store.FindAttachment{ + CreatorID: &author.ID, + Access: &store.MemoAccessScope{UserID: &author.ID, AllowPublic: true, AllowProtected: true}, + SkipDefaultLimit: true, + }) + require.NoError(t, err) + require.Empty(t, attachments) +} + +func TestAttachmentAccessScopeAllowsArchivedMemoCreatorAndFiltersMissingCreator(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + creator, err := ts.CreateUser(ctx, &store.User{Username: "attachment-archived-memo-creator", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + attachmentOwner, err := ts.CreateUser(ctx, &store.User{Username: "attachment-creator-viewer", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + validMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "attachment-archived-creator-memo", CreatorID: creator.ID, Content: "valid", Visibility: store.Public, + }) + require.NoError(t, err) + validAttachment, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: "attachment-archived-creator-file", CreatorID: attachmentOwner.ID, Filename: "valid.txt", Type: "text/plain", MemoID: &validMemo.ID, + }) + require.NoError(t, err) + archived := store.Archived + _, err = ts.UpdateUser(ctx, &store.UpdateUser{ID: creator.ID, RowStatus: &archived}) + require.NoError(t, err) + + attachments, err := ts.ListAttachments(ctx, &store.FindAttachment{ + Access: &store.MemoAccessScope{AllowPublic: true}, + SkipDefaultLimit: true, + }) + require.NoError(t, err) + require.Equal(t, []int32{validAttachment.ID}, attachmentIDs(attachments), + "attachments keep following an active memo's audience when its creator is archived") + + corruptMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "attachment-missing-creator-memo", CreatorID: attachmentOwner.ID, Content: "corrupt", Visibility: store.Public, + }) + require.NoError(t, err) + _, err = ts.CreateAttachment(ctx, &store.Attachment{ + UID: "attachment-missing-creator-file", CreatorID: attachmentOwner.ID, Filename: "corrupt.txt", Type: "text/plain", MemoID: &corruptMemo.ID, + }) + require.NoError(t, err) + _, err = ts.GetDriver().GetDB().ExecContext(ctx, + fmt.Sprintf("UPDATE memo SET creator_id = 2147483000 WHERE id = %d", corruptMemo.ID)) + require.NoError(t, err) + + attachments, err = ts.ListAttachments(ctx, &store.FindAttachment{ + Access: &store.MemoAccessScope{AllowPublic: true}, + SkipDefaultLimit: true, + }) + require.NoError(t, err) + require.Equal(t, []int32{validAttachment.ID}, attachmentIDs(attachments), + "an attachment must not reveal a memo whose creator cannot be resolved") +} + +func TestAttachmentWritePolicyRevalidatesMemoSpaceMembership(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "attachment-write-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + member, err := ts.CreateUser(ctx, &store.User{Username: "attachment-write-member", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + space, err := ts.CreateSpace(ctx, &store.Space{UID: "attachment-write-space", Title: "Attachment Writes"}, owner.ID) + require.NoError(t, err) + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: member.ID, Role: store.SpaceMemberRoleUser}, owner.ID) + require.NoError(t, err) + + root, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "attachment-write-root", CreatorID: member.ID, Content: "root", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }) + require.NoError(t, err) + target, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: "attachment-write-comment", CreatorID: member.ID, Content: "comment", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }, root.ID, member.ID) + require.NoError(t, err) + secondTarget, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: "attachment-write-second-comment", CreatorID: member.ID, Content: "second", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }, root.ID, member.ID) + require.NoError(t, err) + policy := memoWritePolicy(member.ID, false) + unlinked, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: "attachment-policy-unlinked", CreatorID: member.ID, Filename: "unlinked.txt", Type: "text/plain", + }) + require.NoError(t, err) + unlinkedRename := "unlinked-renamed.txt" + require.NoError(t, ts.UpdateAttachment(ctx, &store.UpdateAttachment{ + ID: unlinked.ID, Filename: &unlinkedRename, Policy: policy, + })) + + attachment, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: "attachment-policy-linked", + CreatorID: member.ID, + Filename: "linked.txt", + Type: "text/plain", + Size: 1, + Blob: []byte("a"), + MemoID: &target.ID, + Policy: policy, + }) + require.NoError(t, err) + renamed := "renamed.txt" + require.NoError(t, ts.UpdateAttachment(ctx, &store.UpdateAttachment{ + ID: attachment.ID, Filename: &renamed, Policy: policy, + })) + foreignAttachment, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: "attachment-policy-foreign-owner", + CreatorID: owner.ID, + Filename: "foreign.txt", + Type: "text/plain", + MemoID: &target.ID, + }) + require.NoError(t, err) + foreignRename := "must-not-rename-foreign.txt" + err = ts.UpdateAttachment(ctx, &store.UpdateAttachment{ + ID: foreignAttachment.ID, Filename: &foreignRename, Policy: policy, + }) + require.ErrorIs(t, err, store.ErrMemoPermissionDenied) + storedForeign, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &foreignAttachment.ID}) + require.NoError(t, err) + require.Equal(t, "foreign.txt", storedForeign.Filename) + + // A trusted internal caller can still rebind legacy data. A later transport + // update discovers and authorizes the current binding in its transaction. + require.NoError(t, ts.UpdateAttachment(ctx, &store.UpdateAttachment{ID: attachment.ID, MemoID: &secondTarget.ID})) + currentBindingRename := "current-binding.txt" + err = ts.UpdateAttachment(ctx, &store.UpdateAttachment{ + ID: attachment.ID, Filename: ¤tBindingRename, Policy: policy, + }) + require.NoError(t, err) + stored, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID}) + require.NoError(t, err) + require.Equal(t, currentBindingRename, stored.Filename) + require.NoError(t, ts.UpdateAttachment(ctx, &store.UpdateAttachment{ID: attachment.ID, MemoID: &target.ID})) + + archived := store.Archived + _, err = ts.UpdateUser(ctx, &store.UpdateUser{ID: member.ID, RowStatus: &archived}) + require.NoError(t, err) + _, err = ts.CreateAttachment(ctx, &store.Attachment{ + UID: "attachment-policy-archived-actor", + CreatorID: member.ID, + Filename: "archived.txt", + Type: "text/plain", + MemoID: &target.ID, + Policy: policy, + }) + require.ErrorIs(t, err, store.ErrMemoSpaceMembershipRequired) + archivedRename := "archived-must-not-rename.txt" + err = ts.UpdateAttachment(ctx, &store.UpdateAttachment{ + ID: unlinked.ID, Filename: &archivedRename, Policy: policy, + }) + require.ErrorIs(t, err, store.ErrMemoPermissionDenied) + normal := store.Normal + _, err = ts.UpdateUser(ctx, &store.UpdateUser{ID: member.ID, RowStatus: &normal}) + require.NoError(t, err) + + require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: member.ID}, owner.ID)) + _, err = ts.CreateAttachment(ctx, &store.Attachment{ + UID: "attachment-policy-revoked-create", + CreatorID: member.ID, + Filename: "revoked.txt", + Type: "text/plain", + MemoID: &target.ID, + Policy: policy, + }) + require.ErrorIs(t, err, store.ErrMemoSpaceMembershipRequired) + revokedRename := "revoked-rename.txt" + err = ts.UpdateAttachment(ctx, &store.UpdateAttachment{ + ID: attachment.ID, Filename: &revokedRename, Policy: policy, + }) + require.ErrorIs(t, err, store.ErrMemoSpaceMembershipRequired) + stored, err = ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID}) + require.NoError(t, err) + require.Equal(t, currentBindingRename, stored.Filename) + + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: member.ID, Role: store.SpaceMemberRoleUser}, owner.ID) + require.NoError(t, err) + restoredRename := "restored-membership.txt" + err = ts.UpdateAttachment(ctx, &store.UpdateAttachment{ + ID: attachment.ID, Filename: &restoredRename, Policy: policy, + }) + require.NoError(t, err) + stored, err = ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID}) + require.NoError(t, err) + require.Equal(t, restoredRename, stored.Filename) +} + +func attachmentIDs(attachments []*store.Attachment) []int32 { + ids := make([]int32, 0, len(attachments)) + for _, attachment := range attachments { + ids = append(ids, attachment.ID) + } + return ids +} diff --git a/store/test/attachment_delete_test.go b/store/test/attachment_delete_test.go new file mode 100644 index 00000000..7736f03e --- /dev/null +++ b/store/test/attachment_delete_test.go @@ -0,0 +1,181 @@ +package test + +import ( + "context" + "testing" + + "github.com/stretchr/testify/require" + + "github.com/usememos/memos/store" +) + +func TestDeleteAttachmentsWithPolicyUsesCurrentBinding(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + _, actor, space := createAttachmentDeleteSpace(ctx, t, ts, "current") + firstMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "attachment-delete-current-first", CreatorID: actor.ID, Content: "first", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }) + require.NoError(t, err) + secondMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "attachment-delete-current-second", CreatorID: actor.ID, Content: "second", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }) + require.NoError(t, err) + attachment, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: "attachment-delete-current-target", CreatorID: actor.ID, Filename: "current.txt", Type: "text/plain", MemoID: &firstMemo.ID, + }) + require.NoError(t, err) + + // The delete protocol authorizes the binding locked in its own transaction; + // it does not compare a transport snapshot of the old binding. + require.NoError(t, ts.UpdateAttachment(ctx, &store.UpdateAttachment{ID: attachment.ID, MemoID: &secondMemo.ID})) + require.NoError(t, ts.DeleteAttachmentsWithPolicy(ctx, attachmentDeletionPolicy(actor.ID, secondMemo), []int32{attachment.ID})) + + stored, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID}) + require.NoError(t, err) + require.Nil(t, stored) +} + +func TestDeleteAttachmentsWithPolicyRevalidatesCurrentMemoMembership(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, actor, space := createAttachmentDeleteSpace(ctx, t, ts, "membership") + memo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "attachment-delete-membership-memo", CreatorID: actor.ID, Content: "memo", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }) + require.NoError(t, err) + attachment, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: "attachment-delete-membership-target", CreatorID: actor.ID, Filename: "member.txt", Type: "text/plain", MemoID: &memo.ID, + }) + require.NoError(t, err) + require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: actor.ID}, owner.ID)) + + err = ts.DeleteAttachmentsWithPolicy(ctx, attachmentDeletionPolicy(actor.ID, memo), []int32{attachment.ID}) + require.ErrorIs(t, err, store.ErrMemoSpaceMembershipRequired) + stored, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID}) + require.NoError(t, err) + require.NotNil(t, stored) +} + +func TestDeleteAttachmentsWithPolicyRequiresCurrentMemoAuthor(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, actor, space := createAttachmentDeleteSpace(ctx, t, ts, "memo-author") + ownerMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "attachment-delete-owner-memo", CreatorID: owner.ID, Content: "owner", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }) + require.NoError(t, err) + attachment, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: "attachment-delete-actor-target", CreatorID: actor.ID, Filename: "actor.txt", Type: "text/plain", + }) + require.NoError(t, err) + require.NoError(t, ts.UpdateAttachment(ctx, &store.UpdateAttachment{ID: attachment.ID, MemoID: &ownerMemo.ID})) + + err = ts.DeleteAttachmentsWithPolicy(ctx, attachmentDeletionPolicy(actor.ID, ownerMemo), []int32{attachment.ID}) + require.ErrorIs(t, err, store.ErrMemoPermissionDenied) + stored, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID}) + require.NoError(t, err) + require.NotNil(t, stored) +} + +func TestDeleteAttachmentsWithPolicyBatchIsAtomic(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + actor, err := ts.CreateUser(ctx, &store.User{Username: "attachment-delete-batch-actor", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + other, err := ts.CreateUser(ctx, &store.User{Username: "attachment-delete-batch-other", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + owned, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: "attachment-delete-batch-owned", CreatorID: actor.ID, Filename: "owned.txt", Type: "text/plain", + }) + require.NoError(t, err) + foreign, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: "attachment-delete-batch-foreign", CreatorID: other.ID, Filename: "foreign.txt", Type: "text/plain", + }) + require.NoError(t, err) + + err = ts.DeleteAttachmentsWithPolicy(ctx, attachmentDeletionPolicy(actor.ID), []int32{owned.ID, foreign.ID}) + require.ErrorIs(t, err, store.ErrMemoPermissionDenied) + for _, attachment := range []*store.Attachment{owned, foreign} { + stored, getErr := ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID}) + require.NoError(t, getErr) + require.NotNil(t, stored) + } + + err = ts.DeleteAttachmentsWithPolicy(ctx, attachmentDeletionPolicy(actor.ID), []int32{owned.ID, 2147483000}) + require.ErrorIs(t, err, store.ErrMemoMutationConflict) + stored, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &owned.ID}) + require.NoError(t, err) + require.NotNil(t, stored, "a missing batch target must not partially delete existing rows") +} + +func TestDeleteAttachmentsWithPolicyValidatesIDs(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + require.Error(t, ts.DeleteAttachmentsWithPolicy(ctx, nil, []int32{1})) + require.Error(t, ts.DeleteAttachmentsWithPolicy(ctx, attachmentDeletionPolicy(1), nil)) + require.Error(t, ts.DeleteAttachmentsWithPolicy(ctx, attachmentDeletionPolicy(1), []int32{0})) + require.Error(t, ts.DeleteAttachmentsWithPolicy(ctx, attachmentDeletionPolicy(1), []int32{1, 1})) +} + +func TestDeleteAttachmentsWithPolicyRejectsChangedMemoContent(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + actor, err := ts.CreateUser(ctx, &store.User{Username: "attachment-delete-content-actor", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + memo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "attachment-delete-content-memo", CreatorID: actor.ID, Content: "before", Visibility: store.Private, + }) + require.NoError(t, err) + attachment, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: "attachment-delete-content-target", CreatorID: actor.ID, Filename: "content.txt", Type: "text/plain", MemoID: &memo.ID, + }) + require.NoError(t, err) + policy := attachmentDeletionPolicy(actor.ID, memo) + err = ts.DeleteAttachmentsWithPolicy(ctx, attachmentDeletionPolicy(actor.ID), []int32{attachment.ID}) + require.ErrorIs(t, err, store.ErrMemoMutationConflict, "bound attachments require a memo content snapshot") + + updatedContent := "after" + require.NoError(t, ts.UpdateMemo(ctx, &store.UpdateMemo{ID: memo.ID, Content: &updatedContent})) + + err = ts.DeleteAttachmentsWithPolicy(ctx, policy, []int32{attachment.ID}) + require.ErrorIs(t, err, store.ErrMemoMutationConflict) + stored, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID}) + require.NoError(t, err) + require.NotNil(t, stored) +} + +func attachmentDeletionPolicy(actorUserID int32, memos ...*store.Memo) *store.AttachmentDeletionPolicy { + expectedMemoContents := make(map[int32]string, len(memos)) + for _, memo := range memos { + if memo != nil { + expectedMemoContents[memo.ID] = memo.Content + } + } + return &store.AttachmentDeletionPolicy{ActorUserID: actorUserID, ExpectedMemoContents: expectedMemoContents} +} + +func createAttachmentDeleteSpace(ctx context.Context, t *testing.T, ts *store.Store, suffix string) (*store.User, *store.User, *store.Space) { + t.Helper() + owner, err := ts.CreateUser(ctx, &store.User{Username: "attachment-delete-" + suffix + "-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + actor, err := ts.CreateUser(ctx, &store.User{Username: "attachment-delete-" + suffix + "-actor", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + space, err := ts.CreateSpace(ctx, &store.Space{UID: "attachment-delete-" + suffix + "-space", Title: suffix}, owner.ID) + require.NoError(t, err) + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: actor.ID, Role: store.SpaceMemberRoleUser}, owner.ID) + require.NoError(t, err) + return owner, actor, space +} diff --git a/store/test/attachment_filter_test.go b/store/test/attachment_filter_test.go index be024cce..4e86f792 100644 --- a/store/test/attachment_filter_test.go +++ b/store/test/attachment_filter_test.go @@ -167,19 +167,19 @@ func TestAttachmentFilterCreateTimeComparison(t *testing.T) { tc := NewAttachmentFilterTestContext(t) defer tc.Close() - now := time.Now().Unix() + nowSec := time.Now().Unix() tc.CreateAttachment(NewAttachmentBuilder(tc.CreatorID).Filename("test.png").MimeType("image/png")) // Test: create_time < future (should match) - attachments := tc.ListWithFilter(`create_time < timestamp(` + formatInt64(now+3600) + `)`) + attachments := tc.ListWithFilter(`create_time < timestamp(` + formatInt64(nowSec+3600) + `)`) require.Len(t, attachments, 1) // Test: create_time > past (should match) - attachments = tc.ListWithFilter(`create_time > timestamp(` + formatInt64(now-3600) + `)`) + attachments = tc.ListWithFilter(`create_time > timestamp(` + formatInt64(nowSec-3600) + `)`) require.Len(t, attachments, 1) // Test: create_time > future (should not match) - attachments = tc.ListWithFilter(`create_time > timestamp(` + formatInt64(now+3600) + `)`) + attachments = tc.ListWithFilter(`create_time > timestamp(` + formatInt64(nowSec+3600) + `)`) require.Len(t, attachments, 0) } diff --git a/store/test/attachment_test.go b/store/test/attachment_test.go index 9faf029d..cde3f915 100644 --- a/store/test/attachment_test.go +++ b/store/test/attachment_test.go @@ -224,6 +224,85 @@ func TestMemoMutationRollsBackOnBindingConflict(t *testing.T) { require.Equal(t, otherMemo.ID, *storedConflicting.MemoID) } +func TestMemoCreationMutationRollsBackDependentWrites(t *testing.T) { + t.Parallel() + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + user, err := createTestingHostUser(ctx, ts) + require.NoError(t, err) + + topLevelUID := shortuuid.New() + topLevel := &store.Memo{UID: topLevelUID, CreatorID: user.ID, Content: "top level", Visibility: store.Private} + err = ts.ApplyMemoMutation(ctx, &store.MemoMutation{ + MemoCreate: topLevel, + MemoCreatorID: user.ID, + ExpectedMemoContent: topLevel.Content, + RequiredAttachmentIDs: []int32{2147483000}, + }) + require.ErrorIs(t, err, store.ErrMemoMutationConflict) + storedTopLevel, err := ts.GetMemo(ctx, &store.FindMemo{UID: &topLevelUID}) + require.NoError(t, err) + require.Nil(t, storedTopLevel, "dependent write failure must roll back the top-level memo row") + + root, err := ts.CreateMemo(ctx, &store.Memo{UID: shortuuid.New(), CreatorID: user.ID, Content: "root", Visibility: store.Public}) + require.NoError(t, err) + commentUID := shortuuid.New() + comment := &store.Memo{UID: commentUID, CreatorID: user.ID, Content: "comment", Visibility: store.Public} + err = ts.ApplyMemoMutation(ctx, &store.MemoMutation{ + MemoCreate: comment, + CommentContextMemoID: &root.ID, + MemoCreatorID: user.ID, + ExpectedMemoContent: comment.Content, + RequiredAttachmentIDs: []int32{2147483000}, + }) + require.ErrorIs(t, err, store.ErrMemoMutationConflict) + storedComment, err := ts.GetMemo(ctx, &store.FindMemo{UID: &commentUID}) + require.NoError(t, err) + require.Nil(t, storedComment, "dependent write failure must roll back the comment row") +} + +func TestMemoCreationMutationCommitsMemoBindingsAndRelationsTogether(t *testing.T) { + t.Parallel() + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + user, err := createTestingHostUser(ctx, ts) + require.NoError(t, err) + target, err := ts.CreateMemo(ctx, &store.Memo{UID: shortuuid.New(), CreatorID: user.ID, Content: "target", Visibility: store.Private}) + require.NoError(t, err) + attachment, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: shortuuid.New(), CreatorID: user.ID, Filename: "created.png", Type: "image/png", + }) + require.NoError(t, err) + + created := &store.Memo{UID: shortuuid.New(), CreatorID: user.ID, Content: "created", Visibility: store.Private} + err = ts.ApplyMemoMutation(ctx, &store.MemoMutation{ + MemoCreate: created, + MemoCreatorID: user.ID, + ExpectedMemoContent: created.Content, + Bindings: []*store.MemoAttachmentBinding{{ID: attachment.ID, UID: attachment.UID, UpdatedTs: time.Now().Unix()}}, + RequiredAttachmentIDs: []int32{attachment.ID}, + ReplaceReferenceRelations: true, + ReferenceRelations: []*store.MemoRelation{{ + RelatedMemoID: target.ID, + Type: store.MemoRelationReference, + }}, + }) + require.NoError(t, err) + require.Positive(t, created.ID) + + storedAttachment, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID}) + require.NoError(t, err) + require.NotNil(t, storedAttachment.MemoID) + require.Equal(t, created.ID, *storedAttachment.MemoID) + relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{MemoIDList: []int32{created.ID}}) + require.NoError(t, err) + require.Len(t, relations, 1) + require.Equal(t, created.ID, relations[0].MemoID) + require.Equal(t, target.ID, relations[0].RelatedMemoID) +} + func TestMemoMutationUpdatesMemoAndBindingsTogether(t *testing.T) { t.Parallel() ctx := context.Background() @@ -265,7 +344,7 @@ func TestMemoMutationUpdatesMemoAndBindingsTogether(t *testing.T) { require.Equal(t, memo.ID, *storedAdded.MemoID) storedRemoved, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &removed.ID}) require.NoError(t, err) - require.Nil(t, storedRemoved.MemoID) + require.Nil(t, storedRemoved) } func TestMemoMutationRollsBackWhenRequiredAttachmentIsMissing(t *testing.T) { diff --git a/store/test/memo_access_test.go b/store/test/memo_access_test.go new file mode 100644 index 00000000..390fbb98 --- /dev/null +++ b/store/test/memo_access_test.go @@ -0,0 +1,217 @@ +package test + +import ( + "context" + "fmt" + "testing" + + "github.com/stretchr/testify/require" + + "github.com/usememos/memos/store" +) + +func TestMemoAccessScopeUsesEachMemoAudience(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "access-local-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + viewer, err := ts.CreateUser(ctx, &store.User{Username: "access-local-viewer", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + + privateContext, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "access-private-context", CreatorID: owner.ID, Content: "private context", Visibility: store.Private, + }) + require.NoError(t, err) + publicComment, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: "access-public-comment", CreatorID: owner.ID, Content: "public comment", Visibility: store.Public, + }, privateContext.ID, owner.ID) + require.NoError(t, err) + publicContext, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "access-public-context", CreatorID: owner.ID, Content: "public context", Visibility: store.Public, + }) + require.NoError(t, err) + privateComment, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: "access-private-comment", CreatorID: owner.ID, Content: "private comment", Visibility: store.Private, + }, publicContext.ID, owner.ID) + require.NoError(t, err) + + visible, err := ts.ListMemos(ctx, &store.FindMemo{ + Access: &store.MemoAccessScope{UserID: &viewer.ID, AllowPublic: true, AllowProtected: true}, + }) + require.NoError(t, err) + require.ElementsMatch(t, []int32{publicComment.ID, publicContext.ID}, memoIDs(visible), + "COMMENT relations must neither grant nor restrict memo-local read access") + + commentsForPrivateContext, err := ts.ListMemos(ctx, &store.FindMemo{ + CommentContextMemoID: &privateContext.ID, + Access: &store.MemoAccessScope{UserID: &viewer.ID, AllowPublic: true, AllowProtected: true}, + }) + require.NoError(t, err) + require.Equal(t, []int32{publicComment.ID}, memoIDs(commentsForPrivateContext), + "a readable comment may be returned even when its context memo is not readable") + + nonComments, err := ts.ListMemos(ctx, &store.FindMemo{ + ExcludeComments: true, + Access: &store.MemoAccessScope{UserID: &viewer.ID, AllowPublic: true, AllowProtected: true}, + }) + require.NoError(t, err) + require.Equal(t, []int32{publicContext.ID}, memoIDs(nonComments), "ordinary feeds exclude memos with COMMENT context") + + ownerRows, err := ts.ListMemos(ctx, &store.FindMemo{ + Access: &store.MemoAccessScope{UserID: &owner.ID, AllowPublic: true, AllowProtected: true}, + }) + require.NoError(t, err) + require.ElementsMatch(t, []int32{privateContext.ID, publicComment.ID, publicContext.ID, privateComment.ID}, memoIDs(ownerRows)) +} + +func TestMemoAccessScopeUsesAudienceForInvalidLocalPlacement(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "access-invalid-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + memo, err := ts.CreateMemo(ctx, &store.Memo{UID: "access-invalid-memo", CreatorID: owner.ID, Content: "memo", Visibility: store.Public}) + require.NoError(t, err) + + _, err = ts.GetDriver().GetDB().ExecContext(ctx, fmt.Sprintf("UPDATE memo SET space_id = 2147483000 WHERE id = %d", memo.ID)) + require.NoError(t, err) + visible, err := ts.ListMemos(ctx, &store.FindMemo{ + Access: &store.MemoAccessScope{UserID: &owner.ID, AllowPublic: true, AllowProtected: true}, + }) + require.NoError(t, err) + require.Equal(t, []int32{memo.ID}, memoIDs(visible), "a dangling placement must not override a non-Space audience") + + _, err = ts.GetDriver().GetDB().ExecContext(ctx, fmt.Sprintf("UPDATE memo SET space_id = NULL, visibility = 'SPACE' WHERE id = %d", memo.ID)) + require.NoError(t, err) + visible, err = ts.ListMemos(ctx, &store.FindMemo{ + Access: &store.MemoAccessScope{UserID: &owner.ID, AllowPublic: true, AllowProtected: true}, + }) + require.NoError(t, err) + require.Empty(t, visible, "SPACE without placement fails closed even for the author") +} + +func TestMemoAccessScopeSpaceAudienceHasNoAuthorBypass(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + author, err := ts.CreateUser(ctx, &store.User{Username: "access-removed-author", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + admin, err := ts.CreateUser(ctx, &store.User{Username: "access-remaining-admin", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + space, err := ts.CreateSpace(ctx, &store.Space{UID: "access-author-space", Title: "Author access"}, author.ID) + require.NoError(t, err) + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: admin.ID, Role: store.SpaceMemberRoleAdmin}, author.ID) + require.NoError(t, err) + + membersMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "access-author-members", CreatorID: author.ID, Content: "members", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }) + require.NoError(t, err) + privateMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "access-author-private", CreatorID: author.ID, Content: "private", Visibility: store.Private, SpaceID: &space.ID, + }) + require.NoError(t, err) + require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: author.ID}, admin.ID)) + + authorRows, err := ts.ListMemos(ctx, &store.FindMemo{ + Access: &store.MemoAccessScope{UserID: &author.ID, AllowPublic: true, AllowProtected: true}, + }) + require.NoError(t, err) + require.Equal(t, []int32{privateMemo.ID}, memoIDs(authorRows), "PRIVATE remains author-readable, but SPACE requires current membership") + + adminRows, err := ts.ListMemos(ctx, &store.FindMemo{ + Access: &store.MemoAccessScope{UserID: &admin.ID, AllowPublic: true, AllowProtected: true}, + }) + require.NoError(t, err) + require.Equal(t, []int32{membersMemo.ID}, memoIDs(adminRows), "membership reads SPACE but does not expand PRIVATE") +} + +func TestMemoAccessScopeArchivedRowsRemainAuthorOnly(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "access-archive-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + viewer, err := ts.CreateUser(ctx, &store.User{Username: "access-archive-viewer", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + memo, err := ts.CreateMemo(ctx, &store.Memo{UID: "access-archive-memo", CreatorID: owner.ID, Content: "memo", Visibility: store.Public}) + require.NoError(t, err) + archived := store.Archived + require.NoError(t, ts.UpdateMemo(ctx, &store.UpdateMemo{ID: memo.ID, RowStatus: &archived})) + + ownerRows, err := ts.ListMemos(ctx, &store.FindMemo{ + RowStatus: &archived, + Access: &store.MemoAccessScope{UserID: &owner.ID, AllowPublic: true, AllowProtected: true}, + }) + require.NoError(t, err) + require.Equal(t, []int32{memo.ID}, memoIDs(ownerRows)) + viewerRows, err := ts.ListMemos(ctx, &store.FindMemo{ + RowStatus: &archived, + Access: &store.MemoAccessScope{UserID: &viewer.ID, AllowPublic: true, AllowProtected: true}, + }) + require.NoError(t, err) + require.Empty(t, viewerRows) + anonymousRows, err := ts.ListMemos(ctx, &store.FindMemo{RowStatus: &archived, Access: &store.MemoAccessScope{AllowPublic: true}}) + require.NoError(t, err) + require.Empty(t, anonymousRows) +} + +func TestMemoAccessScopeAllowsArchivedCreatorButFiltersMissingCreatorBeforePagination(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + archivedCreator, err := ts.CreateUser(ctx, &store.User{Username: "access-archived-creator", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + viewer, err := ts.CreateUser(ctx, &store.User{Username: "access-creator-viewer", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + publicMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "access-archived-creator-public", CreatorID: archivedCreator.ID, Content: "public", Visibility: store.Public, + }) + require.NoError(t, err) + protectedMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "access-archived-creator-protected", CreatorID: archivedCreator.ID, Content: "protected", Visibility: store.Protected, + }) + require.NoError(t, err) + archived := store.Archived + _, err = ts.UpdateUser(ctx, &store.UpdateUser{ID: archivedCreator.ID, RowStatus: &archived}) + require.NoError(t, err) + + visible, err := ts.ListMemos(ctx, &store.FindMemo{ + Access: &store.MemoAccessScope{UserID: &viewer.ID, AllowPublic: true, AllowProtected: true}, + }) + require.NoError(t, err) + require.ElementsMatch(t, []int32{publicMemo.ID, protectedMemo.ID}, memoIDs(visible), + "archiving a creator does not change the audience of their active memos") + + missingCreatorMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "access-missing-creator", CreatorID: viewer.ID, Content: "corrupt", Visibility: store.Public, + }) + require.NoError(t, err) + _, err = ts.GetDriver().GetDB().ExecContext(ctx, + fmt.Sprintf("UPDATE memo SET creator_id = 2147483000 WHERE id = %d", missingCreatorMemo.ID)) + require.NoError(t, err) + + limit := 2 + visible, err = ts.ListMemos(ctx, &store.FindMemo{ + Access: &store.MemoAccessScope{UserID: &viewer.ID, AllowPublic: true, AllowProtected: true}, + Limit: &limit, + }) + require.NoError(t, err) + require.Len(t, visible, 2) + require.ElementsMatch(t, []int32{publicMemo.ID, protectedMemo.ID}, memoIDs(visible), + "a newer dangling-creator row must be removed before LIMIT is applied") +} + +func memoIDs(memos []*store.Memo) []int32 { + ids := make([]int32, 0, len(memos)) + for _, memo := range memos { + ids = append(ids, memo.ID) + } + return ids +} diff --git a/store/test/memo_delete_policy_test.go b/store/test/memo_delete_policy_test.go new file mode 100644 index 00000000..5f46e519 --- /dev/null +++ b/store/test/memo_delete_policy_test.go @@ -0,0 +1,182 @@ +package test + +import ( + "context" + "fmt" + "testing" + + "github.com/stretchr/testify/require" + + storepb "github.com/usememos/memos/proto/gen/store" + "github.com/usememos/memos/store" +) + +func TestDeleteMemoWithPolicyDeletesOnlyTargetAndIncidentResources(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + contextAuthor, err := ts.CreateUser(ctx, &store.User{Username: "delete-context-author", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + commentAuthor, err := ts.CreateUser(ctx, &store.User{Username: "delete-comment-author", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + replyAuthor, err := ts.CreateUser(ctx, &store.User{Username: "delete-reply-author", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + + contextMemo, err := ts.CreateMemo(ctx, &store.Memo{UID: "delete-context", CreatorID: contextAuthor.ID, Content: "context", Visibility: store.Public}) + require.NoError(t, err) + comment, err := ts.CreateMemoComment(ctx, &store.Memo{UID: "delete-comment", CreatorID: commentAuthor.ID, Content: "comment", Visibility: store.Protected}, contextMemo.ID, commentAuthor.ID) + require.NoError(t, err) + reply, err := ts.CreateMemoComment(ctx, &store.Memo{UID: "delete-reply", CreatorID: replyAuthor.ID, Content: "reply", Visibility: store.Public}, comment.ID, replyAuthor.ID) + require.NoError(t, err) + + attachment, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: "delete-comment-attachment", CreatorID: commentAuthor.ID, Filename: "comment.txt", Type: "text/plain", Size: 1, Blob: []byte("x"), MemoID: &comment.ID, + }) + require.NoError(t, err) + reaction, err := ts.UpsertReaction(ctx, &store.Reaction{CreatorID: contextAuthor.ID, MemoID: comment.ID, ReactionType: "heart"}) + require.NoError(t, err) + share, err := ts.CreateMemoShare(ctx, &store.MemoShare{UID: "delete-comment-share", MemoID: comment.ID, CreatorID: commentAuthor.ID}) + require.NoError(t, err) + inbox, err := ts.CreateInbox(ctx, &store.Inbox{ + SenderID: commentAuthor.ID, ReceiverID: contextAuthor.ID, Status: store.UNREAD, + Message: &storepb.InboxMessage{ + Type: storepb.InboxMessage_MEMO_COMMENT, + Payload: &storepb.InboxMessage_MemoComment{MemoComment: &storepb.InboxMessage_MemoCommentPayload{ + MemoId: comment.ID, RelatedMemoId: contextMemo.ID, + }}, + }, + }) + require.NoError(t, err) + + _, err = ts.DeleteMemoWithPolicy(ctx, &store.DeleteMemoWithPolicy{MemoID: comment.ID, ActorUserID: replyAuthor.ID}) + require.ErrorIs(t, err, store.ErrMemoPermissionDenied) + + result, err := ts.DeleteMemoWithPolicy(ctx, &store.DeleteMemoWithPolicy{MemoID: comment.ID, ActorUserID: commentAuthor.ID}) + require.NoError(t, err) + require.True(t, result.ActorCanRead) + + deleted, err := ts.GetMemo(ctx, &store.FindMemo{ID: &comment.ID}) + require.NoError(t, err) + require.Nil(t, deleted) + for _, survivorID := range []int32{contextMemo.ID, reply.ID} { + survivor, err := ts.GetMemo(ctx, &store.FindMemo{ID: &survivorID}) + require.NoError(t, err) + require.NotNil(t, survivor) + } + + gotAttachment, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID}) + require.NoError(t, err) + require.Nil(t, gotAttachment) + gotReaction, err := ts.GetReaction(ctx, &store.FindReaction{ID: &reaction.ID}) + require.NoError(t, err) + require.Nil(t, gotReaction) + gotShare, err := ts.GetMemoShare(ctx, &store.FindMemoShare{ID: &share.ID}) + require.NoError(t, err) + require.Nil(t, gotShare) + gotInboxes, err := ts.ListInboxes(ctx, &store.FindInbox{ID: &inbox.ID}) + require.NoError(t, err) + require.Len(t, gotInboxes, 1, "Memo deletion must not control the independent inbox lifecycle") + + incident, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{MemoIDList: []int32{comment.ID}}) + require.NoError(t, err) + require.Empty(t, incident) + replyRelations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{MemoID: &reply.ID}) + require.NoError(t, err) + require.Empty(t, replyRelations, "the surviving reply loses only its deleted context relation") +} + +func TestMemoDeleteActorCanReadAudienceMatrix(t *testing.T) { + spaceID := int32(1) + tests := []struct { + name string + rowStatus store.RowStatus + visibility store.Visibility + spaceID *int32 + spaceExists bool + actorMember bool + actorCanRead bool + }{ + {name: "public", rowStatus: store.Normal, visibility: store.Public, actorCanRead: true}, + {name: "protected", rowStatus: store.Normal, visibility: store.Protected, actorCanRead: true}, + {name: "private author", rowStatus: store.Normal, visibility: store.Private, actorCanRead: true}, + {name: "space member", rowStatus: store.Normal, visibility: store.SpaceAudience, spaceID: &spaceID, spaceExists: true, actorMember: true, actorCanRead: true}, + {name: "removed space member", rowStatus: store.Normal, visibility: store.SpaceAudience, spaceID: &spaceID, spaceExists: true}, + {name: "space audience without placement", rowStatus: store.Normal, visibility: store.SpaceAudience}, + {name: "dangling placement", rowStatus: store.Normal, visibility: store.Public, spaceID: &spaceID, actorCanRead: true}, + {name: "unknown audience", rowStatus: store.Normal, visibility: store.Visibility("UNKNOWN")}, + {name: "invalid lifecycle", rowStatus: store.RowStatus("UNKNOWN"), visibility: store.Public}, + {name: "archived author", rowStatus: store.Archived, visibility: store.Private, actorCanRead: true}, + } + + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + require.Equal(t, test.actorCanRead, store.MemoDeleteActorCanRead( + test.rowStatus, + test.visibility, + test.spaceID, + test.spaceExists, + test.actorMember, + )) + }) + } +} + +func TestDeleteMemoWithPolicySnapshotsCurrentAudience(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + author, err := ts.CreateUser(ctx, &store.User{Username: "delete-snapshot-author", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + admin, err := ts.CreateUser(ctx, &store.User{Username: "delete-snapshot-admin", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + space, err := ts.CreateSpace(ctx, &store.Space{UID: "delete-snapshot-space", Title: "Delete snapshot"}, author.ID) + require.NoError(t, err) + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: admin.ID, Role: store.SpaceMemberRoleAdmin}, author.ID) + require.NoError(t, err) + + type memoExpectation struct { + memo *store.Memo + actorCanRead bool + } + memos := make([]memoExpectation, 0, 4) + for index, visibility := range []store.Visibility{store.Public, store.Protected, store.Private, store.SpaceAudience} { + memo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: fmt.Sprintf("delete-snapshot-%d", index), + CreatorID: author.ID, + Content: visibility.String(), + Visibility: visibility, + SpaceID: &space.ID, + }) + require.NoError(t, err) + memos = append(memos, memoExpectation{memo: memo, actorCanRead: visibility != store.SpaceAudience}) + } + require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: author.ID}, admin.ID)) + + for _, expectation := range memos { + result, err := ts.DeleteMemoWithPolicy(ctx, &store.DeleteMemoWithPolicy{MemoID: expectation.memo.ID, ActorUserID: author.ID}) + require.NoError(t, err) + require.Equal(t, expectation.actorCanRead, result.ActorCanRead, expectation.memo.Visibility) + } + + dangling, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "delete-snapshot-dangling", CreatorID: author.ID, Content: "dangling", Visibility: store.Public, + }) + require.NoError(t, err) + _, err = ts.GetDriver().GetDB().ExecContext(ctx, fmt.Sprintf("UPDATE memo SET space_id = 2147483000 WHERE id = %d", dangling.ID)) + require.NoError(t, err) + result, err := ts.DeleteMemoWithPolicy(ctx, &store.DeleteMemoWithPolicy{MemoID: dangling.ID, ActorUserID: author.ID}) + require.NoError(t, err) + require.True(t, result.ActorCanRead, "a dangling placement must not override a PUBLIC audience") + + unassignedMembers, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "delete-snapshot-unassigned-members", CreatorID: author.ID, Content: "invalid", Visibility: store.Public, + }) + require.NoError(t, err) + _, err = ts.GetDriver().GetDB().ExecContext(ctx, fmt.Sprintf("UPDATE memo SET visibility = 'SPACE' WHERE id = %d", unassignedMembers.ID)) + require.NoError(t, err) + result, err = ts.DeleteMemoWithPolicy(ctx, &store.DeleteMemoWithPolicy{MemoID: unassignedMembers.ID, ActorUserID: author.ID}) + require.NoError(t, err) + require.False(t, result.ActorCanRead, "SPACE without placement must fail closed") +} diff --git a/store/test/memo_filter_test.go b/store/test/memo_filter_test.go index 8a70c4e2..e159b98a 100644 --- a/store/test/memo_filter_test.go +++ b/store/test/memo_filter_test.go @@ -701,19 +701,19 @@ func TestMemoFilterCreatedTsComparison(t *testing.T) { tc := NewMemoFilterTestContext(t) defer tc.Close() - now := time.Now().Unix() + nowSec := time.Now().Unix() tc.CreateMemo(NewMemoBuilder("memo-ts", tc.User.ID).Content("Timestamp test")) // Test: created_ts < future (should match) - memos := tc.ListWithFilter(`created_ts < timestamp(` + formatInt64(now+3600) + `)`) + memos := tc.ListWithFilter(`created_ts < timestamp(` + formatInt64(nowSec+3600) + `)`) require.Len(t, memos, 1) // Test: created_ts > past (should match) - memos = tc.ListWithFilter(`created_ts > timestamp(` + formatInt64(now-3600) + `)`) + memos = tc.ListWithFilter(`created_ts > timestamp(` + formatInt64(nowSec-3600) + `)`) require.Len(t, memos, 1) // Test: created_ts > future (should not match) - memos = tc.ListWithFilter(`created_ts > timestamp(` + formatInt64(now+3600) + `)`) + memos = tc.ListWithFilter(`created_ts > timestamp(` + formatInt64(nowSec+3600) + `)`) require.Len(t, memos, 0) } diff --git a/store/test/memo_relation_policy_test.go b/store/test/memo_relation_policy_test.go new file mode 100644 index 00000000..8e2a3930 --- /dev/null +++ b/store/test/memo_relation_policy_test.go @@ -0,0 +1,160 @@ +package test + +import ( + "context" + "testing" + + "github.com/lithammer/shortuuid/v4" + "github.com/stretchr/testify/require" + + "github.com/usememos/memos/store" +) + +func TestMemoRelationMutationRevalidatesRelatedMemo(t *testing.T) { + t.Parallel() + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + spaceOwner, err := ts.CreateUser(ctx, &store.User{Username: "relation-space-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + // An application ADMIN deliberately acts as the source author. The instance + // role must not bypass the related memo's current Space audience. + actor, err := ts.CreateUser(ctx, &store.User{Username: "relation-app-admin", Role: store.RoleAdmin, PasswordHash: "hash"}) + require.NoError(t, err) + space, err := ts.CreateSpace(ctx, &store.Space{UID: shortuuid.New(), Title: "Relations"}, spaceOwner.ID) + require.NoError(t, err) + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: actor.ID, Role: store.SpaceMemberRoleUser}, spaceOwner.ID) + require.NoError(t, err) + + targetRoot, err := ts.CreateMemo(ctx, &store.Memo{ + UID: shortuuid.New(), CreatorID: spaceOwner.ID, Content: "target root", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }) + require.NoError(t, err) + targetComment, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: shortuuid.New(), CreatorID: spaceOwner.ID, Content: "independent target", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }, targetRoot.ID, spaceOwner.ID) + require.NoError(t, err) + source, err := ts.CreateMemo(ctx, &store.Memo{ + UID: shortuuid.New(), CreatorID: actor.ID, Content: "source", Visibility: store.Private, + }) + require.NoError(t, err) + + policy := &store.MemoWritePolicy{ + ActorUserID: actor.ID, + } + err = ts.ApplyMemoMutation(ctx, &store.MemoMutation{ + MemoID: source.ID, + MemoCreatorID: actor.ID, + ExpectedMemoContent: source.Content, + ReplaceReferenceRelations: true, + ReferenceRelations: []*store.MemoRelation{{ + MemoID: source.ID, RelatedMemoID: targetComment.ID, Type: store.MemoRelationReference, + }}, + Policy: policy, + }) + require.NoError(t, err) + + require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: actor.ID}, spaceOwner.ID)) + updatedContent := "must not commit" + err = ts.ApplyMemoMutation(ctx, &store.MemoMutation{ + MemoID: source.ID, + MemoCreatorID: actor.ID, + ExpectedMemoContent: source.Content, + MemoUpdate: &store.UpdateMemo{ID: source.ID, Content: &updatedContent}, + ReplaceReferenceRelations: true, + ReferenceRelations: []*store.MemoRelation{{ + MemoID: source.ID, RelatedMemoID: targetComment.ID, Type: store.MemoRelationReference, + }}, + Policy: policy, + }) + require.ErrorIs(t, err, store.ErrMemoPermissionDenied) + + stored, err := ts.GetMemo(ctx, &store.FindMemo{ID: &source.ID}) + require.NoError(t, err) + require.Equal(t, "source", stored.Content) + referenceType := store.MemoRelationReference + relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{MemoID: &source.ID, Type: &referenceType}) + require.NoError(t, err) + require.Len(t, relations, 1) + require.Equal(t, targetComment.ID, relations[0].RelatedMemoID) +} + +func TestMemoRelationMutationRejectsCommentPersistence(t *testing.T) { + t.Parallel() + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + user, err := createTestingHostUser(ctx, ts) + require.NoError(t, err) + source, err := ts.CreateMemo(ctx, &store.Memo{UID: shortuuid.New(), CreatorID: user.ID, Content: "source", Visibility: store.Private}) + require.NoError(t, err) + target, err := ts.CreateMemo(ctx, &store.Memo{UID: shortuuid.New(), CreatorID: user.ID, Content: "target", Visibility: store.Private}) + require.NoError(t, err) + + _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{MemoID: source.ID, RelatedMemoID: target.ID, Type: store.MemoRelationComment}) + require.Error(t, err) + err = ts.ApplyMemoMutation(ctx, &store.MemoMutation{ + MemoID: source.ID, + MemoCreatorID: user.ID, + ExpectedMemoContent: source.Content, + ReplaceReferenceRelations: true, + ReferenceRelations: []*store.MemoRelation{{ + MemoID: source.ID, RelatedMemoID: target.ID, Type: store.MemoRelationComment, + }}, + }) + require.Error(t, err) + + relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{MemoID: &source.ID}) + require.NoError(t, err) + require.Empty(t, relations) +} + +func TestMemoCommentCreationKeepsIndependentPlacementAndAudience(t *testing.T) { + t.Parallel() + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "comment-context-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + actor, err := ts.CreateUser(ctx, &store.User{Username: "comment-independent-actor", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + contextSpace, err := ts.CreateSpace(ctx, &store.Space{UID: shortuuid.New(), Title: "Context"}, owner.ID) + require.NoError(t, err) + commentSpace, err := ts.CreateSpace(ctx, &store.Space{UID: shortuuid.New(), Title: "Comment"}, owner.ID) + require.NoError(t, err) + for _, space := range []*store.Space{contextSpace, commentSpace} { + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: actor.ID, Role: store.SpaceMemberRoleUser}, owner.ID) + require.NoError(t, err) + } + contextMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: shortuuid.New(), CreatorID: owner.ID, Content: "context", Visibility: store.Public, SpaceID: &contextSpace.ID, + }) + require.NoError(t, err) + comment, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: shortuuid.New(), CreatorID: actor.ID, Content: "comment", Visibility: store.Private, SpaceID: &commentSpace.ID, + }, contextMemo.ID, actor.ID) + require.NoError(t, err) + require.Equal(t, store.Private, comment.Visibility) + require.Equal(t, &commentSpace.ID, comment.SpaceID) + + commentType := store.MemoRelationComment + relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{MemoID: &comment.ID, Type: &commentType}) + require.NoError(t, err) + require.Len(t, relations, 1) + require.Equal(t, contextMemo.ID, relations[0].RelatedMemoID) + require.Error(t, ts.DeleteMemoRelation(ctx, &store.DeleteMemoRelation{ + MemoID: &comment.ID, RelatedMemoID: &contextMemo.ID, Type: &commentType, + })) + + require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: contextSpace.ID, UserID: actor.ID}, owner.ID)) + rejectedUID := shortuuid.New() + _, err = ts.CreateMemoComment(ctx, &store.Memo{ + UID: rejectedUID, CreatorID: actor.ID, Content: "rejected", Visibility: store.Private, SpaceID: &commentSpace.ID, + }, contextMemo.ID, actor.ID) + require.ErrorIs(t, err, store.ErrMemoSpaceMembershipRequired) + rejected, getErr := ts.GetMemo(ctx, &store.FindMemo{UID: &rejectedUID}) + require.NoError(t, getErr) + require.Nil(t, rejected, "failed context participation must not leave an orphan memo") +} diff --git a/store/test/memo_relation_test.go b/store/test/memo_relation_test.go index 2276e2a8..237c0ed0 100644 --- a/store/test/memo_relation_test.go +++ b/store/test/memo_relation_test.go @@ -58,7 +58,7 @@ func TestMemoRelationStore(t *testing.T) { Type: store.MemoRelationComment, } _, err = ts.UpsertMemoRelation(ctx, commentRelation) - require.NoError(t, err) + require.Error(t, err) ts.Close() } @@ -106,7 +106,7 @@ func TestMemoRelationListByMemoID(t *testing.T) { _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{ MemoID: mainMemo.ID, RelatedMemoID: relatedMemo2.ID, - Type: store.MemoRelationComment, + Type: store.MemoRelationReference, }) require.NoError(t, err) @@ -124,7 +124,7 @@ func TestMemoRelationListByMemoID(t *testing.T) { Type: &refType, }) require.NoError(t, err) - require.Equal(t, 1, len(refRelations)) + require.Equal(t, 2, len(refRelations)) require.Equal(t, store.MemoRelationReference, refRelations[0].Type) // List by related memo ID @@ -195,6 +195,118 @@ func TestMemoRelationDelete(t *testing.T) { ts.Close() } +func TestMemoRelationDeleteRequiresExplicitReferenceType(t *testing.T) { + t.Parallel() + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + user, err := createTestingHostUser(ctx, ts) + require.NoError(t, err) + + contextMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "delete-guard-context", + CreatorID: user.ID, + Content: "context", + Visibility: store.Public, + }) + require.NoError(t, err) + comment, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: "delete-guard-comment", + CreatorID: user.ID, + Content: "comment", + Visibility: store.Private, + }, contextMemo.ID, user.ID) + require.NoError(t, err) + + commentType := store.MemoRelationComment + referenceType := store.MemoRelationReference + _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{ + MemoID: comment.ID, + RelatedMemoID: contextMemo.ID, + Type: referenceType, + }) + require.NoError(t, err) + + assertRelationExists := func(t *testing.T, relationType store.MemoRelationType) { + t.Helper() + relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{ + MemoID: &comment.ID, + Type: &relationType, + }) + require.NoError(t, err) + require.Len(t, relations, 1) + require.Equal(t, contextMemo.ID, relations[0].RelatedMemoID) + } + assertRelationsExist := func(t *testing.T) { + t.Helper() + assertRelationExists(t, commentType) + assertRelationExists(t, referenceType) + } + assertRelationsExist(t) + + zeroID := int32(0) + negativeID := int32(-1) + + for _, test := range []struct { + name string + run func() error + }{ + { + name: "store rejects omitted type", + run: func() error { + return ts.DeleteMemoRelation(ctx, &store.DeleteMemoRelation{ + MemoID: &comment.ID, RelatedMemoID: &contextMemo.ID, + }) + }, + }, + { + name: "driver rejects omitted type", + run: func() error { + return ts.GetDriver().DeleteMemoRelation(ctx, &store.DeleteMemoRelation{ + MemoID: &comment.ID, RelatedMemoID: &contextMemo.ID, + }) + }, + }, + { + name: "driver rejects comment type", + run: func() error { + return ts.GetDriver().DeleteMemoRelation(ctx, &store.DeleteMemoRelation{ + MemoID: &comment.ID, RelatedMemoID: &contextMemo.ID, Type: &commentType, + }) + }, + }, + { + name: "store rejects unscoped reference delete", + run: func() error { + return ts.DeleteMemoRelation(ctx, &store.DeleteMemoRelation{Type: &referenceType}) + }, + }, + { + name: "driver rejects unscoped reference delete", + run: func() error { + return ts.GetDriver().DeleteMemoRelation(ctx, &store.DeleteMemoRelation{Type: &referenceType}) + }, + }, + { + name: "store rejects non-positive memo endpoint", + run: func() error { + return ts.DeleteMemoRelation(ctx, &store.DeleteMemoRelation{MemoID: &zeroID, Type: &referenceType}) + }, + }, + { + name: "driver rejects non-positive related endpoint", + run: func() error { + return ts.GetDriver().DeleteMemoRelation(ctx, &store.DeleteMemoRelation{RelatedMemoID: &negativeID, Type: &referenceType}) + }, + }, + } { + t.Run(test.name, func(t *testing.T) { + require.Error(t, test.run()) + assertRelationsExist(t) + }) + } +} + func TestMemoRelationDifferentTypes(t *testing.T) { t.Parallel() ctx := context.Background() @@ -226,20 +338,21 @@ func TestMemoRelationDifferentTypes(t *testing.T) { }) require.NoError(t, err) - // Create comment relation (same memos, different type - should be allowed) + // COMMENT context is created atomically with its memo and cannot be + // persisted through the generic relation mutation path. _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{ MemoID: mainMemo.ID, RelatedMemoID: relatedMemo.ID, Type: store.MemoRelationComment, }) - require.NoError(t, err) + require.Error(t, err) - // Verify both relations exist + // Verify only the reference relation exists. relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{ MemoID: &mainMemo.ID, }) require.NoError(t, err) - require.Equal(t, 2, len(relations)) + require.Len(t, relations, 1) ts.Close() } @@ -332,11 +445,11 @@ func TestMemoRelationDeleteByType(t *testing.T) { }) require.NoError(t, err) - // Create comment relation + // Create a second reference relation. _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{ MemoID: mainMemo.ID, RelatedMemoID: relatedMemo2.ID, - Type: store.MemoRelationComment, + Type: store.MemoRelationReference, }) require.NoError(t, err) @@ -348,13 +461,12 @@ func TestMemoRelationDeleteByType(t *testing.T) { }) require.NoError(t, err) - // Verify only comment relation remains + // Verify all reference relations were deleted. relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{ MemoID: &mainMemo.ID, }) require.NoError(t, err) - require.Len(t, relations, 1) - require.Equal(t, store.MemoRelationComment, relations[0].Type) + require.Empty(t, relations) ts.Close() } @@ -405,9 +517,11 @@ func TestMemoRelationDeleteByMemoID(t *testing.T) { }) require.NoError(t, err) - // Delete all relations for memo1 + // Delete all reference relations for memo1. + referenceType := store.MemoRelationReference err = ts.DeleteMemoRelation(ctx, &store.DeleteMemoRelation{ MemoID: &memo1.ID, + Type: &referenceType, }) require.NoError(t, err) @@ -472,7 +586,7 @@ func TestMemoRelationListByRelatedMemoID(t *testing.T) { _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{ MemoID: referrer2.ID, RelatedMemoID: targetMemo.ID, - Type: store.MemoRelationComment, + Type: store.MemoRelationReference, }) require.NoError(t, err) @@ -528,26 +642,26 @@ func TestMemoRelationListCombinedFilters(t *testing.T) { _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{ MemoID: mainMemo.ID, RelatedMemoID: relatedMemo2.ID, - Type: store.MemoRelationComment, + Type: store.MemoRelationReference, }) require.NoError(t, err) // List with MemoID and Type filter refType := store.MemoRelationReference relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{ - MemoID: &mainMemo.ID, - Type: &refType, + MemoID: &mainMemo.ID, + RelatedMemoID: &relatedMemo1.ID, + Type: &refType, }) require.NoError(t, err) require.Len(t, relations, 1) require.Equal(t, relatedMemo1.ID, relations[0].RelatedMemoID) // List with MemoID, RelatedMemoID, and Type filter - commentType := store.MemoRelationComment relations, err = ts.ListMemoRelations(ctx, &store.FindMemoRelation{ MemoID: &mainMemo.ID, RelatedMemoID: &relatedMemo2.ID, - Type: &commentType, + Type: &refType, }) require.NoError(t, err) require.Len(t, relations, 1) @@ -686,11 +800,11 @@ func TestMemoRelationListByMemoIDList(t *testing.T) { }) require.NoError(t, err) - // A -> C (comment) + // A -> C (reference) _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{ MemoID: memoA.ID, RelatedMemoID: memoC.ID, - Type: store.MemoRelationComment, + Type: store.MemoRelationReference, }) require.NoError(t, err) @@ -802,11 +916,11 @@ func TestMemoRelationListByMemoIDListWithTypeFilter(t *testing.T) { }) require.NoError(t, err) - // A -> C (comment) + // A -> C (reference) _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{ MemoID: memoA.ID, RelatedMemoID: memoC.ID, - Type: store.MemoRelationComment, + Type: store.MemoRelationReference, }) require.NoError(t, err) @@ -817,7 +931,7 @@ func TestMemoRelationListByMemoIDListWithTypeFilter(t *testing.T) { Type: &refType, }) require.NoError(t, err) - require.Len(t, relations, 1) + require.Len(t, relations, 2) require.Equal(t, store.MemoRelationReference, relations[0].Type) // Batch query with type filter: only comments @@ -827,8 +941,7 @@ func TestMemoRelationListByMemoIDListWithTypeFilter(t *testing.T) { Type: &commentType, }) require.NoError(t, err) - require.Len(t, relations, 1) - require.Equal(t, store.MemoRelationComment, relations[0].Type) + require.Empty(t, relations) ts.Close() } @@ -961,16 +1074,16 @@ func TestMemoRelationFiltersSourceStatusBeforePagination(t *testing.T) { archived := store.Archived require.NoError(t, ts.UpdateMemo(ctx, &store.UpdateMemo{ID: archivedMemo.ID, RowStatus: &archived})) for _, memoID := range []int32{normalMemo.ID, archivedMemo.ID} { - _, err := ts.UpsertMemoRelation(ctx, &store.MemoRelation{MemoID: memoID, RelatedMemoID: parent.ID, Type: store.MemoRelationComment}) + _, err := ts.UpsertMemoRelation(ctx, &store.MemoRelation{MemoID: memoID, RelatedMemoID: parent.ID, Type: store.MemoRelationReference}) require.NoError(t, err) } normal := store.Normal - commentType := store.MemoRelationComment + referenceType := store.MemoRelationReference limit := 1 relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{ RelatedMemoID: &parent.ID, - Type: &commentType, + Type: &referenceType, SourceMemoRowStatus: &normal, Limit: &limit, }) diff --git a/store/test/memo_share_test.go b/store/test/memo_share_test.go new file mode 100644 index 00000000..657345c6 --- /dev/null +++ b/store/test/memo_share_test.go @@ -0,0 +1,39 @@ +package test + +import ( + "context" + "testing" + + "github.com/stretchr/testify/require" + + "github.com/usememos/memos/store" +) + +func TestMemoShareDeleteRequiresSelector(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := createTestingHostUser(ctx, ts) + require.NoError(t, err) + memo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "memo-share-delete-selector", CreatorID: owner.ID, Content: "memo", Visibility: store.Public, + }) + require.NoError(t, err) + + for _, uid := range []string{"memo-share-delete-first", "memo-share-delete-second"} { + _, err := ts.CreateMemoShare(ctx, &store.MemoShare{UID: uid, MemoID: memo.ID, CreatorID: owner.ID}) + require.NoError(t, err) + } + + require.Error(t, ts.DeleteMemoShare(ctx, &store.DeleteMemoShare{})) + require.Error(t, ts.DeleteMemoShare(ctx, &store.DeleteMemoShare{MemoID: &memo.ID})) + shares, err := ts.ListMemoShares(ctx, &store.FindMemoShare{MemoID: &memo.ID}) + require.NoError(t, err) + require.Len(t, shares, 2) + + require.NoError(t, ts.DeleteMemoShare(ctx, &store.DeleteMemoShare{UID: &shares[0].UID})) + shares, err = ts.ListMemoShares(ctx, &store.FindMemoShare{MemoID: &memo.ID}) + require.NoError(t, err) + require.Len(t, shares, 1) +} diff --git a/store/test/memo_write_policy_test.go b/store/test/memo_write_policy_test.go new file mode 100644 index 00000000..39241910 --- /dev/null +++ b/store/test/memo_write_policy_test.go @@ -0,0 +1,205 @@ +package test + +import ( + "context" + "testing" + "time" + + "github.com/stretchr/testify/require" + + "github.com/usememos/memos/store" +) + +func TestMemoWritePolicyRevalidatesMembershipAndExactMemoShares(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "memo-policy-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + admin, err := ts.CreateUser(ctx, &store.User{Username: "memo-policy-admin", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + space, err := ts.CreateSpace(ctx, &store.Space{UID: "memo-policy-space", Title: "Policy"}, owner.ID) + require.NoError(t, err) + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: admin.ID, Role: store.SpaceMemberRoleAdmin}, owner.ID) + require.NoError(t, err) + memo, err := ts.CreateMemo(ctx, &store.Memo{UID: "memo-policy-root", CreatorID: owner.ID, Content: "memo", Visibility: store.Public, SpaceID: &space.ID}) + require.NoError(t, err) + comment, err := ts.CreateMemoComment(ctx, &store.Memo{UID: "memo-policy-comment", CreatorID: owner.ID, Content: "comment"}, memo.ID, owner.ID) + require.NoError(t, err) + + // A share on a related memo does not affect this memo's audience. + _, err = ts.CreateMemoShare(ctx, &store.MemoShare{UID: "memo-policy-comment-share", MemoID: comment.ID, CreatorID: owner.ID}) + require.NoError(t, err) + spaceAudience := store.SpaceAudience + err = ts.UpdateMemo(ctx, &store.UpdateMemo{ + ID: memo.ID, + Visibility: &spaceAudience, + Policy: memoWritePolicy(owner.ID, false), + }) + require.NoError(t, err) + + public := store.Public + err = ts.UpdateMemo(ctx, &store.UpdateMemo{ID: memo.ID, Visibility: &public}) + require.NoError(t, err) + memo.Visibility = store.Public + _, err = ts.CreateMemoShare(ctx, &store.MemoShare{UID: "memo-policy-direct-share", MemoID: memo.ID, CreatorID: owner.ID}) + require.NoError(t, err) + err = ts.UpdateMemo(ctx, &store.UpdateMemo{ + ID: memo.ID, + Visibility: &spaceAudience, + Policy: memoWritePolicy(owner.ID, false), + }) + require.ErrorIs(t, err, store.ErrMemoShareConflict) + + require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: owner.ID}, admin.ID)) + updatedContent := "must not commit" + err = ts.UpdateMemo(ctx, &store.UpdateMemo{ + ID: memo.ID, + Content: &updatedContent, + Policy: memoWritePolicy(owner.ID, false), + }) + require.ErrorIs(t, err, store.ErrMemoSpaceMembershipRequired) + + // The explicit lifecycle exception still permits withdrawal after removal. + err = ts.UpdateMemo(ctx, &store.UpdateMemo{ + ID: memo.ID, + ClearSpace: true, + Policy: memoWritePolicy(owner.ID, true), + }) + require.NoError(t, err) + memo, err = ts.GetMemo(ctx, &store.FindMemo{ID: &memo.ID}) + require.NoError(t, err) + require.Nil(t, memo.SpaceID) + require.Equal(t, "memo", memo.Content) +} + +func TestMemoWritePolicyIgnoresExpiredSharesWhenNarrowingAudience(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "memo-expired-share-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + space, err := ts.CreateSpace(ctx, &store.Space{UID: "memo-expired-share-space", Title: "Expired share"}, owner.ID) + require.NoError(t, err) + memo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "memo-expired-share-root", CreatorID: owner.ID, Content: "memo", Visibility: store.Public, SpaceID: &space.ID, + }) + require.NoError(t, err) + expiredTsSec := time.Now().Add(-time.Hour).Unix() + _, err = ts.CreateMemoShare(ctx, &store.MemoShare{ + UID: "memo-expired-share-token", MemoID: memo.ID, CreatorID: owner.ID, ExpiresTs: &expiredTsSec, + }) + require.NoError(t, err) + + spaceAudience := store.SpaceAudience + err = ts.UpdateMemo(ctx, &store.UpdateMemo{ + ID: memo.ID, + Visibility: &spaceAudience, + Policy: memoWritePolicy(owner.ID, false), + }) + require.NoError(t, err) +} + +func TestMemoWritePolicyRemovedMemberCanOnlyMoveOrWithdraw(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "memo-move-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + admin, err := ts.CreateUser(ctx, &store.User{Username: "memo-move-admin", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + source, err := ts.CreateSpace(ctx, &store.Space{UID: "memo-move-source", Title: "Source"}, owner.ID) + require.NoError(t, err) + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: source.ID, UserID: admin.ID, Role: store.SpaceMemberRoleAdmin}, owner.ID) + require.NoError(t, err) + target, err := ts.CreateSpace(ctx, &store.Space{UID: "memo-move-target", Title: "Target"}, owner.ID) + require.NoError(t, err) + memo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "memo-move", CreatorID: owner.ID, Content: "memo", Visibility: store.Public, SpaceID: &source.ID, + }) + require.NoError(t, err) + require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: source.ID, UserID: owner.ID}, admin.ID)) + + policy := memoWritePolicy(owner.ID, true) + newContent := "must not commit" + err = ts.UpdateMemo(ctx, &store.UpdateMemo{ID: memo.ID, SpaceID: &target.ID, Content: &newContent, Policy: policy}) + require.ErrorIs(t, err, store.ErrMemoSpaceMembershipRequired) + + err = ts.UpdateMemo(ctx, &store.UpdateMemo{ID: memo.ID, SpaceID: &target.ID, Policy: policy}) + require.NoError(t, err) + memo, err = ts.GetMemo(ctx, &store.FindMemo{ID: &memo.ID}) + require.NoError(t, err) + require.Equal(t, &target.ID, memo.SpaceID) + require.Equal(t, "memo", memo.Content) +} + +func TestMemoWritePolicyUsesCurrentAudienceForMoveRules(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "memo-current-audience-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + source, err := ts.CreateSpace(ctx, &store.Space{UID: "memo-current-audience-source", Title: "Source"}, owner.ID) + require.NoError(t, err) + target, err := ts.CreateSpace(ctx, &store.Space{UID: "memo-current-audience-target", Title: "Target"}, owner.ID) + require.NoError(t, err) + memo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "memo-current-audience", CreatorID: owner.ID, Content: "memo", Visibility: store.Public, SpaceID: &source.ID, + }) + require.NoError(t, err) + + // Simulate the audience changing after the transport read but before its + // policy-backed move. The transaction must use SPACE as the current + // audience and require explicit confirmation. + spaceAudience := store.SpaceAudience + require.NoError(t, ts.UpdateMemo(ctx, &store.UpdateMemo{ID: memo.ID, Visibility: &spaceAudience})) + policy := memoWritePolicy(owner.ID, true) + err = ts.UpdateMemo(ctx, &store.UpdateMemo{ID: memo.ID, SpaceID: &target.ID, Policy: policy}) + require.ErrorIs(t, err, store.ErrMemoMutationConflict) + + err = ts.UpdateMemo(ctx, &store.UpdateMemo{ID: memo.ID, SpaceID: &target.ID, Visibility: &spaceAudience, Policy: policy}) + require.NoError(t, err) + stored, err := ts.GetMemo(ctx, &store.FindMemo{ID: &memo.ID}) + require.NoError(t, err) + require.Equal(t, &target.ID, stored.SpaceID) + require.Equal(t, store.SpaceAudience, stored.Visibility) +} + +func TestMemoWritePolicyUsesCurrentAudienceWhenCreatingShare(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "memo-current-share-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + space, err := ts.CreateSpace(ctx, &store.Space{UID: "memo-current-share-space", Title: "Share"}, owner.ID) + require.NoError(t, err) + memo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "memo-current-share", CreatorID: owner.ID, Content: "memo", Visibility: store.Public, SpaceID: &space.ID, + }) + require.NoError(t, err) + + policy := &store.MemoWritePolicy{ActorUserID: owner.ID, CreatingShare: true} + spaceAudience := store.SpaceAudience + require.NoError(t, ts.UpdateMemo(ctx, &store.UpdateMemo{ID: memo.ID, Visibility: &spaceAudience})) + _, err = ts.CreateMemoShare(ctx, &store.MemoShare{ + UID: "memo-current-share-token", MemoID: memo.ID, CreatorID: owner.ID, Policy: policy, + }) + require.ErrorIs(t, err, store.ErrMemoShareConflict) + + public := store.Public + archived := store.Archived + require.NoError(t, ts.UpdateMemo(ctx, &store.UpdateMemo{ID: memo.ID, Visibility: &public, RowStatus: &archived})) + _, err = ts.CreateMemoShare(ctx, &store.MemoShare{ + UID: "memo-current-archived-share", MemoID: memo.ID, CreatorID: owner.ID, Policy: policy, + }) + require.ErrorIs(t, err, store.ErrMemoMutationConflict) +} + +func memoWritePolicy(actorUserID int32, lifecycleOnly bool) *store.MemoWritePolicy { + return &store.MemoWritePolicy{ActorUserID: actorUserID, LifecycleOnly: lifecycleOnly} +} diff --git a/store/test/migrator_test.go b/store/test/migrator_test.go index 4c379b85..cddeab92 100644 --- a/store/test/migrator_test.go +++ b/store/test/migrator_test.go @@ -29,6 +29,16 @@ func (d *delayedInstanceSettingCreateDriver) CreateInstanceSettingIfNotExists(ct return d.Driver.CreateInstanceSettingIfNotExists(ctx, create) } +func requireQueryError(ctx context.Context, t *testing.T, db *sql.DB, query, message string) { + t.Helper() + rows, err := db.QueryContext(ctx, query) + if rows != nil { + defer rows.Close() + require.NoError(t, rows.Err()) + } + require.Error(t, err, message) +} + // TestFreshInstall verifies that LATEST.sql applies correctly on a fresh database. // This is essentially what NewTestingStore already does, but we make it explicit. func TestFreshInstall(t *testing.T) { @@ -48,6 +58,42 @@ func TestFreshInstall(t *testing.T) { instanceSetting, err := ts.GetInstanceBasicSetting(ctx) require.NoError(t, err) require.Equal(t, currentSchemaVersion, instanceSetting.SchemaVersion) + + // The fresh schema supports memo-local Space placement without adding a + // canonical thread shape. COMMENT remains an ordinary relation row. + driver := getDriverFromEnv() + insertSpace := "INSERT INTO space (id, uid, title, description) VALUES (?, ?, ?, ?)" + insertMemo := "INSERT INTO memo (id, uid, creator_id, content, visibility, payload, space_id) VALUES (?, ?, ?, ?, ?, ?, ?)" + insertRelation := "INSERT INTO memo_relation (memo_id, related_memo_id, type) VALUES (?, ?, ?)" + if driver == "postgres" { + insertSpace = "INSERT INTO space (id, uid, title, description) VALUES ($1, $2, $3, $4)" + insertMemo = "INSERT INTO memo (id, uid, creator_id, content, visibility, payload, space_id) VALUES ($1, $2, $3, $4, $5, $6, $7)" + insertRelation = "INSERT INTO memo_relation (memo_id, related_memo_id, type) VALUES ($1, $2, $3)" + } + _, err = ts.GetDriver().GetDB().ExecContext(ctx, insertSpace, 900001, "fresh-space", "Fresh Space", "schema fixture") + require.NoError(t, err) + _, err = ts.GetDriver().GetDB().ExecContext(ctx, insertMemo, 900001, "fresh-context", 1, "context", store.Public, `{}`, nil) + require.NoError(t, err) + _, err = ts.GetDriver().GetDB().ExecContext(ctx, insertMemo, 900002, "fresh-comment", 1, "comment", store.SpaceAudience, `{}`, 900001) + require.NoError(t, err) + _, err = ts.GetDriver().GetDB().ExecContext(ctx, insertRelation, 900002, 900001, store.MemoRelationComment) + require.NoError(t, err) + + var relationCount int + require.NoError(t, ts.GetDriver().GetDB().QueryRowContext(ctx, + "SELECT COUNT(*) FROM memo_relation WHERE memo_id = 900002 AND related_memo_id = 900001 AND type = 'COMMENT'", + ).Scan(&relationCount)) + require.Equal(t, 1, relationCount) + + requireQueryError(ctx, t, ts.GetDriver().GetDB(), "SELECT parent_memo_id, root_memo_id FROM memo LIMIT 0", "fresh memo schema must not contain canonical-root columns") + requireQueryError(ctx, t, ts.GetDriver().GetDB(), "SELECT row_status FROM space LIMIT 0", "fresh Space schema has no archived state") + if driver == "sqlite" { + var indexName string + require.NoError(t, ts.GetDriver().GetDB().QueryRowContext(ctx, + "SELECT name FROM sqlite_master WHERE type = 'index' AND name = 'idx_memo_creator_id'", + ).Scan(&indexName)) + require.Equal(t, "idx_memo_creator_id", indexName) + } } // TestMigrationReRun verifies that re-running the migration on an already @@ -104,6 +150,123 @@ func TestMigrationWithData(t *testing.T) { require.Equal(t, "Data before migration re-run", memo.Content, "memo content should be preserved") } +func TestMigrationMultiSpacesPreservesMemosAndRelations(t *testing.T) { + ctx := context.Background() + driver := getDriverFromEnv() + dsn := getTestingProfileForDriver(t, driver).DSN + db, err := sql.Open(driver, dsn) + require.NoError(t, err) + _, err = db.ExecContext(ctx, legacySchemaFixture(driver)) + require.NoError(t, err) + + basicSetting, err := protojson.Marshal(&storepb.InstanceBasicSetting{SchemaVersion: "0.31.3"}) + require.NoError(t, err) + insertSetting := "INSERT INTO system_setting (name, value, description) VALUES (?, ?, '')" + insertMemo := "INSERT INTO memo (id, uid, content, visibility, row_status, pinned, payload) VALUES (?, ?, ?, ?, ?, ?, ?)" + insertRelation := "INSERT INTO memo_relation (memo_id, related_memo_id, type) VALUES (?, ?, ?)" + if driver == "postgres" { + insertSetting = "INSERT INTO system_setting (name, value, description) VALUES ($1, $2, '')" + insertMemo = "INSERT INTO memo (id, uid, content, visibility, row_status, pinned, payload) VALUES ($1, $2, $3, $4, $5, $6, $7)" + insertRelation = "INSERT INTO memo_relation (memo_id, related_memo_id, type) VALUES ($1, $2, $3)" + } + _, err = db.ExecContext(ctx, insertSetting, "BASIC", string(basicSetting)) + require.NoError(t, err) + for _, memo := range []struct { + id int32 + uid string + visibility store.Visibility + rowStatus store.RowStatus + pinned bool + payload string + }{ + {id: 1, uid: "legacy-root", visibility: store.Public, rowStatus: store.Normal, pinned: true, payload: `{"property":{"hasLink":true}}`}, + {id: 2, uid: "legacy-direct-comment", visibility: store.Public, rowStatus: store.Normal, payload: `{}`}, + {id: 3, uid: "legacy-nested-comment", visibility: store.Protected, rowStatus: store.Archived, payload: `{"property":{"hasTaskList":true}}`}, + {id: 4, uid: "legacy-reference-target", visibility: store.Private, rowStatus: store.Normal, payload: `{}`}, + } { + _, err = db.ExecContext(ctx, insertMemo, memo.id, memo.uid, memo.uid, memo.visibility, memo.rowStatus, memo.pinned, memo.payload) + require.NoError(t, err) + } + for _, relation := range []struct { + memoID, relatedMemoID int32 + typeName store.MemoRelationType + }{ + {memoID: 2, relatedMemoID: 1, typeName: store.MemoRelationComment}, + {memoID: 3, relatedMemoID: 2, typeName: store.MemoRelationComment}, + {memoID: 1, relatedMemoID: 4, typeName: store.MemoRelationReference}, + } { + _, err = db.ExecContext(ctx, insertRelation, relation.memoID, relation.relatedMemoID, relation.typeName) + require.NoError(t, err) + } + if driver == "sqlite" { + _, err = db.ExecContext(ctx, "CREATE INDEX idx_memo_creator_id ON memo(creator_id)") + require.NoError(t, err) + } + require.NoError(t, db.Close()) + + ts := NewTestingStoreWithDSN(ctx, t, driver, dsn) + require.NoError(t, ts.Migrate(ctx)) + defer ts.Close() + + assertMemo := func(id int32, uid string, visibility store.Visibility, rowStatus store.RowStatus, pinned bool, payload string) { + t.Helper() + var gotUID, content string + var gotVisibility store.Visibility + var gotRowStatus store.RowStatus + var gotPinned bool + var gotPayload []byte + var spaceID sql.NullInt64 + query := "SELECT uid, content, visibility, row_status, pinned, payload, space_id FROM memo WHERE id = ?" + if driver == "postgres" { + query = "SELECT uid, content, visibility, row_status, pinned, payload, space_id FROM memo WHERE id = $1" + } + require.NoError(t, ts.GetDriver().GetDB().QueryRowContext(ctx, query, id).Scan( + &gotUID, &content, &gotVisibility, &gotRowStatus, &gotPinned, &gotPayload, &spaceID, + )) + require.Equal(t, uid, gotUID) + require.Equal(t, uid, content) + require.Equal(t, visibility, gotVisibility) + require.Equal(t, rowStatus, gotRowStatus) + require.Equal(t, pinned, gotPinned) + require.JSONEq(t, payload, string(gotPayload)) + require.False(t, spaceID.Valid) + } + assertMemo(1, "legacy-root", store.Public, store.Normal, true, `{"property":{"hasLink":true}}`) + assertMemo(2, "legacy-direct-comment", store.Public, store.Normal, false, `{}`) + assertMemo(3, "legacy-nested-comment", store.Protected, store.Archived, false, `{"property":{"hasTaskList":true}}`) + assertMemo(4, "legacy-reference-target", store.Private, store.Normal, false, `{}`) + + type relationRow struct { + memoID, relatedMemoID int32 + typeName store.MemoRelationType + } + rows, err := ts.GetDriver().GetDB().QueryContext(ctx, "SELECT memo_id, related_memo_id, type FROM memo_relation ORDER BY memo_id, related_memo_id, type") + require.NoError(t, err) + defer rows.Close() + var relations []relationRow + for rows.Next() { + var relation relationRow + require.NoError(t, rows.Scan(&relation.memoID, &relation.relatedMemoID, &relation.typeName)) + relations = append(relations, relation) + } + require.NoError(t, rows.Err()) + require.Equal(t, []relationRow{ + {memoID: 1, relatedMemoID: 4, typeName: store.MemoRelationReference}, + {memoID: 2, relatedMemoID: 1, typeName: store.MemoRelationComment}, + {memoID: 3, relatedMemoID: 2, typeName: store.MemoRelationComment}, + }, relations) + + requireQueryError(ctx, t, ts.GetDriver().GetDB(), "SELECT parent_memo_id, root_memo_id FROM memo LIMIT 0", "memo-local schema must not add canonical-root columns") + requireQueryError(ctx, t, ts.GetDriver().GetDB(), "SELECT row_status FROM space LIMIT 0", "Space has no archived state") + if driver == "sqlite" { + var indexName string + require.NoError(t, ts.GetDriver().GetDB().QueryRowContext(ctx, + "SELECT name FROM sqlite_master WHERE type = 'index' AND name = 'idx_memo_creator_id'", + ).Scan(&indexName)) + require.Equal(t, "idx_memo_creator_id", indexName, "memo rebuild must preserve the creator lookup index") + } +} + // TestMigrationMultipleReRuns verifies that migration is idempotent // even when run multiple times in succession. func TestMigrationMultipleReRuns(t *testing.T) { @@ -834,7 +997,21 @@ func legacySchemaFixture(driver string) string { ); CREATE TABLE memo ( id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, - uid VARCHAR(256) NOT NULL UNIQUE + uid VARCHAR(256) NOT NULL UNIQUE, + creator_id INT NOT NULL DEFAULT 0, + created_ts TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + updated_ts TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, + row_status VARCHAR(256) NOT NULL DEFAULT 'NORMAL', + content TEXT NOT NULL DEFAULT (''), + visibility VARCHAR(256) NOT NULL DEFAULT 'PRIVATE', + pinned BOOLEAN NOT NULL DEFAULT FALSE, + payload JSON NOT NULL DEFAULT (JSON_OBJECT()) + ); + CREATE TABLE memo_relation ( + memo_id INT NOT NULL, + related_memo_id INT NOT NULL, + type VARCHAR(256) NOT NULL, + UNIQUE(memo_id, related_memo_id, type) ); CREATE TABLE reaction ( id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, @@ -887,7 +1064,21 @@ func legacySchemaFixture(driver string) string { ); CREATE TABLE memo ( id SERIAL PRIMARY KEY, - uid TEXT NOT NULL UNIQUE + uid TEXT NOT NULL UNIQUE, + creator_id INTEGER NOT NULL DEFAULT 0, + created_ts BIGINT NOT NULL DEFAULT EXTRACT(EPOCH FROM NOW()), + updated_ts BIGINT NOT NULL DEFAULT EXTRACT(EPOCH FROM NOW()), + row_status TEXT NOT NULL DEFAULT 'NORMAL', + content TEXT NOT NULL DEFAULT '', + visibility TEXT NOT NULL DEFAULT 'PRIVATE', + pinned BOOLEAN NOT NULL DEFAULT FALSE, + payload JSONB NOT NULL DEFAULT '{}' + ); + CREATE TABLE memo_relation ( + memo_id INTEGER NOT NULL, + related_memo_id INTEGER NOT NULL, + type TEXT NOT NULL, + UNIQUE(memo_id, related_memo_id, type) ); CREATE TABLE reaction ( id SERIAL PRIMARY KEY, @@ -942,7 +1133,21 @@ func legacySchemaFixture(driver string) string { ); CREATE TABLE memo ( id INTEGER PRIMARY KEY AUTOINCREMENT, - uid TEXT NOT NULL UNIQUE + uid TEXT NOT NULL UNIQUE, + creator_id INTEGER NOT NULL DEFAULT 0, + created_ts BIGINT NOT NULL DEFAULT (strftime('%s', 'now')), + updated_ts BIGINT NOT NULL DEFAULT (strftime('%s', 'now')), + row_status TEXT NOT NULL CHECK (row_status IN ('NORMAL', 'ARCHIVED')) DEFAULT 'NORMAL', + content TEXT NOT NULL DEFAULT '', + visibility TEXT NOT NULL CHECK (visibility IN ('PUBLIC', 'PROTECTED', 'PRIVATE')) DEFAULT 'PRIVATE', + pinned INTEGER NOT NULL CHECK (pinned IN (0, 1)) DEFAULT 0, + payload TEXT NOT NULL DEFAULT '{}' + ); + CREATE TABLE memo_relation ( + memo_id INTEGER NOT NULL, + related_memo_id INTEGER NOT NULL, + type TEXT NOT NULL, + UNIQUE(memo_id, related_memo_id, type) ); CREATE TABLE reaction ( id INTEGER PRIMARY KEY AUTOINCREMENT, diff --git a/store/test/reaction_policy_test.go b/store/test/reaction_policy_test.go new file mode 100644 index 00000000..ad3245cd --- /dev/null +++ b/store/test/reaction_policy_test.go @@ -0,0 +1,198 @@ +package test + +import ( + "context" + "testing" + + "github.com/stretchr/testify/require" + + "github.com/usememos/memos/store" +) + +func TestReactionWritePolicyUsesTargetMemoAudience(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "reaction-local-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + viewer, err := ts.CreateUser(ctx, &store.User{Username: "reaction-local-viewer", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + outsider, err := ts.CreateUser(ctx, &store.User{Username: "reaction-local-outsider", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + + contextMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "reaction-local-context", CreatorID: owner.ID, Content: "public context", Visibility: store.Public, + }) + require.NoError(t, err) + privateComment, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: "reaction-local-private-comment", CreatorID: viewer.ID, Content: "private comment", Visibility: store.Private, + }, contextMemo.ID, viewer.ID) + require.NoError(t, err) + + _, err = ts.UpsertReaction(ctx, &store.Reaction{ + CreatorID: owner.ID, MemoID: privateComment.ID, ReactionType: "context-author", + Policy: reactionWritePolicy(owner.ID), + }) + require.ErrorIs(t, err, store.ErrMemoPermissionDenied, "a public context relation must not grant access to a private comment") + _, err = ts.UpsertReaction(ctx, &store.Reaction{ + CreatorID: viewer.ID, MemoID: privateComment.ID, ReactionType: "comment-author", + Policy: reactionWritePolicy(viewer.ID), + }) + require.NoError(t, err) + + privateContext, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "reaction-local-private-context", CreatorID: owner.ID, Content: "private context", Visibility: store.Private, + }) + require.NoError(t, err) + publicComment, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: "reaction-local-public-comment", CreatorID: owner.ID, Content: "public comment", Visibility: store.Public, + }, privateContext.ID, owner.ID) + require.NoError(t, err) + _, err = ts.UpsertReaction(ctx, &store.Reaction{ + CreatorID: outsider.ID, MemoID: publicComment.ID, ReactionType: "public-comment", + Policy: reactionWritePolicy(outsider.ID), + }) + require.NoError(t, err, "a private context relation must not restrict a public comment") + + _, err = ts.UpsertReaction(ctx, &store.Reaction{ + CreatorID: outsider.ID, MemoID: publicComment.ID, ReactionType: "wrong-actor", Policy: reactionWritePolicy(owner.ID), + }) + require.ErrorIs(t, err, store.ErrReactionPermissionDenied) +} + +func TestReactionWritePolicySpaceParticipationIsMemoLocal(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "reaction-space-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + member, err := ts.CreateUser(ctx, &store.User{Username: "reaction-space-member", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + outsider, err := ts.CreateUser(ctx, &store.User{Username: "reaction-space-outsider", Role: store.RoleAdmin, PasswordHash: "hash"}) + require.NoError(t, err) + + space, err := ts.CreateSpace(ctx, &store.Space{UID: "reaction-space", Title: "Reaction Space"}, owner.ID) + require.NoError(t, err) + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: member.ID, Role: store.SpaceMemberRoleUser}, owner.ID) + require.NoError(t, err) + spaceMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "reaction-space-memo", CreatorID: owner.ID, Content: "space memo", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }) + require.NoError(t, err) + + _, err = ts.UpsertReaction(ctx, &store.Reaction{ + CreatorID: member.ID, MemoID: spaceMemo.ID, ReactionType: "member", Policy: reactionWritePolicy(member.ID), + }) + require.NoError(t, err) + _, err = ts.UpsertReaction(ctx, &store.Reaction{ + CreatorID: outsider.ID, MemoID: spaceMemo.ID, ReactionType: "application-admin", Policy: reactionWritePolicy(outsider.ID), + }) + require.ErrorIs(t, err, store.ErrMemoSpaceMembershipRequired, "application ADMIN must not bypass Space membership") + + require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: member.ID}, owner.ID)) + _, err = ts.UpsertReaction(ctx, &store.Reaction{ + CreatorID: member.ID, MemoID: spaceMemo.ID, ReactionType: "former-member", Policy: reactionWritePolicy(member.ID), + }) + require.ErrorIs(t, err, store.ErrMemoSpaceMembershipRequired) + + assignedPrivate, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "reaction-space-private", CreatorID: owner.ID, Content: "private", Visibility: store.Private, SpaceID: &space.ID, + }) + require.NoError(t, err) + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: member.ID, Role: store.SpaceMemberRoleUser}, owner.ID) + require.NoError(t, err) + _, err = ts.UpsertReaction(ctx, &store.Reaction{ + CreatorID: member.ID, MemoID: assignedPrivate.ID, ReactionType: "private-member", Policy: reactionWritePolicy(member.ID), + }) + require.ErrorIs(t, err, store.ErrMemoPermissionDenied, "Space membership must not broaden a PRIVATE memo") +} + +func TestReactionWritePolicyRejectsInactiveActorAndMemo(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "reaction-state-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + actor, err := ts.CreateUser(ctx, &store.User{Username: "reaction-state-actor", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + memo, err := ts.CreateMemo(ctx, &store.Memo{UID: "reaction-state-memo", CreatorID: owner.ID, Content: "memo", Visibility: store.Public}) + require.NoError(t, err) + + archived := store.Archived + _, err = ts.UpdateUser(ctx, &store.UpdateUser{ID: actor.ID, RowStatus: &archived}) + require.NoError(t, err) + _, err = ts.UpsertReaction(ctx, &store.Reaction{ + CreatorID: actor.ID, MemoID: memo.ID, ReactionType: "inactive-actor", Policy: reactionWritePolicy(actor.ID), + }) + require.ErrorIs(t, err, store.ErrReactionPermissionDenied) + + require.NoError(t, ts.UpdateMemo(ctx, &store.UpdateMemo{ID: memo.ID, RowStatus: &archived})) + _, err = ts.UpsertReaction(ctx, &store.Reaction{ + CreatorID: owner.ID, MemoID: memo.ID, ReactionType: "inactive-memo", Policy: reactionWritePolicy(owner.ID), + }) + require.ErrorIs(t, err, store.ErrMemoSpaceNotWritable) +} + +func TestDeleteReactionAtomicallyEnforcesCreatorAndParticipation(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "reaction-delete-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + member, err := ts.CreateUser(ctx, &store.User{Username: "reaction-delete-member", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + space, err := ts.CreateSpace(ctx, &store.Space{UID: "reaction-delete-space", Title: "Delete Reactions"}, owner.ID) + require.NoError(t, err) + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: member.ID, Role: store.SpaceMemberRoleUser}, owner.ID) + require.NoError(t, err) + memo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "reaction-delete-memo", CreatorID: owner.ID, Content: "memo", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }) + require.NoError(t, err) + reaction, err := ts.UpsertReaction(ctx, &store.Reaction{ + CreatorID: member.ID, MemoID: memo.ID, ReactionType: "delete", Policy: reactionWritePolicy(member.ID), + }) + require.NoError(t, err) + + err = ts.DeleteReaction(ctx, &store.DeleteReaction{ + ID: &reaction.ID, MemoID: &memo.ID, ActorUserID: &owner.ID, Policy: reactionWritePolicy(owner.ID), + }) + require.ErrorIs(t, err, store.ErrReactionPermissionDenied) + requireReactionPresent(ctx, t, ts, reaction.ID) + + require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: member.ID}, owner.ID)) + err = ts.DeleteReaction(ctx, &store.DeleteReaction{ + ID: &reaction.ID, MemoID: &memo.ID, ActorUserID: &member.ID, Policy: reactionWritePolicy(member.ID), + }) + require.ErrorIs(t, err, store.ErrMemoSpaceMembershipRequired) + requireReactionPresent(ctx, t, ts, reaction.ID) + + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: member.ID, Role: store.SpaceMemberRoleUser}, owner.ID) + require.NoError(t, err) + require.NoError(t, ts.DeleteReaction(ctx, &store.DeleteReaction{ + ID: &reaction.ID, MemoID: &memo.ID, ActorUserID: &member.ID, Policy: reactionWritePolicy(member.ID), + })) + requireReactionMissing(ctx, t, ts, reaction.ID) +} + +func reactionWritePolicy(actorUserID int32) *store.ReactionWritePolicy { + return &store.ReactionWritePolicy{ActorUserID: actorUserID} +} + +func requireReactionPresent(ctx context.Context, t *testing.T, ts *store.Store, reactionID int32) { + t.Helper() + reaction, err := ts.GetReaction(ctx, &store.FindReaction{ID: &reactionID}) + require.NoError(t, err) + require.NotNil(t, reaction) +} + +func requireReactionMissing(ctx context.Context, t *testing.T, ts *store.Store, reactionID int32) { + t.Helper() + reaction, err := ts.GetReaction(ctx, &store.FindReaction{ID: &reactionID}) + require.NoError(t, err) + require.Nil(t, reaction) +} diff --git a/store/test/reaction_test.go b/store/test/reaction_test.go index dbd7c16c..adb25e8a 100644 --- a/store/test/reaction_test.go +++ b/store/test/reaction_test.go @@ -328,9 +328,8 @@ func TestReactionInsertedAfterMemoCleanupStartsIsRemoved(t *testing.T) { require.FailNow(t, "timed out waiting for memo delete barrier") } - // Store.DeleteMemo has completed its application-managed relation and - // attachment cleanup, but the physical memo delete has not started. This - // recreates the old window where a prior reaction cleanup could be bypassed. + // The deletion transaction has not started yet. A reaction created in this + // window must still be removed by the compound memo deletion. reaction, err := ts.UpsertReaction(ctx, &store.Reaction{ CreatorID: user.ID, MemoID: memo.ID, @@ -456,14 +455,14 @@ type memoDeleteBarrierDriver struct { continueDelete chan struct{} } -func (d *memoDeleteBarrierDriver) DeleteMemo(ctx context.Context, delete *store.DeleteMemo) error { +func (d *memoDeleteBarrierDriver) DeleteMemoWithPolicy(ctx context.Context, delete *store.DeleteMemoWithPolicy) (*store.DeleteMemoWithPolicyResult, error) { close(d.deleteStarted) select { case <-d.continueDelete: case <-ctx.Done(): - return ctx.Err() + return nil, ctx.Err() } - return d.Driver.DeleteMemo(ctx, delete) + return d.Driver.DeleteMemoWithPolicy(ctx, delete) } func newReactionTestingStoreWithDriver(ctx context.Context, t *testing.T, wrap func(store.Driver) store.Driver) *store.Store { diff --git a/store/test/space_delete_test.go b/store/test/space_delete_test.go new file mode 100644 index 00000000..0d2a7a80 --- /dev/null +++ b/store/test/space_delete_test.go @@ -0,0 +1,136 @@ +package test + +import ( + "context" + "testing" + + "github.com/stretchr/testify/require" + + storepb "github.com/usememos/memos/proto/gen/store" + "github.com/usememos/memos/store" +) + +func TestDeleteSpaceDeletesOnlyDirectlyAssignedMemosAndOwnedResources(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + admin, err := ts.CreateUser(ctx, &store.User{Username: "space-delete-admin", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + member, err := ts.CreateUser(ctx, &store.User{Username: "space-delete-member", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + applicationAdmin, err := ts.CreateUser(ctx, &store.User{Username: "space-delete-app-admin", Role: store.RoleAdmin, PasswordHash: "hash"}) + require.NoError(t, err) + + space, err := ts.CreateSpace(ctx, &store.Space{UID: "delete-space", Title: "Delete Space"}, admin.ID) + require.NoError(t, err) + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: member.ID, Role: store.SpaceMemberRoleUser}, admin.ID) + require.NoError(t, err) + + assigned, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "delete-space-assigned", + CreatorID: admin.ID, + Content: "assigned content", + Visibility: store.Public, + SpaceID: &space.ID, + }) + require.NoError(t, err) + survivor, err := ts.CreateMemo(ctx, &store.Memo{UID: "delete-space-survivor", CreatorID: member.ID, Content: "survivor", Visibility: store.Public}) + require.NoError(t, err) + otherSurvivor, err := ts.CreateMemo(ctx, &store.Memo{UID: "delete-space-other-survivor", CreatorID: member.ID, Content: "other", Visibility: store.Public}) + require.NoError(t, err) + + _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{MemoID: assigned.ID, RelatedMemoID: survivor.ID, Type: store.MemoRelationReference}) + require.NoError(t, err) + _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{MemoID: otherSurvivor.ID, RelatedMemoID: assigned.ID, Type: store.MemoRelationReference}) + require.NoError(t, err) + _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{MemoID: survivor.ID, RelatedMemoID: otherSurvivor.ID, Type: store.MemoRelationReference}) + require.NoError(t, err) + + attachment, err := ts.CreateAttachment(ctx, &store.Attachment{ + UID: "delete-space-attachment", + CreatorID: admin.ID, + Filename: "assigned.txt", + MemoID: &assigned.ID, + Payload: &storepb.AttachmentPayload{}, + }) + require.NoError(t, err) + reaction, err := ts.UpsertReaction(ctx, &store.Reaction{CreatorID: member.ID, MemoID: assigned.ID, ReactionType: "THUMBS_UP"}) + require.NoError(t, err) + share, err := ts.CreateMemoShare(ctx, &store.MemoShare{UID: "delete-space-share", MemoID: assigned.ID, CreatorID: admin.ID}) + require.NoError(t, err) + referencingNotification, err := ts.CreateInbox(ctx, &store.Inbox{ + SenderID: admin.ID, ReceiverID: member.ID, Status: store.UNREAD, + Message: &storepb.InboxMessage{ + Type: storepb.InboxMessage_MEMO_COMMENT, + Payload: &storepb.InboxMessage_MemoComment{MemoComment: &storepb.InboxMessage_MemoCommentPayload{ + MemoId: assigned.ID, RelatedMemoId: survivor.ID, + }}, + }, + }) + require.NoError(t, err) + survivingNotification, err := ts.CreateInbox(ctx, &store.Inbox{ + SenderID: member.ID, ReceiverID: admin.ID, Status: store.UNREAD, + Message: &storepb.InboxMessage{ + Type: storepb.InboxMessage_MEMO_MENTION, + Payload: &storepb.InboxMessage_MemoMention{MemoMention: &storepb.InboxMessage_MemoMentionPayload{ + MemoId: survivor.ID, RelatedMemoId: otherSurvivor.ID, + }}, + }, + }) + require.NoError(t, err) + + _, err = ts.DeleteSpace(ctx, &store.DeleteSpace{ID: space.ID, ActorUserID: member.ID}) + require.ErrorIs(t, err, store.ErrSpacePermissionDenied) + _, err = ts.DeleteSpace(ctx, &store.DeleteSpace{ID: space.ID, ActorUserID: applicationAdmin.ID}) + require.ErrorIs(t, err, store.ErrSpacePermissionDenied, "application ADMIN must not bypass Space membership") + + deleteResult, err := ts.DeleteSpace(ctx, &store.DeleteSpace{ID: space.ID, ActorUserID: admin.ID}) + require.NoError(t, err) + require.NotNil(t, deleteResult) + require.Len(t, deleteResult.Attachments, 1) + require.Equal(t, attachment.ID, deleteResult.Attachments[0].ID) + + deletedSpace, err := ts.GetSpace(ctx, &store.FindSpace{ID: &space.ID}) + require.NoError(t, err) + require.Nil(t, deletedSpace) + deletedMemo, err := ts.GetMemo(ctx, &store.FindMemo{ID: &assigned.ID}) + require.NoError(t, err) + require.Nil(t, deletedMemo) + for _, memoID := range []int32{survivor.ID, otherSurvivor.ID} { + memo, err := ts.GetMemo(ctx, &store.FindMemo{ID: &memoID}) + require.NoError(t, err) + require.NotNil(t, memo, "relation traversal must not delete surviving endpoints") + } + + deletedAttachment, err := ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID}) + require.NoError(t, err) + require.Nil(t, deletedAttachment) + deletedReaction, err := ts.GetReaction(ctx, &store.FindReaction{ID: &reaction.ID}) + require.NoError(t, err) + require.Nil(t, deletedReaction) + deletedShare, err := ts.GetMemoShare(ctx, &store.FindMemoShare{ID: &share.ID}) + require.NoError(t, err) + require.Nil(t, deletedShare) + retainedInboxes, err := ts.ListInboxes(ctx, &store.FindInbox{ID: &referencingNotification.ID}) + require.NoError(t, err) + require.Len(t, retainedInboxes, 1, "Space deletion must not control the independent inbox lifecycle") + survivingInboxes, err := ts.ListInboxes(ctx, &store.FindInbox{ID: &survivingNotification.ID}) + require.NoError(t, err) + require.Len(t, survivingInboxes, 1) + + incidentRelations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{MemoID: &assigned.ID}) + require.NoError(t, err) + require.Empty(t, incidentRelations) + incomingIncidentRelations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{RelatedMemoID: &assigned.ID}) + require.NoError(t, err) + require.Empty(t, incomingIncidentRelations) + survivingRelations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{MemoID: &survivor.ID}) + require.NoError(t, err) + require.Len(t, survivingRelations, 1) + require.Equal(t, otherSurvivor.ID, survivingRelations[0].RelatedMemoID) + + membership, err := ts.GetSpaceMember(ctx, &store.FindSpaceMember{SpaceID: &space.ID, UserID: &member.ID}) + require.NoError(t, err) + require.Nil(t, membership) +} diff --git a/store/test/space_test.go b/store/test/space_test.go new file mode 100644 index 00000000..aada02fc --- /dev/null +++ b/store/test/space_test.go @@ -0,0 +1,194 @@ +package test + +import ( + "context" + "testing" + + "github.com/stretchr/testify/require" + + "github.com/usememos/memos/store" +) + +func TestSpaceStoreMembershipGuards(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "space-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + member, err := ts.CreateUser(ctx, &store.User{Username: "space-member", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + + space, err := ts.CreateSpace(ctx, &store.Space{UID: "space-store", Title: "Store Space"}, owner.ID) + require.NoError(t, err) + + ownerMembership, err := ts.GetSpaceMember(ctx, &store.FindSpaceMember{SpaceID: &space.ID, UserID: &owner.ID, ViewerUserID: &owner.ID}) + require.NoError(t, err) + require.Equal(t, store.SpaceMemberRoleAdmin, ownerMembership.Role) + + created, err := ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: member.ID, Role: store.SpaceMemberRoleUser}, owner.ID) + require.NoError(t, err) + require.Equal(t, member.ID, created.UserID) + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: member.ID, Role: store.SpaceMemberRoleUser}, owner.ID) + require.ErrorIs(t, err, store.ErrSpaceMemberAlreadyExists) + + userRole := store.SpaceMemberRoleUser + _, err = ts.UpdateSpaceMember(ctx, &store.UpdateSpaceMember{SpaceID: space.ID, UserID: owner.ID, Role: &userRole}, owner.ID) + require.ErrorIs(t, err, store.ErrLastSpaceAdmin) + + adminRole := store.SpaceMemberRoleAdmin + _, err = ts.UpdateSpaceMember(ctx, &store.UpdateSpaceMember{SpaceID: space.ID, UserID: member.ID, Role: &adminRole}, owner.ID) + require.NoError(t, err) + _, err = ts.UpdateSpaceMember(ctx, &store.UpdateSpaceMember{SpaceID: space.ID, UserID: owner.ID, Role: &userRole}, member.ID) + require.NoError(t, err) + + require.NoError(t, ts.DeleteSpaceMember(ctx, &store.DeleteSpaceMember{SpaceID: space.ID, UserID: owner.ID}, owner.ID)) + ownerMembership, err = ts.GetSpaceMember(ctx, &store.FindSpaceMember{SpaceID: &space.ID, UserID: &owner.ID, ViewerUserID: &member.ID}) + require.NoError(t, err) + require.Nil(t, ownerMembership) +} + +func TestSpaceStoreRequiresTitle(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "space-title-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + _, err = ts.CreateSpace(ctx, nil, owner.ID) + require.Error(t, err) + _, err = ts.CreateSpace(ctx, &store.Space{UID: "space-title-empty"}, owner.ID) + require.Error(t, err) + _, err = ts.CreateSpace(ctx, &store.Space{UID: "space-title-blank", Title: " \t "}, owner.ID) + require.Error(t, err) + + space, err := ts.CreateSpace(ctx, &store.Space{UID: "space-title-preserved", Title: " Preserved "}, owner.ID) + require.NoError(t, err) + require.Equal(t, " Preserved ", space.Title) + _, err = ts.UpdateSpace(ctx, nil, owner.ID) + require.Error(t, err) + _, err = ts.UpdateSpace(ctx, &store.UpdateSpace{ID: space.ID}, owner.ID) + require.Error(t, err) + blank := " " + _, err = ts.UpdateSpace(ctx, &store.UpdateSpace{ID: space.ID, Title: &blank}, owner.ID) + require.Error(t, err) + stored, err := ts.GetSpace(ctx, &store.FindSpace{ID: &space.ID}) + require.NoError(t, err) + require.Equal(t, " Preserved ", stored.Title) + _, err = ts.UpdateSpaceMember(ctx, nil, owner.ID) + require.Error(t, err) +} + +func TestSpaceMemoAccessDoesNotFlowAcrossCommentRelation(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "memo-space-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + member, err := ts.CreateUser(ctx, &store.User{Username: "memo-space-member", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + outsider, err := ts.CreateUser(ctx, &store.User{Username: "memo-space-outsider", Role: store.RoleAdmin, PasswordHash: "hash"}) + require.NoError(t, err) + + space, err := ts.CreateSpace(ctx, &store.Space{UID: "memo-space", Title: "Memo Space"}, owner.ID) + require.NoError(t, err) + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: member.ID, Role: store.SpaceMemberRoleUser}, owner.ID) + require.NoError(t, err) + + contextMemo, err := ts.CreateMemo(ctx, &store.Memo{ + UID: "space-context", CreatorID: owner.ID, Content: "context", Visibility: store.SpaceAudience, SpaceID: &space.ID, + }) + require.NoError(t, err) + _, err = ts.CreateMemo(ctx, &store.Memo{ + UID: "outsider-assigned", CreatorID: outsider.ID, Content: "no", Visibility: store.Public, SpaceID: &space.ID, + }) + require.ErrorIs(t, err, store.ErrMemoSpaceMembershipRequired) + + comment, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: "space-public-comment", CreatorID: owner.ID, Content: "public comment", Visibility: store.Public, + }, contextMemo.ID, owner.ID) + require.NoError(t, err) + require.Nil(t, comment.SpaceID) + require.Equal(t, store.Public, comment.Visibility) + + memberMemos, err := ts.ListMemos(ctx, &store.FindMemo{ + Access: &store.MemoAccessScope{UserID: &member.ID, AllowPublic: true, AllowProtected: true}, + }) + require.NoError(t, err) + require.ElementsMatch(t, []int32{contextMemo.ID, comment.ID}, memoIDs(memberMemos)) + + outsiderMemos, err := ts.ListMemos(ctx, &store.FindMemo{ + Access: &store.MemoAccessScope{UserID: &outsider.ID, AllowPublic: true, AllowProtected: true}, + }) + require.NoError(t, err) + require.Equal(t, []int32{comment.ID}, memoIDs(outsiderMemos), "application ADMIN sees the public comment but cannot inherit its Space context") + + nonComments, err := ts.ListMemos(ctx, &store.FindMemo{ + Access: &store.MemoAccessScope{UserID: &member.ID, AllowPublic: true, AllowProtected: true}, + ExcludeComments: true, + }) + require.NoError(t, err) + require.Equal(t, []int32{contextMemo.ID}, memoIDs(nonComments)) +} + +func TestUserArchiveAndDeleteRequireLeavingSpaces(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + owner, err := ts.CreateUser(ctx, &store.User{Username: "archive-space-owner", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + backup, err := ts.CreateUser(ctx, &store.User{Username: "archive-space-backup", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + space, err := ts.CreateSpace(ctx, &store.Space{UID: "archive-space", Title: "Archive Space"}, owner.ID) + require.NoError(t, err) + + archived := store.Archived + _, err = ts.UpdateUser(ctx, &store.UpdateUser{ID: owner.ID, RowStatus: &archived}) + require.ErrorIs(t, err, store.ErrLastSpaceAdmin) + _, err = ts.CreateSpaceMember(ctx, &store.SpaceMember{SpaceID: space.ID, UserID: backup.ID, Role: store.SpaceMemberRoleAdmin}, owner.ID) + require.NoError(t, err) + _, err = ts.UpdateUser(ctx, &store.UpdateUser{ID: owner.ID, RowStatus: &archived}) + require.NoError(t, err) + _, err = ts.DeleteUser(ctx, &store.DeleteUser{ID: owner.ID}) + require.ErrorIs(t, err, store.ErrUserHasSpaceMembership) +} + +func TestDeleteUserRemovesAuthoredMemoWithoutFollowingComments(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + user, err := ts.CreateUser(ctx, &store.User{Username: "delete-comment-user", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + peer, err := ts.CreateUser(ctx, &store.User{Username: "delete-comment-peer", Role: store.RoleUser, PasswordHash: "hash"}) + require.NoError(t, err) + contextMemo, err := ts.CreateMemo(ctx, &store.Memo{UID: "peer-context", CreatorID: peer.ID, Content: "context", Visibility: store.Public}) + require.NoError(t, err) + comment, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: "user-comment", CreatorID: user.ID, Content: "comment", Visibility: store.Public, + }, contextMemo.ID, user.ID) + require.NoError(t, err) + reply, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: "peer-reply", CreatorID: peer.ID, Content: "reply", Visibility: store.Public, + }, comment.ID, peer.ID) + require.NoError(t, err) + + _, err = ts.DeleteUser(ctx, &store.DeleteUser{ID: user.ID}) + require.NoError(t, err) + deletedUser, err := ts.GetUser(ctx, &store.FindUser{ID: &user.ID}) + require.NoError(t, err) + require.Nil(t, deletedUser) + deletedComment, err := ts.GetMemo(ctx, &store.FindMemo{ID: &comment.ID}) + require.NoError(t, err) + require.Nil(t, deletedComment) + for _, memo := range []*store.Memo{contextMemo, reply} { + remaining, getErr := ts.GetMemo(ctx, &store.FindMemo{ID: &memo.ID}) + require.NoError(t, getErr) + require.NotNil(t, remaining) + } + relations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{MemoIDList: []int32{comment.ID}}) + require.NoError(t, err) + require.Empty(t, relations) +} diff --git a/store/test/user_delete_test.go b/store/test/user_delete_test.go index 19d001a4..5ecb7932 100644 --- a/store/test/user_delete_test.go +++ b/store/test/user_delete_test.go @@ -10,6 +10,22 @@ import ( "github.com/usememos/memos/store" ) +func TestDeleteUserIsIdempotent(t *testing.T) { + ctx := context.Background() + ts := NewTestingStore(ctx, t) + defer ts.Close() + + user, err := createTestingUserWithRole(ctx, ts, "delete-idempotent", store.RoleUser) + require.NoError(t, err) + first, err := ts.DeleteUser(ctx, &store.DeleteUser{ID: user.ID}) + require.NoError(t, err) + require.NotNil(t, first) + second, err := ts.DeleteUser(ctx, &store.DeleteUser{ID: user.ID}) + require.NoError(t, err) + require.NotNil(t, second) + require.Empty(t, second.UserSettingKeys) +} + func TestDeleteUserCleansRelatedData(t *testing.T) { t.Parallel() @@ -36,31 +52,17 @@ func TestDeleteUserCleansRelatedData(t *testing.T) { Visibility: store.Public, }) require.NoError(t, err) - peerCommentOnOwnMemo, err := ts.CreateMemo(ctx, &store.Memo{ - UID: "delete-peer-comment", - CreatorID: peer.ID, - Content: "peer comment on owner memo", - Visibility: store.Public, - }) + peerCommentOnOwnMemo, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: "delete-peer-comment", + CreatorID: peer.ID, + Content: "peer comment on owner memo", + }, ownMemo.ID, peer.ID) require.NoError(t, err) - _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{ - MemoID: peerCommentOnOwnMemo.ID, - RelatedMemoID: ownMemo.ID, - Type: store.MemoRelationComment, - }) - require.NoError(t, err) - userCommentOnPeerMemo, err := ts.CreateMemo(ctx, &store.Memo{ - UID: "delete-user-comment", - CreatorID: user.ID, - Content: "owner comment on peer memo", - Visibility: store.Public, - }) - require.NoError(t, err) - _, err = ts.UpsertMemoRelation(ctx, &store.MemoRelation{ - MemoID: userCommentOnPeerMemo.ID, - RelatedMemoID: peerMemo.ID, - Type: store.MemoRelationComment, - }) + userCommentOnPeerMemo, err := ts.CreateMemoComment(ctx, &store.Memo{ + UID: "delete-user-comment", + CreatorID: user.ID, + Content: "owner comment on peer memo", + }, peerMemo.ID, user.ID) require.NoError(t, err) ownerAttachment, err := ts.CreateAttachment(ctx, &store.Attachment{ @@ -139,7 +141,7 @@ func TestDeleteUserCleansRelatedData(t *testing.T) { Message: &storepb.InboxMessage{Type: storepb.InboxMessage_MEMO_MENTION}, }) require.NoError(t, err) - _, err = ts.CreateInbox(ctx, &store.Inbox{ + referencingDeletedMemoInbox, err := ts.CreateInbox(ctx, &store.Inbox{ SenderID: peer.ID, ReceiverID: peer.ID, Status: store.UNREAD, @@ -191,14 +193,16 @@ func TestDeleteUserCleansRelatedData(t *testing.T) { require.NoError(t, err) require.NotNil(t, keptUser) - for _, memo := range []*store.Memo{ownMemo, peerCommentOnOwnMemo, userCommentOnPeerMemo} { + for _, memo := range []*store.Memo{ownMemo, userCommentOnPeerMemo} { got, getErr := ts.GetMemo(ctx, &store.FindMemo{ID: &memo.ID}) require.NoError(t, getErr) require.Nil(t, got, memo.UID) } - keptMemo, err := ts.GetMemo(ctx, &store.FindMemo{ID: &peerMemo.ID}) - require.NoError(t, err) - require.NotNil(t, keptMemo) + for _, memo := range []*store.Memo{peerMemo, peerCommentOnOwnMemo} { + got, getErr := ts.GetMemo(ctx, &store.FindMemo{ID: &memo.ID}) + require.NoError(t, getErr) + require.NotNil(t, got, memo.UID) + } for _, attachment := range []*store.Attachment{ownerAttachment, peerAttachmentOnDeletedMemo} { got, getErr := ts.GetAttachment(ctx, &store.FindAttachment{ID: &attachment.ID}) @@ -211,7 +215,7 @@ func TestDeleteUserCleansRelatedData(t *testing.T) { deletedMemoRelations, err := ts.ListMemoRelations(ctx, &store.FindMemoRelation{MemoIDList: []int32{ownMemo.ID, peerCommentOnOwnMemo.ID, userCommentOnPeerMemo.ID}}) require.NoError(t, err) - require.Empty(t, deletedMemoRelations) + require.Empty(t, deletedMemoRelations, "relations incident to deleted memos must be removed without deleting the other endpoint") keptReactions, err := ts.ListReactions(ctx, &store.FindReaction{MemoID: &peerMemo.ID}) require.NoError(t, err) @@ -231,6 +235,9 @@ func TestDeleteUserCleansRelatedData(t *testing.T) { deletedReceivedInboxes, err := ts.ListInboxes(ctx, &store.FindInbox{ReceiverID: &user.ID}) require.NoError(t, err) require.Empty(t, deletedReceivedInboxes) + referencedInboxes, err := ts.ListInboxes(ctx, &store.FindInbox{ID: &referencingDeletedMemoInbox.ID}) + require.NoError(t, err) + require.Len(t, referencedInboxes, 1, "deleting a referenced memo must not control another user's inbox lifecycle") keptInboxes, err := ts.ListInboxes(ctx, &store.FindInbox{ID: &inboxToKeep.ID}) require.NoError(t, err) require.Len(t, keptInboxes, 1) diff --git a/store/user.go b/store/user.go index 335796c4..6324d43a 100644 --- a/store/user.go +++ b/store/user.go @@ -2,11 +2,16 @@ package store import ( "context" + stderrors "errors" "strconv" "github.com/pkg/errors" ) +// ErrUserHasSpaceMembership blocks account deletion until its Space lifecycle +// has been resolved explicitly. +var ErrUserHasSpaceMembership = stderrors.New("user still has space memberships") + // Role is the type of a role. type Role string @@ -168,6 +173,8 @@ func (s *Store) GetUser(ctx context.Context, find *FindUser) (*User, error) { return user, nil } +// DeleteUser removes a user and returns cache invalidation state. Deleting an +// already-missing user is idempotent and returns an empty result. func (s *Store) DeleteUser(ctx context.Context, delete *DeleteUser) (*DeleteUserResult, error) { result, err := s.driver.DeleteUser(ctx, delete) if err != nil { diff --git a/web/src/components/MemoEditor/services/memoService.ts b/web/src/components/MemoEditor/services/memoService.ts index 02b47c32..2a9815d8 100644 --- a/web/src/components/MemoEditor/services/memoService.ts +++ b/web/src/components/MemoEditor/services/memoService.ts @@ -1,6 +1,7 @@ import { create } from "@bufbuild/protobuf"; import { FieldMaskSchema, timestampDate, timestampFromDate } from "@bufbuild/protobuf/wkt"; import { isEqual } from "lodash-es"; +import { getEditorReferenceRelations } from "@/components/MemoMetadata/Relation/relationHelpers"; import { memoServiceClient } from "@/connect"; import type { Attachment } from "@/types/proto/api/v1/attachment_service_pb"; import { AttachmentSchema } from "@/types/proto/api/v1/attachment_service_pb"; @@ -40,9 +41,11 @@ function buildUpdateMask( mask.add("attachments"); patch.attachments = toAttachmentReferences(allAttachments); } - if (!isEqual(state.metadata.relations, prevMemo.relations)) { + const previousReferenceRelations = getEditorReferenceRelations(prevMemo.relations, prevMemo.name); + const nextReferenceRelations = getEditorReferenceRelations(state.metadata.relations, prevMemo.name); + if (!isEqual(nextReferenceRelations, previousReferenceRelations)) { mask.add("relations"); - patch.relations = state.metadata.relations; + patch.relations = nextReferenceRelations; } if (!isEqual(state.metadata.location, prevMemo.location)) { mask.add("location"); diff --git a/web/src/hooks/useLiveMemoRefresh.ts b/web/src/hooks/useLiveMemoRefresh.ts index c3e09696..1656437b 100644 --- a/web/src/hooks/useLiveMemoRefresh.ts +++ b/web/src/hooks/useLiveMemoRefresh.ts @@ -17,14 +17,7 @@ const HIDDEN_DISCONNECT_DELAY_MS = 30_000; const SSE_CONNECTION_LOCK_NAME = "memos-sse-connection"; const SSE_SYNC_CHANNEL_NAME = "memos-sse-sync"; -const SSE_EVENT_TYPES = { - memoCreated: "memo.created", - memoUpdated: "memo.updated", - memoDeleted: "memo.deleted", - memoCommentCreated: "memo.comment.created", - reactionUpserted: "reaction.upserted", - reactionDeleted: "reaction.deleted", -} as const; +const SSE_EVENT_TYPE = "memo.changed" as const; // --------------------------------------------------------------------------- // Shared connection status store (singleton) @@ -62,9 +55,7 @@ export function useSSEConnectionStatus(): SSEConnectionStatus { } interface SSEChangeEvent { - type: (typeof SSE_EVENT_TYPES)[keyof typeof SSE_EVENT_TYPES]; - name: string; - parent?: string; + type: typeof SSE_EVENT_TYPE; } type SSESyncMessage = @@ -78,8 +69,7 @@ type SSESyncMessage = /** * useLiveMemoRefresh connects to the server's SSE endpoint and - * invalidates relevant React Query caches when change events - * (memos, reactions) are received. + * invalidates memo-backed React Query caches when a change event is received. * * This enables real-time updates across all open instances of the app. */ @@ -161,8 +151,7 @@ export function useLiveMemoRefresh() { if (hasConnectedOnceRef.current) { // Resync active collaborative views after reconnect because the server may have // dropped events while the client was disconnected or backpressured. - queryClient.invalidateQueries({ queryKey: memoKeys.all, refetchType: "active" }); - queryClient.invalidateQueries({ queryKey: userKeys.stats(), refetchType: "active" }); + invalidateLiveMemoQueries(queryClient); } hasConnectedOnceRef.current = true; @@ -286,8 +275,7 @@ export function useLiveMemoRefresh() { } if (message.status === "connected") { if (hasConnectedOnceRef.current) { - queryClient.invalidateQueries({ queryKey: memoKeys.all, refetchType: "active" }); - queryClient.invalidateQueries({ queryKey: userKeys.stats(), refetchType: "active" }); + invalidateLiveMemoQueries(queryClient); } hasConnectedOnceRef.current = true; } @@ -469,38 +457,13 @@ async function consumeSSEStream(body: ReadableStream, signal: AbortS } function handleSSEEvent(event: SSEChangeEvent, queryClient: ReturnType) { - switch (event.type) { - case SSE_EVENT_TYPES.memoCreated: - queryClient.invalidateQueries({ queryKey: memoKeys.lists() }); - queryClient.invalidateQueries({ queryKey: userKeys.stats() }); - break; - - case SSE_EVENT_TYPES.memoUpdated: - queryClient.invalidateQueries({ queryKey: memoKeys.detail(event.name) }); - queryClient.invalidateQueries({ queryKey: memoKeys.lists() }); - if (event.parent) { - queryClient.invalidateQueries({ queryKey: memoKeys.comments(event.parent) }); - } - break; - - case SSE_EVENT_TYPES.memoDeleted: - queryClient.removeQueries({ queryKey: memoKeys.detail(event.name) }); - queryClient.invalidateQueries({ queryKey: memoKeys.lists() }); - queryClient.invalidateQueries({ queryKey: userKeys.stats() }); - break; - - case SSE_EVENT_TYPES.memoCommentCreated: - queryClient.invalidateQueries({ queryKey: memoKeys.comments(event.name) }); - queryClient.invalidateQueries({ queryKey: memoKeys.detail(event.name) }); - break; - - case SSE_EVENT_TYPES.reactionUpserted: - case SSE_EVENT_TYPES.reactionDeleted: - queryClient.invalidateQueries({ queryKey: memoKeys.detail(event.name) }); - queryClient.invalidateQueries({ queryKey: memoKeys.lists() }); - if (event.parent) { - queryClient.invalidateQueries({ queryKey: memoKeys.comments(event.parent) }); - } - break; + if (event.type !== SSE_EVENT_TYPE) { + return; } + invalidateLiveMemoQueries(queryClient); +} + +function invalidateLiveMemoQueries(queryClient: ReturnType) { + queryClient.invalidateQueries({ queryKey: memoKeys.all, refetchType: "active" }); + queryClient.invalidateQueries({ queryKey: userKeys.stats(), refetchType: "active" }); } diff --git a/web/src/types/proto/api/v1/memo_service_pb.ts b/web/src/types/proto/api/v1/memo_service_pb.ts index 6c2af688..0dc45738 100644 --- a/web/src/types/proto/api/v1/memo_service_pb.ts +++ b/web/src/types/proto/api/v1/memo_service_pb.ts @@ -20,7 +20,7 @@ import type { Message } from "@bufbuild/protobuf"; * Describes the file api/v1/memo_service.proto. */ export const file_api_v1_memo_service: GenFile = /*@__PURE__*/ - fileDesc("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", [file_api_v1_attachment_service, file_api_v1_common, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp]); + fileDesc("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", [file_api_v1_attachment_service, file_api_v1_common, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp]); /** * Reaction is a reaction attached to a memo. @@ -118,8 +118,9 @@ export type Memo = Message<"memos.api.v1.Memo"> & { /** * The visibility of the memo. - * One of PRIVATE (creator only), PROTECTED (signed-in users), or - * PUBLIC (anyone). Defaults to PRIVATE on creation when unspecified. + * One of PRIVATE (creator only), PROTECTED (signed-in users), PUBLIC + * (anonymous-eligible), or SPACE (active space members). Defaults to + * PRIVATE on creation when unspecified. * * @generated from field: memos.api.v1.Visibility visibility = 9; */ @@ -168,7 +169,8 @@ export type Memo = Message<"memos.api.v1.Memo"> & { property?: Memo_Property | undefined; /** - * Output only. The name of the parent memo. + * Output only. The readable context memo of this COMMENT relation, if any. + * This is omitted unless the caller may independently read both memos. * Format: memos/{memo} * * @generated from field: optional string parent = 16; @@ -188,6 +190,14 @@ export type Memo = Message<"memos.api.v1.Memo"> & { * @generated from field: optional memos.api.v1.Location location = 18; */ location?: Location | undefined; + + /** + * Optional. The space in which this memo is placed. Format: spaces/{space}. + * Every memo, including a comment, owns its placement independently. + * + * @generated from field: optional string space = 19; + */ + space?: string | undefined; }; /** @@ -347,7 +357,7 @@ export type ListMemosRequest = Message<"memos.api.v1.ListMemosRequest"> & { * Available fields: * content (string), creator (string, e.g. "users/1"), * created_ts / updated_ts (timestamp), pinned (bool), - * visibility (string: PRIVATE | PROTECTED | PUBLIC), + * visibility (string: PRIVATE | PROTECTED | PUBLIC | SPACE), * tags (list; match with `"work" in tags`, not `tag == "work"`), * has_task_list / has_link / has_code / has_incomplete_tasks (bool), * has_location (bool; true when the memo has a location attached). @@ -368,6 +378,28 @@ export type ListMemosRequest = Message<"memos.api.v1.ListMemosRequest"> & { * @generated from field: bool show_deleted = 6; */ showDeleted: boolean; + + /** + * @generated from oneof memos.api.v1.ListMemosRequest.scope + */ + scope: { + /** + * Optional. Limit results to readable non-comment memos in a space of + * which the caller is an active member. + * + * @generated from field: string space = 7; + */ + value: string; + case: "space"; + } | { + /** + * Optional. Limit results to memos with no space. Must be true when set. + * + * @generated from field: bool unassigned = 8; + */ + value: boolean; + case: "unassigned"; + } | { case: undefined; value?: undefined }; }; /** @@ -666,7 +698,7 @@ export type SetMemoRelationsRequest = Message<"memos.api.v1.SetMemoRelationsRequ name: string; /** - * Required. The relations to set for the memo. + * Required. The REFERENCE relations to set for the memo. COMMENT is invalid. * * @generated from field: repeated memos.api.v1.MemoRelation relations = 2; */ @@ -1213,11 +1245,19 @@ export enum Visibility { PROTECTED = 2, /** - * PUBLIC: anyone, including anonymous visitors, can read the memo. + * PUBLIC: signed-in users can read the memo; anonymous visitors can read it + * when instance policy permits. * * @generated from enum value: PUBLIC = 3; */ PUBLIC = 3, + + /** + * SPACE: active members of the memo's space can read it. + * + * @generated from enum value: SPACE = 4; + */ + SPACE = 4, } /** @@ -1232,7 +1272,8 @@ export const VisibilitySchema: GenEnum = /*@__PURE__*/ export const MemoService: GenService<{ /** * CreateMemo creates a memo. The request body is a Memo; set its content - * (Markdown) and visibility (PRIVATE | PROTECTED | PUBLIC, default PRIVATE). + * (Markdown) and visibility (PRIVATE | PROTECTED | PUBLIC | SPACE, + * default PRIVATE). * The memo is owned by the authenticated user; requires authentication. * * @generated from rpc memos.api.v1.MemoService.CreateMemo @@ -1243,7 +1284,7 @@ export const MemoService: GenService<{ output: typeof MemoSchema; }, /** - * ListMemos lists memos with pagination and filter. + * ListMemos lists readable non-comment memos with pagination and filter. * * @generated from rpc memos.api.v1.MemoService.ListMemos */ @@ -1273,7 +1314,8 @@ export const MemoService: GenService<{ output: typeof MemoSchema; }, /** - * DeleteMemo deletes a memo. + * DeleteMemo deletes only the named memo and its owned resources. It removes + * incident relations but never deletes another memo. * * @generated from rpc memos.api.v1.MemoService.DeleteMemo */ @@ -1305,9 +1347,9 @@ export const MemoService: GenService<{ output: typeof ListMemoAttachmentsResponseSchema; }, /** - * SetMemoRelations replaces the full set of relations on a memo with the - * provided list (not an append). Pass the complete desired set; an empty list - * clears all relations. Idempotent. + * SetMemoRelations replaces the full set of mutable REFERENCE relations on a + * memo. COMMENT relations are immutable creation context and are rejected by + * this RPC. An empty list clears references without changing COMMENT. * * @generated from rpc memos.api.v1.MemoService.SetMemoRelations */ @@ -1327,7 +1369,9 @@ export const MemoService: GenService<{ output: typeof ListMemoRelationsResponseSchema; }, /** - * CreateMemoComment creates a comment for a memo. + * CreateMemoComment atomically creates an independent memo plus one immutable + * COMMENT context relation to the named memo. The new memo keeps its own + * placement, visibility, authorship, and lifecycle. * * @generated from rpc memos.api.v1.MemoService.CreateMemoComment */ diff --git a/web/src/types/proto/api/v1/space_service_pb.ts b/web/src/types/proto/api/v1/space_service_pb.ts new file mode 100644 index 00000000..867f0667 --- /dev/null +++ b/web/src/types/proto/api/v1/space_service_pb.ts @@ -0,0 +1,511 @@ +// @generated by protoc-gen-es v2.12.1 with parameter "target=ts" +// @generated from file api/v1/space_service.proto (package memos.api.v1, syntax proto3) +/* eslint-disable */ + +import type { GenEnum, GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv2"; +import { enumDesc, fileDesc, messageDesc, serviceDesc } from "@bufbuild/protobuf/codegenv2"; +import { file_google_api_annotations } from "../../google/api/annotations_pb"; +import { file_google_api_client } from "../../google/api/client_pb"; +import { file_google_api_field_behavior } from "../../google/api/field_behavior_pb"; +import { file_google_api_resource } from "../../google/api/resource_pb"; +import type { EmptySchema, FieldMask } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_empty, file_google_protobuf_field_mask } from "@bufbuild/protobuf/wkt"; +import type { Message } from "@bufbuild/protobuf"; + +/** + * Describes the file api/v1/space_service.proto. + */ +export const file_api_v1_space_service: GenFile = /*@__PURE__*/ + fileDesc("ChphcGkvdjEvc3BhY2Vfc2VydmljZS5wcm90bxIMbWVtb3MuYXBpLnYxIoYBCgVTcGFjZRIRCgRuYW1lGAEgASgJQgPgQQgSEgoFdGl0bGUYAiABKAlCA+BBAhIYCgtkZXNjcmlwdGlvbhgDIAEoCUID4EEBOjzqQTkKEm1lbW9zLmFwaS52MS9TcGFjZRIOc3BhY2VzL3tzcGFjZX0aBG5hbWUqBnNwYWNlczIFc3BhY2UikAIKC1NwYWNlTWVtYmVyEhEKBG5hbWUYASABKAlCA+BBCBInCgR1c2VyGAIgASgJQhngQQL6QRMKEW1lbW9zLmFwaS52MS9Vc2VyEjEKBHJvbGUYAyABKA4yHi5tZW1vcy5hcGkudjEuU3BhY2VNZW1iZXIuUm9sZUID4EECIjEKBFJvbGUSFAoQUk9MRV9VTlNQRUNJRklFRBAAEgkKBUFETUlOEAESCAoEVVNFUhACOl/qQVwKGG1lbW9zLmFwaS52MS9TcGFjZU1lbWJlchIfc3BhY2VzL3tzcGFjZX0vbWVtYmVycy97bWVtYmVyfRoEbmFtZSoMc3BhY2VNZW1iZXJzMgtzcGFjZU1lbWJlciJUChJDcmVhdGVTcGFjZVJlcXVlc3QSJwoFc3BhY2UYASABKAsyEy5tZW1vcy5hcGkudjEuU3BhY2VCA+BBAhIVCghzcGFjZV9pZBgCIAEoCUID4EEBIkQKEUxpc3RTcGFjZXNSZXF1ZXN0EhYKCXBhZ2Vfc2l6ZRgBIAEoBUID4EEBEhcKCnBhZ2VfdG9rZW4YAiABKAlCA+BBASJSChJMaXN0U3BhY2VzUmVzcG9uc2USIwoGc3BhY2VzGAEgAygLMhMubWVtb3MuYXBpLnYxLlNwYWNlEhcKD25leHRfcGFnZV90b2tlbhgCIAEoCSI7Cg9HZXRTcGFjZVJlcXVlc3QSKAoEbmFtZRgBIAEoCUIa4EEC+kEUChJtZW1vcy5hcGkudjEvU3BhY2UicwoSVXBkYXRlU3BhY2VSZXF1ZXN0EicKBXNwYWNlGAEgASgLMhMubWVtb3MuYXBpLnYxLlNwYWNlQgPgQQISNAoLdXBkYXRlX21hc2sYAiABKAsyGi5nb29nbGUucHJvdG9idWYuRmllbGRNYXNrQgPgQQIiPgoSRGVsZXRlU3BhY2VSZXF1ZXN0EigKBG5hbWUYASABKAlCGuBBAvpBFAoSbWVtb3MuYXBpLnYxL1NwYWNlIoIBChhDcmVhdGVTcGFjZU1lbWJlclJlcXVlc3QSMAoGcGFyZW50GAEgASgJQiDgQQL6QRoSGG1lbW9zLmFwaS52MS9TcGFjZU1lbWJlchI0CgxzcGFjZV9tZW1iZXIYAiABKAsyGS5tZW1vcy5hcGkudjEuU3BhY2VNZW1iZXJCA+BBAiJ8ChdMaXN0U3BhY2VNZW1iZXJzUmVxdWVzdBIwCgZwYXJlbnQYASABKAlCIOBBAvpBGhIYbWVtb3MuYXBpLnYxL1NwYWNlTWVtYmVyEhYKCXBhZ2Vfc2l6ZRgCIAEoBUID4EEBEhcKCnBhZ2VfdG9rZW4YAyABKAlCA+BBASJlChhMaXN0U3BhY2VNZW1iZXJzUmVzcG9uc2USMAoNc3BhY2VfbWVtYmVycxgBIAMoCzIZLm1lbW9zLmFwaS52MS5TcGFjZU1lbWJlchIXCg9uZXh0X3BhZ2VfdG9rZW4YAiABKAkiRwoVR2V0U3BhY2VNZW1iZXJSZXF1ZXN0Ei4KBG5hbWUYASABKAlCIOBBAvpBGgoYbWVtb3MuYXBpLnYxL1NwYWNlTWVtYmVyIoYBChhVcGRhdGVTcGFjZU1lbWJlclJlcXVlc3QSNAoMc3BhY2VfbWVtYmVyGAEgASgLMhkubWVtb3MuYXBpLnYxLlNwYWNlTWVtYmVyQgPgQQISNAoLdXBkYXRlX21hc2sYAiABKAsyGi5nb29nbGUucHJvdG9idWYuRmllbGRNYXNrQgPgQQIiSgoYRGVsZXRlU3BhY2VNZW1iZXJSZXF1ZXN0Ei4KBG5hbWUYASABKAlCIOBBAvpBGgoYbWVtb3MuYXBpLnYxL1NwYWNlTWVtYmVyMtAKCgxTcGFjZVNlcnZpY2USawoLQ3JlYXRlU3BhY2USIC5tZW1vcy5hcGkudjEuQ3JlYXRlU3BhY2VSZXF1ZXN0GhMubWVtb3MuYXBpLnYxLlNwYWNlIiXaQQVzcGFjZYLT5JMCFzoFc3BhY2UiDi9hcGkvdjEvc3BhY2VzEmoKCkxpc3RTcGFjZXMSHy5tZW1vcy5hcGkudjEuTGlzdFNwYWNlc1JlcXVlc3QaIC5tZW1vcy5hcGkudjEuTGlzdFNwYWNlc1Jlc3BvbnNlIhnaQQCC0+STAhASDi9hcGkvdjEvc3BhY2VzEmYKCEdldFNwYWNlEh0ubWVtb3MuYXBpLnYxLkdldFNwYWNlUmVxdWVzdBoTLm1lbW9zLmFwaS52MS5TcGFjZSIm2kEEbmFtZYLT5JMCGRIXL2FwaS92MS97bmFtZT1zcGFjZXMvKn0ShgEKC1VwZGF0ZVNwYWNlEiAubWVtb3MuYXBpLnYxLlVwZGF0ZVNwYWNlUmVxdWVzdBoTLm1lbW9zLmFwaS52MS5TcGFjZSJA2kERc3BhY2UsdXBkYXRlX21hc2uC0+STAiY6BXNwYWNlMh0vYXBpL3YxL3tzcGFjZS5uYW1lPXNwYWNlcy8qfRJvCgtEZWxldGVTcGFjZRIgLm1lbW9zLmFwaS52MS5EZWxldGVTcGFjZVJlcXVlc3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHkiJtpBBG5hbWWC0+STAhkqFy9hcGkvdjEve25hbWU9c3BhY2VzLyp9EqUBChFDcmVhdGVTcGFjZU1lbWJlchImLm1lbW9zLmFwaS52MS5DcmVhdGVTcGFjZU1lbWJlclJlcXVlc3QaGS5tZW1vcy5hcGkudjEuU3BhY2VNZW1iZXIiTdpBE3BhcmVudCxzcGFjZV9tZW1iZXKC0+STAjE6DHNwYWNlX21lbWJlciIhL2FwaS92MS97cGFyZW50PXNwYWNlcy8qfS9tZW1iZXJzEpUBChBMaXN0U3BhY2VNZW1iZXJzEiUubWVtb3MuYXBpLnYxLkxpc3RTcGFjZU1lbWJlcnNSZXF1ZXN0GiYubWVtb3MuYXBpLnYxLkxpc3RTcGFjZU1lbWJlcnNSZXNwb25zZSIy2kEGcGFyZW50gtPkkwIjEiEvYXBpL3YxL3twYXJlbnQ9c3BhY2VzLyp9L21lbWJlcnMSggEKDkdldFNwYWNlTWVtYmVyEiMubWVtb3MuYXBpLnYxLkdldFNwYWNlTWVtYmVyUmVxdWVzdBoZLm1lbW9zLmFwaS52MS5TcGFjZU1lbWJlciIw2kEEbmFtZYLT5JMCIxIhL2FwaS92MS97bmFtZT1zcGFjZXMvKi9tZW1iZXJzLyp9ErcBChFVcGRhdGVTcGFjZU1lbWJlchImLm1lbW9zLmFwaS52MS5VcGRhdGVTcGFjZU1lbWJlclJlcXVlc3QaGS5tZW1vcy5hcGkudjEuU3BhY2VNZW1iZXIiX9pBGHNwYWNlX21lbWJlcix1cGRhdGVfbWFza4LT5JMCPjoMc3BhY2VfbWVtYmVyMi4vYXBpL3YxL3tzcGFjZV9tZW1iZXIubmFtZT1zcGFjZXMvKi9tZW1iZXJzLyp9EoUBChFEZWxldGVTcGFjZU1lbWJlchImLm1lbW9zLmFwaS52MS5EZWxldGVTcGFjZU1lbWJlclJlcXVlc3QaFi5nb29nbGUucHJvdG9idWYuRW1wdHkiMNpBBG5hbWWC0+STAiMqIS9hcGkvdjEve25hbWU9c3BhY2VzLyovbWVtYmVycy8qfUKpAQoQY29tLm1lbW9zLmFwaS52MUIRU3BhY2VTZXJ2aWNlUHJvdG9QAVowZ2l0aHViLmNvbS91c2VtZW1vcy9tZW1vcy9wcm90by9nZW4vYXBpL3YxO2FwaXYxogIDTUFYqgIMTWVtb3MuQXBpLlYxygIMTWVtb3NcQXBpXFYx4gIYTWVtb3NcQXBpXFYxXEdQQk1ldGFkYXRh6gIOTWVtb3M6OkFwaTo6VjFiBnByb3RvMw", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask]); + +/** + * Space is a collaboration boundary for placed memos. + * + * @generated from message memos.api.v1.Space + */ +export type Space = Message<"memos.api.v1.Space"> & { + /** + * The resource name of the space. Format: spaces/{space}. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * Required. The human-readable title. + * + * @generated from field: string title = 2; + */ + title: string; + + /** + * Optional. A description of the space. + * + * @generated from field: string description = 3; + */ + description: string; +}; + +/** + * Describes the message memos.api.v1.Space. + * Use `create(SpaceSchema)` to create a new message. + */ +export const SpaceSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_api_v1_space_service, 0); + +/** + * SpaceMember is a user's membership and governance role in a space. + * + * @generated from message memos.api.v1.SpaceMember + */ +export type SpaceMember = Message<"memos.api.v1.SpaceMember"> & { + /** + * The resource name. Format: spaces/{space}/members/{username}. + * + * @generated from field: string name = 1; + */ + name: string; + + /** + * Required. The member user. Format: users/{username}. + * + * @generated from field: string user = 2; + */ + user: string; + + /** + * Required. The member's role within this space. + * + * @generated from field: memos.api.v1.SpaceMember.Role role = 3; + */ + role: SpaceMember_Role; +}; + +/** + * Describes the message memos.api.v1.SpaceMember. + * Use `create(SpaceMemberSchema)` to create a new message. + */ +export const SpaceMemberSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_api_v1_space_service, 1); + +/** + * @generated from enum memos.api.v1.SpaceMember.Role + */ +export enum SpaceMember_Role { + /** + * @generated from enum value: ROLE_UNSPECIFIED = 0; + */ + ROLE_UNSPECIFIED = 0, + + /** + * @generated from enum value: ADMIN = 1; + */ + ADMIN = 1, + + /** + * @generated from enum value: USER = 2; + */ + USER = 2, +} + +/** + * Describes the enum memos.api.v1.SpaceMember.Role. + */ +export const SpaceMember_RoleSchema: GenEnum = /*@__PURE__*/ + enumDesc(file_api_v1_space_service, 1, 0); + +/** + * @generated from message memos.api.v1.CreateSpaceRequest + */ +export type CreateSpaceRequest = Message<"memos.api.v1.CreateSpaceRequest"> & { + /** + * Required. The space to create. + * + * @generated from field: memos.api.v1.Space space = 1; + */ + space?: Space | undefined; + + /** + * Optional. The resource ID to use. If empty, one is generated. + * + * @generated from field: string space_id = 2; + */ + spaceId: string; +}; + +/** + * Describes the message memos.api.v1.CreateSpaceRequest. + * Use `create(CreateSpaceRequestSchema)` to create a new message. + */ +export const CreateSpaceRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_api_v1_space_service, 2); + +/** + * @generated from message memos.api.v1.ListSpacesRequest + */ +export type ListSpacesRequest = Message<"memos.api.v1.ListSpacesRequest"> & { + /** + * Optional. The maximum number of spaces to return. + * + * @generated from field: int32 page_size = 1; + */ + pageSize: number; + + /** + * Optional. A token from a previous ListSpaces response. + * + * @generated from field: string page_token = 2; + */ + pageToken: string; +}; + +/** + * Describes the message memos.api.v1.ListSpacesRequest. + * Use `create(ListSpacesRequestSchema)` to create a new message. + */ +export const ListSpacesRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_api_v1_space_service, 3); + +/** + * @generated from message memos.api.v1.ListSpacesResponse + */ +export type ListSpacesResponse = Message<"memos.api.v1.ListSpacesResponse"> & { + /** + * @generated from field: repeated memos.api.v1.Space spaces = 1; + */ + spaces: Space[]; + + /** + * @generated from field: string next_page_token = 2; + */ + nextPageToken: string; +}; + +/** + * Describes the message memos.api.v1.ListSpacesResponse. + * Use `create(ListSpacesResponseSchema)` to create a new message. + */ +export const ListSpacesResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_api_v1_space_service, 4); + +/** + * @generated from message memos.api.v1.GetSpaceRequest + */ +export type GetSpaceRequest = Message<"memos.api.v1.GetSpaceRequest"> & { + /** + * Required. The resource name of the space. + * + * @generated from field: string name = 1; + */ + name: string; +}; + +/** + * Describes the message memos.api.v1.GetSpaceRequest. + * Use `create(GetSpaceRequestSchema)` to create a new message. + */ +export const GetSpaceRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_api_v1_space_service, 5); + +/** + * @generated from message memos.api.v1.UpdateSpaceRequest + */ +export type UpdateSpaceRequest = Message<"memos.api.v1.UpdateSpaceRequest"> & { + /** + * Required. The space with updated values. + * + * @generated from field: memos.api.v1.Space space = 1; + */ + space?: Space | undefined; + + /** + * Required. The fields to update: title or description. + * + * @generated from field: google.protobuf.FieldMask update_mask = 2; + */ + updateMask?: FieldMask | undefined; +}; + +/** + * Describes the message memos.api.v1.UpdateSpaceRequest. + * Use `create(UpdateSpaceRequestSchema)` to create a new message. + */ +export const UpdateSpaceRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_api_v1_space_service, 6); + +/** + * @generated from message memos.api.v1.DeleteSpaceRequest + */ +export type DeleteSpaceRequest = Message<"memos.api.v1.DeleteSpaceRequest"> & { + /** + * Required. The resource name of the space. + * + * @generated from field: string name = 1; + */ + name: string; +}; + +/** + * Describes the message memos.api.v1.DeleteSpaceRequest. + * Use `create(DeleteSpaceRequestSchema)` to create a new message. + */ +export const DeleteSpaceRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_api_v1_space_service, 7); + +/** + * @generated from message memos.api.v1.CreateSpaceMemberRequest + */ +export type CreateSpaceMemberRequest = Message<"memos.api.v1.CreateSpaceMemberRequest"> & { + /** + * Required. The parent space. Format: spaces/{space}. + * + * @generated from field: string parent = 1; + */ + parent: string; + + /** + * Required. The membership to create. + * + * @generated from field: memos.api.v1.SpaceMember space_member = 2; + */ + spaceMember?: SpaceMember | undefined; +}; + +/** + * Describes the message memos.api.v1.CreateSpaceMemberRequest. + * Use `create(CreateSpaceMemberRequestSchema)` to create a new message. + */ +export const CreateSpaceMemberRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_api_v1_space_service, 8); + +/** + * @generated from message memos.api.v1.ListSpaceMembersRequest + */ +export type ListSpaceMembersRequest = Message<"memos.api.v1.ListSpaceMembersRequest"> & { + /** + * Required. The parent space. Format: spaces/{space}. + * + * @generated from field: string parent = 1; + */ + parent: string; + + /** + * Optional. The maximum number of members to return. + * + * @generated from field: int32 page_size = 2; + */ + pageSize: number; + + /** + * Optional. A token from a previous ListSpaceMembers response. + * + * @generated from field: string page_token = 3; + */ + pageToken: string; +}; + +/** + * Describes the message memos.api.v1.ListSpaceMembersRequest. + * Use `create(ListSpaceMembersRequestSchema)` to create a new message. + */ +export const ListSpaceMembersRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_api_v1_space_service, 9); + +/** + * @generated from message memos.api.v1.ListSpaceMembersResponse + */ +export type ListSpaceMembersResponse = Message<"memos.api.v1.ListSpaceMembersResponse"> & { + /** + * @generated from field: repeated memos.api.v1.SpaceMember space_members = 1; + */ + spaceMembers: SpaceMember[]; + + /** + * @generated from field: string next_page_token = 2; + */ + nextPageToken: string; +}; + +/** + * Describes the message memos.api.v1.ListSpaceMembersResponse. + * Use `create(ListSpaceMembersResponseSchema)` to create a new message. + */ +export const ListSpaceMembersResponseSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_api_v1_space_service, 10); + +/** + * @generated from message memos.api.v1.GetSpaceMemberRequest + */ +export type GetSpaceMemberRequest = Message<"memos.api.v1.GetSpaceMemberRequest"> & { + /** + * Required. Format: spaces/{space}/members/{username}. + * + * @generated from field: string name = 1; + */ + name: string; +}; + +/** + * Describes the message memos.api.v1.GetSpaceMemberRequest. + * Use `create(GetSpaceMemberRequestSchema)` to create a new message. + */ +export const GetSpaceMemberRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_api_v1_space_service, 11); + +/** + * @generated from message memos.api.v1.UpdateSpaceMemberRequest + */ +export type UpdateSpaceMemberRequest = Message<"memos.api.v1.UpdateSpaceMemberRequest"> & { + /** + * Required. The membership with the new role. + * + * @generated from field: memos.api.v1.SpaceMember space_member = 1; + */ + spaceMember?: SpaceMember | undefined; + + /** + * Required. Only role is supported. + * + * @generated from field: google.protobuf.FieldMask update_mask = 2; + */ + updateMask?: FieldMask | undefined; +}; + +/** + * Describes the message memos.api.v1.UpdateSpaceMemberRequest. + * Use `create(UpdateSpaceMemberRequestSchema)` to create a new message. + */ +export const UpdateSpaceMemberRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_api_v1_space_service, 12); + +/** + * @generated from message memos.api.v1.DeleteSpaceMemberRequest + */ +export type DeleteSpaceMemberRequest = Message<"memos.api.v1.DeleteSpaceMemberRequest"> & { + /** + * Required. Format: spaces/{space}/members/{username}. + * + * @generated from field: string name = 1; + */ + name: string; +}; + +/** + * Describes the message memos.api.v1.DeleteSpaceMemberRequest. + * Use `create(DeleteSpaceMemberRequestSchema)` to create a new message. + */ +export const DeleteSpaceMemberRequestSchema: GenMessage = /*@__PURE__*/ + messageDesc(file_api_v1_space_service, 13); + +/** + * SpaceService manages collaborative spaces and their memberships. + * + * @generated from service memos.api.v1.SpaceService + */ +export const SpaceService: GenService<{ + /** + * CreateSpace creates a space and makes the authenticated caller its first + * administrator. + * + * @generated from rpc memos.api.v1.SpaceService.CreateSpace + */ + createSpace: { + methodKind: "unary"; + input: typeof CreateSpaceRequestSchema; + output: typeof SpaceSchema; + }, + /** + * ListSpaces lists spaces of which the authenticated caller is a member. + * + * @generated from rpc memos.api.v1.SpaceService.ListSpaces + */ + listSpaces: { + methodKind: "unary"; + input: typeof ListSpacesRequestSchema; + output: typeof ListSpacesResponseSchema; + }, + /** + * GetSpace gets a space of which the authenticated caller is a member. + * + * @generated from rpc memos.api.v1.SpaceService.GetSpace + */ + getSpace: { + methodKind: "unary"; + input: typeof GetSpaceRequestSchema; + output: typeof SpaceSchema; + }, + /** + * UpdateSpace updates space metadata. + * + * @generated from rpc memos.api.v1.SpaceService.UpdateSpace + */ + updateSpace: { + methodKind: "unary"; + input: typeof UpdateSpaceRequestSchema; + output: typeof SpaceSchema; + }, + /** + * DeleteSpace permanently deletes a space and every memo currently placed + * in it. It never follows memo relations to other memos. + * + * @generated from rpc memos.api.v1.SpaceService.DeleteSpace + */ + deleteSpace: { + methodKind: "unary"; + input: typeof DeleteSpaceRequestSchema; + output: typeof EmptySchema; + }, + /** + * CreateSpaceMember directly adds an existing active user to a space. + * + * @generated from rpc memos.api.v1.SpaceService.CreateSpaceMember + */ + createSpaceMember: { + methodKind: "unary"; + input: typeof CreateSpaceMemberRequestSchema; + output: typeof SpaceMemberSchema; + }, + /** + * ListSpaceMembers lists the members of a space. + * + * @generated from rpc memos.api.v1.SpaceService.ListSpaceMembers + */ + listSpaceMembers: { + methodKind: "unary"; + input: typeof ListSpaceMembersRequestSchema; + output: typeof ListSpaceMembersResponseSchema; + }, + /** + * GetSpaceMember gets one membership in a space. + * + * @generated from rpc memos.api.v1.SpaceService.GetSpaceMember + */ + getSpaceMember: { + methodKind: "unary"; + input: typeof GetSpaceMemberRequestSchema; + output: typeof SpaceMemberSchema; + }, + /** + * UpdateSpaceMember changes a member's space role. + * + * @generated from rpc memos.api.v1.SpaceService.UpdateSpaceMember + */ + updateSpaceMember: { + methodKind: "unary"; + input: typeof UpdateSpaceMemberRequestSchema; + output: typeof SpaceMemberSchema; + }, + /** + * DeleteSpaceMember removes a member. A member may delete their own + * membership to leave the space. + * + * @generated from rpc memos.api.v1.SpaceService.DeleteSpaceMember + */ + deleteSpaceMember: { + methodKind: "unary"; + input: typeof DeleteSpaceMemberRequestSchema; + output: typeof EmptySchema; + }, +}> = /*@__PURE__*/ + serviceDesc(file_api_v1_space_service, 0); + diff --git a/web/tests/live-memo-refresh.test.tsx b/web/tests/live-memo-refresh.test.tsx index 194b2251..ea9cfbd0 100644 --- a/web/tests/live-memo-refresh.test.tsx +++ b/web/tests/live-memo-refresh.test.tsx @@ -20,9 +20,6 @@ vi.mock("@/contexts/AuthContext", () => ({ vi.mock("@/hooks/useMemoQueries", () => ({ memoKeys: { all: ["memos"], - lists: () => ["memos", "list"], - detail: (name: string) => ["memos", "detail", name], - comments: (name: string) => ["memos", "comments", name], }, })); @@ -225,12 +222,14 @@ describe("useLiveMemoRefresh", () => { await waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(1)); act(() => { - streamControllers[0].enqueue(new TextEncoder().encode('data: {"type":"memo.created","name":"memos/1"}\n\n')); + streamControllers[0].enqueue(new TextEncoder().encode('data: {"type":"memo.changed"}\n\n')); }); await waitFor(() => { - expect(firstInvalidate).toHaveBeenCalledWith({ queryKey: ["memos", "list"] }); - expect(secondInvalidate).toHaveBeenCalledWith({ queryKey: ["memos", "list"] }); + expect(firstInvalidate).toHaveBeenCalledWith({ queryKey: ["memos"], refetchType: "active" }); + expect(secondInvalidate).toHaveBeenCalledWith({ queryKey: ["memos"], refetchType: "active" }); + expect(firstInvalidate).toHaveBeenCalledWith({ queryKey: ["users", "stats"], refetchType: "active" }); + expect(secondInvalidate).toHaveBeenCalledWith({ queryKey: ["users", "stats"], refetchType: "active" }); }); first.unmount(); diff --git a/web/tests/memo-editor-relations.test.ts b/web/tests/memo-editor-relations.test.ts new file mode 100644 index 00000000..4de36a26 --- /dev/null +++ b/web/tests/memo-editor-relations.test.ts @@ -0,0 +1,100 @@ +import { create } from "@bufbuild/protobuf"; +import { beforeEach, describe, expect, it, vi } from "vitest"; +import { memoService } from "@/components/MemoEditor/services/memoService"; +import { createInitialState, type EditorState } from "@/components/MemoEditor/state"; +import { + type Memo, + MemoRelation_MemoSchema, + MemoRelation_Type, + MemoRelationSchema, + MemoSchema, +} from "@/types/proto/api/v1/memo_service_pb"; + +const clients = vi.hoisted(() => ({ + getMemo: vi.fn(), + updateMemo: vi.fn(), +})); + +vi.mock("@/connect", () => ({ + attachmentServiceClient: { + createAttachment: vi.fn(), + }, + memoServiceClient: { + createMemo: vi.fn(), + createMemoComment: vi.fn(), + getMemo: clients.getMemo, + updateMemo: clients.updateMemo, + }, +})); + +const createRelation = (type: MemoRelation_Type, memoName: string, relatedMemoName: string) => + create(MemoRelationSchema, { + type, + memo: create(MemoRelation_MemoSchema, { name: memoName }), + relatedMemo: create(MemoRelation_MemoSchema, { name: relatedMemoName }), + }); + +const createReference = (relatedMemoName: string) => + create(MemoRelationSchema, { + type: MemoRelation_Type.REFERENCE, + relatedMemo: create(MemoRelation_MemoSchema, { name: relatedMemoName }), + }); + +const createEditorState = (memo: Memo): EditorState => ({ + ...createInitialState(), + ...memoService.fromMemo(memo), +}); + +describe("memo editor relation updates", () => { + beforeEach(() => { + clients.updateMemo.mockImplementation(async ({ memo }: { memo: Memo }) => memo); + }); + + it("sends only mutable references when editing a comment", async () => { + const commentName = "memos/comment"; + const parentRelation = createRelation(MemoRelation_Type.COMMENT, commentName, "memos/parent"); + const existingReference = createRelation(MemoRelation_Type.REFERENCE, commentName, "memos/existing-reference"); + const incomingReference = createRelation(MemoRelation_Type.REFERENCE, "memos/referencing-comment", commentName); + const comment = create(MemoSchema, { + name: commentName, + content: "Comment", + relations: [parentRelation, existingReference, incomingReference], + }); + const addedReference = createReference("memos/added-reference"); + const state = createEditorState(comment); + state.metadata.relations = [...state.metadata.relations, addedReference]; + clients.getMemo.mockResolvedValue(comment); + + await memoService.save(state, { memoName: commentName }); + + expect(clients.updateMemo).toHaveBeenCalledOnce(); + const request = clients.updateMemo.mock.calls[0][0]; + expect(request.updateMask.paths).toContain("relations"); + expect(request.memo.relations).toEqual([existingReference, addedReference]); + expect(request.memo.relations.every((relation: { type: MemoRelation_Type }) => relation.type === MemoRelation_Type.REFERENCE)).toBe( + true, + ); + }); + + it("ignores a new incoming comment when comparing a parent memo's relations", async () => { + const parentName = "memos/parent"; + const outgoingReference = createRelation(MemoRelation_Type.REFERENCE, parentName, "memos/reference"); + const editorMemo = create(MemoSchema, { + name: parentName, + content: "Parent", + relations: [outgoingReference], + }); + const freshMemo = create(MemoSchema, { + name: parentName, + content: editorMemo.content, + relations: [outgoingReference, createRelation(MemoRelation_Type.COMMENT, "memos/new-comment", parentName)], + }); + const state = createEditorState(editorMemo); + clients.getMemo.mockResolvedValue(freshMemo); + + const result = await memoService.save(state, { memoName: parentName }); + + expect(result).toEqual({ memoName: parentName, hasChanges: false }); + expect(clients.updateMemo).not.toHaveBeenCalled(); + }); +});