upd

src/db/schema/apps.ts

@@ -1,5 +1,6 @@
 import {
   pgTable,
+  primaryKey,
   timestamp,
   uniqueIndex,
   uuid,
@@ -15,9 +16,6 @@ export const appsTable = pgTable(
     id: uuid("id").defaultRandom().primaryKey(),
     name: varchar("name").notNull(),
     fileName: varchar("filename").notNull(),
-    serverId: uuid("server_id")
-      .notNull()
-      .references(() => serversTable.id, { onDelete: "cascade" }),
     companyId: uuid("company_id")
       .notNull()
       .references(() => companiesTable.id, { onDelete: "cascade" }),
@@ -31,19 +29,39 @@ export const appsTable = pgTable(
   },
   (table) => ({
     uniqueFileNameServerId: uniqueIndex("unique_file_name_server_id").on(
-      table.fileName,
-      table.serverId
+      table.fileName
     ),
   })
 );
 
-export const appsRelations = relations(appsTable, ({ one }) => ({
+export const appsRelations = relations(appsTable, ({ one, many }) => ({
   company: one(companiesTable, {
     fields: [appsTable.companyId],
     references: [companiesTable.id],
   }),
+  servers: many(appsToServers),
+}));
+
+export const appsToServers = pgTable(
+  "apps_to_servers",
+  {
+    appId: uuid("app_id")
+      .notNull()
+      .references(() => appsTable.id, { onDelete: "cascade" }),
+    serverId: uuid("server_id")
+      .notNull()
+      .references(() => serversTable.id, { onDelete: "cascade" }),
+  },
+  (t) => [primaryKey({ columns: [t.appId, t.serverId] })]
+);
+
+export const appsToServersRelations = relations(appsToServers, ({ one }) => ({
+  app: one(appsTable, {
+    fields: [appsToServers.appId],
+    references: [appsTable.id],
+  }),
   server: one(serversTable, {
-    fields: [appsTable.serverId],
+    fields: [appsToServers.serverId],
     references: [serversTable.id],
   }),
 }));

src/db/schema/servers.ts

@@ -9,7 +9,7 @@ import {
 import { companiesTable } from "./companies";
 import { relations } from "drizzle-orm";
 import { sessionsTable } from "./sessions";
-import { appsTable } from "./apps";
+import { appsToServers } from "./apps";
 
 export const serversTable = pgTable(
   "servers",
@@ -49,5 +49,5 @@ export const serversRelations = relations(serversTable, ({ one, many }) => ({
     references: [companiesTable.id],
   }),
   sessions: many(sessionsTable),
-  apps: many(appsTable),
+  apps: many(appsToServers),
 }));

src/services/apps/create.ts

@@ -1,6 +1,6 @@
 import { status } from "elysia";
 import db from "../../db";
-import { appsTable } from "../../db/schema";
+import { appsTable, appsToServers } from "../../db/schema";
 import { sql } from "drizzle-orm";
 import type { AuthContext } from "./../../middlewares/auth";
 
@@ -26,21 +26,30 @@ export default async function createApp(
           name: app,
           fileName: app,
           companyId: body.companyId,
-          serverId: body.serverId,
         }))
       )
       .returning()
       .onConflictDoUpdate({
-        target: [appsTable.fileName, appsTable.serverId],
+        target: [appsTable.fileName],
         set: {
           name: sql`excluded.name`,
           fileName: sql`excluded.fileName`,
           companyId: sql`excluded.company_id`,
-          serverId: sql`excluded.server_id`,
         },
       });
 
-    return apps;
+    const appsOfServer = await db
+      .insert(appsToServers)
+      .values(apps.map(({ id }) => ({ appId: id, serverId: body.serverId })))
+      .onConflictDoUpdate({
+        target: [appsToServers.appId, appsToServers.serverId],
+        set: { appId: sql`excluded.app_id`, serverId: body.serverId },
+      })
+      .returning();
+
+    console.log(appsOfServer);
+
+    return appsOfServer;
   } catch (error) {
     console.log((error as Error).message);
     return status(500, "Internal Server Error");

src/services/servers/getServers.ts

@@ -52,7 +52,7 @@ export default async function getServers(
                   },
                 },
               },
-              apps: true,
+              apps: { with: { app: true } },
             }
           : undefined),
       },