feat(spaces): add multi-space memo collaboration (#6228)

This commit is contained in:
amblued 2026-08-23 19:36:50 +08:00 committed by GitHub
parent fc6cbab7d0
commit 6da8461e1d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
187 changed files with 17393 additions and 2409 deletions

200
docs/design/multi-spaces.md Normal file
View file

@ -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.

View file

@ -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<string>; 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];
}

View file

@ -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"}
];
}

View file

@ -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

View file

@ -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)

View file

@ -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"))
}

View file

@ -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

View file

@ -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

View file

@ -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

View file

@ -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

View file

@ -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<string>; 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{

View file

@ -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)

View file

@ -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

View file

@ -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
}

View file

@ -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
)

View file

@ -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",
}

View file

@ -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

View file

@ -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<string>; 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

View file

@ -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

View file

@ -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

View file

@ -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

View file

@ -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

View file

@ -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}
}

View file

@ -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)
}

View file

@ -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")
}

View file

@ -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
}

View file

@ -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")
}

View file

@ -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": {},

View file

@ -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",

View file

@ -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: &currentTs,
UpdatedTs: &currentTsSec,
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)
}

View file

@ -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.

View file

@ -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:

View file

@ -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))
})
}
}

View file

@ -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},

View file

@ -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
}

View file

@ -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...)),

View file

@ -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

View file

@ -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) {

View file

@ -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) {

View file

@ -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",

View file

@ -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 = &currentUser.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
}

View file

@ -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
}

View file

@ -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
}

View file

@ -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)
}

View file

@ -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):
}
}

View file

@ -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
}

View file

@ -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:

View file

@ -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
}

View file

@ -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)
}

View file

@ -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)
}

View file

@ -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

View file

@ -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,

View file

@ -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()
}

View file

@ -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 {

View file

@ -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")))
})
}
}

View file

@ -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)

View file

@ -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)
}
}
}

View file

@ -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: &currentUser.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: &currentUser.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: &currentUser.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: &currentUser.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: &currentUser.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
}

View file

@ -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),
}
}

View file

@ -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))
}

View file

@ -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),
}
}

View file

@ -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
}

View file

@ -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
}
}

View file

@ -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)
})
}

View file

@ -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)
}

View file

@ -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")
}
}

View file

@ -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.

View file

@ -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) {

View file

@ -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) {

View file

@ -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)
})
}
}

View file

@ -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
}

View file

@ -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.

View file

@ -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)
}

View file

@ -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: &regularUser.ID})
require.NoError(t, err)
require.NotNil(t, remainingReaction)
})
t.Run("DeleteMemoReaction permission denied for non-owner", func(t *testing.T) {

View file

@ -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)

View file

@ -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) {

View file

@ -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")
}

View file

@ -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")
}

View file

@ -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: &currentTs,
UpdatedTs: &currentTsSec,
}
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",

View file

@ -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 {

View file

@ -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

View file

@ -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 = &currentUser.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{}

View file

@ -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
}

View file

@ -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))
}

View file

@ -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)

View file

@ -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

View file

@ -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))
}

View file

@ -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 {

View file

@ -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(), `<loc>https://demo.usememos.com/memos/publicmemo</loc>`)
require.NotContains(t, rec.Body.String(), "privatememo")
}

View file

@ -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))

View file

@ -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
}

View file

@ -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
}

113
store/attachment_delete.go Normal file
View file

@ -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
}

View file

@ -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
}

View file

@ -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
}

View file

@ -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 {

View file

@ -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
}

View file

@ -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
}

View file

@ -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
}

View file

@ -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
}

Some files were not shown because too many files have changed in this diff Show more