refactor: make drizzle handle json

drizzle/0000_absurd_kitty_pryde.sql drizzle/0000_boring_exiles.sql

···
 --> statement-breakpoint
 CREATE TABLE `oauth_session` (
 	`did` text PRIMARY KEY NOT NULL,
-	`session_json` text NOT NULL,
+	`session` text NOT NULL,
 	`updated_at` integer NOT NULL
 );
 --> statement-breakpoint
 CREATE INDEX `oauth_session_updated_at_idx` ON `oauth_session` (`updated_at`);--> statement-breakpoint
 CREATE TABLE `oauth_state` (
 	`key` text PRIMARY KEY NOT NULL,
-	`state_json` text NOT NULL,
+	`state` text NOT NULL,
 	`expires_at` integer NOT NULL
 );
 --> statement-breakpoint
 CREATE INDEX `oauth_state_expires_at_idx` ON `oauth_state` (`expires_at`);--> statement-breakpoint
 CREATE TABLE `profile` (
 	`did` text PRIMARY KEY NOT NULL,
-	`display_name` text,
-	`record_json` text NOT NULL,
+	`record` text NOT NULL,
 	`indexed_at` integer NOT NULL
 );
 --> statement-breakpoint
···
 	`uri` text PRIMARY KEY NOT NULL,
 	`author_did` text NOT NULL,
 	`rkey` text NOT NULL,
-	`status` text NOT NULL,
-	`created_at` text NOT NULL,
+	`record` text NOT NULL,
+	`sort_at` integer NOT NULL,
 	`indexed_at` integer NOT NULL
 );
 --> statement-breakpoint
-CREATE INDEX `status_indexed_at_idx` ON `status` (`indexed_at`);
+CREATE INDEX `status_sort_at_idx` ON `status` (`sort_at`);

drizzle/meta/0000_snapshot.json

···
 {
   "version": "6",
   "dialect": "sqlite",
-  "id": "78dc97fb-2759-4aba-b927-e6b7d1d2ac73",
+  "id": "ca02a5fe-d4e6-42ad-a03e-3b5cd85f3302",
   "prevId": "00000000-0000-0000-0000-000000000000",
   "tables": {
     "identity": {
···
           "notNull": true,
           "autoincrement": false
         },
-        "session_json": {
-          "name": "session_json",
+        "session": {
+          "name": "session",
           "type": "text",
           "primaryKey": false,
           "notNull": true,
···
           "notNull": true,
           "autoincrement": false
         },
-        "state_json": {
-          "name": "state_json",
+        "state": {
+          "name": "state",
           "type": "text",
           "primaryKey": false,
           "notNull": true,
···
           "notNull": true,
           "autoincrement": false
         },
-        "display_name": {
-          "name": "display_name",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "autoincrement": false
-        },
-        "record_json": {
-          "name": "record_json",
+        "record": {
+          "name": "record",
           "type": "text",
           "primaryKey": false,
           "notNull": true,
···
           "notNull": true,
           "autoincrement": false
         },
-        "status": {
-          "name": "status",
+        "record": {
+          "name": "record",
           "type": "text",
           "primaryKey": false,
           "notNull": true,
           "autoincrement": false
         },
-        "created_at": {
-          "name": "created_at",
-          "type": "text",
+        "sort_at": {
+          "name": "sort_at",
+          "type": "integer",
           "primaryKey": false,
           "notNull": true,
           "autoincrement": false
···
         }
       },
       "indexes": {
-        "status_indexed_at_idx": {
-          "name": "status_indexed_at_idx",
+        "status_sort_at_idx": {
+          "name": "status_sort_at_idx",
           "columns": [
-            "indexed_at"
+            "sort_at"
           ],
           "isUnique": false
         }

drizzle/meta/_journal.json

···
     {
       "idx": 0,
       "version": "6",
-      "when": 1765706992228,
-      "tag": "0000_absurd_kitty_pryde",
+      "when": 1765708606190,
+      "tag": "0000_boring_exiles",
       "breakpoints": true
     }
   ]

src/lib/components/status-picker.svelte

···
 									handle: user.handle,
 									displayName: user.displayName,
 								},
-								status: data.status,
+								record: {
+									$type: 'xyz.statusphere.status',
+									status: data.status,
+									createdAt: new Date().toISOString(),
+								},
 								indexedAt: new Date().toISOString(),
 							},
 							...current.statuses,

src/lib/components/timeline.svelte

···
 	<div class="timeline">
 		{#each statuses as item}
 			<div class="item">
-				<div class="emoji">{item.status}</div>
+				<div class="emoji">{item.record.status}</div>
 				<div class="content">
 					<a
 						href={getBskyProfileUrl(item.author.handle)}

src/lib/server/db/schema.ts

···
 import { index, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
 
+import type { AppBskyActorProfile } from '@atcute/bluesky';
+import type { StoredSession, StoredState } from '@atcute/oauth-node-client';
+
+import type { XyzStatusphereStatus } from '$lib/lexicons';
+
 export const oauthState = sqliteTable(
 	'oauth_state',
 	{
 		key: text('key').primaryKey(),
-		stateJson: text('state_json').notNull(),
+		state: text('state', { mode: 'json' }).$type<StoredState>().notNull(),
 		expiresAt: integer('expires_at').notNull(),
 	},
 	(table) => [index('oauth_state_expires_at_idx').on(table.expiresAt)],
···
 	'oauth_session',
 	{
 		did: text('did').primaryKey(),
-		sessionJson: text('session_json').notNull(),
+		session: text('session', { mode: 'json' }).$type<StoredSession>().notNull(),
 		updatedAt: integer('updated_at').notNull(),
 	},
 	(table) => [index('oauth_session_updated_at_idx').on(table.updatedAt)],
···
 
 export const profile = sqliteTable('profile', {
 	did: text('did').primaryKey(),
-	displayName: text('display_name'),
-	recordJson: text('record_json').notNull(),
+	record: text('record', { mode: 'json' }).$type<AppBskyActorProfile.Main>().notNull(),
 	indexedAt: integer('indexed_at').notNull(),
 });
 
···
 		uri: text('uri').primaryKey(),
 		authorDid: text('author_did').notNull(),
 		rkey: text('rkey').notNull(),
-		status: text('status').notNull(),
-		createdAt: text('created_at').notNull(),
+		record: text('record', { mode: 'json' }).$type<XyzStatusphereStatus.Main>().notNull(),
+		sortAt: integer('sort_at').notNull(),
 		indexedAt: integer('indexed_at').notNull(),
 	},
-	(table) => [index('status_indexed_at_idx').on(table.indexedAt)],
+	(table) => [index('status_sort_at_idx').on(table.sortAt)],
 );

src/lib/server/oauth/stores.ts

···
 	sessions: {
 		async get(did: Did) {
 			const row = await db.select().from(oauthSession).where(eq(oauthSession.did, did)).get();
-			if (!row) {
-				return;
-			}
-
-			return JSON.parse(row.sessionJson) as StoredSession;
+			return row?.session;
 		},
-		async set(did: Did, value: StoredSession) {
-			const sessionJson = JSON.stringify(value);
+		async set(did: Did, session: StoredSession) {
 			const updatedAt = Date.now();
 
 			await db
 				.insert(oauthSession)
-				.values({ did, sessionJson, updatedAt })
+				.values({ did, session, updatedAt })
 				.onConflictDoUpdate({
 					target: oauthSession.did,
-					set: { sessionJson, updatedAt },
+					set: { session, updatedAt },
 				})
 				.run();
 		},
···
 				return;
 			}
 
-			return JSON.parse(row.stateJson) as StoredState;
+			return row.state;
 		},
-		async set(key: string, value: StoredState) {
-			const stateJson = JSON.stringify(value);
-			const expiresAt = value.expiresAt;
+		async set(key: string, state: StoredState) {
+			const expiresAt = state.expiresAt;
 
 			await db
 				.insert(oauthState)
-				.values({ key, stateJson, expiresAt })
+				.values({ key, state, expiresAt })
 				.onConflictDoUpdate({
 					target: oauthState.key,
-					set: { stateJson, expiresAt },
+					set: { state, expiresAt },
 				})
 				.run();
 		},

src/lib/server/tap/ingest.ts

···
 import { db } from '$lib/server/db';
 import { identity, profile, status } from '$lib/server/db/schema';
 
-const now = () => Date.now();
-
 const toAtUri = (did: string, collection: string, rkey: string): string => {
 	return `at://${did}/${collection}/${rkey}`;
 };
···
  */
 export const ingestTapEvent = async (event: TapEvent): Promise<void> => {
 	if (event.type === 'identity') {
+		const updatedAt = Date.now();
+
 		await db
 			.insert(identity)
 			.values({
···
 				handle: event.handle,
 				isActive: event.isActive,
 				status: event.status,
-				updatedAt: now(),
+				updatedAt,
 			})
 			.onConflictDoUpdate({
 				target: identity.did,
···
 					handle: event.handle,
 					isActive: event.isActive,
 					status: event.status,
-					updatedAt: now(),
+					updatedAt,
 				},
 			})
 			.run();
···
 			return;
 		}
 
-		const record = event.record;
-		if (!record) {
-			return;
-		}
-
-		const parsed = safeParse(AppBskyActorProfile.mainSchema, record);
+		const parsed = safeParse(AppBskyActorProfile.mainSchema, event.record);
 		if (!parsed.ok) {
 			return;
 		}
 
-		const indexedAt = now();
-		const recordJson = JSON.stringify(parsed.value);
+		const record = parsed.value;
+		const indexedAt = Date.now();
 
 		await db
 			.insert(profile)
 			.values({
 				did: event.did,
-				displayName: parsed.value.displayName ?? null,
-				recordJson,
+				record,
 				indexedAt,
 			})
 			.onConflictDoUpdate({
 				target: profile.did,
 				set: {
-					displayName: parsed.value.displayName ?? null,
-					recordJson,
+					record,
 					indexedAt,
 				},
 			})
···
 			return;
 		}
 
-		const record = event.record;
-		if (!record) {
-			return;
-		}
-
-		const parsed = safeParse(XyzStatusphereStatus.mainSchema, record);
+		const parsed = safeParse(XyzStatusphereStatus.mainSchema, event.record);
 		if (!parsed.ok) {
 			return;
 		}
 
-		const indexedAt = now();
+		const record = parsed.value;
+		const indexedAt = Date.now();
+		const sortAt = Math.min(Date.parse(record.createdAt), indexedAt);
 
 		await db
 			.insert(status)
···
 				uri,
 				authorDid: event.did,
 				rkey: event.rkey,
-				status: parsed.value.status,
-				createdAt: parsed.value.createdAt,
+				record,
+				sortAt,
 				indexedAt,
 			})
 			.onConflictDoUpdate({
 				target: status.uri,
 				set: {
-					status: parsed.value.status,
+					record,
 					indexedAt,
 				},
 			})

src/lib/status.remote.ts

···
 	return {
 		did,
 		handle: (identity?.handle ?? 'handle.invalid') as Handle,
-		displayName: profile?.displayName ?? undefined,
+		displayName: profile?.record.displayName ?? undefined,
 	};
 });
 
-const encodeCursor = (indexedAt: number, uri: string): string => {
-	return `${indexedAt}:${uri}`;
+const encodeCursor = (sortAt: number, uri: string): string => {
+	return `${sortAt}:${uri}`;
 };
 
 const cursorSchema = v.pipe(
···
 			return NEVER;
 		}
 
-		const indexedAt = parseInt(input.slice(0, idx), 10);
+		const sortAt = parseInt(input.slice(0, idx), 10);
 		const uri = input.slice(idx + 1);
 
-		if (Number.isNaN(indexedAt) || !uri) {
+		if (Number.isNaN(sortAt) || !uri) {
 			addIssue({ message: 'invalid cursor format' });
 			return NEVER;
 		}
 
-		return { indexedAt, uri };
+		return { sortAt, uri };
 	}),
 );
 
···
 		// insert locally so we don't have to wait for ingester
 		{
 			const uri: CanonicalResourceUri = `at://${session.did}/xyz.statusphere.status/${rkey}`;
+			const indexedAt = Date.now();
+			const sortAt = Math.min(Date.parse(createdAt), indexedAt);
+
 			await db
 				.insert(schema.status)
 				.values({
 					uri,
 					authorDid: session.did,
 					rkey,
-					status,
-					createdAt,
-					indexedAt: Date.now(),
+					record,
+					sortAt,
+					indexedAt,
 				})
 				.onConflictDoNothing()
 				.run();
···
 
 export interface StatusView {
 	author: AuthorView;
-	status: string;
+	record: XyzStatusphereStatus.Main;
 	indexedAt: string;
 }
 
···
 			.where(
 				cursor
 					? or(
-							lt(schema.status.indexedAt, cursor.indexedAt),
-							and(eq(schema.status.indexedAt, cursor.indexedAt), lt(schema.status.uri, cursor.uri)),
+							lt(schema.status.sortAt, cursor.sortAt),
+							and(eq(schema.status.sortAt, cursor.sortAt), lt(schema.status.uri, cursor.uri)),
 						)
 					: undefined,
 			)
-			.orderBy(desc(schema.status.indexedAt), desc(schema.status.uri))
+			.orderBy(desc(schema.status.sortAt), desc(schema.status.uri))
 			.limit(limit + 1)
 			.all();
 
···
 		const statuses = items.map((s): StatusView => {
 			const identity = identityMap.get(s.authorDid);
 			const profile = profileMap.get(s.authorDid);
-			const indexedAt = Math.min(Date.parse(s.createdAt), s.indexedAt);
 
 			return {
 				author: {
 					did: s.authorDid as Did,
 					handle: (identity?.handle ?? 'handle.invalid') as Handle,
-					displayName: profile?.displayName ?? undefined,
+					displayName: profile?.record.displayName ?? undefined,
 				},
-				status: s.status,
-				indexedAt: new Date(indexedAt).toISOString(),
+				record: s.record,
+				indexedAt: new Date(s.sortAt).toISOString(),
 			};
 		});
 
 		const last = items[items.length - 1];
 
 		return {
-			cursor: hasMore && last ? encodeCursor(last.indexedAt, last.uri) : undefined,
+			cursor: hasMore && last ? encodeCursor(last.sortAt, last.uri) : undefined,
 			statuses,
 		};
 	},