planpostai/canvas-backend
3
0
Fork 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions

Compare commits

base: planpostai:main
Branches Tags
planpostai:main
planpostai:canvas_updated_be
planpostai:dev
..
compare: planpostai:canvas_updated_be
Branches Tags
planpostai:main
planpostai:canvas_updated_be
planpostai:dev

No commits in common. "main" and "canvas_updated_be" have entirely different histories.
main ... canvas_upd

16 changed files with 463 additions and 744 deletions
Show stats Expand all files Collapse all files

37
Dockerfile
View file

@ -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"]

53
docker-compose.yml
View file

@ -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:

10
drizzle.config.ts
View file

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

9
entrypoint.sh
View file

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

5
package.json
View file

@ -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"

107
src/api/auth/auth.controller.ts
View file

@ -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 {
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
@ -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 {
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" };
@ -58,36 +47,20 @@ export const getUserData = async (userId: string) => {
}
};
export const updateUser = async (
id: string,
body: {
paid_status: string;
package_expire_date: string;
}
) => {
export const updateUser = async (id: 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).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 };
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 {
@ -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 &&
refresh_cookie === undefined &&
userId !== undefined
) {
}
else if (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);
@ -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 {
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",
};
} else {
return { status: 500, 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` };
}
};
}

85
src/api/auth/auth.route.ts
View file

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

5
src/api/design/design.controller.ts
View file

@ -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 };
}
};
}

33
src/api/index.ts
View file

@ -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: "" })
.get("/", () => {
console.log("Root endpoint accessed");
export const api = new Elysia({
prefix: "/api",
});
api.get("/", () => {
return "Hello from PlanPostAI Canvas API";
})
.use(authRoute)
.use(projectRoutes)
.use(uploadRoutes)
.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";
});
});
api.use(authRoute);
api.use(projectRoutes);
api.use(uploadRoutes);
api.use(downloadRoute);
api.use(photoLibraryRoutes);
api.use(designRoute);

129
src/api/project/project.controller.ts
View file

@ -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
.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) =>
(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)
const projectsToDelete = allProjects.filter(proj =>
(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'
@ -45,15 +37,10 @@ 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?.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)
)
);
@ -61,51 +48,29 @@ 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 };
}
};
@ -113,34 +78,18 @@ 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,
user_id: 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));
const existingProject = await db.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
.update(projects)
.set({
const updatedProject = await db.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 {
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 };
}
};
@ -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 {
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 };
}
};

75
src/api/project/project.route.ts
View file

@ -1,11 +1,5 @@
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({
@ -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(
"/each/:project_id",
async ({ params: { project_id }, authData }) => {
if (authData.status !== 200) return authData;
projectRoutes.get("/each/:project_id", 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) 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(
"/update/:project_id",
async ({ body, params: { project_id }, authData }) => {
if (authData.status !== 200) return authData;
projectRoutes.put("/update/:project_id", async ({ body, params: { project_id }, 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(
project_id,
body,
token,
user_id as string
);
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 }) => {
if (authData.status !== 200) return authData;
projectRoutes.delete("/delete/:project_id", 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()
})
});

76
src/app.ts
View file

@ -1,52 +1,60 @@
import { Elysia, t } from "elysia";
import swagger from "@elysiajs/swagger";
import cors from "@elysiajs/cors";
import { Elysia } from "elysia";
import swagger from '@elysiajs/swagger';
import { ENV } from "./config/env";
import cors from "@elysiajs/cors";
import { api } from "./api";
const app = new Elysia()
.use(
cors({
origin: [
const allowedOrigins = [
"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: [
"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,
})
)
.get("/test", () => "Hello World", {})
.use(api)
.use(
swagger({
path: "/swagger",
}))
.use(swagger({
path: "/api/docs",
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",
},
})
)
.listen(ENV.SERVER_PORT);
{
name: "Uploads",
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`);

6
src/config/env.ts
View file

@ -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,
};
}

7
src/config/minioClient.ts
View file

@ -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://", ""),
useSSL: ENV.MINIO_ENDPOINT!.startsWith("https"),
endPoint: ENV.MINIO_ENDPOINT!,
port: ENV.MINIO_PORT,
useSSL: false,
accessKey: ENV.MINIO_ACCESS_KEY,
secretKey: ENV.MINIO_SECRET_KEY,
});
})

26
src/db/schema.ts
View file

@ -1,13 +1,4 @@
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(),
@ -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(),
});