quietlight/skraak.app - Change UCDTBEK3CF6YT2H6V57HI6FAFW44BIYYAK3Z2QJ5LJE7QWX7OEYAC

added the ability to edit and soft delete datasets

Created by AEj8dahVWy718uSSFPe9VSRJ5qX5G8pC2zvFzJJ8yzBd on May 24, 2025

UCDTBEK3CF6YT2H6V57HI6FAFW44BIYYAK3Z2QJ5LJE7QWX7OEYAC

Dependencies

In channels

main

Change contents

Insertion in src/worker/index.ts at line 1304 [3.240196]

[2.3511]

        details: error instanceof Error ? error.message : String(error),
      },
      500
    );
  }
});
/**
 * Protected API route to update an existing dataset
 * 
 * @route PUT /api/datasets/:id
 * @authentication Required
 * @param {string} id - Dataset ID in URL path
 * @body {Object} Dataset update payload:
 *   - name?: string (optional, max 255 chars)
 *   - description?: string (optional, max 255 chars)
 *   - public?: boolean (optional)
 *   - type?: string (optional)
 *   - active?: boolean (optional, for soft delete)
 * @returns {Object} Response containing:
 *   - data: The updated dataset object
 * @error 400 - If fields are invalid or dataset not found
 * @error 403 - If user doesn't own the dataset
 * @error 500 - If database operation fails
 * @description Updates an existing dataset owned by the authenticated user
 *   Only the dataset owner can modify it
 */
app.put("/api/datasets/:id", authenticate, async (c) => {
  try {
    // Get the JWT payload (user info)
    const jwtPayload = (c as unknown as { jwtPayload: JWTPayload }).jwtPayload;
    const userId = jwtPayload.sub; // User ID from JWT
    // Get dataset ID from URL parameters
    const datasetId = c.req.param("id");
    
    if (!datasetId) {
      return c.json({
        error: "Missing dataset ID in URL"
      }, 400);
    }
    // Parse request body
    const body = await c.req.json();
    const { name, description, public: isPublic, type, active } = body;
    // Connect to the database
    const sql = neon(c.env.DATABASE_URL);
    const db = drizzle(sql);
    // First, check if the dataset exists and if the user owns it
    const existingDataset = await db
      .select({
        id: dataset.id,
        owner: dataset.owner,
        active: dataset.active
      })
      .from(dataset)
      .where(eq(dataset.id, datasetId))
      .limit(1);
    if (existingDataset.length === 0) {
      return c.json({
        error: "Dataset not found"
      }, 404);
    }
    // Check ownership
    if (existingDataset[0].owner !== userId) {
      return c.json({
        error: "You don't have permission to modify this dataset"
      }, 403);
    }
    // Validate fields if provided
    if (name !== undefined) {
      if (typeof name !== 'string' || name.trim().length === 0) {
        return c.json({
          error: "Invalid field: name must be a non-empty string"
        }, 400);
      }
      
      if (name.length > 255) {
        return c.json({
          error: "Field 'name' must be 255 characters or less"
        }, 400);
      }
    }
    if (description !== undefined && description !== null && description.length > 255) {
      return c.json({
        error: "Field 'description' must be 255 characters or less"
      }, 400);
    }
    if (type !== undefined) {
      const validTypes = ['organise', 'test', 'train'];
      if (!validTypes.includes(type)) {
        return c.json({
          error: `Field 'type' must be one of: ${validTypes.join(', ')}`
        }, 400);
      }
    }
    // Build update object with only provided fields
    const updateData: Record<string, unknown> = {
      lastModified: new Date(),
      modifiedBy: userId,
    };
    if (name !== undefined) {
      updateData.name = name.trim();
    }
    
    if (description !== undefined) {
      updateData.description = description?.trim() || null;
    }
    
    if (isPublic !== undefined) {
      updateData.public = Boolean(isPublic);
    }
    
    if (type !== undefined) {
      updateData.type = type;
    }
    
    if (active !== undefined) {
      updateData.active = Boolean(active);
    }
    // Update the dataset
    const result = await db
      .update(dataset)
      .set(updateData)
      .where(eq(dataset.id, datasetId))
      .returning({
        id: dataset.id,
        name: dataset.name,
        description: dataset.description,
        public: dataset.public,
        type: dataset.type,
        createdAt: dataset.createdAt,
        lastModified: dataset.lastModified,
        owner: dataset.owner,
        active: dataset.active,
      });
    if (result.length === 0) {
      return c.json({
        error: "Failed to update dataset"
      }, 500);
    }
    console.log("Updated dataset:", result[0].id, "for user:", userId);
    return c.json({
      data: result[0]
    });
  } catch (error) {
    console.error("Error updating dataset:", error);
    
    return c.json(
      {
        error: "Failed to update dataset",

Replacement in src/components/Datasets.tsx at line 3 [4.3332]
B:BD[4.3445] → [2.3657:3697]
```
import { Plus, X } from "lucide-react";
```
[4.3445]
[2.3697]
```
import { Plus, X, Edit, Trash2 } from "lucide-react";
```

Replacement in src/components/Datasets.tsx at line 25 [4.3332]

B:BD[4.4134] → [2.3766:3979]

  const [showCreateForm, setShowCreateForm] = useState<boolean>(false);
  const [createLoading, setCreateLoading] = useState<boolean>(false);
  const [createError, setCreateError] = useState<string | null>(null);

[4.4134]

[2.3979]

  const [showForm, setShowForm] = useState<boolean>(false);
  const [formLoading, setFormLoading] = useState<boolean>(false);
  const [formError, setFormError] = useState<string | null>(null);
  const [editingDataset, setEditingDataset] = useState<Dataset | null>(null);
  const [isEditMode, setIsEditMode] = useState<boolean>(false);

Replacement in src/components/Datasets.tsx at line 79 [4.3332]

B:BD[2.4159] → [2.4159:4221]

  const handleCreateDataset = async (e: React.FormEvent) => {

[2.4159]

[2.4221]

  const handleSubmitDataset = async (e: React.FormEvent) => {

Replacement in src/components/Datasets.tsx at line 84 [4.3332]

B:BD[2.4289] → [2.4289:4343]

    setCreateLoading(true);
    setCreateError(null);

[2.4289]

[2.4343]

    setFormLoading(true);
    setFormError(null);

Deletion in src/components/Datasets.tsx at line 89 [4.3332]
B:BD[2.4408] → [2.4408:4437]
```
      const id = nanoid(12);
```

Replacement in src/components/Datasets.tsx at line 90 [4.3332]

B:BD[2.4444] → [2.4444:4872]

      const response = await fetch("/api/datasets", {
        method: "POST",
        headers: {
          "Authorization": `Bearer ${accessToken}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          id,
          name: formData.name,
          description: formData.description || undefined,
          type: formData.type,
          public: formData.public,
        }),
      });

[2.4444]

[2.4872]

      if (isEditMode && editingDataset) {
        // Update existing dataset
        const response = await fetch(`/api/datasets/${editingDataset.id}`, {
          method: "PUT",
          headers: {
            "Authorization": `Bearer ${accessToken}`,
            "Content-Type": "application/json",
          },
          body: JSON.stringify({
            name: formData.name,
            description: formData.description || undefined,
            type: formData.type,
            public: formData.public,
          }),
        });
        if (!response.ok) {
          const errorData = await response.json();
          throw new Error(errorData.error || `HTTP error! Status: ${response.status}`);
        }
        const { data: updatedDataset } = await response.json();
        
        // Update the dataset in the list
        setDatasets(prev => prev.map(dataset => 
          dataset.id === updatedDataset.id ? updatedDataset : dataset
        ));
      } else {
        // Create new dataset
        const id = nanoid(12);
        
        const response = await fetch("/api/datasets", {
          method: "POST",
          headers: {
            "Authorization": `Bearer ${accessToken}`,
            "Content-Type": "application/json",
          },
          body: JSON.stringify({
            id,
            name: formData.name,
            description: formData.description || undefined,
            type: formData.type,
            public: formData.public,
          }),
        });
        if (!response.ok) {
          const errorData = await response.json();
          throw new Error(errorData.error || `HTTP error! Status: ${response.status}`);
        }

Replacement in src/components/Datasets.tsx at line 141 [4.3332]

B:BD[2.4873] → [2.4873:5034]

      if (!response.ok) {
        const errorData = await response.json();
        throw new Error(errorData.error || `HTTP error! Status: ${response.status}`);

[2.4873]

[2.5034]

        const { data: newDataset } = await response.json();
        
        // Add the new dataset to the list
        setDatasets(prev => [newDataset, ...prev]);

Deletion in src/components/Datasets.tsx at line 146 [4.3332]

B:BD[2.5042] → [2.5042:5199]


      const { data: newDataset } = await response.json();
      
      // Add the new dataset to the list
      setDatasets(prev => [newDataset, ...prev]);

Replacement in src/components/Datasets.tsx at line 148 [4.3332]

B:BD[2.5242] → [2.5242:5395]

      setFormData({
        name: '',
        description: '',
        type: 'organise',
        public: false
      });
      setShowCreateForm(false);

[2.5242]

[2.5395]

      handleCancelForm();

Replacement in src/components/Datasets.tsx at line 151 [4.3332]

B:BD[2.5422] → [2.5422:5562]

      setCreateError(err instanceof Error ? err.message : "Failed to create dataset");
      console.error("Error creating dataset:", err);

[2.5422]

[2.5562]

      setFormError(err instanceof Error ? err.message : `Failed to ${isEditMode ? 'update' : 'create'} dataset`);
      console.error(`Error ${isEditMode ? 'updating' : 'creating'} dataset:`, err);

Replacement in src/components/Datasets.tsx at line 154 [4.3332]
B:BD[2.5578] → [2.5578:5609]
```
      setCreateLoading(false);
```
[2.5578]
[2.5609]
```
      setFormLoading(false);
```

Replacement in src/components/Datasets.tsx at line 165 [4.3332]

B:BD[2.5787] → [2.5787:5880]

  const handleCancelCreate = () => {
    setShowCreateForm(false);
    setCreateError(null);

[2.5787]

[2.5880]

  const handleCancelForm = () => {
    setShowForm(false);
    setFormError(null);
    setIsEditMode(false);
    setEditingDataset(null);
    setFormData({
      name: '',
      description: '',
      type: 'organise',
      public: false
    });
  };
  const handleCreateNew = () => {
    setIsEditMode(false);
    setEditingDataset(null);

Insertion in src/components/Datasets.tsx at line 187 [4.3332]
[2.5989]
[2.5989]
```
    setShowForm(true);
```

Insertion in src/components/Datasets.tsx at line 189 [4.3332]

[2.5994]

[5.7994]


  const handleEditDataset = (dataset: Dataset) => {
    setIsEditMode(true);
    setEditingDataset(dataset);
    setFormData({
      name: dataset.name,
      description: dataset.description || '',
      type: dataset.type as 'organise' | 'test' | 'train',
      public: dataset.public
    });
    setShowForm(true);
  };
  const handleDeleteDataset = async (dataset: Dataset) => {
    if (!isAuthenticated) return;
    
    const confirmDelete = window.confirm(`Are you sure you want to delete "${dataset.name}"? This action cannot be undone.`);
    if (!confirmDelete) return;
    
    try {
      const accessToken = await getAccessToken();
      
      const response = await fetch(`/api/datasets/${dataset.id}`, {
        method: "PUT",
        headers: {
          "Authorization": `Bearer ${accessToken}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          active: false
        }),
      });
      if (!response.ok) {
        const errorData = await response.json();
        throw new Error(errorData.error || `HTTP error! Status: ${response.status}`);
      }
      // Remove the dataset from the list (soft delete)
      setDatasets(prev => prev.filter(d => d.id !== dataset.id));
      
    } catch (err) {
      setError(err instanceof Error ? err.message : "Failed to delete dataset");
      console.error("Error deleting dataset:", err);
    }
  };

Replacement in src/components/Datasets.tsx at line 243 [4.3332]

B:BD[2.6221] → [2.6221:6273]

            onClick={() => setShowCreateForm(true)}

[2.6221]

[2.6273]

            onClick={handleCreateNew}

Insertion in src/components/Datasets.tsx at line 267 [4.3332]

[4.6071]

                <TableHead className="w-[120px] py-3 font-bold text-sm uppercase text-center">Actions</TableHead>

Replacement in src/components/Datasets.tsx at line 274 [4.3332]

B:BD[5.8077] → [5.8077:8141]

B:BD[5.8141] → [6.7559:7635]

                  className="cursor-pointer hover:bg-primary/5"
                  onClick={() => onDatasetSelect(dataset.id, dataset.name)}

[5.8077]

[5.8203]

                  className="hover:bg-primary/5"

Replacement in src/components/Datasets.tsx at line 276 [4.3332]

∅:D[5.8221] → [4.6235:6399]

B:BD[4.6235] → [4.6235:6399]

                  <TableCell className="font-medium whitespace-normal break-words">{dataset.name}</TableCell>
                  <TableCell className="text-center">

[5.8221]

[4.6399]

                  <TableCell 
                    className="font-medium whitespace-normal break-words cursor-pointer"
                    onClick={() => onDatasetSelect(dataset.id, dataset.name)}
                  >
                    {dataset.name}
                  </TableCell>
                  <TableCell 
                    className="text-center cursor-pointer"
                    onClick={() => onDatasetSelect(dataset.id, dataset.name)}
                  >

Insertion in src/components/Datasets.tsx at line 293 [4.3332]

[4.6805]

                  </TableCell>
                  <TableCell 
                    className="whitespace-normal break-words cursor-pointer"
                    onClick={() => onDatasetSelect(dataset.id, dataset.name)}
                  >
                    {dataset.description || "—"}

Replacement in src/components/Datasets.tsx at line 300 [4.3332]

B:BD[4.6836] → [4.6836:6950]

                  <TableCell className="whitespace-normal break-words">{dataset.description || "—"}</TableCell>

[4.6836]

[4.6950]

                  <TableCell className="text-center">
                    <div className="flex justify-center gap-2">
                      <Button
                        onClick={(e) => {
                          e.stopPropagation();
                          handleEditDataset(dataset);
                        }}
                        variant="ghost"
                        size="sm"
                        className="p-1 h-8 w-8"
                        title="Edit dataset"
                      >
                        <Edit className="h-4 w-4" />
                      </Button>
                      <Button
                        onClick={(e) => {
                          e.stopPropagation();
                          handleDeleteDataset(dataset);
                        }}
                        variant="ghost"
                        size="sm"
                        className="p-1 h-8 w-8 text-red-600 hover:text-red-700 hover:bg-red-50"
                        title="Delete dataset"
                      >
                        <Trash2 className="h-4 w-4" />
                      </Button>
                    </div>
                  </TableCell>

Replacement in src/components/Datasets.tsx at line 339 [4.3332]

B:BD[2.6496] → [2.6496:6558]

      {/* Create Dataset Modal */}
      {showCreateForm && (

[2.6496]

[2.6558]

      {/* Create/Edit Dataset Modal */}
      {showForm && (

Replacement in src/components/Datasets.tsx at line 344 [4.3332]

B:BD[2.6801] → [2.6801:6877]

              <h3 className="text-lg font-semibold">Create New Dataset</h3>

[2.6801]

[2.6877]

              <h3 className="text-lg font-semibold">
                {isEditMode ? 'Edit Dataset' : 'Create New Dataset'}
              </h3>

Replacement in src/components/Datasets.tsx at line 348 [4.3332]

B:BD[2.6899] → [2.6899:6944]

                onClick={handleCancelCreate}

[2.6899]

[2.6944]

                onClick={handleCancelForm}

Replacement in src/components/Datasets.tsx at line 357 [4.3332]
B:BD[2.7136] → [2.7136:7166]
```
            {createError && (
```
[2.7136]
[2.7166]
```
            {formError && (
```
Replacement in src/components/Datasets.tsx at line 359 [4.3332]
B:BD[2.7266] → [2.7266:7296]
```
                {createError}
```
[2.7266]
[2.7296]
```
                {formError}
```

Replacement in src/components/Datasets.tsx at line 363 [4.3332]

B:BD[2.7333] → [2.7333:7405]

            <form onSubmit={handleCreateDataset} className="space-y-4">

[2.7333]

[2.7405]

            <form onSubmit={handleSubmitDataset} className="space-y-4">

Replacement in src/components/Datasets.tsx at line 427 [4.3332]

B:BD[2.10143] → [2.10143:10190]

                  onClick={handleCancelCreate}

[2.10143]

[2.10190]

                  onClick={handleCancelForm}

Replacement in src/components/Datasets.tsx at line 429 [4.3332]

B:BD[2.10226] → [2.10226:10269]

                  disabled={createLoading}

[2.10226]

[2.10269]

                  disabled={formLoading}

Replacement in src/components/Datasets.tsx at line 435 [4.3332]

B:BD[2.10394] → [2.10394:10462]

                  disabled={createLoading || !formData.name.trim()}

[2.10394]

[2.10462]

                  disabled={formLoading || !formData.name.trim()}

Replacement in src/components/Datasets.tsx at line 437 [4.3332]

B:BD[2.10480] → [2.10480:10549]

                  {createLoading ? "Creating..." : "Create Dataset"}

[2.10480]

[2.10549]

                  {formLoading 
                    ? (isEditMode ? "Updating..." : "Creating...") 
                    : (isEditMode ? "Update Dataset" : "Create Dataset")
                  }