refactor: ♻️ Rewrite build system to fit the monorepo architecture

packages/kit/db/like.ts

@@ -0,0 +1,182 @@
+import * as VersiaEntities from "@versia/sdk/entities";
+import { config } from "@versia-server/config";
+import {
+    and,
+    desc,
+    eq,
+    type InferInsertModel,
+    type InferSelectModel,
+    inArray,
+    type SQL,
+} from "drizzle-orm";
+import { db } from "../tables/db.ts";
+import {
+    Likes,
+    type Notes,
+    Notifications,
+    type Users,
+} from "../tables/schema.ts";
+import { BaseInterface } from "./base.ts";
+import { User } from "./user.ts";
+
+type LikeType = InferSelectModel<typeof Likes> & {
+    liker: InferSelectModel<typeof Users>;
+    liked: InferSelectModel<typeof Notes>;
+};
+
+export class Like extends BaseInterface<typeof Likes, LikeType> {
+    public static $type: LikeType;
+
+    public async reload(): Promise<void> {
+        const reloaded = await Like.fromId(this.data.id);
+
+        if (!reloaded) {
+            throw new Error("Failed to reload like");
+        }
+
+        this.data = reloaded.data;
+    }
+
+    public static async fromId(id: string | null): Promise<Like | null> {
+        if (!id) {
+            return null;
+        }
+
+        return await Like.fromSql(eq(Likes.id, id));
+    }
+
+    public static async fromIds(ids: string[]): Promise<Like[]> {
+        return await Like.manyFromSql(inArray(Likes.id, ids));
+    }
+
+    public static async fromSql(
+        sql: SQL<unknown> | undefined,
+        orderBy: SQL<unknown> | undefined = desc(Likes.id),
+    ): Promise<Like | null> {
+        const found = await db.query.Likes.findFirst({
+            where: sql,
+            orderBy,
+            with: {
+                liked: true,
+                liker: true,
+            },
+        });
+
+        if (!found) {
+            return null;
+        }
+        return new Like(found);
+    }
+
+    public static async manyFromSql(
+        sql: SQL<unknown> | undefined,
+        orderBy: SQL<unknown> | undefined = desc(Likes.id),
+        limit?: number,
+        offset?: number,
+        extra?: Parameters<typeof db.query.Likes.findMany>[0],
+    ): Promise<Like[]> {
+        const found = await db.query.Likes.findMany({
+            where: sql,
+            orderBy,
+            limit,
+            offset,
+            with: {
+                liked: true,
+                liker: true,
+                ...extra?.with,
+            },
+        });
+
+        return found.map((s) => new Like(s));
+    }
+
+    public async update(newRole: Partial<LikeType>): Promise<LikeType> {
+        await db.update(Likes).set(newRole).where(eq(Likes.id, this.id));
+
+        const updated = await Like.fromId(this.data.id);
+
+        if (!updated) {
+            throw new Error("Failed to update like");
+        }
+
+        return updated.data;
+    }
+
+    public save(): Promise<LikeType> {
+        return this.update(this.data);
+    }
+
+    public async delete(): Promise<void> {
+        await db.delete(Likes).where(eq(Likes.id, this.id));
+    }
+
+    public static async insert(
+        data: InferInsertModel<typeof Likes>,
+    ): Promise<Like> {
+        const inserted = (await db.insert(Likes).values(data).returning())[0];
+
+        const like = await Like.fromId(inserted.id);
+
+        if (!like) {
+            throw new Error("Failed to insert like");
+        }
+
+        return like;
+    }
+
+    public get id(): string {
+        return this.data.id;
+    }
+
+    public async clearRelatedNotifications(): Promise<void> {
+        await db
+            .delete(Notifications)
+            .where(
+                and(
+                    eq(Notifications.accountId, this.id),
+                    eq(Notifications.type, "favourite"),
+                    eq(Notifications.notifiedId, this.data.liked.authorId),
+                    eq(Notifications.noteId, this.data.liked.id),
+                ),
+            );
+    }
+
+    public getUri(): URL {
+        return new URL(`/likes/${this.data.id}`, config.http.base_url);
+    }
+
+    public toVersia(): VersiaEntities.Like {
+        return new VersiaEntities.Like({
+            id: this.data.id,
+            author: User.getUri(
+                this.data.liker.id,
+                this.data.liker.uri ? new URL(this.data.liker.uri) : null,
+            ).href,
+            type: "pub.versia:likes/Like",
+            created_at: new Date(this.data.createdAt).toISOString(),
+            liked: this.data.liked.uri
+                ? new URL(this.data.liked.uri).href
+                : new URL(`/notes/${this.data.liked.id}`, config.http.base_url)
+                      .href,
+            uri: this.getUri().href,
+        });
+    }
+
+    public unlikeToVersia(unliker?: User): VersiaEntities.Delete {
+        return new VersiaEntities.Delete({
+            type: "Delete",
+            id: crypto.randomUUID(),
+            created_at: new Date().toISOString(),
+            author: User.getUri(
+                unliker?.id ?? this.data.liker.id,
+                unliker?.data.uri
+                    ? new URL(unliker.data.uri)
+                    : this.data.liker.uri
+                      ? new URL(this.data.liker.uri)
+                      : null,
+            ).href,
+            deleted_type: "pub.versia:likes/Like",
+            deleted: this.getUri().href,
+        });
+    }
+}