feat: monorepo

packages/api/src/routers/auth.ts

@@ -0,0 +1,116 @@
+import { TRPCError } from "@trpc/server";
+import { z } from "zod";
+
+import * as userRepo from "@kan/db/repository/user.repo";
+
+import { createTRPCRouter, protectedProcedure, publicProcedure } from "../trpc";
+
+export const authRouter = createTRPCRouter({
+  getUser: protectedProcedure
+    .meta({
+      openapi: {
+        method: "GET",
+        path: "/users/me",
+        summary: "Get user",
+        description:
+          "Retrieves the currently authenticated user's profile information",
+        tags: ["Users"],
+        protect: true,
+      },
+    })
+    .input(z.void())
+    .output(
+      z.object({
+        id: z.string(),
+        email: z.string(),
+        name: z.string().nullable(),
+      }),
+    )
+    .query(async ({ ctx }) => {
+      const userId = ctx.user?.id;
+
+      if (!userId)
+        throw new TRPCError({
+          message: `User not authenticated`,
+          code: "UNAUTHORIZED",
+        });
+
+      const result = await userRepo.getById(ctx.db, userId);
+
+      if (!result?.name) {
+        throw new TRPCError({
+          message: `User not found`,
+          code: "NOT_FOUND",
+        });
+      }
+
+      return result;
+    }),
+  loginWithEmail: publicProcedure
+    .meta({
+      openapi: {
+        method: "POST",
+        path: "/auth/login/email",
+        summary: "Login with email",
+        description: "Sends a login URL to the provided email address",
+        tags: ["Auth"],
+      },
+    })
+    .input(z.object({ email: z.string() }))
+    .output(z.object({ success: z.boolean() }))
+    .mutation(async ({ ctx, input }) => {
+      const { data } = await ctx.db.auth.signInWithOtp({
+        email: input.email,
+        options: {
+          emailRedirectTo: `${process.env.WEBSITE_URL}`,
+        },
+      });
+
+      if (!data)
+        throw new TRPCError({
+          message: `Failed to login with email`,
+          code: "INTERNAL_SERVER_ERROR",
+        });
+
+      return { success: true };
+    }),
+  loginWithOAuth: publicProcedure
+    .meta({
+      openapi: {
+        method: "POST",
+        path: "/auth/login/oauth",
+        summary: "Login with OAuth",
+        description:
+          "Initiates the login process for a user with the given OAuth provider",
+        tags: ["Auth"],
+      },
+    })
+    .input(z.object({ provider: z.string() }))
+    .output(z.object({ url: z.string() }))
+    .mutation(async ({ ctx, input }) => {
+      if (input.provider !== "google")
+        throw new TRPCError({
+          message: `Unsupported OAuth provider: ${input.provider}`,
+          code: "BAD_REQUEST",
+        });
+
+      const { data } = await ctx.db.auth.signInWithOAuth({
+        provider: "google",
+        options: {
+          queryParams: {
+            access_type: "offline",
+            prompt: "consent",
+          },
+          redirectTo: `${process.env.WEBSITE_URL}/api/auth/confirm`,
+        },
+      });
+
+      if (!data.url)
+        throw new TRPCError({
+          message: `Failed to login with OAuth`,
+          code: "INTERNAL_SERVER_ERROR",
+        });
+
+      return { url: data.url };
+    }),
+});