refactor(api): ♻️ Convery more routes to use OpenAPI

api/api/v1/accounts/:id/follow.ts

@@ -1,10 +1,11 @@
-import { apiRoute, applyConfig, auth, handleZodError } from "@/api";
-import { zValidator } from "@hono/zod-validator";
+import { apiRoute, applyConfig, auth } from "@/api";
+import { createRoute } from "@hono/zod-openapi";
 import ISO6391 from "iso-639-1";
 import { z } from "zod";
 import { RolePermissions } from "~/drizzle/schema";
 import { Relationship } from "~/packages/database-interface/relationship";
 import { User } from "~/packages/database-interface/user";
+import { ErrorSchema } from "~/types/api";
 
 export const meta = applyConfig({
     allowedMethods: ["POST"],
@@ -41,14 +42,52 @@ export const schemas = {
         .default({ reblogs: true, notify: false, languages: [] }),
 };
 
+const route = createRoute({
+    method: "post",
+    path: "/api/v1/accounts/{id}/follow",
+    summary: "Follow user",
+    description: "Follow a user",
+    middleware: [auth(meta.auth, meta.permissions)],
+    responses: {
+        200: {
+            description: "User followed",
+            content: {
+                "application/json": {
+                    schema: Relationship.schema,
+                },
+            },
+        },
+        401: {
+            description: "Unauthorized",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        404: {
+            description: "User not found",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+    },
+    request: {
+        params: schemas.param,
+        body: {
+            content: {
+                "application/json": {
+                    schema: schemas.json,
+                },
+            },
+        },
+    },
+});
+
 export default apiRoute((app) =>
-    app.on(
-        meta.allowedMethods,
-        meta.route,
-        zValidator("param", schemas.param, handleZodError),
-        zValidator("json", schemas.json, handleZodError),
-        auth(meta.auth, meta.permissions),
-        async (context) => {
+    app.openapi(route, async (context) => {
         const { id } = context.req.valid("param");
         const { user } = context.get("auth");
         const { reblogs, notify, languages } = context.req.valid("json");
@@ -76,7 +115,6 @@ export default apiRoute((app) =>
             });
         }
 
-            return context.json(relationship.toApi());
-        },
-    ),
+        return context.json(relationship.toApi(), 200);
+    }),
 );

api/api/v1/accounts/:id/followers.ts

@@ -1,16 +1,11 @@
-import {
-    apiRoute,
-    applyConfig,
-    auth,
-    handleZodError,
-    idValidator,
-} from "@/api";
-import { zValidator } from "@hono/zod-validator";
+import { apiRoute, applyConfig, auth, idValidator } from "@/api";
+import { createRoute } from "@hono/zod-openapi";
 import { and, gt, gte, lt, sql } from "drizzle-orm";
 import { z } from "zod";
 import { RolePermissions, Users } from "~/drizzle/schema";
 import { Timeline } from "~/packages/database-interface/timeline";
 import { User } from "~/packages/database-interface/user";
+import { ErrorSchema } from "~/types/api";
 
 export const meta = applyConfig({
     allowedMethods: ["GET"],
@@ -43,17 +38,46 @@ export const schemas = {
     }),
 };
 
+const route = createRoute({
+    method: "get",
+    path: "/api/v1/accounts/{id}/followers",
+    summary: "Get account followers",
+    description:
+        "Gets an paginated list of accounts that follow the specified account",
+    middleware: [auth(meta.auth, meta.permissions)],
+    request: {
+        params: schemas.param,
+        query: schemas.query,
+    },
+    responses: {
+        200: {
+            description: "A list of accounts that follow the specified account",
+            content: {
+                "application/json": {
+                    schema: z.array(User.schema),
+                },
+            },
+            headers: {
+                Link: {
+                    description: "Links to the next and previous pages",
+                },
+            },
+        },
+        404: {
+            description: "The specified account was not found",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+    },
+});
+
 export default apiRoute((app) =>
-    app.on(
-        meta.allowedMethods,
-        meta.route,
-        zValidator("query", schemas.query, handleZodError),
-        zValidator("param", schemas.param, handleZodError),
-        auth(meta.auth, meta.permissions),
-        async (context) => {
+    app.openapi(route, async (context) => {
         const { id } = context.req.valid("param");
-            const { max_id, since_id, min_id, limit } =
-                context.req.valid("query");
+        const { max_id, since_id, min_id, limit } = context.req.valid("query");
 
         const otherUser = await User.fromId(id);
 
@@ -81,6 +105,5 @@ export default apiRoute((app) =>
                 Link: link,
             },
         );
-        },
-    ),
+    }),
 );

api/api/v1/accounts/:id/following.ts

@@ -1,16 +1,11 @@
-import {
-    apiRoute,
-    applyConfig,
-    auth,
-    handleZodError,
-    idValidator,
-} from "@/api";
-import { zValidator } from "@hono/zod-validator";
+import { apiRoute, applyConfig, auth, idValidator } from "@/api";
+import { createRoute } from "@hono/zod-openapi";
 import { and, gt, gte, lt, sql } from "drizzle-orm";
 import { z } from "zod";
 import { RolePermissions, Users } from "~/drizzle/schema";
 import { Timeline } from "~/packages/database-interface/timeline";
 import { User } from "~/packages/database-interface/user";
+import { ErrorSchema } from "~/types/api";
 
 export const meta = applyConfig({
     allowedMethods: ["GET"],
@@ -43,14 +38,45 @@ export const schemas = {
     }),
 };
 
+const route = createRoute({
+    method: "get",
+    path: "/api/v1/accounts/{id}/following",
+    summary: "Get account following",
+    description:
+        "Gets an paginated list of accounts that the specified account follows",
+    middleware: [auth(meta.auth, meta.permissions)],
+    request: {
+        params: schemas.param,
+        query: schemas.query,
+    },
+    responses: {
+        200: {
+            description:
+                "A list of accounts that the specified account follows",
+            content: {
+                "application/json": {
+                    schema: z.array(User.schema),
+                },
+            },
+            headers: {
+                Link: {
+                    description: "Link to the next page of results",
+                },
+            },
+        },
+        404: {
+            description: "User not found",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+    },
+});
+
 export default apiRoute((app) =>
-    app.on(
-        meta.allowedMethods,
-        meta.route,
-        zValidator("query", schemas.query, handleZodError),
-        zValidator("param", schemas.param, handleZodError),
-        auth(meta.auth, meta.permissions),
-        async (context) => {
+    app.openapi(route, async (context) => {
         const { id } = context.req.valid("param");
         const { max_id, since_id, min_id } = context.req.valid("query");
 
@@ -80,6 +106,5 @@ export default apiRoute((app) =>
                 Link: link,
             },
         );
-        },
-    ),
+    }),
 );

packages/database-interface/emoji.ts

@@ -11,6 +11,7 @@ import {
     eq,
     inArray,
 } from "drizzle-orm";
+import { z } from "zod";
 import { db } from "~/drizzle/db";
 import { Emojis, Instances } from "~/drizzle/schema";
 import { BaseInterface } from "./base";
@@ -21,6 +22,14 @@ export type EmojiWithInstance = InferSelectModel<typeof Emojis> & {
 };
 
 export class Emoji extends BaseInterface<typeof Emojis, EmojiWithInstance> {
+    static schema = z.object({
+        shortcode: z.string(),
+        url: z.string(),
+        visible_in_picker: z.boolean(),
+        category: z.string().optional(),
+        static_url: z.string(),
+    });
+
     async reload(): Promise<void> {
         const reloaded = await Emoji.fromId(this.data.id);
 

packages/database-interface/role.ts

@@ -1,5 +1,5 @@
 import { proxyUrl } from "@/response";
-import type { RolePermission } from "@versia/client/types";
+import { RolePermission } from "@versia/client/types";
 import {
     type InferInsertModel,
     type InferSelectModel,
@@ -9,6 +9,7 @@ import {
     eq,
     inArray,
 } from "drizzle-orm";
+import { z } from "zod";
 import { db } from "~/drizzle/db";
 import { RoleToUsers, Roles } from "~/drizzle/schema";
 import { config } from "~/packages/config-manager/index";
@@ -17,6 +18,16 @@ import { BaseInterface } from "./base";
 export type RoleType = InferSelectModel<typeof Roles>;
 
 export class Role extends BaseInterface<typeof Roles> {
+    static schema = z.object({
+        id: z.string(),
+        name: z.string(),
+        permissions: z.array(z.nativeEnum(RolePermission)),
+        priority: z.number(),
+        description: z.string().nullable(),
+        visible: z.boolean(),
+        icon: z.string().nullable(),
+    });
+
     async reload(): Promise<void> {
         const reloaded = await Role.fromId(this.data.id);
 

packages/database-interface/user.ts

@@ -35,6 +35,7 @@ import {
     sql,
 } from "drizzle-orm";
 import { htmlToText } from "html-to-text";
+import { z } from "zod";
 import {
     type UserWithRelations,
     findManyUsers,
@@ -64,6 +65,57 @@ import { Role } from "./role";
  * Gives helpers to fetch users from database in a nice format
  */
 export class User extends BaseInterface<typeof Users, UserWithRelations> {
+    static schema = z.object({
+        id: z.string(),
+        username: z.string(),
+        acct: z.string(),
+        display_name: z.string(),
+        locked: z.boolean(),
+        discoverable: z.boolean().optional(),
+        group: z.boolean().nullable(),
+        noindex: z.boolean().nullable(),
+        suspended: z.boolean().nullable(),
+        limited: z.boolean().nullable(),
+        created_at: z.string(),
+        followers_count: z.number(),
+        following_count: z.number(),
+        statuses_count: z.number(),
+        note: z.string(),
+        uri: z.string(),
+        url: z.string(),
+        avatar: z.string(),
+        avatar_static: z.string(),
+        header: z.string(),
+        header_static: z.string(),
+        emojis: z.array(Emoji.schema),
+        fields: z.array(
+            z.object({
+                name: z.string(),
+                value: z.string(),
+                verified: z.boolean().nullable().optional(),
+                verified_at: z.string().nullable().optional(),
+            }),
+        ),
+        // FIXME: Use a proper type
+        moved: z.any().nullable(),
+        bot: z.boolean().nullable(),
+        source: z
+            .object({
+                privacy: z.string().nullable(),
+                sensitive: z.boolean().nullable(),
+                language: z.string().nullable(),
+                note: z.string(),
+            })
+            .optional(),
+        role: z
+            .object({
+                name: z.string(),
+            })
+            .optional(),
+        roles: z.array(Role.schema),
+        mute_expires_at: z.string().optional(),
+    });
+
     async reload(): Promise<void> {
         const reloaded = await User.fromId(this.data.id);