update

revert Merge branch 'canvas_be_v1'

Dockerfile

@@ -1,8 +1,6 @@
 # Build stage
 FROM oven/bun:1 AS builder
 
-WORKDIR /app
-
 # Copy package files
 COPY package.json .
 COPY bun.lockb .
@@ -16,6 +14,8 @@ COPY . .
 # Build the application
 RUN bun run build
 
+EXPOSE 5005
+
 # Production stage
 # FROM debian:bookworm-slim
 

docker-compose.yml

@@ -3,8 +3,8 @@ services:
     build:
       context: .
       dockerfile: Dockerfile
-    # ports:
+    ports:
-    #   - "${SERVER_PORT}:${SERVER_PORT}"
+      - "5005:5005"
     depends_on:
       db:
         condition: service_healthy

drizzle.config.ts

@@ -1,10 +1,10 @@
-import { defineConfig } from 'drizzle-kit';
+import { defineConfig } from "drizzle-kit";
-import { ENV } from './src/config/env';
+import { ENV } from "./src/config/env";
 
 export default defineConfig({
-    out: './drizzle',
+  out: "./drizzle",
-    schema: './src/db/schema.ts',
+  schema: "./src/db/schema.ts",
-    dialect: 'postgresql',
+  dialect: "postgresql",
   dbCredentials: {
     url: ENV.DATABASE_URL!,
   },

env.example

@@ -0,0 +1,21 @@
+SERVER_URL=
+SERVER_PORT=
+
+DATABASE_URL=
+
+MINIO_ACCESS_KEY=
+MINIO_SECRET_KEY=
+MINIO_ENDPOINT=
+MINIO_PORT=
+
+CLERK_SECRET_KEY=
+
+JWT_ACCESS_TOKEN_SECRET=
+
+JWT_REFRESH_TOKEN_SECRET=
+
+# developer canvas server url
+CANVAS_SERVER_URL_DEV=
+
+PEXELS_URL=
+PEXELS_ACCESS_KEY=

src/api/auth/auth.controller.ts

@@ -1,5 +1,5 @@
 import { createClerkClient } from "@clerk/backend";
-import { ENV } from "../../config/env"
+import { ENV } from "../../config/env";
 import { users } from "../../db/schema";
 import { db } from "../../db";
 import { eq } from "drizzle-orm";
@@ -7,7 +7,11 @@ import { eq } from "drizzle-orm";
 // @ts-ignore
 import jwt from "jsonwebtoken";
 
-import { checkUserInDB, createUser, storeRefreshToken } from "../../helper/auth/auth.helper";
+import {
+  checkUserInDB,
+  createUser,
+  storeRefreshToken,
+} from "../../helper/auth/auth.helper";
 import { verifyAuth } from "../../middlewares/auth.middlewares";
 
 // Initialize Clerk with your API key
@@ -17,11 +21,10 @@ export const getUserData = async (userId: string) => {
   try {
     const [user, checkInDB] = await Promise.all([
       clerk.users.getUser(userId),
-            checkUserInDB(userId)
+      checkUserInDB(userId),
     ]);
 
     if (user && !checkInDB.found) {
-
       // Validate and transform user data
       const userDBData = {
         id: user.id,
@@ -33,10 +36,18 @@ export const getUserData = async (userId: string) => {
 
       const userData = await createUser(userDBData);
 
-            return { status: 200, message: "User retrieved successfully", data: userData };
+      return {
+        status: 200,
+        message: "User retrieved successfully",
+        data: userData,
+      };
     }
     if (user && checkInDB.found) {
-            return { status: 200, message: "User retrieved successfully", data: checkInDB };
+      return {
+        status: 200,
+        message: "User retrieved successfully",
+        data: checkInDB,
+      };
     }
     if (!user) {
       return { status: 404, message: "User not found" };
@@ -47,20 +58,36 @@ export const getUserData = async (userId: string) => {
   }
 };
 
-export const updateUser = async (id: string, body: {
+export const updateUser = async (
-    paid_status: string,
+  id: string,
-    package_expire_date: string,
+  body: {
-}) => {
+    paid_status: string;
+    package_expire_date: string;
+  }
+) => {
   try {
-        const updateUserData = await db.update(users).set({ paid_status: body?.paid_status, expires_in: body?.package_expire_date }).where(eq(users.id, id)).returning({ updatedId: users.id });
+    const updateUserData = await db
-
+      .update(users)
-        return { status: 200, message: "User updated successfully", updateUserData };
+      .set({
+        paid_status: body?.paid_status,
+        expires_in: body?.package_expire_date,
+      })
+      .where(eq(users.id, id))
+      .returning({ updatedId: users.id });
 
+    return {
+      status: 200,
+      message: "User updated successfully",
+      updateUserData,
+    };
   } catch (error: any) {
     console.error("Error in updateUser:", error.message || error.toString());
-        return { status: 500, message: `An error occurred while updating the user` };
+    return {
+      status: 500,
+      message: `An error occurred while updating the user`,
+    };
   }
-}
+};
 
 export const generateToken = async (context: any) => {
   try {
@@ -71,16 +98,24 @@ export const generateToken = async (context: any) => {
     if (access_cookie !== undefined || refresh_cookie !== undefined) {
       const verify = await verifyAuth(context?.cookie);
       return verify;
-        }
+    } else if (
-        else if (access_cookie === undefined && refresh_cookie === undefined && userId !== undefined) {
+      access_cookie === undefined &&
+      refresh_cookie === undefined &&
+      userId !== undefined
+    ) {
       const user = await checkUserInDB(userId);
       if (user?.found === true) {
-
         // generate access token
-                const accessToken = jwt.sign({ userId }, ENV.JWT_ACCESS_TOKEN_SECRET, { expiresIn: '3h' });
+        const accessToken = jwt.sign({ userId }, ENV.JWT_ACCESS_TOKEN_SECRET, {
+          expiresIn: "3h",
+        });
 
         // generate refresh token
-                const refreshToken = jwt.sign({ userId }, ENV.JWT_REFRESH_TOKEN_SECRET, { expiresIn: '7d' });
+        const refreshToken = jwt.sign(
+          { userId },
+          ENV.JWT_REFRESH_TOKEN_SECRET,
+          { expiresIn: "7d" }
+        );
 
         // store refresh token in db
         const storeRToken = await storeRefreshToken(userId, refreshToken);
@@ -90,7 +125,7 @@ export const generateToken = async (context: any) => {
             value: accessToken,
             httpOnly: true,
             secure: true, // Set to true in production
-                        sameSite: 'none', // Adjust based on your needs
+            sameSite: "none", // Adjust based on your needs
             path: "/",
             maxAge: 3 * 60 * 60, // 3 hours in seconds
           });
@@ -99,27 +134,33 @@ export const generateToken = async (context: any) => {
             value: refreshToken,
             httpOnly: true,
             secure: true, // Set to true in production
-                        sameSite: 'none', // Adjust based on your needs
+            sameSite: "none", // Adjust based on your needs
             path: "/",
             maxAge: 7 * 24 * 60 * 60, // 7 days in seconds
           });
 
-                    return { status: 201, message: "Token generated successfully", token: accessToken, user: user.user };
+          return {
+            status: 201,
+            message: "Token generated successfully",
+            token: accessToken,
+            user: user.user,
+          };
         }
-                return { status: 500, message: "An error occurred while storing the refresh token" };
+        return {
-            }
+          status: 500,
-            else {
+          message: "An error occurred while storing the refresh token",
+        };
+      } else {
         return { status: 404, message: "User not found" };
       }
-        }
+    } else {
-        else {
       return { status: 404, message: "Unauthorized!!!" };
     }
   } catch (error: any) {
     console.error("Error in generateToken:", error.message || error.toString());
-        return { status: 500, message: `An error occurred while generating the token` };
+    return {
+      status: 500,
+      message: `An error occurred while generating the token`,
+    };
   }
-}
+};
-
-
-

src/api/auth/auth.route.ts

@@ -1,47 +1,80 @@
-import Elysia, { t } from "elysia";
+import { Elysia, t } from "elysia";
 import { generateToken, getUserData, updateUser } from "./auth.controller";
 import { verifyAuth } from "../../middlewares/auth.middlewares";
 
-export const authRoute = new Elysia({
+export const authRoute = new Elysia({ prefix: "/auth" });
-    prefix: "/auth",
+
-    tags: ["Auth"],
+authRoute.get(
+  "/user/:userId",
+  async ({ params: { userId } }) => await getUserData(userId),
+  {
     detail: {
-        description: "Routes for managing users",
+      tags: ["Auth"],
+      summary: "Get user data",
+    },
+    params: t.Object({
+      userId: t.String(),
+    }),
   }
-})
+);
 
-authRoute.get("/user/:userId", async ({ params: { userId } }) => await getUserData(userId), {
+authRoute.post(
+  "/user/update/:userId",
+  async ({ params: { userId }, body }) => await updateUser(userId, body),
+  {
+    detail: {
+      tags: ["Auth"],
+      summary: "Update user",
+    },
     params: t.Object({
-        userId: t.String()
+      userId: t.String(),
-    })
-});
-
-authRoute.post("/user/update/:userId", async ({ params: { userId }, body }) => await updateUser(userId, body), {
-    params: t.Object({
-        userId: t.String()
     }),
     body: t.Object({
       paid_status: t.String(),
       package_expire_date: t.String(),
-    })
+    }),
-});
+  }
+);
 
-authRoute.get("/generate-token/:userId", async (context) => await generateToken(context));
+authRoute.get(
+  "/generate-token/:userId",
+  async (context) => await generateToken(context),
+  {
+    detail: {
+      tags: ["Auth"],
+      summary: "Generate token",
+    },
+    params: t.Object({
+      userId: t.String(),
+    }),
+  }
+);
 
-authRoute.get("/user/me", async ({ cookie }) => {
+authRoute.get(
+  "/user/me",
+  async ({ cookie }) => {
     const authData = await verifyAuth(cookie);
     if (authData.status !== 200) {
       return authData;
-    }
+    } else {
-    else {
+      const userId = authData.userId;
-        const userId: string | any = authData.userId;
       const response = await getUserData(userId);
       if (response?.status === 200) {
-            return { ...response.data, token: authData.token, status: 200, message: "User data fetched successfully" };
+        return {
-        }
+          ...response.data,
-        else {
+          token: authData.token,
+          status: 200,
+          message: "User data fetched successfully",
+        };
+      } else {
         return response;
       }
     }
-})
+  },
-
+  {
+    detail: {
+      tags: ["Auth"],
+      summary: "Get current user",
+    },
+  }
+);

src/api/design/design.controller.ts

@@ -0,0 +1,19 @@
+import { ENV } from "../../config/env";
+
+export const getAllDesign = async (token: string) => {
+  try {
+    const response = await fetch(`${ENV.CANVAS_SERVER_URL_DEV}/design`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+    });
+    const data = await response.json();
+    console.log(response);
+    return data;
+  } catch (error: any) {
+    console.log(error);
+    return { status: 500, message: error.message, token };
+  }
+};

src/api/design/design.route.ts

@@ -0,0 +1,24 @@
+import Elysia from "elysia";
+import { verifyAuth } from "../../middlewares/auth.middlewares";
+import { getAllDesign } from "./design.controller";
+
+export const designRoute = new Elysia({
+    prefix: "/design",
+    tags: ["Design"],
+    detail: {
+        description: "Routes for managing designs",
+    }
+}).derive(async ({ cookie }) => {
+    const authData = await verifyAuth(cookie);
+    return { authData }; // Inject into context
+})
+
+designRoute.get("/", async ({ authData }) => {
+    if (authData.status !== 200)
+        return authData;
+    else {
+        const token = authData.token;
+        const response = await getAllDesign(token);
+        return response;
+    }
+})

src/api/index.ts

@@ -1,16 +1,27 @@
-import Elysia from "elysia";
+import { Elysia } from "elysia";
 import { projectRoutes } from "./project/project.route";
 import { uploadRoutes } from "./upload/upload.route";
 import { authRoute } from "./auth/auth.route";
 import { downloadRoute } from "./downloadCount/download.count.route";
+import { photoLibraryRoutes } from "./photoLibrary/photo.library.route";
+import { designRoute } from "./design/design.route";
 
-export const api = new Elysia({
+export const api = new Elysia({ prefix: "" })
-    prefix: "/api",
+  .get("/", () => {
-});
+    console.log("Root endpoint accessed");
-api.get("/", () => {
     return "Hello from PlanPostAI Canvas API";
-});
+  })
-api.use(authRoute);
+  .use(authRoute)
-api.use(projectRoutes);
+  .use(projectRoutes)
-api.use(uploadRoutes);
+  .use(uploadRoutes)
-api.use(downloadRoute);
+  .use(downloadRoute)
+  .use(photoLibraryRoutes)
+  .use(designRoute)
+  .onError(({ code, error, set }) => {
+    console.error(`API Error: ${code}`, error);
+    if (code === "NOT_FOUND") {
+      set.status = 404;
+      return "API Endpoint Not Found";
+    }
+    return "API Error Occurred";
+  });

src/api/photoLibrary/photo.library.controller.ts

@@ -0,0 +1,21 @@
+import { ENV } from "../../config/env";
+
+export const getPhotos = async (keyword: string, pre_page: number, token: string) => {
+    try {
+        const url = `${ENV.PEXELS_URL}/search?query=${keyword}&per_page=${pre_page}`;
+        const response = await fetch(url, {
+            headers: {
+                Authorization: process.env.PEXELS_ACCESS_KEY as string,
+            },
+        })
+
+        if (!response.ok) {
+            return { status: 500, message: "An error occurred while getting the photos", token }
+        }
+        const data = await response.json();
+        return { data, token }
+    } catch (error: any) {
+        console.log("Error in getting photos:", error.message || error.toString());
+        return { status: 500, message: "An error occurred while getting the photos", token };
+    }
+}

src/api/photoLibrary/photo.library.route.ts

@@ -0,0 +1,31 @@
+import Elysia, { t } from "elysia";
+import { getPhotos } from "./photo.library.controller";
+import { verifyAuth } from "../../middlewares/auth.middlewares";
+
+export const photoLibraryRoutes = new Elysia({
+    prefix: "/photos",
+    tags: ["Photos"],
+    detail: {
+        description: "Routes for managing photo library",
+    }
+}).derive(async ({ cookie }) => {
+    const authData = await verifyAuth(cookie);
+    return { authData }; // Inject into context
+});
+
+photoLibraryRoutes.get("/", async ({ query, authData
+}) => {
+    if (authData.status !== 200)
+        return authData;
+    else {
+        const { keyword, per_page } = query;
+        const token = authData.token;
+        const data = await getPhotos(keyword, per_page, token);
+        return { data };
+    }
+}, {
+    query: t.Object({
+        keyword: t.String(),
+        per_page: t.Number(),
+    })
+})

src/api/project/project.controller.ts

@@ -8,18 +8,26 @@ import { removeBucket } from "../../helper/upload/removeBucket";
 export const getAllProjects = async (userId: string, token: string) => {
   try {
     // Fetch all projects for the given user
-        const allProjects = await db.select({
+    const allProjects = await db
+      .select({
         id: projects.id,
         name: projects.name,
         description: projects.description,
         preview_url: projects.preview_url,
         object: projects.object,
-        }).from(projects).where(eq(projects.userId, userId));
+      })
+      .from(projects)
+      .where(eq(projects.userId, userId));
 
     // Identify projects where 'object' is empty or 'object.objects' is empty
-        const projectsToDelete = allProjects.filter(proj =>
+    const projectsToDelete = allProjects.filter(
-            (proj.object && typeof proj.object === "object" && Object.keys(proj.object).length === 0) ||
+      (proj) =>
-            (proj.object?.objects && Array.isArray(proj.object.objects) && proj.object.objects.length === 0)
+        (proj.object &&
+          typeof proj.object === "object" &&
+          Object.keys(proj.object).length === 0) ||
+        (proj.object?.objects &&
+          Array.isArray(proj.object.objects) &&
+          proj.object.objects.length === 0)
     );
 
     // Delete projects with empty 'object' or empty 'object.objects'
@@ -37,10 +45,15 @@ export const getAllProjects = async (userId: string, token: string) => {
     );
 
     // Get remaining projects
-        const remainingProjects = allProjects.filter(proj =>
+    const remainingProjects = allProjects.filter(
+      (proj) =>
         !(
-                (proj.object && typeof proj.object === "object" && Object.keys(proj.object).length === 0) ||
+          (proj.object &&
-                (proj.object?.objects && Array.isArray(proj.object.objects) && proj.object.objects.length === 0)
+            typeof proj.object === "object" &&
+            Object.keys(proj.object).length === 0) ||
+          (proj.object?.objects &&
+            Array.isArray(proj.object.objects) &&
+            proj.object.objects.length === 0)
         )
     );
 
@@ -48,29 +61,51 @@ export const getAllProjects = async (userId: string, token: string) => {
       return { status: 404, message: "No projects found", token };
     }
 
-        return { status: 200, message: "Projects fetched successfully", data: remainingProjects, token };
+    return {
+      status: 200,
+      message: "Projects fetched successfully",
+      data: remainingProjects,
+      token,
+    };
   } catch (error: any) {
     console.log(error.message);
-        return { status: 500, message: "An error occurred while fetching projects", token };
+    return {
+      status: 500,
+      message: "An error occurred while fetching projects",
+      token,
+    };
   }
 };
 
 export const getEachProjects = async (id: string, token: string) => {
   try {
-        const project = await db.select({
+    const project = await db
+      .select({
         id: projects.id,
         name: projects.name,
         description: projects.description,
         preview_url: projects.preview_url,
         object: projects.object,
-        }).from(projects).where(eq(projects.id, id)).limit(1);
+      })
+      .from(projects)
+      .where(eq(projects.id, id))
+      .limit(1);
     if (project.length === 0) {
       return { status: 404, message: "Project not found", token };
     }
-        return { status: 200, message: "Project fetched successfully", data: project[0], token };
+    return {
+      status: 200,
+      message: "Project fetched successfully",
+      data: project[0],
+      token,
+    };
   } catch (error: any) {
     console.log(error.message);
-        return { status: 500, message: "An error occurred while fetching projects", token };
+    return {
+      status: 500,
+      message: "An error occurred while fetching projects",
+      token,
+    };
   }
 };
 
@@ -78,18 +113,34 @@ export const createProject = async (userId: string, token: string) => {
   try {
     const { id } = await createEmptyProject(userId);
     const bucket = await createBucket(id);
-        return { status: 200, message: "New project created successfully", data: { id, bucketName: bucket }, token };
+    return {
-
+      status: 200,
+      message: "New project created successfully",
+      data: { id, bucketName: bucket },
+      token,
+    };
   } catch (error: any) {
     console.log(error.message);
-        return { status: 500, message: "An error occurred while creating projects", token }
+    return {
+      status: 500,
+      message: "An error occurred while creating projects",
+      token,
+    };
   }
 };
 
-export const updateProject = async (id: string, body: any, token: string) => {
+export const updateProject = async (
+  id: string,
+  body: any,
+  token: string,
+  user_id: string
+) => {
   try {
     // 1. Validate if project exists
-        const existingProject = await db.select().from(projects).where(eq(projects.id, id)).limit(1);
+    const existingProject = await db
+      .select()
+      .from(projects)
+      .where(eq(projects.id, id));
     if (existingProject.length === 0) {
       return { status: 404, message: "Project not found", token };
     }
@@ -97,26 +148,40 @@ export const updateProject = async (id: string, body: any, token: string) => {
     const { object, name, description, preview_url } = body;
     // The preview_url will come from client-side as well, where before updating the project a project capture will be taken and uploaded to the bucket. than the url will be sent to the server.And rest of them are normal process
 
-        const updatedProject = await db.update(projects).set({
+    const updatedProject = await db
+      .update(projects)
+      .set({
         object,
         name,
         description,
-            preview_url
+        preview_url,
-        }).where(eq(projects.id, id)).returning({
+        userId: user_id,
+      })
+      .where(eq(projects.id, id))
+      .returning({
         id: projects.id,
         object: projects.object,
         name: projects.name,
         description: projects.description,
-            preview_url: projects.preview_url
+        preview_url: projects.preview_url,
       });
 
     if (updatedProject.length === 0) {
       return { status: 500, message: "Failed to update the project", token };
     }
-        return { status: 200, message: "Project updated successfully", data: updatedProject[0], token };
+    return {
+      status: 200,
+      message: "Project updated successfully",
+      data: updatedProject[0],
+      token,
+    };
   } catch (error: any) {
     console.log("Error updating project:", error.message || error.toString());
-        return { status: 500, message: "An error occurred while updating the project", token };
+    return {
+      status: 500,
+      message: "An error occurred while updating the project",
+      token,
+    };
   }
 };
 
@@ -145,16 +210,21 @@ export const deleteProject = async (id: string, token: string) => {
         return {
           status: bucketDeletionResult.status,
           message: `Error deleting bucket: ${bucketDeletionResult.message}`,
-                    token
+          token,
         };
       }
-            return { status: 200, message: "Project and associated bucket deleted successfully", token };
+      return {
+        status: 200,
+        message: "Project and associated bucket deleted successfully",
+        token,
+      };
     }
   } catch (error: any) {
     console.log("Error in deleteProject:", error.message || error.toString());
-        return { status: 500, message: "An error occurred while deleting the project", token };
+    return {
+      status: 500,
+      message: "An error occurred while deleting the project",
+      token,
+    };
   }
 };
-
-
-

src/api/project/project.route.ts

@@ -1,5 +1,11 @@
 import { Elysia, t } from "elysia";
-import { createProject, deleteProject, getAllProjects, getEachProjects, updateProject } from "./project.controller";
+import {
+  createProject,
+  deleteProject,
+  getAllProjects,
+  getEachProjects,
+  updateProject,
+} from "./project.controller";
 import { verifyAuth } from "../../middlewares/auth.middlewares";
 
 export const projectRoutes = new Elysia({
@@ -7,29 +13,31 @@ export const projectRoutes = new Elysia({
   tags: ["Projects"],
   detail: {
     description: "Routes for managing projects",
-    }
+  },
 }).derive(async ({ cookie }) => {
   const authData = await verifyAuth(cookie);
   return { authData }; // Inject into context
 });
 
-projectRoutes.get("/each/:project_id", async ({ params: { project_id }, authData }) => {
+projectRoutes.get(
-    if (authData.status !== 200)
+  "/each/:project_id",
-        return authData;
+  async ({ params: { project_id }, authData }) => {
+    if (authData.status !== 200) return authData;
     else {
       const token = authData.token;
       const response = await getEachProjects(project_id, token);
       return response;
     }
-}, {
+  },
+  {
     params: t.Object({
-        project_id: t.String()
+      project_id: t.String(),
-    })
+    }),
-});
+  }
+);
 
 projectRoutes.get("/", async ({ authData }: any) => {
-    if (authData.status !== 200)
+  if (authData.status !== 200) return authData;
-        return authData;
   else {
     const userId = authData.userId;
     const token = authData.token;
@@ -39,8 +47,7 @@ projectRoutes.get("/", async ({ authData }: any) => {
 });
 
 projectRoutes.post("/create", async ({ authData }: any) => {
-    if (authData.status !== 200)
+  if (authData.status !== 200) return authData;
-        return authData;
   else {
     const userId = authData.userId;
     const token = authData.token;
@@ -49,37 +56,49 @@ projectRoutes.post("/create", async ({ authData }: any) => {
   }
 });
 
-projectRoutes.put("/update/:project_id", async ({ body, params: { project_id }, authData }) => {
+projectRoutes.put(
-    if (authData.status !== 200)
+  "/update/:project_id",
-        return authData;
+  async ({ body, params: { project_id }, authData }) => {
+    if (authData.status !== 200) return authData;
     else {
       const token = authData.token;
-        const response = await updateProject(project_id, body, token);
+      const user_id = authData?.userId;
+      // sending user_id to the controller to update the project with the user_id, when user tried to design a existing project from the design project panel
+      const response = await updateProject(
+        project_id,
+        body,
+        token,
+        user_id as string
+      );
       return response;
     }
-}, {
+  },
+  {
     params: t.Object({
-        project_id: t.String()
+      project_id: t.String(),
     }),
     body: t.Object({
       object: t.Record(t.String(), t.Any()), // Allows any JSON object
       name: t.String(),
       description: t.String(),
       preview_url: t.String(),
-    })
+    }),
-});
+  }
+);
 
-projectRoutes.delete("/delete/:project_id", async ({ params: { project_id }, authData }) => {
+projectRoutes.delete(
-    if (authData.status !== 200)
+  "/delete/:project_id",
-        return authData;
+  async ({ params: { project_id }, authData }) => {
+    if (authData.status !== 200) return authData;
     else {
       const token = authData.token;
       const response = await deleteProject(project_id, token);
       return response;
     }
-}, {
+  },
+  {
     params: t.Object({
-        project_id: t.String()
+      project_id: t.String(),
-    })
+    }),
-});
+  }
-
+);

src/app.ts

@@ -1,59 +1,52 @@
-import { Elysia } from "elysia";
+import { Elysia, t } from "elysia";
-import swagger from '@elysiajs/swagger';
+import swagger from "@elysiajs/swagger";
-
-import { ENV } from "./config/env";
 import cors from "@elysiajs/cors";
+import { ENV } from "./config/env";
 import { api } from "./api";
 
-const allowedOrigins = [
+const app = new Elysia()
+  .use(
+    cors({
+      origin: [
         "http://localhost:5175",
-  "http://localhost:5173",
+        "http://localhost:5174",
         "https://dashboard.planpostai.com",
+        "https://dev.dashboard.planpostai.com",
         "https://canvas.planpostai.com",
-];
+        "https://canvasdev.planpostai.com",
-
+      ],
-const app = new Elysia({
-  prefix: "",
-  tags: ["Default"],
-})
-  .use(cors({
-    origin: allowedOrigins,
       methods: ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
-    allowedHeaders: ["Content-Type", "Authorization", "X-Requested-With", "Accept", "Origin", "Access-Control-Allow-Origin"],
+      allowedHeaders: [
+        "Content-Type",
+        "Authorization",
+        "X-Requested-With",
+        "Accept",
+        "Origin",
+        "Access-Control-Allow-Origin",
+      ],
       credentials: true,
-  }))
+    })
-  .use(swagger({
+  )
-    path: "/api/docs",
+  .get("/test", () => "Hello World", {})
+  .use(api)
+  .use(
+    swagger({
+      path: "/swagger",
       documentation: {
+        openapi: "3.1.0",
         info: {
           title: "Canvas API",
           version: "1.0.0",
           description: "Canvas API Documentation",
         },
-      tags: [
-        {
-          name: "Projects",
-          description: "All APIs related to Projects",
       },
-        {
+    })
-          name: "Uploads",
+  )
-          description: "All APIs related to Uploads"
+  .listen(ENV.SERVER_PORT);
-        }
-      ],
-    }
-  }))
-  .onError(({ code, error }) => {
-    if (code === 'NOT_FOUND')
-      return 'Not Found :(';
-    console.log("hello from app.ts under error");
-    console.error(error)
-  });
-
-// all routes here
-app.use(api);
-
-app.listen(ENV.SERVER_PORT, () => {
-  console.log(`🦊 Elysia is running at ${ENV.SERVER_URL}:${ENV.SERVER_PORT}`)
-})
 
+app.routes.forEach((route) => {
+  console.log(`Route: ${route.method} ${route.path}`);
+});
 
+console.log(`🦊 Elysia is running at ${ENV.SERVER_URL}`);
+console.log(`Swagger docs available at ${ENV.SERVER_URL}/swagger`);

src/config/env.ts

@@ -1,14 +1,17 @@
-import 'dotenv/config'
+import "dotenv/config";
 
 export const ENV = {
   SERVER_URL: process.env.SERVER_URL,
   SERVER_PORT: process.env.SERVER_PORT || 5000,
+  CANVAS_SERVER_URL_DEV: process.env.CANVAS_SERVER_URL_DEV,
   DATABASE_URL: process.env.DATABASE_URL,
   MINIO_ACCESS_KEY: process.env.MINIO_ACCESS_KEY,
   MINIO_SECRET_KEY: process.env.MINIO_SECRET_KEY,
-    MINIO_ENDPOINT: process.env.MINIO_ENDPOINT,
+  MINIO_ENDPOINT: process.env.MINIO_URL,
   MINIO_PORT: process.env.MINIO_PORT,
   CLERK_SECRET_KEY: process.env.CLERK_SECRET_KEY,
   JWT_ACCESS_TOKEN_SECRET: process.env.JWT_ACCESS_TOKEN_SECRET,
   JWT_REFRESH_TOKEN_SECRET: process.env.JWT_REFRESH_TOKEN_SECRET,
-}
+  PEXELS_URL: process.env.PEXELS_URL,
+  PEXELS_ACCESS_KEY: process.env.PEXELS_ACCESS_KEY,
+};

src/config/minioClient.ts

@@ -3,8 +3,7 @@ import { ENV } from "../config/env";
 
 export const minioClient = new Client({
   endPoint: ENV.MINIO_ENDPOINT!.replace("http://", "").replace("https://", ""),
-  port: ENV.MINIO_PORT,
+  useSSL: ENV.MINIO_ENDPOINT!.startsWith("https"),
-  useSSL: false,
   accessKey: ENV.MINIO_ACCESS_KEY,
   secretKey: ENV.MINIO_SECRET_KEY,
 });

src/db/schema.ts

@@ -1,4 +1,13 @@
-import { boolean, integer, json, pgTable, text, timestamp, uuid, jsonb } from "drizzle-orm/pg-core";
+import {
+  boolean,
+  integer,
+  json,
+  pgTable,
+  text,
+  timestamp,
+  uuid,
+  jsonb,
+} from "drizzle-orm/pg-core";
 
 export const users = pgTable("users", {
   id: text("user_id").primaryKey().notNull(),
@@ -33,3 +42,18 @@ export const uploads = pgTable("uploads", {
   created_at: timestamp("created_at").defaultNow(),
   updated_at: timestamp("updated_at").defaultNow(),
 });
+
+export const shapes = pgTable("shapes", {
+  id: uuid("shape_id").defaultRandom().primaryKey(),
+  shapes: text("shapes").notNull(),
+  created_at: timestamp("created_at").defaultNow(),
+  updated_at: timestamp("updated_at").defaultNow(),
+});
+
+export const category = pgTable("project_category", {
+  id: uuid("category_id").defaultRandom().primaryKey(),
+  user_id: uuid().references(() => users.id),
+  category: text("category").notNull(),
+  created_at: timestamp("created_at").defaultNow(),
+  updated_at: timestamp("updated_at").defaultNow(),
+});