refactor: drop db.query

We need typesafe queries, so we can't use sql templates.
However, I want to stay close to raw sql as possible for readability.
(Also LLMs are better at raw sql than typesafe query builders.)
This switches us to db.select().from().where() style queries everywhere.

Author: lishaduck

src/lib/remote/notes.remote.ts

@@ -17,11 +17,10 @@ import { getEncryptedSnapshot } from "$lib/loro.ts";
 export const getNotes = query(async (): Promise<NoteOrFolder[]> => {
   const { user } = requireLogin();
 
-  const userNotes = await db.query.notes.findMany({
-    where: {
-      ownerId: user.id,
-    },
-  });
+  const userNotes = await db
+    .select()
+    .from(notes)
+    .where(eq(notes.ownerId, user.id));
 
   return userNotes.map(
     (n) =>
@@ -66,11 +65,7 @@ export const createNote = command(
         updatedAt: new Date(),
       } satisfies typeof notes.$inferInsert);
 
-      const note = await db.query.notes.findFirst({
-        where: {
-          id: id,
-        },
-      });
+      const [note] = await db.select().from(notes).where(eq(notes.id, id));
 
       if (!note) throw new Error("Failed to find newly created note!");
 
@@ -90,11 +85,7 @@ export const deleteNote = command(
 
     try {
       // Verify ownership
-      const note = await db.query.notes.findFirst({
-        where: {
-          id: noteId,
-        },
-      });
+      const [note] = await db.select().from(notes).where(eq(notes.id, noteId));
 
       if (!note || note.ownerId !== user.id) error(404, "Not found");
 
@@ -118,11 +109,10 @@ export const updateNote = command(
 
     try {
       // Verify ownership
-      const existingNote = await db.query.notes.findFirst({
-        where: {
-          id: noteId,
-        },
-      });
+      const [existingNote] = await db
+        .select()
+        .from(notes)
+        .where(eq(notes.id, noteId));
 
       if (!existingNote || existingNote.ownerId !== user.id) {
         error(404, "Not found");
@@ -139,11 +129,10 @@ export const updateNote = command(
         })
         .where(eq(notes.id, noteId));
 
-      const updated = await db.query.notes.findFirst({
-        where: {
-          id: noteId,
-        },
-      });
+      const [updated] = await db
+        .select()
+        .from(notes)
+        .where(eq(notes.id, noteId));
 
       if (!updated) throw new Error("Failed to find newly created note!");
 

src/lib/remote/sync.remote.ts

@@ -1,7 +1,9 @@
 import { command, getRequestEvent } from "$app/server";
 import { db } from "$lib/server/db/index.ts";
+import * as table from "$lib/server/db/schema.ts";
 import { broadcast } from "$lib/server/real-time.ts";
 import { error } from "@sveltejs/kit";
+import { eq } from "drizzle-orm";
 import { Schema } from "effect";
 import { syncSchema, syncSchemaJson } from "./notes.schemas.ts";
 
@@ -13,11 +15,11 @@ export const sync = command(syncSchema, async ({ noteId, updates }) => {
 
   try {
     // Verify access
-    const note = await db.query.notes.findFirst({
-      where: {
-        id: noteId,
-      },
-    });
+    const note = await db
+      .select()
+      .from(table.notes)
+      .where(eq(table.notes.id, noteId))
+      .get();
 
     if (!note || note.ownerId !== user.id) error(404, "Not found");
 

src/routes/+layout.server.ts

@@ -1,5 +1,7 @@
 import type { User } from "$lib/schema.ts";
 import { db } from "$lib/server/db";
+import * as table from "$lib/server/db/schema.ts";
+import { eq } from "drizzle-orm";
 
 export interface Data {
   user: User | undefined;
@@ -11,22 +13,15 @@ export const load = async ({ locals }): Promise<Data> => {
   if (!localUser) {
     return { user: undefined };
   }
+  const [user] = await db
+    .select({
+      id: table.users.id,
+      username: table.users.username,
+      publicKey: table.users.publicKey,
+      privateKeyEncrypted: table.users.privateKeyEncrypted,
+    })
+    .from(table.users)
+    .where(eq(table.users.id, localUser.id));
 
-  // Get user with private key from database
-  const user = await db.query.users.findFirst({
-    where: {
-      id: localUser.id,
-    },
-  });
-
-  return {
-    user: user
-      ? {
-          id: user.id,
-          username: user.username,
-          publicKey: user.publicKey,
-          privateKeyEncrypted: user.privateKeyEncrypted,
-        }
-      : undefined,
-  };
+  return { user };
 };

src/routes/+page.server.ts

@@ -1,5 +1,5 @@
 import { db } from "$lib/server/db";
-import { notes } from "$lib/server/db/schema";
+import * as table from "$lib/server/db/schema";
 import { and, count, eq } from "drizzle-orm";
 
 // TODO: Make this a remote function instead.
@@ -28,25 +28,26 @@ export const load = async ({ locals }): Promise<Data> => {
   // Get total notes count (excluding folders)
   const totalNotesResult = await db
     .select({ count: count() })
-    .from(notes)
-    .where(and(eq(notes.ownerId, user.id), eq(notes.isFolder, false)));
+    .from(table.notes)
+    .where(
+      and(eq(table.notes.ownerId, user.id), eq(table.notes.isFolder, false)),
+    );
 
   const totalNotes = totalNotesResult[0]?.count ?? 0;
 
   // Get a random note (excluding folders)
   let randomNote = null;
   if (totalNotes > 0) {
-    const userNotes = await db.query.notes.findMany({
-      where: {
-        ownerId: user.id,
-        isFolder: false,
-      },
-      columns: {
-        id: true,
-        title: true,
-        updatedAt: true,
-      },
-    });
+    const userNotes = await db
+      .select({
+        id: table.notes.id,
+        title: table.notes.title,
+        updatedAt: table.notes.updatedAt,
+      })
+      .from(table.notes)
+      .where(
+        and(eq(table.notes.ownerId, user.id), eq(table.notes.isFolder, false)),
+      );
 
     if (userNotes.length > 0) {
       const randomIndex = Math.floor(Math.random() * userNotes.length);

src/routes/api/sync/[noteId]/+server.ts

@@ -1,7 +1,9 @@
 import { syncSchemaJson } from "$lib/remote/notes.schemas.ts";
 import { db } from "$lib/server/db";
+import * as table from "$lib/server/db/schema.ts";
 import { addClient, removeClient } from "$lib/server/real-time";
 import { json } from "@sveltejs/kit";
+import { eq } from "drizzle-orm";
 import { Schema } from "effect";
 
 export const GET = async ({ params, locals }) => {
@@ -15,12 +17,11 @@ export const GET = async ({ params, locals }) => {
   }
 
   // Verify access
-  const note = await db.query.notes.findFirst({
-    where: {
-      id: noteId,
-    },
-  });
-
+  const note = await db
+    .select()
+    .from(table.notes)
+    .where(eq(table.notes.id, noteId))
+    .get();
   if (!note || note.ownerId !== locals.user.id) {
     // TODO: Add check for shared notes when federation via ATProto is implemented
     return json({ error: "Not found or unauthorized" }, { status: 404 });