Files
Tom MoorandClaude 9ea360995f feat: Optimistic model saves with rollback on failure (#14593)
* feat: Make model.save() optimistic with rollback on failure

Apply saved params to the model immediately so MobX observers update
without waiting for the server, and roll the model back to its previous
state when the request fails. New models with a client-generated id are
optimistically added to the store and removed again on failure.

* chore: Apply formatter and test naming convention

* fix: Scope optimistic saves to passed fields and confirmed values

Only fields passed to save() are applied optimistically, and a failure
reverts a field only while it still holds the optimistic value. Change
hooks compare against the last confirmed values so they run when the
server responds. The optimistic store add is removed.

* refactor: Use optimistic save for preferences and field toggles

Add savePreference to User, Team and Document, and pass changed fields to
save() so they revert on failure.

* fix: Only compare incoming fields against confirmed values in change hooks

---------

Co-authored-by: Claude <noreply@anthropic.com>
2026-11-15 09:26:55 -05:00

460 lines
12 KiB
TypeScript

import { differenceInMilliseconds } from "date-fns";
import { observer } from "mobx-react";
import { DoneIcon } from "outline-icons";
import { darken } from "polished";
import * as React from "react";
import { useTranslation } from "react-i18next";
import { toast } from "sonner";
import styled, { css } from "styled-components";
import { breakpoint } from "@shared/styles/breakpoint";
import EventBoundary from "@shared/components/EventBoundary";
import { s, hover } from "@shared/styles";
import type { ProsemirrorData } from "@shared/types";
import { dateToRelative } from "@shared/utils/date";
import { Minute } from "@shared/utils/time";
import type Comment from "~/models/Comment";
import { Avatar } from "~/components/Avatar";
import ButtonSmall from "~/components/ButtonSmall";
import Flex from "~/components/Flex";
import NudeButton from "~/components/NudeButton";
import ReactionList from "~/components/Reactions/ReactionList";
import ReactionPicker from "~/components/Reactions/ReactionPicker";
import { ResizingHeightContainer } from "~/components/ResizingHeightContainer";
import Text from "~/components/Text";
import Time from "~/components/Time";
import Tooltip from "~/components/Tooltip";
import { resolveCommentActionFactory } from "~/actions/definitions/comments";
import useBoolean from "~/hooks/useBoolean";
import useCurrentUser from "~/hooks/useCurrentUser";
import CommentMenu from "~/menus/CommentMenu";
import lazyWithRetry from "@shared/utils/lazyWithRetry";
const CommentEditor = lazyWithRetry(() => import("./CommentEditor"));
import { HighlightedText } from "./HighlightText";
import { useDocumentContext } from "~/components/DocumentContext";
/**
* Hook to calculate if we should display a timestamp on a comment
*
* @param createdAt The date the comment was created
* @param previousCreatedAt The date of the previous comment, if any
* @returns boolean if to show timestamp
*/
function useShowTime(
createdAt: string | undefined,
previousCreatedAt: string | undefined
): boolean {
if (!createdAt) {
return false;
}
const previousTimeStamp = previousCreatedAt
? dateToRelative(Date.parse(previousCreatedAt))
: undefined;
const currentTimeStamp = dateToRelative(Date.parse(createdAt));
const msSincePreviousComment = previousCreatedAt
? differenceInMilliseconds(
Date.parse(createdAt),
Date.parse(previousCreatedAt)
)
: 0;
return (
!msSincePreviousComment ||
(msSincePreviousComment > 15 * Minute.ms &&
previousTimeStamp !== currentTimeStamp)
);
}
type Props = {
/** The comment to render */
comment: Comment;
/** Whether this is the first comment in the thread */
firstOfThread?: boolean;
/** Whether this is the last comment in the thread */
lastOfThread?: boolean;
/** Whether this is the first consecutive comment by this author */
firstOfAuthor?: boolean;
/** Whether this is the last consecutive comment by this author */
lastOfAuthor?: boolean;
/** The date of the previous comment in the thread */
previousCommentCreatedAt?: string;
/** Whether the user can reply in the thread */
canReply: boolean;
/** Callback when the comment has been deleted */
onDelete?: (id: string) => void;
/** Callback when the comment has been updated */
onUpdate?: (id: string, attrs: { resolved: boolean }) => void;
/** Text to highlight at the top of the comment */
highlightedText?: string;
/** Whether to force the comment into edit mode */
forceEdit?: boolean;
/** Callback when edit mode starts */
onEditStart?: () => void;
/** Callback when edit mode ends */
onEditEnd?: () => void;
};
function CommentThreadItem({
comment,
firstOfAuthor,
firstOfThread,
lastOfThread,
previousCommentCreatedAt,
canReply,
onDelete,
onUpdate,
highlightedText,
forceEdit,
onEditStart,
onEditEnd,
}: Props) {
const { setFocusedCommentId } = useDocumentContext();
const { t } = useTranslation();
const user = useCurrentUser();
const [data, setData] = React.useState(comment.data);
const showAuthor = firstOfAuthor;
const showTime = useShowTime(comment.createdAt, previousCommentCreatedAt);
const showEdited =
comment.updatedAt &&
comment.updatedAt !== comment.createdAt &&
!comment.isResolved;
const [isEditing, setEditing, setReadOnly] = useBoolean();
// Handle forced edit mode
React.useEffect(() => {
if (forceEdit && !isEditing) {
setEditing();
onEditStart?.();
}
}, [forceEdit, isEditing, setEditing, onEditStart]);
// Override setReadOnly to call onEditEnd
const handleSetReadOnly = React.useCallback(() => {
setReadOnly();
onEditEnd?.();
}, [setReadOnly, onEditEnd]);
const formRef = React.useRef<HTMLFormElement>(null);
const handleAddReaction = React.useCallback(
async (emoji: string) => {
await comment.addReaction({ emoji, user });
},
[comment, user]
);
const handleRemoveReaction = React.useCallback(
async (emoji: string) => {
await comment.removeReaction({ emoji, user });
},
[comment, user]
);
const handleUpdate = React.useCallback(
(attrs: { resolved: boolean }) => {
onUpdate?.(comment.id, attrs);
if ("resolved" in attrs) {
setFocusedCommentId(null);
}
},
[comment.id, onUpdate, setFocusedCommentId]
);
const handleDelete = React.useCallback(() => {
onDelete?.(comment.id);
}, [comment.id, onDelete]);
const handleChange = React.useCallback(
(value: (asString: boolean) => ProsemirrorData) => {
setData(value(false));
},
[]
);
const handleSave = React.useCallback(() => {
formRef.current?.dispatchEvent(
new Event("submit", { cancelable: true, bubbles: true })
);
}, []);
const handleSubmit = async (event: React.FormEvent) => {
event.preventDefault();
try {
handleSetReadOnly();
await comment.save({ data });
} catch (_err) {
setEditing();
toast.error(t("Error updating comment"));
}
};
const handleCancel = () => {
setData(comment.data);
handleSetReadOnly();
};
return (
<Flex gap={8} align="flex-start">
{firstOfAuthor && (
<AvatarSpacer>
<Avatar model={comment.createdBy} size={24} />
</AvatarSpacer>
)}
<Bubble
$firstOfThread={firstOfThread}
$firstOfAuthor={firstOfAuthor}
$lastOfThread={lastOfThread}
$canReply={canReply}
column
>
{(showAuthor || showTime) && (
<Meta size="xsmall" type="secondary">
{showAuthor && <em>{comment.createdBy.name}</em>}
{showAuthor && showTime && <> &middot; </>}
{showTime && (
<Time dateTime={comment.createdAt} addSuffix shorten />
)}
{showEdited && (
<>
{" "}
(<Time dateTime={comment.updatedAt}>{t("edited")}</Time>)
</>
)}
</Meta>
)}
{highlightedText && (
<HighlightedText>{highlightedText}</HighlightedText>
)}
<Body ref={formRef} onSubmit={handleSubmit}>
<React.Suspense fallback={null}>
<StyledCommentEditor
key={String(isEditing)}
readOnly={!isEditing}
value={comment.data}
defaultValue={data}
onChange={handleChange}
onSave={handleSave}
onCancel={handleCancel}
autoFocus
/>
</React.Suspense>
{isEditing && (
<Flex align="flex-end" gap={8}>
<ButtonSmall type="submit" borderOnHover>
{t("Save")}
</ButtonSmall>
<ButtonSmall onClick={handleCancel} neutral borderOnHover>
{t("Cancel")}
</ButtonSmall>
</Flex>
)}
<ResizingHeightContainer hideOverflow>
{!!comment.reactions.length && (
<ReactionListContainer gap={6} align="center">
<ReactionList
model={comment}
onAddReaction={handleAddReaction}
onRemoveReaction={handleRemoveReaction}
picker={
!comment.isResolved ? (
<Action
as={ReactionPicker}
onSelect={handleAddReaction}
size={28}
$rounded
/>
) : undefined
}
/>
</ReactionListContainer>
)}
</ResizingHeightContainer>
</Body>
<EventBoundary>
{!isEditing && (
<Actions gap={4}>
{!comment.isResolved && (
<>
{firstOfThread && (
<ResolveButton onUpdate={handleUpdate} comment={comment} />
)}
<Action
as={ReactionPicker}
onSelect={handleAddReaction}
$rounded
/>
</>
)}
<Action
as={CommentMenu}
comment={comment}
onEdit={() => {
setEditing();
onEditStart?.();
}}
onDelete={handleDelete}
onUpdate={handleUpdate}
/>
</Actions>
)}
</EventBoundary>
</Bubble>
</Flex>
);
}
const ResolveButton = ({
comment,
onUpdate,
}: {
comment: Comment;
onUpdate: (attrs: { resolved: boolean }) => void;
}) => {
const { t } = useTranslation();
return (
<Tooltip content={t("Mark as resolved")}>
<Action
as={NudeButton}
action={resolveCommentActionFactory({
comment,
onResolve: () => onUpdate({ resolved: true }),
})}
$rounded
>
<DoneIcon size={22} outline />
</Action>
</Tooltip>
);
};
const StyledCommentEditor = styled(CommentEditor)`
${(props) =>
!props.readOnly &&
css`
box-shadow: 0 0 0 2px ${props.theme.accent};
border-radius: 2px;
padding: 2px;
margin: 2px;
margin-bottom: 8px;
`}
.mention {
background: ${(props) => darken(0.05, props.theme.mentionBackground)};
}
`;
const AvatarSpacer = styled(Flex)`
width: 24px;
height: 24px;
margin-top: 4px;
align-items: flex-end;
justify-content: flex-end;
flex-shrink: 0;
flex-direction: column;
`;
const Body = styled.form`
border-radius: 2px;
`;
const Action = styled.span<{ $rounded?: boolean }>`
color: ${s("textSecondary")};
${(props) =>
props.$rounded &&
css`
border-radius: 50%;
`}
svg {
fill: currentColor;
opacity: 0.5;
}
&[aria-expanded="true"],
&:${hover} {
background: ${s("backgroundQuaternary")};
svg {
opacity: 0.75;
}
}
`;
const Actions = styled(Flex)`
position: absolute;
inset-inline-end: 4px;
top: 4px;
transition: opacity 100ms ease-in-out;
background: ${s("backgroundSecondary")};
padding-inline-start: 4px;
${breakpoint("tablet")`
opacity: 0;
`}
&:has(${Action}[aria-expanded="true"]) {
opacity: 1;
}
`;
const ReactionListContainer = styled(Flex)`
padding-top: 6px;
`;
const Meta = styled(Text)`
margin-bottom: 2px;
em {
font-weight: 600;
font-style: normal;
}
`;
export const Bubble = styled(Flex)<{
$firstOfThread?: boolean;
$firstOfAuthor?: boolean;
$lastOfThread?: boolean;
$canReply?: boolean;
$focused?: boolean;
}>`
position: relative;
flex-grow: 1;
font-size: 16px;
color: ${s("text")};
background: ${s("backgroundSecondary")};
min-width: 2em;
margin-bottom: 1px;
padding: 8px 12px;
transition:
color 100ms ease-out,
background 100ms ease-out;
${({ $lastOfThread, $canReply }) =>
$lastOfThread &&
!$canReply &&
"border-end-start-radius: 8px; border-end-end-radius: 8px"};
${({ $firstOfThread }) =>
$firstOfThread &&
"border-start-start-radius: 8px; border-start-end-radius: 8px"};
margin-inline-start: ${(props) => (props.$firstOfAuthor ? 0 : 32)}px;
p:last-child {
margin-bottom: 0;
}
&: ${hover} ${Actions} {
opacity: 1;
}
${breakpoint("tablet")`
font-size: 15px;
`}
`;
export default observer(CommentThreadItem);