feat(federation): ✨ Implement Share federation support

api/api/v1/statuses/[id]/reblog.ts

@@ -1,8 +1,4 @@
 import { RolePermission, Status as StatusSchema } from "@versia/client/schemas";
-import { Note } from "@versia/kit/db";
-import { Notes } from "@versia/kit/tables";
-import { randomUUIDv7 } from "bun";
-import { and, eq } from "drizzle-orm";
 import { describeRoute } from "hono-openapi";
 import { resolver, validator } from "hono-openapi/zod";
 import { z } from "zod";
@@ -54,39 +50,9 @@ export default apiRoute((app) =>
             const { user } = context.get("auth");
             const note = context.get("note");
 
-            const existingReblog = await Note.fromSql(
-                and(
-                    eq(Notes.authorId, user.id),
-                    eq(Notes.reblogId, note.data.id),
-                ),
-            );
+            const reblog = await user.reblog(note, visibility);
 
-            if (existingReblog) {
-                return context.json(await existingReblog.toApi(user), 200);
-            }
-
-            const newReblog = await Note.insert({
-                id: randomUUIDv7(),
-                authorId: user.id,
-                reblogId: note.data.id,
-                visibility,
-                sensitive: false,
-                updatedAt: new Date().toISOString(),
-                applicationId: null,
-            });
-
-            // Refetch the note *again* to get the proper value of .reblogged
-            const finalNewReblog = await Note.fromId(newReblog.id, user?.id);
-
-            if (!finalNewReblog) {
-                throw new Error("Failed to reblog");
-            }
-
-            if (note.author.local && user.local) {
-                await note.author.notify("reblog", user, newReblog);
-            }
-
-            return context.json(await finalNewReblog.toApi(user), 200);
+            return context.json(await reblog.toApi(user), 200);
         },
     ),
 );

api/api/v1/statuses/[id]/unreblog.ts

@@ -1,7 +1,5 @@
 import { RolePermission, Status as StatusSchema } from "@versia/client/schemas";
 import { Note } from "@versia/kit/db";
-import { Notes } from "@versia/kit/tables";
-import { and, eq } from "drizzle-orm";
 import { describeRoute } from "hono-openapi";
 import { resolver } from "hono-openapi/zod";
 import { apiRoute, auth, withNoteParam } from "@/api";
@@ -42,22 +40,7 @@ export default apiRoute((app) =>
             const { user } = context.get("auth");
             const note = context.get("note");
 
-            const existingReblog = await Note.fromSql(
-                and(
-                    eq(Notes.authorId, user.id),
-                    eq(Notes.reblogId, note.data.id),
-                ),
-                undefined,
-                user?.id,
-            );
-
-            if (!existingReblog) {
-                return context.json(await note.toApi(user), 200);
-            }
-
-            await existingReblog.delete();
-
-            await user.federateToFollowers(existingReblog.deleteToVersia());
+            await user.unreblog(note);
 
             const newNote = await Note.fromId(note.data.id, user.id);
 

api/inbox/index.test.ts

@@ -6,7 +6,7 @@ import {
     enableRealRequests,
     mock,
 } from "bun-bagel";
-import { eq } from "drizzle-orm";
+import { and, eq } from "drizzle-orm";
 import { Instance } from "~/classes/database/instance";
 import { Note } from "~/classes/database/note";
 import { User } from "~/classes/database/user";
@@ -19,6 +19,7 @@ import { fakeRequest } from "~/tests/utils";
 const instanceUrl = new URL("https://versia.example.com");
 const noteId = randomUUIDv7();
 const userId = randomUUIDv7();
+const shareId = randomUUIDv7();
 const userKeys = await User.generateKeys();
 const privateKey = await crypto.subtle.importKey(
     "pkcs8",
@@ -167,4 +168,57 @@ describe("Inbox Tests", () => {
 
         expect(note).not.toBeNull();
     });
+
+    test("should correctly process Share", async () => {
+        const exampleRequest = new VersiaEntities.Share({
+            id: shareId,
+            created_at: "2025-04-18T10:32:01.427Z",
+            uri: new URL(`/shares/${shareId}`, instanceUrl).href,
+            type: "pub.versia:share/Share",
+            author: new URL(`/users/${userId}`, instanceUrl).href,
+            shared: new URL(`/notes/${noteId}`, instanceUrl).href,
+        });
+
+        const signedRequest = await sign(
+            privateKey,
+            new URL(exampleRequest.data.author),
+            new Request(inboxUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Accept: "application/json",
+                    "User-Agent": "Versia/1.0.0",
+                },
+                body: JSON.stringify(exampleRequest.toJSON()),
+            }),
+        );
+
+        const response = await fakeRequest(inboxUrl, {
+            method: "POST",
+            headers: signedRequest.headers,
+            body: signedRequest.body,
+        });
+
+        expect(response.status).toBe(200);
+
+        await sleep(500);
+
+        const dbNote = await Note.fromSql(
+            eq(Notes.uri, new URL(`/notes/${noteId}`, instanceUrl).href),
+        );
+
+        if (!dbNote) {
+            throw new Error("DBNote not found");
+        }
+
+        // Check if share was created in the database
+        const share = await Note.fromSql(
+            and(
+                eq(Notes.reblogId, dbNote.id),
+                eq(Notes.authorId, dbNote.data.authorId),
+            ),
+        );
+
+        expect(share).not.toBeNull();
+    });
 });

api/notes/[uuid]/quotes.ts

@@ -67,7 +67,7 @@ export default apiRoute((app) =>
                 throw ApiError.noteNotFound();
             }
 
-            const replies = await Note.manyFromSql(
+            const quotes = await Note.manyFromSql(
                 and(
                     eq(Notes.quotingId, note.id),
                     inArray(Notes.visibility, ["public", "unlisted"]),
@@ -77,7 +77,7 @@ export default apiRoute((app) =>
                 offset,
             );
 
-            const replyCount = await db.$count(
+            const quoteCount = await db.$count(
                 Notes,
                 and(
                     eq(Notes.quotingId, note.id),
@@ -92,10 +92,10 @@ export default apiRoute((app) =>
                     config.http.base_url,
                 ).href,
                 last:
-                    replyCount > limit
+                    quoteCount > limit
                         ? new URL(
                               `/notes/${note.id}/quotes?offset=${
-                                  replyCount - limit
+                                  quoteCount - limit
                               }`,
                               config.http.base_url,
                           ).href
@@ -104,7 +104,7 @@ export default apiRoute((app) =>
                               config.http.base_url,
                           ).href,
                 next:
-                    offset + limit < replyCount
+                    offset + limit < quoteCount
                         ? new URL(
                               `/notes/${note.id}/quotes?offset=${
                                   offset + limit
@@ -121,8 +121,8 @@ export default apiRoute((app) =>
                               config.http.base_url,
                           ).href
                         : null,
-                total: replyCount,
-                items: replies.map((reply) => reply.getUri().href),
+                total: quoteCount,
+                items: quotes.map((reply) => reply.getUri().href),
             });
 
             // If base_url uses https and request uses http, rewrite request to use https

api/notes/[uuid]/shares.ts

@@ -0,0 +1,151 @@
+import { Status as StatusSchema } from "@versia/client/schemas";
+import { db, Note } from "@versia/kit/db";
+import { Notes } from "@versia/kit/tables";
+import { and, eq, inArray } from "drizzle-orm";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { z } from "zod";
+import { apiRoute, handleZodError } from "@/api";
+import { ApiError } from "~/classes/errors/api-error";
+import { config } from "~/config.ts";
+import * as VersiaEntities from "~/packages/sdk/entities";
+import { URICollectionSchema } from "~/packages/sdk/schemas";
+
+export default apiRoute((app) =>
+    app.get(
+        "/notes/:id/shares",
+        describeRoute({
+            summary: "Retrieve all shares of a Versia Note.",
+            tags: ["Federation"],
+            responses: {
+                200: {
+                    description: "Note shares",
+                    content: {
+                        "application/json": {
+                            schema: resolver(URICollectionSchema),
+                        },
+                    },
+                },
+                404: {
+                    description:
+                        "Entity not found, is remote, or the requester is not allowed to view it.",
+                    content: {
+                        "application/json": {
+                            schema: resolver(ApiError.zodSchema),
+                        },
+                    },
+                },
+            },
+        }),
+        validator(
+            "param",
+            z.object({
+                id: StatusSchema.shape.id,
+            }),
+            handleZodError,
+        ),
+        validator(
+            "query",
+            z.object({
+                limit: z.coerce.number().int().min(1).max(100).default(40),
+                offset: z.coerce.number().int().nonnegative().default(0),
+            }),
+            handleZodError,
+        ),
+        async (context) => {
+            const { id } = context.req.valid("param");
+            const { limit, offset } = context.req.valid("query");
+
+            const note = await Note.fromSql(
+                and(
+                    eq(Notes.id, id),
+                    inArray(Notes.visibility, ["public", "unlisted"]),
+                ),
+            );
+
+            if (!(note && (await note.isViewableByUser(null))) || note.remote) {
+                throw ApiError.noteNotFound();
+            }
+
+            const shares = await Note.manyFromSql(
+                and(
+                    eq(Notes.reblogId, note.id),
+                    inArray(Notes.visibility, ["public", "unlisted"]),
+                ),
+                undefined,
+                limit,
+                offset,
+            );
+
+            const shareCount = await db.$count(
+                Notes,
+                and(
+                    eq(Notes.reblogId, note.id),
+                    inArray(Notes.visibility, ["public", "unlisted"]),
+                ),
+            );
+
+            const uriCollection = new VersiaEntities.URICollection({
+                author: note.author.uri.href,
+                first: new URL(
+                    `/notes/${note.id}/shares?offset=0`,
+                    config.http.base_url,
+                ).href,
+                last:
+                    shareCount > limit
+                        ? new URL(
+                              `/notes/${note.id}/shares?offset=${
+                                  shareCount - limit
+                              }`,
+                              config.http.base_url,
+                          ).href
+                        : new URL(
+                              `/notes/${note.id}/shares`,
+                              config.http.base_url,
+                          ).href,
+                next:
+                    offset + limit < shareCount
+                        ? new URL(
+                              `/notes/${note.id}/shares?offset=${
+                                  offset + limit
+                              }`,
+                              config.http.base_url,
+                          ).href
+                        : null,
+                previous:
+                    offset - limit >= 0
+                        ? new URL(
+                              `/notes/${note.id}/shares?offset=${
+                                  offset - limit
+                              }`,
+                              config.http.base_url,
+                          ).href
+                        : null,
+                total: shareCount,
+                items: shares.map(
+                    (share) =>
+                        new URL(`/shares/${share.id}`, config.http.base_url)
+                            .href,
+                ),
+            });
+
+            // If base_url uses https and request uses http, rewrite request to use https
+            // This fixes reverse proxy errors
+            const reqUrl = new URL(context.req.url);
+            if (
+                config.http.base_url.protocol === "https:" &&
+                reqUrl.protocol === "http:"
+            ) {
+                reqUrl.protocol = "https:";
+            }
+
+            const { headers } = await note.author.sign(
+                uriCollection,
+                reqUrl,
+                "GET",
+            );
+
+            return context.json(uriCollection, 200, headers.toJSON());
+        },
+    ),
+);

api/shares/[uuid]/index.ts

@@ -0,0 +1,79 @@
+import { Status as StatusSchema } from "@versia/client/schemas";
+import { Note } from "@versia/kit/db";
+import { Notes } from "@versia/kit/tables";
+import { and, eq, inArray } from "drizzle-orm";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { z } from "zod";
+import { apiRoute, handleZodError } from "@/api";
+import { ApiError } from "~/classes/errors/api-error";
+import { config } from "~/config.ts";
+import { ShareSchema } from "~/packages/sdk/schemas";
+
+export default apiRoute((app) =>
+    app.get(
+        "/shares/:id",
+        describeRoute({
+            summary: "Retrieve the Versia representation of a share.",
+            tags: ["Federation"],
+            responses: {
+                200: {
+                    description: "Share",
+                    content: {
+                        "application/json": {
+                            schema: resolver(ShareSchema),
+                        },
+                    },
+                },
+                404: {
+                    description:
+                        "Entity not found, is remote, or the requester is not allowed to view it.",
+                    content: {
+                        "application/json": {
+                            schema: resolver(ApiError.zodSchema),
+                        },
+                    },
+                },
+            },
+        }),
+        validator(
+            "param",
+            z.object({
+                id: StatusSchema.shape.id,
+            }),
+            handleZodError,
+        ),
+        async (context) => {
+            const { id } = context.req.valid("param");
+
+            const note = await Note.fromSql(
+                and(
+                    eq(Notes.id, id),
+                    inArray(Notes.visibility, ["public", "unlisted"]),
+                ),
+            );
+
+            if (!(note && (await note.isViewableByUser(null))) || note.remote) {
+                throw ApiError.noteNotFound();
+            }
+
+            // If base_url uses https and request uses http, rewrite request to use https
+            // This fixes reverse proxy errors
+            const reqUrl = new URL(context.req.url);
+            if (
+                config.http.base_url.protocol === "https:" &&
+                reqUrl.protocol === "http:"
+            ) {
+                reqUrl.protocol = "https:";
+            }
+
+            const { headers } = await note.author.sign(
+                note.toVersiaShare(),
+                reqUrl,
+                "GET",
+            );
+
+            return context.json(note.toVersiaShare(), 200, headers.toJSON());
+        },
+    ),
+);

api/well-known/versia.ts

@@ -47,6 +47,8 @@ export default apiRoute((app) =>
                         extensions: [
                             "pub.versia:custom_emojis",
                             "pub.versia:instance_messaging",
+                            "pub.versia:likes",
+                            "pub.versia:shares",
                         ],
                         versions: ["0.5.0"],
                     },