Skip to content

Email for professionals and teams

Merge main into perf/navigation-cover-index

Hieu Nguyen (Jack)3728a6b776d9
diff --cc drizzle/migrations/meta/_journal.json
index f8396cb,55ae3a0..eac0164
--- a/drizzle/migrations/meta/_journal.json
+++ b/drizzle/migrations/meta/_journal.json
@@@ -460,9 -460,16 +460,23 @@@
{
"idx": 66,
"version": "6",
+ "when": 1792844400001,
+ "tag": "0074_add_counts_conversation_indexes",
+ "breakpoints": true
+ },
+ {
+ "idx": 67,
+ "version": "6",
"when": 1792848000000,
+ "tag": "0075_index_fk_columns",
+ "breakpoints": true
++ },
++ {
++ "idx": 68,
++ "version": "6",
++ "when": 1792851600000,
+ "tag": "0076_add_navigation_cover_index",
+ "breakpoints": true
}
]
}
diff --cc src/db/schema/index.ts
index 1ce7ebc,d8b9a85..3438087
--- a/src/db/schema/index.ts
+++ b/src/db/schema/index.ts
@@@ -328,17 -332,31 +332,42 @@@ export const messages = sqliteTable
t.createdAt,
),
index("messages_mailbox_thread_key_idx").on(t.mailboxId, sql`coalesce(${t.threadId}, ${t.id})`),
+ index("messages_nav_cover_idx").on(
+ t.mailboxId,
+ t.status,
+ t.folderId,
+ sql`${t.createdAt} desc`,
+ sql`${t.id} desc`,
+ t.direction,
+ t.read,
+ t.threadId,
+ t.snoozedUntil,
+ ),
+ // Covering index for the folder-counts GROUP BY: lets the counts
+ // endpoint stream grouped rows straight off the index instead of
+ // sorting the whole table.
+ index("messages_counts_cover_idx").on(
+ t.mailboxId,
+ t.folderId,
+ t.direction,
+ t.status,
+ t.read,
+ t.starred,
+ t.snoozedUntil,
+ ),
+ // Conversation paging partitions by coalesce(thread_id, id) and orders
+ // each partition by created_at desc, so the thread key must precede
+ // created_at for the index to feed the window in sorted order. The
+ // snoozed_until filter rides the tail column and never touches the
+ // table.
+ index("messages_conv_cover_idx").on(
+ t.mailboxId,
+ t.status,
+ sql`coalesce(${t.threadId}, ${t.id})`,
+ t.createdAt,
+ t.id,
+ t.snoozedUntil,
+ ),
],
);
diff --cc src/db/schema/index.ts-e
index 0000000,0000000..e58d2f7
new file mode 100644
--- /dev/null
+++ b/src/db/schema/index.ts-e
@@@ -1,0 -1,0 +1,1133 @@@
++import { sqliteTable, text, integer, index, uniqueIndex } from "drizzle-orm/sqlite-core";
++import { sql } from "drizzle-orm";
++import type { AnySQLiteColumn } from "drizzle-orm/sqlite-core";
++
++export const users = sqliteTable("users", {
++ id: text("id").primaryKey(),
++ email: text("email").notNull().unique(),
++ resetEmail: text("reset_email"),
++ forwardingEmail: text("forwarding_email"),
++ passwordHash: text("password_hash").notNull(),
++ name: text("name").notNull(),
++ bookingUsername: text("booking_username"),
++ timeZone: text("time_zone"),
++ avatarKey: text("avatar_key"),
++ role: text("role", { enum: ["admin", "user"] }).notNull().default("user"),
++ // Exactly one account is the primary admin: the one created during setup.
++ // They own administrator management and can hand the role to another account.
++ isPrimaryAdmin: integer("is_primary_admin", { mode: "boolean" }).notNull().default(false),
++ disabled: integer("disabled", { mode: "boolean" }).notNull().default(false),
++ canManageMailboxes: integer("can_manage_mailboxes", { mode: "boolean" }).notNull().default(false),
++ // Capabilities the primary admin grants to other admins.
++ canManageDomains: integer("can_manage_domains", { mode: "boolean" }).notNull().default(false),
++ canManageUsers: integer("can_manage_users", { mode: "boolean" }).notNull().default(false),
++ keyboardShortcutsEnabled: integer("keyboard_shortcuts_enabled", { mode: "boolean" }).notNull().default(true),
++ spamProtectionEnabled: integer("spam_protection_enabled", { mode: "boolean" }).notNull().default(true),
++ /** Days a message may stay in Trash or Spam before the scheduled purge deletes it; null keeps it forever. */
++ trashRetentionDays: integer("trash_retention_days"),
++ // Off shows the mailbox only. On shows Name <mailbox> on To, Cc, and Bcc.
++ showFullRecipientAddresses: integer("show_full_recipient_addresses", { mode: "boolean" }).notNull().default(false),
++ // When the reader loads remote images and styles without being asked: always ask, only for senders not yet allowed, or always.
++ remoteContentMode: text("remote_content_mode", { enum: ["ask", "new_sender", "allow"] }).notNull().default("allow"),
++ // TOTP second factor. The secret is written at enrolment and only counts
++ // once the user has proven a code from their authenticator.
++ totpSecret: text("totp_secret"),
++ totpEnabled: integer("totp_enabled", { mode: "boolean" }).notNull().default(false),
++ totpConfirmedAt: integer("totp_confirmed_at", { mode: "timestamp" }),
++ lastSignInAt: integer("last_sign_in_at", { mode: "timestamp" }),
++ // Set when an admin deletes the account. The account is also `disabled` and can be restored until the
++ // retention window ends, after which the scheduled purge removes it and its data.
++ deletedAt: integer("deleted_at", { mode: "timestamp" }),
++ createdByUserId: text("created_by_user_id").references((): AnySQLiteColumn => users.id, { onDelete: "set null" }),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++}, (t) => [
++ uniqueIndex("users_booking_username_idx").on(t.bookingUsername),
++ index("users_created_by_idx").on(t.createdByUserId),
++]);
++
++export const domains = sqliteTable(
++ "domains",
++ {
++ id: text("id").primaryKey(),
++ userId: text("user_id")
++ .notNull()
++ .references(() => users.id, { onDelete: "cascade" }),
++ hostname: text("hostname").notNull(),
++ zoneId: text("zone_id").notNull(),
++ status: text("status", { enum: ["pending", "active", "error"] })
++ .notNull()
++ .default("pending"),
++ routingStatus: text("routing_status"),
++ sendingSubdomainTag: text("sending_subdomain_tag"),
++ sendingProvider: text("sending_provider", { enum: ["none", "cloudflare", "resend", "ses"] }).notNull().default("none"),
++ receivingProvider: text("receiving_provider", { enum: ["none", "cloudflare", "resend", "ses"] }).notNull().default("cloudflare"),
++ sendingRequested: integer("sending_requested", { mode: "boolean" }).notNull().default(false),
++ sendingEnabled: integer("sending_enabled", { mode: "boolean" }).notNull().default(false),
++ routingEnabled: integer("routing_enabled", { mode: "boolean" }).notNull().default(false),
++ /** The operator skipped adding/checking DNS; set until they confirm the records exist. */
++ dnsSkipped: integer("dns_skipped", { mode: "boolean" }).notNull().default(false),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ },
++ (t) => [
++ uniqueIndex("domains_hostname_idx").on(t.hostname),
++ index("domains_user_idx").on(t.userId),
++ ],
++);
++
++export const mailboxes = sqliteTable(
++ "mailboxes",
++ {
++ id: text("id").primaryKey(),
++ userId: text("user_id")
++ .notNull()
++ .references(() => users.id, { onDelete: "cascade" }),
++ domainId: text("domain_id")
++ .notNull()
++ .references(() => domains.id, { onDelete: "cascade" }),
++ localPart: text("local_part").notNull(),
++ displayName: text("display_name"),
++ signature: text("signature"),
++ autoReplyEnabled: integer("auto_reply_enabled", { mode: "boolean" }).notNull().default(false),
++ autoReplySubject: text("auto_reply_subject").notNull().default("Out of office"),
++ autoReplyBody: text("auto_reply_body").notNull().default(""),
++ avatarKey: text("avatar_key"),
++ type: text("type", { enum: ["personal", "shared"] }).notNull().default("personal"),
++ useAllDomains: integer("use_all_domains", { mode: "boolean" }).notNull().default(true),
++ disabled: integer("disabled", { mode: "boolean" }).notNull().default(false),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ },
++ (t) => [uniqueIndex("mailboxes_address_idx").on(t.domainId, t.localPart), index("mailboxes_user_idx").on(t.userId)],
++);
++
++export const mailboxAliases = sqliteTable(
++ "mailbox_aliases",
++ {
++ id: text("id").primaryKey(),
++ mailboxId: text("mailbox_id")
++ .notNull()
++ .references(() => mailboxes.id, { onDelete: "cascade" }),
++ domainId: text("domain_id")
++ .notNull()
++ .references(() => domains.id, { onDelete: "cascade" }),
++ localPart: text("local_part").notNull(),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ },
++ (t) => [
++ uniqueIndex("mailbox_aliases_address_idx").on(t.domainId, t.localPart),
++ index("mailbox_aliases_mailbox_idx").on(t.mailboxId),
++ ],
++);
++
++export const autoReplyDeliveries = sqliteTable(
++ "auto_reply_deliveries",
++ {
++ id: text("id").primaryKey(),
++ mailboxId: text("mailbox_id")
++ .notNull()
++ .references(() => mailboxes.id, { onDelete: "cascade" }),
++ recipient: text("recipient").notNull(),
++ sentAt: integer("sent_at", { mode: "timestamp" }).notNull(),
++ },
++ (t) => [
++ uniqueIndex("auto_reply_deliveries_mailbox_recipient_idx").on(t.mailboxId, t.recipient),
++ index("auto_reply_deliveries_sent_idx").on(t.sentAt),
++ ],
++);
++
++export const mailboxAccess = sqliteTable(
++ "mailbox_access",
++ {
++ id: text("id").primaryKey(),
++ mailboxId: text("mailbox_id")
++ .notNull()
++ .references(() => mailboxes.id, { onDelete: "cascade" }),
++ userId: text("user_id")
++ .notNull()
++ .references(() => users.id, { onDelete: "cascade" }),
++ permission: text("permission", { enum: ["read_only", "send_as", "send_on_behalf", "full_access"] })
++ .notNull()
++ .default("read_only"),
++ createdByUserId: text("created_by_user_id").references(() => users.id, { onDelete: "set null" }),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ },
++ (t) => [
++ uniqueIndex("mailbox_access_mailbox_user_idx").on(t.mailboxId, t.userId),
++ index("mailbox_access_user_idx").on(t.userId),
++ index("mailbox_access_mailbox_idx").on(t.mailboxId),
++ index("mailbox_access_created_by_idx").on(t.createdByUserId),
++ ],
++);
++
++export const contacts = sqliteTable(
++ "contacts",
++ {
++ id: text("id").primaryKey(),
++ userId: text("user_id")
++ .notNull()
++ .references(() => users.id, { onDelete: "cascade" }),
++ email: text("email").notNull(),
++ displayName: text("display_name"),
++ avatarKey: text("avatar_key"),
++ source: text("source", { enum: ["manual", "inbound", "outbound"] })
++ .notNull()
++ .default("inbound"),
++ blocked: integer("blocked", { mode: "boolean" }).notNull().default(false),
++ // Set when the user allows remote content from this sender; "new_sender" mode loads it without asking afterwards.
++ remoteContentAllowed: integer("remote_content_allowed", { mode: "boolean" }).notNull().default(false),
++ lastSeenAt: integer("last_seen_at", { mode: "timestamp" }),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ },
++ (t) => [
++ uniqueIndex("contacts_user_email_idx").on(t.userId, t.email),
++ index("contacts_user_idx").on(t.userId),
++ ],
++);
++
++export const folders = sqliteTable(
++ "folders",
++ {
++ id: text("id").primaryKey(),
++ userId: text("user_id")
++ .notNull()
++ .references(() => users.id, { onDelete: "cascade" }),
++ mailboxId: text("mailbox_id")
++ .notNull()
++ .references(() => mailboxes.id, { onDelete: "cascade" }),
++ name: text("name").notNull(),
++ color: text("color").notNull().default("#2563eb"),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ },
++ (t) => [
++ uniqueIndex("folders_mailbox_name_idx").on(t.mailboxId, t.name),
++ index("folders_user_idx").on(t.userId),
++ index("folders_mailbox_idx").on(t.mailboxId),
++ ],
++);
++
++export const jmapMailboxRevisions = sqliteTable("jmap_mailbox_revisions", {
++ mailboxId: text("mailbox_id").primaryKey(),
++ revision: integer("revision").notNull().default(0),
++});
++
++/**
++ * JMAP change log, written only by the `jmap_changes_*` triggers of migration
++ * 0064: one row per created, updated or destroyed Email (and per folder or
++ * mailbox change), so `Email/changes`, `Mailbox/changes` and `Thread/changes`
++ * return real deltas. `seq` is the state; rows older than the retention
++ * window are pruned and `jmap_change_floor` records the last pruned seq.
++ */
++export const jmapChanges = sqliteTable(
++ "jmap_changes",
++ {
++ seq: integer("seq").primaryKey({ autoIncrement: true }),
++ mailboxId: text("mailbox_id").notNull(),
++ objectType: text("object_type", { enum: ["email", "mailbox"] }).notNull(),
++ objectId: text("object_id").notNull(),
++ threadId: text("thread_id"),
++ change: text("change", { enum: ["created", "updated", "destroyed"] }).notNull(),
++ createdAt: integer("created_at").notNull().default(sql`(unixepoch())`),
++ },
++ (table) => [index("jmap_changes_mailbox_seq_idx").on(table.mailboxId, table.seq)],
++);
++
++export const jmapChangeFloor = sqliteTable("jmap_change_floor", {
++ id: integer("id").primaryKey(),
++ seq: integer("seq").notNull().default(0),
++});
++
++export const apiKeys = sqliteTable("api_keys", {
++ id: text("id").primaryKey(),
++ /** `device` keys come from a mobile sign-in (`/api/auth/device`) and are listed under Devices. */
++ kind: text("kind", { enum: ["legacy", "mcp", "device"] }).notNull().default("legacy"),
++ userId: text("user_id")
++ .notNull()
++ .references(() => users.id, { onDelete: "cascade" }),
++ name: text("name").notNull(),
++ prefix: text("prefix").notNull(),
++ keyHash: text("key_hash").notNull(),
++ scopes: text("scopes").notNull(),
++ mailboxScopeEnabled: integer("mailbox_scope_enabled", { mode: "boolean" }).notNull().default(false),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ lastUsedAt: integer("last_used_at", { mode: "timestamp" }),
++}, (t) => [index("api_keys_user_idx").on(t.userId)]);
++
++export const messages = sqliteTable(
++ "messages",
++ {
++ id: text("id").primaryKey(),
++ userId: text("user_id")
++ .notNull()
++ .references(() => users.id, { onDelete: "cascade" }),
++ mailboxId: text("mailbox_id").references(() => mailboxes.id, { onDelete: "set null" }),
++ direction: text("direction", { enum: ["inbound", "outbound"] }).notNull(),
++ providerMessageId: text("provider_message_id"),
++ folderId: text("folder_id").references(() => folders.id, { onDelete: "set null" }),
++ fromAddr: text("from_addr").notNull(),
++ toAddr: text("to_addr").notNull(),
++ ccAddr: text("cc_addr"),
++ bccAddr: text("bcc_addr"),
++ /** Full Reply-To header, comma-joined. Replies go here instead of `fromAddr` when set. */
++ replyTo: text("reply_to"),
++ subject: text("subject"),
++ snippet: text("snippet"),
++ textBody: text("text_body"),
++ htmlBody: text("html_body"),
++ rawR2Key: text("raw_r2_key"),
++ status: text("status").notNull().default("received"),
++ read: integer("read", { mode: "boolean" }).notNull().default(false),
++ starred: integer("starred", { mode: "boolean" }).notNull().default(false),
++ snoozedUntil: integer("snoozed_until", { mode: "timestamp" }),
++ threadId: text("thread_id"),
++ // RFC 5322 threading headers, kept so replies land in the right conversation
++ // and so outgoing replies can carry them on to the recipient's client.
++ inReplyTo: text("in_reply_to"),
++ references: text("references_header"),
++ spamScore: integer("spam_score"),
++ spamVerdict: text("spam_verdict", { enum: ["inbox", "suspicious", "spam"] }),
++ spamSignals: text("spam_signals"),
++ spamAnalyzedAt: integer("spam_analyzed_at", { mode: "timestamp" }),
++ spamAnalysisError: text("spam_analysis_error"),
++ /** When the message last entered Trash or Spam; maintained by triggers (migration 0053). */
++ trashedAt: integer("trashed_at", { mode: "timestamp" }),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ },
++ (t) => [
++ index("messages_user_created_idx").on(t.userId, t.createdAt),
++ index("messages_mailbox_idx").on(t.mailboxId),
++ index("messages_folder_idx").on(t.folderId),
++ index("messages_thread_idx").on(t.mailboxId, t.threadId),
++ index("messages_provider_message_idx").on(t.mailboxId, t.providerMessageId),
++ index("messages_raw_r2_key_idx").on(t.rawR2Key),
++ index("messages_trashed_at_idx").on(t.trashedAt),
++ index("messages_inbox_page_idx").on(
++ t.mailboxId,
++ t.status,
++ t.folderId,
++ sql`${t.createdAt} desc`,
++ sql`${t.id} desc`,
++ ),
++ index("messages_thread_key_idx").on(
++ t.mailboxId,
++ t.status,
++ t.folderId,
++ sql`coalesce(${t.threadId}, ${t.id})`,
++ t.createdAt,
++ ),
++ index("messages_mailbox_thread_key_idx").on(t.mailboxId, sql`coalesce(${t.threadId}, ${t.id})`),
++<<<<<<< HEAD
++ index("messages_nav_cover_idx").on(
++ t.mailboxId,
++ t.status,
++ t.folderId,
++ sql`${t.createdAt} desc`,
++ sql`${t.id} desc`,
++ t.direction,
++ t.read,
++ t.threadId,
++=======
++ // Covering index for the folder-counts GROUP BY: lets the counts
++ // endpoint stream grouped rows straight off the index instead of
++ // sorting the whole table.
++ index("messages_counts_cover_idx").on(
++ t.mailboxId,
++ t.folderId,
++ t.direction,
++ t.status,
++ t.read,
++ t.starred,
++ t.snoozedUntil,
++ ),
++ // Conversation paging partitions by coalesce(thread_id, id) and orders
++ // each partition by created_at desc, so the thread key must precede
++ // created_at for the index to feed the window in sorted order. The
++ // snoozed_until filter rides the tail column and never touches the
++ // table.
++ index("messages_conv_cover_idx").on(
++ t.mailboxId,
++ t.status,
++ sql`coalesce(${t.threadId}, ${t.id})`,
++ t.createdAt,
++ t.id,
++>>>>>>> origin/main
++ t.snoozedUntil,
++ ),
++ ],
++);
++
++export const spamTokenStats = sqliteTable(
++ "spam_token_stats",
++ {
++ mailboxId: text("mailbox_id").notNull().references(() => mailboxes.id, { onDelete: "cascade" }),
++ token: text("token").notNull(),
++ spamCount: integer("spam_count").notNull().default(0),
++ hamCount: integer("ham_count").notNull().default(0),
++ updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ },
++ (t) => [
++ uniqueIndex("spam_token_stats_mailbox_token_idx").on(t.mailboxId, t.token),
++ index("spam_token_stats_mailbox_idx").on(t.mailboxId),
++ ],
++);
++
++export const spamReputation = sqliteTable(
++ "spam_reputation",
++ {
++ mailboxId: text("mailbox_id").notNull().references(() => mailboxes.id, { onDelete: "cascade" }),
++ type: text("type", { enum: ["email", "domain", "fingerprint"] }).notNull(),
++ key: text("key").notNull(),
++ messagesSeen: integer("messages_seen").notNull().default(0),
++ spamCount: integer("spam_count").notNull().default(0),
++ hamCount: integer("ham_count").notNull().default(0),
++ firstSeenAt: integer("first_seen_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ lastSeenAt: integer("last_seen_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ },
++ (t) => [
++ uniqueIndex("spam_reputation_mailbox_type_key_idx").on(t.mailboxId, t.type, t.key),
++ index("spam_reputation_mailbox_idx").on(t.mailboxId),
++ ],
++);
++
++export const spamFeedback = sqliteTable(
++ "spam_feedback",
++ {
++ messageId: text("message_id").primaryKey().references(() => messages.id, { onDelete: "cascade" }),
++ mailboxId: text("mailbox_id").notNull().references(() => mailboxes.id, { onDelete: "cascade" }),
++ actorUserId: text("actor_user_id").references(() => users.id, { onDelete: "set null" }),
++ classification: text("classification", { enum: ["spam", "ham"] }).notNull(),
++ trainingTokens: text("training_tokens").notNull(),
++ reputationKeys: text("reputation_keys").notNull(),
++ tokenizerVersion: integer("tokenizer_version").notNull().default(1),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ },
++ (t) => [
++ index("spam_feedback_mailbox_idx").on(t.mailboxId),
++ index("spam_feedback_actor_user_idx").on(t.actorUserId),
++ ],
++);
++
++export const messageAttachments = sqliteTable(
++ "message_attachments",
++ {
++ id: text("id").primaryKey(),
++ messageId: text("message_id")
++ .notNull()
++ .references(() => messages.id, { onDelete: "cascade" }),
++ filename: text("filename").notNull(),
++ contentType: text("content_type").notNull(),
++ size: integer("size").notNull(),
++ disposition: text("disposition", { enum: ["attachment", "inline"] })
++ .notNull()
++ .default("attachment"),
++ contentId: text("content_id"),
++ r2Key: text("r2_key").notNull().unique(),
++ /** Set when the attachment is moved to the Drive trash; hidden from the email until restored, purged after 30 days. */
++ trashedAt: integer("trashed_at", { mode: "timestamp" }),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ },
++ (t) => [index("message_attachments_message_idx").on(t.messageId)],
++);
++
++export const sharedAttachmentLinks = sqliteTable("shared_attachment_links", {
++ id: text("id").primaryKey(),
++ attachmentId: text("attachment_id").notNull().references(() => messageAttachments.id, { onDelete: "cascade" }).unique(),
++ expiresAt: integer("expires_at", { mode: "timestamp" }).notNull(),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++});
++
++export const outboundJobs = sqliteTable("outbound_jobs", {
++ id: text("id").primaryKey(),
++ userId: text("user_id")
++ .notNull()
++ .references(() => users.id, { onDelete: "cascade" }),
++ messageId: text("message_id").references(() => messages.id, { onDelete: "set null" }),
++ status: text("status", { enum: ["queued", "sending", "sent", "failed"] }).notNull().default("queued"),
++ payload: text("payload").notNull(),
++ error: text("error"),
++ scheduledAt: integer("scheduled_at", { mode: "timestamp" }),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ updatedAt: integer("updated_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++}, (t) => [
++ index("outbound_jobs_user_idx").on(t.userId),
++ index("outbound_jobs_message_idx").on(t.messageId),
++]);
++
++/** One row per sent message that carries an open-tracking pixel; the token is the pixel URL's secret. */
++export const messageTracking = sqliteTable(
++ "message_tracking",
++ {
++ token: text("token").primaryKey(),
++ messageId: text("message_id").notNull().references(() => messages.id, { onDelete: "cascade" }),
++ /** Opens that were not classified as automated prefetches. */
++ openCount: integer("open_count").notNull().default(0),
++ firstOpenedAt: integer("first_opened_at", { mode: "timestamp" }),
++ lastOpenedAt: integer("last_opened_at", { mode: "timestamp" }),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ },
++ (t) => [uniqueIndex("message_tracking_message_idx").on(t.messageId)],
++);
++
++/** Hostname under a domain that serves its read-receipt pixels, so the pixel matches the sender. Kept out of `domains` so sending works before the migration. */
++export const domainTrackingHosts = sqliteTable(
++ "domain_tracking_hosts",
++ {
++ domainId: text("domain_id").primaryKey().references(() => domains.id, { onDelete: "cascade" }),
++ hostname: text("hostname").notNull(),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ },
++ (t) => [uniqueIndex("domain_tracking_hosts_hostname_idx").on(t.hostname)],
++);
++
++export const messageOpens = sqliteTable(
++ "message_opens",
++ {
++ id: text("id").primaryKey(),
++ token: text("token").notNull().references(() => messageTracking.token, { onDelete: "cascade" }),
++ openedAt: integer("opened_at", { mode: "timestamp" }).notNull(),
++ client: text("client"),
++ device: text("device"),
++ country: text("country"),
++ city: text("city"),
++ automated: integer("automated", { mode: "boolean" }).notNull().default(false),
++ },
++ (t) => [index("message_opens_token_idx").on(t.token, t.openedAt)],
++);
++
++/**
++ * Per-user composer defaults. Kept out of `users` because every session
++ * lookup selects the whole users row, which would fail before the migration.
++ */
++export const userComposePreferences = sqliteTable("user_compose_preferences", {
++ userId: text("user_id").primaryKey().references(() => users.id, { onDelete: "cascade" }),
++ trackOpensDefault: integer("track_opens_default", { mode: "boolean" }).notNull().default(false),
++ undoSendSeconds: integer("undo_send_seconds").notNull().default(15),
++ updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++});
++
++/**
++ * "Remind me if there is no reply": a sent message whose thread comes back to the
++ * inbox at `dueAt` unless an inbound message joined the thread after it.
++ */
++export const followUps = sqliteTable(
++ "follow_ups",
++ {
++ id: text("id").primaryKey(),
++ messageId: text("message_id").notNull().references(() => messages.id, { onDelete: "cascade" }),
++ userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
++ dueAt: integer("due_at", { mode: "timestamp" }).notNull(),
++ status: text("status", { enum: ["pending", "due", "replied", "dismissed"] }).notNull().default("pending"),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ },
++ (t) => [
++ uniqueIndex("follow_ups_message_idx").on(t.messageId),
++ index("follow_ups_status_due_idx").on(t.status, t.dueAt),
++ index("follow_ups_user_status_idx").on(t.userId, t.status),
++ ],
++);
++
++export const emailTemplates = sqliteTable(
++ "email_templates",
++ {
++ id: text("id").primaryKey(),
++ userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
++ name: text("name").notNull(),
++ subject: text("subject").notNull().default(""),
++ textBody: text("text_body").notNull().default(""),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ },
++ (t) => [index("email_templates_user_idx").on(t.userId)],
++);
++
++export const calendarEvents = sqliteTable(
++ "calendar_events",
++ {
++ id: text("id").primaryKey(),
++ userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
++ mailboxId: text("mailbox_id").references(() => mailboxes.id, { onDelete: "set null" }),
++ title: text("title").notNull(),
++ description: text("description").notNull().default(""),
++ location: text("location").notNull().default(""),
++ attendees: text("attendees").notNull().default("[]"),
++ color: text("color").notNull().default("blue"),
++ repeat: text("repeat", { enum: ["none", "daily", "weekly", "monthly", "weekdays"] }).notNull().default("none"),
++ repeatDays: text("repeat_days").notNull().default("[]"),
++ repeatAnchorDay: integer("repeat_anchor_day"),
++ repeatUntil: integer("repeat_until", { mode: "timestamp" }),
++ excludedOccurrences: text("excluded_occurrences").notNull().default("[]"),
++ timeZone: text("time_zone"),
++ startsAt: integer("starts_at", { mode: "timestamp" }).notNull(),
++ endsAt: integer("ends_at", { mode: "timestamp" }).notNull(),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ },
++ (t) => [
++ index("calendar_events_user_starts_idx").on(t.userId, t.startsAt),
++ index("calendar_events_mailbox_idx").on(t.mailboxId),
++ ],
++);
++
++export const bookingEvents = sqliteTable(
++ "booking_events",
++ {
++ id: text("id").primaryKey(),
++ userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
++ name: text("name").notNull(),
++ slug: text("slug").notNull().default(""),
++ description: text("description").notNull().default(""),
++ color: text("color").notNull().default("#2563eb"),
++ hostIds: text("host_ids").notNull().default("[]"),
++ durationMinutes: integer("duration_minutes").notNull(),
++ location: text("location").notNull().default(""),
++ weekdays: text("weekdays").notNull().default("[1,2,3,4,5]"),
++ startTime: text("start_time").notNull().default("09:00"),
++ endTime: text("end_time").notNull().default("17:00"),
++ timeRanges: text("time_ranges").notNull().default('[{"startTime":"09:00","endTime":"17:00"}]'),
++ timeZone: text("time_zone").notNull().default("UTC"),
++ enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ },
++ (t) => [index("booking_events_user_idx").on(t.userId), uniqueIndex("booking_events_user_slug_idx").on(t.userId, t.slug)],
++);
++
++export const routingRules = sqliteTable(
++ "routing_rules",
++ {
++ id: text("id").primaryKey(),
++ userId: text("user_id")
++ .notNull()
++ .references(() => users.id, { onDelete: "cascade" }),
++ domainId: text("domain_id")
++ .notNull()
++ .references(() => domains.id, { onDelete: "cascade" }),
++ // "mailbox" rules run after delivery and file the message into a folder or system status.
++ // "domain" rules run during address resolution and can catch-all, forward, or reject.
++ scope: text("scope", { enum: ["mailbox", "domain"] }).notNull().default("mailbox"),
++ name: text("name"),
++ enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
++ pattern: text("pattern").notNull(),
++ matchField: text("match_field", {
++ enum: ["email", "content", "title", "sender", "recipient"],
++ })
++ .notNull()
++ .default("email"),
++ matchOperator: text("match_operator", {
++ enum: ["contains", "exact", "starts_with", "ends_with", "regex"],
++ })
++ .notNull()
++ .default("contains"),
++ matchValue: text("match_value").notNull().default(""),
++ mailboxId: text("mailbox_id").references(() => mailboxes.id, { onDelete: "set null" }),
++ folderId: text("folder_id").references(() => folders.id, { onDelete: "set null" }),
++ action: text("action", { enum: ["store", "forward", "reject", "spam", "trash"] }).notNull().default("store"),
++ forwardTo: text("forward_to"),
++ // Forward actions drop the message by default; keepCopy also delivers it to the mailbox.
++ keepCopy: integer("keep_copy", { mode: "boolean" }).notNull().default(false),
++ rejectReason: text("reject_reason"),
++ priority: integer("priority").notNull().default(0),
++ lastMatchedAt: integer("last_matched_at", { mode: "timestamp" }),
++ matchCount: integer("match_count").notNull().default(0),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ },
++ (t) => [
++ index("routing_rules_domain_scope_idx").on(t.domainId, t.scope, t.enabled),
++ index("routing_rules_mailbox_idx").on(t.mailboxId),
++ index("routing_rules_priority_idx").on(t.priority),
++ index("routing_rules_user_idx").on(t.userId),
++ index("routing_rules_folder_idx").on(t.folderId),
++ ],
++);
++
++export const webhooks = sqliteTable("webhooks", {
++ id: text("id").primaryKey(),
++ userId: text("user_id")
++ .notNull()
++ .references(() => users.id, { onDelete: "cascade" }),
++ description: text("description"),
++ url: text("url").notNull(),
++ secret: text("secret").notNull(),
++ events: text("events").notNull(),
++ enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
++ maxAttempts: integer("max_attempts").notNull().default(5),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++}, (t) => [index("webhooks_user_idx").on(t.userId)]);
++
++export const webhookDeliveries = sqliteTable(
++ "webhook_deliveries",
++ {
++ id: text("id").primaryKey(),
++ webhookId: text("webhook_id")
++ .notNull()
++ .references(() => webhooks.id, { onDelete: "cascade" }),
++ eventType: text("event_type").notNull(),
++ payload: text("payload").notNull(),
++ // pending | delivered | failed | retrying | exhausted
++ status: text("status").notNull().default("pending"),
++ attempts: integer("attempts").notNull().default(0),
++ responseStatus: integer("response_status"),
++ error: text("error"),
++ durationMs: integer("duration_ms"),
++ lastAttemptAt: integer("last_attempt_at", { mode: "timestamp" }),
++ nextRetryAt: integer("next_retry_at", { mode: "timestamp" }),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ },
++ (t) => [
++ index("webhook_deliveries_webhook_idx").on(t.webhookId, t.createdAt),
++ index("webhook_deliveries_status_idx").on(t.status),
++ ],
++);
++
++export const sessions = sqliteTable("sessions", {
++ id: text("id").primaryKey(),
++ userId: text("user_id")
++ .notNull()
++ .references(() => users.id, { onDelete: "cascade" }),
++ tokenHash: text("token_hash").notNull().unique(),
++ expiresAt: integer("expires_at", { mode: "timestamp" }).notNull(),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++}, (t) => [index("sessions_user_idx").on(t.userId)]);
++
++/** A native app's push registration (APNs), owned by the device's API key. */
++export const pushDevices = sqliteTable(
++ "push_devices",
++ {
++ id: text("id").primaryKey(),
++ userId: text("user_id")
++ .notNull()
++ .references(() => users.id, { onDelete: "cascade" }),
++ apiKeyId: text("api_key_id")
++ .notNull()
++ .references(() => apiKeys.id, { onDelete: "cascade" }),
++ platform: text("platform", { enum: ["apns"] }).notNull(),
++ token: text("token").notNull(),
++ environment: text("environment", { enum: ["production", "sandbox"] }).notNull().default("production"),
++ topic: text("topic").notNull(),
++ /** Base64 raw P-256 public key; previews are encrypted to it. */
++ publicKey: text("public_key"),
++ previews: integer("previews", { mode: "boolean" }).notNull().default(true),
++ /** The app's own id for this account; echoed in pushes so a tap opens the right account. */
++ clientRef: text("client_ref"),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
++ updatedAt: integer("updated_at", { mode: "timestamp" }).notNull(),
++ },
++ (table) => [
++ uniqueIndex("push_devices_platform_token_user_idx").on(table.platform, table.token, table.userId),
++ index("push_devices_user_idx").on(table.userId),
++ index("push_devices_api_key_idx").on(table.apiKeyId),
++ ],
++);
++
++export const pushSubscriptions = sqliteTable(
++ "push_subscriptions",
++ {
++ id: text("id").primaryKey(),
++ userId: text("user_id")
++ .notNull()
++ .references(() => users.id, { onDelete: "cascade" }),
++ sessionId: text("session_id")
++ .notNull()
++ .references(() => sessions.id, { onDelete: "cascade" }),
++ endpoint: text("endpoint").notNull(),
++ p256dh: text("p256dh").notNull(),
++ auth: text("auth").notNull(),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ updatedAt: integer("updated_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ },
++ (t) => [
++ uniqueIndex("push_subscriptions_endpoint_idx").on(t.endpoint),
++ index("push_subscriptions_user_idx").on(t.userId),
++ index("push_subscriptions_session_idx").on(t.sessionId),
++ ],
++);
++
++/** Single-use links mailed to a user's recovery address. Only the hash is stored. */
++export const passwordResetTokens = sqliteTable(
++ "password_reset_tokens",
++ {
++ id: text("id").primaryKey(),
++ userId: text("user_id")
++ .notNull()
++ .references(() => users.id, { onDelete: "cascade" }),
++ tokenHash: text("token_hash").notNull().unique(),
++ expiresAt: integer("expires_at", { mode: "timestamp" }).notNull(),
++ usedAt: integer("used_at", { mode: "timestamp" }),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ },
++ (t) => [index("password_reset_tokens_user_idx").on(t.userId)],
++);
++
++/** One-time backup codes for accounts with TOTP, hashed like session tokens. */
++export const mfaRecoveryCodes = sqliteTable(
++ "mfa_recovery_codes",
++ {
++ id: text("id").primaryKey(),
++ userId: text("user_id")
++ .notNull()
++ .references(() => users.id, { onDelete: "cascade" }),
++ codeHash: text("code_hash").notNull().unique(),
++ usedAt: integer("used_at", { mode: "timestamp" }),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ },
++ (t) => [index("mfa_recovery_codes_user_idx").on(t.userId)],
++);
++
++/**
++ * A password that checked out but still needs a second factor. The challenge
++ * token stands in for the password on the follow-up request, so the password
++ * is never held client-side between the two steps.
++ */
++export const loginChallenges = sqliteTable("login_challenges", {
++ id: text("id").primaryKey(),
++ userId: text("user_id")
++ .notNull()
++ .references(() => users.id, { onDelete: "cascade" }),
++ tokenHash: text("token_hash").notNull().unique(),
++ expiresAt: integer("expires_at", { mode: "timestamp" }).notNull(),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++}, (t) => [index("login_challenges_user_idx").on(t.userId)]);
++
++export const auditLogs = sqliteTable(
++ "audit_logs",
++ {
++ id: text("id").primaryKey(),
++ actorUserId: text("actor_user_id").references(() => users.id, { onDelete: "set null" }),
++ targetUserId: text("target_user_id").references(() => users.id, { onDelete: "set null" }),
++ mailboxId: text("mailbox_id").references(() => mailboxes.id, { onDelete: "set null" }),
++ messageId: text("message_id").references(() => messages.id, { onDelete: "set null" }),
++ action: text("action").notNull(),
++ metadata: text("metadata"),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ },
++ (t) => [
++ index("audit_logs_actor_idx").on(t.actorUserId),
++ index("audit_logs_mailbox_idx").on(t.mailboxId),
++ index("audit_logs_created_idx").on(t.createdAt),
++ index("audit_logs_message_id_idx").on(t.messageId),
++ index("audit_logs_target_user_idx").on(t.targetUserId),
++ ],
++);
++
++export const backupSettings = sqliteTable("backup_settings", {
++ id: text("id").primaryKey(),
++ enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
++ scheduleType: text("schedule_type", { enum: ["daily", "weekly", "monthly"] })
++ .notNull()
++ .default("daily"),
++ scheduleValue: integer("schedule_value"),
++ retentionEnabled: integer("retention_enabled", { mode: "boolean" }).notNull().default(false),
++ retentionDays: integer("retention_days").notNull().default(30),
++ excludedTableGroups: text("excluded_table_groups").notNull().default("[]"),
++ updatedAt: integer("updated_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++});
++
++export const appSettings = sqliteTable("app_settings", {
++ id: text("id").primaryKey(),
++ appName: text("app_name").notNull().default("Mailflare"),
++ outboundAttachmentMaxMb: integer("outbound_attachment_max_mb").notNull().default(25),
++ /** Per-user Drive storage cap in bytes; null means unlimited. */
++ driveStorageLimitBytes: integer("drive_storage_limit_bytes"),
++ resendApiKey: text("resend_api_key"),
++ /** JSON: AWS access key, secret and region (see src/lib/aws/config.ts). */
++ awsConfig: text("aws_config"),
++ /** JSON: the shared SES inbound resources Mailflare created (bucket, topic, rule set, webhook token). */
++ sesReceiving: text("ses_receiving"),
++ resendWebhookId: text("resend_webhook_id"),
++ resendWebhookSecret: text("resend_webhook_secret"),
++ iconKey: text("icon_key"),
++ agentEnabled: integer("agent_enabled", { mode: "boolean" }).notNull().default(true),
++ agentProvider: text("agent_provider", { enum: ["cloudflare", "compatible"] }),
++ agentPreset: text("agent_preset", { enum: ["openai", "openrouter", "groq", "custom"] }),
++ agentBaseUrl: text("agent_base_url"),
++ agentApiKey: text("agent_api_key"),
++ agentModel: text("agent_model"),
++ agentModelRates: text("agent_model_rates"),
++ /** Spam analysis lookups; the SPAMHAUS_DQS_KEY and ABUSECH_AUTH_KEY env vars apply when these are null. */
++ spamhausDqsKey: text("spamhaus_dqs_key"),
++ abusechAuthKey: text("abusech_auth_key"),
++ spamDomainAgeCheck: integer("spam_domain_age_check", { mode: "boolean" }).notNull().default(true),
++ /** JSON: brands the administrator added for display-name impersonation checks (see src/lib/spam/settings.ts). */
++ spamBrands: text("spam_brands"),
++ updatedAt: integer("updated_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++});
++
++export const licenseSettings = sqliteTable("license_settings", {
++ id: text("id").primaryKey(),
++ instanceId: text("instance_id").notNull().unique(),
++ instanceUrl: text("instance_url"),
++ licenseKeyHash: text("license_key_hash"),
++ plan: text("plan", { enum: ["community", "pro", "team"] }).notNull().default("community"),
++ state: text("state", { enum: ["inactive", "active", "invalid", "expired", "deactivated"] })
++ .notNull()
++ .default("inactive"),
++ features: text("features").notNull().default("[]"),
++ // Account seats from Paymug's seatLimit; null is unlimited. Rows predating seats keep one.
++ seatLimit: integer("seat_limit").default(1),
++ activatedAt: integer("activated_at", { mode: "timestamp" }),
++ validatedAt: integer("validated_at", { mode: "timestamp" }),
++ updatedAt: integer("updated_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++});
++
++export const backups = sqliteTable(
++ "backups",
++ {
++ id: text("id").primaryKey(),
++ status: text("status", { enum: ["queued", "running", "completed", "failed"] })
++ .notNull()
++ .default("queued"),
++ trigger: text("trigger", { enum: ["manual", "scheduled"] }).notNull(),
++ r2Key: text("r2_key"),
++ filename: text("filename"),
++ size: integer("size"),
++ error: text("error"),
++ createdByUserId: text("created_by_user_id").references(() => users.id, { onDelete: "set null" }),
++ createdAt: integer("created_at", { mode: "timestamp" })
++ .notNull()
++ .$defaultFn(() => new Date()),
++ startedAt: integer("started_at", { mode: "timestamp" }),
++ completedAt: integer("completed_at", { mode: "timestamp" }),
++ },
++ (t) => [
++ index("backups_created_idx").on(t.createdAt),
++ index("backups_status_idx").on(t.status),
++ index("backups_created_by_idx").on(t.createdByUserId),
++ ],
++);
++
++export const mailboxAgentSettings = sqliteTable("mailbox_agent_settings", {
++ mailboxId: text("mailbox_id").primaryKey().references(() => mailboxes.id, { onDelete: "cascade" }),
++ enabled: integer("enabled", { mode: "boolean" }).notNull().default(false),
++ modelId: text("model_id"),
++ autoDraftEnabled: integer("auto_draft_enabled", { mode: "boolean" }).notNull().default(false),
++ reviewerUserId: text("reviewer_user_id").references(() => users.id, { onDelete: "set null" }),
++ instructions: text("instructions").notNull().default(""),
++ dailyLimit: integer("daily_limit").notNull().default(25),
++ updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++}, (t) => [index("mailbox_agent_settings_reviewer_idx").on(t.reviewerUserId)]);
++
++export const aiUsage = sqliteTable("ai_usage", {
++ id: text("id").primaryKey(),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ provider: text("provider").notNull(),
++ model: text("model").notNull(),
++ source: text("source").notNull(),
++ inputTokens: integer("input_tokens"),
++ outputTokens: integer("output_tokens"),
++ costUsdMicros: integer("cost_usd_micros"),
++}, (t) => [index("ai_usage_created_idx").on(t.createdAt)]);
++
++export const agentConversations = sqliteTable("agent_conversations", {
++ id: text("id").primaryKey(),
++ userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
++ mailboxId: text("mailbox_id").notNull().references(() => mailboxes.id, { onDelete: "cascade" }),
++ title: text("title").notNull().default("New conversation"),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++}, (t) => [
++ index("agent_conversations_owner_idx").on(t.userId, t.mailboxId, t.updatedAt),
++ index("agent_conversations_mailbox_idx").on(t.mailboxId),
++]);
++
++export const agentChatMessages = sqliteTable("agent_chat_messages", {
++ id: text("id").primaryKey(),
++ conversationId: text("conversation_id").notNull().references(() => agentConversations.id, { onDelete: "cascade" }),
++ role: text("role", { enum: ["user", "assistant", "tool"] }).notNull(),
++ content: text("content").notNull(),
++ toolName: text("tool_name"),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++}, (t) => [index("agent_chat_messages_conversation_idx").on(t.conversationId, t.createdAt)]);
++
++export const agentJobs = sqliteTable("agent_jobs", {
++ id: text("id").primaryKey(),
++ mailboxId: text("mailbox_id").notNull().references(() => mailboxes.id, { onDelete: "cascade" }),
++ sourceMessageId: text("source_message_id").notNull().references(() => messages.id, { onDelete: "cascade" }),
++ reviewerUserId: text("reviewer_user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
++ status: text("status", { enum: ["pending", "running", "completed", "skipped", "failed"] }).notNull().default("pending"),
++ attempts: integer("attempts").notNull().default(0),
++ nextAttemptAt: integer("next_attempt_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ leaseUntil: integer("lease_until", { mode: "timestamp" }),
++ draftId: text("draft_id").references(() => messages.id, { onDelete: "set null" }),
++ reason: text("reason"),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++}, (t) => [
++ uniqueIndex("agent_jobs_source_idx").on(t.mailboxId, t.sourceMessageId),
++ index("agent_jobs_due_idx").on(t.status, t.nextAttemptAt),
++ index("agent_jobs_source_message_idx").on(t.sourceMessageId),
++ index("agent_jobs_draft_idx").on(t.draftId),
++ index("agent_jobs_reviewer_idx").on(t.reviewerUserId),
++]);
++
++export const agentDraftMetadata = sqliteTable("agent_draft_metadata", {
++ draftId: text("draft_id").primaryKey().references(() => messages.id, { onDelete: "cascade" }),
++ mailboxId: text("mailbox_id").notNull().references(() => mailboxes.id, { onDelete: "cascade" }),
++ origin: text("origin", { enum: ["chat", "auto", "mcp"] }).notNull(),
++ sourceMessageId: text("source_message_id").references(() => messages.id, { onDelete: "set null" }),
++ revision: integer("revision").notNull().default(1),
++ humanEditedAt: integer("human_edited_at", { mode: "timestamp" }),
++ scheduledAt: integer("scheduled_at", { mode: "timestamp" }),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++}, (t) => [
++ index("agent_draft_meta_source_msg_idx").on(t.sourceMessageId),
++ index("agent_draft_metadata_mailbox_idx").on(t.mailboxId),
++]);
++
++export const agentSendApprovals = sqliteTable("agent_send_approvals", {
++ id: text("id").primaryKey(),
++ draftId: text("draft_id").notNull().references(() => messages.id, { onDelete: "cascade" }),
++ mailboxId: text("mailbox_id").notNull().references(() => mailboxes.id, { onDelete: "cascade" }),
++ userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
++ requestKeyId: text("request_key_id").references(() => apiKeys.id, { onDelete: "set null" }),
++ revision: integer("revision").notNull(),
++ payloadHash: text("payload_hash").notNull(),
++ status: text("status", { enum: ["pending", "claimed", "sent", "unknown", "expired", "cancelled"] }).notNull().default("pending"),
++ claimedAt: integer("claimed_at", { mode: "timestamp" }),
++ messageId: text("message_id"),
++ expiresAt: integer("expires_at", { mode: "timestamp" }).notNull(),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++}, (t) => [
++ index("agent_send_approvals_user_idx").on(t.userId, t.status),
++ uniqueIndex("agent_send_approvals_delivery_idx").on(t.draftId).where(sql`status IN ('claimed', 'sent', 'unknown')`),
++ index("agent_send_approvals_request_key_idx").on(t.requestKeyId),
++ index("agent_send_approvals_mailbox_idx").on(t.mailboxId),
++ index("agent_send_approvals_draft_idx").on(t.draftId),
++]);
++
++export const mcpKeyMailboxes = sqliteTable("mcp_key_mailboxes", {
++ keyId: text("key_id").notNull().references(() => apiKeys.id, { onDelete: "cascade" }),
++ mailboxId: text("mailbox_id").notNull().references(() => mailboxes.id, { onDelete: "cascade" }),
++}, (t) => [
++ uniqueIndex("mcp_key_mailbox_idx").on(t.keyId, t.mailboxId),
++ index("mcp_key_mailboxes_mailbox_idx").on(t.mailboxId),
++]);
++
++export const driveItems = sqliteTable("drive_items", {
++ id: text("id").primaryKey(),
++ ownerId: text("owner_id").notNull().references(() => users.id, { onDelete: "cascade" }),
++ parentId: text("parent_id"),
++ kind: text("kind", { enum: ["file", "folder"] }).notNull(),
++ name: text("name").notNull(),
++ r2Key: text("r2_key"),
++ size: integer("size").notNull().default(0),
++ contentType: text("content_type").notNull().default("application/octet-stream"),
++ // Set while a multipart upload is in flight; such rows stay hidden until the upload completes.
++ uploadId: text("upload_id"),
++ uploadPartSize: integer("upload_part_size"),
++ uploadFingerprint: text("upload_fingerprint"),
++ linkToken: text("link_token"),
++ trashedAt: integer("trashed_at", { mode: "timestamp" }),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++ updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++}, (t) => [
++ index("drive_items_owner_parent_idx").on(t.ownerId, t.parentId),
++ uniqueIndex("drive_items_link_token_idx").on(t.linkToken),
++]);
++
++export const driveUploadParts = sqliteTable("drive_upload_parts", {
++ itemId: text("item_id").notNull().references(() => driveItems.id, { onDelete: "cascade" }),
++ partNumber: integer("part_number").notNull(),
++ etag: text("etag").notNull(),
++}, (t) => [uniqueIndex("drive_upload_parts_idx").on(t.itemId, t.partNumber)]);
++
++export const driveShares = sqliteTable("drive_shares", {
++ id: text("id").primaryKey(),
++ itemId: text("item_id").notNull().references(() => driveItems.id, { onDelete: "cascade" }),
++ userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
++ role: text("role", { enum: ["view", "edit"] }).notNull().default("view"),
++ createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => new Date()),
++}, (t) => [
++ uniqueIndex("drive_shares_item_user_idx").on(t.itemId, t.userId),
++ index("drive_shares_user_idx").on(t.userId),
++]);
++
++export const schema = {
++ users,
++ domains,
++ mailboxes,
++ mailboxAliases,
++ autoReplyDeliveries,
++ mailboxAccess,
++ contacts,
++ folders,
++ apiKeys,
++ messages,
++ spamTokenStats,
++ spamReputation,
++ spamFeedback,
++ messageAttachments,
++ sharedAttachmentLinks,
++ outboundJobs,
++ emailTemplates,
++ calendarEvents,
++ bookingEvents,
++ routingRules,
++ webhooks,
++ webhookDeliveries,
++ sessions,
++ pushSubscriptions,
++ driveItems,
++ driveUploadParts,
++ driveShares,
++ auditLogs,
++ backupSettings,
++ backups,
++ appSettings,
++ licenseSettings,
++ mailboxAgentSettings,
++ aiUsage,
++ agentConversations,
++ agentChatMessages,
++ agentJobs,
++ agentDraftMetadata,
++ agentSendApprovals,
++ mcpKeyMailboxes,
++};