Dockerfile

@@ -1,37 +0,0 @@
-# Build stage
-FROM oven/bun:1 AS builder
-
-# Copy package files
-COPY package.json .
-COPY bun.lockb .
-
-# Install dependencies
-RUN bun install --frozen-lockfile
-
-# Copy source code
-COPY . .
-
-# Build the application
-RUN bun run build
-
-EXPOSE 5005
-
-# Production stage
-# FROM debian:bookworm-slim
-
-# WORKDIR /app
-
-# # Copy only the compiled binary from builder
-# COPY --from=builder /app/server .
-
-# # Expose the port your app runs on
-# EXPOSE 3000
-
-# # Copy the entrypoint script
-# COPY entrypoint.sh .
-
-# Make the entrypoint script executable
-RUN chmod +x ./entrypoint.sh
-
-# Set the entrypoint
-ENTRYPOINT ["./entrypoint.sh"]

docker-compose.yml

@@ -1,53 +0,0 @@
-services:
-  api:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    ports:
-      - "5005:5005"
-    depends_on:
-      db:
-        condition: service_healthy
-      minio:
-        condition: service_healthy
-    environment:
-      NODE_ENV: production
-      DATABASE_URL: ${DATABASE_URL}
-
-  db:
-    image: postgres:latest
-    environment:
-      POSTGRES_USER: ${DB_USER}
-      POSTGRES_PASSWORD: ${DB_PASSWORD}
-      POSTGRES_DB: ${DB_NAME}
-    # ports:
-    #   - "${DB_PORT}:5432"
-    volumes:
-      - postgres_data:/var/lib/postgresql/data
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U ${DB_USER} -d ${DB_NAME}"]
-      interval: 10s
-      timeout: 5s
-      retries: 5
-      start_period: 10s
-
-  minio:
-    image: minio/minio:latest
-    # ports:
-    # - "9000:9000"
-    # - "9001:9001"
-    environment:
-      MINIO_ROOT_USER: ${MINIO_ROOT_USER}
-      MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD}
-    command: server /data --console-address ":9001"
-    volumes:
-      - minio_data:/data
-    healthcheck:
-      test: ["CMD", "mc", "ready", "local"]
-      interval: 30s
-      timeout: 20s
-      retries: 3
-
-volumes:
-  postgres_data:
-  minio_data:

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!,
     },

entrypoint.sh

@@ -1,9 +0,0 @@
-#!/bin/sh
-set -e
-
-# Run migrations
-bun run db:migrate
-
-# Start the application
-echo "Starting the application..."
-./server

package.json

@@ -3,11 +3,10 @@
   "version": "1.0.50",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "db:studio": "drizzle-kit studio",
+    "db:studio": "drizzle-kit studio --port=3000",
     "db:generate": "drizzle-kit generate",
     "db:migrate": "drizzle-kit migrate",
     "db:push": "drizzle-kit push:pg",
-    "build": "bun build --compile --minify-whitespace --minify-syntax --target bun --outfile server ./src/app.ts",
     "dev": "bun run --watch src/app.ts"
   },
   "dependencies": {
@@ -15,7 +14,6 @@
     "@elysiajs/cookie": "^0.8.0",
     "@elysiajs/cors": "^1.2.0",
     "@elysiajs/swagger": "^1.2.0",
-    "drizzle-kit": "^0.30.2",
     "dotenv": "^16.4.7",
     "drizzle-orm": "^0.38.4",
     "elysia": "latest",
@@ -28,6 +26,7 @@
   "devDependencies": {
     "@types/pg": "^8.11.10",
     "bun-types": "latest",
+    "drizzle-kit": "^0.30.2",
     "tsx": "^4.19.2"
   },
   "module": "src/app.js"

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,11 +7,7 @@ import { eq } from "drizzle-orm";
 // @ts-ignore
 import jwt from "jsonwebtoken";
 
-import {
+import { checkUserInDB, createUser, storeRefreshToken } from "../../helper/auth/auth.helper";
-  checkUserInDB,
-  createUser,
-  storeRefreshToken,
-} from "../../helper/auth/auth.helper";
 import { verifyAuth } from "../../middlewares/auth.middlewares";
 
 // Initialize Clerk with your API key
@@ -21,10 +17,11 @@ 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,
@@ -36,18 +33,10 @@ export const getUserData = async (userId: string) => {
 
             const userData = await createUser(userDBData);
 
-      return {
+            return { status: 200, message: "User retrieved successfully", data: userData };
-        status: 200,
-        message: "User retrieved successfully",
-        data: userData,
-      };
         }
         if (user && checkInDB.found) {
-      return {
+            return { status: 200, message: "User retrieved successfully", data: checkInDB };
-        status: 200,
-        message: "User retrieved successfully",
-        data: checkInDB,
-      };
         }
         if (!user) {
             return { status: 404, message: "User not found" };
@@ -58,36 +47,20 @@ export const getUserData = async (userId: string) => {
     }
 };
 
-export const updateUser = async (
+export const updateUser = async (id: string, body: {
-  id: string,
+    paid_status: string,
-  body: {
+    package_expire_date: string,
-    paid_status: string;
+}) => {
-    package_expire_date: string;
-  }
-) => {
     try {
-    const updateUserData = await db
+        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 });
-      .update(users)
+
-      .set({
+        return { status: 200, message: "User updated successfully", updateUserData };
-        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 {
+        return { status: 500, message: `An error occurred while updating the user` };
-      status: 500,
-      message: `An error occurred while updating the user`,
-    };
     }
-};
+}
 
 export const generateToken = async (context: any) => {
     try {
@@ -98,24 +71,16 @@ export const generateToken = async (context: any) => {
         if (access_cookie !== undefined || refresh_cookie !== undefined) {
             const verify = await verifyAuth(context?.cookie);
             return verify;
-    } else if (
+        }
-      access_cookie === undefined &&
+        else if (access_cookie === undefined && refresh_cookie === undefined && userId !== 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, {
+                const accessToken = jwt.sign({ userId }, ENV.JWT_ACCESS_TOKEN_SECRET, { expiresIn: '3h' });
-          expiresIn: "3h",
-        });
 
                 // generate refresh token
-        const refreshToken = jwt.sign(
+                const refreshToken = jwt.sign({ userId }, ENV.JWT_REFRESH_TOKEN_SECRET, { expiresIn: '7d' });
-          { userId },
-          ENV.JWT_REFRESH_TOKEN_SECRET,
-          { expiresIn: "7d" }
-        );
 
                 // store refresh token in db
                 const storeRToken = await storeRefreshToken(userId, refreshToken);
@@ -125,7 +90,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
                     });
@@ -134,33 +99,27 @@ 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 {
+                    return { status: 201, message: "Token generated successfully", token: accessToken, user: user.user };
-            status: 201,
-            message: "Token generated successfully",
-            token: accessToken,
-            user: user.user,
-          };
                 }
-        return {
+                return { status: 500, message: "An error occurred while storing the refresh token" };
-          status: 500,
+            }
-          message: "An error occurred while storing the refresh token",
+            else {
-        };
-      } 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 {
+        return { status: 500, message: `An error occurred while generating the token` };
-      status: 500,
-      message: `An error occurred while generating the token`,
-    };
     }
-};
+}
+
+
+

src/api/auth/auth.route.ts

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

src/api/design/design.controller.ts

@@ -7,13 +7,12 @@ export const getAllDesign = async (token: string) => {
             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/index.ts

@@ -1,4 +1,4 @@
-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";
@@ -6,22 +6,17 @@ 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({ prefix: "" })
+export const api = new Elysia({
-  .get("/", () => {
+    prefix: "/api",
-    console.log("Root endpoint accessed");
+});
+
+api.get("/", () => {
     return "Hello from PlanPostAI Canvas API";
-  })
+});
-  .use(authRoute)
+
-  .use(projectRoutes)
+api.use(authRoute);
-  .use(uploadRoutes)
+api.use(projectRoutes);
-  .use(downloadRoute)
+api.use(uploadRoutes);
-  .use(photoLibraryRoutes)
+api.use(downloadRoute);
-  .use(designRoute)
+api.use(photoLibraryRoutes);
-  .onError(({ code, error, set }) => {
+api.use(designRoute);
-    console.error(`API Error: ${code}`, error);
-    if (code === "NOT_FOUND") {
-      set.status = 404;
-      return "API Endpoint Not Found";
-    }
-    return "API Error Occurred";
-  });

src/api/project/project.controller.ts

@@ -8,26 +8,18 @@ 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
+        const allProjects = await db.select({
-      .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(
+        const projectsToDelete = allProjects.filter(proj =>
-      (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)
         );
 
         // Delete projects with empty 'object' or empty 'object.objects'
@@ -45,15 +37,10 @@ export const getAllProjects = async (userId: string, token: string) => {
         );
 
         // Get remaining projects
-    const remainingProjects = allProjects.filter(
+        const remainingProjects = allProjects.filter(proj =>
-      (proj) =>
             !(
-          (proj.object &&
+                (proj.object && typeof proj.object === "object" && Object.keys(proj.object).length === 0) ||
-            typeof proj.object === "object" &&
+                (proj.object?.objects && Array.isArray(proj.object.objects) && proj.object.objects.length === 0)
-            Object.keys(proj.object).length === 0) ||
-          (proj.object?.objects &&
-            Array.isArray(proj.object.objects) &&
-            proj.object.objects.length === 0)
             )
         );
 
@@ -61,51 +48,29 @@ export const getAllProjects = async (userId: string, token: string) => {
             return { status: 404, message: "No projects found", token };
         }
 
-    return {
+        return { status: 200, message: "Projects fetched successfully", data: remainingProjects, token };
-      status: 200,
-      message: "Projects fetched successfully",
-      data: remainingProjects,
-      token,
-    };
     } catch (error: any) {
         console.log(error.message);
-    return {
+        return { status: 500, message: "An error occurred while fetching projects", token };
-      status: 500,
-      message: "An error occurred while fetching projects",
-      token,
-    };
     }
 };
 
 export const getEachProjects = async (id: string, token: string) => {
     try {
-    const project = await db
+        const project = await db.select({
-      .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 {
+        return { status: 200, message: "Project fetched successfully", data: project[0], token };
-      status: 200,
-      message: "Project fetched successfully",
-      data: project[0],
-      token,
-    };
     } catch (error: any) {
         console.log(error.message);
-    return {
+        return { status: 500, message: "An error occurred while fetching projects", token };
-      status: 500,
-      message: "An error occurred while fetching projects",
-      token,
-    };
     }
 };
 
@@ -113,34 +78,18 @@ export const createProject = async (userId: string, token: string) => {
     try {
         const { id } = await createEmptyProject(userId);
         const bucket = await createBucket(id);
-    return {
+        return { status: 200, message: "New project created successfully", data: { id, bucketName: bucket }, token };
-      status: 200,
+
-      message: "New project created successfully",
-      data: { id, bucketName: bucket },
-      token,
-    };
     } catch (error: any) {
         console.log(error.message);
-    return {
+        return { status: 500, message: "An error occurred while creating projects", token }
-      status: 500,
-      message: "An error occurred while creating projects",
-      token,
-    };
     }
 };
 
-export const updateProject = async (
+export const updateProject = async (id: string, body: any, token: string, user_id: string) => {
-  id: string,
-  body: any,
-  token: string,
-  user_id: string
-) => {
     try {
         // 1. Validate if project exists
-    const existingProject = await db
+        const existingProject = await db.select().from(projects).where(eq(projects.id, id));
-      .select()
-      .from(projects)
-      .where(eq(projects.id, id));
         if (existingProject.length === 0) {
             return { status: 404, message: "Project not found", token };
         }
@@ -148,40 +97,27 @@ export const updateProject = async (
         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
+        const updatedProject = await db.update(projects).set({
-      .update(projects)
-      .set({
             object,
             name,
             description,
             preview_url,
             userId: user_id,
-      })
+        }).where(eq(projects.id, id)).returning({
-      .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 {
+        return { status: 200, message: "Project updated successfully", data: updatedProject[0], token };
-      status: 200,
-      message: "Project updated successfully",
-      data: updatedProject[0],
-      token,
-    };
     } catch (error: any) {
         console.log("Error updating project:", error.message || error.toString());
-    return {
+        return { status: 500, message: "An error occurred while updating the project", token };
-      status: 500,
-      message: "An error occurred while updating the project",
-      token,
-    };
     }
 };
 
@@ -210,21 +146,16 @@ export const deleteProject = async (id: string, token: string) => {
                 return {
                     status: bucketDeletionResult.status,
                     message: `Error deleting bucket: ${bucketDeletionResult.message}`,
-          token,
+                    token
                 };
             }
-      return {
+            return { status: 200, message: "Project and associated bucket deleted successfully", token };
-        status: 200,
-        message: "Project and associated bucket deleted successfully",
-        token,
-      };
         }
     } catch (error: any) {
         console.log("Error in deleteProject:", error.message || error.toString());
-    return {
+        return { status: 500, message: "An error occurred while deleting the project", token };
-      status: 500,
-      message: "An error occurred while deleting the project",
-      token,
-    };
     }
 };
+
+
+

src/api/project/project.route.ts

@@ -1,11 +1,5 @@
 import { Elysia, t } from "elysia";
-import {
+import { createProject, deleteProject, getAllProjects, getEachProjects, updateProject } from "./project.controller";
-  createProject,
-  deleteProject,
-  getAllProjects,
-  getEachProjects,
-  updateProject,
-} from "./project.controller";
 import { verifyAuth } from "../../middlewares/auth.middlewares";
 
 export const projectRoutes = new Elysia({
@@ -13,31 +7,29 @@ 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(
+projectRoutes.get("/each/:project_id", async ({ params: { project_id }, authData }) => {
-  "/each/:project_id",
+    if (authData.status !== 200)
-  async ({ params: { project_id }, authData }) => {
+        return 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) return authData;
+    if (authData.status !== 200)
+        return authData;
     else {
         const userId = authData.userId;
         const token = authData.token;
@@ -47,7 +39,8 @@ projectRoutes.get("/", async ({ authData }: any) => {
 });
 
 projectRoutes.post("/create", async ({ authData }: any) => {
-  if (authData.status !== 200) return authData;
+    if (authData.status !== 200)
+        return authData;
     else {
         const userId = authData.userId;
         const token = authData.token;
@@ -56,49 +49,39 @@ projectRoutes.post("/create", async ({ authData }: any) => {
     }
 });
 
-projectRoutes.put(
+projectRoutes.put("/update/:project_id", async ({ body, params: { project_id }, authData }) => {
-  "/update/:project_id",
+    if (authData.status !== 200)
-  async ({ body, params: { project_id }, authData }) => {
+        return authData;
-    if (authData.status !== 200) return authData;
     else {
         const token = authData.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(
+        const response = await updateProject(project_id, body, token, user_id as string);
-        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(
+projectRoutes.delete("/delete/:project_id", async ({ params: { project_id }, authData }) => {
-  "/delete/:project_id",
+    if (authData.status !== 200)
-  async ({ params: { project_id }, authData }) => {
+        return 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,52 +1,60 @@
-import { Elysia, t } from "elysia";
+import { Elysia } from "elysia";
-import swagger from "@elysiajs/swagger";
+import swagger from '@elysiajs/swagger';
-import cors from "@elysiajs/cors";
+
 import { ENV } from "./config/env";
+import cors from "@elysiajs/cors";
 import { api } from "./api";
 
-const app = new Elysia()
+const allowedOrigins = [
-  .use(
-    cors({
-      origin: [
   "http://localhost:5175",
   "http://localhost:5174",
+  "http://localhost:5173",
   "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: [
+    allowedHeaders: ["Content-Type", "Authorization", "X-Requested-With", "Accept", "Origin", "Access-Control-Allow-Origin"],
-        "Content-Type",
-        "Authorization",
-        "X-Requested-With",
-        "Accept",
-        "Origin",
-        "Access-Control-Allow-Origin",
-      ],
     credentials: true,
-    })
+  }))
-  )
+  .use(swagger({
-  .get("/test", () => "Hello World", {})
+    path: "/api/docs",
-  .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",
-  .listen(ENV.SERVER_PORT);
+          description: "All APIs related to Uploads"
+        }
+      ],
+    }
+  }))
+  .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,4 +1,4 @@
-import "dotenv/config";
+import 'dotenv/config'
 
 export const ENV = {
     SERVER_URL: process.env.SERVER_URL,
@@ -7,11 +7,11 @@ export const ENV = {
     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_URL,
+    MINIO_ENDPOINT: process.env.MINIO_ENDPOINT,
     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

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

src/db/schema.ts

@@ -1,13 +1,4 @@
-import {
+import { boolean, integer, json, pgTable, text, timestamp, uuid, jsonb } from "drizzle-orm/pg-core";
-  boolean,
-  integer,
-  json,
-  pgTable,
-  text,
-  timestamp,
-  uuid,
-  jsonb,
-} from "drizzle-orm/pg-core";
 
 export const users = pgTable("users", {
     id: text("user_id").primaryKey().notNull(),
@@ -42,18 +33,3 @@ 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(),
-});