Merge branch 'main' into releases/1.1.0

Author: jhoward1994

README.md

@@ -210,6 +210,7 @@ The `files` property provides access to the Strapi Media Library through the Upl
 - `find(params?: FileQueryParams): Promise<FileListResponse>` - Retrieves a list of file metadata based on optional query parameters
 - `findOne(fileId: number): Promise<FileResponse>` - Retrieves the metadata for a single file by its ID
 - `update(fileId: number, fileInfo: FileUpdateData): Promise<FileResponse>` - Updates metadata for an existing file
+- `delete(fileId: number): Promise<void>` - Deletes a file by its ID
 
 #### Example: Finding Files
 
@@ -271,6 +272,23 @@ console.log(updatedFile.name); // Updated file name
 console.log(updatedFile.alternativeText); // Updated alt text
 ```
 
+#### Example: Deleting a File
+
+```typescript
+// Initialize the client
+const client = strapi({
+  baseURL: 'http://localhost:1337/api',
+  auth: 'your-api-token',
+});
+
+// Delete a file by ID
+const deletedFile = await client.files.delete(1);
+
+console.log('File deleted successfully');
+console.log('Deleted file ID:', deletedFile.id);
+console.log('Deleted file name:', deletedFile.name);
+```
+
 ## 🐛 Debug
 
 This section provides guidance on enabling and managing debug logs for the SDK,

demo/node-javascript/src/index.js

@@ -144,6 +144,52 @@ async function main() {
       'Tech category not found. Make sure you have a category with slug "tech" in your Strapi instance.'
     );
   }
+
+  console.log(os.EOL);
+  console.log('=== File Deletion Operations ===');
+  console.log(os.EOL);
+
+  const getFileThatCanBeDeleted = async () => {
+    try {
+      const files = await client.files.find();
+      if (files && files.length > 0) {
+        const fileToDelete = files[0];
+        console.log(`Found file to delete: ${fileToDelete.name} (ID: ${fileToDelete.id})`);
+        return fileToDelete.id;
+      }
+      return null;
+    } catch (error) {
+      console.error('Error finding files:', error);
+      return null;
+    }
+  };
+
+  const PERFORM_ACTUAL_DELETE = false;
+  const fileIdToDelete = await getFileThatCanBeDeleted();
+
+  if (fileIdToDelete && PERFORM_ACTUAL_DELETE) {
+    console.log(os.EOL);
+    console.log(`Attempting to delete file with ID: ${fileIdToDelete}`);
+
+    try {
+      const deletedFile = await client.files.delete(fileIdToDelete);
+      console.log('Deleted file metadata:', deletedFile);
+
+      console.log(os.EOL);
+      console.log(`Attempting to find deleted file with ID: ${fileIdToDelete}`);
+      try {
+        const file = await client.files.findOne(fileIdToDelete);
+        console.error('Unexpected result: File still exists:', file);
+      } catch (error) {
+        console.log('Expected error: File no longer exists');
+        console.log(`Error message: ${error.message}`);
+      }
+    } catch (error) {
+      console.error('Error during file deletion demonstration:', error);
+    }
+  } else {
+    console.log('No files available for deletion demonstration.');
+  }
 }
 
 main().catch(console.error);

demo/node-typescript/src/index.ts

@@ -76,6 +76,7 @@ async function runDemo() {
   await demonstrateCategoryImageInteractions();
   await demonstrateDirectFileOperations();
   await demonstrateFileUpdates();
+  await demonstrateFileDeletion();
 }
 
 async function demonstrateBasicCategoryFunctionality() {
@@ -222,6 +223,58 @@ async function demonstrateFileUpdates() {
   }
 }
 
+const PERFORM_ACTUAL_DELETE = false;
+async function demonstrateFileDeletion() {
+  if (!PERFORM_ACTUAL_DELETE) {
+    return;
+  }
+
+  console.log(os.EOL);
+  console.log('=== File Deletion Operations ===');
+  console.log(os.EOL);
+
+  const getFileThatCanBeDeleted = async (): Promise<number | null> => {
+    try {
+      const files = await client.files.find();
+      if (files && files.length > 0) {
+        const fileToDelete = files[0];
+        console.log(`Found file to delete: ${fileToDelete.name} (ID: ${fileToDelete.id})`);
+        return fileToDelete.id;
+      }
+      return null;
+    } catch (error) {
+      console.error('Error finding files:', error);
+      return null;
+    }
+  };
+
+  const fileIdToDelete = await getFileThatCanBeDeleted();
+
+  if (fileIdToDelete) {
+    console.log(os.EOL);
+    console.log(`Attempting to delete file with ID: ${fileIdToDelete}`);
+
+    try {
+      const deletedFile = await client.files.delete(fileIdToDelete);
+      console.log('Deleted file metadata:', deletedFile);
+
+      console.log(os.EOL);
+      console.log(`Attempting to find deleted file with ID: ${fileIdToDelete}`);
+      try {
+        const file = await client.files.findOne(fileIdToDelete);
+        console.error('Unexpected result: File still exists:', file);
+      } catch (error) {
+        console.log('Expected error: File no longer exists');
+        console.log(`Error message: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    } catch (error) {
+      console.error('Error during file deletion demonstration:', error);
+    }
+  } else {
+    console.log('No files available for deletion demonstration.');
+  }
+}
+
 // Helper function to format file sizes
 function formatFileSize(bytes: number): string {
   if (bytes < 1024) return `${bytes} B`;

src/files/manager.ts

@@ -192,4 +192,41 @@ export class FilesManager {
       throw error;
     }
   }
+
+  /**
+   * Deletes a file by its ID.
+   *
+   * @param fileId - The numeric identifier of the file to delete.
+   * @returns A promise that resolves to the deleted file object.
+   *
+   * @throws {FileNotFoundError} if the file with the specified ID does not exist.
+   * @throws {FileForbiddenError} if the user does not have permission to delete the file.
+   * @throws {HTTPError} if the HTTP client encounters connection issues, the server is unreachable, or authentication fails.
+   *
+   * @example
+   * ```typescript
+   * const filesManager = new FilesManager(httpClient);
+   *
+   * await filesManager.delete(1);
+   * console.log('File deleted successfully');
+   * ```
+   */
+  async delete(fileId: number): Promise<FileResponse> {
+    debug('deleting file with ID %o', fileId);
+
+    try {
+      const url = `${FILE_API_PREFIX}/files/${fileId}`;
+      const client = this.createFileHttpClient(fileId);
+
+      const response = await client.delete(url);
+      const json = await response.json();
+
+      debug('successfully deleted file with ID %o', fileId);
+
+      return json;
+    } catch (error) {
+      debug('error deleting file with ID %o: %o', fileId, error);
+      throw error;
+    }
+  }
 }

tests/unit/files/files-client-integration.test.ts

@@ -218,4 +218,75 @@ describe('Strapi Client - Files Integration', () => {
       }
     });
   });
+
+  describe('files.delete integration', () => {
+    it('should correctly call the delete endpoint', async () => {
+      // Arrange
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: jest.fn().mockResolvedValueOnce({ id: 1, name: 'deleted-file.jpg' }),
+      });
+
+      // Act
+      const result = await strapi.files.delete(1);
+
+      // Assert
+      const requestArg = mockFetch.mock.calls[0][0];
+      expect(requestArg.url).toBe('http://example.com/api/upload/files/1');
+      expect(requestArg.method).toBe('DELETE');
+      expect(result).toEqual({ id: 1, name: 'deleted-file.jpg' });
+    });
+
+    it('should pass authentication headers when deleting a file', async () => {
+      // Arrange
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: jest.fn().mockResolvedValueOnce({ id: 1, name: 'deleted-file.jpg' }),
+      });
+
+      // Create an authenticated Strapi client
+      const authenticatedStrapi = new Strapi({
+        baseURL: 'http://example.com/api',
+        auth: {
+          strategy: 'api-token',
+          options: { token: 'test_token' },
+        },
+      });
+
+      // Act
+      await authenticatedStrapi.files.delete(1);
+
+      // Assert
+      const requestArg = mockFetch.mock.calls[0][0];
+      expect(requestArg.url).toBe('http://example.com/api/upload/files/1');
+      expect(requestArg.method).toBe('DELETE');
+      expect(requestArg.headers.get('Authorization')).toBe('Bearer test_token');
+    });
+
+    it('should handle file not found errors when deleting', async () => {
+      // Arrange
+      const fileId = 999;
+      const mockRequest = new Request(`http://example.com/api/upload/files/${fileId}`);
+      const mockResponse = new Response('Not Found', { status: 404, statusText: 'Not Found' });
+
+      // Create a not found error that will be thrown by HttpClient
+      const httpNotFoundError = new HTTPNotFoundError(mockResponse, mockRequest);
+      mockFetch.mockRejectedValueOnce(httpNotFoundError);
+
+      // Act & Assert
+      try {
+        await strapi.files.delete(fileId);
+        fail('Expected error was not thrown');
+      } catch (error) {
+        // The error should be mapped to a FileNotFoundError
+        expect(error).toBeInstanceOf(FileNotFoundError);
+        if (error instanceof FileNotFoundError) {
+          expect(error.fileId).toBe(fileId);
+          expect(error.message).toContain(`File with ID ${fileId} not found`);
+        }
+      }
+    });
+  });
 });

tests/unit/files/files-manager.test.ts

@@ -630,4 +630,103 @@ describe('FilesManager', () => {
       expect(createSpy).toHaveBeenCalledWith(1);
     });
   });
+
+  describe('delete', () => {
+    it('should successfully delete a file by ID', async () => {
+      // Arrange
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: jest.fn().mockResolvedValueOnce({ id: 1, name: 'deleted-file.jpg' }),
+      });
+
+      // Act
+      const result = await filesManager.delete(1);
+
+      // Assert
+      expect(mockFetch).toHaveBeenCalledTimes(1);
+      const requestArg = mockFetch.mock.calls[0][0];
+
+      // Check that the URL and method are correct
+      expect(requestArg.url).toBe('http://example.com/api/upload/files/1');
+      expect(requestArg.method).toBe('DELETE');
+
+      // Check the returned result
+      expect(result).toEqual({ id: 1, name: 'deleted-file.jpg' });
+    });
+
+    it('should throw FileNotFoundError when deleting a non-existent file', async () => {
+      // Arrange
+      const fileId = 999;
+      const mockRequest = new Request(`http://example.com/api/upload/files/${fileId}`);
+      const mockResponse = new Response('Not Found', { status: 404, statusText: 'Not Found' });
+
+      // Create an HTTPNotFoundError that would be thrown by the HttpClient
+      const httpNotFoundError = new HTTPNotFoundError(mockResponse, mockRequest);
+      mockFetch.mockRejectedValueOnce(httpNotFoundError);
+
+      // Act & Assert
+      try {
+        await filesManager.delete(fileId);
+        fail('Expected an error to be thrown');
+      } catch (error) {
+        // Check that the error is properly mapped to a FileNotFoundError
+        expect(error).toBeInstanceOf(FileNotFoundError);
+        if (error instanceof FileNotFoundError) {
+          // Verify the error contains the file ID and a relevant message
+          expect(error.fileId).toBe(fileId);
+          expect(error.message).toContain(`File with ID ${fileId} not found`);
+          // Verify the original request and response are preserved
+          expect(error.request).toBe(mockRequest);
+          expect(error.response).toBe(mockResponse);
+        }
+      }
+    });
+
+    it('should throw FileForbiddenError when user does not have permission', async () => {
+      // Arrange
+      const fileId = 1;
+      const mockRequest = new Request(`http://example.com/api/upload/files/${fileId}`);
+      const mockResponse = new Response('Forbidden', { status: 403, statusText: 'Forbidden' });
+
+      // Create an HTTPForbiddenError that would be thrown by the HttpClient
+      const httpForbiddenError = new HTTPForbiddenError(mockResponse, mockRequest);
+      mockFetch.mockRejectedValueOnce(httpForbiddenError);
+
+      // Act & Assert
+      try {
+        await filesManager.delete(fileId);
+        fail('Expected an error to be thrown');
+      } catch (error) {
+        // Check that the error is properly mapped to a FileForbiddenError
+        expect(error).toBeInstanceOf(FileForbiddenError);
+        if (error instanceof FileForbiddenError) {
+          // Verify the error contains the file ID and a relevant message
+          expect(error.fileId).toBe(fileId);
+          expect(error.message).toContain(`Access to file with ID ${fileId} is forbidden`);
+          // Verify the original request and response are preserved
+          expect(error.request).toBe(mockRequest);
+          expect(error.response).toBe(mockResponse);
+        }
+      }
+    });
+
+    it('should pass fileId to createFileHttpClient', async () => {
+      // Arrange
+      // Create spy on the private method using any
+      const createSpy = jest.spyOn(filesManager as any, 'createFileHttpClient');
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: jest.fn().mockResolvedValueOnce({ id: 1, name: 'deleted-file.jpg' }),
+      });
+
+      // Act
+      await filesManager.delete(1);
+
+      // Assert
+      expect(createSpy).toHaveBeenCalledWith(1);
+    });
+  });
 });