feat(src/core/api.ts): move db calls here from server/index

src/core/api.ts

···
 import { is, type ActorIdentifier } from '@atcute/lexicons';
 import type { CreateCommit, DeleteCommit } from '@atcute/jetstream';
 import * as schema from "../db/schema"
+import { DEFAULT_MARKET_COLS, DEFAULT_BET_COLS, DEFAULT_RESOLUTION_COLS } from '../db/schema';
 import { eq } from 'drizzle-orm';
+
 
 export const db = drizzle(process.env.DATABASE_URL!, { schema });
 
+export async function tryListMarkets() {
+    return await db.query.marketsTable.findMany({
+        columns: DEFAULT_MARKET_COLS,
+        orderBy: (markets, { desc }) => [desc(markets.createdAt)],
+        with: {
+            bets: { columns: DEFAULT_BET_COLS },
+            resolution: { columns: DEFAULT_RESOLUTION_COLS }
+        },
+    })
+}
+
+export async function tryFindMarket(uri: string) {
+    return await db.query.marketsTable.findFirst({
+        columns: DEFAULT_MARKET_COLS,
+        where: eq(schema.marketsTable.uri, uri),
+        with: {
+            bets: { columns: DEFAULT_BET_COLS },
+            resolution: { columns: DEFAULT_RESOLUTION_COLS }
+        }
+    })
+}
+
+export async function tryFindMarketBets(uri: string) {
+    return await db.query.betsTable.findMany({
+        columns: DEFAULT_BET_COLS,
+        where: eq(schema.betsTable.marketUri, uri),
+        orderBy: (bets, { desc }) => [desc(bets.createdAt)],
+        with: {
+            market: {
+                columns: DEFAULT_MARKET_COLS,
+                with: { resolution: { columns: DEFAULT_RESOLUTION_COLS } }
+            }
+        }
+    })
+}
+
+export async function tryFindMarketResolutions(uri: string) {
+    return await db.query.resolutionsTable.findFirst({
+        columns: DEFAULT_RESOLUTION_COLS,
+        where: eq(schema.resolutionsTable.marketUri, uri),
+        orderBy: (resolutions, { desc }) => [desc(resolutions.createdAt)],
+        with: {
+            market: {
+                columns: DEFAULT_MARKET_COLS,
+                with: { bets: { columns: DEFAULT_BET_COLS } }
+            }
+        }
+    })
+}
+
 export async function tryCreateMarket(did: ActorIdentifier, { record, rev, rkey, cid }: CreateCommit) {
     if (is(ZaCoCiaranCumulusMarket.mainSchema, record)) {
         const uri = `at://${did}/${record.$type}/${rkey}`;
         console.log("> Creating Market:", uri);
+
         const { question, liquidity } = record;
         const [closesAt, createdAt] = [new Date(record.closesAt), new Date(record.createdAt)];
 

src/db/schema.ts

···
     closesAt: timestamp({ withTimezone: true }).notNull(),
 });
 
+export const DEFAULT_MARKET_COLS = {
+    uri: true,
+    did: true,
+    cid: true,
+    question: true,
+    liquidity: true,
+    closesAt: true,
+    createdAt: true,
+}
+
 export const betsTable = pgTable("bets", {
     ...SHARED_SCHEMA,
     position: betPositionEnum().notNull(),
     marketUri: text().notNull(),
 });
 
+export const DEFAULT_BET_COLS = {
+    uri: true,
+    did: true,
+    cid: true,
+    position: true,
+    createdAt: true,
+}
+
 export const resolutionsTable = pgTable("resolutions", {
     ...SHARED_SCHEMA,
     answer: resolutionAnswerEnum().notNull(),
     marketUri: text().notNull(),
 });
+
+export const DEFAULT_RESOLUTION_COLS = {
+    uri: true,
+    did: true,
+    cid: true,
+    answer: true,
+    createdAt: true,
+}
 
 export const marketsRelations = relations(marketsTable, ({ many, one }) => ({
     bets: many(betsTable),

src/server/index.ts

···
 import { staticPlugin } from '@elysiajs/static'
 import { swagger } from '@elysiajs/swagger'
 import { cors } from '@elysiajs/cors'
-import { drizzle } from "drizzle-orm/node-postgres";
-import * as schema from "../db/schema"
-import { eq } from "drizzle-orm";
-
-const db = drizzle(process.env.DATABASE_URL!, { schema });
+import { tryFindMarket, tryFindMarketBets, tryFindMarketResolutions, tryListMarkets } from "@/core/api";
 
 export const app = new Elysia()
     .use(cors())
     .use(swagger())
     .use(staticPlugin({ prefix: "/", assets: "dist" }))
     .get("/", () => new Response(Bun.file("dist/index.html")))
-    .group("/api", (app) => (
-        app.get("/markets", async () =>
-            Response.json(await db.query.marketsTable.findMany({
-                with: { bets: true, resolution: true },
-                orderBy: (markets, { desc }) => [desc(markets.createdAt)],
-            }))
-        ).group("/market", (app) => (
-            app.get("/:uri", async ({ params: { uri } }) =>
-                Response.json(await db.query.marketsTable.findFirst({
-                    where: eq(schema.marketsTable.uri, uri),
-                    with: { bets: true, resolution: true }
-                }))
-            ).get("/:uri/bets", async ({ params: { uri } }) =>
-                Response.json(await db.query.betsTable.findMany({
-                    where: eq(schema.betsTable.marketUri, uri),
-                    with: {
-                        market: { with: { resolution: true } }
-                    }
-                }))
-            ).get("/:uri/resolutions", async ({ params: { uri } }) =>
-                Response.json(await db.query.resolutionsTable.findMany({
-                    where: eq(schema.resolutionsTable.marketUri, uri),
-                    with: {
-                        market: { with: { bets: true } }
-                    }
-                }))
-            )
-        ))
-    ))
-    .listen({ port: process.env.PORT!, hostname: "0.0.0.0" })
+    .group("/api", api => api
+        .get("/markets", async () => await tryListMarkets())
+        .group("/market", (market) => market
+            .get("/:uri", async ({ params }) => await tryFindMarket(params.uri))
+            .get("/:uri/bets", async ({ params }) => await tryFindMarketBets(params.uri))
+            .get("/:uri/resolutions", async ({ params }) => await tryFindMarketResolutions(params.uri))
+        )
+    ).listen({ port: process.env.PORT!, hostname: "0.0.0.0" })
 
 console.log(`> Server running on ${app.server?.protocol}://${app.server?.hostname}:${app.server?.port}`);