refactor(api): ♻️ Finish first pass of OpenAPI refactor

api/api/v1/statuses/:id/context.ts

@@ -1,8 +1,9 @@
-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 { z } from "zod";
 import { RolePermissions } from "~/drizzle/schema";
 import { Note } from "~/packages/database-interface/note";
+import { ErrorSchema } from "~/types/api";
 
 export const meta = applyConfig({
     allowedMethods: ["GET"],
@@ -25,13 +26,39 @@ export const schemas = {
     }),
 };
 
+const route = createRoute({
+    method: "get",
+    path: "/api/v1/statuses/{id}/context",
+    middleware: [auth(meta.auth, meta.permissions)],
+    summary: "Get status context",
+    request: {
+        params: schemas.param,
+    },
+    responses: {
+        200: {
+            description: "Status context",
+            content: {
+                "application/json": {
+                    schema: z.object({
+                        ancestors: z.array(Note.schema),
+                        descendants: z.array(Note.schema),
+                    }),
+                },
+            },
+        },
+        404: {
+            description: "Record not found",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+    },
+});
+
 export default apiRoute((app) =>
-    app.on(
-        meta.allowedMethods,
-        meta.route,
-        zValidator("param", schemas.param, handleZodError),
-        auth(meta.auth, meta.permissions),
-        async (context) => {
+    app.openapi(route, async (context) => {
         const { id } = context.req.valid("param");
 
         const { user } = context.get("auth");
@@ -46,14 +73,16 @@ export default apiRoute((app) =>
 
         const descendants = await foundStatus.getDescendants(user ?? null);
 
-            return context.json({
+        return context.json(
+            {
                 ancestors: await Promise.all(
                     ancestors.map((status) => status.toApi(user)),
                 ),
                 descendants: await Promise.all(
                     descendants.map((status) => status.toApi(user)),
                 ),
-            });
             },
-    ),
+            200,
+        );
+    }),
 );

api/api/v1/statuses/:id/favourite.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 { z } from "zod";
 import { createLike } from "~/classes/functions/like";
 import { db } from "~/drizzle/db";
 import { RolePermissions } from "~/drizzle/schema";
 import { Note } from "~/packages/database-interface/note";
+import { ErrorSchema } from "~/types/api";
 
 export const meta = applyConfig({
     allowedMethods: ["POST"],
@@ -27,13 +28,44 @@ export const schemas = {
     }),
 };
 
+const route = createRoute({
+    method: "post",
+    path: "/api/v1/statuses/{id}/favourite",
+    summary: "Favourite a status",
+    middleware: [auth(meta.auth, meta.permissions)],
+    request: {
+        params: schemas.param,
+    },
+    responses: {
+        200: {
+            description: "Favourited status",
+            content: {
+                "application/json": {
+                    schema: Note.schema,
+                },
+            },
+        },
+        401: {
+            description: "Unauthorized",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        404: {
+            description: "Record not found",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+    },
+});
+
 export default apiRoute((app) =>
-    app.on(
-        meta.allowedMethods,
-        meta.route,
-        zValidator("param", schemas.param, handleZodError),
-        auth(meta.auth, meta.permissions),
-        async (context) => {
+    app.openapi(route, async (context) => {
         const { id } = context.req.valid("param");
 
         const { user } = context.get("auth");
@@ -50,10 +82,7 @@ export default apiRoute((app) =>
 
         const existingLike = await db.query.Likes.findFirst({
             where: (like, { and, eq }) =>
-                    and(
-                        eq(like.likedId, note.data.id),
-                        eq(like.likerId, user.id),
-                    ),
+                and(eq(like.likedId, note.data.id), eq(like.likerId, user.id)),
         });
 
         if (!existingLike) {
@@ -66,7 +95,6 @@ export default apiRoute((app) =>
             return context.json({ error: "Record not found" }, 404);
         }
 
-            return context.json(await newNote.toApi(user));
-        },
-    ),
+        return context.json(await newNote.toApi(user), 200);
+    }),
 );

api/api/v1/statuses/:id/favourited_by.ts

@@ -1,16 +1,12 @@
-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 { Note } from "~/packages/database-interface/note";
 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"],
@@ -39,16 +35,46 @@ export const schemas = {
     }),
 };
 
+const route = createRoute({
+    method: "get",
+    path: "/api/v1/statuses/{id}/favourited_by",
+    summary: "Get users who favourited a status",
+    middleware: [auth(meta.auth, meta.permissions)],
+    request: {
+        params: schemas.param,
+        query: schemas.query,
+    },
+    responses: {
+        200: {
+            description: "Users who favourited a status",
+            content: {
+                "application/json": {
+                    schema: z.array(User.schema),
+                },
+            },
+        },
+        401: {
+            description: "Unauthorized",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        404: {
+            description: "Record 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) => {
-            const { max_id, since_id, min_id, limit } =
-                context.req.valid("query");
+    app.openapi(route, async (context) => {
+        const { max_id, since_id, min_id, limit } = context.req.valid("query");
         const { id } = context.req.valid("param");
 
         const { user } = context.get("auth");
@@ -81,6 +107,5 @@ export default apiRoute((app) =>
                 Link: link,
             },
         );
-        },
-    ),
+    }),
 );

api/api/v1/statuses/:id/index.ts

@@ -1,18 +1,12 @@
-import {
-    apiRoute,
-    applyConfig,
-    auth,
-    handleZodError,
-    idValidator,
-    jsonOrForm,
-} from "@/api";
-import { zValidator } from "@hono/zod-validator";
+import { apiRoute, applyConfig, auth, idValidator, jsonOrForm } from "@/api";
+import { createRoute } from "@hono/zod-openapi";
 import ISO6391 from "iso-639-1";
 import { z } from "zod";
 import { RolePermissions } from "~/drizzle/schema";
 import { config } from "~/packages/config-manager/index";
 import { Attachment } from "~/packages/database-interface/attachment";
 import { Note } from "~/packages/database-interface/note";
+import { ErrorSchema } from "~/types/api";
 
 export const meta = applyConfig({
     allowedMethods: ["GET", "DELETE", "PUT"],
@@ -95,18 +89,181 @@ export const schemas = {
         ),
 };
 
-export default apiRoute((app) =>
-    app.on(
-        meta.allowedMethods,
-        meta.route,
-        jsonOrForm(),
-        zValidator("param", schemas.param, handleZodError),
-        zValidator("json", schemas.json, handleZodError),
-        auth(meta.auth, meta.permissions),
-        async (context) => {
+const routeGet = createRoute({
+    method: "get",
+    path: "/api/v1/statuses/{id}",
+    summary: "Get status",
+    middleware: [auth(meta.auth, meta.permissions)],
+    request: {
+        params: schemas.param,
+    },
+    responses: {
+        200: {
+            description: "Status",
+            content: {
+                "application/json": {
+                    schema: Note.schema,
+                },
+            },
+        },
+        404: {
+            description: "Record not found",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+    },
+});
+
+const routeDelete = createRoute({
+    method: "delete",
+    path: "/api/v1/statuses/{id}",
+    summary: "Delete a status",
+    middleware: [auth(meta.auth, meta.permissions)],
+    request: {
+        params: schemas.param,
+    },
+    responses: {
+        200: {
+            description: "Deleted status",
+            content: {
+                "application/json": {
+                    schema: Note.schema,
+                },
+            },
+        },
+        401: {
+            description: "Unauthorized",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        404: {
+            description: "Record not found",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+    },
+});
+
+const routePut = createRoute({
+    method: "put",
+    path: "/api/v1/statuses/{id}",
+    summary: "Update a status",
+    middleware: [auth(meta.auth, meta.permissions), jsonOrForm()],
+    request: {
+        params: schemas.param,
+        body: {
+            content: {
+                "application/json": {
+                    schema: schemas.json,
+                },
+                "application/x-www-form-urlencoded": {
+                    schema: schemas.json,
+                },
+                "multipart/form-data": {
+                    schema: schemas.json,
+                },
+            },
+        },
+    },
+    responses: {
+        200: {
+            description: "Updated status",
+            content: {
+                "application/json": {
+                    schema: Note.schema,
+                },
+            },
+        },
+        401: {
+            description: "Unauthorized",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        404: {
+            description: "Record not found",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        422: {
+            description: "Invalid media IDs",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+    },
+});
+
+export default apiRoute((app) => {
+    app.openapi(routeGet, async (context) => {
         const { id } = context.req.valid("param");
         const { user } = context.get("auth");
 
+        const note = await Note.fromId(id, user?.id);
+
+        if (!note?.isViewableByUser(user)) {
+            return context.json({ error: "Record not found" }, 404);
+        }
+
+        return context.json(await note.toApi(user), 200);
+    });
+
+    app.openapi(routeDelete, async (context) => {
+        const { id } = context.req.valid("param");
+        const { user } = context.get("auth");
+
+        const note = await Note.fromId(id, user?.id);
+
+        if (!note?.isViewableByUser(user)) {
+            return context.json({ error: "Record not found" }, 404);
+        }
+
+        if (note.author.id !== user?.id) {
+            return context.json({ error: "Unauthorized" }, 401);
+        }
+
+        // TODO: Delete and redraft
+        await note.delete();
+
+        await user.federateToFollowers(note.deleteToVersia());
+
+        return context.json(await note.toApi(user), 200);
+    });
+
+    app.openapi(routePut, async (context) => {
+        const { id } = context.req.valid("param");
+        const { user } = context.get("auth");
+
+        if (!user) {
+            return context.json({ error: "Unauthorized" }, 401);
+        }
+
+        const note = await Note.fromId(id, user?.id);
+
+        if (!note?.isViewableByUser(user)) {
+            return context.json({ error: "Record not found" }, 404);
+        }
+
+        if (note.author.id !== user.id) {
+            return context.json({ error: "Unauthorized" }, 401);
+        }
+
         // TODO: Polls
         const {
             status: statusText,
@@ -116,47 +273,11 @@ export default apiRoute((app) =>
             sensitive,
         } = context.req.valid("json");
 
-            const note = await Note.fromId(id, user?.id);
-
-            if (!note?.isViewableByUser(user)) {
-                return context.json({ error: "Record not found" }, 404);
-            }
-
-            switch (context.req.method) {
-                case "GET": {
-                    return context.json(await note.toApi(user));
-                }
-                case "DELETE": {
-                    if (note.author.id !== user?.id) {
-                        return context.json({ error: "Unauthorized" }, 401);
-                    }
-
-                    // TODO: Delete and redraft
-
-                    await note.delete();
-
-                    await user.federateToFollowers(note.deleteToVersia());
-
-                    return context.json(await note.toApi(user), 200);
-                }
-                case "PUT": {
-                    if (!user) {
-                        return context.json({ error: "Unauthorized" }, 401);
-                    }
-
-                    if (note.author.id !== user.id) {
-                        return context.json({ error: "Unauthorized" }, 401);
-                    }
-
         if (media_ids.length > 0) {
-                        const foundAttachments =
-                            await Attachment.fromIds(media_ids);
+            const foundAttachments = await Attachment.fromIds(media_ids);
 
             if (foundAttachments.length !== media_ids.length) {
-                            return context.json(
-                                { error: "Invalid media IDs" },
-                                422,
-                            );
+                return context.json({ error: "Invalid media IDs" }, 422);
             }
         }
 
@@ -175,9 +296,6 @@ export default apiRoute((app) =>
             mediaAttachments: media_ids,
         });
 
-                    return context.json(await newNote.toApi(user));
-                }
-            }
-        },
-    ),
-);
+        return context.json(await newNote.toApi(user), 200);
+    });
+});

api/api/v1/statuses/:id/pin.ts

@@ -1,15 +1,10 @@
-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 { z } from "zod";
 import { db } from "~/drizzle/db";
 import { RolePermissions } from "~/drizzle/schema";
 import { Note } from "~/packages/database-interface/note";
+import { ErrorSchema } from "~/types/api";
 
 export const meta = applyConfig({
     allowedMethods: ["POST"],
@@ -32,13 +27,52 @@ export const schemas = {
     }),
 };
 
+const route = createRoute({
+    method: "post",
+    path: "/api/v1/statuses/{id}/pin",
+    summary: "Pin a status",
+    middleware: [auth(meta.auth, meta.permissions)],
+    request: {
+        params: schemas.param,
+    },
+    responses: {
+        200: {
+            description: "Pinned status",
+            content: {
+                "application/json": {
+                    schema: Note.schema,
+                },
+            },
+        },
+        401: {
+            description: "Unauthorized",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        404: {
+            description: "Record not found",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        422: {
+            description: "Already pinned",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+    },
+});
+
 export default apiRoute((app) =>
-    app.on(
-        meta.allowedMethods,
-        meta.route,
-        zValidator("param", schemas.param, handleZodError),
-        auth(meta.auth, meta.permissions),
-        async (context) => {
+    app.openapi(route, async (context) => {
         const { id } = context.req.valid("param");
         const { user } = context.get("auth");
 
@@ -70,7 +104,6 @@ export default apiRoute((app) =>
 
         await user.pin(foundStatus);
 
-            return context.json(await foundStatus.toApi(user));
-        },
-    ),
+        return context.json(await foundStatus.toApi(user), 200);
+    }),
 );

api/api/v1/statuses/:id/reblog.ts

@@ -1,10 +1,11 @@
-import { apiRoute, applyConfig, auth, handleZodError, jsonOrForm } from "@/api";
-import { zValidator } from "@hono/zod-validator";
+import { apiRoute, applyConfig, auth, jsonOrForm } from "@/api";
+import { createRoute } from "@hono/zod-openapi";
 import { and, eq } from "drizzle-orm";
 import { z } from "zod";
 import { db } from "~/drizzle/db";
 import { Notes, Notifications, RolePermissions } from "~/drizzle/schema";
 import { Note } from "~/packages/database-interface/note";
+import { ErrorSchema } from "~/types/api";
 
 export const meta = applyConfig({
     allowedMethods: ["POST"],
@@ -30,15 +31,73 @@ export const schemas = {
     }),
 };
 
+const route = createRoute({
+    method: "post",
+    path: "/api/v1/statuses/{id}/reblog",
+    summary: "Reblog a status",
+    middleware: [auth(meta.auth, meta.permissions), jsonOrForm()],
+    request: {
+        params: schemas.param,
+        body: {
+            content: {
+                "application/json": {
+                    schema: schemas.json,
+                },
+                "application/x-www-form-urlencoded": {
+                    schema: schemas.json,
+                },
+                "multipart/form-data": {
+                    schema: schemas.json,
+                },
+            },
+        },
+    },
+    responses: {
+        201: {
+            description: "Reblogged status",
+            content: {
+                "application/json": {
+                    schema: Note.schema,
+                },
+            },
+        },
+        401: {
+            description: "Unauthorized",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        404: {
+            description: "Record not found",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        422: {
+            description: "Already reblogged",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        500: {
+            description: "Failed to reblog",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+    },
+});
+
 export default apiRoute((app) =>
-    app.on(
-        meta.allowedMethods,
-        meta.route,
-        jsonOrForm(),
-        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 { visibility } = context.req.valid("json");
         const { user } = context.get("auth");
@@ -92,7 +151,6 @@ export default apiRoute((app) =>
             });
         }
 
-            return context.json(await finalNewReblog.toApi(user));
-        },
-    ),
+        return context.json(await finalNewReblog.toApi(user), 201);
+    }),
 );

api/api/v1/statuses/:id/reblogged_by.ts

@@ -1,10 +1,12 @@
-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 { and, gt, gte, lt, sql } from "drizzle-orm";
 import { z } from "zod";
 import { RolePermissions, Users } from "~/drizzle/schema";
 import { Note } from "~/packages/database-interface/note";
 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"],
@@ -33,17 +35,47 @@ export const schemas = {
     }),
 };
 
+const route = createRoute({
+    method: "get",
+    path: "/api/v1/statuses/{id}/reblogged_by",
+    summary: "Get users who reblogged a status",
+    middleware: [auth(meta.auth, meta.permissions)],
+    request: {
+        params: schemas.param,
+        query: schemas.query,
+    },
+    responses: {
+        200: {
+            description: "Users who reblogged a status",
+            content: {
+                "application/json": {
+                    schema: z.array(User.schema),
+                },
+            },
+        },
+        401: {
+            description: "Unauthorized",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        404: {
+            description: "Record not found",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+    },
+});
+
 export default apiRoute((app) =>
-    app.on(
-        meta.allowedMethods,
-        meta.route,
-        zValidator("param", schemas.param, handleZodError),
-        zValidator("query", schemas.query, handleZodError),
-        auth(meta.auth, meta.permissions),
-        async (context) => {
+    app.openapi(route, async (context) => {
         const { id } = context.req.valid("param");
-            const { max_id, min_id, since_id, limit } =
-                context.req.valid("query");
+        const { max_id, min_id, since_id, limit } = context.req.valid("query");
         const { user } = context.get("auth");
 
         if (!user) {
@@ -74,6 +106,5 @@ export default apiRoute((app) =>
                 Link: link,
             },
         );
-        },
-    ),
+    }),
 );

api/api/v1/statuses/:id/source.ts

@@ -1,9 +1,10 @@
-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 type { StatusSource as ApiStatusSource } from "@versia/client/types";
 import { z } from "zod";
 import { RolePermissions } from "~/drizzle/schema";
 import { Note } from "~/packages/database-interface/note";
+import { ErrorSchema } from "~/types/api";
 
 export const meta = applyConfig({
     allowedMethods: ["GET"],
@@ -26,13 +27,48 @@ export const schemas = {
     }),
 };
 
+const route = createRoute({
+    method: "get",
+    path: "/api/v1/statuses/{id}/source",
+    summary: "Get status source",
+    middleware: [auth(meta.auth, meta.permissions)],
+    request: {
+        params: schemas.param,
+    },
+    responses: {
+        200: {
+            description: "Status source",
+            content: {
+                "application/json": {
+                    schema: z.object({
+                        id: z.string().uuid(),
+                        spoiler_text: z.string(),
+                        text: z.string(),
+                    }),
+                },
+            },
+        },
+        401: {
+            description: "Unauthorized",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        404: {
+            description: "Record not found",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+    },
+});
+
 export default apiRoute((app) =>
-    app.on(
-        meta.allowedMethods,
-        meta.route,
-        zValidator("param", schemas.param, handleZodError),
-        auth(meta.auth, meta.permissions),
-        async (context) => {
+    app.openapi(route, async (context) => {
         const { id } = context.req.valid("param");
         const { user } = context.get("auth");
 
@@ -46,12 +82,14 @@ export default apiRoute((app) =>
             return context.json({ error: "Record not found" }, 404);
         }
 
-            return context.json({
+        return context.json(
+            {
                 id: status.id,
                 // TODO: Give real source for spoilerText
                 spoiler_text: status.data.spoilerText,
                 text: status.data.contentSource,
-            } as ApiStatusSource);
-        },
-    ),
+            } satisfies ApiStatusSource,
+            200,
+        );
+    }),
 );

api/api/v1/statuses/:id/unfavourite.ts

@@ -1,9 +1,10 @@
-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 { z } from "zod";
 import { deleteLike } from "~/classes/functions/like";
 import { RolePermissions } from "~/drizzle/schema";
 import { Note } from "~/packages/database-interface/note";
+import { ErrorSchema } from "~/types/api";
 
 export const meta = applyConfig({
     allowedMethods: ["POST"],
@@ -26,13 +27,44 @@ export const schemas = {
     }),
 };
 
+const route = createRoute({
+    method: "post",
+    path: "/api/v1/statuses/{id}/unfavourite",
+    summary: "Unfavourite a status",
+    middleware: [auth(meta.auth, meta.permissions)],
+    request: {
+        params: schemas.param,
+    },
+    responses: {
+        200: {
+            description: "Unfavourited status",
+            content: {
+                "application/json": {
+                    schema: Note.schema,
+                },
+            },
+        },
+        401: {
+            description: "Unauthorized",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        404: {
+            description: "Record not found",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+    },
+});
+
 export default apiRoute((app) =>
-    app.on(
-        meta.allowedMethods,
-        meta.route,
-        zValidator("param", schemas.param, handleZodError),
-        auth(meta.auth, meta.permissions),
-        async (context) => {
+    app.openapi(route, async (context) => {
         const { id } = context.req.valid("param");
         const { user } = context.get("auth");
 
@@ -54,7 +86,6 @@ export default apiRoute((app) =>
             return context.json({ error: "Record not found" }, 404);
         }
 
-            return context.json(await newNote.toApi(user));
-        },
-    ),
+        return context.json(await newNote.toApi(user), 200);
+    }),
 );

api/api/v1/statuses/:id/unpin.ts

@@ -1,8 +1,9 @@
-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 { z } from "zod";
 import { RolePermissions } from "~/drizzle/schema";
 import { Note } from "~/packages/database-interface/note";
+import { ErrorSchema } from "~/types/api";
 
 export const meta = applyConfig({
     allowedMethods: ["POST"],
@@ -25,13 +26,44 @@ export const schemas = {
     }),
 };
 
+const route = createRoute({
+    method: "post",
+    path: "/api/v1/statuses/{id}/unpin",
+    summary: "Unpin a status",
+    middleware: [auth(meta.auth, meta.permissions)],
+    request: {
+        params: schemas.param,
+    },
+    responses: {
+        200: {
+            description: "Unpinned status",
+            content: {
+                "application/json": {
+                    schema: Note.schema,
+                },
+            },
+        },
+        401: {
+            description: "Unauthorized",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        404: {
+            description: "Record not found",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+    },
+});
+
 export default apiRoute((app) =>
-    app.on(
-        meta.allowedMethods,
-        meta.route,
-        zValidator("param", schemas.param, handleZodError),
-        auth(meta.auth, meta.permissions),
-        async (context) => {
+    app.openapi(route, async (context) => {
         const { id } = context.req.valid("param");
         const { user } = context.get("auth");
 
@@ -55,7 +87,6 @@ export default apiRoute((app) =>
             return context.json({ error: "Record not found" }, 404);
         }
 
-            return context.json(await status.toApi(user));
-        },
-    ),
+        return context.json(await status.toApi(user), 200);
+    }),
 );

api/api/v1/statuses/:id/unreblog.ts

@@ -1,9 +1,10 @@
-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 { and, eq } from "drizzle-orm";
 import { z } from "zod";
 import { Notes, RolePermissions } from "~/drizzle/schema";
 import { Note } from "~/packages/database-interface/note";
+import { ErrorSchema } from "~/types/api";
 
 export const meta = applyConfig({
     allowedMethods: ["POST"],
@@ -26,13 +27,52 @@ export const schemas = {
     }),
 };
 
+const route = createRoute({
+    method: "post",
+    path: "/api/v1/statuses/{id}/unreblog",
+    summary: "Unreblog a status",
+    middleware: [auth(meta.auth, meta.permissions)],
+    request: {
+        params: schemas.param,
+    },
+    responses: {
+        200: {
+            description: "Unreblogged status",
+            content: {
+                "application/json": {
+                    schema: Note.schema,
+                },
+            },
+        },
+        401: {
+            description: "Unauthorized",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        404: {
+            description: "Record not found",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        422: {
+            description: "Not already reblogged",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+    },
+});
+
 export default apiRoute((app) =>
-    app.on(
-        meta.allowedMethods,
-        meta.route,
-        zValidator("param", schemas.param, handleZodError),
-        auth(meta.auth, meta.permissions),
-        async (context) => {
+    app.openapi(route, async (context) => {
         const { id } = context.req.valid("param");
         const { user } = context.get("auth");
 
@@ -70,7 +110,6 @@ export default apiRoute((app) =>
             return context.json({ error: "Record not found" }, 404);
         }
 
-            return context.json(await newNote.toApi(user));
-        },
-    ),
+        return context.json(await newNote.toApi(user), 200);
+    }),
 );

api/api/v1/statuses/index.test.ts

@@ -154,7 +154,7 @@ describe(meta.route, () => {
             }),
         });
 
-        expect(response.status).toBe(200);
+        expect(response.status).toBe(201);
         expect(response.headers.get("content-type")).toContain(
             "application/json",
         );
@@ -179,7 +179,7 @@ describe(meta.route, () => {
             }),
         });
 
-        expect(response.status).toBe(200);
+        expect(response.status).toBe(201);
         expect(response.headers.get("content-type")).toContain(
             "application/json",
         );
@@ -216,7 +216,7 @@ describe(meta.route, () => {
             }),
         });
 
-        expect(response2.status).toBe(200);
+        expect(response2.status).toBe(201);
         expect(response2.headers.get("content-type")).toContain(
             "application/json",
         );
@@ -253,7 +253,7 @@ describe(meta.route, () => {
             }),
         });
 
-        expect(response2.status).toBe(200);
+        expect(response2.status).toBe(201);
         expect(response2.headers.get("content-type")).toContain(
             "application/json",
         );
@@ -276,7 +276,7 @@ describe(meta.route, () => {
             }),
         });
 
-        expect(response.status).toBe(200);
+        expect(response.status).toBe(201);
         expect(response.headers.get("content-type")).toContain(
             "application/json",
         );
@@ -303,7 +303,7 @@ describe(meta.route, () => {
                 }),
             });
 
-            expect(response.status).toBe(200);
+            expect(response.status).toBe(201);
             expect(response.headers.get("content-type")).toContain(
                 "application/json",
             );
@@ -332,7 +332,7 @@ describe(meta.route, () => {
                 }),
             });
 
-            expect(response.status).toBe(200);
+            expect(response.status).toBe(201);
             expect(response.headers.get("content-type")).toContain(
                 "application/json",
             );
@@ -361,7 +361,7 @@ describe(meta.route, () => {
                 }),
             });
 
-            expect(response.status).toBe(200);
+            expect(response.status).toBe(201);
             expect(response.headers.get("content-type")).toContain(
                 "application/json",
             );
@@ -387,7 +387,7 @@ describe(meta.route, () => {
                 }),
             });
 
-            expect(response.status).toBe(200);
+            expect(response.status).toBe(201);
             expect(response.headers.get("content-type")).toContain(
                 "application/json",
             );
@@ -411,7 +411,7 @@ describe(meta.route, () => {
                 }),
             });
 
-            expect(response.status).toBe(200);
+            expect(response.status).toBe(201);
             expect(response.headers.get("content-type")).toContain(
                 "application/json",
             );

api/api/v1/statuses/index.ts

@@ -1,11 +1,12 @@
-import { apiRoute, applyConfig, auth, handleZodError, jsonOrForm } from "@/api";
-import { zValidator } from "@hono/zod-validator";
+import { apiRoute, applyConfig, auth, jsonOrForm } from "@/api";
+import { createRoute } from "@hono/zod-openapi";
 import ISO6391 from "iso-639-1";
 import { z } from "zod";
 import { RolePermissions } from "~/drizzle/schema";
 import { config } from "~/packages/config-manager/index";
 import { Attachment } from "~/packages/database-interface/attachment";
 import { Note } from "~/packages/database-interface/note";
+import { ErrorSchema } from "~/types/api";
 
 export const meta = applyConfig({
     allowedMethods: ["POST"],
@@ -100,14 +101,56 @@ export const schemas = {
         ),
 };
 
+const route = createRoute({
+    method: "post",
+    path: "/api/v1/statuses",
+    middleware: [auth(meta.auth, meta.permissions), jsonOrForm()],
+    summary: "Post a new status",
+    request: {
+        body: {
+            content: {
+                "application/json": {
+                    schema: schemas.json,
+                },
+                "application/x-www-form-urlencoded": {
+                    schema: schemas.json,
+                },
+                "multipart/form-data": {
+                    schema: schemas.json,
+                },
+            },
+        },
+    },
+    responses: {
+        201: {
+            description: "The new status",
+            content: {
+                "application/json": {
+                    schema: Note.schema,
+                },
+            },
+        },
+        401: {
+            description: "Unauthorized",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+        422: {
+            description: "Invalid data",
+            content: {
+                "application/json": {
+                    schema: ErrorSchema,
+                },
+            },
+        },
+    },
+});
+
 export default apiRoute((app) =>
-    app.on(
-        meta.allowedMethods,
-        meta.route,
-        jsonOrForm(),
-        zValidator("json", schemas.json, handleZodError),
-        auth(meta.auth, meta.permissions),
-        async (context) => {
+    app.openapi(route, async (context) => {
         const { user, application } = context.get("auth");
 
         if (!user) {
@@ -144,10 +187,7 @@ export default apiRoute((app) =>
         }
 
         if (quote_id && !(await Note.fromId(quote_id))) {
-                return context.json(
-                    { error: "Invalid quote_id (not found)" },
-                    422,
-                );
+            return context.json({ error: "Invalid quote_id (not found)" }, 422);
         }
 
         const newNote = await Note.fromData({
@@ -171,7 +211,6 @@ export default apiRoute((app) =>
             await newNote.federateToUsers();
         }
 
-            return context.json(await newNote.toApi(user));
-        },
-    ),
+        return context.json(await newNote.toApi(user), 201);
+    }),
 );