fix: Keep Manual Unread Reminders in Date Groups

This commit is contained in:
Lia 2026-10-03 13:24:53 +00:00 • committed by Danny Avila
parent ad99250a35
commit c41413ad21
20 changed files with 209 additions and 14 deletions

View file

@ -175,6 +175,7 @@ class ImportBatchBuilder {
delete convo.lastResponseAt;
delete convo.lastResponseMessageId;
delete convo.lastResponseIsManual;
delete convo.isMarkedUnread;
delete convo.lastSeenAt;
this.conversations.push(convo);

View file

@ -249,8 +249,11 @@ describe('groupConversationsByStatus finished chats', () => {
]);
});
it('leaves a chat marked unread by hand in its date group', () => {
const manual = replied('manual', 1, { lastResponseIsManual: true });
it.each([
{ lastResponseIsManual: true },
{ isMarkedUnread: true, lastResponseMessageId: 'real-reply' },
])('leaves a chat marked unread by hand in its date group (%j)', (marker) => {
const manual = replied('manual', 1, marker);
const dated = groupConversations([manual], newestFirst);
expect(partitionGroups(dated, new Set(), newestFirst)).toBe(dated);

View file

@ -22,7 +22,11 @@ function showsStatusGroups(options: ConversationGroupOptions): boolean {
/** A reply that landed while the user was elsewhere. "Mark as unread" sets the same
* stamp as a reminder, not as a finished run, so that chat keeps its date. */
function isFinishedUnseen(conversation: TConversation): boolean {
return conversation.lastResponseIsManual !== true && isConversationUnseen(conversation);
return (
conversation.isMarkedUnread !== true &&
conversation.lastResponseIsManual !== true &&
isConversationUnseen(conversation)
);
}
function newestFirst(a: TConversation, b: TConversation): number {

View file

@ -44,6 +44,7 @@ export function areConversationListItemFieldsEqual(
holds, which means these have to be compared in their own right. */
prevConversation.lastResponseAt === nextConversation.lastResponseAt &&
prevConversation.lastResponseIsManual === nextConversation.lastResponseIsManual &&
prevConversation.isMarkedUnread === nextConversation.isMarkedUnread &&
prevConversation.lastSeenAt === nextConversation.lastSeenAt
);
}

View file

@ -444,6 +444,7 @@ describe('pinned list cache synchronization', () => {
isShared: true,
lastResponseAt: '2026-08-16T10:00:00.000Z',
lastResponseIsManual: true,
isMarkedUnread: true,
lastSeenAt: '2026-08-16T10:01:00.000Z',
} as TConversation);
@ -451,6 +452,7 @@ describe('pinned list cache synchronization', () => {
expect('isShared' in stripped).toBe(false);
expect('lastResponseAt' in stripped).toBe(false);
expect('lastResponseIsManual' in stripped).toBe(false);
expect('isMarkedUnread' in stripped).toBe(false);
expect('lastSeenAt' in stripped).toBe(false);
expect(stripped.conversationId).toBe(pinnedConversationId);
expect(stripped.title).toBe(pinnedConvo.title);

View file

@ -4,8 +4,12 @@ import { EModelEndpoint, QueryKeys } from 'librechat-data-provider';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import type { InfiniteData } from '@tanstack/react-query';
import type { ConversationCursorData } from '~/utils/convos';
import {
groupConversationsByStatus,
FINISHED_CHATS_GROUP,
} from '~/components/Conversations/running';
import { useMarkConversationSeenMutation, useMarkConversationUnreadMutation } from '../mutations';
import { isConversationUnseen, updateConvoInAllQueries } from '~/utils';
import { applyServerReplyStamp, isConversationUnseen, updateConvoInAllQueries } from '~/utils';
const mockMarkUnread = jest.fn();
const mockMarkSeen = jest.fn();
@ -73,6 +77,43 @@ describe('useMarkConversationUnreadMutation', () => {
mockMarkSeen.mockReset();
});
it('keeps a manually unread real reply out of Finished, then lifts a newer reply', async () => {
mockMarkUnread.mockResolvedValue({
modified: true,
lastResponseAt: RESPONDED_AT,
isMarkedUnread: true,
});
const { result, cached, queryClient } = setup(RESPONDED_AT, SEEN_AT);
const options = { field: 'updatedAt', direction: 'desc' } as const;
await act(async () => {
await result.current.mutateAsync({ conversationId: CONVO_ID });
});
expect(cached()?.isMarkedUnread).toBe(true);
expect(cached()?.lastResponseMessageId).toBe('original-reply');
const dates = [['Today', [cached()!]]] as [string, NonNullable<ReturnType<typeof cached>>[]][];
expect(groupConversationsByStatus(dates, new Set(), options)).toBe(dates);
act(() => {
applyServerReplyStamp(queryClient, CONVO_ID, {
lastResponseAt: '2026-08-16T12:00:00.000Z',
lastResponseMessageId: 'new-reply',
});
});
expect(cached()?.isMarkedUnread).toBeUndefined();
expect(groupConversationsByStatus([['Today', [cached()!]]], new Set(), options)[0][0]).toBe(
FINISHED_CHATS_GROUP,
);
});
it('restores manual unread intent when the write fails', async () => {
mockMarkUnread.mockRejectedValue(new Error('Unavailable'));
const { result, cached } = setup(RESPONDED_AT, SEEN_AT);
await act(async () => {
await result.current.mutateAsync({ conversationId: CONVO_ID }).catch(() => undefined);
});
expect(cached()?.isMarkedUnread).toBeUndefined();
expect(cached()?.lastSeenAt).toBe(SEEN_AT);
});
it('reasserts the unread state when a refetch lands on top of it', async () => {
/* A list refetch already in flight can have read the old catch-up and commit after the
optimistic clear, quietly taking the dot back off a conversation the server did flag. */
@ -87,6 +128,7 @@ describe('useMarkConversationUnreadMutation', () => {
await waitFor(() => expect(isConversationUnseen(cached())).toBe(true));
expect(cached()?.lastSeenAt).toBeUndefined();
expect(cached()?.isMarkedUnread).toBe(true);
});
it('preserves a later seen operation even when its stamp equals the original catch-up', async () => {

View file

@ -569,7 +569,11 @@ export const useMarkConversationSeenMutation = (): UseMutationResult<
*/
type UnreadWriteBaseline = Pick<
t.TConversation,
'lastResponseAt' | 'lastResponseMessageId' | 'lastResponseIsManual' | 'lastSeenAt'
| 'lastResponseAt'
| 'lastResponseMessageId'
| 'lastResponseIsManual'
| 'isMarkedUnread'
| 'lastSeenAt'
>;
const resolveReplyIdentity = (
@ -671,6 +675,7 @@ const reassertAcceptedUnread = (
serverResponseAt == null ? convo.lastResponseMessageId : resolveReplyIdentity(convo, data),
lastResponseIsManual:
serverResponseAt == null ? convo.lastResponseIsManual : data.lastResponseIsManual,
isMarkedUnread: data.isMarkedUnread ?? true,
lastSeenAt: undefined,
}));
};
@ -702,6 +707,7 @@ export const useMarkConversationUnreadMutation = (): UseMutationResult<
lastResponseAt: observed?.lastResponseAt,
lastResponseMessageId: observed?.lastResponseMessageId,
lastResponseIsManual: observed?.lastResponseIsManual,
isMarkedUnread: observed?.isMarkedUnread,
lastSeenAt: observed?.lastSeenAt,
});
const interrupted = await cancelConvoReadFetches(queryClient, vars.conversationId);
@ -710,6 +716,7 @@ export const useMarkConversationUnreadMutation = (): UseMutationResult<
lastResponseAt: owner.chain.baseline.lastResponseAt,
lastResponseMessageId: owner.chain.baseline.lastResponseMessageId,
lastResponseIsManual: owner.chain.baseline.lastResponseIsManual,
isMarkedUnread: owner.chain.baseline.isMarkedUnread,
lastSeenAt: owner.chain.baseline.lastSeenAt,
token: owner.token,
interrupted,
@ -734,6 +741,7 @@ export const useMarkConversationUnreadMutation = (): UseMutationResult<
: convo.lastResponseMessageId,
lastResponseIsManual:
convo.lastResponseAt == null || convo.lastResponseIsManual === true ? true : undefined,
isMarkedUnread: true,
lastSeenAt: undefined,
}));
return context;
@ -812,6 +820,7 @@ export const useMarkConversationUnreadMutation = (): UseMutationResult<
const lastResponseIsManual = keepsCached
? cached?.lastResponseIsManual
: data.lastResponseIsManual;
const isMarkedUnread = keepsCached ? cached?.isMarkedUnread : (data.isMarkedUnread ?? true);
const lastResponseMessageId =
keepsCached || serverResponseAt == null
? cached?.lastResponseMessageId
@ -820,6 +829,7 @@ export const useMarkConversationUnreadMutation = (): UseMutationResult<
cached?.lastSeenAt === undefined &&
cachedResponseAt === lastResponseAt &&
cached?.lastResponseIsManual === lastResponseIsManual &&
cached?.isMarkedUnread === isMarkedUnread &&
cached?.lastResponseMessageId === lastResponseMessageId
) {
return;
@ -829,6 +839,7 @@ export const useMarkConversationUnreadMutation = (): UseMutationResult<
lastResponseAt,
lastResponseMessageId,
lastResponseIsManual,
isMarkedUnread,
lastSeenAt: undefined,
}));
},
@ -865,6 +876,7 @@ export const useMarkConversationUnreadMutation = (): UseMutationResult<
lastResponseAt: context?.lastResponseAt,
lastResponseMessageId: resolveReplyIdentity(convo, context),
lastResponseIsManual: context?.lastResponseIsManual,
isMarkedUnread: context?.isMarkedUnread,
lastSeenAt: context?.lastSeenAt,
}));
},

View file

@ -220,6 +220,7 @@ const mergeTimestamps = async (
lastResponseAt,
lastResponseMessageId,
lastResponseIsManual,
isMarkedUnread,
lastSeenAt,
updatedAt,
} = convo;
@ -260,6 +261,7 @@ const mergeTimestamps = async (
cached &&
cached.lastResponseAt === lastResponseAt &&
cached.lastResponseIsManual === lastResponseIsManual &&
cached.isMarkedUnread === isMarkedUnread &&
cached.lastSeenAt === (lastSeenAt ?? undefined) &&
(updatedAt === undefined || cached.updatedAt === updatedAt) &&
(incomingResponseMessageId === undefined ||
@ -286,11 +288,13 @@ const mergeTimestamps = async (
lastResponseIsManual === true
? undefined
: (incomingResponseMessageId ?? cached.lastResponseMessageId);
const nextIsMarkedUnread = stampDelivery ? cached.isMarkedUnread : isMarkedUnread;
const nextLastSeenAt = stampDelivery ? cached.lastSeenAt : lastSeenAt;
const nextUpdatedAt = stampDelivery ? cached.updatedAt : (updatedAt ?? cached.updatedAt);
if (
cached.lastResponseMessageId !== nextLastResponseMessageId ||
cached.lastResponseIsManual !== lastResponseIsManual ||
cached.isMarkedUnread !== nextIsMarkedUnread ||
cached.lastSeenAt !== nextLastSeenAt ||
cached.updatedAt !== nextUpdatedAt
) {
@ -298,6 +302,7 @@ const mergeTimestamps = async (
...current,
lastResponseMessageId: nextLastResponseMessageId,
lastResponseIsManual,
isMarkedUnread: nextIsMarkedUnread,
lastSeenAt: nextLastSeenAt,
updatedAt: nextUpdatedAt,
}));
@ -355,6 +360,7 @@ const mergeTimestamps = async (
fresh.lastResponseAt === lastResponseAt &&
fresh.lastResponseMessageId === (incomingResponseMessageId ?? fresh.lastResponseMessageId) &&
fresh.lastResponseIsManual === lastResponseIsManual &&
fresh.isMarkedUnread === isMarkedUnread &&
fresh.lastSeenAt === (lastSeenAt ?? undefined) &&
(updatedAt === undefined || fresh.updatedAt === updatedAt)
) {
@ -369,6 +375,7 @@ const mergeTimestamps = async (
lastResponseAt,
lastResponseMessageId: incomingResponseMessageId ?? current.lastResponseMessageId,
lastResponseIsManual,
isMarkedUnread,
lastSeenAt,
updatedAt: updatedAt ?? current.updatedAt,
}),

View file

@ -28,6 +28,7 @@ const sidebarFields = [
'lastResponseAt',
'lastResponseMessageId',
'lastResponseIsManual',
'isMarkedUnread',
'lastSeenAt',
'isTemporary',
'expiredAt',

View file

@ -1240,6 +1240,7 @@ export function applyServerReplyStamp(
lastResponseAt,
lastResponseMessageId: lastResponseMessageId ?? convo.lastResponseMessageId,
lastResponseIsManual: undefined,
isMarkedUnread: advances ? undefined : convo.isMarkedUnread,
lastSeenAt: advances ? undefined : convo.lastSeenAt,
updatedAt: updatedAt ?? convo.updatedAt,
}),
@ -1278,6 +1279,13 @@ const preserveReadState = (next: TConversation, found: TConversation): TConversa
if (!('lastResponseIsManual' in next)) {
merged.lastResponseIsManual = found.lastResponseIsManual;
}
if (!('isMarkedUnread' in next)) {
merged.isMarkedUnread =
next.lastResponseAt != null &&
(found.lastResponseAt == null || next.lastResponseAt > found.lastResponseAt)
? undefined
: found.isMarkedUnread;
}
if (!('lastSeenAt' in next)) {
merged.lastSeenAt = found.lastSeenAt;
}
@ -1296,6 +1304,7 @@ const chatOwnedStaleFields = [
'lastResponseAt',
'lastResponseMessageId',
'lastResponseIsManual',
'isMarkedUnread',
'lastSeenAt',
] as const;

View file

@ -258,6 +258,24 @@ test.describe('unseen replies', () => {
/* At least one more, not exactly one: the other projects share this user
* and seed unseen conversations of their own while this one runs. */
await expect.poll(() => titleCount(page)).toBeGreaterThanOrEqual(baseline + 1);
await expect.poll(async () => (await readConversation(id))?.isMarkedUnread).toBe(true);
expect((await readConversation(id))?.lastResponseIsManual).not.toBe(true);
await page.reload();
await openSidebar(page);
await expect(row.locator('span[aria-hidden="true"].bg-status-info')).toBeVisible();
await expect
.poll(async () =>
row.evaluate((node) => {
let previous = node.closest('[role="row"]')?.previousElementSibling;
while (previous) {
const heading = previous.querySelector('h2');
if (heading) return heading.textContent;
previous = previous.previousElementSibling;
}
return null;
}),
)
.toBe('Today');
const token = await getAccessToken(page);
const neverReplied = conversationId();

View file

@ -158,6 +158,7 @@ export const excludedKeys = new Set([
'lastResponseAt',
'lastResponseMessageId',
'lastResponseIsManual',
'isMarkedUnread',
'lastSeenAt',
]);

View file

@ -798,12 +798,14 @@ describe('tPresetSchema', () => {
lastResponseAt: '2026-08-16T10:00:00.000Z',
lastResponseMessageId: 'reply-1',
lastResponseIsManual: true,
isMarkedUnread: true,
lastSeenAt: '2026-08-16T09:00:00.000Z',
});
expect(parsed).not.toHaveProperty('lastResponseAt');
expect(parsed).not.toHaveProperty('lastResponseMessageId');
expect(parsed).not.toHaveProperty('lastResponseIsManual');
expect(parsed).not.toHaveProperty('isMarkedUnread');
expect(parsed).not.toHaveProperty('lastSeenAt');
});

View file

@ -1255,6 +1255,8 @@ export const tConversationSchema = z.object({
lastResponseMessageId: z.string().optional(),
/** True only while `lastResponseAt` is the synthetic marker from "mark unread". */
lastResponseIsManual: z.boolean().optional(),
/** Manual reminder, cleared by reading or a new persisted reply. */
isMarkedUnread: z.boolean().optional(),
/** Set when the user has the newest message on screen; compared against `lastResponseAt`. */
lastSeenAt: z.string().optional(),
/* Files */
@ -1326,6 +1328,7 @@ export const tPresetSchema = tConversationSchema
lastResponseAt: true,
lastResponseMessageId: true,
lastResponseIsManual: true,
isMarkedUnread: true,
lastSeenAt: true,
})
.merge(

View file

@ -513,6 +513,7 @@ export type TMarkConversationUnreadResponse = {
lastResponseMessageId?: string;
/** True only when the settled stamp is the synthetic mark-unread marker. */
lastResponseIsManual?: boolean;
isMarkedUnread?: boolean;
};
export type TSharedMessagesResponse = Omit<TSharedLink, 'messages'> & {

View file

@ -54,6 +54,7 @@ export type MinimalConversation = Pick<
| 'lastResponseAt'
| 'lastResponseMessageId'
| 'lastResponseIsManual'
| 'isMarkedUnread'
| 'lastSeenAt'
>;

View file

@ -3181,6 +3181,7 @@ describe('Conversation Operations', () => {
const result = await markConvoUnread('user123', mockConversationData.conversationId);
expect(result.modified).toBe(true);
expect(result.isMarkedUnread).toBe(true);
const convo = await Conversation.findOne({
conversationId: mockConversationData.conversationId,
@ -3188,6 +3189,7 @@ describe('Conversation Operations', () => {
expect(convo?.lastSeenAt).toBeUndefined();
expect(convo?.lastResponseAt?.toISOString()).toBe('2026-08-16T10:00:00.000Z');
expect(convo?.lastResponseIsManual).toBeUndefined();
expect(convo?.isMarkedUnread).toBe(true);
});
it('returns the stamp it settled on so the client never invents one', async () => {
@ -3293,6 +3295,65 @@ describe('Conversation Operations', () => {
expect(convo?.lastSeenAt).toBeInstanceOf(Date);
});
});
describe('manual unread reminders', () => {
it('survives reload and is cleared by a persisted real reply', async () => {
await Conversation.create({
conversationId: mockConversationData.conversationId,
user: 'user123',
endpoint: EModelEndpoint.openAI,
lastResponseAt: new Date('2026-08-16T10:00:00.000Z'),
lastResponseMessageId: 'original-reply',
});
await methods.markConvoUnread('user123', mockConversationData.conversationId);
const unread = await Conversation.findOne({
conversationId: mockConversationData.conversationId,
}).lean<IConversation>();
expect(unread?.isMarkedUnread).toBe(true);
expect(unread?.lastResponseMessageId).toBe('original-reply');
await methods.stampConvoLastResponse(
'user123',
mockConversationData.conversationId,
'new-reply',
);
const replied = await Conversation.findOne({
conversationId: mockConversationData.conversationId,
}).lean<IConversation>();
expect(replied?.isMarkedUnread).toBeUndefined();
expect(replied?.lastResponseMessageId).toBe('new-reply');
});
it('is cleared only by an acknowledgement of the current reply', async () => {
const responseAt = new Date('2026-08-16T10:00:00.000Z');
await Conversation.create({
conversationId: mockConversationData.conversationId,
user: 'user123',
endpoint: EModelEndpoint.openAI,
lastResponseAt: responseAt,
isMarkedUnread: true,
});
await methods.markConvoSeen(
'user123',
mockConversationData.conversationId,
new Date(responseAt.getTime() - 1),
);
expect(
(
await Conversation.findOne({
conversationId: mockConversationData.conversationId,
}).lean<IConversation>()
)?.isMarkedUnread,
).toBe(true);
await methods.markConvoSeen('user123', mockConversationData.conversationId, responseAt);
expect(
(
await Conversation.findOne({
conversationId: mockConversationData.conversationId,
}).lean<IConversation>()
)?.isMarkedUnread,
).toBeUndefined();
});
});
describe('unseen-reply fields', () => {
it('returns lastResponseAt, manual marker, and lastSeenAt from the cursor listing', async () => {
const lastResponseAt = new Date('2026-08-16T10:00:00.000Z');
@ -3304,6 +3365,7 @@ describe('Conversation Operations', () => {
lastResponseAt,
lastResponseMessageId: 'reply-listed',
lastResponseIsManual: true,
isMarkedUnread: true,
lastSeenAt,
});
@ -3312,6 +3374,7 @@ describe('Conversation Operations', () => {
expect(conversations[0].lastResponseAt?.toISOString()).toBe(lastResponseAt.toISOString());
expect(conversations[0].lastResponseMessageId).toBe('reply-listed');
expect(conversations[0].lastResponseIsManual).toBe(true);
expect(conversations[0].isMarkedUnread).toBe(true);
expect(conversations[0].lastSeenAt?.toISOString()).toBe(lastSeenAt.toISOString());
});

View file

@ -573,6 +573,7 @@ export interface ConversationMethods {
lastResponseAt?: Date;
lastResponseMessageId?: string;
lastResponseIsManual?: boolean;
isMarkedUnread?: boolean;
}>;
stampConvoLastResponse(
user: string,
@ -653,7 +654,7 @@ export function createConversationMethods(
casFilter,
{
$set: { lastResponseAt: stamp, lastResponseMessageId: responseMessageId },
$unset: { lastSeenAt: '', lastResponseIsManual: '' },
$unset: { lastSeenAt: '', lastResponseIsManual: '', isMarkedUnread: '' },
$max: { updatedAt: stamp },
},
{ new: true, projection, timestamps: false },
@ -2413,6 +2414,7 @@ export function createConversationMethods(
/* Read-state fields are server-owned. A stale marker must never be reintroduced by a
* metadata save after a real reply cleared it. */
delete update.lastResponseIsManual;
delete update.isMarkedUnread;
delete update.lastResponseAt;
delete update.lastResponseMessageId;
delete update.initial_agent_id;
@ -2436,6 +2438,7 @@ export function createConversationMethods(
}
const unsetFields: Record<string, number> = { ...(metadata?.unsetFields ?? {}) };
delete unsetFields.lastResponseIsManual;
delete unsetFields.isMarkedUnread;
delete unsetFields.lastResponseMessageId;
delete unsetFields.lastResponseAt;
delete unsetFields.initial_agent_id;
@ -2568,7 +2571,7 @@ export function createConversationMethods(
const { lastResponseAt, ...withoutReplyStamp } = setFields;
operation.$set = withoutReplyStamp;
operation.$max = { lastResponseAt };
operation.$unset = { lastResponseIsManual: '' };
operation.$unset = { lastResponseIsManual: '', isMarkedUnread: '' };
}
if (Object.keys(unsetFields).length > 0) {
operation.$unset = {
@ -2736,6 +2739,7 @@ export function createConversationMethods(
lastResponseAt: 1,
lastResponseMessageId: 1,
lastResponseIsManual: 1,
isMarkedUnread: 1,
updatedAt: 1,
},
);
@ -2746,6 +2750,7 @@ export function createConversationMethods(
conversation.lastResponseAt = stamped.stamp;
conversation.lastResponseMessageId = stamped.conversation.lastResponseMessageId;
conversation.lastResponseIsManual = stamped.conversation.lastResponseIsManual;
conversation.isMarkedUnread = stamped.conversation.isMarkedUnread;
conversation.lastSeenAt = undefined;
if (stamped.conversation.updatedAt) {
conversation.updatedAt = stamped.conversation.updatedAt;
@ -3091,6 +3096,7 @@ export function createConversationMethods(
delete sanitized.lastResponseAt;
delete sanitized.lastResponseMessageId;
delete sanitized.lastResponseIsManual;
delete sanitized.isMarkedUnread;
delete sanitized.lastSeenAt;
delete sanitized.codeApprovalMode;
delete sanitized.initial_agent_id;
@ -3512,7 +3518,7 @@ export function createConversationMethods(
the sidebar lists archived and unarchived chats in the same session, and the
active list also carries the unarchived pins beside them. */
.select(
'conversationId endpoint title createdAt updatedAt archivedAt isArchived user model agent_id assistant_id spec iconURL chatProjectId pinned lastResponseAt lastResponseMessageId lastResponseIsManual lastSeenAt',
'conversationId endpoint title createdAt updatedAt archivedAt isArchived user model agent_id assistant_id spec iconURL chatProjectId pinned lastResponseAt lastResponseMessageId lastResponseIsManual isMarkedUnread lastSeenAt',
)
.sort(sortObj)
.limit(pageSize + 1)
@ -4003,7 +4009,7 @@ export function createConversationMethods(
const lastSeenAt = observedResponseAt && observedResponseAt > now ? observedResponseAt : now;
const result = await Conversation.updateOne(
filter,
{ $set: { lastSeenAt } },
{ $set: { lastSeenAt }, $unset: { isMarkedUnread: '' } },
{ timestamps: false },
);
/* Matched, not modified: a retry of an acknowledgement that already landed writes the
@ -4032,7 +4038,12 @@ export function createConversationMethods(
async function markConvoUnread(user: string, conversationId: string) {
try {
const Conversation = mongoose.models.Conversation as Model<IConversation>;
const projection = { lastResponseAt: 1, lastResponseMessageId: 1, lastResponseIsManual: 1 };
const projection = {
lastResponseAt: 1,
lastResponseMessageId: 1,
lastResponseIsManual: 1,
isMarkedUnread: 1,
};
const stamped = await Conversation.findOneAndUpdate(
{
conversationId,
@ -4040,12 +4051,15 @@ export function createConversationMethods(
$or: [{ lastResponseAt: null }, { lastResponseAt: { $exists: false } }],
},
{
$set: { lastResponseAt: new Date(), lastResponseIsManual: true },
$set: { lastResponseAt: new Date(), lastResponseIsManual: true, isMarkedUnread: true },
$unset: { lastSeenAt: '', lastResponseMessageId: '' },
},
{ timestamps: false, new: true, projection },
).lean<
Pick<IConversation, 'lastResponseAt' | 'lastResponseMessageId' | 'lastResponseIsManual'>
Pick<
IConversation,
'lastResponseAt' | 'lastResponseMessageId' | 'lastResponseIsManual' | 'isMarkedUnread'
>
>();
if (stamped) {
return {
@ -4053,15 +4067,19 @@ export function createConversationMethods(
lastResponseAt: stamped.lastResponseAt,
lastResponseMessageId: stamped.lastResponseMessageId,
lastResponseIsManual: stamped.lastResponseIsManual === true,
isMarkedUnread: stamped.isMarkedUnread,
};
}
const cleared = await Conversation.findOneAndUpdate(
{ conversationId, user },
{ $unset: { lastSeenAt: '' } },
{ $set: { isMarkedUnread: true }, $unset: { lastSeenAt: '' } },
{ timestamps: false, new: true, projection },
).lean<
Pick<IConversation, 'lastResponseAt' | 'lastResponseMessageId' | 'lastResponseIsManual'>
Pick<
IConversation,
'lastResponseAt' | 'lastResponseMessageId' | 'lastResponseIsManual' | 'isMarkedUnread'
>
>();
return cleared
@ -4070,6 +4088,7 @@ export function createConversationMethods(
lastResponseAt: cleared.lastResponseAt,
lastResponseMessageId: cleared.lastResponseMessageId,
lastResponseIsManual: cleared.lastResponseIsManual === true,
isMarkedUnread: cleared.isMarkedUnread,
}
: { modified: false };
} catch (error) {

View file

@ -400,6 +400,9 @@ const convoSchema: Schema<IConversation> = new Schema(
lastResponseIsManual: {
type: Boolean,
},
isMarkedUnread: {
type: Boolean,
},
lastSeenAt: {
type: Date,
},

View file

@ -346,6 +346,8 @@ export interface IConversation extends Document {
lastResponseMessageId?: string;
/** True only while `lastResponseAt` is the synthetic marker from "mark unread". */
lastResponseIsManual?: boolean;
/** Manual reminder, cleared by reading or a new persisted reply. */
isMarkedUnread?: boolean;
/** Set when the user has the newest message on screen; compared against `lastResponseAt`. */
lastSeenAt?: Date;
}