chore: formatting the code of recent changes

backend/database/src/index.ts

@@ -6,18 +6,18 @@ import { z } from "zod"
 import { and, eq, sql } from "drizzle-orm"
 import * as schema from "./schema"
 import {
-	Sandbox,
-	sandbox,
-	sandboxLikes,
-	user,
-	usersToSandboxes,
+  Sandbox,
+  sandbox,
+  sandboxLikes,
+  user,
+  usersToSandboxes,
 } from "./schema"
 
 export interface Env {
-	DB: D1Database
-	STORAGE: any
-	KEY: string
-	STORAGE_WORKER_URL: string
+  DB: D1Database
+  STORAGE: any
+  KEY: string
+  STORAGE_WORKER_URL: string
 }
 
 // https://github.com/drizzle-team/drizzle-orm/tree/main/examples/cloudflare-d1
@@ -25,469 +25,488 @@ export interface Env {
 // npm run generate
 // npx wrangler d1 execute d1-sandbox --local --file=./drizzle/<FILE>
 interface SandboxWithLiked extends Sandbox {
-	liked: boolean
+  liked: boolean
 }
 
 interface UserResponse extends Omit<schema.User, "sandbox"> {
-	sandbox: SandboxWithLiked[]
+  sandbox: SandboxWithLiked[]
 }
 
 export default {
-	async fetch(
-		request: Request,
-		env: Env,
-		ctx: ExecutionContext
-	): Promise<Response> {
-		const success = new Response("Success", { status: 200 })
-		const invalidRequest = new Response("Invalid Request", { status: 400 })
-		const notFound = new Response("Not Found", { status: 404 })
-		const methodNotAllowed = new Response("Method Not Allowed", { status: 405 })
+  async fetch(
+    request: Request,
+    env: Env,
+    ctx: ExecutionContext
+  ): Promise<Response> {
+    const success = new Response("Success", { status: 200 })
+    const invalidRequest = new Response("Invalid Request", { status: 400 })
+    const notFound = new Response("Not Found", { status: 404 })
+    const methodNotAllowed = new Response("Method Not Allowed", { status: 405 })
 
-		const url = new URL(request.url)
-		const path = url.pathname
-		const method = request.method
+    const url = new URL(request.url)
+    const path = url.pathname
+    const method = request.method
 
-		if (request.headers.get("Authorization") !== env.KEY) {
-			return new Response("Unauthorized", { status: 401 })
-		}
+    if (request.headers.get("Authorization") !== env.KEY) {
+      return new Response("Unauthorized", { status: 401 })
+    }
 
-		const db = drizzle(env.DB, { schema })
+    const db = drizzle(env.DB, { schema })
 
-		if (path === "/api/sandbox") {
-			if (method === "GET") {
-				const params = url.searchParams
-				if (params.has("id")) {
-					const id = params.get("id") as string
-					const res = await db.query.sandbox.findFirst({
-						where: (sandbox, { eq }) => eq(sandbox.id, id),
-						with: {
-							usersToSandboxes: true,
-						},
-					})
-					return json(res ?? {})
-				} else {
-					const res = await db.select().from(sandbox).all()
-					return json(res ?? {})
-				}
-			} else if (method === "DELETE") {
-				const params = url.searchParams
-				if (params.has("id")) {
-					const id = params.get("id") as string
-					await db
-						.delete(usersToSandboxes)
-						.where(eq(usersToSandboxes.sandboxId, id))
-					await db.delete(sandbox).where(eq(sandbox.id, id))
+    if (path === "/api/sandbox") {
+      if (method === "GET") {
+        const params = url.searchParams
+        if (params.has("id")) {
+          const id = params.get("id") as string
+          const res = await db.query.sandbox.findFirst({
+            where: (sandbox, { eq }) => eq(sandbox.id, id),
+            with: {
+              usersToSandboxes: true,
+            },
+          })
+          return json(res ?? {})
+        } else {
+          const res = await db.select().from(sandbox).all()
+          return json(res ?? {})
+        }
+      } else if (method === "DELETE") {
+        const params = url.searchParams
+        if (params.has("id")) {
+          const id = params.get("id") as string
+          await db
+            .delete(usersToSandboxes)
+            .where(eq(usersToSandboxes.sandboxId, id))
+          await db.delete(sandbox).where(eq(sandbox.id, id))
 
-					const deleteStorageRequest = new Request(
-						`${env.STORAGE_WORKER_URL}/api/project`,
-						{
-							method: "DELETE",
-							body: JSON.stringify({ sandboxId: id }),
-							headers: {
-								"Content-Type": "application/json",
-								Authorization: `${env.KEY}`,
-							},
-						}
-					)
-					await env.STORAGE.fetch(deleteStorageRequest)
+          const deleteStorageRequest = new Request(
+            `${env.STORAGE_WORKER_URL}/api/project`,
+            {
+              method: "DELETE",
+              body: JSON.stringify({ sandboxId: id }),
+              headers: {
+                "Content-Type": "application/json",
+                Authorization: `${env.KEY}`,
+              },
+            }
+          )
+          await env.STORAGE.fetch(deleteStorageRequest)
 
-					return success
-				} else {
-					return invalidRequest
-				}
-			} else if (method === "POST") {
-				const postSchema = z.object({
-					id: z.string(),
-					name: z.string().optional(),
-					visibility: z.enum(["public", "private"]).optional(),
-				})
+          return success
+        } else {
+          return invalidRequest
+        }
+      } else if (method === "POST") {
+        const postSchema = z.object({
+          id: z.string(),
+          name: z.string().optional(),
+          visibility: z.enum(["public", "private"]).optional(),
+        })
 
-				const body = await request.json()
-				const { id, name, visibility } = postSchema.parse(body)
-				const sb = await db
-					.update(sandbox)
-					.set({ name, visibility })
-					.where(eq(sandbox.id, id))
-					.returning()
-					.get()
+        const body = await request.json()
+        const { id, name, visibility } = postSchema.parse(body)
+        const sb = await db
+          .update(sandbox)
+          .set({ name, visibility })
+          .where(eq(sandbox.id, id))
+          .returning()
+          .get()
 
-				return success
-			} else if (method === "PUT") {
-				const initSchema = z.object({
-					type: z.string(),
-					name: z.string(),
-					userId: z.string(),
-					visibility: z.enum(["public", "private"]),
-				})
+        return success
+      } else if (method === "PUT") {
+        const initSchema = z.object({
+          type: z.string(),
+          name: z.string(),
+          userId: z.string(),
+          visibility: z.enum(["public", "private"]),
+        })
 
-				const body = await request.json()
-				const { type, name, userId, visibility } = initSchema.parse(body)
+        const body = await request.json()
+        const { type, name, userId, visibility } = initSchema.parse(body)
 
-				const userSandboxes = await db
-					.select()
-					.from(sandbox)
-					.where(eq(sandbox.userId, userId))
-					.all()
+        const userSandboxes = await db
+          .select()
+          .from(sandbox)
+          .where(eq(sandbox.userId, userId))
+          .all()
 
-				if (userSandboxes.length >= 8) {
-					return new Response("You reached the maximum # of sandboxes.", {
-						status: 400,
-					})
-				}
+        if (userSandboxes.length >= 8) {
+          return new Response("You reached the maximum # of sandboxes.", {
+            status: 400,
+          })
+        }
 
-				const sb = await db
-					.insert(sandbox)
-					.values({ type, name, userId, visibility, createdAt: new Date() })
-					.returning()
-					.get()
+        const sb = await db
+          .insert(sandbox)
+          .values({ type, name, userId, visibility, createdAt: new Date() })
+          .returning()
+          .get()
 
-				const initStorageRequest = new Request(
-					`${env.STORAGE_WORKER_URL}/api/init`,
-					{
-						method: "POST",
-						body: JSON.stringify({ sandboxId: sb.id, type }),
-						headers: {
-							"Content-Type": "application/json",
-							Authorization: `${env.KEY}`,
-						},
-					}
-				)
+        const initStorageRequest = new Request(
+          `${env.STORAGE_WORKER_URL}/api/init`,
+          {
+            method: "POST",
+            body: JSON.stringify({ sandboxId: sb.id, type }),
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `${env.KEY}`,
+            },
+          }
+        )
 
-				await env.STORAGE.fetch(initStorageRequest)
+        await env.STORAGE.fetch(initStorageRequest)
 
-				return new Response(sb.id, { status: 200 })
-			} else {
-				return methodNotAllowed
-			}
-		} else if (path === "/api/sandbox/share") {
-			if (method === "GET") {
-				const params = url.searchParams
-				if (params.has("id")) {
-					const id = params.get("id") as string
-					const res = await db.query.usersToSandboxes.findMany({
-						where: (uts, { eq }) => eq(uts.userId, id),
-					})
+        return new Response(sb.id, { status: 200 })
+      } else {
+        return methodNotAllowed
+      }
+    } else if (path === "/api/sandbox/share") {
+      if (method === "GET") {
+        const params = url.searchParams
+        if (params.has("id")) {
+          const id = params.get("id") as string
+          const res = await db.query.usersToSandboxes.findMany({
+            where: (uts, { eq }) => eq(uts.userId, id),
+          })
 
-					const owners = await Promise.all(
-						res.map(async (r) => {
-							const sb = await db.query.sandbox.findFirst({
-								where: (sandbox, { eq }) => eq(sandbox.id, r.sandboxId),
-								with: {
-									author: true,
-								},
-							})
-							if (!sb) return
-							return {
-								id: sb.id,
-								name: sb.name,
-								type: sb.type,
-								author: sb.author.name,
-								authorAvatarUrl: sb.author.avatarUrl,
-								sharedOn: r.sharedOn,
-							}
-						})
-					)
+          const owners = await Promise.all(
+            res.map(async (r) => {
+              const sb = await db.query.sandbox.findFirst({
+                where: (sandbox, { eq }) => eq(sandbox.id, r.sandboxId),
+                with: {
+                  author: true,
+                },
+              })
+              if (!sb) return
+              return {
+                id: sb.id,
+                name: sb.name,
+                type: sb.type,
+                author: sb.author.name,
+                authorAvatarUrl: sb.author.avatarUrl,
+                sharedOn: r.sharedOn,
+              }
+            })
+          )
 
-					return json(owners ?? {})
-				} else return invalidRequest
-			} else if (method === "POST") {
-				const shareSchema = z.object({
-					sandboxId: z.string(),
-					email: z.string(),
-				})
+          return json(owners ?? {})
+        } else return invalidRequest
+      } else if (method === "POST") {
+        const shareSchema = z.object({
+          sandboxId: z.string(),
+          email: z.string(),
+        })
 
-				const body = await request.json()
-				const { sandboxId, email } = shareSchema.parse(body)
+        const body = await request.json()
+        const { sandboxId, email } = shareSchema.parse(body)
 
-				const user = await db.query.user.findFirst({
-					where: (user, { eq }) => eq(user.email, email),
-					with: {
-						sandbox: true,
-						usersToSandboxes: true,
-					},
-				})
+        const user = await db.query.user.findFirst({
+          where: (user, { eq }) => eq(user.email, email),
+          with: {
+            sandbox: true,
+            usersToSandboxes: true,
+          },
+        })
 
-				if (!user) {
-					return new Response("No user associated with email.", { status: 400 })
-				}
+        if (!user) {
+          return new Response("No user associated with email.", { status: 400 })
+        }
 
-				if (user.sandbox.find((sb) => sb.id === sandboxId)) {
-					return new Response("Cannot share with yourself!", { status: 400 })
-				}
+        if (user.sandbox.find((sb) => sb.id === sandboxId)) {
+          return new Response("Cannot share with yourself!", { status: 400 })
+        }
 
-				if (user.usersToSandboxes.find((uts) => uts.sandboxId === sandboxId)) {
-					return new Response("User already has access.", { status: 400 })
-				}
+        if (user.usersToSandboxes.find((uts) => uts.sandboxId === sandboxId)) {
+          return new Response("User already has access.", { status: 400 })
+        }
 
-				await db
-					.insert(usersToSandboxes)
-					.values({ userId: user.id, sandboxId, sharedOn: new Date() })
-					.get()
+        await db
+          .insert(usersToSandboxes)
+          .values({ userId: user.id, sandboxId, sharedOn: new Date() })
+          .get()
 
-				return success
-			} else if (method === "DELETE") {
-				const deleteShareSchema = z.object({
-					sandboxId: z.string(),
-					userId: z.string(),
-				})
+        return success
+      } else if (method === "DELETE") {
+        const deleteShareSchema = z.object({
+          sandboxId: z.string(),
+          userId: z.string(),
+        })
 
-				const body = await request.json()
-				const { sandboxId, userId } = deleteShareSchema.parse(body)
+        const body = await request.json()
+        const { sandboxId, userId } = deleteShareSchema.parse(body)
 
-				await db
-					.delete(usersToSandboxes)
-					.where(
-						and(
-							eq(usersToSandboxes.userId, userId),
-							eq(usersToSandboxes.sandboxId, sandboxId)
-						)
-					)
+        await db
+          .delete(usersToSandboxes)
+          .where(
+            and(
+              eq(usersToSandboxes.userId, userId),
+              eq(usersToSandboxes.sandboxId, sandboxId)
+            )
+          )
 
-				return success
-			} else return methodNotAllowed
-		} else if (path === "/api/user") {
-			if (method === "GET") {
-				const params = url.searchParams
+        return success
+      } else return methodNotAllowed
+    } else if (path === "/api/user") {
+      if (method === "GET") {
+        const params = url.searchParams
 
-				if (params.has("id")) {
-					const id = params.get("id") as string
+        if (params.has("id")) {
+          const id = params.get("id") as string
 
-					const res = await db.query.user.findFirst({
-						where: (user, { eq }) => eq(user.id, id),
-						with: {
-							sandbox: {
-								orderBy: (sandbox, { desc }) => [desc(sandbox.createdAt)],
-								with: {
-									likes: true,
-								},
-							},
-							usersToSandboxes: true,
-						},
-					})
-					if (res) {
-						const transformedUser: UserResponse = {
-							...res,
-							sandbox: res.sandbox.map(
-								(sb): SandboxWithLiked => ({
-									...sb,
-									liked: sb.likes.some((like) => like.userId === id),
-								})
-							),
-						}
-						return json(transformedUser)
-					}
-					return json(res ?? {})
-				} else if (params.has("username")) {
-					const username = params.get("username") as string
-					const userId = params.get("currentUserId")
-					const res = await db.query.user.findFirst({
-						where: (user, { eq }) => eq(user.username, username),
-						with: {
-							sandbox: {
-								orderBy: (sandbox, { desc }) => [desc(sandbox.createdAt)],
-								with: {
-									likes: true,
-								},
-							},
-							usersToSandboxes: true,
-						},
-					})
-					if (res) {
-						const transformedUser: UserResponse = {
-							...res,
-							sandbox: res.sandbox.map(
-								(sb): SandboxWithLiked => ({
-									...sb,
-									liked: sb.likes.some((like) => like.userId === userId),
-								})
-							),
-						}
-						return json(transformedUser)
-					}
-					return json(res ?? {})
-				} else {
-					const res = await db.select().from(user).all()
-					return json(res ?? {})
-				}
-			} else if (method === "POST") {
-				const userSchema = z.object({
-					id: z.string(),
-					name: z.string(),
-					email: z.string().email(),
-					username: z.string(),
-					avatarUrl: z.string().optional(),
-					createdAt: z.string().optional(),
-					generations: z.number().optional(),
-					tier: z.enum(["FREE", "PRO", "ENTERPRISE"]).optional(),
-					tierExpiresAt: z.number().optional(),
-					lastResetDate: z.number().optional(),
-				})
+          const res = await db.query.user.findFirst({
+            where: (user, { eq }) => eq(user.id, id),
+            with: {
+              sandbox: {
+                orderBy: (sandbox, { desc }) => [desc(sandbox.createdAt)],
+                with: {
+                  likes: true,
+                },
+              },
+              usersToSandboxes: true,
+            },
+          })
+          if (res) {
+            const transformedUser: UserResponse = {
+              ...res,
+              sandbox: res.sandbox.map(
+                (sb): SandboxWithLiked => ({
+                  ...sb,
+                  liked: sb.likes.some((like) => like.userId === id),
+                })
+              ),
+            }
+            return json(transformedUser)
+          }
+          return json(res ?? {})
+        } else if (params.has("username")) {
+          const username = params.get("username") as string
+          const userId = params.get("currentUserId")
+          const res = await db.query.user.findFirst({
+            where: (user, { eq }) => eq(user.username, username),
+            with: {
+              sandbox: {
+                orderBy: (sandbox, { desc }) => [desc(sandbox.createdAt)],
+                with: {
+                  likes: true,
+                },
+              },
+              usersToSandboxes: true,
+            },
+          })
+          if (res) {
+            const transformedUser: UserResponse = {
+              ...res,
+              sandbox: res.sandbox.map(
+                (sb): SandboxWithLiked => ({
+                  ...sb,
+                  liked: sb.likes.some((like) => like.userId === userId),
+                })
+              ),
+            }
+            return json(transformedUser)
+          }
+          return json(res ?? {})
+        } else {
+          const res = await db.select().from(user).all()
+          return json(res ?? {})
+        }
+      } else if (method === "POST") {
+        const userSchema = z.object({
+          id: z.string(),
+          name: z.string(),
+          email: z.string().email(),
+          username: z.string(),
+          avatarUrl: z.string().optional(),
+          createdAt: z.string().optional(),
+          generations: z.number().optional(),
+          tier: z.enum(["FREE", "PRO", "ENTERPRISE"]).optional(),
+          tierExpiresAt: z.number().optional(),
+          lastResetDate: z.number().optional(),
+        })
 
-				const body = await request.json()
+        const body = await request.json()
 
-				const { id, name, email, username, avatarUrl, createdAt, generations, tier, tierExpiresAt, lastResetDate } = userSchema.parse(body)
-				const res = await db
-					.insert(user)
-					.values({
-						id,
-						name,
-						email,
-						username,
-						avatarUrl,
-						createdAt: createdAt ? new Date(createdAt) : new Date(),
-						generations,
-						tier,
-						tierExpiresAt,
-						lastResetDate,
-					})
-					.returning()
-					.get()
-				return json({ res })
-			} else if (method === "DELETE") {
-				const params = url.searchParams
-				if (params.has("id")) {
-					const id = params.get("id") as string
-					await db.delete(user).where(eq(user.id, id))
-					return success
-				} else return invalidRequest
-			} else if (method === "PUT") {
-				const updateUserSchema = z.object({
-					id: z.string(),
-					name: z.string().optional(),
-					email: z.string().email().optional(),
-					username: z.string().optional(),
-					avatarUrl: z.string().optional(),
-					generations: z.number().optional(),
-				})
+        const {
+          id,
+          name,
+          email,
+          username,
+          avatarUrl,
+          createdAt,
+          generations,
+          tier,
+          tierExpiresAt,
+          lastResetDate,
+        } = userSchema.parse(body)
+        const res = await db
+          .insert(user)
+          .values({
+            id,
+            name,
+            email,
+            username,
+            avatarUrl,
+            createdAt: createdAt ? new Date(createdAt) : new Date(),
+            generations,
+            tier,
+            tierExpiresAt,
+            lastResetDate,
+          })
+          .returning()
+          .get()
+        return json({ res })
+      } else if (method === "DELETE") {
+        const params = url.searchParams
+        if (params.has("id")) {
+          const id = params.get("id") as string
+          await db.delete(user).where(eq(user.id, id))
+          return success
+        } else return invalidRequest
+      } else if (method === "PUT") {
+        const updateUserSchema = z.object({
+          id: z.string(),
+          name: z.string().optional(),
+          email: z.string().email().optional(),
+          username: z.string().optional(),
+          avatarUrl: z.string().optional(),
+          generations: z.number().optional(),
+        })
 
-				try {
-					const body = await request.json()
-					const validatedData = updateUserSchema.parse(body)
+        try {
+          const body = await request.json()
+          const validatedData = updateUserSchema.parse(body)
 
-					const { id, username, ...updateData } = validatedData
+          const { id, username, ...updateData } = validatedData
 
-					// If username is being updated, check for existing username
-					if (username) {
-						const existingUser = await db
-							.select()
-							.from(user)
-							.where(eq(user.username, username))
-							.get()
-						if (existingUser && existingUser.id !== id) {
-							return json({ error: "Username already exists" }, { status: 409 })
-						}
-					}
+          // If username is being updated, check for existing username
+          if (username) {
+            const existingUser = await db
+              .select()
+              .from(user)
+              .where(eq(user.username, username))
+              .get()
+            if (existingUser && existingUser.id !== id) {
+              return json({ error: "Username already exists" }, { status: 409 })
+            }
+          }
 
-					const cleanUpdateData = {
-						...updateData,
-						...(username ? { username } : {}),
-					}
+          const cleanUpdateData = {
+            ...updateData,
+            ...(username ? { username } : {}),
+          }
 
-					const res = await db
-						.update(user)
-						.set(cleanUpdateData)
-						.where(eq(user.id, id))
-						.returning()
-						.get()
+          const res = await db
+            .update(user)
+            .set(cleanUpdateData)
+            .where(eq(user.id, id))
+            .returning()
+            .get()
 
-					if (!res) {
-						return json({ error: "User not found" }, { status: 404 })
-					}
+          if (!res) {
+            return json({ error: "User not found" }, { status: 404 })
+          }
 
-					return json({ res })
-				} catch (error) {
-					if (error instanceof z.ZodError) {
-						return json({ error: error.errors }, { status: 400 })
-					}
-					return json({ error: "Internal server error" }, { status: 500 })
-				}
-			} else {
-				return methodNotAllowed
-			}
-		} else if (path === "/api/user/check-username") {
-			if (method === "GET") {
-				const params = url.searchParams
-				const username = params.get("username")
+          return json({ res })
+        } catch (error) {
+          if (error instanceof z.ZodError) {
+            return json({ error: error.errors }, { status: 400 })
+          }
+          return json({ error: "Internal server error" }, { status: 500 })
+        }
+      } else {
+        return methodNotAllowed
+      }
+    } else if (path === "/api/user/check-username") {
+      if (method === "GET") {
+        const params = url.searchParams
+        const username = params.get("username")
 
-				if (!username) return invalidRequest
+        if (!username) return invalidRequest
 
-				const exists = await db.query.user.findFirst({
-					where: (user, { eq }) => eq(user.username, username),
-				})
+        const exists = await db.query.user.findFirst({
+          where: (user, { eq }) => eq(user.username, username),
+        })
 
-				return json({ exists: !!exists })
-			}
-			return methodNotAllowed
-		} else if (path === "/api/user/increment-generations" && method === "POST") {
-			const schema = z.object({
-				userId: z.string(),
-			})
+        return json({ exists: !!exists })
+      }
+      return methodNotAllowed
+    } else if (
+      path === "/api/user/increment-generations" &&
+      method === "POST"
+    ) {
+      const schema = z.object({
+        userId: z.string(),
+      })
 
-			const body = await request.json()
-			const { userId } = schema.parse(body)
+      const body = await request.json()
+      const { userId } = schema.parse(body)
 
-			await db
-				.update(user)
-				.set({ generations: sql`${user.generations} + 1` })
-				.where(eq(user.id, userId))
-				.get()
+      await db
+        .update(user)
+        .set({ generations: sql`${user.generations} + 1` })
+        .where(eq(user.id, userId))
+        .get()
 
-			return success
-		} else if (path === "/api/user/update-tier" && method === "POST") {
-			const schema = z.object({
-				userId: z.string(),
-				tier: z.enum(["FREE", "PRO", "ENTERPRISE"]),
-				tierExpiresAt: z.date(),
-			})
+      return success
+    } else if (path === "/api/user/update-tier" && method === "POST") {
+      const schema = z.object({
+        userId: z.string(),
+        tier: z.enum(["FREE", "PRO", "ENTERPRISE"]),
+        tierExpiresAt: z.date(),
+      })
 
-			const body = await request.json()
-			const { userId, tier, tierExpiresAt } = schema.parse(body)
+      const body = await request.json()
+      const { userId, tier, tierExpiresAt } = schema.parse(body)
 
-			await db
-				.update(user)
-				.set({ 
-					tier,
-					tierExpiresAt: tierExpiresAt.getTime(),
-					// Reset generations when upgrading tier
-					generations: 0
-				})
-				.where(eq(user.id, userId))
-				.get()
+      await db
+        .update(user)
+        .set({
+          tier,
+          tierExpiresAt: tierExpiresAt.getTime(),
+          // Reset generations when upgrading tier
+          generations: 0,
+        })
+        .where(eq(user.id, userId))
+        .get()
 
-			return success
-		} else if (path === "/api/user/check-reset" && method === "POST") {
-			const schema = z.object({
-				userId: z.string(),
-			})
+      return success
+    } else if (path === "/api/user/check-reset" && method === "POST") {
+      const schema = z.object({
+        userId: z.string(),
+      })
 
-			const body = await request.json()
-			const { userId } = schema.parse(body)
+      const body = await request.json()
+      const { userId } = schema.parse(body)
 
-			const dbUser = await db.query.user.findFirst({
-				where: (user, { eq }) => eq(user.id, userId),
-			})
+      const dbUser = await db.query.user.findFirst({
+        where: (user, { eq }) => eq(user.id, userId),
+      })
 
-			if (!dbUser) {
-				return new Response("User not found", { status: 404 })
-			}
+      if (!dbUser) {
+        return new Response("User not found", { status: 404 })
+      }
 
-			const now = new Date()
-			const lastReset = dbUser.lastResetDate ? new Date(dbUser.lastResetDate) : new Date(0)
+      const now = new Date()
+      const lastReset = dbUser.lastResetDate
+        ? new Date(dbUser.lastResetDate)
+        : new Date(0)
 
-			if (now.getMonth() !== lastReset.getMonth() || now.getFullYear() !== lastReset.getFullYear()) {
-				await db
-					.update(user)
-					.set({ 
-						generations: 0,
-						lastResetDate: now.getTime()
-					})
-					.where(eq(user.id, userId))
-					.get()
-				
-				return new Response("Reset successful", { status: 200 })
-			}
+      if (
+        now.getMonth() !== lastReset.getMonth() ||
+        now.getFullYear() !== lastReset.getFullYear()
+      ) {
+        await db
+          .update(user)
+          .set({
+            generations: 0,
+            lastResetDate: now.getTime(),
+          })
+          .where(eq(user.id, userId))
+          .get()
 
-			return new Response("No reset needed", { status: 200 })
-		} else return notFound
-	},
+        return new Response("Reset successful", { status: 200 })
+      }
+
+      return new Response("No reset needed", { status: 200 })
+    } else return notFound
+  },
 }

backend/database/src/schema.ts

@@ -4,112 +4,112 @@ import { integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core"
 
 // #region Tables
 export const user = sqliteTable("user", {
-	id: text("id")
-		.$defaultFn(() => createId())
-		.primaryKey()
-		.unique(),
-	name: text("name").notNull(),
-	email: text("email").notNull(),
-	username: text("username").notNull().unique(),
-	avatarUrl: text("avatarUrl"),
-	createdAt: integer("createdAt", { mode: "timestamp_ms" }).default(
-		sql`CURRENT_TIMESTAMP`
-	),
-	generations: integer("generations").default(0),
-	tier: text("tier", { enum: ["FREE", "PRO", "ENTERPRISE"] }).default("FREE"),
-	tierExpiresAt: integer("tierExpiresAt"),
-	lastResetDate: integer("lastResetDate"),
+  id: text("id")
+    .$defaultFn(() => createId())
+    .primaryKey()
+    .unique(),
+  name: text("name").notNull(),
+  email: text("email").notNull(),
+  username: text("username").notNull().unique(),
+  avatarUrl: text("avatarUrl"),
+  createdAt: integer("createdAt", { mode: "timestamp_ms" }).default(
+    sql`CURRENT_TIMESTAMP`
+  ),
+  generations: integer("generations").default(0),
+  tier: text("tier", { enum: ["FREE", "PRO", "ENTERPRISE"] }).default("FREE"),
+  tierExpiresAt: integer("tierExpiresAt"),
+  lastResetDate: integer("lastResetDate"),
 })
 
 export type User = typeof user.$inferSelect
 
 export const sandbox = sqliteTable("sandbox", {
-	id: text("id")
-		.$defaultFn(() => createId())
-		.primaryKey()
-		.unique(),
-	name: text("name").notNull(),
-	type: text("type").notNull(),
-	visibility: text("visibility", { enum: ["public", "private"] }),
-	createdAt: integer("createdAt", { mode: "timestamp_ms" }).default(
-		sql`CURRENT_TIMESTAMP`
-	),
-	userId: text("user_id")
-		.notNull()
-		.references(() => user.id),
-	likeCount: integer("likeCount").default(0),
-	viewCount: integer("viewCount").default(0),
+  id: text("id")
+    .$defaultFn(() => createId())
+    .primaryKey()
+    .unique(),
+  name: text("name").notNull(),
+  type: text("type").notNull(),
+  visibility: text("visibility", { enum: ["public", "private"] }),
+  createdAt: integer("createdAt", { mode: "timestamp_ms" }).default(
+    sql`CURRENT_TIMESTAMP`
+  ),
+  userId: text("user_id")
+    .notNull()
+    .references(() => user.id),
+  likeCount: integer("likeCount").default(0),
+  viewCount: integer("viewCount").default(0),
 })
 
 export type Sandbox = typeof sandbox.$inferSelect
 
 export const sandboxLikes = sqliteTable(
-	"sandbox_likes",
-	{
-		userId: text("user_id")
-			.notNull()
-			.references(() => user.id),
-		sandboxId: text("sandbox_id")
-			.notNull()
-			.references(() => sandbox.id),
-		createdAt: integer("createdAt", { mode: "timestamp_ms" }).default(
-			sql`CURRENT_TIMESTAMP`
-		),
-	},
-	(table) => ({
-		pk: primaryKey({ columns: [table.sandboxId, table.userId] }),
-	})
+  "sandbox_likes",
+  {
+    userId: text("user_id")
+      .notNull()
+      .references(() => user.id),
+    sandboxId: text("sandbox_id")
+      .notNull()
+      .references(() => sandbox.id),
+    createdAt: integer("createdAt", { mode: "timestamp_ms" }).default(
+      sql`CURRENT_TIMESTAMP`
+    ),
+  },
+  (table) => ({
+    pk: primaryKey({ columns: [table.sandboxId, table.userId] }),
+  })
 )
 
 export const usersToSandboxes = sqliteTable("users_to_sandboxes", {
-	userId: text("userId")
-		.notNull()
-		.references(() => user.id),
-	sandboxId: text("sandboxId")
-		.notNull()
-		.references(() => sandbox.id),
-	sharedOn: integer("sharedOn", { mode: "timestamp_ms" }),
+  userId: text("userId")
+    .notNull()
+    .references(() => user.id),
+  sandboxId: text("sandboxId")
+    .notNull()
+    .references(() => sandbox.id),
+  sharedOn: integer("sharedOn", { mode: "timestamp_ms" }),
 })
 
 // #region Relations
 export const userRelations = relations(user, ({ many }) => ({
-	sandbox: many(sandbox),
-	usersToSandboxes: many(usersToSandboxes),
-	likes: many(sandboxLikes),
+  sandbox: many(sandbox),
+  usersToSandboxes: many(usersToSandboxes),
+  likes: many(sandboxLikes),
 }))
 
 export const sandboxRelations = relations(sandbox, ({ one, many }) => ({
-	author: one(user, {
-		fields: [sandbox.userId],
-		references: [user.id],
-	}),
-	usersToSandboxes: many(usersToSandboxes),
-	likes: many(sandboxLikes),
+  author: one(user, {
+    fields: [sandbox.userId],
+    references: [user.id],
+  }),
+  usersToSandboxes: many(usersToSandboxes),
+  likes: many(sandboxLikes),
 }))
 
 export const sandboxLikesRelations = relations(sandboxLikes, ({ one }) => ({
-	user: one(user, {
-		fields: [sandboxLikes.userId],
-		references: [user.id],
-	}),
-	sandbox: one(sandbox, {
-		fields: [sandboxLikes.sandboxId],
-		references: [sandbox.id],
-	}),
+  user: one(user, {
+    fields: [sandboxLikes.userId],
+    references: [user.id],
+  }),
+  sandbox: one(sandbox, {
+    fields: [sandboxLikes.sandboxId],
+    references: [sandbox.id],
+  }),
 }))
 
 export const usersToSandboxesRelations = relations(
-	usersToSandboxes,
-	({ one }) => ({
-		group: one(sandbox, {
-			fields: [usersToSandboxes.sandboxId],
-			references: [sandbox.id],
-		}),
-		user: one(user, {
-			fields: [usersToSandboxes.userId],
-			references: [user.id],
-		}),
-	})
+  usersToSandboxes,
+  ({ one }) => ({
+    group: one(sandbox, {
+      fields: [usersToSandboxes.sandboxId],
+      references: [sandbox.id],
+    }),
+    user: one(user, {
+      fields: [usersToSandboxes.userId],
+      references: [user.id],
+    }),
+  })
 )
 
 // #endregion

frontend/app/api/ai/route.ts

@@ -43,42 +43,45 @@ export async function POST(request: Request) {
     const userData = await dbUser.json()
 
     // Get tier settings
-    const tierSettings = TIERS[userData.tier as keyof typeof TIERS] || TIERS.FREE
+    const tierSettings =
+      TIERS[userData.tier as keyof typeof TIERS] || TIERS.FREE
     if (userData.generations >= tierSettings.generations) {
       return new Response(
-        `AI generation limit reached for your ${userData.tier || "FREE"} tier`, 
+        `AI generation limit reached for your ${userData.tier || "FREE"} tier`,
         { status: 429 }
       )
     }
 
-    const { 
-      messages, 
-      context, 
-      activeFileContent, 
+    const {
+      messages,
+      context,
+      activeFileContent,
       isEditMode,
       fileName,
       line,
-      templateType 
+      templateType,
     } = await request.json()
 
     // Get template configuration
     const templateConfig = templateConfigs[templateType]
 
     // Create template context
-    const templateContext = templateConfig ? `
+    const templateContext = templateConfig
+      ? `
 Project Template: ${templateConfig.name}
 
 File Structure:
 ${Object.entries(templateConfig.fileStructure)
   .map(([path, info]) => `${path} - ${info.description}`)
-  .join('\n')}
+  .join("\n")}
 
 Conventions:
-${templateConfig.conventions.join('\n')}
+${templateConfig.conventions.join("\n")}
 
 Dependencies:
 ${JSON.stringify(templateConfig.dependencies, null, 2)}
-` : ''
+`
+      : ""
 
     // Create system message based on mode
     let systemMessage
@@ -146,7 +149,10 @@ ${activeFileContent ? `Active File Content:\n${activeFileContent}\n` : ""}`
       new ReadableStream({
         async start(controller) {
           for await (const chunk of stream) {
-            if (chunk.type === "content_block_delta" && chunk.delta.type === "text_delta") {
+            if (
+              chunk.type === "content_block_delta" &&
+              chunk.delta.type === "text_delta"
+            ) {
               controller.enqueue(encoder.encode(chunk.delta.text))
             }
           }
@@ -164,8 +170,8 @@ ${activeFileContent ? `Active File Content:\n${activeFileContent}\n` : ""}`
   } catch (error) {
     console.error("AI generation error:", error)
     return new Response(
-      error instanceof Error ? error.message : "Internal Server Error", 
+      error instanceof Error ? error.message : "Internal Server Error",
       { status: 500 }
     )
   }
-}
+}

frontend/app/api/user/upgrade-tier/route.ts

@@ -8,9 +8,9 @@ export async function POST(request: Request) {
     }
 
     const { tier } = await request.json()
-    
+
     // handle payment processing here
-        
+
     const response = await fetch(
       `${process.env.NEXT_PUBLIC_DATABASE_WORKER_URL}/api/user/update-tier`,
       {
@@ -39,4 +39,4 @@ export async function POST(request: Request) {
       { status: 500 }
     )
   }
-}
+}

frontend/components/editor/AIChat/index.tsx

@@ -53,7 +53,7 @@ export default function AIChat({
   // scroll to bottom of chat when messages change
   const scrollToBottom = (force: boolean = false) => {
     if (!chatContainerRef.current || (!autoScroll && !force)) return
-    
+
     chatContainerRef.current.scrollTo({
       top: chatContainerRef.current.scrollHeight,
       behavior: force ? "smooth" : "auto",
@@ -63,10 +63,10 @@ export default function AIChat({
   // function to handle scroll events
   const handleScroll = () => {
     if (!chatContainerRef.current) return
-    
+
     const { scrollTop, scrollHeight, clientHeight } = chatContainerRef.current
     const isAtBottom = Math.abs(scrollHeight - scrollTop - clientHeight) < 50
-    
+
     setAutoScroll(isAtBottom)
     setShowScrollButton(!isAtBottom)
   }
@@ -75,8 +75,8 @@ export default function AIChat({
   useEffect(() => {
     const container = chatContainerRef.current
     if (container) {
-      container.addEventListener('scroll', handleScroll)
-      return () => container.removeEventListener('scroll', handleScroll)
+      container.addEventListener("scroll", handleScroll)
+      return () => container.removeEventListener("scroll", handleScroll)
     }
   }, [])
 
@@ -200,7 +200,7 @@ export default function AIChat({
           />
         ))}
         {isLoading && <LoadingDots />}
-        
+
         {/* Add scroll to bottom button */}
         {showScrollButton && (
           <button

frontend/components/editor/AIChat/lib/chatUtils.ts

@@ -131,22 +131,20 @@ export const handleSend = async (
     }))
 
     // Fetch AI response for chat message component
-    const response = await fetch("/api/ai", 
-    {
+    const response = await fetch("/api/ai", {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-          messages: anthropicMessages,
-          context: context || undefined,
-          activeFileContent: activeFileContent,
-          isEditMode: isEditMode,
-          templateType: templateType,
-        }),
-        signal: abortControllerRef.current.signal,
-      }
-    )
+      },
+      body: JSON.stringify({
+        messages: anthropicMessages,
+        context: context || undefined,
+        activeFileContent: activeFileContent,
+        isEditMode: isEditMode,
+        templateType: templateType,
+      }),
+      signal: abortControllerRef.current.signal,
+    })
 
     // Throw error if response is not ok
     if (!response.ok) {
@@ -201,7 +199,8 @@ export const handleSend = async (
       console.error("Error fetching AI response:", error)
       const errorMessage = {
         role: "assistant" as const,
-        content: error.message || "Sorry, I encountered an error. Please try again.",
+        content:
+          error.message || "Sorry, I encountered an error. Please try again.",
       }
       setMessages((prev) => [...prev, errorMessage])
     }

frontend/components/editor/generate.tsx

@@ -66,15 +66,17 @@ export default function GenerateInput({
           "Content-Type": "application/json",
         },
         body: JSON.stringify({
-          messages: [{
-            role: "user",
-            content: regenerate ? currentPrompt : input
-          }],
+          messages: [
+            {
+              role: "user",
+              content: regenerate ? currentPrompt : input,
+            },
+          ],
           context: null,
           activeFileContent: data.code,
           isEditMode: true,
           fileName: data.fileName,
-          line: data.line
+          line: data.line,
         }),
       })
 

frontend/components/editor/index.tsx

@@ -1087,62 +1087,62 @@ export default function CodeEditor({
                       </div>
                     </>
                   ) : // Note clerk.loaded is required here due to a bug: https://github.com/clerk/javascript/issues/1643
-                    clerk.loaded ? (
-                      <>
-                        {/* {provider && userInfo ? (
+                  clerk.loaded ? (
+                    <>
+                      {/* {provider && userInfo ? (
                           <Cursors yProvider={provider} userInfo={userInfo} />
                         ) : null} */}
-                        <Editor
-                          height="100%"
-                          language={editorLanguage}
-                          beforeMount={handleEditorWillMount}
-                          onMount={handleEditorMount}
-                          onChange={(value) => {
-                            // If the new content is different from the cached content, update it
-                            if (value !== fileContents[activeFileId]) {
-                              setActiveFileContent(value ?? "") // Update the active file content
-                              // Mark the file as unsaved by setting 'saved' to false
-                              setTabs((prev) =>
-                                prev.map((tab) =>
-                                  tab.id === activeFileId
-                                    ? { ...tab, saved: false }
-                                    : tab
-                                )
+                      <Editor
+                        height="100%"
+                        language={editorLanguage}
+                        beforeMount={handleEditorWillMount}
+                        onMount={handleEditorMount}
+                        onChange={(value) => {
+                          // If the new content is different from the cached content, update it
+                          if (value !== fileContents[activeFileId]) {
+                            setActiveFileContent(value ?? "") // Update the active file content
+                            // Mark the file as unsaved by setting 'saved' to false
+                            setTabs((prev) =>
+                              prev.map((tab) =>
+                                tab.id === activeFileId
+                                  ? { ...tab, saved: false }
+                                  : tab
                               )
-                            } else {
-                              // If the content matches the cached content, mark the file as saved
-                              setTabs((prev) =>
-                                prev.map((tab) =>
-                                  tab.id === activeFileId
-                                    ? { ...tab, saved: true }
-                                    : tab
-                                )
+                            )
+                          } else {
+                            // If the content matches the cached content, mark the file as saved
+                            setTabs((prev) =>
+                              prev.map((tab) =>
+                                tab.id === activeFileId
+                                  ? { ...tab, saved: true }
+                                  : tab
                               )
-                            }
-                          }}
-                          options={{
-                            tabSize: 2,
-                            minimap: {
-                              enabled: false,
-                            },
-                            padding: {
-                              bottom: 4,
-                              top: 4,
-                            },
-                            scrollBeyondLastLine: false,
-                            fixedOverflowWidgets: true,
-                            fontFamily: "var(--font-geist-mono)",
-                          }}
-                          theme={theme === "light" ? "vs" : "vs-dark"}
-                          value={activeFileContent}
-                        />
-                      </>
-                    ) : (
-                      <div className="w-full h-full flex items-center justify-center text-xl font-medium text-muted-foreground/50 select-none">
-                        <Loader2 className="animate-spin w-6 h-6 mr-3" />
-                        Waiting for Clerk to load...
-                      </div>
-                    )}
+                            )
+                          }
+                        }}
+                        options={{
+                          tabSize: 2,
+                          minimap: {
+                            enabled: false,
+                          },
+                          padding: {
+                            bottom: 4,
+                            top: 4,
+                          },
+                          scrollBeyondLastLine: false,
+                          fixedOverflowWidgets: true,
+                          fontFamily: "var(--font-geist-mono)",
+                        }}
+                        theme={theme === "light" ? "vs" : "vs-dark"}
+                        value={activeFileContent}
+                      />
+                    </>
+                  ) : (
+                    <div className="w-full h-full flex items-center justify-center text-xl font-medium text-muted-foreground/50 select-none">
+                      <Loader2 className="animate-spin w-6 h-6 mr-3" />
+                      Waiting for Clerk to load...
+                    </div>
+                  )}
                 </div>
               </ResizablePanel>
               <ResizableHandle />

frontend/components/profile/index.tsx

@@ -231,7 +231,10 @@ function ProfileCard({
             <div className="flex flex-col items-center gap-2">
               <p className="text-xs text-muted-foreground">{joinedAt}</p>
               {typeof generations === "number" && (
-                <SubscriptionBadge generations={generations} tier={tier as keyof typeof TIERS} />
+                <SubscriptionBadge
+                  generations={generations}
+                  tier={tier as keyof typeof TIERS}
+                />
               )}
             </div>
           </>
@@ -445,7 +448,13 @@ const StatsItem = ({ icon: Icon, label }: StatsItemProps) => (
 // #endregion
 
 // #region Sub Badge
-const SubscriptionBadge = ({ generations, tier = "FREE" }: { generations: number, tier?: keyof typeof TIERS }) => {
+const SubscriptionBadge = ({
+  generations,
+  tier = "FREE",
+}: {
+  generations: number
+  tier?: keyof typeof TIERS
+}) => {
   return (
     <div className="flex gap-2 items-center">
       <Badge variant="secondary" className="text-sm cursor-pointer">

frontend/components/ui/userButton.tsx

@@ -10,7 +10,7 @@ import {
 import { User } from "@/lib/types"
 import { useClerk } from "@clerk/nextjs"
 import {
-    Crown,
+  Crown,
   LayoutDashboard,
   LogOut,
   Sparkles,
@@ -43,7 +43,11 @@ const TIER_INFO = {
   },
 } as const
 
-export default function UserButton({ userData: initialUserData }: { userData: User }) {
+export default function UserButton({
+  userData: initialUserData,
+}: {
+  userData: User
+}) {
   const [userData, setUserData] = useState<User>(initialUserData)
   const [isOpen, setIsOpen] = useState(false)
   const { signOut } = useClerk()
@@ -57,7 +61,7 @@ export default function UserButton({ userData: initialUserData }: { userData: Us
           headers: {
             Authorization: `${process.env.NEXT_PUBLIC_WORKERS_KEY}`,
           },
-          cache: 'no-store'
+          cache: "no-store",
         }
       )
       if (res.ok) {
@@ -75,9 +79,12 @@ export default function UserButton({ userData: initialUserData }: { userData: Us
     }
   }, [isOpen])
 
-  const tierInfo = TIER_INFO[userData.tier as keyof typeof TIER_INFO] || TIER_INFO.FREE
+  const tierInfo =
+    TIER_INFO[userData.tier as keyof typeof TIER_INFO] || TIER_INFO.FREE
   const TierIcon = tierInfo.icon
-  const usagePercentage = Math.floor((userData.generations || 0) * 100 / tierInfo.limit)
+  const usagePercentage = Math.floor(
+    ((userData.generations || 0) * 100) / tierInfo.limit
+  )
 
   const handleUpgrade = async () => {
     router.push(`/@${userData.username}`)
@@ -98,7 +105,6 @@ export default function UserButton({ userData: initialUserData }: { userData: Us
 
         <DropdownMenuSeparator />
 
-
         <DropdownMenuItem className="cursor-pointer" asChild>
           <Link href={"/dashboard"}>
             <LayoutDashboard className="mr-2 size-4" />
@@ -114,12 +120,13 @@ export default function UserButton({ userData: initialUserData }: { userData: Us
         </DropdownMenuItem>
         <DropdownMenuSeparator />
 
-
         <div className="py-1.5 px-2 w-full">
           <div className="flex items-center justify-between">
             <div className="flex items-center gap-1.5">
               <TierIcon className={`h-4 w-4 ${tierInfo.color}`} />
-              <span className="text-sm font-medium">{userData.tier || "FREE"} Plan</span>
+              <span className="text-sm font-medium">
+                {userData.tier || "FREE"} Plan
+              </span>
             </div>
             {(userData.tier === "FREE" || userData.tier === "PRO") && (
               <Button
@@ -139,16 +146,20 @@ export default function UserButton({ userData: initialUserData }: { userData: Us
           <div className="w-full">
             <div className="flex items-center justify-between text-sm text-muted-foreground mb-2">
               <span>AI Usage</span>
-              <span>{userData.generations}/{tierInfo.limit}</span>
+              <span>
+                {userData.generations}/{tierInfo.limit}
+              </span>
             </div>
 
-            <div className="rounded-full w-full h-2 overflow-hidden bg-secondary mb-1">  
+            <div className="rounded-full w-full h-2 overflow-hidden bg-secondary mb-1">
               <div
                 className={`h-full rounded-full transition-all duration-300 ${
-                usagePercentage > 90 ? 'bg-red-500' : 
-                usagePercentage > 75 ? 'bg-yellow-500' : 
-                tierInfo.color.replace('text-', 'bg-')
-              }`}
+                  usagePercentage > 90
+                    ? "bg-red-500"
+                    : usagePercentage > 75
+                    ? "bg-yellow-500"
+                    : tierInfo.color.replace("text-", "bg-")
+                }`}
                 style={{
                   width: `${Math.min(usagePercentage, 100)}%`,
                 }}
@@ -173,4 +184,3 @@ export default function UserButton({ userData: initialUserData }: { userData: Us
     </DropdownMenu>
   )
 }
-

frontend/lib/data/index.ts

@@ -38,6 +38,6 @@ export const projectTemplates: {
     name: "PHP",
     description: "PHP development environment",
     icon: "/project-icons/php.svg",
-    disabled: false
+    disabled: false,
   },
 ]

frontend/lib/templates/index.ts

@@ -1,290 +1,290 @@
 export interface TemplateConfig {
-    id: string
-    name: string,
-    runCommand: string,
-    fileStructure: {
-      [key: string]: {
-        purpose: string
-        description: string
-      }
-    }
-    conventions: string[]
-    dependencies?: {
-      [key: string]: string
-    }
-    scripts?: {
-      [key: string]: string
+  id: string
+  name: string
+  runCommand: string
+  fileStructure: {
+    [key: string]: {
+      purpose: string
+      description: string
     }
   }
-  
-  export const templateConfigs: { [key: string]: TemplateConfig } = {
-    reactjs: {
-      id: "reactjs",
-      name: "React",
-      runCommand: "npm run dev",
-      fileStructure: {
-        "src/": {
-          purpose: "source",
-          description: "Contains all React components and application logic"
-        },
-        "src/components/": {
-          purpose: "components",
-          description: "Reusable React components"
-        },
-        "src/lib/": {
-          purpose: "utilities",
-          description: "Utility functions and shared code"
-        },
-        "src/App.tsx": {
-          purpose: "entry",
-          description: "Main application component"
-        },
-        "src/index.tsx": {
-          purpose: "entry",
-          description: "Application entry point"
-        },
-        "src/index.css": {
-          purpose: "styles",
-          description: "Global CSS styles"
-        },
-        "public/": {
-          purpose: "static",
-          description: "Static assets and index.html"
-        },
-        "tsconfig.json": {
-          purpose: "config",
-          description: "TypeScript configuration"
-        },
-        "vite.config.ts": {
-          purpose: "config", 
-          description: "Vite bundler configuration"
-        },
-        "package.json": {
-          purpose: "config",
-          description: "Project dependencies and scripts"
-        }
-      },
-      conventions: [
-        "Use functional components with hooks",
-        "Follow React naming conventions (PascalCase for components)",
-        "Keep components small and focused",
-        "Use TypeScript for type safety"
-      ],
-      dependencies: {
-        "@radix-ui/react-icons": "^1.3.0",
-        "@radix-ui/react-slot": "^1.1.0",
-        "class-variance-authority": "^0.7.0",
-        "clsx": "^2.1.1",
-        "lucide-react": "^0.441.0",
-        "react": "^18.3.1",
-        "react-dom": "^18.3.1",
-        "tailwind-merge": "^2.5.2",
-        "tailwindcss-animate": "^1.0.7"
-      },
-      scripts: {
-        "dev": "vite",
-        "build": "tsc && vite build",
-        "preview": "vite preview",
-      }
-    },
-    // Next.js template config
-    nextjs: {
-      id: "nextjs",
-      name: "NextJS",
-      runCommand: "npm run dev",
-      fileStructure: {
-        "pages/": {
-          purpose: "routing",
-          description: "Page components and API routes"
-        },
-        "pages/api/": {
-          purpose: "api",
-          description: "API route handlers"
-        },
-        "pages/_app.tsx": {
-          purpose: "entry",
-          description: "Application wrapper component"
-        },
-        "pages/index.tsx": {
-          purpose: "page",
-          description: "Homepage component"
-        },
-        "public/": {
-          purpose: "static",
-          description: "Static assets and files"
-        },
-        "styles/": {
-          purpose: "styles",
-          description: "CSS modules and global styles"
-        },
-        "styles/globals.css": {
-          purpose: "styles",
-          description: "Global CSS styles"
-        },
-        "styles/Home.module.css": {
-          purpose: "styles",
-          description: "Homepage-specific styles"
-        },
-        "next.config.js": {
-          purpose: "config",
-          description: "Next.js configuration"
-        },
-        "next-env.d.ts": {
-          purpose: "types",
-          description: "Next.js TypeScript declarations"
-        },
-        "tsconfig.json": {
-          purpose: "config",
-          description: "TypeScript configuration"
-        },
-        "package.json": {
-          purpose: "config",
-          description: "Project dependencies and scripts"
-        }
-      },
-      conventions: [
-        "Use file-system based routing",
-        "Keep API routes in pages/api",
-        "Use CSS Modules for component styles",
-        "Follow Next.js data fetching patterns"
-      ],
-      dependencies: {
-        "next": "^14.1.0",
-        "react": "^18.2.0",
-        "react-dom": "18.2.0",
-        "tailwindcss": "^3.4.1"
-      },
-      scripts: {
-        "dev": "next dev",
-        "build": "next build",
-        "start": "next start",
-        "lint": "next lint",
-      }
-    },
-    // Streamlit template config
-    streamlit: {
-      id: "streamlit",
-      name: "Streamlit",
-      runCommand: "./venv/bin/streamlit run main.py --server.runOnSave true",
-      fileStructure: {
-        "main.py": {
-          purpose: "entry",
-          description: "Main Streamlit application file"
-        },
-        "requirements.txt": {
-          purpose: "dependencies",
-          description: "Python package dependencies"
-        },
-        "Procfile": {
-          purpose: "deployment",
-          description: "Deployment configuration for hosting platforms"
-        },
-        "venv/": {
-          purpose: "environment",
-          description: "Python virtual environment directory"
-        }
-      },
-      conventions: [
-        "Use Streamlit components for UI",
-        "Follow PEP 8 style guide",
-        "Keep dependencies in requirements.txt",
-        "Use virtual environment for isolation"
-      ],
-      dependencies: {
-        "streamlit": "^1.40.0",
-        "altair": "^5.5.0"
-      },
-      scripts: {
-        "start": "streamlit run main.py",
-        "dev": "./venv/bin/streamlit run main.py --server.runOnSave true"
-      }
-    },
-    // HTML template config
-    vanillajs: {
-      id: "vanillajs",
-      name: "HTML/JS",
-      runCommand: "npm run dev",
-      fileStructure: {
-        "index.html": {
-          purpose: "entry",
-          description: "Main HTML entry point"
-        },
-        "style.css": {
-          purpose: "styles",
-          description: "Global CSS styles"
-        },
-        "script.js": {
-          purpose: "scripts",
-          description: "JavaScript application logic"
-        },
-        "package.json": {
-          purpose: "config",
-          description: "Project dependencies and scripts"
-        },
-        "package-lock.json": {
-          purpose: "config",
-          description: "Locked dependency versions"
-        },
-        "vite.config.js": {
-          purpose: "config",
-          description: "Vite bundler configuration"
-        }
-      },
-      conventions: [
-        "Use semantic HTML elements",
-        "Keep CSS modular and organized",
-        "Write clean, modular JavaScript",
-        "Follow modern ES6+ practices"
-      ],
-      dependencies: {
-        "vite": "^5.0.12"
-      },
-      scripts: {
-        "dev": "vite",
-        "build": "vite build",
-        "preview": "vite preview"
-      }
-    },
-    // PHP template config
-    php: {
-      id: "php",
-      name: "PHP",
-      runCommand: "npx vite",
-      fileStructure: {
-        "index.php": {
-          purpose: "entry",
-          description: "Main PHP entry point"
-        },
-        "package.json": {
-          purpose: "config",
-          description: "Frontend dependencies and scripts"
-        },
-        "package-lock.json": {
-          purpose: "config",
-          description: "Locked dependency versions"
-        },
-        "vite.config.js": {
-          purpose: "config",
-          description: "Vite configuration for frontend assets"
-        },
-        "node_modules/": {
-          purpose: "dependencies",
-          description: "Frontend dependency files"
-        }
-      },
-      conventions: [
-        "Follow PSR-12 coding standards",
-        "Use modern PHP 8+ features",
-        "Organize assets with Vite",
-        "Keep PHP logic separate from presentation"
-      ],
-      dependencies: {
-        "vite": "^5.0.0"
-      },
-      scripts: {
-        "dev": "vite",
-        "build": "vite build",
-        "preview": "vite preview"
-      }
-    }
+  conventions: string[]
+  dependencies?: {
+    [key: string]: string
+  }
+  scripts?: {
+    [key: string]: string
+  }
+}
+
+export const templateConfigs: { [key: string]: TemplateConfig } = {
+  reactjs: {
+    id: "reactjs",
+    name: "React",
+    runCommand: "npm run dev",
+    fileStructure: {
+      "src/": {
+        purpose: "source",
+        description: "Contains all React components and application logic",
+      },
+      "src/components/": {
+        purpose: "components",
+        description: "Reusable React components",
+      },
+      "src/lib/": {
+        purpose: "utilities",
+        description: "Utility functions and shared code",
+      },
+      "src/App.tsx": {
+        purpose: "entry",
+        description: "Main application component",
+      },
+      "src/index.tsx": {
+        purpose: "entry",
+        description: "Application entry point",
+      },
+      "src/index.css": {
+        purpose: "styles",
+        description: "Global CSS styles",
+      },
+      "public/": {
+        purpose: "static",
+        description: "Static assets and index.html",
+      },
+      "tsconfig.json": {
+        purpose: "config",
+        description: "TypeScript configuration",
+      },
+      "vite.config.ts": {
+        purpose: "config",
+        description: "Vite bundler configuration",
+      },
+      "package.json": {
+        purpose: "config",
+        description: "Project dependencies and scripts",
+      },
+    },
+    conventions: [
+      "Use functional components with hooks",
+      "Follow React naming conventions (PascalCase for components)",
+      "Keep components small and focused",
+      "Use TypeScript for type safety",
+    ],
+    dependencies: {
+      "@radix-ui/react-icons": "^1.3.0",
+      "@radix-ui/react-slot": "^1.1.0",
+      "class-variance-authority": "^0.7.0",
+      clsx: "^2.1.1",
+      "lucide-react": "^0.441.0",
+      react: "^18.3.1",
+      "react-dom": "^18.3.1",
+      "tailwind-merge": "^2.5.2",
+      "tailwindcss-animate": "^1.0.7",
+    },
+    scripts: {
+      dev: "vite",
+      build: "tsc && vite build",
+      preview: "vite preview",
+    },
+  },
+  // Next.js template config
+  nextjs: {
+    id: "nextjs",
+    name: "NextJS",
+    runCommand: "npm run dev",
+    fileStructure: {
+      "pages/": {
+        purpose: "routing",
+        description: "Page components and API routes",
+      },
+      "pages/api/": {
+        purpose: "api",
+        description: "API route handlers",
+      },
+      "pages/_app.tsx": {
+        purpose: "entry",
+        description: "Application wrapper component",
+      },
+      "pages/index.tsx": {
+        purpose: "page",
+        description: "Homepage component",
+      },
+      "public/": {
+        purpose: "static",
+        description: "Static assets and files",
+      },
+      "styles/": {
+        purpose: "styles",
+        description: "CSS modules and global styles",
+      },
+      "styles/globals.css": {
+        purpose: "styles",
+        description: "Global CSS styles",
+      },
+      "styles/Home.module.css": {
+        purpose: "styles",
+        description: "Homepage-specific styles",
+      },
+      "next.config.js": {
+        purpose: "config",
+        description: "Next.js configuration",
+      },
+      "next-env.d.ts": {
+        purpose: "types",
+        description: "Next.js TypeScript declarations",
+      },
+      "tsconfig.json": {
+        purpose: "config",
+        description: "TypeScript configuration",
+      },
+      "package.json": {
+        purpose: "config",
+        description: "Project dependencies and scripts",
+      },
+    },
+    conventions: [
+      "Use file-system based routing",
+      "Keep API routes in pages/api",
+      "Use CSS Modules for component styles",
+      "Follow Next.js data fetching patterns",
+    ],
+    dependencies: {
+      next: "^14.1.0",
+      react: "^18.2.0",
+      "react-dom": "18.2.0",
+      tailwindcss: "^3.4.1",
+    },
+    scripts: {
+      dev: "next dev",
+      build: "next build",
+      start: "next start",
+      lint: "next lint",
+    },
+  },
+  // Streamlit template config
+  streamlit: {
+    id: "streamlit",
+    name: "Streamlit",
+    runCommand: "./venv/bin/streamlit run main.py --server.runOnSave true",
+    fileStructure: {
+      "main.py": {
+        purpose: "entry",
+        description: "Main Streamlit application file",
+      },
+      "requirements.txt": {
+        purpose: "dependencies",
+        description: "Python package dependencies",
+      },
+      Procfile: {
+        purpose: "deployment",
+        description: "Deployment configuration for hosting platforms",
+      },
+      "venv/": {
+        purpose: "environment",
+        description: "Python virtual environment directory",
+      },
+    },
+    conventions: [
+      "Use Streamlit components for UI",
+      "Follow PEP 8 style guide",
+      "Keep dependencies in requirements.txt",
+      "Use virtual environment for isolation",
+    ],
+    dependencies: {
+      streamlit: "^1.40.0",
+      altair: "^5.5.0",
+    },
+    scripts: {
+      start: "streamlit run main.py",
+      dev: "./venv/bin/streamlit run main.py --server.runOnSave true",
+    },
+  },
+  // HTML template config
+  vanillajs: {
+    id: "vanillajs",
+    name: "HTML/JS",
+    runCommand: "npm run dev",
+    fileStructure: {
+      "index.html": {
+        purpose: "entry",
+        description: "Main HTML entry point",
+      },
+      "style.css": {
+        purpose: "styles",
+        description: "Global CSS styles",
+      },
+      "script.js": {
+        purpose: "scripts",
+        description: "JavaScript application logic",
+      },
+      "package.json": {
+        purpose: "config",
+        description: "Project dependencies and scripts",
+      },
+      "package-lock.json": {
+        purpose: "config",
+        description: "Locked dependency versions",
+      },
+      "vite.config.js": {
+        purpose: "config",
+        description: "Vite bundler configuration",
+      },
+    },
+    conventions: [
+      "Use semantic HTML elements",
+      "Keep CSS modular and organized",
+      "Write clean, modular JavaScript",
+      "Follow modern ES6+ practices",
+    ],
+    dependencies: {
+      vite: "^5.0.12",
+    },
+    scripts: {
+      dev: "vite",
+      build: "vite build",
+      preview: "vite preview",
+    },
+  },
+  // PHP template config
+  php: {
+    id: "php",
+    name: "PHP",
+    runCommand: "npx vite",
+    fileStructure: {
+      "index.php": {
+        purpose: "entry",
+        description: "Main PHP entry point",
+      },
+      "package.json": {
+        purpose: "config",
+        description: "Frontend dependencies and scripts",
+      },
+      "package-lock.json": {
+        purpose: "config",
+        description: "Locked dependency versions",
+      },
+      "vite.config.js": {
+        purpose: "config",
+        description: "Vite configuration for frontend assets",
+      },
+      "node_modules/": {
+        purpose: "dependencies",
+        description: "Frontend dependency files",
+      },
+    },
+    conventions: [
+      "Follow PSR-12 coding standards",
+      "Use modern PHP 8+ features",
+      "Organize assets with Vite",
+      "Keep PHP logic separate from presentation",
+    ],
+    dependencies: {
+      vite: "^5.0.0",
+    },
+    scripts: {
+      dev: "vite",
+      build: "vite build",
+      preview: "vite preview",
+    },
+  },
 }

frontend/lib/tiers.ts

@@ -1,19 +1,19 @@
 export const TIERS = {
-    FREE: {
-      //   generations: 100, 
-      //   maxTokens: 1024,
-      generations: 1000,
-      maxTokens: 4096,
-      model: "claude-3-5-sonnet-20240620",
-    },
-    PRO: {
-      generations: 500,
-      maxTokens: 2048,
-      model: "claude-3-5-sonnet-20240620",
-    },
-    ENTERPRISE: {
-      generations: 1000,
-      maxTokens: 4096,
-      model: "claude-3-5-sonnet-20240620",
-    },
-}
+  FREE: {
+    //   generations: 100,
+    //   maxTokens: 1024,
+    generations: 1000,
+    maxTokens: 4096,
+    model: "claude-3-5-sonnet-20240620",
+  },
+  PRO: {
+    generations: 500,
+    maxTokens: 2048,
+    model: "claude-3-5-sonnet-20240620",
+  },
+  ENTERPRISE: {
+    generations: 1000,
+    maxTokens: 4096,
+    model: "claude-3-5-sonnet-20240620",
+  },
+}