Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

fix(email): include viewed history in backfill catch-up (#6172)

Sean Aye99a34834bfcd
diff --git a/apps/web/src/lib/queries/soup/backfill.test.tsx b/apps/web/src/lib/queries/soup/backfill.test.tsx
index a93f536600..02549e72a2 100644
--- a/apps/web/src/lib/queries/soup/backfill.test.tsx
+++ b/apps/web/src/lib/queries/soup/backfill.test.tsx
@@ -173,8 +173,17 @@ describe('runSoupBackfills', () => {
filters: {
emailFilter: {
tree: {
- literal: {
- updatedAt: { gte: '2026-09-02T12:00:00.000Z' },
+ or: {
+ left: {
+ literal: {
+ updatedAt: { gte: '2026-09-02T12:00:00.000Z' },
+ },
+ },
+ right: {
+ literal: {
+ viewedAt: { gte: '2026-09-02T12:00:00.000Z' },
+ },
+ },
},
},
},
@@ -255,8 +264,17 @@ describe('runSoupBackfills', () => {
filters: {
emailFilter: {
tree: {
- literal: {
- updatedAt: { gte: '2026-09-02T12:00:00.000Z' },
+ or: {
+ left: {
+ literal: {
+ updatedAt: { gte: '2026-09-02T12:00:00.000Z' },
+ },
+ },
+ right: {
+ literal: {
+ viewedAt: { gte: '2026-09-02T12:00:00.000Z' },
+ },
+ },
},
},
},
@@ -375,7 +393,7 @@ describe('runSoupBackfills', () => {
it('restarts from the beginning when the cache generation is replaced', async () => {
localStorage.setItem(
- 'graphql-soup-backfill:v7:user-1:core-entities',
+ 'graphql-soup-backfill:v8:user-1:core-entities',
JSON.stringify({
userId: 'user-1',
nextCursor: 'stale-cursor',
diff --git a/apps/web/src/lib/queries/soup/backfill.ts b/apps/web/src/lib/queries/soup/backfill.ts
index 9d343037f9..7975772386 100644
--- a/apps/web/src/lib/queries/soup/backfill.ts
+++ b/apps/web/src/lib/queries/soup/backfill.ts
@@ -22,7 +22,7 @@ import { createEffect, createSignal, onCleanup } from 'solid-js';
// Bump when a default backfill input or completion guarantee changes so
// persisted cursors cannot retain an older hydration contract.
-const BACKFILL_VERSION = 7;
+const BACKFILL_VERSION = 8;
const PAGE_LIMIT = 100;
// Five threads × twenty messages reaches the backend's 100-message cap.
const EMAIL_CONTENT_PAGE_LIMIT = 5;
@@ -310,8 +310,13 @@ export function withUpdatedSince(
literal: { updatedAt: { gte: updatedSince } },
};
- const emailUpdatedAt = {
- literal: { updatedAt: { gte: updatedSince } },
+ // VIEWED_UPDATED can move a row ahead of the scan cursor through either
+ // the thread timestamp or this viewer's history timestamp. Cover both.
+ const emailSortWatermark = {
+ or: {
+ left: { literal: { updatedAt: { gte: updatedSince } } },
+ right: { literal: { viewedAt: { gte: updatedSince } } },
+ },
};
return {
@@ -323,7 +328,7 @@ export function withUpdatedSince(
chatFilter: and(filters.chatFilter, chatUpdatedAt),
emailFilter: {
...(filters.emailFilter ?? {}),
- tree: and(filters.emailFilter?.tree, emailUpdatedAt),
+ tree: and(filters.emailFilter?.tree, emailSortWatermark),
},
},
};
diff --git a/apps/web/src/lib/service-clients/service-storage/graphql/generated/graphql.ts b/apps/web/src/lib/service-clients/service-storage/graphql/generated/graphql.ts
index a8ef7f742d..73061f7de9 100644
--- a/apps/web/src/lib/service-clients/service-storage/graphql/generated/graphql.ts
+++ b/apps/web/src/lib/service-clients/service-storage/graphql/generated/graphql.ts
@@ -428,33 +428,35 @@ export type GraphqlEmailFilterAst = {
/** GraphQL input representing the email literal. */
export type GraphqlEmailLiteral =
{ /** The bcc option. */
- bcc: GraphqlEmailValue; calendarOnly?: never; cc?: never; createdAt?: never; importance?: never; notificationDone?: never; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; }
+ bcc: GraphqlEmailValue; calendarOnly?: never; cc?: never; createdAt?: never; importance?: never; notificationDone?: never; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; viewedAt?: never; }
| { bcc?: never; /** The calendar only option. */
- calendarOnly: boolean; cc?: never; createdAt?: never; importance?: never; notificationDone?: never; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; }
+ calendarOnly: boolean; cc?: never; createdAt?: never; importance?: never; notificationDone?: never; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; viewedAt?: never; }
| { bcc?: never; calendarOnly?: never; /** The cc option. */
- cc: GraphqlEmailValue; createdAt?: never; importance?: never; notificationDone?: never; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; }
+ cc: GraphqlEmailValue; createdAt?: never; importance?: never; notificationDone?: never; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; viewedAt?: never; }
| { bcc?: never; calendarOnly?: never; cc?: never; /** The created at option. */
- createdAt: GraphqlDateLiteral; importance?: never; notificationDone?: never; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; }
+ createdAt: GraphqlDateLiteral; importance?: never; notificationDone?: never; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; viewedAt?: never; }
| { bcc?: never; calendarOnly?: never; cc?: never; createdAt?: never; /** The importance option. */
- importance: boolean; notificationDone?: never; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; }
+ importance: boolean; notificationDone?: never; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; viewedAt?: never; }
| { bcc?: never; calendarOnly?: never; cc?: never; createdAt?: never; importance?: never; /** The notification done option. */
- notificationDone: boolean; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; }
+ notificationDone: boolean; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; viewedAt?: never; }
| { bcc?: never; calendarOnly?: never; cc?: never; createdAt?: never; importance?: never; notificationDone?: never; /** The notification seen option. */
- notificationSeen: boolean; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; }
+ notificationSeen: boolean; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; viewedAt?: never; }
| { bcc?: never; calendarOnly?: never; cc?: never; createdAt?: never; importance?: never; notificationDone?: never; notificationSeen?: never; /** The owner option. */
- owner: string | number; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; }
+ owner: string | number; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; viewedAt?: never; }
| { bcc?: never; calendarOnly?: never; cc?: never; createdAt?: never; importance?: never; notificationDone?: never; notificationSeen?: never; owner?: never; /** The project id option. */
- projectId: string; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; }
+ projectId: string; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; viewedAt?: never; }
| { bcc?: never; calendarOnly?: never; cc?: never; createdAt?: never; importance?: never; notificationDone?: never; notificationSeen?: never; owner?: never; projectId?: never; /** The recipient option. */
- recipient: GraphqlEmailValue; sender?: never; shared?: never; threadId?: never; updatedAt?: never; }
+ recipient: GraphqlEmailValue; sender?: never; shared?: never; threadId?: never; updatedAt?: never; viewedAt?: never; }
| { bcc?: never; calendarOnly?: never; cc?: never; createdAt?: never; importance?: never; notificationDone?: never; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; /** The sender option. */
- sender: GraphqlEmailValue; shared?: never; threadId?: never; updatedAt?: never; }
+ sender: GraphqlEmailValue; shared?: never; threadId?: never; updatedAt?: never; viewedAt?: never; }
| { bcc?: never; calendarOnly?: never; cc?: never; createdAt?: never; importance?: never; notificationDone?: never; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; sender?: never; /** The shared option. */
- shared: GraphqlSharedEmailFilter; threadId?: never; updatedAt?: never; }
+ shared: GraphqlSharedEmailFilter; threadId?: never; updatedAt?: never; viewedAt?: never; }
| { bcc?: never; calendarOnly?: never; cc?: never; createdAt?: never; importance?: never; notificationDone?: never; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; /** The thread id option. */
- threadId: string | number; updatedAt?: never; }
+ threadId: string | number; updatedAt?: never; viewedAt?: never; }
| { bcc?: never; calendarOnly?: never; cc?: never; createdAt?: never; importance?: never; notificationDone?: never; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; /** The updated at option. */
- updatedAt: GraphqlDateLiteral; };
+ updatedAt: GraphqlDateLiteral; viewedAt?: never; }
+ | { bcc?: never; calendarOnly?: never; cc?: never; createdAt?: never; importance?: never; notificationDone?: never; notificationSeen?: never; owner?: never; projectId?: never; recipient?: never; sender?: never; shared?: never; threadId?: never; updatedAt?: never; /** The per-viewer viewed at option. */
+ viewedAt: GraphqlDateLiteral; };
/** GraphQL input representing the email value. */
export type GraphqlEmailValue =
diff --git a/crates/email/src/outbound/email_pg_repo/dynamic/filters.rs b/crates/email/src/outbound/email_pg_repo/dynamic/filters.rs
index 0bd8add69a..a60b86524a 100644
--- a/crates/email/src/outbound/email_pg_repo/dynamic/filters.rs
+++ b/crates/email/src/outbound/email_pg_repo/dynamic/filters.rs
@@ -40,6 +40,7 @@ pub(super) fn has_thread_literals(ast: &Expr<EmailLiteral>) -> bool {
| EmailLiteral::NotificationDone(_)
| EmailLiteral::CreatedAt(_)
| EmailLiteral::UpdatedAt(_)
+ | EmailLiteral::ViewedAt(_)
| EmailLiteral::Property(_),
) => true,
filter_ast::ExprFrame::Literal(EmailLiteral::Shared(_)) => false,
@@ -62,6 +63,7 @@ pub(super) fn has_message_literals(ast: &Expr<EmailLiteral>) -> bool {
| EmailLiteral::NotificationDone(_)
| EmailLiteral::CreatedAt(_)
| EmailLiteral::UpdatedAt(_)
+ | EmailLiteral::ViewedAt(_)
| EmailLiteral::Property(_),
) => false,
filter_ast::ExprFrame::Literal(_) => true,
@@ -181,47 +183,149 @@ fn build_address_text_match(
}
}
-pub(super) fn build_message_email_filter(
+fn build_message_literal_predicate(
+ literal: &EmailLiteral,
+ resolved: &ResolvedFilters,
+) -> SqlFragment {
+ match literal {
+ EmailLiteral::Sender(email) => {
+ build_address_predicate_on_m(AddressKind::Sender, email, resolved)
+ }
+ EmailLiteral::Recipient(email) => {
+ build_address_predicate_on_m(AddressKind::Recipient, email, resolved)
+ }
+ EmailLiteral::Cc(email) => build_address_predicate_on_m(AddressKind::Cc, email, resolved),
+ EmailLiteral::Bcc(email) => build_address_predicate_on_m(AddressKind::Bcc, email, resolved),
+ _ => unreachable!("expected a message-level email literal"),
+ }
+}
+
+fn build_thread_literal_predicate(
+ literal: &EmailLiteral,
+ sort_ts_field: &str,
+ thread_alias: &str,
+ history_alias: &str,
+) -> SqlFragment {
+ match literal {
+ EmailLiteral::ThreadId(id) => {
+ let mut f = SqlFragment::raw(format!("{thread_alias}.id = "));
+ f.extend(SqlFragment::bind_uuid(*id));
+ f
+ }
+ EmailLiteral::Owner(id) => {
+ let mut f = SqlFragment::raw(format!("{thread_alias}.link_id = "));
+ f.extend(SqlFragment::bind_uuid(*id));
+ f
+ }
+ EmailLiteral::ProjectId(id) => {
+ let mut f = SqlFragment::raw(format!("{thread_alias}.project_id = "));
+ f.extend(SqlFragment::bind_string(id.clone()));
+ f
+ }
+ // Denormalized flag maintained at attachment ingest — deriving this
+ // from email_attachments at query time is prohibitively slow.
+ EmailLiteral::CalendarOnly(true) => {
+ SqlFragment::raw(format!("{thread_alias}.has_calendar_attachment"))
+ }
+ EmailLiteral::CalendarOnly(false) => SqlFragment::raw("TRUE"),
+ // Denormalized importance flag maintained by update_thread_metadata
+ // (sync_thread_signal_flag) and the email_filters resync fan-out.
+ EmailLiteral::Importance(true) => SqlFragment::raw(format!("{thread_alias}.is_signal")),
+ EmailLiteral::Importance(false) => {
+ SqlFragment::raw(format!("(NOT {thread_alias}.is_signal)"))
+ }
+ EmailLiteral::CreatedAt(lit) => date_predicate(&format!("{thread_alias}.created_at"), lit),
+ EmailLiteral::UpdatedAt(lit) => date_predicate(sort_ts_field, lit),
+ EmailLiteral::ViewedAt(lit) => date_predicate(&format!("{history_alias}.updated_at"), lit),
+ EmailLiteral::Property(lit) => build_thread_property_predicate(lit, thread_alias),
+ EmailLiteral::NotificationSeen(true) => {
+ SqlFragment::raw(format!("{thread_alias}.is_read = TRUE"))
+ }
+ EmailLiteral::NotificationSeen(false) => {
+ SqlFragment::raw(format!("{thread_alias}.is_read = FALSE"))
+ }
+ // These literals are handled outside the thread/message predicate.
+ EmailLiteral::NotificationDone(_) | EmailLiteral::Shared(_) => SqlFragment::raw("TRUE"),
+ EmailLiteral::Sender(_)
+ | EmailLiteral::Cc(_)
+ | EmailLiteral::Bcc(_)
+ | EmailLiteral::Recipient(_) => unreachable!("expected a thread-level email literal"),
+ }
+}
+
+/// Builds the full filter for one candidate `(thread, message)` pair. Keeping
+/// the original boolean tree inside one correlated message probe preserves
+/// single-message semantics through mixed-level OR and NOT expressions.
+fn build_candidate_pair_predicate(
ast: &Expr<EmailLiteral>,
+ sort_ts_field: &str,
resolved: &ResolvedFilters,
) -> SqlFragment {
- let fragment = ast.collapse_frames(|frame| match frame {
+ ast.collapse_frames(|frame| match frame {
filter_ast::ExprFrame::And(a, b) => SqlFragment::and(a, b),
filter_ast::ExprFrame::Or(a, b) => SqlFragment::or(a, b),
filter_ast::ExprFrame::Not(a) => SqlFragment::not(a),
+ filter_ast::ExprFrame::Literal(literal) => match literal {
+ EmailLiteral::Sender(_)
+ | EmailLiteral::Cc(_)
+ | EmailLiteral::Bcc(_)
+ | EmailLiteral::Recipient(_) => build_message_literal_predicate(&literal, resolved),
+ _ => build_thread_literal_predicate(&literal, sort_ts_field, "t", "uh"),
+ },
+ })
+}
- filter_ast::ExprFrame::Literal(
- EmailLiteral::ThreadId(_) | EmailLiteral::Owner(_) | EmailLiteral::ProjectId(_),
- ) => SqlFragment::raw("TRUE"),
-
- filter_ast::ExprFrame::Literal(EmailLiteral::Sender(email)) => {
- build_address_predicate_on_m(AddressKind::Sender, &email, resolved)
- }
-
- filter_ast::ExprFrame::Literal(EmailLiteral::Recipient(email)) => {
- build_address_predicate_on_m(AddressKind::Recipient, &email, resolved)
- }
+/// Lowers a thread-level literal inside the per-message LATERAL as a scalar
+/// correlated predicate. A scalar subquery intentionally preserves SQL NULL
+/// semantics under NOT (notably for threads without a ViewedAt history row).
+fn build_correlated_thread_predicate(literal: &EmailLiteral, sort_ts_field: &str) -> SqlFragment {
+ if matches!(
+ literal,
+ EmailLiteral::NotificationDone(_) | EmailLiteral::Shared(_)
+ ) {
+ return SqlFragment::raw("TRUE");
+ }
- filter_ast::ExprFrame::Literal(EmailLiteral::Cc(email)) => {
- build_address_predicate_on_m(AddressKind::Cc, &email, resolved)
- }
+ let thread_alias = "email_filter_thread";
+ let history_alias = "email_filter_history";
+ let correlated_sort_ts_field = sort_ts_field.replace("t.", &format!("{thread_alias}."));
+ let predicate = build_thread_literal_predicate(
+ literal,
+ &correlated_sort_ts_field,
+ thread_alias,
+ history_alias,
+ );
- filter_ast::ExprFrame::Literal(EmailLiteral::Bcc(email)) => {
- build_address_predicate_on_m(AddressKind::Bcc, &email, resolved)
- }
+ let mut f = SqlFragment::raw("(SELECT ");
+ f.extend(predicate);
+ f.push_raw(format!(" FROM email_threads {thread_alias}"));
+ if matches!(literal, EmailLiteral::ViewedAt(_)) {
+ f.push_raw(format!(
+ " LEFT JOIN email_user_history {history_alias} \
+ ON {history_alias}.thread_id = {thread_alias}.id \
+ AND {history_alias}.link_id = {thread_alias}.link_id"
+ ));
+ }
+ f.push_raw(format!(" WHERE {thread_alias}.id = m.thread_id)"));
+ f
+}
- filter_ast::ExprFrame::Literal(EmailLiteral::Importance(_)) => SqlFragment::raw("TRUE"),
- filter_ast::ExprFrame::Literal(EmailLiteral::NotificationDone(_)) => {
- SqlFragment::raw("TRUE")
- }
- filter_ast::ExprFrame::Literal(EmailLiteral::NotificationSeen(_)) => {
- SqlFragment::raw("TRUE")
- }
- filter_ast::ExprFrame::Literal(EmailLiteral::Shared(_)) => SqlFragment::raw("TRUE"),
- filter_ast::ExprFrame::Literal(EmailLiteral::CalendarOnly(_)) => SqlFragment::raw("TRUE"),
- filter_ast::ExprFrame::Literal(EmailLiteral::CreatedAt(_)) => SqlFragment::raw("TRUE"),
- filter_ast::ExprFrame::Literal(EmailLiteral::UpdatedAt(_)) => SqlFragment::raw("TRUE"),
- filter_ast::ExprFrame::Literal(EmailLiteral::Property(_)) => SqlFragment::raw("TRUE"),
+pub(super) fn build_message_email_filter(
+ ast: &Expr<EmailLiteral>,
+ resolved: &ResolvedFilters,
+ sort_ts_field: &str,
+) -> SqlFragment {
+ let fragment = ast.collapse_frames(|frame| match frame {
+ filter_ast::ExprFrame::And(a, b) => SqlFragment::and(a, b),
+ filter_ast::ExprFrame::Or(a, b) => SqlFragment::or(a, b),
+ filter_ast::ExprFrame::Not(a) => SqlFragment::not(a),
+ filter_ast::ExprFrame::Literal(literal) => match literal {
+ EmailLiteral::Sender(_)
+ | EmailLiteral::Cc(_)
+ | EmailLiteral::Bcc(_)
+ | EmailLiteral::Recipient(_) => build_message_literal_predicate(&literal, resolved),
+ _ => build_correlated_thread_predicate(&literal, sort_ts_field),
+ },
});
fragment.with_and_prefix()
@@ -386,7 +490,11 @@ pub(super) fn build_thread_message_exists_filter(
f.extend(view_message_filter);
}
if has_message_literals(ast) {
- f.extend(build_message_email_filter(ast, resolved));
+ f.extend(build_message_email_filter(
+ ast,
+ resolved,
+ get_sort_timestamp_field(view),
+ ));
}
f.push_raw(")");
f
@@ -819,83 +927,33 @@ impl MatchingThreadsCtes {
}
}
-/// Builds thread-level SQL WHERE conditions. Message-level literals map to TRUE.
+/// Builds thread-level SQL WHERE conditions. When the tree contains message
+/// literals, the complete expression is evaluated inside one correlated
+/// message predicate instead of replacing those literals with `TRUE`.
pub(super) fn build_thread_email_filter(
ast: &Expr<EmailLiteral>,
sort_ts_field: &str,
+ resolved: &ResolvedFilters,
) -> SqlFragment {
- let fragment = ast.collapse_frames(|frame| match frame {
- filter_ast::ExprFrame::And(a, b) => SqlFragment::and(a, b),
- filter_ast::ExprFrame::Or(a, b) => SqlFragment::or(a, b),
- filter_ast::ExprFrame::Not(a) => SqlFragment::not(a),
-
- filter_ast::ExprFrame::Literal(EmailLiteral::ThreadId(id)) => {
- let mut f = SqlFragment::raw("t.id = ");
- f.extend(SqlFragment::bind_uuid(id));
- f
- }
-
- filter_ast::ExprFrame::Literal(EmailLiteral::Owner(id)) => {
- let mut f = SqlFragment::raw("t.link_id = ");
- f.extend(SqlFragment::bind_uuid(id));
- f
- }
-
- filter_ast::ExprFrame::Literal(EmailLiteral::ProjectId(id)) => {
- let mut f = SqlFragment::raw("t.project_id = ");
- f.extend(SqlFragment::bind_string(id));
- f
- }
-
- // Denormalized flag maintained at attachment ingest — deriving this
- // from email_attachments at query time is prohibitively slow.
- filter_ast::ExprFrame::Literal(EmailLiteral::CalendarOnly(true)) => {
- SqlFragment::raw("t.has_calendar_attachment")
- }
-
- filter_ast::ExprFrame::Literal(EmailLiteral::CalendarOnly(false)) => {
- SqlFragment::raw("TRUE")
- }
-
- // Denormalized importance flag maintained by update_thread_metadata
- // (sync_thread_signal_flag) and the email_filters resync fan-out.
- filter_ast::ExprFrame::Literal(EmailLiteral::Importance(true)) => {
- SqlFragment::raw("t.is_signal")
- }
-
- filter_ast::ExprFrame::Literal(EmailLiteral::Importance(false)) => {
- SqlFragment::raw("(NOT t.is_signal)")
- }
-
- filter_ast::ExprFrame::Literal(EmailLiteral::CreatedAt(ref lit)) => {
- date_predicate("t.created_at", lit)
- }
-
- filter_ast::ExprFrame::Literal(EmailLiteral::UpdatedAt(ref lit)) => {
- date_predicate(sort_ts_field, lit)
- }
-
- filter_ast::ExprFrame::Literal(EmailLiteral::Property(ref lit)) => {
- build_thread_property_predicate(lit)
- }
-
- filter_ast::ExprFrame::Literal(EmailLiteral::NotificationSeen(true)) => {
- SqlFragment::raw("t.is_read = TRUE")
- }
-
- filter_ast::ExprFrame::Literal(EmailLiteral::NotificationSeen(false)) => {
- SqlFragment::raw("t.is_read = FALSE")
- }
-
- filter_ast::ExprFrame::Literal(
- EmailLiteral::Sender(_)
- | EmailLiteral::Cc(_)
- | EmailLiteral::Bcc(_)
- | EmailLiteral::Recipient(_)
- | EmailLiteral::NotificationDone(_)
- | EmailLiteral::Shared(_),
- ) => SqlFragment::raw("TRUE"),
- });
+ let fragment = if has_message_literals(ast) {
+ let mut f = SqlFragment::raw(
+ "EXISTS (SELECT 1 FROM email_messages m WHERE m.thread_id = t.id AND ",
+ );
+ f.extend(build_trash_check(resolved));
+ f.push_raw(" AND ");
+ f.extend(build_candidate_pair_predicate(ast, sort_ts_field, resolved));
+ f.push_raw(")");
+ f
+ } else {
+ ast.collapse_frames(|frame| match frame {
+ filter_ast::ExprFrame::And(a, b) => SqlFragment::and(a, b),
+ filter_ast::ExprFrame::Or(a, b) => SqlFragment::or(a, b),
+ filter_ast::ExprFrame::Not(a) => SqlFragment::not(a),
+ filter_ast::ExprFrame::Literal(literal) => {
+ build_thread_literal_predicate(&literal, sort_ts_field, "t", "uh")
+ }
+ })
+ };
fragment.with_and_prefix()
}
@@ -903,20 +961,20 @@ pub(super) fn build_thread_email_filter(
/// Entity-property predicate for a candidate thread: EXISTS against
/// `entity_properties` keyed on the thread id. A literal typed to a
/// non-thread entity can never match a thread, so it renders FALSE.
-fn build_thread_property_predicate(lit: &PropertiesLiteral) -> SqlFragment {
+fn build_thread_property_predicate(lit: &PropertiesLiteral, thread_alias: &str) -> SqlFragment {
if lit
.entity_type
.is_some_and(|et| et != PropertyEntityType::Thread)
{
return SqlFragment::raw("FALSE");
}
- let mut f = SqlFragment::raw(
+ let mut f = SqlFragment::raw(format!(
r#"EXISTS (
SELECT 1 FROM entity_properties ep_prop
- WHERE ep_prop.entity_id = t.id::text
+ WHERE ep_prop.entity_id = {thread_alias}.id::text
AND ep_prop.entity_type = 'THREAD'
AND ep_prop.property_definition_id = "#,
- );
+ ));
f.extend(SqlFragment::bind_uuid(lit.property_definition_id));
match &lit.value {
PropertyMatchValue::SelectOption(option_id) => {
diff --git a/crates/email/src/outbound/email_pg_repo/dynamic/query.rs b/crates/email/src/outbound/email_pg_repo/dynamic/query.rs
index 786b49c62c..76cf00400c 100644
--- a/crates/email/src/outbound/email_pg_repo/dynamic/query.rs
+++ b/crates/email/src/outbound/email_pg_repo/dynamic/query.rs
@@ -63,6 +63,21 @@ fn sort_uses_view_history(sort_method_str: &str) -> bool {
matches!(sort_method_str, "viewed_at" | "viewed_updated")
}
+/// A viewed_at predicate also requires the caller-specific history row in
+/// the candidate stage, even when ordering uses a non-viewed timestamp.
+fn filter_uses_view_history(ast: &Expr<EmailLiteral>) -> bool {
+ ast.collapse_frames(|frame| match frame {
+ filter_ast::ExprFrame::And(a, b) | filter_ast::ExprFrame::Or(a, b) => a || b,
+ filter_ast::ExprFrame::Not(a) => a,
+ filter_ast::ExprFrame::Literal(EmailLiteral::ViewedAt(_)) => true,
+ filter_ast::ExprFrame::Literal(_) => false,
+ })
+}
+
+fn uses_view_history(ast: &Expr<EmailLiteral>, sort_method_str: &str) -> bool {
+ sort_uses_view_history(sort_method_str) || filter_uses_view_history(ast)
+}
+
/// Pushes the `user_source_ids AS (…), SharedEmailThreads AS (…)` CTE pair
/// (without the leading `WITH` keyword and without trailing comma) into the
/// builder. Caller is responsible for emitting the `WITH` keyword and any
@@ -107,7 +122,7 @@ fn push_thread_candidate_select(
sort_ts_field: &str,
source: ThreadCandidateSource,
) {
- let defer_uh = !sort_uses_view_history(&params.sort_method_str);
+ let defer_uh = !uses_view_history(email_filter, &params.sort_method_str);
// Multi-inbox owned scans fan out one ordered, LIMITed subscan per link:
// `link_id = ANY(...)` index scans can't return ordered output (pre-PG17),
@@ -313,7 +328,7 @@ fn push_thread_candidate_select(
}
if has_thread_literals(email_filter) {
- build_thread_email_filter(email_filter, sort_ts_field).push_into(builder);
+ build_thread_email_filter(email_filter, sort_ts_field, &params.resolved).push_into(builder);
}
// Ensure the candidate LIMIT only counts threads that will survive the
@@ -413,10 +428,10 @@ fn build_query(
) -> QueryBuilder<'static, Postgres> {
let sort_ts_field = get_sort_timestamp_field(view);
let view_message_filter = build_view_message_filter(view);
- // When viewed-history isn't the sort key, the `email_user_history` join is
- // pushed past the candidate `LIMIT` so it runs once per returned row
- // instead of once per candidate thread (see `sort_uses_view_history`).
- let defer_uh = !sort_uses_view_history(&params.sort_method_str);
+ // When neither ordering nor filtering needs view history, the
+ // `email_user_history` join is pushed past the candidate `LIMIT` so it
+ // runs once per returned row instead of once per candidate thread.
+ let defer_uh = !uses_view_history(email_filter, &params.sort_method_str);
let needs_shared_cte = !matches!(params.shared, SharedEmailFilter::Exclude);
// When the candidate stage pushes a full per-message EXISTS (view-level
@@ -658,7 +673,8 @@ fn build_query(
}
if has_message_literals(email_filter) {
- build_message_email_filter(email_filter, &params.resolved).push_into(&mut builder);
+ build_message_email_filter(email_filter, &params.resolved, sort_ts_field)
+ .push_into(&mut builder);
}
builder.push(
diff --git a/crates/email/src/outbound/email_pg_repo/dynamic/tests.rs b/crates/email/src/outbound/email_pg_repo/dynamic/tests.rs
index 721e9d9e93..95d09bf0b9 100644
--- a/crates/email/src/outbound/email_pg_repo/dynamic/tests.rs
+++ b/crates/email/src/outbound/email_pg_repo/dynamic/tests.rs
@@ -35,6 +35,14 @@ fn resolved_with_random_ids(emails: &[&str]) -> ResolvedFilters {
r
}
+fn build_message_email_filter(ast: &Expr<EmailLiteral>, resolved: &ResolvedFilters) -> SqlFragment {
+ super::filters::build_message_email_filter(ast, resolved, "t.updated_at")
+}
+
+fn build_thread_email_filter(ast: &Expr<EmailLiteral>, sort_ts_field: &str) -> SqlFragment {
+ super::filters::build_thread_email_filter(ast, sort_ts_field, &ResolvedFilters::empty())
+}
+
#[test]
fn unresolved_sender_short_circuits() {
let expr = Expr::Literal(EmailLiteral::Sender(complete("[email protected]")));
@@ -278,15 +286,15 @@ fn test_notification_seen_compiles_to_thread_is_read() {
}
#[test]
-fn test_notification_seen_is_noop_in_message_filter() {
+fn test_notification_seen_is_correlated_in_message_filter() {
for seen in [true, false] {
let result = build_message_email_filter(
&Expr::Literal(EmailLiteral::NotificationSeen(seen)),
&ResolvedFilters::empty(),
);
let debug = result.to_debug_sql();
- assert!(debug.contains("TRUE"));
- assert!(!debug.contains("is_read"));
+ assert!(debug.contains("email_filter_thread.is_read"));
+ assert!(debug.contains("email_filter_thread.id = m.thread_id"));
}
}
@@ -331,15 +339,14 @@ fn test_importance_compiles_to_thread_signal_flag() {
}
#[test]
-fn test_importance_is_noop_in_message_filter() {
- // The heuristic lives in the denormalized flag now; the lateral must not
- // re-evaluate it per message.
+fn test_importance_is_correlated_to_thread_signal_flag_in_message_filter() {
for imp in [true, false] {
let result = build_message_email_filter(
&Expr::Literal(EmailLiteral::Importance(imp)),
&ResolvedFilters::empty(),
);
let debug = result.to_debug_sql();
+ assert!(debug.contains("email_filter_thread.is_signal"));
assert!(!debug.contains("email_filters"));
assert!(!debug.contains("CATEGORY"));
assert!(!debug.contains("is_important"));
@@ -783,6 +790,34 @@ fn test_build_query_defers_user_history_join_for_updated_at_sort() {
assert!(sql.contains("uh.updated_at AS viewed_at"));
}
+#[test]
+fn test_viewed_at_filter_keeps_user_history_join_inline_for_updated_sort() {
+ use chrono::TimeZone;
+ use item_filters::ast::date::DateLiteral;
+
+ let view = PreviewView::StandardLabel(PreviewViewStandardLabel::Sent);
+ let dt = chrono::Utc.with_ymd_and_hms(2024, 3, 1, 0, 0, 0).unwrap();
+ let expr = Expr::Literal(EmailLiteral::ViewedAt(DateLiteral::GreaterThanOrEqual(dt)));
+ let sql = super::query::debug_build_query_sql_with_sort(
+ &view,
+ &expr,
+ models_pagination::SimpleSortMethod::UpdatedAt,
+ );
+
+ assert_eq!(
+ sql.matches("LEFT JOIN email_user_history").count(),
+ 1,
+ "viewed_at filtering needs one inline history join: {sql}"
+ );
+ let uh_pos = sql.find("LEFT JOIN email_user_history").unwrap();
+ let el_pos = sql.find("JOIN email_links el").unwrap();
+ assert!(
+ uh_pos < el_pos,
+ "viewed_at filter must join history before the candidate filter: {sql}"
+ );
+ assert!(sql.contains("uh.updated_at >="));
+}
+
#[test]
fn test_build_query_keeps_user_history_join_inline_for_viewed_at_sort() {
let view = PreviewView::StandardLabel(PreviewViewStandardLabel::Sent);
@@ -844,47 +879,116 @@ fn test_build_thread_email_filter_multiple_thread_ids() {
}
#[test]
-fn test_build_thread_email_filter_maps_sender_to_true() {
+fn test_build_thread_email_filter_correlates_sender() {
+ let contact_id = Uuid::new_v4();
let expr = Expr::Literal(EmailLiteral::Sender(complete("[email protected]")));
- let result = build_thread_email_filter(&expr, DEFAULT_SORT_TS);
+ let resolved = resolved_with(&[("[email protected]", contact_id)]);
+ let result = super::filters::build_thread_email_filter(&expr, DEFAULT_SORT_TS, &resolved);
let debug = result.to_debug_sql();
- assert!(debug.contains("TRUE"));
- assert!(!debug.contains("t.id"));
+ assert!(debug.contains("EXISTS (SELECT 1 FROM email_messages m"));
+ assert!(debug.contains("m.thread_id = t.id"));
+ assert!(debug.contains("m.from_contact_id"));
+ assert!(result.has_bind_uuid(&contact_id));
}
#[test]
-fn test_build_message_email_filter_maps_thread_id_to_true() {
+fn test_build_message_email_filter_correlates_thread_id() {
let id = Uuid::new_v4();
let expr = Expr::Literal(EmailLiteral::ThreadId(id));
let result = build_message_email_filter(&expr, &ResolvedFilters::empty());
let debug = result.to_debug_sql();
- assert!(debug.contains("TRUE"));
- assert!(!debug.contains("t.id"));
+ assert!(debug.contains("SELECT email_filter_thread.id ="));
+ assert!(debug.contains("email_filter_thread.id = m.thread_id"));
+ assert!(result.has_bind_uuid(&id));
}
#[test]
-fn test_combined_thread_id_and_sender_splits_correctly() {
+fn test_combined_thread_id_and_sender_uses_both_predicates_at_each_level() {
let id = Uuid::new_v4();
let contact_id = Uuid::new_v4();
let expr = Expr::and(
Expr::Literal(EmailLiteral::ThreadId(id)),
Expr::Literal(EmailLiteral::Sender(complete("[email protected]"))),
);
+ let resolved = resolved_with(&[("[email protected]", contact_id)]);
- let thread_result = build_thread_email_filter(&expr, DEFAULT_SORT_TS);
+ let thread_result =
+ super::filters::build_thread_email_filter(&expr, DEFAULT_SORT_TS, &resolved);
let thread_debug = thread_result.to_debug_sql();
+ assert!(thread_debug.contains("t.id ="));
+ assert!(thread_debug.contains("m.from_contact_id"));
assert!(thread_result.has_bind_uuid(&id));
- assert!(!thread_debug.contains("from_contact_id"));
+ assert!(thread_result.has_bind_uuid(&contact_id));
- let resolved = resolved_with(&[("[email protected]", contact_id)]);
let message_result = build_message_email_filter(&expr, &resolved);
let message_debug = message_result.to_debug_sql();
- assert!(message_debug.contains("from_contact_id"));
+ assert!(message_debug.contains("email_filter_thread.id ="));
+ assert!(message_debug.contains("m.from_contact_id"));
+ assert!(message_result.has_bind_uuid(&id));
assert!(message_result.has_bind_uuid(&contact_id));
}
+#[test]
+fn test_mixed_sender_or_viewed_at_keeps_both_correlated_predicates() {
+ use chrono::TimeZone;
+ use item_filters::ast::date::DateLiteral;
+
+ let contact_id = Uuid::new_v4();
+ let cutoff = chrono::Utc.with_ymd_and_hms(2024, 3, 1, 0, 0, 0).unwrap();
+ let expr = Expr::or(
+ Expr::Literal(EmailLiteral::Sender(complete("[email protected]"))),
+ Expr::Literal(EmailLiteral::ViewedAt(DateLiteral::GreaterThanOrEqual(
+ cutoff,
+ ))),
+ );
+ let resolved = resolved_with(&[("[email protected]", contact_id)]);
+
+ let thread = super::filters::build_thread_email_filter(&expr, DEFAULT_SORT_TS, &resolved);
+ let thread_sql = thread.to_debug_sql();
+ assert!(thread_sql.contains("EXISTS (SELECT 1 FROM email_messages m"));
+ assert!(thread_sql.contains("m.from_contact_id"));
+ assert!(thread_sql.contains("OR uh.updated_at >="));
+ assert!(thread.has_bind_uuid(&contact_id));
+
+ let message = build_message_email_filter(&expr, &resolved);
+ let message_sql = message.to_debug_sql();
+ assert!(message_sql.contains("m.from_contact_id"));
+ assert!(message_sql.contains("OR (SELECT email_filter_history.updated_at >="));
+ assert!(message_sql.contains("email_filter_thread.id = m.thread_id"));
+ assert!(message.has_bind_uuid(&contact_id));
+}
+
+#[test]
+fn test_mixed_not_sender_or_viewed_at_keeps_both_correlated_predicates() {
+ use chrono::TimeZone;
+ use item_filters::ast::date::DateLiteral;
+
+ let contact_id = Uuid::new_v4();
+ let cutoff = chrono::Utc.with_ymd_and_hms(2024, 3, 1, 0, 0, 0).unwrap();
+ let expr = Expr::is_not(Expr::or(
+ Expr::Literal(EmailLiteral::Sender(complete("[email protected]"))),
+ Expr::Literal(EmailLiteral::ViewedAt(DateLiteral::GreaterThanOrEqual(
+ cutoff,
+ ))),
+ ));
+ let resolved = resolved_with(&[("[email protected]", contact_id)]);
+
+ let thread = super::filters::build_thread_email_filter(&expr, DEFAULT_SORT_TS, &resolved);
+ let thread_sql = thread.to_debug_sql();
+ assert!(thread_sql.contains("(NOT ("));
+ assert!(thread_sql.contains("m.from_contact_id"));
+ assert!(thread_sql.contains("uh.updated_at >="));
+
+ let message = build_message_email_filter(&expr, &resolved);
+ let message_sql = message.to_debug_sql();
+ assert!(message_sql.contains("(NOT ("));
+ assert!(message_sql.contains("m.from_contact_id"));
+ assert!(message_sql.contains("email_filter_history.updated_at >="));
+ assert!(message_sql.contains("email_filter_thread.id = m.thread_id"));
+}
+
#[test]
fn test_has_thread_literals_true_when_thread_id_present() {
let id = Uuid::new_v4();
@@ -950,13 +1054,14 @@ fn test_build_thread_email_filter_multiple_project_ids() {
}
#[test]
-fn test_build_message_email_filter_maps_project_id_to_true() {
+fn test_build_message_email_filter_correlates_project_id() {
let expr = Expr::Literal(EmailLiteral::ProjectId("project-123".to_string()));
let result = build_message_email_filter(&expr, &ResolvedFilters::empty());
let debug = result.to_debug_sql();
- assert!(debug.contains("TRUE"));
- assert!(!debug.contains("project_id"));
+ assert!(debug.contains("email_filter_thread.project_id ="));
+ assert!(debug.contains("email_filter_thread.id = m.thread_id"));
+ assert!(result.has_bind_string("project-123"));
}
#[test]
@@ -972,25 +1077,28 @@ fn test_has_message_literals_false_when_only_project_id() {
}
#[test]
-fn test_combined_project_id_and_sender_splits_correctly() {
+fn test_combined_project_id_and_sender_uses_both_predicates_at_each_level() {
let contact_id = Uuid::new_v4();
let expr = Expr::and(
Expr::Literal(EmailLiteral::ProjectId("project-123".to_string())),
Expr::Literal(EmailLiteral::Sender(complete("[email protected]"))),
);
+ let resolved = resolved_with(&[("[email protected]", contact_id)]);
- let thread_result = build_thread_email_filter(&expr, DEFAULT_SORT_TS);
+ let thread_result =
+ super::filters::build_thread_email_filter(&expr, DEFAULT_SORT_TS, &resolved);
let thread_debug = thread_result.to_debug_sql();
assert!(thread_debug.contains("t.project_id = "));
+ assert!(thread_debug.contains("m.from_contact_id"));
assert!(thread_result.has_bind_string("project-123"));
- assert!(!thread_debug.contains("from_contact_id"));
+ assert!(thread_result.has_bind_uuid(&contact_id));
- let resolved = resolved_with(&[("[email protected]", contact_id)]);
let message_result = build_message_email_filter(&expr, &resolved);
let message_debug = message_result.to_debug_sql();
- assert!(message_debug.contains("from_contact_id"));
+ assert!(message_debug.contains("email_filter_thread.project_id ="));
+ assert!(message_debug.contains("m.from_contact_id"));
assert!(message_result.has_bind_uuid(&contact_id));
- assert!(!message_result.has_bind_string("project-123"));
+ assert!(message_result.has_bind_string("project-123"));
}
#[test]
@@ -1523,12 +1631,13 @@ fn test_build_thread_email_filter_calendar_only_false_maps_to_true() {
}
#[test]
-fn test_build_message_email_filter_maps_calendar_only_to_true() {
+fn test_build_message_email_filter_correlates_calendar_only() {
let expr = Expr::Literal(EmailLiteral::CalendarOnly(true));
let result = build_message_email_filter(&expr, &ResolvedFilters::empty());
let debug = result.to_debug_sql();
- assert!(debug.contains("TRUE"));
+ assert!(debug.contains("email_filter_thread.has_calendar_attachment"));
+ assert!(debug.contains("email_filter_thread.id = m.thread_id"));
assert!(!debug.contains("email_attachments"));
}
@@ -1618,6 +1727,22 @@ fn test_has_thread_literals_true_when_created_at_present() {
assert!(has_thread_literals(&expr));
}
+#[test]
+fn test_build_thread_email_filter_viewed_at_uses_user_history_timestamp() {
+ use chrono::TimeZone;
+ use item_filters::ast::date::DateLiteral;
+
+ let dt = chrono::Utc.with_ymd_and_hms(2024, 3, 1, 0, 0, 0).unwrap();
+ let expr = Expr::Literal(EmailLiteral::ViewedAt(DateLiteral::GreaterThanOrEqual(dt)));
+ let result = build_thread_email_filter(&expr, DEFAULT_SORT_TS);
+ let debug = result.to_debug_sql();
+
+ assert!(debug.contains("uh.updated_at >="));
+ assert!(debug.contains("2024-03-01"));
+ assert!(has_thread_literals(&expr));
+ assert!(!has_message_literals(&expr));
+}
+
#[test]
fn test_has_thread_literals_true_when_updated_at_present() {
use chrono::TimeZone;
diff --git a/crates/email/src/outbound/email_pg_repo/test/dynamic_query.rs b/crates/email/src/outbound/email_pg_repo/test/dynamic_query.rs
index 903dde11c0..e8abdf5827 100644
--- a/crates/email/src/outbound/email_pg_repo/test/dynamic_query.rs
+++ b/crates/email/src/outbound/email_pg_repo/test/dynamic_query.rs
@@ -838,22 +838,11 @@ async fn test_dynamic_query_with_importance_filter(pool: Pool<Postgres>) -> anyh
Ok(())
}
-// KNOWN LIMITATION (pinned, not desired): an OR mixing a message-level
-// literal (Sender) with a thread-level literal (Importance) broadens to
-// match-everything. The thread stage maps Sender to TRUE and the lateral
-// maps Importance to TRUE, so `(TRUE OR t.is_signal)` / `(sender OR TRUE)`
-// both collapse. The correct result here would be the 6 signal threads
-// (john's threads 1/2/5 are all signal), but noise threads 6 and 7 leak in.
-// This predates the is_signal flip for every other thread-level literal
-// (CalendarOnly, ProjectId, dates); Importance joined the risk surface when
-// it moved thread-level. The FE and AI toolset only emit AND-shaped
-// importance filters, so no caller hits this today. If this test starts
-// failing with 6, cross-level OR was fixed — delete this test with joy.
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../../../fixtures", scripts("email_dynamic_query"))
)]
-async fn test_mixed_or_sender_importance_broadens_known_limitation(
+async fn test_mixed_or_sender_importance_preserves_both_branches(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
sync_all_signal_flags(&pool).await?;
@@ -876,11 +865,11 @@ async fn test_mixed_or_sender_importance_broadens_known_limitation(
let result_ids: std::collections::HashSet<String> =
results.iter().map(|r| r.id.to_string()).collect();
- // Broadened: every thread with a surfaceable message (1-8), including
- // noise threads 6 and 7 that match neither OR branch.
- assert_eq!(results.len(), 8, "mixed OR currently broadens to all");
- assert!(result_ids.contains("20000006-0000-0000-0000-000000000006"));
- assert!(result_ids.contains("20000007-0000-0000-0000-000000000007"));
+ // Threads 6 and 7 match neither branch. The other six surfaceable
+ // threads are signal threads, including all three John threads.
+ assert_eq!(results.len(), 6, "mixed OR must preserve both predicates");
+ assert!(!result_ids.contains("20000006-0000-0000-0000-000000000006"));
+ assert!(!result_ids.contains("20000007-0000-0000-0000-000000000007"));
Ok(())
}
@@ -2820,6 +2809,120 @@ async fn test_viewed_at_sort_orders_by_view_history(pool: Pool<Postgres>) -> any
Ok(())
}
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../../fixtures", scripts("email_dynamic_query"))
+)]
+async fn test_viewed_at_filter_uses_view_history_with_updated_sort(
+ pool: Pool<Postgres>,
+) -> anyhow::Result<()> {
+ use item_filters::ast::date::DateLiteral;
+
+ let link_id = Uuid::parse_str("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")?;
+ let cutoff = Utc.with_ymd_and_hms(2024, 5, 15, 0, 0, 0).unwrap();
+ let viewed_7 = Utc.with_ymd_and_hms(2024, 6, 1, 0, 0, 0).unwrap();
+ let viewed_4 = Utc.with_ymd_and_hms(2024, 5, 1, 0, 0, 0).unwrap();
+ record_view(&pool, link_id, THREAD_7, viewed_7).await?;
+ record_view(&pool, link_id, THREAD_4, viewed_4).await?;
+
+ let view = PreviewView::StandardLabel(PreviewViewStandardLabel::Inbox);
+ let filter = Arc::new(Expr::Literal(EmailLiteral::ViewedAt(
+ DateLiteral::GreaterThanOrEqual(cutoff),
+ )));
+ let results = dynamic::dynamic_email_thread_cursor(
+ &pool,
+ &[link_id],
+ 50,
+ &view,
+ Query::new(None, SimpleSortMethod::UpdatedAt, filter),
+ "",
+ None,
+ )
+ .await?;
+
+ let ids: Vec<String> = results.iter().map(|row| row.id.to_string()).collect();
+ assert_eq!(ids, vec![THREAD_7.to_string()]);
+ assert_eq!(results[0].viewed_at, Some(viewed_7));
+
+ Ok(())
+}
+
+#[sqlx::test(
+ migrator = "MACRO_DB_MIGRATIONS",
+ fixtures(path = "../../../../fixtures", scripts("email_dynamic_query"))
+)]
+async fn test_mixed_sender_or_viewed_at_and_not_preserve_semantics(
+ pool: Pool<Postgres>,
+) -> anyhow::Result<()> {
+ use item_filters::ast::date::DateLiteral;
+
+ let link_id = Uuid::parse_str("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")?;
+ let cutoff = Utc.with_ymd_and_hms(2024, 5, 15, 0, 0, 0).unwrap();
+ let older_view = Utc.with_ymd_and_hms(2024, 5, 1, 0, 0, 0).unwrap();
+ let recent_view = Utc.with_ymd_and_hms(2024, 6, 1, 0, 0, 0).unwrap();
+ for thread_id in [THREAD_1, THREAD_4, THREAD_5] {
+ record_view(&pool, link_id, thread_id, older_view).await?;
+ }
+ record_view(&pool, link_id, THREAD_7, recent_view).await?;
+
+ let sender_or_viewed = Expr::or(
+ Expr::Literal(EmailLiteral::Sender(Email::Complete(
+ EmailStr::parse_from_str("[email protected]")?.into_owned(),
+ ))),
+ Expr::Literal(EmailLiteral::ViewedAt(DateLiteral::GreaterThanOrEqual(
+ cutoff,
+ ))),
+ );
+ let view = PreviewView::StandardLabel(PreviewViewStandardLabel::Inbox);
+ let results = dynamic::dynamic_email_thread_cursor(
+ &pool,
+ &[link_id],
+ 50,
+ &view,
+ Query::new(
+ None,
+ SimpleSortMethod::UpdatedAt,
+ Arc::new(sender_or_viewed.clone()),
+ ),
+ "",
+ None,
+ )
+ .await?;
+ let ids: std::collections::HashSet<String> =
+ results.iter().map(|row| row.id.to_string()).collect();
+ assert_eq!(
+ ids,
+ [THREAD_1, THREAD_5, THREAD_7]
+ .into_iter()
+ .map(str::to_string)
+ .collect(),
+ "OR must include John threads and the recently viewed Jane thread"
+ );
+
+ let results = dynamic::dynamic_email_thread_cursor(
+ &pool,
+ &[link_id],
+ 50,
+ &view,
+ Query::new(
+ None,
+ SimpleSortMethod::UpdatedAt,
+ Arc::new(Expr::is_not(sender_or_viewed)),
+ ),
+ "",
+ None,
+ )
+ .await?;
+ let ids: Vec<String> = results.iter().map(|row| row.id.to_string()).collect();
+ assert_eq!(
+ ids,
+ vec![THREAD_4.to_string()],
+ "NOT must exclude every message matching either inner branch"
+ );
+
+ Ok(())
+}
+
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../../../fixtures", scripts("email_dynamic_query"))
diff --git a/crates/graphql_soup_filter_input/src/lib.rs b/crates/graphql_soup_filter_input/src/lib.rs
index 9efbc46fa5..cc9cf042d0 100644
--- a/crates/graphql_soup_filter_input/src/lib.rs
+++ b/crates/graphql_soup_filter_input/src/lib.rs
@@ -817,6 +817,8 @@ enum GraphqlEmailLiteral {
CreatedAt(GraphqlDateLiteral),
/// The updated at option.
UpdatedAt(GraphqlDateLiteral),
+ /// The per-viewer viewed at option.
+ ViewedAt(GraphqlDateLiteral),
}
impl IntoFilterExpr<EmailLiteral> for GraphqlEmailLiteral {
@@ -837,6 +839,7 @@ impl IntoFilterExpr<EmailLiteral> for GraphqlEmailLiteral {
Self::CalendarOnly(calendar_only) => EmailLiteral::CalendarOnly(calendar_only),
Self::CreatedAt(date) => EmailLiteral::CreatedAt(date.into_ast()?),
Self::UpdatedAt(date) => EmailLiteral::UpdatedAt(date.into_ast()?),
+ Self::ViewedAt(date) => EmailLiteral::ViewedAt(date.into_ast()?),
};
Ok(Expr::val(literal))
}
diff --git a/crates/item_filters/src/ast/email.rs b/crates/item_filters/src/ast/email.rs
index fdbdb9bf49..ba1d1df91c 100644
--- a/crates/item_filters/src/ast/email.rs
+++ b/crates/item_filters/src/ast/email.rs
@@ -73,6 +73,9 @@ pub enum EmailLiteral {
/// Filter by thread updated_at timestamp (view-dependent field)
#[serde(rename = "ua")]
UpdatedAt(DateLiteral),
+ /// Filter by the viewer's per-thread viewed_at timestamp.
+ #[serde(rename = "va")]
+ ViewedAt(DateLiteral),
/// Thread-level entity-property condition, checked against
/// `entity_properties` keyed on the thread id. Injected by the soup
/// service when a request carries a properties filter; never produced
diff --git a/static_assets/schema.graphql b/static_assets/schema.graphql
index 4a56d22033..f286b54385 100644
--- a/static_assets/schema.graphql
+++ b/static_assets/schema.graphql
@@ -1689,6 +1689,10 @@ input GraphqlEmailLiteral @oneOf {
The updated at option.
"""
updatedAt: GraphqlDateLiteral
+ """
+ The per-viewer viewed at option.
+ """
+ viewedAt: GraphqlDateLiteral
}
"""