Skip to content

Postgres #731

Open
Open
Postgres#731

Description

@ngoiyaeric
ngoiyaeric
opened on Jul 11, 2026

The system is not retrieving the usrr chats and displaying them back to the user when they are clicked on. Thoroughly debug this such chat save chat works perfectly.

Activity

  1. ngoiyaeric commented on Jul 11, 2026

    @ngoiyaeric
    ngoiyaeric
    on Jul 11, 2026
    CollaboratorAuthor

    @coderabbitai plan

  2. coderabbitai commented on Jul 11, 2026

    @coderabbitai
    coderabbitaibot
    on Jul 11, 2026 – with coderabbitai
    Contributor

    Coding Plan

    Summary

    • Debug and harden the save lifecycle first: instrument every save attempt, fix the save-trigger guard that skips turns, verify upsert/conflict/ordering behavior, and surface failed writes instead of reporting silent success.
    • Add type/name columns to the messages table and thread them through the save path, so the UI-rendering discriminators are no longer lost on persistence. Rehydrate them in app/search/[id]/page.tsx, so loaded chats render correctly.
    • Add explicit verification (DB row count and ordered message ids matched against the in-memory conversation) and regression tests for duplicate ids, concurrent saves, and the final save after streaming, plus enumerated end-to-end test scenarios.
    • Harden the renderer and filter, fix the anonymous-user UUID lookup, improve retrieval error visibility, and separately resolve the calendar-notes Date-serialization TypeError.
    Design Choices
    Design Choice 1: How to recover the lost `type`/`name` message metadata on load

    Options Considered:

    1. Persist type and name as new columns on the messages table, write them on save, and read them on load.
    2. Derive type at load time from role and content-shape parsing, with no schema change.

    Chosen Option: 1

    Rationale: Persisting the discriminator is lossless. It matches how the data is produced. It avoids brittle content parsing that could misclassify tool, related, followup, or resolution messages.

    💡 User Tips

    Regenerate the plan with different choices with @coderabbitai <feedback>.

    Implementation Steps

    Phase 1: Debug and Harden the Save Lifecycle

    This phase has the highest priority. It instruments and verifies the save path before any schema or UI changes. It makes save failures observable instead of silent. It covers AI state update timing, streaming and completion behavior, the save-trigger guard, saveChat mapping, upsert/conflict/ordering behavior, and transactional integrity.

    Task 1: Instrument every save attempt

    Make each save attempt observable end to end.

    • Update onSetAIState in app/actions.tsx to log each save attempt with structured context: chat id, resolved user id, total message count, per-message id and type, and the trigger state (which submit branch produced the turn).
    • Update saveChat in lib/actions/chat.ts and the low-level saveChat in lib/actions/chat-db.ts to log the number of chat rows and message rows actually inserted or updated (report rows affected from the Drizzle result).
    • Log at the boundary between the in-memory AIState.messages and the mapped NewMessage[], so a mismatch in count or id set is visible in logs.
    Task 2: Fix the save-trigger guard that skips turns

    Ensure turns without a response-type message still persist.

    • Review the early-return guard in onSetAIState (app/actions.tsx): if (!state.messages.some(e => e.type === 'response')) return.
    • This guard skips saving turns that contain only resolution_search_result or definition messages, so those turns never persist.
    • Change the guard so it persists any turn that adds new user or assistant messages, not only turns that contain a response-type message. Keep skipping empty or no-op states.
    Task 3: Verify upsert, conflict, and ordering behavior

    Confirm the batch upsert preserves all messages and their order.

    • Review the batch upsert in saveChat (lib/actions/chat-db.ts), including the existing id-deduplication step that reassigns a fresh crypto.randomUUID() for duplicate ids (for example, the shared groupeId used by response, related, and followup messages).
    • Confirm the insert(...).onConflictDoUpdate target and update set do not drop messages when re-saving an existing chat across multiple turns.
    • Confirm message ordering on read is deterministic: getMessagesByChatId orders by createdAt asc. Ensure createdAt is assigned per message so sibling messages that shared one groupeId retain a stable, distinct order.
    Task 4: Surface failed writes instead of reporting success

    Stop treating swallowed write errors as success.

    • Review the save transaction in saveChat (lib/actions/chat-db.ts) and its wrapper in lib/actions/chat.ts.
    • If the transaction throws, log the error with chat id and user id context and propagate a failure signal to onSetAIState instead of returning silently.
    • In onSetAIState, log any save failure with the same structured context defined in the save-attempt instrumentation task, so a failed persist is diagnosable.
    🤖 Prompt for AI agents 
    Implement debugging instrumentation and correctness fixes for the chat save
lifecycle, before any schema or UI change. Treat this as the highest-priority
phase.

- In `app/actions.tsx`, update `onSetAIState` to log each save attempt with
structured context: chat id, resolved user id, total message count, per-message
id and `type`, and the trigger state (which `submit` branch produced the turn).
- In `lib/actions/chat.ts` and `lib/actions/chat-db.ts`, update both `saveChat`
functions to log the number of chat rows and message rows actually inserted or
updated, using the rows-affected result from Drizzle.
- Add logging at the boundary between the in-memory `AIState.messages` and the
mapped `NewMessage[]`, so a mismatch in count or id set is visible in logs.
- In `app/actions.tsx`, fix the early-return guard in `onSetAIState` (`if
(!state.messages.some(e => e.type === 'response')) return`). This guard
currently skips saving turns that contain only `resolution_search_result` or
`definition` messages. Change it to persist any turn that adds new user or
assistant messages, not only turns containing a `response`-type message.
Continue to skip empty or no-op states.
- In `lib/actions/chat-db.ts`, review the batch upsert in `saveChat`, including
the id-deduplication step that reassigns a fresh `crypto.randomUUID()` for
duplicate ids (for example, the shared `groupeId` used by
`response`/`related`/`followup` messages). Confirm the
`insert(...).onConflictDoUpdate` target and update set do not drop messages on
re-save across multiple turns. Confirm `getMessagesByChatId` orders by
`createdAt asc` deterministically, and ensure `createdAt` is assigned per
message so sibling messages sharing a `groupeId` retain a stable, distinct
order.
- Review the save transaction in `saveChat` (`lib/actions/chat-db.ts`) and its
wrapper in `lib/actions/chat.ts`. If the transaction throws, log the error with
chat id and user id context, and propagate a failure signal to `onSetAIState`
instead of returning silently. In `onSetAIState`, log any save failure using the
same structured context as the save-attempt instrumentation.

    Phase 2: Persist Message Rendering Metadata

    The goal of this phase is to stop losing the type/name discriminators when messages are written to Postgres. Today the save path strips these fields, making faithful reconstruction impossible. This phase introduces dedicated columns and threads the values through the entire save path, so future chats store everything needed to re-render.

    Task 1: Extend the messages schema with `type` and `name`

    Add persistence for the fields that drive UI rendering.

    • Update lib/db/schema.ts messages table to add a nullable type text column and a nullable name text column (both optional, to remain compatible with existing rows).
    • Add a corresponding Drizzle migration under drizzle/migrations/ that adds the two columns. Keep it additive and nullable, so existing data is unaffected and no backfill is required.
    • Ensure the migration does not tighten the existing messages_role_check constraint (leave role handling as-is, per prior migration history).
    Task 2: Write `type`/`name` on the save path

    Ensure new and updated messages carry the discriminators into the DB.

    • Update saveChat in lib/actions/chat.ts to include type and name when mapping AIMessage to NewMessage (currently only id/userId/role/content/createdAt are mapped).
    • Update the low-level saveChat in lib/actions/chat-db.ts so the insert(...).onConflictDoUpdate for messages also updates the new type/name columns, so re-saves of an existing chat refresh these values.
    Task 3: Stop persisting the synthetic `end` sentinel

    Prevent transcript pollution that also complicates rendering.

    • In app/actions.tsx onSetAIState, exclude the synthetic { content: 'end', type: 'end' } marker message from the array handed to saveChat (filter it out before persisting), so it is not written into messages on every save.
    🤖 Prompt for AI agents 
    Implement persistence of the `type` and `name` message discriminators, so they
are not lost when messages are written to Postgres.

- In `lib/db/schema.ts`, add nullable `type` and `name` text columns to the
`messages` table (both optional and nullable, to remain compatible with existing
rows).
- Add a new Drizzle migration file under `drizzle/migrations/` that adds these
two columns additively as nullable, requiring no backfill of existing data. Do
not modify or tighten the existing `messages_role_check` constraint; leave role
handling unchanged.
- In `lib/actions/chat.ts`, update `saveChat` to map `type` and `name` from
`AIMessage` onto the `NewMessage` object passed to persistence (currently only
`id`/`userId`/`role`/`content`/`createdAt` are mapped).
- In `lib/actions/chat-db.ts`, update the low-level `saveChat` function's
`insert(...).onConflictDoUpdate` call for `messages` to also update the `type`
and `name` columns, so that re-saving an existing chat refreshes these values.
- In `app/actions.tsx`, in `onSetAIState`, filter out the synthetic `{ content:
'end', type: 'end' }` marker message from the array passed to `saveChat`, so
this sentinel is never written to the `messages` table.

    Phase 3: Reconstruct Full Messages on Retrieval

    With metadata now persisted, this phase makes the retrieval path rebuild complete AIMessage objects, so the AI SDK can regenerate the correct UI components for a loaded chat.

    Task 1: Map `type`/`name` when rehydrating from DB

    Restore the discriminators the renderer depends on.

    • Update app/search/[id]/page.tsx where it maps dbMessages to initialMessages, to populate type (cast to the AIMessage['type'] union) and name from the DB row, instead of leaving them undefined. Remove the outdated comment noting these fields are unavailable.
    • Confirm getChatMessages in lib/actions/chat.ts and getMessagesByChatId in lib/actions/chat-db.ts return the new columns (they select the full row, so verify the returned and typed shape includes type/name).
    Task 2: Harden `getUIStateFromAIState` against fallthrough entries

    Eliminate the latent crash and blank-render risk, once messages start reaching the switch again.

    • In app/actions.tsx getUIStateFromAIState, ensure the inner switch(type) branches for user/assistant roles cannot implicitly return undefined (add explicit return null fallbacks for unrecognized type values).
    • Update the final .filter(...) to drop both null and undefined entries, so no malformed entry can reach ChatMessages (which indexes message.id unconditionally).
    🤖 Prompt for AI agents 
    Implement rehydration of full `AIMessage` objects from the DB, so previously
persisted `type`/`name` metadata is available at render time, and harden the
rendering switch against fallthrough.

- In `app/search/[id]/page.tsx`, update the mapping from `dbMessages` to
`initialMessages` to populate `type` (cast to the `AIMessage['type']` union) and
`name` from the corresponding DB row fields, instead of leaving them
`undefined`. Remove the outdated comment stating these fields are unavailable.
- Verify that `getChatMessages` in `lib/actions/chat.ts` and
`getMessagesByChatId` in `lib/actions/chat-db.ts` return the new `type`/`name`
columns from the full row selection, and that their returned and typed shape
includes these fields.
- In `app/actions.tsx`, update `getUIStateFromAIState`: in the inner
`switch(type)` branches for `user` and `assistant` roles, add explicit `return
null` fallbacks for unrecognized `type` values, so nothing is implicitly
returned as `undefined`.
- Update the final `.filter(...)` in `getUIStateFromAIState` to drop both `null`
and `undefined` entries, ensuring no malformed entry reaches `ChatMessages`
(which indexes `message.id` unconditionally).

    Phase 4: Retrieval Robustness and Correctness Fixes

    This phase addresses adjacent retrieval-path defects surfaced during debugging that can cause "found in history but won't open" symptoms and make failures invisible.

    Task 1: Fix invalid-UUID lookup for anonymous users

    Prevent a UUID type error masquerading as "chat not found."

    • In app/search/[id]/page.tsx generateMetadata (and any similar caller), stop passing the literal string 'anonymous' into getChat. Pass the resolved user id or a falsy value instead, so the intended anonymous or public-access branch in chat-db.ts getChat (the if (!userId) path) is actually taken, instead of comparing a non-UUID string against a uuid column.
    Task 2: Make retrieval failures observable

    Distinguish genuine "empty/absent" chats from swallowed DB errors.

    • Review the silent catch blocks in lib/actions/chat.ts (getChat, getChatMessages, getChats) and lib/actions/chat-db.ts (getMessagesByChatId) that return null/[] on error. Keep graceful degradation, but ensure errors are logged with enough context (chat id, user id), so a failed retrieval is diagnosable rather than indistinguishable from an empty result.
    🤖 Prompt for AI agents 
    Fix adjacent retrieval-path defects that can cause chats to appear in history
but fail to open, and make failures observable rather than silent.

- In `app/search/[id]/page.tsx`, in `generateMetadata` (and any similar caller),
stop passing the literal string `'anonymous'` into `getChat`. Instead pass the
resolved user id or a falsy value, so that the intended anonymous or
public-access branch in `chat-db.ts` `getChat` (the `if (!userId)` path) is
correctly taken, instead of erroring by comparing a non-UUID string against a
`uuid` column.
- Review the silent catch blocks in `lib/actions/chat.ts` (`getChat`,
`getChatMessages`, `getChats`) and `lib/actions/chat-db.ts`
(`getMessagesByChatId`) that currently return `null`/`[]` on error. Keep the
graceful degradation behavior, but add logging of the error with sufficient
context (chat id, user id), so that a failed retrieval can be diagnosed and
distinguished from a genuinely empty result.

    Phase 5: Save/Retrieve Verification and Regression Testing

    This phase adds an explicit debugging and test plan. It verifies that the persisted transcript matches the in-memory conversation, and adds regression coverage for the failure modes found during debugging.

    Task 1: Add post-save verification of row count and ordered message IDs

    Confirm the DB state matches the in-memory conversation after every save.

    • After saveChat completes, read the persisted messages for the chat (getMessagesByChatId) and compare the ordered set of message ids and the row count against the in-memory AIState.messages (excluding the filtered end sentinel).
    • Log a warning with chat id and user id context if the count differs or the ordered id set differs.
    • Use this verification during debugging as a temporary or guarded check. Document how to enable it without affecting normal request latency.
    Task 2: Define and run enumerated save/retrieve test scenarios

    Cover the conversation shapes that reproduce the bug.

    • Define test scenarios and expected outcomes for: new chats, long multi-turn chats, rapid consecutive messages in one session, streamed assistant responses, browser refresh or reload of an open chat, reopening a chat from history, and anonymous versus authenticated users.
    • For each scenario, verify the round-trip: save writes the expected rows, retrieval returns them, and getUIStateFromAIState renders non-empty UIState.
    • Record where these scenarios are executed (manual checklist and/or automated tests), so the plan produces a repeatable verification procedure.
    Task 3: Add regression tests for save-lifecycle failure modes

    Prevent reintroduction of the persistence defects.

    • Add regression tests for duplicate or shared message ids on save (the groupeId case), to confirm the dedup step in chat-db.ts saveChat writes distinct rows and does not raise ON CONFLICT DO UPDATE cannot affect row a second time.
    • Add regression tests for concurrent or consecutive saves of the same chat, to confirm no messages are dropped and ordering is stable.
    • Add a regression test for the final save after streaming completes (the single aiState.done() per turn), to confirm the full cumulative history persists.
    • Place tests using any existing test setup in the repo. If none exists, add a minimal test harness under a conventional test directory, and note the chosen runner.
    🤖 Prompt for AI agents 
    Implement an explicit debugging and test plan that verifies the persisted
transcript matches the in-memory conversation, and adds regression coverage for
the save-lifecycle failure modes.

- After `saveChat` completes, read the persisted messages for the chat using
`getMessagesByChatId`, and compare the ordered set of message ids and the row
count against the in-memory `AIState.messages` (excluding the filtered `end`
sentinel). Log a warning with chat id and user id context if the count or the
ordered id set differs. Implement this verification as a temporary or guarded
check during debugging, and document how to enable it without affecting normal
request latency.
- Define test scenarios and expected outcomes for: new chats, long multi-turn
chats, rapid consecutive messages in one session, streamed assistant responses,
browser refresh or reload of an open chat, reopening a chat from history, and
anonymous versus authenticated users. For each scenario, verify the round-trip:
save writes the expected rows, retrieval returns them, and
`getUIStateFromAIState` renders a non-empty `UIState`. Record where these
scenarios are executed (manual checklist and/or automated tests).
- Add regression tests for duplicate or shared message ids on save (the
`groupeId` case), confirming the dedup step in `chat-db.ts` `saveChat` writes
distinct rows and does not raise `ON CONFLICT DO UPDATE cannot affect row a
second time`. Add regression tests for concurrent or consecutive saves of the
same chat, confirming no messages are dropped and ordering is stable. Add a
regression test for the final save after streaming completes (the single
`aiState.done()` per turn), confirming the full cumulative history persists. Use
any existing test setup in the repo; if none exists, add a minimal test harness
under a conventional test directory and note the chosen runner.

    Phase 6: Fix Date Serialization in calendar_notes Queries

    This phase addresses an incidental, adjacent bug discovered during testing: fetching calendar notes fails at the Postgres driver layer. It is kept separate from the chat persistence and retrieval fixes. getNotes in lib/actions/calendar.ts interpolates raw JS Date objects into a sql template date-range filter. Under drizzle-orm 0.45.2 and postgres.js 3.4.9, timestamp values are expected as strings on this path, so binding a Date triggers a TypeError ("The "string" argument must be of type string or an instance of Buffer or ArrayBuffer. Received an instance of Date"), which is then swallowed and returned as an empty note list.

    Task 1: Locate and confirm the date-parameter serialization issue

    Pin down the exact failing code path before changing it.

    • Confirm in lib/actions/calendar.ts getNotes that startDate/endDate (plain Date objects produced via new Date(date); setHours(...)) are interpolated directly into the raw sql\${calendarNotes.date} >= ${startDate}`/<= ${endDate}` fragments, bypassing Drizzle's column-aware value mapping.
    • Verify the calendarNotes.date column is timestamp('date', { withTimezone: true }) (timestamptz) in lib/db/schema.ts, and that lib/db/index.ts configures no custom type parsers or serializers, so binding relies on postgres.js defaults for untyped sql-template parameters.
    Task 2: Fix the Date-to-parameter conversion in `getNotes`

    Bind the date-range boundaries in a form the driver and ORM serialize correctly.

    • Update the date-range filter in lib/actions/calendar.ts getNotes to use Drizzle's column-aware comparators (gte(calendarNotes.date, startDate) / lte(calendarNotes.date, endDate), importing gte/lte from drizzle-orm), so values route through the column's typed serialization — or, if the raw sql template is retained, pass ISO strings (for example, startDate.toISOString()) instead of raw Date objects.
    • Remove the now-unnecessary nested and(sql\...`, sql`...`)composition in favor of the typed helpers, keeping the overallwhere(and(...))structure and existinguserId/chatId` conditions intact.
    Task 3: Add safeguards and logging to catch similar type-mismatch errors early

    Ensure a recurrence surfaces instead of silently returning empty results.

    • Enhance the existing catch block in lib/actions/calendar.ts getNotes (and saveNote), so the logged error includes enough context (operation name, userId, requested date or range) to make driver-level serialization failures diagnosable, rather than indistinguishable from "no notes for this day."
    • Note in the code or comment that raw sql template date interpolation should prefer Drizzle's typed comparators or explicit .toISOString() conversion, to guard against reintroducing the same Date-vs-string mismatch elsewhere.
    🤖 Prompt for AI agents 
    Fix an incidental, adjacent bug discovered during testing where fetching
calendar notes fails at the Postgres driver layer, due to a Date-vs-string
parameter mismatch. This is unrelated to the chat `type`/`name` persistence root
cause, and must be implemented as a separate, self-contained fix.

- Confirm in `lib/actions/calendar.ts` `getNotes` that `startDate`/`endDate`
(plain `Date` objects produced via `new Date(date); setHours(...)`) are
interpolated directly into raw `sql` template date-range fragments
(`sql\`${calendarNotes.date} >= ${startDate}\`` / `<= ${endDate}`), bypassing
Drizzle's column-aware value mapping. Verify the `calendarNotes.date` column is
`timestamp('date', { withTimezone: true })` (`timestamptz`) in
`lib/db/schema.ts`, and that `lib/db/index.ts` configures no custom type parsers
or serializers, so binding relies on postgres.js defaults for untyped
`sql`-template parameters.
- Update the date-range filter in `getNotes` to use Drizzle's column-aware
comparators (`gte(calendarNotes.date, startDate)` / `lte(calendarNotes.date,
endDate)`, importing `gte`/`lte` from `drizzle-orm`), so values route through
the column's typed serialization. Alternatively, if retaining the raw `sql`
template, pass ISO strings (for example, `startDate.toISOString()`) instead of
raw `Date` objects. Remove the now-unnecessary nested `and(sql\`...\`,
sql\`...\`)` composition in favor of the typed helpers, while keeping the
overall `where(and(...))` structure and existing `userId`/`chatId` conditions
intact.
- Enhance the existing `catch` block in `getNotes` (and `saveNote`) in
`lib/actions/calendar.ts`, so logged errors include enough context (operation
name, `userId`, requested date or range) to make driver-level serialization
failures diagnosable, rather than indistinguishable from "no notes for this
day." Add a note in the code or comment that raw `sql` template date
interpolation should prefer Drizzle's typed comparators or explicit
`.toISOString()` conversion, to guard against reintroducing the same
Date-vs-string mismatch elsewhere.
    Research

    The app uses the Vercel AI SDK RSC (ai/rsc) with a createAI provider defined in app/actions.tsx. Chats and messages are stored in Postgres via Drizzle (lib/db/schema.ts), with a raw query layer (lib/actions/chat-db.ts) and server-action wrappers (lib/actions/chat.ts). Saving happens in onSetAIState (app/actions.tsx), which builds a Chat object and calls saveChat. onSetAIState runs once per conversation turn (on aiState.done()) and receives the full cumulative message history.

    Retrieval happens on app/search/[id]/page.tsx, which calls getChat/getChatMessages, rebuilds AIMessage[], and seeds <AI initialAIState>. On mount, onGetUIState runs getUIStateFromAIState, which converts raw AIMessages into React components. This conversion gates on msg.type first. The type field is never stored in the messages table, so DB-loaded messages (all with type === undefined) are discarded. This produces an empty chat view with no error.

    The database is accessed through the postgres driver (postgres.js 3.4.9) wrapped by drizzle-orm 0.45.2.

    🚀 Next Steps

    🤖 All AI agent prompts combined 
    Task: 1

Implement debugging instrumentation and correctness fixes for the chat save
lifecycle, before any schema or UI change. Treat this as the highest-priority
phase.

- In `app/actions.tsx`, update `onSetAIState` to log each save attempt with
structured context: chat id, resolved user id, total message count, per-message
id and `type`, and the trigger state (which `submit` branch produced the turn).
- In `lib/actions/chat.ts` and `lib/actions/chat-db.ts`, update both `saveChat`
functions to log the number of chat rows and message rows actually inserted or
updated, using the rows-affected result from Drizzle.
- Add logging at the boundary between the in-memory `AIState.messages` and the
mapped `NewMessage[]`, so a mismatch in count or id set is visible in logs.
- In `app/actions.tsx`, fix the early-return guard in `onSetAIState` (`if
(!state.messages.some(e => e.type === 'response')) return`). This guard
currently skips saving turns that contain only `resolution_search_result` or
`definition` messages. Change it to persist any turn that adds new user or
assistant messages, not only turns containing a `response`-type message.
Continue to skip empty or no-op states.
- In `lib/actions/chat-db.ts`, review the batch upsert in `saveChat`, including
the id-deduplication step that reassigns a fresh `crypto.randomUUID()` for
duplicate ids (for example, the shared `groupeId` used by
`response`/`related`/`followup` messages). Confirm the
`insert(...).onConflictDoUpdate` target and update set do not drop messages on
re-save across multiple turns. Confirm `getMessagesByChatId` orders by
`createdAt asc` deterministically, and ensure `createdAt` is assigned per
message so sibling messages sharing a `groupeId` retain a stable, distinct
order.
- Review the save transaction in `saveChat` (`lib/actions/chat-db.ts`) and its
wrapper in `lib/actions/chat.ts`. If the transaction throws, log the error with
chat id and user id context, and propagate a failure signal to `onSetAIState`
instead of returning silently. In `onSetAIState`, log any save failure using the
same structured context as the save-attempt instrumentation.
===============================================================================

Task: 2

Implement persistence of the `type` and `name` message discriminators, so they
are not lost when messages are written to Postgres.

- In `lib/db/schema.ts`, add nullable `type` and `name` text columns to the
`messages` table (both optional and nullable, to remain compatible with existing
rows).
- Add a new Drizzle migration file under `drizzle/migrations/` that adds these
two columns additively as nullable, requiring no backfill of existing data. Do
not modify or tighten the existing `messages_role_check` constraint; leave role
handling unchanged.
- In `lib/actions/chat.ts`, update `saveChat` to map `type` and `name` from
`AIMessage` onto the `NewMessage` object passed to persistence (currently only
`id`/`userId`/`role`/`content`/`createdAt` are mapped).
- In `lib/actions/chat-db.ts`, update the low-level `saveChat` function's
`insert(...).onConflictDoUpdate` call for `messages` to also update the `type`
and `name` columns, so that re-saving an existing chat refreshes these values.
- In `app/actions.tsx`, in `onSetAIState`, filter out the synthetic `{ content:
'end', type: 'end' }` marker message from the array passed to `saveChat`, so
this sentinel is never written to the `messages` table.
===============================================================================

Task: 3

Implement rehydration of full `AIMessage` objects from the DB, so previously
persisted `type`/`name` metadata is available at render time, and harden the
rendering switch against fallthrough.

- In `app/search/[id]/page.tsx`, update the mapping from `dbMessages` to
`initialMessages` to populate `type` (cast to the `AIMessage['type']` union) and
`name` from the corresponding DB row fields, instead of leaving them
`undefined`. Remove the outdated comment stating these fields are unavailable.
- Verify that `getChatMessages` in `lib/actions/chat.ts` and
`getMessagesByChatId` in `lib/actions/chat-db.ts` return the new `type`/`name`
columns from the full row selection, and that their returned and typed shape
includes these fields.
- In `app/actions.tsx`, update `getUIStateFromAIState`: in the inner
`switch(type)` branches for `user` and `assistant` roles, add explicit `return
null` fallbacks for unrecognized `type` values, so nothing is implicitly
returned as `undefined`.
- Update the final `.filter(...)` in `getUIStateFromAIState` to drop both `null`
and `undefined` entries, ensuring no malformed entry reaches `ChatMessages`
(which indexes `message.id` unconditionally).
===============================================================================

Task: 4

Fix adjacent retrieval-path defects that can cause chats to appear in history
but fail to open, and make failures observable rather than silent.

- In `app/search/[id]/page.tsx`, in `generateMetadata` (and any similar caller),
stop passing the literal string `'anonymous'` into `getChat`. Instead pass the
resolved user id or a falsy value, so that the intended anonymous or
public-access branch in `chat-db.ts` `getChat` (the `if (!userId)` path) is
correctly taken, instead of erroring by comparing a non-UUID string against a
`uuid` column.
- Review the silent catch blocks in `lib/actions/chat.ts` (`getChat`,
`getChatMessages`, `getChats`) and `lib/actions/chat-db.ts`
(`getMessagesByChatId`) that currently return `null`/`[]` on error. Keep the
graceful degradation behavior, but add logging of the error with sufficient
context (chat id, user id), so that a failed retrieval can be diagnosed and
distinguished from a genuinely empty result.
===============================================================================

Task: 5

Implement an explicit debugging and test plan that verifies the persisted
transcript matches the in-memory conversation, and adds regression coverage for
the save-lifecycle failure modes.

- After `saveChat` completes, read the persisted messages for the chat using
`getMessagesByChatId`, and compare the ordered set of message ids and the row
count against the in-memory `AIState.messages` (excluding the filtered `end`
sentinel). Log a warning with chat id and user id context if the count or the
ordered id set differs. Implement this verification as a temporary or guarded
check during debugging, and document how to enable it without affecting normal
request latency.
- Define test scenarios and expected outcomes for: new chats, long multi-turn
chats, rapid consecutive messages in one session, streamed assistant responses,
browser refresh or reload of an open chat, reopening a chat from history, and
anonymous versus authenticated users. For each scenario, verify the round-trip:
save writes the expected rows, retrieval returns them, and
`getUIStateFromAIState` renders a non-empty `UIState`. Record where these
scenarios are executed (manual checklist and/or automated tests).
- Add regression tests for duplicate or shared message ids on save (the
`groupeId` case), confirming the dedup step in `chat-db.ts` `saveChat` writes
distinct rows and does not raise `ON CONFLICT DO UPDATE cannot affect row a
second time`. Add regression tests for concurrent or consecutive saves of the
same chat, confirming no messages are dropped and ordering is stable. Add a
regression test for the final save after streaming completes (the single
`aiState.done()` per turn), confirming the full cumulative history persists. Use
any existing test setup in the repo; if none exists, add a minimal test harness
under a conventional test directory and note the chosen runner.
===============================================================================

Task: 6

Fix an incidental, adjacent bug discovered during testing where fetching
calendar notes fails at the Postgres driver layer, due to a Date-vs-string
parameter mismatch. This is unrelated to the chat `type`/`name` persistence root
cause, and must be implemented as a separate, self-contained fix.

- Confirm in `lib/actions/calendar.ts` `getNotes` that `startDate`/`endDate`
(plain `Date` objects produced via `new Date(date); setHours(...)`) are
interpolated directly into raw `sql` template date-range fragments
(`sql\`${calendarNotes.date} >= ${startDate}\`` / `<= ${endDate}`), bypassing
Drizzle's column-aware value mapping. Verify the `calendarNotes.date` column is
`timestamp('date', { withTimezone: true })` (`timestamptz`) in
`lib/db/schema.ts`, and that `lib/db/index.ts` configures no custom type parsers
or serializers, so binding relies on postgres.js defaults for untyped
`sql`-template parameters.
- Update the date-range filter in `getNotes` to use Drizzle's column-aware
comparators (`gte(calendarNotes.date, startDate)` / `lte(calendarNotes.date,
endDate)`, importing `gte`/`lte` from `drizzle-orm`), so values route through
the column's typed serialization. Alternatively, if retaining the raw `sql`
template, pass ISO strings (for example, `startDate.toISOString()`) instead of
raw `Date` objects. Remove the now-unnecessary nested `and(sql\`...\`,
sql\`...\`)` composition in favor of the typed helpers, while keeping the
overall `where(and(...))` structure and existing `userId`/`chatId` conditions
intact.
- Enhance the existing `catch` block in `getNotes` (and `saveNote`) in
`lib/actions/calendar.ts`, so logged errors include enough context (operation
name, `userId`, requested date or range) to make driver-level serialization
failures diagnosable, rather than indistinguishable from "no notes for this
day." Add a note in the code or comment that raw `sql` template date
interpolation should prefer Drizzle's typed comparators or explicit
`.toISOString()` conversion, to guard against reintroducing the same
Date-vs-string mismatch elsewhere.
    💡 Iterate on the plan with: @coderabbitai <feedback> 
    Example Feedback
- @coderabbitai You can skip phase 3. Add a simple unit test case for phase 2.
- @coderabbitai For design choice 1 go ahead with option 3 and replan.

    💬 Have feedback or questions? Drop into our discord!

  3. ngoiyaeric commented on Jul 11, 2026

    @ngoiyaeric
    ngoiyaeric
    on Jul 11, 2026
    CollaboratorAuthor

    2026-07-11 16:29:47.102 [info] Chat DB actions loaded. Ensure getCurrentUserId() is correctly implemented for server-side usage if applicable.
    2026-07-11 16:29:47.283 [error] Error fetching notes: Error: Failed query: select "id", "user_id", "chat_id", "date", "content", "location_tags", "user_tags", "map_feature_id", "created_at", "updated_at" from "calendar_notes" where ("calendar_notes"."user_id" = $1 and ("calendar_notes"."date" >= $2 and "calendar_notes"."date" <= $3) and "calendar_notes"."chat_id" = $4) order by "calendar_notes"."created_at" desc
    params: 957edcef-6fbb-499b-bf14-2b5c9d3bdc9d,Sat Jul 11 2026 00:00:00 GMT+0000 (Coordinated Universal Time),Sat Jul 11 2026 23:59:59 GMT+0000 (Coordinated Universal Time),ae6ef7c4-7aa8-4bb9-a064-ad3b0b23c787
    at ew.queryWithCache (.next/server/chunks/4322.js:107:35097)
    at async (.next/server/chunks/4322.js:107:37585)
    at async M (.next/server/chunks/5043.js:226:1219) {
    query: 'select "id", "user_id", "chat_id", "date", "content", "location_tags", "user_tags", "map_feature_id", "created_at", "updated_at" from "calendar_notes" where ("calendar_notes"."user_id" = $1 and ("calendar_notes"."date" >= $2 and "calendar_notes"."date" <= $3) and "calendar_notes"."chat_id" = $4) order by "calendar_notes"."created_at" desc',
    params: [Array],
    [cause]: TypeError: The "string" argument must be of type string or an instance of Buffer or ArrayBuffer. Received an instance of Date
    at Function.str (.next/server/chunks/4322.js:70:79105)
    at (.next/server/chunks/4322.js:80:1817)
    at Array.forEach ()
    at tR (.next/server/chunks/4322.js:80:1688)
    at eU (.next/server/chunks/4322.js:70:82164)
    at te (.next/server/chunks/4322.js:70:88132)
    at e3 (.next/server/chunks/4322.js:70:86112)
    at Socket.eH (.next/server/chunks/4322.js:70:83833) {
    code: 'ERR_INVALID_ARG_TYPE'
    }
    }
    @coderabbitai plan

  4. coderabbitai commented on Jul 11, 2026

    @coderabbitai
    coderabbitaibot
    on Jul 11, 2026 – with coderabbitai
    Contributor

    I've updated the plan above based on your feedback. Ready to proceed when you are!

  5. ngoiyaeric commented on Aug 17, 2026

    @ngoiyaeric
    ngoiyaeric
    on Aug 17, 2026
    CollaboratorAuthor

    The system is only saving the first couple of chats and is not saving all the chats @coderabbitai

  6. coderabbitai commented on Aug 17, 2026

    @coderabbitai
    coderabbitaibot
    on Aug 17, 2026 – with coderabbitai
    Contributor

    I've updated the plan above based on your feedback. Ready to proceed when you are!

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions