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

packages/api/plugins/openid/routes/sso/:id/index.test.ts

@@ -0,0 +1,38 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { fakeRequest, getTestUsers } from "@versia-server/tests";
+
+const { deleteUsers, tokens } = await getTestUsers(1);
+
+afterAll(async () => {
+    await deleteUsers();
+});
+
+// /api/v1/sso/:id
+describe("/api/v1/sso/:id", () => {
+    test("should not find unknown issuer", async () => {
+        const response = await fakeRequest("/api/v1/sso/unknown", {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${tokens[0].data.accessToken}`,
+            },
+        });
+
+        expect(response.status).toBe(404);
+        expect(await response.json()).toMatchObject({
+            error: "Issuer with ID unknown not found in instance's OpenID configuration",
+        });
+
+        const response2 = await fakeRequest("/api/v1/sso/unknown", {
+            method: "DELETE",
+            headers: {
+                Authorization: `Bearer ${tokens[0].data.accessToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+
+        expect(response2.status).toBe(404);
+        expect(await response2.json()).toMatchObject({
+            error: "Issuer with ID unknown not found in instance's OpenID configuration",
+        });
+    });
+});

packages/api/plugins/openid/routes/sso/:id/index.ts

@@ -0,0 +1,152 @@
+import { RolePermission } from "@versia/client/schemas";
+import { ApiError } from "@versia-server/kit";
+import { auth, handleZodError } from "@versia-server/kit/api";
+import { db } from "@versia-server/kit/db";
+import { OpenIdAccounts } from "@versia-server/kit/tables";
+import { and, eq, type SQL } from "drizzle-orm";
+import { describeRoute } from "hono-openapi";
+import { resolver, validator } from "hono-openapi/zod";
+import { z } from "zod";
+import type { PluginType } from "../../../index.ts";
+
+export default (plugin: PluginType): void => {
+    plugin.registerRoute("/api/v1/sso/:id", (app) => {
+        app.get(
+            "/api/v1/sso/:id",
+            describeRoute({
+                summary: "Get linked account",
+                tags: ["SSO"],
+                responses: {
+                    200: {
+                        description: "Linked account",
+                        content: {
+                            "application/json": {
+                                schema: resolver(
+                                    z.object({
+                                        id: z.string(),
+                                        name: z.string(),
+                                        icon: z.string().optional(),
+                                    }),
+                                ),
+                            },
+                        },
+                    },
+                    404: ApiError.accountNotFound().schema,
+                },
+            }),
+            auth({
+                auth: true,
+                permissions: [RolePermission.OAuth],
+            }),
+            plugin.middleware,
+            validator("param", z.object({ id: z.string() }), handleZodError),
+            async (context) => {
+                const { id: issuerId } = context.req.valid("param");
+                const { user } = context.get("auth");
+
+                const issuer = context
+                    .get("pluginConfig")
+                    .providers.find((provider) => provider.id === issuerId);
+
+                if (!issuer) {
+                    return context.json(
+                        {
+                            error: `Issuer with ID ${issuerId} not found in instance's OpenID configuration`,
+                        },
+                        404,
+                    );
+                }
+
+                const account = await db.query.OpenIdAccounts.findFirst({
+                    where: (account): SQL | undefined =>
+                        and(
+                            eq(account.userId, user.id),
+                            eq(account.issuerId, issuerId),
+                        ),
+                });
+
+                if (!account) {
+                    throw new ApiError(
+                        404,
+                        "Account not found or is not linked to this issuer",
+                    );
+                }
+
+                return context.json(
+                    {
+                        id: issuer.id,
+                        name: issuer.name,
+                        icon: issuer.icon?.proxied,
+                    },
+                    200,
+                );
+            },
+        );
+
+        app.delete(
+            "/api/v1/sso/:id",
+            describeRoute({
+                summary: "Unlink account",
+                tags: ["SSO"],
+                responses: {
+                    204: {
+                        description: "Account unlinked",
+                    },
+                    404: {
+                        description: "Account not found",
+                        content: {
+                            "application/json": {
+                                schema: resolver(ApiError.zodSchema),
+                            },
+                        },
+                    },
+                },
+            }),
+            auth({
+                auth: true,
+                permissions: [RolePermission.OAuth],
+            }),
+            plugin.middleware,
+            validator("param", z.object({ id: z.string() }), handleZodError),
+            async (context) => {
+                const { id: issuerId } = context.req.valid("param");
+                const { user } = context.get("auth");
+
+                // Check if issuer exists
+                const issuer = context
+                    .get("pluginConfig")
+                    .providers.find((provider) => provider.id === issuerId);
+
+                if (!issuer) {
+                    return context.json(
+                        {
+                            error: `Issuer with ID ${issuerId} not found in instance's OpenID configuration`,
+                        },
+                        404,
+                    );
+                }
+
+                const account = await db.query.OpenIdAccounts.findFirst({
+                    where: (account): SQL | undefined =>
+                        and(
+                            eq(account.userId, user.id),
+                            eq(account.issuerId, issuerId),
+                        ),
+                });
+
+                if (!account) {
+                    throw new ApiError(
+                        404,
+                        "Account not found or is not linked to this issuer",
+                    );
+                }
+
+                await db
+                    .delete(OpenIdAccounts)
+                    .where(eq(OpenIdAccounts.id, account.id));
+
+                return context.body(null, 204);
+            },
+        );
+    });
+};