Merge branch 'develop' of github.com:IQSS/dataverse-client-javascript into 170-file-collection-results

Author: GPortas

docs/useCases.md

@@ -16,6 +16,7 @@ The different use cases currently available in the package are classified below,
     - [List All Collection Items](#list-all-collection-items)
   - [Collections write use cases](#collections-write-use-cases)
     - [Create a Collection](#create-a-collection)
+    - [Publish a Collection](#publish-a-collection)
 - [Datasets](#Datasets)
   - [Datasets read use cases](#datasets-read-use-cases)
     - [Get a Dataset](#get-a-dataset)
@@ -227,6 +228,28 @@ The above example creates the new collection in the `root` collection since no c
 
 The use case returns a number, which is the identifier of the created collection.
 
+#### Publish a Collection
+
+Publishes a Collection, given the collection identifier.
+
+##### Example call:
+
+```typescript
+import { publishCollection } from '@iqss/dataverse-client-javascript'
+
+/* ... */
+
+const collectionIdOrAlias = 12345
+
+publishCollection.execute(collectionIdOrAlias)
+
+/* ... */
+```
+
+The `collectionIdOrAlias` is a generic collection identifier, which can be either a string (for queries by CollectionAlias), or a number (for queries by CollectionId).
+
+_See [use case](../src/collections/domain/useCases/PublishCollection.ts)_ definition.
+
 ## Datasets
 
 ### Datasets Read Use Cases

src/collections/domain/repositories/ICollectionsRepository.ts

@@ -11,6 +11,7 @@ export interface ICollectionsRepository {
     collectionDTO: CollectionDTO,
     parentCollectionId: number | string
   ): Promise<number>
+  publishCollection(collectionIdOrAlias: number | string): Promise<void>
   getCollectionFacets(collectionIdOrAlias: number | string): Promise<CollectionFacet[]>
   getCollectionUserPermissions(
     collectionIdOrAlias: number | string

src/collections/domain/useCases/PublishCollection.ts

@@ -0,0 +1,20 @@
+import { UseCase } from '../../../core/domain/useCases/UseCase'
+import { ICollectionsRepository } from '../repositories/ICollectionsRepository' // Assuming Axios for HTTP requests
+
+export class PublishCollection implements UseCase<void> {
+  private collectionsRepository: ICollectionsRepository
+
+  constructor(collectionsRepository: ICollectionsRepository) {
+    this.collectionsRepository = collectionsRepository
+  }
+
+  /**
+   * Publishes a collection, given its identifier.
+   *
+   * @param {number | string} [collectionIdOrAlias] - The collection identifier, which can be a string (for collection alias), or a number (for numeric identifiers).
+   * @returns {Promise<void>} - This method does not return anything upon successful completion.
+   */
+  async execute(collectionIdOrAlias: number | string): Promise<void> {
+    return await this.collectionsRepository.publishCollection(collectionIdOrAlias)
+  }
+}

src/collections/index.ts

@@ -3,6 +3,7 @@ import { GetCollection } from './domain/useCases/GetCollection'
 import { GetCollectionFacets } from './domain/useCases/GetCollectionFacets'
 import { GetCollectionUserPermissions } from './domain/useCases/GetCollectionUserPermissions'
 import { GetCollectionItems } from './domain/useCases/GetCollectionItems'
+import { PublishCollection } from './domain/useCases/PublishCollection'
 
 import { CollectionsRepository } from './infra/repositories/CollectionsRepository'
 
@@ -13,13 +14,15 @@ const createCollection = new CreateCollection(collectionsRepository)
 const getCollectionFacets = new GetCollectionFacets(collectionsRepository)
 const getCollectionUserPermissions = new GetCollectionUserPermissions(collectionsRepository)
 const getCollectionItems = new GetCollectionItems(collectionsRepository)
+const publishCollection = new PublishCollection(collectionsRepository)
 
 export {
   getCollection,
   createCollection,
   getCollectionFacets,
   getCollectionUserPermissions,
-  getCollectionItems
+  getCollectionItems,
+  publishCollection
 }
 export { Collection, CollectionInputLevel } from './domain/models/Collection'
 export { CollectionFacet } from './domain/models/CollectionFacet'

src/collections/infra/repositories/CollectionsRepository.ts

@@ -118,6 +118,16 @@ export class CollectionsRepository extends ApiRepository implements ICollections
         throw error
       })
   }
+  public async publishCollection(collectionIdOrAlias: string | number): Promise<void> {
+    return this.doPost(
+      `/${this.collectionsResourceName}/${collectionIdOrAlias}/actions/:publish`,
+      {}
+    )
+      .then(() => undefined)
+      .catch((error) => {
+        throw error
+      })
+  }
 
   public async getCollectionUserPermissions(
     collectionIdOrAlias: number | string

src/files/infra/clients/DirectUploadClient.ts

@@ -19,9 +19,6 @@ export class DirectUploadClient implements IDirectUploadClient {
   private filesRepository: IFilesRepository
   private maxMultipartRetries: number
 
-  private readonly progressAfterUrlGeneration: number = 10
-  private readonly progressAfterFileUpload: number = 100
-
   private readonly fileUploadTimeoutMs: number = 60_000
 
   constructor(filesRepository: IFilesRepository, maxMultipartRetries = 5) {
@@ -43,14 +40,12 @@ export class DirectUploadClient implements IDirectUploadClient {
           throw new UrlGenerationError(file.name, datasetId, error.message)
         })
     }
-    progress(this.progressAfterUrlGeneration)
 
     if (destination.urls.length === 1) {
-      await this.uploadSinglepartFile(datasetId, file, destination, abortController)
+      await this.uploadSinglepartFile(datasetId, file, destination, progress, abortController)
     } else {
       await this.uploadMultipartFile(datasetId, file, destination, progress, abortController)
     }
-    progress(this.progressAfterFileUpload)
 
     return destination.storageId
   }
@@ -59,18 +54,20 @@ export class DirectUploadClient implements IDirectUploadClient {
     datasetId: number | string,
     file: File,
     destination: FileUploadDestination,
+    progress: (now: number) => void,
     abortController: AbortController
   ): Promise<void> {
     try {
       const arrayBuffer = await file.arrayBuffer()
       await axios.put(destination.urls[0], arrayBuffer, {
         headers: {
           'Content-Type': 'application/octet-stream',
-          'Content-Length': file.size.toString(),
           'x-amz-tagging': 'dv-state=temp'
         },
         timeout: this.fileUploadTimeoutMs,
-        signal: abortController.signal
+        signal: abortController.signal,
+        onUploadProgress: (progressEvent) =>
+          progress(Math.round((progressEvent.loaded * 100) / file.size))
       })
     } catch (error) {
       if (axios.isCancel(error)) {
@@ -92,8 +89,6 @@ export class DirectUploadClient implements IDirectUploadClient {
     const maxRetries = this.maxMultipartRetries
     const limitConcurrency = pLimit(1)
 
-    const progressPartSize = 80 / destination.urls.length
-
     const uploadPart = async (
       destinationUrl: string,
       index: number,
@@ -106,17 +101,17 @@ export class DirectUploadClient implements IDirectUploadClient {
       try {
         const response = await axios.put(destinationUrl, fileSlice, {
           headers: {
-            'Content-Type': 'application/octet-stream',
-            'Content-Length': fileSlice.size
+            'Content-Type': 'application/octet-stream'
           },
           maxBodyLength: Infinity,
           maxContentLength: Infinity,
           timeout: this.fileUploadTimeoutMs,
-          signal: abortController.signal
+          signal: abortController.signal,
+          onUploadProgress: (progressEvent) =>
+            progress(Math.round(((offset + progressEvent.loaded) * 100) / file.size))
         })
         const eTag = response.headers['etag'].replace(/"/g, '')
         eTags[`${index + 1}`] = eTag
-        progress(Math.round(this.progressAfterUrlGeneration + progressPartSize * (index + 1)))
       } catch (error) {
         if (axios.isCancel(error)) {
           await this.abortMultipartUpload(file.name, datasetId, destination.abortEndpoint)

test/functional/collections/PublishCollection.test.ts

@@ -0,0 +1,47 @@
+import { ApiConfig, createCollection, publishCollection, WriteError } from '../../../src'
+import { TestConstants } from '../../testHelpers/TestConstants'
+import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
+import {
+  createCollectionDTO,
+  deleteCollectionViaApi
+} from '../../testHelpers/collections/collectionHelper'
+
+const testNewCollection = createCollectionDTO('test-publish-collection')
+
+describe('execute', () => {
+  beforeEach(async () => {
+    ApiConfig.init(
+      TestConstants.TEST_API_URL,
+      DataverseApiAuthMechanism.API_KEY,
+      process.env.TEST_API_KEY
+    )
+  })
+
+  test('should successfully publish a collection with id', async () => {
+    const createdCollectiontIdentifier = await createCollection.execute(testNewCollection)
+
+    const response = await publishCollection.execute(createdCollectiontIdentifier)
+
+    expect(response).toBeUndefined()
+    await deleteCollectionViaApi(testNewCollection.alias)
+  })
+  test('should successfully publish a collection with alias', async () => {
+    await createCollection.execute(testNewCollection)
+
+    const response = await publishCollection.execute(testNewCollection.alias)
+
+    expect(response).toBeUndefined()
+    await deleteCollectionViaApi(testNewCollection.alias)
+  })
+
+  test('should throw an error when trying to publish a collection that does not exist', async () => {
+    const nonExistentTestCollectionId = 4567
+    const expectedError = new WriteError(
+      `[404] Can't find dataverse with identifier='${nonExistentTestCollectionId}'`
+    )
+
+    await expect(publishCollection.execute(nonExistentTestCollectionId)).rejects.toThrow(
+      expectedError
+    )
+  })
+})

test/integration/collections/CollectionsRepository.test.ts

@@ -107,6 +107,23 @@ describe('CollectionsRepository', () => {
     })
   })
 
+  describe('publishCollection', () => {
+    const testPublishCollectionAlias = 'publishCollection-test'
+
+    afterAll(async () => {
+      await deleteCollectionViaApi(testPublishCollectionAlias)
+    })
+
+    test('should publish a collection', async () => {
+      const newCollectionDTO = createCollectionDTO(testPublishCollectionAlias)
+      const actualId = await sut.createCollection(newCollectionDTO)
+      await sut.publishCollection(actualId)
+      const createdCollection = await sut.getCollection(actualId)
+
+      expect(createdCollection.isReleased).toBe(true)
+      expect(createdCollection.name).toBe(newCollectionDTO.name)
+    })
+  })
   describe('createCollection', () => {
     const testCreateCollectionAlias1 = 'createCollection-test-1'
     const testCreateCollectionAlias2 = 'createCollection-test-2'

test/integration/files/DirectUpload.test.ts

@@ -95,10 +95,6 @@ describe('Direct Upload', () => {
 
     expect(await singlepartFileExistsInBucket(singlepartFileUrl)).toBe(true)
 
-    expect(progressMock).toHaveBeenCalledWith(10)
-    expect(progressMock).toHaveBeenCalledWith(100)
-    expect(progressMock).toHaveBeenCalledTimes(2)
-
     // Test FilesRepository.addUploadedFileToDataset method
 
     let datasetFiles = await filesRepositorySut.getDatasetFiles(
@@ -156,12 +152,6 @@ describe('Direct Upload', () => {
     )
     expect(actualStorageId).toBe(destination.storageId)
 
-    expect(progressMock).toHaveBeenCalledWith(10)
-    expect(progressMock).toHaveBeenCalledWith(50)
-    expect(progressMock).toHaveBeenCalledWith(90)
-    expect(progressMock).toHaveBeenCalledWith(100)
-    expect(progressMock).toHaveBeenCalledTimes(4)
-
     // Test FilesRepository.addUploadedFileToDataset method
 
     let datasetFiles = await filesRepositorySut.getDatasetFiles(
@@ -221,10 +211,6 @@ describe('Direct Upload', () => {
         destination
       )
     ).rejects.toThrow(FileUploadCancelError)
-
-    expect(progressMock).not.toHaveBeenCalledWith(50)
-    expect(progressMock).not.toHaveBeenCalledWith(90)
-    expect(progressMock).not.toHaveBeenCalledWith(100)
   })
 
   const createTestFileUploadDestination = async (file: File, testDatasetId: number) => {

test/unit/collections/PublishCollection.test.ts

@@ -0,0 +1,23 @@
+import { ICollectionsRepository } from '../../../src/collections/domain/repositories/ICollectionsRepository'
+import { PublishCollection } from '../../../src/collections/domain/useCases/PublishCollection'
+import { WriteError } from '../../../src'
+
+describe('execute', () => {
+  test('should return undefined on repository success', async () => {
+    const collectionsRepositoryStub: ICollectionsRepository = {} as ICollectionsRepository
+    collectionsRepositoryStub.publishCollection = jest.fn().mockResolvedValue(undefined)
+    const sut = new PublishCollection(collectionsRepositoryStub)
+
+    const actual = await sut.execute(1)
+
+    expect(actual).toEqual(undefined)
+  })
+
+  test('should return error result on repository error', async () => {
+    const collectionsRepositoryStub: ICollectionsRepository = {} as ICollectionsRepository
+    collectionsRepositoryStub.publishCollection = jest.fn().mockRejectedValue(new WriteError())
+    const sut = new PublishCollection(collectionsRepositoryStub)
+
+    await expect(sut.execute(1)).rejects.toThrow(WriteError)
+  })
+})