Skip to content

Email for professionals and teams

fix(tracking): recognise missing tables through drizzle's wrapped errors (#182)

Kevin Kyburzc254f125ef25
diff --git a/src/app/api/domains/[id]/tracking/route.ts b/src/app/api/domains/[id]/tracking/route.ts
index 34c7bfb..e41c93c 100644
--- a/src/app/api/domains/[id]/tracking/route.ts
+++ b/src/app/api/domains/[id]/tracking/route.ts
@@ -6,6 +6,7 @@ import { hasValidSessionMutationOrigin } from "@/lib/auth/origin";
import { getDomainForUser } from "@/lib/domains/service";
import { getDomainTrackingHost, setDomainTrackingHost, TrackingHostsUnavailableError } from "@/lib/tracking/open-tracking";
import { normalizeTrackingHost } from "@/lib/tracking/open-tracking-utils";
+import { isUniqueConstraintError } from "@/lib/database-errors";
type Params = { params: Promise<{ id: string }> };
@@ -54,7 +55,7 @@ export async function PUT(request: Request, { params }: Params) {
await setDomainTrackingHost(env, id, hostname);
} catch (error) {
if (error instanceof TrackingHostsUnavailableError) return NextResponse.json(MIGRATION_REQUIRED, { status: 409 });
- if (String(error).includes("UNIQUE")) return NextResponse.json({ error: "Another domain already uses this hostname" }, { status: 409 });
+ if (isUniqueConstraintError(error)) return NextResponse.json({ error: "Another domain already uses this hostname" }, { status: 409 });
throw error;
}
return NextResponse.json({ hostname, available: true });
diff --git a/src/app/api/messages/[messageId]/opens/route.ts b/src/app/api/messages/[messageId]/opens/route.ts
index a670ea6..f1e3b98 100644
--- a/src/app/api/messages/[messageId]/opens/route.ts
+++ b/src/app/api/messages/[messageId]/opens/route.ts
@@ -4,6 +4,7 @@ import { getDb } from "@/db";
import { messages } from "@/db/schema";
import { getCurrentUser } from "@/lib/auth/cookies";
import { getEnv } from "@/lib/cloudflare";
+import { isMissingTableError } from "@/lib/database-errors";
import { getMailboxAccessLevel } from "@/lib/mailboxes/access";
import { getMessageTrackingSummary } from "@/lib/tracking/open-tracking";
@@ -30,7 +31,7 @@ export async function GET(
try {
return NextResponse.json({ tracking: await getMessageTrackingSummary(env, messageId) });
} catch (error) {
- if (String(error).includes("no such table")) return NextResponse.json({ tracking: null });
+ if (isMissingTableError(error)) return NextResponse.json({ tracking: null });
throw error;
}
}
diff --git a/src/lib/database-errors.ts b/src/lib/database-errors.ts
new file mode 100644
index 0000000..dd9cab2
--- /dev/null
+++ b/src/lib/database-errors.ts
@@ -0,0 +1,25 @@
+/**
+ * Whether any error in the chain has a message matching `pattern`. Drizzle
+ * wraps driver errors as "Failed query: …" and keeps the SQLite message on
+ * `cause`, so checking only the outer message misses it.
+ */
+function errorChainMatches(error: unknown, pattern: RegExp): boolean {
+ let current: unknown = error;
+ const visited = new Set<unknown>();
+ while (current && !visited.has(current)) {
+ visited.add(current);
+ if (pattern.test(current instanceof Error ? current.message : String(current))) return true;
+ if (typeof current !== "object" || !("cause" in current)) break;
+ current = (current as { cause?: unknown }).cause;
+ }
+ return false;
+}
+
+/** The table does not exist yet, for features whose migration may not be applied. */
+export function isMissingTableError(error: unknown): boolean {
+ return errorChainMatches(error, /no such table/i);
+}
+
+export function isUniqueConstraintError(error: unknown): boolean {
+ return errorChainMatches(error, /UNIQUE constraint failed/i);
+}
diff --git a/src/lib/tracking/open-tracking.ts b/src/lib/tracking/open-tracking.ts
index d97aac2..7b4e4ab 100644
--- a/src/lib/tracking/open-tracking.ts
+++ b/src/lib/tracking/open-tracking.ts
@@ -5,6 +5,7 @@ import { domains, domainTrackingHosts, messageOpens, messageTracking, messages }
import { newId } from "@/lib/ids";
import { classifyOpen, createTrackingToken, isDuplicateOpen, MAX_STORED_OPENS } from "./open-tracking-utils";
import type { MessageTrackingSummary } from "./types";
+import { isMissingTableError } from "@/lib/database-errors";
/** Returns the message's pixel token, creating it on the first delivery attempt. */
export async function ensureTrackingToken(env: CloudflareEnv, messageId: string): Promise<string> {
@@ -96,15 +97,11 @@ export async function getOpenCounts(env: CloudflareEnv, messageIds: string[]): P
for (const row of rows) counts.set(row.messageId, row.openCount);
} catch (error) {
// Lists keep working before migration 0068 is applied.
- if (!isMissingTable(error)) throw error;
+ if (!isMissingTableError(error)) throw error;
}
return counts;
}
-function isMissingTable(error: unknown): boolean {
- return String(error).includes("no such table");
-}
-
/** The pixel hostname configured for the sender's domain, if any. */
export async function getTrackingHostForSender(env: CloudflareEnv, from: string): Promise<string | null> {
const domain = getEmailAddress(from).split("@")[1]?.toLowerCase();
@@ -118,7 +115,7 @@ export async function getTrackingHostForSender(env: CloudflareEnv, from: string)
.limit(1);
return row?.hostname ?? null;
} catch (error) {
- if (isMissingTable(error)) return null;
+ if (isMissingTableError(error)) return null;
throw error;
}
}
@@ -133,7 +130,7 @@ export async function getDomainTrackingHost(env: CloudflareEnv, domainId: string
.limit(1);
return row?.hostname ?? null;
} catch (error) {
- if (isMissingTable(error)) throw new TrackingHostsUnavailableError();
+ if (isMissingTableError(error)) throw new TrackingHostsUnavailableError();
throw error;
}
}
@@ -150,7 +147,7 @@ export async function setDomainTrackingHost(env: CloudflareEnv, domainId: string
.values({ domainId, hostname })
.onConflictDoUpdate({ target: domainTrackingHosts.domainId, set: { hostname } });
} catch (error) {
- if (isMissingTable(error)) throw new TrackingHostsUnavailableError();
+ if (isMissingTableError(error)) throw new TrackingHostsUnavailableError();
throw error;
}
}
diff --git a/tests/database-errors.test.mjs b/tests/database-errors.test.mjs
new file mode 100644
index 0000000..c19c780
--- /dev/null
+++ b/tests/database-errors.test.mjs
@@ -0,0 +1,48 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+import test, { after } from "node:test";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { build } from "esbuild";
+
+const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+const outDir = mkdtempSync(join(root, "tests", ".tmp-database-errors-"));
+after(() => rmSync(outDir, { recursive: true, force: true }));
+
+await build({
+ entryPoints: {
+ errors: join(root, "src/lib/database-errors.ts"),
+ tracking: join(root, "src/lib/tracking/open-tracking.ts"),
+ database: join(root, "server/runtime/sqlite-database.ts"),
+ },
+ outdir: outDir,
+ outExtension: { ".js": ".mjs" },
+ bundle: true,
+ platform: "node",
+ format: "esm",
+ target: "node22",
+ tsconfig: join(root, "tsconfig.json"),
+ external: ["better-sqlite3", "drizzle-orm", "drizzle-orm/*"],
+ logLevel: "silent",
+});
+
+const load = (name) => import(pathToFileURL(join(outDir, `${name}.mjs`)).href);
+const { isMissingTableError, isUniqueConstraintError } = await load("errors");
+const { getOpenCounts } = await load("tracking");
+const { SqliteDatabase } = await load("database");
+
+test("driver errors are found through drizzle's wrapper", () => {
+ const wrapped = new Error("Failed query: select 1\nparams: ", { cause: new Error("no such table: message_tracking") });
+ assert.equal(isMissingTableError(wrapped), true);
+ assert.equal(isMissingTableError(new Error("D1_ERROR: no such table: x: SQLITE_ERROR")), true);
+ assert.equal(isMissingTableError(new Error("Failed query", { cause: new Error("database is locked") })), false);
+ assert.equal(isUniqueConstraintError(new Error("Failed query", { cause: new Error("UNIQUE constraint failed: domain_tracking_hosts.hostname") })), true);
+ assert.equal(isUniqueConstraintError(new Error("no such table")), false);
+});
+
+test("message lists with sent mail keep working before migration 0068", async (t) => {
+ const database = new SqliteDatabase(join(outDir, "empty.sqlite"));
+ t.after(() => database.db.close());
+ const counts = await getOpenCounts({ DB: database }, ["m1"]);
+ assert.equal(counts.size, 0);
+});