@remit/drizzle-service 0.0.75 → 0.0.77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.75",
+  "version": "0.0.77",
   "description": "Drizzle ORM service over SQLite",
   "type": "module",
   "main": "src/index.ts",
@@ -9,6 +9,10 @@
     ".": {
       "types": "./src/index.ts",
       "default": "./src/index.ts"
+    },
+    "./test-sqlite": {
+      "types": "./src/test-sqlite.ts",
+      "default": "./src/test-sqlite.ts"
     }
   },
   "scripts": {

package/src/repair/thread-message-category-contract.ts

@@ -470,7 +470,7 @@ export const describeRepairContract = (
 				"ahead:",
 				"fan-out:",
 				"orphans:",
-				"not-yet-classified:",
+				"uncategorized:",
 				"divergent per mailbox:",
 				"category tally:",
 			]) {

package/src/repair/thread-message-category.ts

@@ -53,10 +53,9 @@
  *     `message.category` is still `uncategorized`, so the pending exclusion
  *     above refuses the row outright.
  *
- * Only the fourth is interesting, and it is not impossible. It is unreachable
- * through `backfillClassification`, which returns early once the category is
- * decided. It is reachable through the primary path, which is re-enterable: the
- * skip guard is `if (message.bodyStorageKey && !force)` (`body-sync.ts`), and
+ * Only the fourth is interesting, and it is not impossible. It is reachable
+ * through the one path that classifies, which is re-enterable: the skip guard
+ * is `if (hasStoredBody(message.bodyStorageKey) && !force)` (`body-sync.ts`), and
  * `force` is a live event flag — the read-miss re-arm cue, resolved in the
  * imap-worker's `sync-message-body.ts`. A forced re-fetch re-runs
  * `classifyByHeaders` over the same bytes, so it normally rewrites the value it
@@ -351,7 +350,7 @@ export const formatCheckReport = (
 	`  ahead: ${report.ahead} ${plural(report.ahead)} classified against a pending message — after #326 body-sync writes the row before the message, so this is a classification in flight. Not repaired: pushing it back to pending would undo a correct classification and serve Unclassified for mail that is already classified. Expected non-zero on a live instance mid-sync, zero on a quiescent one.`,
 	`fan-out: ${report.fanOutMessages} messages holding ${report.fanOutRows} thread_message rows — the multi-row shape #326 hardens against. Expected zero: deriveMessageId and deriveThreadMessageId are both mailbox-independent, so a message in two mailboxes collapses to one row, and the reachable case is thread-root drift.`,
 	`orphans: ${report.orphanRows} ${plural(report.orphanRows)} with no message row — not repaired, nothing to copy. Expected zero.`,
-	`not-yet-classified: ${report.notYetClassified} ${plural(report.notYetClassified)} pending against a pending message — not classified yet. Not a defect, not touched by the repair, and unchanged by it. Expected non-zero on a live instance.`,
+	`uncategorized: ${report.notYetClassified} ${plural(report.notYetClassified)} uncategorized against an uncategorized message — the row agrees with its message, so there is nothing to repair and this figure is untouched by the repair. It is NOT the same as "not classified yet": it mixes mail the classifier has not reached with mail it reached and had nothing to say about. Only \`message.classification_state\` separates them (\`SELECT classification_state, count(*) FROM message WHERE category = 'uncategorized' GROUP BY 1\`), and a large \`NotExamined\` count is the cohort worth acting on. Expected non-zero on a live instance.`,
 	`divergent per mailbox: ${
 		report.divergentByMailbox.length === 0
 			? "none"

package/src/repos/i4-account.ts

@@ -19,6 +19,17 @@ import { rowToMailbox } from "./i4-mailbox.js";
 
 type DB = Db<Record<string, unknown>>;
 
+/**
+ * A stored failure is a sentence the account card shows, not a transcript.
+ * Long enough for what a mail server says when it refuses, short enough that a
+ * chatty one — or a stack-carrying `Error.message` from a sync — cannot fill the
+ * column. Clamped here so every writer is bounded, whatever it hands over.
+ */
+const LAST_ERROR_MAX_LENGTH = 500;
+
+const clampLastError = (value: string | undefined): string | undefined =>
+	value === undefined ? undefined : value.slice(0, LAST_ERROR_MAX_LENGTH);
+
 export function rowToAccount(
 	row: typeof accountTable.$inferSelect,
 ): AccountItem {
@@ -88,7 +99,7 @@ export class AccountRepo implements IAccountRepository {
 				connectionState: input.connectionState,
 				lastConnectedAt: input.lastConnectedAt,
 				lastSyncAt: input.lastSyncAt,
-				lastError: input.lastError,
+				lastError: clampLastError(input.lastError),
 				syncPhase: input.syncPhase,
 				mailboxCountTotal: input.mailboxCountTotal,
 				mailboxCountSynced: input.mailboxCountSynced,
@@ -159,7 +170,8 @@ export class AccountRepo implements IAccountRepository {
 		if (input.lastConnectedAt !== undefined)
 			updates.lastConnectedAt = input.lastConnectedAt;
 		if (input.lastSyncAt !== undefined) updates.lastSyncAt = input.lastSyncAt;
-		if (input.lastError !== undefined) updates.lastError = input.lastError;
+		if (input.lastError !== undefined)
+			updates.lastError = clampLastError(input.lastError);
 		if (input.syncPhase !== undefined) updates.syncPhase = input.syncPhase;
 		if (input.mailboxCountTotal !== undefined)
 			updates.mailboxCountTotal = input.mailboxCountTotal;

package/src/repos/message.ts

@@ -59,6 +59,7 @@ function toMessageItem(row: typeof messageTable.$inferSelect): MessageItem {
 		status: row.status,
 		syncStatus: row.syncStatus,
 		category: row.category,
+		classificationState: row.classificationState,
 		authenticityVerdict: row.authenticityVerdict,
 		hasListUnsubscribe: row.hasListUnsubscribe,
 		movedByRemit: row.movedByRemit,
@@ -185,6 +186,8 @@ export class DrizzleMessageRepository implements IMessageRepository {
 			status: input.status ?? ("active" as const),
 			syncStatus: input.syncStatus ?? ("pending" as const),
 			category: input.category ?? ("uncategorized" as const),
+			classificationState:
+				input.classificationState ?? ("NotExamined" as const),
 			authenticityVerdict:
 				input.authenticityVerdict ?? ("NotEvaluated" as const),
 			hasListUnsubscribe: input.hasListUnsubscribe ?? false,
@@ -368,6 +371,9 @@ export class DrizzleMessageRepository implements IMessageRepository {
 				? { syncStatus: input.syncStatus }
 				: {}),
 			...(input.category !== undefined ? { category: input.category } : {}),
+			...(input.classificationState !== undefined
+				? { classificationState: input.classificationState }
+				: {}),
 			...(input.authenticityVerdict !== undefined
 				? { authenticityVerdict: input.authenticityVerdict }
 				: {}),

package/src/test-sqlite.ts

@@ -0,0 +1,39 @@
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import type { Db } from "./db.js";
+import {
+	applyMigration,
+	migrationJournal,
+} from "./test-shipped-sqlite-schema.js";
+
+/**
+ * The store a test runs against: the committed SQLite entity migrations, in the
+ * order the migrator runs them, over the same engine a self-host deployment
+ * boots. Applying the shipped DDL rather than pushing the drizzle table objects
+ * is the point — a test then fails when the two drift (reader#73).
+ */
+export const applyShippedMigrations = (sqlite: Database.Database): void => {
+	for (const entry of [...migrationJournal()].sort(
+		(left, right) => left.idx - right.idx,
+	)) {
+		applyMigration(sqlite, entry.tag);
+	}
+};
+
+/**
+ * A migrated in-memory database and a drizzle handle over it, for a test that
+ * wants one repo and no file to clean up.
+ */
+export const createShippedSqliteDb = (): {
+	db: Db<Record<string, unknown>>;
+	sqlite: Database.Database;
+	close: () => void;
+} => {
+	const sqlite = new Database(":memory:");
+	applyShippedMigrations(sqlite);
+	return {
+		db: drizzle(sqlite) as unknown as Db<Record<string, unknown>>,
+		sqlite,
+		close: () => sqlite.close(),
+	};
+};