create-ailk 0.1.0

package/templates/apps/api/src/routes/auth/user.ts

@@ -0,0 +1,244 @@
+/**
+ * User Data Routes
+ * 
+ * Handles user profile and preferences (stored locally).
+ */
+import type { Prisma } from '@working-theory/database';
+import { logger } from '@working-theory/observability';
+import type { FastifyPluginAsync } from 'fastify';
+import { z } from 'zod';
+
+import { prisma } from '../../lib/prisma.js';
+
+const updateProfileSchema = z.object({
+  name: z.string().optional(),
+  image: z.string().url().optional(),
+});
+
+const userDataSchema = z.object({
+  key: z.string().min(1),
+  value: z.unknown(),
+});
+
+export const userRoutes: FastifyPluginAsync = async (fastify) => {
+  /**
+   * GET /v1/user/profile
+   * Get current user's profile
+   */
+  fastify.get('/v1/user/profile', async (request, reply) => {
+    try {
+      const userId = (request as unknown as { userId?: string }).userId;
+      if (!userId) {
+        return reply.status(401).send({
+          success: false,
+          error: 'Authentication required',
+        });
+      }
+
+      const user = await prisma.user.findUnique({
+        where: { id: userId },
+        select: {
+          id: true,
+          email: true,
+          name: true,
+          image: true,
+          role: true,
+          createdAt: true,
+        },
+      });
+
+      if (!user) {
+        return reply.status(404).send({
+          success: false,
+          error: 'User not found',
+        });
+      }
+
+      return reply.send({
+        success: true,
+        data: user,
+      });
+    } catch (error) {
+      logger.error({ err: error }, '[User] Error fetching profile');
+      return reply.status(500).send({
+        success: false,
+        error: 'Internal server error',
+      });
+    }
+  });
+
+  /**
+   * PATCH /v1/user/profile
+   * Update current user's profile
+   */
+  fastify.patch('/v1/user/profile', async (request, reply) => {
+    try {
+      const userId = (request as unknown as { userId?: string }).userId;
+      if (!userId) {
+        return reply.status(401).send({
+          success: false,
+          error: 'Authentication required',
+        });
+      }
+
+      const data = updateProfileSchema.parse(request.body);
+
+      const user = await prisma.user.update({
+        where: { id: userId },
+        data: {
+          ...(data.name !== undefined && { name: data.name }),
+          ...(data.image !== undefined && { image: data.image }),
+        },
+        select: {
+          id: true,
+          email: true,
+          name: true,
+          image: true,
+          role: true,
+          updatedAt: true,
+        },
+      });
+
+      return reply.send({
+        success: true,
+        data: user,
+      });
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        return reply.status(400).send({
+          success: false,
+          error: 'Validation failed',
+          details: error.issues,
+        });
+      }
+
+      logger.error({ err: error }, '[User] Error updating profile');
+      return reply.status(500).send({
+        success: false,
+        error: 'Internal server error',
+      });
+    }
+  });
+
+  /**
+   * GET /v1/user/data/:key
+   * Get user data by key
+   */
+  fastify.get<{ Params: { key: string } }>('/v1/user/data/:key', async (request, reply) => {
+    try {
+      const userId = (request as unknown as { userId?: string }).userId;
+      if (!userId) {
+        return reply.status(401).send({
+          success: false,
+          error: 'Authentication required',
+        });
+      }
+
+      const { key } = request.params;
+
+      const userData = await prisma.userData.findUnique({
+        where: {
+          userId_key: { userId, key },
+        },
+      });
+
+      if (!userData) {
+        return reply.status(404).send({
+          success: false,
+          error: 'Data not found',
+        });
+      }
+
+      return reply.send({
+        success: true,
+        data: userData.value,
+      });
+    } catch (error) {
+      logger.error({ err: error }, '[User] Error fetching data');
+      return reply.status(500).send({
+        success: false,
+        error: 'Internal server error',
+      });
+    }
+  });
+
+  /**
+   * PUT /v1/user/data/:key
+   * Set user data by key
+   */
+  fastify.put<{ Params: { key: string } }>('/v1/user/data/:key', async (request, reply) => {
+    try {
+      const userId = (request as unknown as { userId?: string }).userId;
+      if (!userId) {
+        return reply.status(401).send({
+          success: false,
+          error: 'Authentication required',
+        });
+      }
+
+      const { key } = request.params;
+      const { value } = userDataSchema.parse({ key, value: request.body });
+
+      const jsonValue = value as Prisma.InputJsonValue;
+      const userData = await prisma.userData.upsert({
+        where: {
+          userId_key: { userId, key },
+        },
+        update: { value: jsonValue },
+        create: { userId, key, value: jsonValue },
+      });
+
+      return reply.send({
+        success: true,
+        data: userData.value,
+      });
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        return reply.status(400).send({
+          success: false,
+          error: 'Validation failed',
+          details: error.issues,
+        });
+      }
+
+      logger.error({ err: error }, '[User] Error saving data');
+      return reply.status(500).send({
+        success: false,
+        error: 'Internal server error',
+      });
+    }
+  });
+
+  /**
+   * DELETE /v1/user/data/:key
+   * Delete user data by key
+   */
+  fastify.delete<{ Params: { key: string } }>('/v1/user/data/:key', async (request, reply) => {
+    try {
+      const userId = (request as unknown as { userId?: string }).userId;
+      if (!userId) {
+        return reply.status(401).send({
+          success: false,
+          error: 'Authentication required',
+        });
+      }
+
+      const { key } = request.params;
+
+      await prisma.userData.deleteMany({
+        where: { userId, key },
+      });
+
+      return reply.send({
+        success: true,
+        message: 'Data deleted',
+      });
+    } catch (error) {
+      logger.error({ err: error }, '[User] Error deleting data');
+      return reply.status(500).send({
+        success: false,
+        error: 'Internal server error',
+      });
+    }
+  });
+};