Skip to content

armgit / memos

Public Imported from GitHub
0

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.

fix(editor): preserve memo timestamp edits when closing popover

johnnyjoygh0716eaac2c07
diff --git a/server/router/api/v1/memo_service.go b/server/router/api/v1/memo_service.go
index 4475f213d..7f222575c 100644
--- a/server/router/api/v1/memo_service.go
+++ b/server/router/api/v1/memo_service.go
@@ -406,6 +406,9 @@ func (s *APIV1Service) UpdateMemo(ctx context.Context, request *v1pb.UpdateMemoR
} else if path == "update_time" {
updatedTsSec := time.Now().Unix()
if request.Memo.UpdateTime != nil {
+ if !request.Memo.UpdateTime.IsValid() {
+ return nil, status.Errorf(codes.InvalidArgument, "update_time is invalid")
+ }
updatedTsSec = request.Memo.UpdateTime.AsTime().Unix()
}
update.UpdatedTs = &updatedTsSec
diff --git a/server/router/api/v1/test/memo_timestamp_test.go b/server/router/api/v1/test/memo_timestamp_test.go
new file mode 100644
index 000000000..fc057db75
--- /dev/null
+++ b/server/router/api/v1/test/memo_timestamp_test.go
@@ -0,0 +1,123 @@
+package test
+
+import (
+ "context"
+ "testing"
+ "time"
+
+ "github.com/stretchr/testify/require"
+ "google.golang.org/grpc/codes"
+ "google.golang.org/grpc/status"
+ "google.golang.org/protobuf/types/known/fieldmaskpb"
+ "google.golang.org/protobuf/types/known/timestamppb"
+
+ apiv1 "github.com/usememos/memos/proto/gen/api/v1"
+ "github.com/usememos/memos/store"
+)
+
+func TestUpdateMemoTimestamps(t *testing.T) {
+ ctx := context.Background()
+ ts := NewTestService(t)
+ defer ts.Cleanup()
+ user, err := ts.CreateRegularUser(ctx, "timestamp-owner")
+ require.NoError(t, err)
+ userCtx := ts.CreateUserContext(ctx, user.ID)
+ originalCreate := int64(1577836800)
+ originalUpdate := originalCreate + 3600
+ customCreate := originalCreate - 86400
+ customUpdate := originalUpdate - 86400
+
+ for _, tc := range []struct {
+ name string
+ paths []string
+ patch *apiv1.Memo
+ wantCreate int64
+ wantUpdate int64
+ autoUpdate bool
+ }{
+ {"creation only", []string{"create_time"}, &apiv1.Memo{CreateTime: &timestamppb.Timestamp{Seconds: customCreate}}, customCreate, originalUpdate, false},
+ {"modification only", []string{"update_time"}, &apiv1.Memo{UpdateTime: &timestamppb.Timestamp{Seconds: customUpdate}}, originalCreate, customUpdate, false},
+ {"both", []string{"create_time", "update_time"}, &apiv1.Memo{CreateTime: &timestamppb.Timestamp{Seconds: customCreate}, UpdateTime: &timestamppb.Timestamp{Seconds: customUpdate}}, customCreate, customUpdate, false},
+ {"with content", []string{"content", "create_time", "update_time"}, &apiv1.Memo{Content: "changed", CreateTime: &timestamppb.Timestamp{Seconds: customCreate}, UpdateTime: &timestamppb.Timestamp{Seconds: customUpdate}}, customCreate, customUpdate, false},
+ {"automatic modification", []string{"content", "update_time"}, &apiv1.Memo{Content: "changed"}, originalCreate, 0, true},
+ {"unmasked timestamps ignored", []string{"content"}, &apiv1.Memo{Content: "changed", CreateTime: &timestamppb.Timestamp{Seconds: customCreate}, UpdateTime: &timestamppb.Timestamp{Seconds: customUpdate}}, originalCreate, originalUpdate, false},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ memo, err := ts.Service.CreateMemo(userCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{
+ Content: "original", Visibility: apiv1.Visibility_PRIVATE,
+ CreateTime: &timestamppb.Timestamp{Seconds: originalCreate}, UpdateTime: &timestamppb.Timestamp{Seconds: originalUpdate},
+ }})
+ require.NoError(t, err)
+ tc.patch.Name = memo.Name
+ before := time.Now().Unix()
+ updated, err := ts.Service.UpdateMemo(userCtx, &apiv1.UpdateMemoRequest{
+ Memo: tc.patch, UpdateMask: &fieldmaskpb.FieldMask{Paths: tc.paths},
+ })
+ require.NoError(t, err)
+ require.Equal(t, tc.wantCreate, updated.CreateTime.Seconds)
+ if tc.autoUpdate {
+ require.GreaterOrEqual(t, updated.UpdateTime.Seconds, before)
+ require.LessOrEqual(t, updated.UpdateTime.Seconds, time.Now().Unix())
+ } else {
+ require.Equal(t, tc.wantUpdate, updated.UpdateTime.Seconds)
+ }
+ // Verify both API reads and raw stored values, not just the update response.
+ fetched, err := ts.Service.GetMemo(userCtx, &apiv1.GetMemoRequest{Name: memo.Name})
+ require.NoError(t, err)
+ require.Equal(t, updated.CreateTime, fetched.CreateTime)
+ require.Equal(t, updated.UpdateTime, fetched.UpdateTime)
+ id := parseMemoIDFromNameForTest(t, ts, memo.Name)
+ stored, err := ts.Store.GetMemo(ctx, &store.FindMemo{ID: &id})
+ require.NoError(t, err)
+ require.Equal(t, updated.CreateTime.Seconds, stored.CreatedTs)
+ require.Equal(t, updated.UpdateTime.Seconds, stored.UpdatedTs)
+ wantContent := "original"
+ if tc.patch.Content != "" {
+ wantContent = tc.patch.Content
+ }
+ require.Equal(t, wantContent, stored.Content)
+ })
+ }
+}
+
+func TestUpdateMemoRejectsInvalidTimestamps(t *testing.T) {
+ ctx := context.Background()
+ ts := NewTestService(t)
+ defer ts.Cleanup()
+ user, err := ts.CreateRegularUser(ctx, "invalid-timestamp-owner")
+ require.NoError(t, err)
+ userCtx := ts.CreateUserContext(ctx, user.ID)
+ memo, err := ts.Service.CreateMemo(userCtx, &apiv1.CreateMemoRequest{Memo: &apiv1.Memo{
+ Content: "original", Visibility: apiv1.Visibility_PRIVATE,
+ }})
+ require.NoError(t, err)
+ for _, path := range []string{"create_time", "update_time"} {
+ for _, timestamp := range []*timestamppb.Timestamp{
+ {Seconds: 253402300800},
+ {Nanos: -1},
+ {Nanos: 1000000000},
+ nil,
+ } {
+ if path == "update_time" && timestamp == nil {
+ continue // An omitted update_time explicitly requests the current time.
+ }
+ t.Run(path+"/"+timestamp.String(), func(t *testing.T) {
+ patch := &apiv1.Memo{Name: memo.Name, Content: "must not persist"}
+ if path == "create_time" {
+ patch.CreateTime = timestamp
+ } else {
+ patch.UpdateTime = timestamp
+ }
+ _, err := ts.Service.UpdateMemo(userCtx, &apiv1.UpdateMemoRequest{
+ Memo: patch, UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"content", path}},
+ })
+ require.Equal(t, codes.InvalidArgument, status.Code(err))
+ fetched, err := ts.Service.GetMemo(userCtx, &apiv1.GetMemoRequest{Name: memo.Name})
+ require.NoError(t, err)
+ require.Equal(t, memo.Content, fetched.Content)
+ require.Equal(t, memo.CreateTime, fetched.CreateTime)
+ require.Equal(t, memo.UpdateTime, fetched.UpdateTime)
+ })
+ }
+ }
+}
diff --git a/store/test/memo_timestamp_test.go b/store/test/memo_timestamp_test.go
new file mode 100644
index 000000000..fc428f883
--- /dev/null
+++ b/store/test/memo_timestamp_test.go
@@ -0,0 +1,51 @@
+package test
+
+import (
+ "context"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/usememos/memos/store"
+)
+
+func TestMemoTimestampUpdates(t *testing.T) {
+ t.Parallel()
+ ctx := context.Background()
+ ts := NewTestingStore(ctx, t)
+ defer ts.Close()
+ user, err := createTestingHostUser(ctx, ts)
+ require.NoError(t, err)
+ originalCreate, originalUpdate := int64(1577836800), int64(1577840400)
+ created, updated := originalCreate-86400, originalUpdate-86400
+
+ for _, tc := range []struct {
+ name string
+ patch *store.UpdateMemo
+ wantCreate int64
+ wantUpdate int64
+ }{
+ {"creation-only", &store.UpdateMemo{CreatedTs: &created}, created, originalUpdate},
+ {"modification-only", &store.UpdateMemo{UpdatedTs: &updated}, originalCreate, updated},
+ {"both", &store.UpdateMemo{CreatedTs: &created, UpdatedTs: &updated}, created, updated},
+ {"unrelated-update", &store.UpdateMemo{Content: new("changed")}, originalCreate, originalUpdate},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ memo, err := ts.CreateMemo(ctx, &store.Memo{
+ UID: tc.name, CreatorID: user.ID, Content: "original", Visibility: store.Private,
+ CreatedTs: originalCreate, UpdatedTs: originalUpdate,
+ })
+ require.NoError(t, err)
+ tc.patch.ID = memo.ID
+ require.NoError(t, ts.UpdateMemo(ctx, tc.patch))
+ got, err := ts.GetMemo(ctx, &store.FindMemo{ID: &memo.ID})
+ require.NoError(t, err)
+ require.NotNil(t, got)
+ require.Equal(t, tc.wantCreate, got.CreatedTs)
+ require.Equal(t, tc.wantUpdate, got.UpdatedTs)
+ if tc.patch.Content != nil {
+ require.Equal(t, *tc.patch.Content, got.Content)
+ }
+ })
+ }
+}
diff --git a/web/src/components/MemoEditor/components/TimestampPopover.tsx b/web/src/components/MemoEditor/components/TimestampPopover.tsx
index 02c3c1441..1b5420c3e 100644
--- a/web/src/components/MemoEditor/components/TimestampPopover.tsx
+++ b/web/src/components/MemoEditor/components/TimestampPopover.tsx
@@ -1,4 +1,4 @@
-import { type FC, useRef, useState } from "react";
+import { type FC, useId, useRef, useState } from "react";
import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
import { useTranslate } from "@/utils/i18n";
import { useEditorContext, useEditorSelector } from "../state";
@@ -12,9 +12,12 @@ function formatDate(date: Date): string {
function parseDate(value: string): Date | undefined {
const match = value.match(/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/);
- if (!match) return undefined;
- const date = new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]), Number(match[4]), Number(match[5]), Number(match[6]));
- return Number.isNaN(date.getTime()) ? undefined : date;
+ if (!match || Number(match[1]) === 0) return undefined;
+ const date = new Date(0);
+ date.setFullYear(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
+ date.setHours(Number(match[4]), Number(match[5]), Number(match[6]), 0);
+ // Date normalizes overflowing fields (e.g. February 30) instead of rejecting them.
+ return formatDate(date) === value ? date : undefined;
}
const TimestampInput: FC<{
@@ -22,34 +25,38 @@ const TimestampInput: FC<{
date: Date | undefined;
onChange: (date: Date) => void;
}> = ({ label, date, onChange }) => {
+ const id = useId();
const initialValue = useRef(date ? formatDate(date) : "");
const [value, setValue] = useState(initialValue.current);
const [invalid, setInvalid] = useState(false);
- const handleBlur = () => {
- const parsed = parseDate(value);
+ const handleChange = (nextValue: string) => {
+ setValue(nextValue);
+ const parsed = parseDate(nextValue);
+ setInvalid(false);
if (parsed) {
- setInvalid(false);
+ // Closing the popover can unmount the input without firing blur.
+ // Keep valid edits in the editor store as soon as they are entered.
onChange(parsed);
- } else {
- setInvalid(true);
}
};
return (
<div className="space-y-1">
- <label className="text-xs font-medium text-muted-foreground">
+ <label htmlFor={id} className="text-xs font-medium text-muted-foreground">
{label}
{value !== initialValue.current && <span className="text-primary ml-0.5">*</span>}
</label>
<input
+ id={id}
type="text"
className="block w-full rounded-md border border-border bg-background px-2 py-1 text-sm font-mono data-[invalid=true]:border-destructive"
data-invalid={invalid}
+ aria-invalid={invalid}
placeholder={DATETIME_FORMAT}
value={value}
- onChange={(e) => setValue(e.target.value)}
- onBlur={handleBlur}
+ onChange={(e) => handleChange(e.target.value)}
+ onBlur={() => setInvalid(!parseDate(value))}
/>
</div>
);
diff --git a/web/tests/memo-editor-timestamps.test.tsx b/web/tests/memo-editor-timestamps.test.tsx
new file mode 100644
index 000000000..6504cf1d7
--- /dev/null
+++ b/web/tests/memo-editor-timestamps.test.tsx
@@ -0,0 +1,104 @@
+import { create } from "@bufbuild/protobuf";
+import { timestampFromDate } from "@bufbuild/protobuf/wkt";
+import { act, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { TimestampPopover } from "@/components/MemoEditor/components/TimestampPopover";
+import { memoService } from "@/components/MemoEditor/services/memoService";
+import { createInitialState, EditorProvider, useEditorContext } from "@/components/MemoEditor/state";
+import { type Memo, MemoSchema } from "@/types/proto/api/v1/memo_service_pb";
+
+const clients = vi.hoisted(() => ({ getMemo: vi.fn(), updateMemo: vi.fn() }));
+vi.mock("@/connect", () => ({
+ attachmentServiceClient: { createAttachment: vi.fn() },
+ memoServiceClient: clients,
+}));
+vi.mock("@/utils/i18n", () => ({ useTranslate: () => (key: string) => key }));
+
+const originalCreate = new Date(2020, 0, 1, 10, 20, 30);
+const originalUpdate = new Date(2020, 0, 2, 11, 22, 33);
+const customTime = new Date(2024, 1, 29, 12, 34, 56);
+let editor: ReturnType<typeof useEditorContext>;
+
+function Probe() {
+ editor = useEditorContext();
+ return <TimestampPopover />;
+}
+
+function renderEditor() {
+ const memo = create(MemoSchema, {
+ name: "memos/timestamps",
+ content: "Original content",
+ createTime: timestampFromDate(originalCreate),
+ updateTime: timestampFromDate(originalUpdate),
+ });
+ clients.getMemo.mockResolvedValue(memo);
+ render(
+ <EditorProvider initialEditorState={{ ...createInitialState(), ...memoService.fromMemo(memo) }}>
+ <Probe />
+ </EditorProvider>,
+ );
+ fireEvent.click(screen.getByRole("button"));
+ return memo;
+}
+
+describe("memo editor timestamps", () => {
+ beforeEach(() => {
+ clients.updateMemo.mockImplementation(async ({ memo }: { memo: Memo }) => memo);
+ });
+
+ it.each([
+ [0, "createTime", "create_time"],
+ [1, "updateTime", "update_time"],
+ ] as const)("saves %s after dismissing the focused input with Escape", async (index, field, path) => {
+ const memo = renderEditor();
+ const input = screen.getAllByRole("textbox")[index];
+ act(() => input.focus());
+ fireEvent.change(input, { target: { value: "2024-02-29 12:34:56" } });
+ fireEvent.keyDown(input, { key: "Escape" });
+ await waitFor(() => expect(screen.queryByRole("textbox")).not.toBeInTheDocument());
+
+ await memoService.save(editor.getState(), { memoName: memo.name });
+
+ expect(clients.updateMemo).toHaveBeenCalledOnce();
+ const request = clients.updateMemo.mock.calls[0][0];
+ expect(request.updateMask.paths).toEqual([path]);
+ expect(request.memo[field]).toEqual(timestampFromDate(customTime));
+ });
+
+ it.each([
+ "2024-02-30 12:34:56",
+ "2024-13-01 12:34:56",
+ "2024-02-29 24:34:56",
+ "invalid",
+ ])("rejects invalid local time %s without changing the saved timestamp", async (value) => {
+ const memo = renderEditor();
+ const input = screen.getAllByRole("textbox")[0];
+ fireEvent.change(input, { target: { value } });
+ fireEvent.blur(input);
+ expect(input).toHaveAttribute("data-invalid", "true");
+ expect(editor.getState().timestamps.createTime).toEqual(originalCreate);
+ await memoService.save(editor.getState(), { memoName: memo.name });
+ expect(clients.updateMemo).not.toHaveBeenCalled();
+ });
+
+ it("automatically updates the modification time for content edits", async () => {
+ const memo = renderEditor();
+ const state = { ...editor.getState(), content: "Changed content" };
+ await memoService.save(state, { memoName: memo.name });
+ const request = clients.updateMemo.mock.calls[0][0];
+ expect(request.updateMask.paths).toEqual(["content", "update_time"]);
+ expect(request.memo.updateTime).toBeUndefined();
+ expect(request.memo.createTime).toBeUndefined();
+ });
+
+ it("keeps the explicitly chosen modification time when content also changes", async () => {
+ const memo = renderEditor();
+ const input = screen.getAllByRole("textbox")[1];
+ fireEvent.change(input, { target: { value: "2024-02-29 12:34:56" } });
+ // Saving must see the edit even if the input has not blurred yet.
+ await memoService.save({ ...editor.getState(), content: "Changed content" }, { memoName: memo.name });
+ const request = clients.updateMemo.mock.calls[0][0];
+ expect(request.updateMask.paths).toEqual(["content", "update_time"]);
+ expect(request.memo.updateTime).toEqual(timestampFromDate(customTime));
+ });
+});