versia-pub/server
2
0
Fork 0
mirror of https://github.com/versia-pub/server.git synced 2025-12-06 08:28:19 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

refactor(api): ♻️ More OpenAPI refactoring

Browse source
This commit is contained in:
Jesse Wierzbinski 2024-09-15 14:59:21 +02:00
parent b755fc5d62
commit 739bbe935b
No known key found for this signature in database
7 changed files with 471 additions and 297 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

68
api/api/v1/notifications/:id/dismiss.ts
View file

@ -1,9 +1,10 @@
import { apiRoute, applyConfig, auth, handleZodError } from "@/api"; import { apiRoute, applyConfig, auth } from "@/api";
import { zValidator } from "@hono/zod-validator"; import { createRoute } from "@hono/zod-openapi";
import { eq } from "drizzle-orm"; import { eq } from "drizzle-orm";
import { z } from "zod"; import { z } from "zod";
import { db } from "~/drizzle/db"; import { db } from "~/drizzle/db";
import { Notifications, RolePermissions } from "~/drizzle/schema"; import { Notifications, RolePermissions } from "~/drizzle/schema";
import { ErrorSchema } from "~/types/api";
export const meta = applyConfig({ export const meta = applyConfig({
allowedMethods: ["POST"], allowedMethods: ["POST"],
@ -27,28 +28,45 @@ export const schemas = {
}), }),
}; };
export default apiRoute((app) => const route = createRoute({
app.on( method: "post",
meta.allowedMethods, path: "/api/v1/notifications/{id}/dismiss",
meta.route, summary: "Dismiss notification",
zValidator("param", schemas.param, handleZodError), middleware: [auth(meta.auth, meta.permissions)],
auth(meta.auth, meta.permissions), request: {
async (context) => { params: schemas.param,
const { id } = context.req.valid("param"); },
responses: {
const { user } = context.get("auth"); 200: {
if (!user) { description: "Notification dismissed",
return context.json({ error: "Unauthorized" }, 401);
}
await db
.update(Notifications)
.set({
dismissed: true,
})
.where(eq(Notifications.id, id));
return context.json({});
}, },
), 401: {
description: "Unauthorized",
content: {
"application/json": {
schema: ErrorSchema,
},
},
},
},
});
export default apiRoute((app) =>
app.openapi(route, async (context) => {
const { id } = context.req.valid("param");
const { user } = context.get("auth");
if (!user) {
return context.json({ error: "Unauthorized" }, 401);
}
await db
.update(Notifications)
.set({
dismissed: true,
})
.where(eq(Notifications.id, id));
return context.newResponse(null, 200);
}),
); );

128
api/api/v1/notifications/:id/index.ts
View file

@ -1,8 +1,14 @@
import { apiRoute, applyConfig, auth, handleZodError } from "@/api"; import { apiRoute, applyConfig, auth } from "@/api";
import { zValidator } from "@hono/zod-validator"; import { createRoute } from "@hono/zod-openapi";
import { z } from "zod"; import { z } from "zod";
import { findManyNotifications } from "~/classes/functions/notification"; import {
findManyNotifications,
notificationToApi,
} from "~/classes/functions/notification";
import { RolePermissions } from "~/drizzle/schema"; import { RolePermissions } from "~/drizzle/schema";
import { Note } from "~/packages/database-interface/note";
import { User } from "~/packages/database-interface/user";
import { ErrorSchema } from "~/types/api";
export const meta = applyConfig({ export const meta = applyConfig({
allowedMethods: ["GET"], allowedMethods: ["GET"],
@ -26,36 +32,90 @@ export const schemas = {
}), }),
}; };
export default apiRoute((app) => const route = createRoute({
app.on( method: "get",
meta.allowedMethods, path: "/api/v1/notifications/{id}",
meta.route, summary: "Get notification",
zValidator("param", schemas.param, handleZodError), middleware: [auth(meta.auth, meta.permissions)],
auth(meta.auth, meta.permissions), request: {
async (context) => { params: schemas.param,
const { id } = context.req.valid("param"); },
responses: {
const { user } = context.get("auth"); 200: {
if (!user) { description: "Notification",
return context.json({ error: "Unauthorized" }, 401); schema: z.object({
} account: z.lazy(() => User.schema).nullable(),
created_at: z.string(),
const notification = ( id: z.string().uuid(),
await findManyNotifications( status: z.lazy(() => Note.schema).optional(),
{ // TODO: Add reactions
where: (notification, { eq }) => type: z.enum([
eq(notification.id, id), "mention",
limit: 1, "status",
}, "follow",
user.id, "follow_request",
) "reblog",
)[0]; "poll",
"favourite",
if (!notification) { "update",
return context.json({ error: "Notification not found" }, 404); "admin.sign_up",
} "admin.report",
"chat",
return context.json(notification); "pleroma:chat_mention",
"pleroma:emoji_reaction",
"pleroma:event_reminder",
"pleroma:participation_request",
"pleroma:participation_accepted",
"move",
"group_reblog",
"group_favourite",
"user_approved",
]),
target: z.lazy(() => User.schema).optional(),
}),
}, },
), 401: {
description: "Unauthorized",
content: {
"application/json": {
schema: ErrorSchema,
},
},
},
404: {
description: "Notification not found",
content: {
"application/json": {
schema: ErrorSchema,
},
},
},
},
});
export default apiRoute((app) =>
app.openapi(route, async (context) => {
const { id } = context.req.valid("param");
const { user } = context.get("auth");
if (!user) {
return context.json({ error: "Unauthorized" }, 401);
}
const notification = (
await findManyNotifications(
{
where: (notification, { eq }) => eq(notification.id, id),
limit: 1,
},
user.id,
)
)[0];
if (!notification) {
return context.json({ error: "Notification not found" }, 404);
}
return context.json(await notificationToApi(notification), 200);
}),
); );

57
api/api/v1/notifications/clear/index.ts
View file

@ -1,7 +1,9 @@
import { apiRoute, applyConfig, auth } from "@/api"; import { apiRoute, applyConfig, auth } from "@/api";
import { createRoute } from "@hono/zod-openapi";
import { eq } from "drizzle-orm"; import { eq } from "drizzle-orm";
import { db } from "~/drizzle/db"; import { db } from "~/drizzle/db";
import { Notifications, RolePermissions } from "~/drizzle/schema"; import { Notifications, RolePermissions } from "~/drizzle/schema";
import { ErrorSchema } from "~/types/api";
export const meta = applyConfig({ export const meta = applyConfig({
allowedMethods: ["POST"], allowedMethods: ["POST"],
@ -19,25 +21,40 @@ export const meta = applyConfig({
}, },
}); });
export default apiRoute((app) => const route = createRoute({
app.on( method: "post",
meta.allowedMethods, path: "/api/v1/notifications/clear",
meta.route, summary: "Clear notifications",
auth(meta.auth, meta.permissions), middleware: [auth(meta.auth, meta.permissions)],
async (context) => { responses: {
const { user } = context.get("auth"); 200: {
if (!user) { description: "Notifications cleared",
return context.json({ error: "Unauthorized" }, 401);
}
await db
.update(Notifications)
.set({
dismissed: true,
})
.where(eq(Notifications.notifiedId, user.id));
return context.json({});
}, },
), 401: {
description: "Unauthorized",
content: {
"application/json": {
schema: ErrorSchema,
},
},
},
},
});
export default apiRoute((app) =>
app.openapi(route, async (context) => {
const { user } = context.get("auth");
if (!user) {
return context.json({ error: "Unauthorized" }, 401);
}
await db
.update(Notifications)
.set({
dismissed: true,
})
.where(eq(Notifications.notifiedId, user.id));
return context.newResponse(null, 200);
}),
); );

80
api/api/v1/notifications/destroy_multiple/index.ts
View file

@ -1,9 +1,10 @@
import { apiRoute, applyConfig, auth, handleZodError } from "@/api"; import { apiRoute, applyConfig, auth } from "@/api";
import { zValidator } from "@hono/zod-validator"; import { createRoute } from "@hono/zod-openapi";
import { and, eq, inArray } from "drizzle-orm"; import { and, eq, inArray } from "drizzle-orm";
import { z } from "zod"; import { z } from "zod";
import { db } from "~/drizzle/db"; import { db } from "~/drizzle/db";
import { Notifications, RolePermissions } from "~/drizzle/schema"; import { Notifications, RolePermissions } from "~/drizzle/schema";
import { ErrorSchema } from "~/types/api";
export const meta = applyConfig({ export const meta = applyConfig({
allowedMethods: ["DELETE"], allowedMethods: ["DELETE"],
@ -27,34 +28,51 @@ export const schemas = {
}), }),
}; };
export default apiRoute((app) => const route = createRoute({
app.on( method: "delete",
meta.allowedMethods, path: "/api/v1/notifications/destroy_multiple",
meta.route, summary: "Dismiss multiple notifications",
zValidator("query", schemas.query, handleZodError), middleware: [auth(meta.auth, meta.permissions)],
auth(meta.auth, meta.permissions), request: {
async (context) => { query: schemas.query,
const { user } = context.get("auth"); },
responses: {
if (!user) { 200: {
return context.json({ error: "Unauthorized" }, 401); description: "Notifications dismissed",
}
const { "ids[]": ids } = context.req.valid("query");
await db
.update(Notifications)
.set({
dismissed: true,
})
.where(
and(
inArray(Notifications.id, ids),
eq(Notifications.notifiedId, user.id),
),
);
return context.json({});
}, },
), 401: {
description: "Unauthorized",
content: {
"application/json": {
schema: ErrorSchema,
},
},
},
},
});
export default apiRoute((app) =>
app.openapi(route, async (context) => {
const { user } = context.get("auth");
if (!user) {
return context.json({ error: "Unauthorized" }, 401);
}
const { "ids[]": ids } = context.req.valid("query");
await db
.update(Notifications)
.set({
dismissed: true,
})
.where(
and(
inArray(Notifications.id, ids),
eq(Notifications.notifiedId, user.id),
),
);
return context.newResponse(null, 200);
}),
); );

317
api/api/v1/notifications/index.ts
View file

@ -1,12 +1,6 @@
import { import { apiRoute, applyConfig, auth, idValidator } from "@/api";
apiRoute,
applyConfig,
auth,
handleZodError,
idValidator,
} from "@/api";
import { fetchTimeline } from "@/timelines"; import { fetchTimeline } from "@/timelines";
import { zValidator } from "@hono/zod-validator"; import { createRoute } from "@hono/zod-openapi";
import { sql } from "drizzle-orm"; import { sql } from "drizzle-orm";
import { z } from "zod"; import { z } from "zod";
import { import {
@ -15,6 +9,9 @@ import {
} from "~/classes/functions/notification"; } from "~/classes/functions/notification";
import type { NotificationWithRelations } from "~/classes/functions/notification"; import type { NotificationWithRelations } from "~/classes/functions/notification";
import { RolePermissions } from "~/drizzle/schema"; import { RolePermissions } from "~/drizzle/schema";
import { Note } from "~/packages/database-interface/note";
import { User } from "~/packages/database-interface/user";
import { ErrorSchema } from "~/types/api";
export const meta = applyConfig({ export const meta = applyConfig({
allowedMethods: ["GET"], allowedMethods: ["GET"],
@ -36,137 +33,157 @@ export const meta = applyConfig({
}); });
export const schemas = { export const schemas = {
query: z.object({ query: z
max_id: z.string().regex(idValidator).optional(), .object({
since_id: z.string().regex(idValidator).optional(), max_id: z.string().regex(idValidator).optional(),
min_id: z.string().regex(idValidator).optional(), since_id: z.string().regex(idValidator).optional(),
limit: z.coerce.number().int().min(1).max(80).default(15), min_id: z.string().regex(idValidator).optional(),
exclude_types: z limit: z.coerce.number().int().min(1).max(80).default(15),
.enum([ exclude_types: z
"mention", .enum([
"status", "mention",
"follow", "status",
"follow_request", "follow",
"reblog", "follow_request",
"poll", "reblog",
"favourite", "poll",
"update", "favourite",
"admin.sign_up", "update",
"admin.report", "admin.sign_up",
"chat", "admin.report",
"pleroma:chat_mention", "chat",
"pleroma:emoji_reaction", "pleroma:chat_mention",
"pleroma:event_reminder", "pleroma:emoji_reaction",
"pleroma:participation_request", "pleroma:event_reminder",
"pleroma:participation_accepted", "pleroma:participation_request",
"move", "pleroma:participation_accepted",
"group_reblog", "move",
"group_favourite", "group_reblog",
"user_approved", "group_favourite",
]) "user_approved",
.array() ])
.optional(), .array()
types: z .optional(),
.enum([ types: z
"mention", .enum([
"status", "mention",
"follow", "status",
"follow_request", "follow",
"reblog", "follow_request",
"poll", "reblog",
"favourite", "poll",
"update", "favourite",
"admin.sign_up", "update",
"admin.report", "admin.sign_up",
"chat", "admin.report",
"pleroma:chat_mention", "chat",
"pleroma:emoji_reaction", "pleroma:chat_mention",
"pleroma:event_reminder", "pleroma:emoji_reaction",
"pleroma:participation_request", "pleroma:event_reminder",
"pleroma:participation_accepted", "pleroma:participation_request",
"move", "pleroma:participation_accepted",
"group_reblog", "move",
"group_favourite", "group_reblog",
"user_approved", "group_favourite",
]) "user_approved",
.array() ])
.optional(), .array()
account_id: z.string().regex(idValidator).optional(), .optional(),
}), account_id: z.string().regex(idValidator).optional(),
})
.refine((val) => {
// Can't use both exclude_types and types
return !(val.exclude_types && val.types);
}),
}; };
const route = createRoute({
method: "get",
path: "/api/v1/notifications",
summary: "Get notifications",
middleware: [auth(meta.auth, meta.permissions)],
request: {
query: schemas.query,
},
responses: {
200: {
description: "Notifications",
content: {
"application/json": {
schema: z.array(
z.object({
account: z.lazy(() => User.schema).nullable(),
created_at: z.string(),
id: z.string().uuid(),
status: z.lazy(() => Note.schema).optional(),
// TODO: Add reactions
type: z.string(),
target: z.lazy(() => User.schema).optional(),
}),
),
},
},
},
401: {
description: "Unauthorized",
content: {
"application/json": {
schema: ErrorSchema,
},
},
},
},
});
export default apiRoute((app) => export default apiRoute((app) =>
app.on( app.openapi(route, async (context) => {
meta.allowedMethods, const { user } = context.get("auth");
meta.route, if (!user) {
zValidator("query", schemas.query, handleZodError), return context.json({ error: "Unauthorized" }, 401);
auth(meta.auth, meta.permissions), }
async (context) => {
const { user } = context.get("auth");
if (!user) {
return context.json({ error: "Unauthorized" }, 401);
}
const { const {
account_id, account_id,
exclude_types, exclude_types,
limit, limit,
max_id, max_id,
min_id, min_id,
since_id, since_id,
types, types,
} = context.req.valid("query"); } = context.req.valid("query");
if (types && exclude_types) { const { objects, link } =
return context.json( await fetchTimeline<NotificationWithRelations>(
{ findManyNotifications,
error: "Can't use both types and exclude_types", {
}, where: (
400, // @ts-expect-error Yes I KNOW the types are wrong
); notification,
} // @ts-expect-error Yes I KNOW the types are wrong
{ lt, gte, gt, and, eq, not, inArray },
const { objects, link } = ) =>
await fetchTimeline<NotificationWithRelations>( and(
findManyNotifications, max_id ? lt(notification.id, max_id) : undefined,
{ since_id
where: ( ? gte(notification.id, since_id)
// @ts-expect-error Yes I KNOW the types are wrong : undefined,
notification, min_id ? gt(notification.id, min_id) : undefined,
// @ts-expect-error Yes I KNOW the types are wrong eq(notification.notifiedId, user.id),
{ lt, gte, gt, and, eq, not, inArray }, eq(notification.dismissed, false),
) => account_id
and( ? eq(notification.accountId, account_id)
max_id : undefined,
? lt(notification.id, max_id) not(eq(notification.accountId, user.id)),
: undefined, types
since_id ? inArray(notification.type, types)
? gte(notification.id, since_id) : undefined,
: undefined, exclude_types
min_id ? not(inArray(notification.type, exclude_types))
? gt(notification.id, min_id) : undefined,
: undefined, // Don't show notes that have filtered words in them (via Notification.note.content via Notification.noteId)
eq(notification.notifiedId, user.id), // Filters in `Filters` table have keyword in `FilterKeywords` table (use LIKE)
eq(notification.dismissed, false), // Filters table has a userId and a context which is an array
account_id sql`NOT EXISTS (
? eq(notification.accountId, account_id)
: undefined,
not(eq(notification.accountId, user.id)),
types
? inArray(notification.type, types)
: undefined,
exclude_types
? not(
inArray(
notification.type,
exclude_types,
),
)
: undefined,
// Don't show notes that have filtered words in them (via Notification.note.content via Notification.noteId)
// Filters in `Filters` table have keyword in `FilterKeywords` table (use LIKE)
// Filters table has a userId and a context which is an array
sql`NOT EXISTS (
SELECT 1 SELECT 1
FROM "Filters" FROM "Filters"
WHERE "Filters"."userId" = ${user.id} WHERE "Filters"."userId" = ${user.id}
@ -182,23 +199,21 @@ export default apiRoute((app) =>
) )
AND "Filters"."context" @> ARRAY['notifications'] AND "Filters"."context" @> ARRAY['notifications']
)`, )`,
), ),
limit, limit,
// @ts-expect-error Yes I KNOW the types are wrong // @ts-expect-error Yes I KNOW the types are wrong
orderBy: (notification, { desc }) => orderBy: (notification, { desc }) => desc(notification.id),
desc(notification.id),
},
context.req.raw,
user.id,
);
return context.json(
await Promise.all(objects.map((n) => notificationToApi(n))),
200,
{
Link: link,
}, },
context.req.raw,
user.id,
); );
},
), return context.json(
await Promise.all(objects.map((n) => notificationToApi(n))),
200,
{
Link: link,
},
);
}),
); );

59
api/api/v1/profile/avatar.ts
View file

@ -1,5 +1,8 @@
import { apiRoute, applyConfig, auth } from "@/api"; import { apiRoute, applyConfig, auth } from "@/api";
import { createRoute } from "@hono/zod-openapi";
import { RolePermissions } from "~/drizzle/schema"; import { RolePermissions } from "~/drizzle/schema";
import { User } from "~/packages/database-interface/user";
import { ErrorSchema } from "~/types/api";
export const meta = applyConfig({ export const meta = applyConfig({
allowedMethods: ["DELETE"], allowedMethods: ["DELETE"],
@ -16,23 +19,43 @@ export const meta = applyConfig({
}, },
}); });
export default apiRoute((app) => const route = createRoute({
app.on( method: "delete",
meta.allowedMethods, path: "/api/v1/profile/avatar",
meta.route, summary: "Delete avatar",
auth(meta.auth, meta.permissions), middleware: [auth(meta.auth, meta.permissions)],
async (context) => { responses: {
const { user: self } = context.get("auth"); 200: {
description: "User",
if (!self) { content: {
return context.json({ error: "Unauthorized" }, 401); "application/json": {
} schema: User.schema,
},
await self.update({ },
avatar: "",
});
return context.json(self.toApi(true));
}, },
), 401: {
description: "Unauthorized",
content: {
"application/json": {
schema: ErrorSchema,
},
},
},
},
});
export default apiRoute((app) =>
app.openapi(route, async (context) => {
const { user: self } = context.get("auth");
if (!self) {
return context.json({ error: "Unauthorized" }, 401);
}
await self.update({
avatar: "",
});
return context.json(self.toApi(true), 200);
}),
); );

59
api/api/v1/profile/header.ts
View file

@ -1,5 +1,8 @@
import { apiRoute, applyConfig, auth } from "@/api"; import { apiRoute, applyConfig, auth } from "@/api";
import { createRoute } from "@hono/zod-openapi";
import { RolePermissions } from "~/drizzle/schema"; import { RolePermissions } from "~/drizzle/schema";
import { User } from "~/packages/database-interface/user";
import { ErrorSchema } from "~/types/api";
export const meta = applyConfig({ export const meta = applyConfig({
allowedMethods: ["DELETE"], allowedMethods: ["DELETE"],
@ -16,23 +19,43 @@ export const meta = applyConfig({
}, },
}); });
export default apiRoute((app) => const route = createRoute({
app.on( method: "delete",
meta.allowedMethods, path: "/api/v1/profile/header",
meta.route, summary: "Delete header",
auth(meta.auth, meta.permissions), middleware: [auth(meta.auth, meta.permissions)],
async (context) => { responses: {
const { user: self } = context.get("auth"); 200: {
description: "User",
if (!self) { content: {
return context.json({ error: "Unauthorized" }, 401); "application/json": {
} schema: User.schema,
},
await self.update({ },
header: "",
});
return context.json(self.toApi(true));
}, },
), 401: {
description: "Unauthorized",
content: {
"application/json": {
schema: ErrorSchema,
},
},
},
},
});
export default apiRoute((app) =>
app.openapi(route, async (context) => {
const { user: self } = context.get("auth");
if (!self) {
return context.json({ error: "Unauthorized" }, 401);
}
await self.update({
header: "",
});
return context.json(self.toApi(true), 200);
}),
); );