making strides in the device and link domain setup

2026-03-27 23:58:06 +02:00
parent 8c45efc92e
commit c7c303a934
17 changed files with 1202 additions and 198 deletions
--- a/packages/logic/domains/link/repository.ts
+++ b/packages/logic/domains/link/repository.ts
@@ -0,0 +1,173 @@
+import { ResultAsync, errAsync, okAsync } from "neverthrow";
+import { FlowExecCtx } from "@core/flow.execution.context";
+import { Database, asc, eq } from "@pkg/db";
+import { link } from "@pkg/db/schema";
+import { type Err } from "@pkg/result";
+import { logger } from "@pkg/logger";
+import { traceResultAsync } from "@core/observability";
+import { CreateLink, Link, LinkWithDevice, UpdateLink } from "./data";
+import { linkErrors } from "./errors";
+
+export class LinkRepository {
+    constructor(private db: Database) {}
+
+    list(fctx: FlowExecCtx): ResultAsync<Link[], Err> {
+        return traceResultAsync({
+            name: "link.list",
+            fctx,
+            fn: () =>
+                ResultAsync.fromPromise(
+                    this.db.select().from(link).orderBy(asc(link.createdAt)),
+                    (e) =>
+                        linkErrors.listFailed(
+                            fctx,
+                            e instanceof Error ? e.message : String(e),
+                        ),
+                ).map((rows) => rows as Link[]),
+        });
+    }
+
+    getById(fctx: FlowExecCtx, id: number): ResultAsync<Link, Err> {
+        return traceResultAsync({
+            name: "link.getById",
+            fctx,
+            fn: () =>
+                ResultAsync.fromPromise(
+                    this.db.query.link.findFirst({ where: eq(link.id, id) }),
+                    (e) =>
+                        linkErrors.dbError(
+                            fctx,
+                            e instanceof Error ? e.message : String(e),
+                        ),
+                ).andThen((row) => {
+                    if (!row) return errAsync(linkErrors.linkNotFound(fctx, id));
+                    return okAsync(row as Link);
+                }),
+        });
+    }
+
+    getByToken(fctx: FlowExecCtx, token: string): ResultAsync<LinkWithDevice, Err> {
+        return traceResultAsync({
+            name: "link.getByToken",
+            fctx,
+            fn: () =>
+                ResultAsync.fromPromise(
+                    this.db.query.link.findFirst({
+                        where: eq(link.token, token),
+                        with: { device: true },
+                    }),
+                    (e) =>
+                        linkErrors.dbError(
+                            fctx,
+                            e instanceof Error ? e.message : String(e),
+                        ),
+                ).andThen((row) => {
+                    if (!row) return errAsync(linkErrors.linkNotFound(fctx, token));
+                    return okAsync(row as LinkWithDevice);
+                }),
+        });
+    }
+
+    create(fctx: FlowExecCtx, data: CreateLink): ResultAsync<Link, Err> {
+        logger.info("Creating link", { ...fctx, token: data.token });
+
+        return traceResultAsync({
+            name: "link.create",
+            fctx,
+            fn: () =>
+                ResultAsync.fromPromise(
+                    this.db
+                        .insert(link)
+                        .values({
+                            token: data.token,
+                            status: "active",
+                            linkedDeviceId: data.linkedDeviceId ?? null,
+                            expiresAt: data.expiresAt ?? null,
+                            createdAt: new Date(),
+                            updatedAt: new Date(),
+                        })
+                        .returning()
+                        .execute(),
+                    (e) =>
+                        linkErrors.createFailed(
+                            fctx,
+                            e instanceof Error ? e.message : String(e),
+                        ),
+                ).map((rows) => rows[0] as Link),
+        });
+    }
+
+    update(
+        fctx: FlowExecCtx,
+        id: number,
+        updates: UpdateLink,
+    ): ResultAsync<Link, Err> {
+        return traceResultAsync({
+            name: "link.update",
+            fctx,
+            fn: () =>
+                this.getById(fctx, id).andThen(() =>
+                    ResultAsync.fromPromise(
+                        this.db
+                            .update(link)
+                            .set({ ...updates, updatedAt: new Date() })
+                            .where(eq(link.id, id))
+                            .returning()
+                            .execute(),
+                        (e) =>
+                            linkErrors.updateFailed(
+                                fctx,
+                                e instanceof Error ? e.message : String(e),
+                            ),
+                    ).andThen((rows) => {
+                        if (!rows[0])
+                            return errAsync(linkErrors.linkNotFound(fctx, id));
+                        return okAsync(rows[0] as Link);
+                    }),
+                ),
+        });
+    }
+
+    delete(fctx: FlowExecCtx, id: number): ResultAsync<boolean, Err> {
+        return traceResultAsync({
+            name: "link.delete",
+            fctx,
+            fn: () =>
+                this.getById(fctx, id).andThen(() =>
+                    ResultAsync.fromPromise(
+                        this.db.delete(link).where(eq(link.id, id)).execute(),
+                        (e) =>
+                            linkErrors.deleteFailed(
+                                fctx,
+                                e instanceof Error ? e.message : String(e),
+                            ),
+                    ).map(() => true),
+                ),
+        });
+    }
+
+    touch(fctx: FlowExecCtx, token: string): ResultAsync<Link, Err> {
+        return traceResultAsync({
+            name: "link.touch",
+            fctx,
+            fn: () =>
+                ResultAsync.fromPromise(
+                    this.db
+                        .update(link)
+                        .set({ lastAccessedAt: new Date(), updatedAt: new Date() })
+                        .where(eq(link.token, token))
+                        .returning()
+                        .execute(),
+                    (e) =>
+                        linkErrors.updateFailed(
+                            fctx,
+                            e instanceof Error ? e.message : String(e),
+                        ),
+                ).andThen((rows) => {
+                    if (!rows[0])
+                        return errAsync(linkErrors.linkNotFound(fctx, token));
+                    return okAsync(rows[0] as Link);
+                }),
+        });
+    }
+}