Refactor db.ts to use kysely statements

src/controllers/activitypub/actor.ts

@@ -1,5 +1,5 @@
 import { getAuthor } from '@/client.ts';
-import { db } from '@/db.ts';
+import { findUser } from '@/db/users.ts';
 import { toActor } from '@/transformers/nostr-to-activitypub.ts';
 import { activityJson } from '@/utils.ts';
 
@@ -8,7 +8,7 @@ import type { AppContext, AppController } from '@/app.ts';
 const actorController: AppController = async (c) => {
   const username = c.req.param('username');
 
-  const user = db.getUserByUsername(username);
+  const user = await findUser({ username });
   if (!user) return notFound(c);
 
   const event = await getAuthor(user.pubkey);

src/controllers/well-known/nostr.ts

@@ -1,5 +1,5 @@
 import { Conf } from '@/config.ts';
-import { db } from '@/db.ts';
+import { findUser } from '@/db/users.ts';
 import { z } from '@/deps.ts';
 
 import type { AppController } from '@/app.ts';
@@ -10,9 +10,9 @@ const nameSchema = z.string().min(1).regex(/^\w+$/);
  * Serves NIP-05's nostr.json.
  * https://github.com/nostr-protocol/nips/blob/master/05.md
  */
-const nostrController: AppController = (c) => {
+const nostrController: AppController = async (c) => {
   const name = nameSchema.safeParse(c.req.query('name'));
-  const user = name.success ? db.getUserByUsername(name.data) : null;
+  const user = name.success ? await findUser({ username: name.data }) : null;
 
   if (!user) return c.json({ names: {}, relays: {} });
 

src/controllers/well-known/webfinger.ts

@@ -4,6 +4,7 @@ import { nip19, z } from '@/deps.ts';
 
 import type { AppContext, AppController } from '@/app.ts';
 import type { Webfinger } from '@/schemas/webfinger.ts';
+import { findUser } from '@/db/users.ts';
 
 const webfingerQuerySchema = z.object({
   resource: z.string().url(),
@@ -36,14 +37,14 @@ const acctSchema = z.custom<URL>((value) => value instanceof URL)
     path: ['resource', 'acct'],
   });
 
-function handleAcct(c: AppContext, resource: URL): Response {
+async function handleAcct(c: AppContext, resource: URL): Promise<Response> {
   const result = acctSchema.safeParse(resource);
   if (!result.success) {
     return c.json({ error: 'Invalid acct URI', schema: result.error }, 400);
   }
 
   const [username, host] = result.data;
-  const user = db.getUserByUsername(username);
+  const user = await findUser({ username });
 
   if (!user) {
     return c.json({ error: 'Not found' }, 404);

src/db.ts

@@ -1,19 +1,39 @@
-import { type Filter, Sqlite } from '@/deps.ts';
-import { SignedEvent } from '@/event.ts';
+import { DenoSqliteDialect, Kysely, Sqlite } from '@/deps.ts';
 
-interface User {
+interface Tables {
+  events: EventRow;
+  tags: TagRow;
+  users: UserRow;
+}
+
+interface EventRow {
+  id: string;
+  kind: number;
+  pubkey: string;
+  content: string;
+  created_at: number;
+  tags: string;
+  sig: string;
+}
+
+interface TagRow {
+  tag: string;
+  value_1: string | null;
+  value_2: string | null;
+  value_3: string | null;
+  event_id: string;
+}
+
+interface UserRow {
   pubkey: string;
   username: string;
   inserted_at: Date;
 }
 
-class DittoDB {
-  #db: Sqlite;
+const sqlite = new Sqlite('data/db.sqlite3');
 
-  constructor(db: Sqlite) {
-    this.#db = db;
-
-    this.#db.execute(`
+// TODO: move this into a proper migration
+sqlite.execute(`
   CREATE TABLE IF NOT EXISTS events (
     id TEXT PRIMARY KEY,
     kind INTEGER NOT NULL,
@@ -48,67 +68,11 @@ class DittoDB {
 
   CREATE UNIQUE INDEX IF NOT EXISTS idx_users_username ON users(username);
 `);
-  }
 
-  insertUser(user: Pick<User, 'pubkey' | 'username'>): void {
-    this.#db.query(
-      'INSERT INTO users(pubkey, username) VALUES (?, ?)',
-      [user.pubkey, user.username],
-    );
-  }
-
-  getUserByUsername(username: string): User | null {
-    const result = this.#db.query<[string, string, Date]>(
-      'SELECT pubkey, username, inserted_at FROM users WHERE username = ?',
-      [username],
-    )[0];
-    if (!result) return null;
-    return {
-      pubkey: result[0],
-      username: result[1],
-      inserted_at: result[2],
-    };
-  }
-
-  insertEvent(event: SignedEvent): void {
-    this.#db.transaction(() => {
-      this.#db.query(
-        `
-        INSERT INTO events(id, kind, pubkey, content, created_at, tags, sig)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
-      `,
-        [
-          event.id,
-          event.kind,
-          event.pubkey,
-          event.content,
-          event.created_at,
-          JSON.stringify(event.tags),
-          event.sig,
-        ],
-      );
-
-      for (const [tag, value1, value2, value3] of event.tags) {
-        if (['p', 'e', 'q', 'd', 't', 'proxy'].includes(tag)) {
-          this.#db.query(
-            `
-            INSERT INTO tags(event_id, tag, value_1, value_2, value_3)
-            VALUES (?, ?, ?, ?, ?)
-          `,
-            [event.id, tag, value1 || null, value2 || null, value3 || null],
-          );
-        }
-      }
+const db = new Kysely<Tables>({
+  dialect: new DenoSqliteDialect({
+    database: sqlite,
+  }),
 });
-  }
 
-  getFilter<K extends number = number>(_filter: Filter<K>) {
-    // TODO
-  }
-}
-
-const db = new DittoDB(
-  new Sqlite('data/db.sqlite3'),
-);
-
-export { db };
+export { db, type EventRow, type TagRow, type UserRow };

src/db/events.ts

@@ -0,0 +1,39 @@
+import { type Filter, type Insertable } from '@/deps.ts';
+import { type SignedEvent } from '@/event.ts';
+
+import { db, type TagRow } from '../db.ts';
+
+function insertEvent(event: SignedEvent): Promise<void> {
+  return db.transaction().execute(async (trx) => {
+    await trx.insertInto('events')
+      .values({
+        ...event,
+        tags: JSON.stringify(event.tags),
+      })
+      .executeTakeFirst();
+
+    const tags = event.tags.reduce<Insertable<TagRow>[]>((results, tag) => {
+      if (['p', 'e', 'q', 'd', 't', 'proxy'].includes(tag[0])) {
+        results.push({
+          event_id: event.id,
+          tag: tag[0],
+          value_1: tag[1] || null,
+          value_2: tag[2] || null,
+          value_3: tag[3] || null,
+        });
+      }
+
+      return results;
+    }, []);
+
+    await trx.insertInto('tags')
+      .values(tags)
+      .execute();
+  });
+}
+
+function getFilter<K extends number = number>(_filter: Filter<K>) {
+  // TODO
+}
+
+export { getFilter, insertEvent };

src/db/users.ts

@@ -0,0 +1,27 @@
+import { type Insertable } from '@/deps.ts';
+
+import { db, type UserRow } from '../db.ts';
+
+/** Adds a user to the database. */
+function insertUser(user: Insertable<UserRow>) {
+  return db.insertInto('users').values(user).execute();
+}
+
+/**
+ * Finds a single user based on one or more properties.
+ *
+ * ```ts
+ * await findUser({ username: 'alex' });
+ * ```
+ */
+function findUser(user: Partial<Insertable<UserRow>>) {
+  let query = db.selectFrom('users').selectAll();
+
+  for (const [key, value] of Object.entries(user)) {
+    query = query.where(key as keyof UserRow, '=', value);
+  }
+
+  return query.executeTakeFirst();
+}
+
+export { findUser, insertUser };

src/deps.ts

@@ -50,5 +50,5 @@ export * as secp from 'npm:@noble/secp256k1@^2.0.0';
 export { LRUCache } from 'npm:lru-cache@^10.0.0';
 export { DB as Sqlite } from 'https://deno.land/x/sqlite@v3.7.3/mod.ts';
 export * as dotenv from 'https://deno.land/std@0.197.0/dotenv/mod.ts';
-export { Kysely } from 'npm:kysely@^0.25.0';
+export { type Insertable, Kysely, type NullableInsertKeys } from 'npm:kysely@^0.25.0';
 export { DenoSqliteDialect } from 'https://gitlab.com/soapbox-pub/kysely-deno-sqlite/-/raw/76748303a45fac64a889cd2b9265c6c9b8ef2e8b/mod.ts';

src/loopback.ts

@@ -1,5 +1,5 @@
 import { Conf } from '@/config.ts';
-import { db } from '@/db.ts';
+import { insertEvent } from '@/db/events.ts';
 import { RelayPool } from '@/deps.ts';
 import { trends } from '@/trends.ts';
 import { nostrDate, nostrNow } from '@/utils.ts';
@@ -22,7 +22,7 @@ relay.subscribe(
 /** Handle events through the loopback pipeline. */
 function handleEvent(event: SignedEvent): void {
   console.info('loopback event:', event.id);
-  db.insertEvent(event);
+  insertEvent(event);
   trackHashtags(event);
 }