Arjuna-Ragil · Arjuna-Ragil · Feb 9, 2026 · Feb 9, 2026
diff --git a/Internal/adapters/repository/dynamicDBRepo.go b/Internal/adapters/repository/dynamicDBRepo.go
@@ -43,3 +43,11 @@ func (dr *DynamicDBRepo) GetTables(projectID uint) ([]domain.DynTableDef, error)
 	}
 	return tables, nil
 }
+
+func (dr *DynamicDBRepo) DropDynTable(tx *gorm.DB, projectID uint, tableID uint) error {
+	var dynTable domain.DynTableDef
+	if err := tx.Where("project_id = ? AND id = ?", projectID, tableID).Delete(&dynTable).Error; err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/Internal/api/Routes/routev1.go b/Internal/api/Routes/routev1.go
@@ -59,8 +59,12 @@ func SetupRouterV1(r *gin.Engine, deps Deps) {
 				{
 					manage.POST("/invite/:projectid", deps.Project.InviteProjectHandler)
 					manage.DELETE("/remove/:projuserid", deps.Project.RemoveProjectUserHandler)
-					manage.POST("/create/table/:projectid", deps.DynamicDB.CreateDynamicDBHandler)
-					manage.POST("/create/col/:projectid/:tableid", deps.DynamicDB.AddDynamicColHandler)
+					table := manage.Group("/table")
+					{
+						table.POST("/create/:projectid", deps.DynamicDB.CreateDynamicDBHandler)
+						table.POST("/create/col/:projectid/:tableid", deps.DynamicDB.AddDynamicColHandler)
+						table.DELETE("/drop/:projectid/:tableid", deps.DynamicDB.DropDynTableHandler)
+					}
 				}
 			}
 		}

diff --git a/Internal/api/handlers/dynamicDBHandler.go b/Internal/api/handlers/dynamicDBHandler.go
@@ -117,3 +117,46 @@ func (dh *DynamicDBHandler) GetDynTablesHandler(c *gin.Context) {
 		"data":    tables,
 	})
 }
+
+func (dh *DynamicDBHandler) DropDynTableHandler(c *gin.Context) {
+	projectIDStr := c.Param("projectid")
+	projectID, err := strconv.Atoi(projectIDStr)
+	if err != nil {
+		c.JSON(400, gin.H{
+			"message": "Project ID not valid",
+			"error":   err.Error(),
+		})
+		return
+	}
+	tableIDStr := c.Param("tableid")
+	tableID, err := strconv.Atoi(tableIDStr)
+	if err != nil {
+		c.JSON(400, gin.H{
+			"message": "Table ID not valid",
+			"data":    err.Error(),
+		})
+		return
+	}
+	input := services.DropTableReq{
+		ProjectID: uint(projectID),
+		TableID:   uint(tableID),
+	}
+	if err = c.ShouldBindJSON(&input); err != nil {
+		c.JSON(400, gin.H{
+			"message": "Invalid input",
+			"error":   err.Error(),
+		})
+		return
+	}
+	if err = dh.Serv.DelDynTable(&input); err != nil {
+		c.JSON(500, gin.H{
+			"message": "Failed to delete dynamic table",
+			"error":   err.Error(),
+		})
+		return
+	}
+	c.JSON(200, gin.H{
+		"message": "Successfully deleted dynamic table",
+		"data":    nil,
+	})
+}
diff --git a/Internal/core/domain/projectdb.go b/Internal/core/domain/projectdb.go
@@ -26,7 +26,7 @@ type DynTableDef struct {
 	ProjectID uint        `gorm:"not null" json:"project_id"`
 	Name      string      `gorm:"size:255;not null" json:"name"`
 	Alias     string      `gorm:"size:255;not null" json:"alias"`
-	Columns   []DynColDef `gorm:"foreignKey:DynTableDefID" json:"columns"`
+	Columns   []DynColDef `gorm:"foreignKey:DynTableDefID;constraint:OnUpdate:CASCADE,OnDelete:CASCADE;" json:"columns"`
 }
 
 type DynColDef struct {

diff --git a/Internal/core/services/dynamicDBService.go b/Internal/core/services/dynamicDBService.go
@@ -28,6 +28,12 @@ type DDLTableReq struct {
 	Columns   []ColumnReq `json:"columns"`
 }
 
+type DropTableReq struct {
+	ProjectID uint   `json:"project_id"`
+	TableID   uint   `json:"id"`
+	TableName string `json:"table_name"`
+}
+
 func sanitizeInput(input string) string {
 	result := strings.ToLower(input)
 	result = strings.ReplaceAll(result, " ", "_")
@@ -126,3 +132,30 @@ func (ds *DynamicDBService) GetDynamicTables(projectID uint) ([]domain.DynTableD
 	}
 	return tables, nil
 }
+
+// DelDynTable DROP TABLE IF EXISTS name CASCADE;
+func (ds *DynamicDBService) DelDynTable(input *DropTableReq) error {
+	tx := ds.DB.Gorm.Begin()
+
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+		}
+	}()
+
+	safeTableName := fmt.Sprintf("proj_%d_%s", input.ProjectID, sanitizeInput(input.TableName))
+
+	if err := ds.Repo.DropDynTable(tx, input.ProjectID, input.TableID); err != nil {
+		tx.Rollback()
+		return err
+	}
+
+	var queryBuilder strings.Builder
+	queryBuilder.WriteString(fmt.Sprintf("DROP TABLE IF EXISTS %s CASCADE", safeTableName))
+	query := queryBuilder.String()
+
+	if err := ds.Repo.RunDynamicQuery(tx, query); err != nil {
+		return err
+	}
+	return tx.Commit().Error
+}
diff --git a/Lb-web/src/features/project/pages/ProjectDatabase.tsx b/Lb-web/src/features/project/pages/ProjectDatabase.tsx
@@ -50,13 +50,18 @@
     // Expand/Collapse State
     const [expandedTables, setExpandedTables] = useState<Record<number, boolean>>({});
 
+    // Delete Table State
+    const [deleteDialogOpen, setDeleteDialogOpen] = useState(false);
+    const [tableToDelete, setTableToDelete] = useState<DynTableDef | null>(null);
+    const [deleteLoading, setDeleteLoading] = useState(false);
+
 
     useEffect(() => {
         if (projectId) {
            fetchProject();
            fetchTables();
        }
    }, [projectId, id]);

    const fetchProject = async () => {
        try {
@@ -121,7 +126,7 @@
            setTableName("");
            setNewColumns([]);
            fetchTables(); // Refresh list
        } catch (err: any) {
            console.error("Failed to create table", err);
            setCreateError(err.response?.data?.message || err.message || "Failed to create table");
        } finally {
@@ -180,6 +185,27 @@
     };
 
 
+    const openDeleteDialog = (table: DynTableDef) => {
+        setTableToDelete(table);
+        setDeleteDialogOpen(true);
+    };
+
+    const confirmDeleteTable = async () => {
+        if (!tableToDelete) return;
+        setDeleteLoading(true);
+        try {
+            await dynamicDBService.deleteTable(projectId, tableToDelete.id);
+            setDeleteDialogOpen(false);
+            setTableToDelete(null);
+            fetchTables();
+        } catch (err) {
+            console.error("Failed to delete table", err);
+            // In a real app, show a toast here
+        } finally {
+            setDeleteLoading(false);
+        }
+    };
+
     if (loadingProject) {
         return <div className="flex h-screen items-center justify-center bg-slate-50"><Loader2 className="animate-spin text-sky-600" /></div>;
     }
@@ -383,6 +409,42 @@
                                     </DialogFooter>
                                 </DialogContent>
                             </Dialog>
+
+                            {/* Delete Confirmation Dialog */}
+                            <Dialog open={deleteDialogOpen} onOpenChange={setDeleteDialogOpen}>
+                                <DialogContent>
+                                    <DialogHeader>
+                                        <DialogTitle className="text-red-600 flex items-center gap-2">
+                                            <Trash2 className="h-5 w-5" /> Delete Table
+                                        </DialogTitle>
+                                        <DialogDescription>
+                                            Are you sure you want to delete the table <strong>{tableToDelete?.alias}</strong>?
+                                            <br /><br />
+                                            This action cannot be undone and will permanently delete all data in this table.
+                                        </DialogDescription>
+                                    </DialogHeader>
+                                    <DialogFooter>
+                                        <Button variant="outline" onClick={() => setDeleteDialogOpen(false)} disabled={deleteLoading}>
+                                            Cancel
+                                        </Button>
+                                        <Button
+                                            variant="destructive"
+                                            onClick={confirmDeleteTable}
+                                            disabled={deleteLoading}
+                                            className="bg-red-600 hover:bg-red-700"
+                                        >
+                                            {deleteLoading ? (
+                                                <>
+                                                    <Loader2 className="mr-2 h-4 w-4 animate-spin" />
+                                                    Deleting...
+                                                </>
+                                            ) : (
+                                                "Delete Table"
+                                            )}
+                                        </Button>
+                                    </DialogFooter>
+                                </DialogContent>
+                            </Dialog>
                         </div>
 
                         {/* Tables List */}
@@ -408,6 +470,18 @@
                                                 </div>
                                             </div>
                                             <div className="flex items-center space-x-2">
+                                                <Button
+                                                    size="icon"
+                                                    variant="ghost"
+                                                    className="h-8 w-8 text-red-500 hover:text-red-700 hover:bg-red-100"
+                                                    onClick={(e) => {
+                                                        e.stopPropagation();
+                                                        openDeleteDialog(t);
+                                                    }}
+                                                    title="Drop Table"
+                                                >
+                                                    <Trash2 className="h-4 w-4" />
+                                                </Button>
                                                 <Button size="sm" variant="ghost" className="text-sky-600" onClick={(e) => {
                                                     e.stopPropagation();
                                                     openAddColDialog(t);

diff --git a/Lb-web/src/features/project/services/dynamicDBService.ts b/Lb-web/src/features/project/services/dynamicDBService.ts
@@ -12,18 +12,28 @@ export interface DDLTableReq {
 
 export const dynamicDBService = {
     createTable: async (projectId: number, data: DDLTableReq) => {
-        const response = await api.post(`/protected/project/manage/create/table/${projectId}`, data);
+        const response = await api.post(`/protected/project/manage/table/create/${projectId}`, data);
         return response.data;
     },
 
     addColumn: async (projectId: number, tableId: number, data: DDLTableReq) => {
-        const response = await api.post(`/protected/project/manage/create/col/${projectId}/${tableId}`, data);
+        const response = await api.post(`/protected/project/manage/table/create/col/${projectId}/${tableId}`, data);
         return response.data;
     },
 
     getTables: async (projectId: number): Promise<DynTableDef[]> => {
         const response = await api.get(`/protected/project/${projectId}/tables`);
         return response.data.data;
+    },
+
+    deleteTable: async (projectId: number, tableId: number) => {
+        const response = await api.delete(`/protected/project/manage/table/drop/${projectId}/${tableId}`, {
+            data: {
+                project_id: projectId,
+                table_id: tableId
+            }
+        });
+        return response.data;
     }
 };