Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.
Go dockerfossgomarkdownmemomicroblognote-takingnotesopen-sourceown-your-datareactself-hostedsqlitetimeline
feat: show attachment storage usage in account settings (#6326)
ABirdba44a669116f
diff --git a/proto/api/v1/user_service.proto b/proto/api/v1/user_service.protoindex f6a929be7..b92018504 100644--- a/proto/api/v1/user_service.proto+++ b/proto/api/v1/user_service.proto@@ -424,6 +424,12 @@ message UserStats {// Total memo count.int32 total_memo_count = 6;+ // Total persisted attachment size in bytes, including unlinked uploads and+ // attachments in all spaces. Excludes temporary uploads and derived files.+ // Returned only by GetUserStats for the authenticated user's own stats,+ // independently of the request's memo filter.+ optional int64 attachment_storage_bytes = 9 [(google.api.field_behavior) = OUTPUT_ONLY];+// Memo type statistics.message MemoTypeStats {int32 link_count = 1;diff --git a/proto/gen/api/v1/user_service.pb.go b/proto/gen/api/v1/user_service.pb.goindex 8a082489a..83bda6a97 100644--- a/proto/gen/api/v1/user_service.pb.go+++ b/proto/gen/api/v1/user_service.pb.go@@ -915,8 +915,13 @@ type UserStats struct {PinnedMemos []string `protobuf:"bytes,5,rep,name=pinned_memos,json=pinnedMemos,proto3" json:"pinned_memos,omitempty"`// Total memo count.TotalMemoCount int32 `protobuf:"varint,6,opt,name=total_memo_count,json=totalMemoCount,proto3" json:"total_memo_count,omitempty"`- unknownFields protoimpl.UnknownFields- sizeCache protoimpl.SizeCache+ // Total persisted attachment size in bytes, including unlinked uploads and+ // attachments in all spaces. Excludes temporary uploads and derived files.+ // Returned only by GetUserStats for the authenticated user's own stats,+ // independently of the request's memo filter.+ AttachmentStorageBytes *int64 `protobuf:"varint,9,opt,name=attachment_storage_bytes,json=attachmentStorageBytes,proto3,oneof" json:"attachment_storage_bytes,omitempty"`+ unknownFields protoimpl.UnknownFields+ sizeCache protoimpl.SizeCache}func (x *UserStats) Reset() {@@ -998,6 +1003,13 @@ func (x *UserStats) GetTotalMemoCount() int32 {return 0}+func (x *UserStats) GetAttachmentStorageBytes() int64 {+ if x != nil && x.AttachmentStorageBytes != nil {+ return *x.AttachmentStorageBytes+ }+ return 0+}+type GetUserStatsRequest struct {state protoimpl.MessageState `protogen:"open.v1"`// Required. The resource name of the user.@@ -4032,7 +4044,7 @@ const file_api_v1_user_service_proto_rawDesc = "" +"\x11DeleteUserRequest\x12-\n" +"\x04name\x18\x01 \x01(\tB\x19\xe0A\x02\xfaA\x13\n" +"\x11memos.api.v1/UserR\x04name\x12\x19\n" +- "\x05force\x18\x02 \x01(\bB\x03\xe0A\x01R\x05force\"\xf5\x05\n" ++ "\x05force\x18\x02 \x01(\bB\x03\xe0A\x01R\x05force\"\xd6\x06\n" +"\tUserStats\x12\x17\n" +"\x04name\x18\x01 \x01(\tB\x03\xe0A\bR\x04name\x12M\n" +"\x0fmemo_type_stats\x18\x03 \x01(\v2%.memos.api.v1.UserStats.MemoTypeStatsR\rmemoTypeStats\x12B\n" +@@ -4041,7 +4053,8 @@ const file_api_v1_user_service_proto_rawDesc = "" +"\x17memo_updated_timestamps\x18\b \x03(\v2\x1a.google.protobuf.TimestampR\x15memoUpdatedTimestamps\x129\n" +"\fpinned_memos\x18\x05 \x03(\tB\x16\xfaA\x13\n" +"\x11memos.api.v1/MemoR\vpinnedMemos\x12(\n" +- "\x10total_memo_count\x18\x06 \x01(\x05R\x0etotalMemoCount\x1a;\n" ++ "\x10total_memo_count\x18\x06 \x01(\x05R\x0etotalMemoCount\x12B\n" ++ "\x18attachment_storage_bytes\x18\t \x01(\x03B\x03\xe0A\x03H\x00R\x16attachmentStorageBytes\x88\x01\x01\x1a;\n" +"\rTagCountEntry\x12\x10\n" +"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +"\x05value\x18\x02 \x01(\x05R\x05value:\x028\x01\x1a\x8b\x01\n" +@@ -4054,7 +4067,8 @@ const file_api_v1_user_service_proto_rawDesc = "" +"todo_count\x18\x03 \x01(\x05R\ttodoCount\x12\x1d\n" +"\n" +"undo_count\x18\x04 \x01(\x05R\tundoCount:E\xeaAB\n" +- "\x16memos.api.v1/UserStats\x12\x12users/{user}/stats*\tuserStats2\tuserStatsJ\x04\b\x02\x10\x03R\x17memo_display_timestamps\"z\n" ++ "\x16memos.api.v1/UserStats\x12\x12users/{user}/stats*\tuserStats2\tuserStatsB\x1b\n" ++ "\x19_attachment_storage_bytesJ\x04\b\x02\x10\x03R\x17memo_display_timestamps\"z\n" +"\x13GetUserStatsRequest\x12-\n" +"\x04name\x18\x01 \x01(\tB\x19\xe0A\x02\xfaA\x13\n" +"\x11memos.api.v1/UserR\x04name\x12\x1b\n" +@@ -4545,6 +4559,7 @@ func file_api_v1_user_service_proto_init() {}file_api_v1_common_proto_init()file_api_v1_space_service_proto_init()+ file_api_v1_user_service_proto_msgTypes[9].OneofWrappers = []any{}file_api_v1_user_service_proto_msgTypes[13].OneofWrappers = []any{(*UserSetting_GeneralSetting_)(nil),(*UserSetting_WebhooksSetting_)(nil),diff --git a/proto/gen/openapi.yaml b/proto/gen/openapi.yamlindex 1aad1ef4b..04e3621db 100644--- a/proto/gen/openapi.yaml+++ b/proto/gen/openapi.yaml@@ -5009,6 +5009,14 @@ components:type: integerdescription: Total memo count.format: int32+ attachmentStorageBytes:+ readOnly: true+ type: string+ description: |-+ Total persisted attachment size in bytes, including unlinked uploads and+ attachments in all spaces. Excludes temporary uploads and derived files.+ Returned only by GetUserStats for the authenticated user's own stats,+ independently of the request's memo filter.description: User statistics messagesUserStats_MemoTypeStats:type: objectdiff --git a/server/api/v1/test/user_service_stats_test.go b/server/api/v1/test/user_service_stats_test.goindex 5556a566a..92c85f704 100644--- a/server/api/v1/test/user_service_stats_test.go+++ b/server/api/v1/test/user_service_stats_test.go@@ -464,3 +464,43 @@ func TestUserStatsSpaceFilter(t *testing.T) {})require.Equal(t, codes.InvalidArgument, status.Code(err))}++func TestGetUserStats_AttachmentStorage(t *testing.T) {+ ts := NewTestService(t)+ defer ts.Cleanup()+ ctx := context.Background()+ owner, err := ts.CreateRegularUser(ctx, "storage_owner")+ require.NoError(t, err)+ other, err := ts.CreateRegularUser(ctx, "storage_other")+ require.NoError(t, err)+ ownerCtx := ts.CreateUserContext(ctx, owner.ID)+ request := &v1pb.GetUserStatsRequest{Name: "users/" + owner.Username}++ stats, err := ts.Service.GetUserStats(ownerCtx, request)+ require.NoError(t, err)+ require.NotNil(t, stats.AttachmentStorageBytes)+ require.Zero(t, *stats.AttachmentStorageBytes)++ attachment := createTestImageAttachment(ownerCtx, t, ts, "owner.png")+ createTestImageAttachment(ts.CreateUserContext(ctx, other.ID), t, ts, "other.png")++ // Memo filtering must not turn account storage into a partial total.+ stats, err = ts.Service.GetUserStats(ownerCtx, &v1pb.GetUserStatsRequest{Name: request.Name, Filter: `content.contains("no matches")`})+ require.NoError(t, err)+ require.Zero(t, stats.TotalMemoCount)+ require.NotNil(t, stats.AttachmentStorageBytes)+ require.Equal(t, attachment.Size, *stats.AttachmentStorageBytes)++ for _, viewerCtx := range []context.Context{ctx, ts.CreateUserContext(ctx, other.ID)} {+ stats, err = ts.Service.GetUserStats(viewerCtx, request)+ require.NoError(t, err)+ require.Nil(t, stats.AttachmentStorageBytes, "private storage totals must not appear in public user stats")+ }++ _, err = ts.Service.DeleteAttachment(ownerCtx, &v1pb.DeleteAttachmentRequest{Name: attachment.Name})+ require.NoError(t, err)+ stats, err = ts.Service.GetUserStats(ownerCtx, request)+ require.NoError(t, err)+ require.NotNil(t, stats.AttachmentStorageBytes)+ require.Zero(t, *stats.AttachmentStorageBytes)+}diff --git a/server/api/v1/user_service_stats.go b/server/api/v1/user_service_stats.goindex 45f11a58e..35bfc7061 100644--- a/server/api/v1/user_service_stats.go+++ b/server/api/v1/user_service_stats.go@@ -283,6 +283,14 @@ func (s *APIV1Service) GetUserStats(ctx context.Context, request *v1pb.GetUserSt},}+ if currentUser != nil && currentUser.ID == userID {+ size, err := s.Store.GetAttachmentStorageUsage(ctx, userID)+ if err != nil {+ return nil, status.Errorf(codes.Internal, "failed to get attachment storage usage: %v", err)+ }+ userStats.AttachmentStorageBytes = &size+ }+return userStats, nil}diff --git a/store/attachment.go b/store/attachment.goindex d70071e20..2fa922c59 100644--- a/store/attachment.go+++ b/store/attachment.go@@ -406,3 +406,8 @@ func shouldFailCreateAttachmentPostCommit(ctx context.Context) bool {failpoint, ok := ctx.Value(createAttachmentPostCommitFailpointKey{}).(bool)return ok && failpoint}++// GetAttachmentStorageUsage returns the total persisted attachment size for a creator in bytes.+func (s *Store) GetAttachmentStorageUsage(ctx context.Context, creatorID int32) (int64, error) {+ return s.driver.GetAttachmentStorageUsage(ctx, creatorID)+}diff --git a/store/db/mysql/attachment.go b/store/db/mysql/attachment.goindex d8f1c09d0..3da2bd606 100644--- a/store/db/mysql/attachment.go+++ b/store/db/mysql/attachment.go@@ -338,3 +338,12 @@ func listMySQLAttachmentsByIDs(ctx context.Context, tx *sql.Tx, attachmentIDs []}return attachments, nil}++// GetAttachmentStorageUsage returns the total persisted attachment size for a creator in bytes.+func (d *DB) GetAttachmentStorageUsage(ctx context.Context, creatorID int32) (int64, error) {+ var size int64+ if err := d.db.QueryRowContext(ctx, "SELECT COALESCE(SUM(size), 0) FROM attachment WHERE creator_id = ?", creatorID).Scan(&size); err != nil {+ return 0, errors.Wrap(err, "failed to sum attachment sizes")+ }+ return size, nil+}diff --git a/store/db/postgres/attachment.go b/store/db/postgres/attachment.goindex 330dfb305..4eb1ddd59 100644--- a/store/db/postgres/attachment.go+++ b/store/db/postgres/attachment.go@@ -315,3 +315,12 @@ func (d *DB) DeleteAttachments(ctx context.Context, deletes []*store.DeleteAttactx = nilreturn nil}++// GetAttachmentStorageUsage returns the total persisted attachment size for a creator in bytes.+func (d *DB) GetAttachmentStorageUsage(ctx context.Context, creatorID int32) (int64, error) {+ var size int64+ if err := d.db.QueryRowContext(ctx, "SELECT COALESCE(SUM(size), 0) FROM attachment WHERE creator_id = $1", creatorID).Scan(&size); err != nil {+ return 0, errors.Wrap(err, "failed to sum attachment sizes")+ }+ return size, nil+}diff --git a/store/db/sqlite/attachment.go b/store/db/sqlite/attachment.goindex 0cb7b2f98..23c2c371c 100644--- a/store/db/sqlite/attachment.go+++ b/store/db/sqlite/attachment.go@@ -300,3 +300,12 @@ func (d *DB) DeleteAttachments(ctx context.Context, deletes []*store.DeleteAttacreturn tx.Commit()}++// GetAttachmentStorageUsage returns the total persisted attachment size for a creator in bytes.+func (d *DB) GetAttachmentStorageUsage(ctx context.Context, creatorID int32) (int64, error) {+ var size int64+ if err := d.db.QueryRowContext(ctx, "SELECT COALESCE(SUM(size), 0) FROM attachment WHERE creator_id = ?", creatorID).Scan(&size); err != nil {+ return 0, errors.Wrap(err, "failed to sum attachment sizes")+ }+ return size, nil+}diff --git a/store/driver.go b/store/driver.goindex e7f7b5083..90a69fcbe 100644--- a/store/driver.go+++ b/store/driver.go@@ -21,6 +21,7 @@ type Driver interface {// Attachment model related methods.CreateAttachment(ctx context.Context, create *Attachment) (*Attachment, error)ListAttachments(ctx context.Context, find *FindAttachment) ([]*Attachment, error)+ GetAttachmentStorageUsage(ctx context.Context, creatorID int32) (int64, error)UpdateAttachment(ctx context.Context, update *UpdateAttachment) errorDeleteAttachment(ctx context.Context, delete *DeleteAttachment) errorDeleteAttachments(ctx context.Context, deletes []*DeleteAttachment) errordiff --git a/store/test/attachment_test.go b/store/test/attachment_test.goindex cde3f9158..22e46dbc3 100644--- a/store/test/attachment_test.go+++ b/store/test/attachment_test.go@@ -3,6 +3,7 @@ package testimport ("context""fmt"+ "math""sync""testing""time"@@ -701,3 +702,50 @@ func TestMemoMutationConcurrentUpdatesSameMemoNoSQLiteBusy(t *testing.T) {require.ErrorIs(t, err, store.ErrMemoMutationConflict)}}++func TestAttachmentStorageUsage(t *testing.T) {+ t.Parallel()+ ctx := context.Background()+ ts := NewTestingStore(ctx, t)+ creator, err := createTestingHostUser(ctx, ts)+ require.NoError(t, err)++ size, err := ts.GetAttachmentStorageUsage(ctx, creator.ID)+ require.NoError(t, err)+ require.Zero(t, size)++ // One row per storage type, with a total exceeding a signed 32-bit integer.+ var expected int64+ var first *store.Attachment+ for i, storageType := range []storepb.AttachmentStorageType{+ storepb.AttachmentStorageType_ATTACHMENT_STORAGE_TYPE_UNSPECIFIED,+ storepb.AttachmentStorageType_LOCAL,+ storepb.AttachmentStorageType_S3,+ } {+ attachment, err := ts.CreateAttachment(ctx, &store.Attachment{+ UID: shortuuid.New(), CreatorID: creator.ID, Filename: "file", Size: math.MaxInt32, StorageType: storageType,+ })+ require.NoError(t, err)+ expected += attachment.Size+ if i == 0 {+ first = attachment+ }+ }+ _, err = ts.CreateAttachment(ctx, &store.Attachment{UID: shortuuid.New(), CreatorID: 102, Filename: "other", Size: 123})+ require.NoError(t, err)+ size, err = ts.GetAttachmentStorageUsage(ctx, creator.ID)+ require.NoError(t, err)+ require.Equal(t, expected, size)++ memo, err := ts.CreateMemo(ctx, &store.Memo{UID: shortuuid.New(), CreatorID: creator.ID, Content: "memo", Visibility: store.Private})+ require.NoError(t, err)+ require.NoError(t, ts.UpdateAttachment(ctx, &store.UpdateAttachment{ID: first.ID, MemoID: &memo.ID}))+ size, err = ts.GetAttachmentStorageUsage(ctx, creator.ID)+ require.NoError(t, err)+ require.Equal(t, expected, size, "binding does not change storage usage")++ require.NoError(t, ts.DeleteAttachment(ctx, &store.DeleteAttachment{ID: first.ID}))+ size, err = ts.GetAttachmentStorageUsage(ctx, creator.ID)+ require.NoError(t, err)+ require.Equal(t, expected-first.Size, size)+}diff --git a/web/src/components/Settings/MyAccountSection.tsx b/web/src/components/Settings/MyAccountSection.tsxindex 5f93f0fb6..7369774f7 100644--- a/web/src/components/Settings/MyAccountSection.tsx+++ b/web/src/components/Settings/MyAccountSection.tsx@@ -17,6 +17,7 @@ import UserAvatar from "../UserAvatar";import LinkedIdentitySection from "./LinkedIdentitySection";import SettingGroup from "./SettingGroup";import SettingSection from "./SettingSection";+import UserStatsSection from "./UserStatsSection";const MyAccountSection = () => {const t = useTranslate();@@ -67,6 +68,8 @@ const MyAccountSection = () => {</div></SettingGroup>+ <UserStatsSection />+<LinkedIdentitySection /><SettingGroup showSeparator title={t("setting.account.danger-area")} description={t("setting.account.danger-area-description")}>diff --git a/web/src/components/Settings/ResourceStatsSection.tsx b/web/src/components/Settings/ResourceStatsSection.tsxindex 08308a5d9..21e659ce0 100644--- a/web/src/components/Settings/ResourceStatsSection.tsx+++ b/web/src/components/Settings/ResourceStatsSection.tsx@@ -4,7 +4,7 @@ import { Button } from "@/components/ui/button";import { instanceKeys, useInstanceStats } from "@/hooks/useInstanceQueries";import { useTranslate } from "@/utils/i18n";import SettingGroup from "./SettingGroup";-import { SettingList, SettingListItem, SettingPanel } from "./SettingList";+import { SettingList, SettingPanel, StatRow } from "./SettingList";import SettingSection from "./SettingSection";const formatBytes = (bytes: number | bigint): string => {@@ -32,16 +32,6 @@ const renderBytes = (value: bigint | number | undefined, unknown: string): strinreturn formatBytes(n);};-const StatValue = ({ value }: { value: string }) => (- <span className="block min-w-0 max-w-full break-all text-right font-mono text-sm tabular-nums text-foreground">{value}</span>-);--const StatRow = ({ label, value }: { label: string; value: string }) => (- <SettingListItem label={label} controlClassName="w-full justify-end sm:w-auto">- <StatValue value={value} />- </SettingListItem>-);-const ResourceStatsSection = () => {const t = useTranslate();const queryClient = useQueryClient();diff --git a/web/src/components/Settings/SettingList.tsx b/web/src/components/Settings/SettingList.tsxindex e6170a90e..a09dd3658 100644--- a/web/src/components/Settings/SettingList.tsx+++ b/web/src/components/Settings/SettingList.tsx@@ -48,6 +48,16 @@ export const SettingListItem = ({);};+export const StatValue = ({ value }: { value: string }) => (+ <span className="block min-w-0 max-w-full break-all text-right font-mono text-sm tabular-nums text-foreground">{value}</span>+);++export const StatRow = ({ label, value }: { label: string; value: string }) => (+ <SettingListItem label={label} controlClassName="w-full justify-end sm:w-auto">+ <StatValue value={value} />+ </SettingListItem>+);+interface SettingPanelProps {children: ReactNode;className?: string;diff --git a/web/src/components/Settings/UserStatsSection.tsx b/web/src/components/Settings/UserStatsSection.tsxnew file mode 100644index 000000000..524d89402--- /dev/null+++ b/web/src/components/Settings/UserStatsSection.tsx@@ -0,0 +1,31 @@+import useCurrentUser from "@/hooks/useCurrentUser";+import { useUserStats } from "@/hooks/useUserQueries";+import { formatFileSize } from "@/utils/format";+import { useTranslate } from "@/utils/i18n";+import SettingGroup from "./SettingGroup";+import { SettingList, StatRow } from "./SettingList";++const UserStatsSection = () => {+ const t = useTranslate();+ const user = useCurrentUser();+ const { data, isError } = useUserStats(user?.name);++ if (!user) return null;++ const storage = data?.attachmentStorageBytes;+ return (+ <SettingGroup showSeparator title={t("common.statistics")}>+ {isError ? (+ <p className="text-sm text-muted-foreground" role="status">+ {t("setting.account.storage-usage-error")}+ </p>+ ) : (+ <SettingList>+ <StatRow label={t("setting.account.attachment-storage")} value={storage === undefined ? "…" : formatFileSize(Number(storage))} />+ </SettingList>+ )}+ </SettingGroup>+ );+};++export default UserStatsSection;diff --git a/web/src/hooks/useAttachmentQueries.ts b/web/src/hooks/useAttachmentQueries.tsindex 756a6f4c2..ac07a5715 100644--- a/web/src/hooks/useAttachmentQueries.ts+++ b/web/src/hooks/useAttachmentQueries.ts@@ -1,8 +1,8 @@import { create } from "@bufbuild/protobuf";import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";import { attachmentServiceClient } from "@/connect";+import { userKeys } from "@/hooks/useUserQueries";import {- type Attachment,BatchDeleteAttachmentsRequestSchema,type ListAttachmentsRequest,ListAttachmentsRequestSchema,@@ -48,40 +48,6 @@ export function useInfiniteAttachments(request: Partial<ListAttachmentsRequest>});}-// Hook to create/upload attachment-export function useCreateAttachment() {- const queryClient = useQueryClient();-- return useMutation({- mutationFn: async (attachment: Attachment) => {- const result = await attachmentServiceClient.createAttachment({ attachment });- return result;- },- onSuccess: () => {- // Invalidate attachments list- queryClient.invalidateQueries({ queryKey: attachmentKeys.lists() });- },- });-}--// Hook to delete attachment-export function useDeleteAttachment() {- const queryClient = useQueryClient();-- return useMutation({- mutationFn: async (name: string) => {- await attachmentServiceClient.deleteAttachment({ name });- return name;- },- onSuccess: (name) => {- // Remove from cache- queryClient.removeQueries({ queryKey: attachmentKeys.detail(name) });- // Invalidate lists- queryClient.invalidateQueries({ queryKey: attachmentKeys.lists() });- },- });-}-export function useBatchDeleteAttachments() {const queryClient = useQueryClient();@@ -94,7 +60,12 @@ export function useBatchDeleteAttachments() {for (const name of names) {queryClient.removeQueries({ queryKey: attachmentKeys.detail(name) });}+ },+ // The server may have deleted rows even when it reports a storage cleanup+ // failure, so lists and storage usage refresh regardless of outcome.+ onSettled: () => {queryClient.invalidateQueries({ queryKey: attachmentKeys.lists() });+ queryClient.invalidateQueries({ queryKey: userKeys.stats() });},});}diff --git a/web/src/locales/az.json b/web/src/locales/az.jsonindex 9274366db..358afaf60 100644--- a/web/src/locales/az.json+++ b/web/src/locales/az.json@@ -614,6 +614,8 @@"web-clipper-title": "Memos Web Clipper ilə tokendən istifadə"},"account": {+ "attachment-storage": "Qoşmaların tutduğu yer",+ "storage-usage-error": "Qoşmalarınızın tutduğu yer haqqında məlumat əlçatan deyil.","change-password": "Parolu dəyiş","danger-area": "Təhlükəli sahə","danger-area-description": "Geri qaytarıla bilməyən hesab əməliyyatları buradadır. Davam etməzdən əvvəl onları diqqətlə nəzərdən keçirin.",diff --git a/web/src/locales/en.json b/web/src/locales/en.jsonindex dcde0a22d..db90e23dd 100644--- a/web/src/locales/en.json+++ b/web/src/locales/en.json@@ -614,6 +614,8 @@"web-clipper-title": "Use a token with Memos Web Clipper"},"account": {+ "attachment-storage": "Attachment storage",+ "storage-usage-error": "Your attachment storage is unavailable.","change-password": "Change password","danger-area": "Danger area","danger-area-description": "Irreversible account actions live here. Review them carefully before continuing.",diff --git a/web/src/locales/zh-Hans.json b/web/src/locales/zh-Hans.jsonindex 606cb5aab..13a083c58 100644--- a/web/src/locales/zh-Hans.json+++ b/web/src/locales/zh-Hans.json@@ -737,6 +737,8 @@"no-tokens-found": "未找到访问令牌"},"account": {+ "attachment-storage": "附件占用空间",+ "storage-usage-error": "暂时无法获取你的附件占用空间。","change-password": "修改密码","danger-area": "危险操作区","danger-area-description": "不可逆的账号操作统一放在这里,执行前请再次确认影响。",diff --git a/web/src/locales/zh-Hant.json b/web/src/locales/zh-Hant.jsonindex 85be86408..846fef544 100644--- a/web/src/locales/zh-Hant.json+++ b/web/src/locales/zh-Hant.json@@ -555,6 +555,8 @@"web-clipper-title": "搭配 Memos 網頁剪藏器使用令牌"},"account": {+ "attachment-storage": "附件佔用空間",+ "storage-usage-error": "暫時無法取得你的附件佔用空間。","change-password": "變更密碼","danger-area": "危險區域","danger-area-description": "此處為不可逆的帳號操作。請在繼續之前仔細檢閱。",diff --git a/web/src/types/proto/api/v1/user_service_pb.ts b/web/src/types/proto/api/v1/user_service_pb.tsindex 673b54d5b..20b358490 100644--- a/web/src/types/proto/api/v1/user_service_pb.ts+++ b/web/src/types/proto/api/v1/user_service_pb.ts@@ -22,7 +22,7 @@ import type { Message } from "@bufbuild/protobuf";* Describes the file api/v1/user_service.proto.*/export const file_api_v1_user_service: GenFile = /*@__PURE__*/- fileDesc("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", [file_api_v1_common, file_api_v1_space_service, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_google_type_color]);+ fileDesc("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", [file_api_v1_common, file_api_v1_space_service, file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_empty, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_google_type_color]);/*** @generated from message memos.api.v1.User@@ -444,6 +444,16 @@ export type UserStats = Message<"memos.api.v1.UserStats"> & {* @generated from field: int32 total_memo_count = 6;*/totalMemoCount: number;++ /**+ * Total persisted attachment size in bytes, including unlinked uploads and+ * attachments in all spaces. Excludes temporary uploads and derived files.+ * Returned only by GetUserStats for the authenticated user's own stats,+ * independently of the request's memo filter.+ *+ * @generated from field: optional int64 attachment_storage_bytes = 9;+ */+ attachmentStorageBytes?: bigint | undefined;};/**diff --git a/web/tests/attachment-storage-usage.test.tsx b/web/tests/attachment-storage-usage.test.tsxnew file mode 100644index 000000000..e19a8d82f--- /dev/null+++ b/web/tests/attachment-storage-usage.test.tsx@@ -0,0 +1,92 @@+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";+import { act, render, renderHook, screen, waitFor } from "@testing-library/react";+import type { PropsWithChildren } from "react";+import { beforeEach, describe, expect, it, vi } from "vitest";+import UserStatsSection from "@/components/Settings/UserStatsSection";+import { useBatchDeleteAttachments } from "@/hooks/useAttachmentQueries";+import { userKeys, useUserStats } from "@/hooks/useUserQueries";++const mocks = vi.hoisted(() => ({+ getUserStats: vi.fn(),+ batchDeleteAttachments: vi.fn(),+ user: { name: "users/alice" } as { name: string } | undefined,+}));++vi.mock("@/connect", () => ({ attachmentServiceClient: mocks, userServiceClient: mocks }));+vi.mock("@/hooks/useCurrentUser", () => ({ default: () => mocks.user }));+vi.mock("@/utils/i18n", () => ({+ useTranslate: () => (key: string) =>+ ({+ "common.statistics": "Statistics",+ "setting.account.attachment-storage": "Attachment storage",+ "setting.account.storage-usage-error": "Your attachment storage is unavailable.",+ })[key] ?? key,+}));++const setup = () => {+ const client = new QueryClient({ defaultOptions: { queries: { retry: false }, mutations: { retry: false } } });+ const wrapper = ({ children }: PropsWithChildren) => <QueryClientProvider client={client}>{children}</QueryClientProvider>;+ return { client, wrapper };+};++describe("account statistics", () => {+ beforeEach(() => {+ mocks.user = { name: "users/alice" };+ mocks.getUserStats.mockReset();+ mocks.batchDeleteAttachments.mockReset();+ });++ it("distinguishes loading, zero bytes, and a failed read", async () => {+ let resolve!: (value: { attachmentStorageBytes: bigint }) => void;+ mocks.getUserStats.mockReturnValueOnce(+ new Promise((done) => {+ resolve = done;+ }),+ );+ const { client, wrapper } = setup();+ render(<UserStatsSection />, { wrapper });+ expect(screen.getByRole("heading", { name: "Statistics" })).toBeInTheDocument();+ expect(screen.getByText("Attachment storage")).toBeInTheDocument();+ expect(screen.getByText("…")).toBeInTheDocument();+ await act(async () => resolve({ attachmentStorageBytes: 0n }));+ expect(await screen.findByText("0 B")).toBeInTheDocument();++ mocks.getUserStats.mockRejectedValue(new Error("offline"));+ await act(async () => {+ await client.invalidateQueries({ queryKey: userKeys.stats() });+ });+ expect(await screen.findByText("Your attachment storage is unavailable.")).toBeInTheDocument();+ expect(screen.queryByText("0 B")).not.toBeInTheDocument();+ });++ it("does not show another user's cached total after an account change", async () => {+ mocks.getUserStats.mockResolvedValueOnce({ attachmentStorageBytes: 1024n }).mockResolvedValueOnce({ attachmentStorageBytes: 2048n });+ const { wrapper } = setup();+ const { rerender } = render(<UserStatsSection />, { wrapper });+ expect(await screen.findByText("1.0 KB")).toBeInTheDocument();+ mocks.user = { name: "users/bob" };+ rerender(<UserStatsSection />);+ expect(screen.queryByText("1.0 KB")).not.toBeInTheDocument();+ expect(await screen.findByText("2.0 KB")).toBeInTheDocument();+ });++ it("refreshes usage even when deletion reports a storage cleanup failure", async () => {+ mocks.getUserStats.mockResolvedValueOnce({ attachmentStorageBytes: 1024n }).mockResolvedValue({ attachmentStorageBytes: 0n });+ mocks.batchDeleteAttachments.mockRejectedValue(new Error("attachments were deleted but storage cleanup failed"));+ const { wrapper } = setup();+ const { result } = renderHook(() => ({ stats: useUserStats("users/alice"), deletion: useBatchDeleteAttachments() }), { wrapper });+ await waitFor(() => expect(result.current.stats.data?.attachmentStorageBytes).toBe(1024n));+ await act(async () => {+ await result.current.deletion.mutateAsync(["attachments/file"]).catch(() => {});+ });+ await waitFor(() => expect(result.current.stats.data?.attachmentStorageBytes).toBe(0n));+ });++ it("does not request or display usage without a signed-in user", () => {+ mocks.user = undefined;+ const { wrapper } = setup();+ const { container } = render(<UserStatsSection />, { wrapper });+ expect(container).toBeEmptyDOMElement();+ expect(mocks.getUserStats).not.toHaveBeenCalled();+ });+});