@maas/payload-plugin-media-cloud 0.0.0

package/dist/tus/stores/s3/metadata-manager.d.ts

@@ -0,0 +1,85 @@
+import { TusUploadMetadata } from "../../../types/index.js";
+import { S3 } from "@aws-sdk/client-s3";
+import { KvStore, Upload } from "@tus/utils";
+
+//#region src/tus/stores/s3/metadata-manager.d.ts
+type GenerateInfoKeyArgs = {
+  id: string;
+};
+type GeneratePartKeyArgs = {
+  id: string;
+  isIncomplete?: boolean;
+};
+type GetMetadataArgs = {
+  id: string;
+};
+type SaveMetadataArgs = {
+  upload: Upload;
+  uploadId: string;
+};
+type CompleteMetadataArgs = {
+  upload: Upload;
+};
+type ClearCacheArgs = {
+  id: string;
+};
+declare class S3MetadataManager {
+  private client;
+  private bucket;
+  private cache;
+  private shouldUseExpirationTags;
+  private generateCompleteTag;
+  constructor(client: S3, bucket: string, cache: KvStore<TusUploadMetadata>, shouldUseExpirationTags: () => boolean, generateCompleteTag: (value: 'false' | 'true') => string | undefined);
+  /**
+   * Generates the S3 key for metadata info files
+   * @param args - The function arguments
+   * @param args.id - The file ID
+   * @returns The S3 key for the metadata file
+   */
+  generateInfoKey(args: GenerateInfoKeyArgs): string;
+  /**
+   * Generates the S3 key for part files
+   * @param args - The function arguments
+   * @param args.id - The file ID
+   * @param args.isIncomplete - Whether this is an incomplete part
+   * @returns The S3 key for the part file
+   */
+  generatePartKey(args: GeneratePartKeyArgs): string;
+  /**
+   * Retrieves upload metadata previously saved in `${file_id}.info`.
+   * There's a small and simple caching mechanism to avoid multiple
+   * HTTP calls to S3.
+   * @param args - The function arguments
+   * @param args.id - The file ID to retrieve metadata for
+   * @returns Promise that resolves to the upload metadata
+   */
+  getMetadata(args: GetMetadataArgs): Promise<TusUploadMetadata>;
+  /**
+   * Saves upload metadata to a `${file_id}.info` file on S3.
+   * Please note that the file is empty and the metadata is saved
+   * on the S3 object's `Metadata` field, so that only a `headObject`
+   * is necessary to retrieve the data.
+   * @param args - The function arguments
+   * @param args.upload - The upload object containing metadata
+   * @param args.uploadId - The upload ID for the multipart upload
+   * @returns Promise that resolves when metadata is saved
+   */
+  saveMetadata(args: SaveMetadataArgs): Promise<void>;
+  /**
+   * Completes metadata by updating it with completion tags
+   * @param args - The function arguments
+   * @param args.upload - The completed upload object
+   * @returns Promise that resolves when metadata is updated
+   */
+  completeMetadata(args: CompleteMetadataArgs): Promise<void>;
+  /**
+   * Removes cached data for a given file
+   * @param args - The function arguments
+   * @param args.id - The file ID to remove from cache
+   * @returns Promise that resolves when cache is cleared
+   */
+  clearCache(args: ClearCacheArgs): Promise<void>;
+}
+//#endregion
+export { S3MetadataManager };
+//# sourceMappingURL=metadata-manager.d.ts.map

package/dist/tus/stores/s3/metadata-manager.js

@@ -0,0 +1,135 @@
+import { log } from "./log.js";
+import { TUS_RESUMABLE, Upload } from "@tus/utils";
+
+//#region src/tus/stores/s3/metadata-manager.ts
+var S3MetadataManager = class {
+	constructor(client, bucket, cache, shouldUseExpirationTags, generateCompleteTag) {
+		this.client = client;
+		this.bucket = bucket;
+		this.cache = cache;
+		this.shouldUseExpirationTags = shouldUseExpirationTags;
+		this.generateCompleteTag = generateCompleteTag;
+	}
+	/**
+	* Generates the S3 key for metadata info files
+	* @param args - The function arguments
+	* @param args.id - The file ID
+	* @returns The S3 key for the metadata file
+	*/
+	generateInfoKey(args) {
+		const { id } = args;
+		return `${id}.info`;
+	}
+	/**
+	* Generates the S3 key for part files
+	* @param args - The function arguments
+	* @param args.id - The file ID
+	* @param args.isIncomplete - Whether this is an incomplete part
+	* @returns The S3 key for the part file
+	*/
+	generatePartKey(args) {
+		const { id, isIncomplete = false } = args;
+		let key = id;
+		if (isIncomplete) key += ".part";
+		return key;
+	}
+	/**
+	* Retrieves upload metadata previously saved in `${file_id}.info`.
+	* There's a small and simple caching mechanism to avoid multiple
+	* HTTP calls to S3.
+	* @param args - The function arguments
+	* @param args.id - The file ID to retrieve metadata for
+	* @returns Promise that resolves to the upload metadata
+	*/
+	async getMetadata(args) {
+		const { id } = args;
+		const cached = await this.cache.get(id);
+		if (cached) return cached;
+		const { Body, Metadata } = await this.client.getObject({
+			Bucket: this.bucket,
+			Key: this.generateInfoKey({ id })
+		});
+		const file = JSON.parse(await Body?.transformToString());
+		const metadata = {
+			file: new Upload({
+				id,
+				creation_date: file.creation_date,
+				metadata: file.metadata,
+				offset: Number.parseInt(file.offset, 10),
+				size: Number.isFinite(file.size) ? Number.parseInt(file.size, 10) : void 0,
+				storage: file.storage
+			}),
+			"tus-version": Metadata?.["tus-version"],
+			"upload-id": Metadata?.["upload-id"]
+		};
+		await this.cache.set(id, metadata);
+		return metadata;
+	}
+	/**
+	* Saves upload metadata to a `${file_id}.info` file on S3.
+	* Please note that the file is empty and the metadata is saved
+	* on the S3 object's `Metadata` field, so that only a `headObject`
+	* is necessary to retrieve the data.
+	* @param args - The function arguments
+	* @param args.upload - The upload object containing metadata
+	* @param args.uploadId - The upload ID for the multipart upload
+	* @returns Promise that resolves when metadata is saved
+	*/
+	async saveMetadata(args) {
+		const { upload, uploadId } = args;
+		log(`[${upload.id}] saving metadata`);
+		await this.client.putObject({
+			Body: JSON.stringify(upload),
+			Bucket: this.bucket,
+			Key: this.generateInfoKey({ id: upload.id }),
+			Metadata: {
+				"tus-version": TUS_RESUMABLE,
+				"upload-id": uploadId
+			},
+			Tagging: this.generateCompleteTag("false")
+		});
+		log(`[${upload.id}] metadata file saved`);
+	}
+	/**
+	* Completes metadata by updating it with completion tags
+	* @param args - The function arguments
+	* @param args.upload - The completed upload object
+	* @returns Promise that resolves when metadata is updated
+	*/
+	async completeMetadata(args) {
+		const { upload } = args;
+		const metadata = await this.getMetadata({ id: upload.id });
+		const completedMetadata = {
+			...metadata,
+			file: upload
+		};
+		await this.cache.set(upload.id, completedMetadata);
+		if (!this.shouldUseExpirationTags()) return;
+		const { "upload-id": uploadId } = metadata;
+		await this.client.putObject({
+			Body: JSON.stringify(upload),
+			Bucket: this.bucket,
+			Key: this.generateInfoKey({ id: upload.id }),
+			Metadata: {
+				"tus-version": TUS_RESUMABLE,
+				"upload-id": uploadId
+			},
+			Tagging: this.generateCompleteTag("true")
+		});
+	}
+	/**
+	* Removes cached data for a given file
+	* @param args - The function arguments
+	* @param args.id - The file ID to remove from cache
+	* @returns Promise that resolves when cache is cleared
+	*/
+	async clearCache(args) {
+		const { id } = args;
+		log(`[${id}] removing cached data`);
+		await this.cache.delete(id);
+	}
+};
+
+//#endregion
+export { S3MetadataManager };
+//# sourceMappingURL=metadata-manager.js.map

package/dist/tus/stores/s3/metadata-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata-manager.js","names":["client: S3","bucket: string","cache: KvStore<TusUploadMetadata>","shouldUseExpirationTags: () => boolean","generateCompleteTag: (value: 'false' | 'true') => string | undefined","args: GenerateInfoKeyArgs","args: GeneratePartKeyArgs","args: GetMetadataArgs","metadata: TusUploadMetadata","args: SaveMetadataArgs","args: CompleteMetadataArgs","completedMetadata: TusUploadMetadata","args: ClearCacheArgs"],"sources":["../../../../src/tus/stores/s3/metadata-manager.ts"],"sourcesContent":["import { TUS_RESUMABLE, Upload } from '@tus/utils'\nimport { log } from './log'\n\nimport type { S3 } from '@aws-sdk/client-s3'\nimport type { KvStore } from '@tus/utils'\nimport type { TusUploadMetadata } from '../../../types'\n\ntype GenerateInfoKeyArgs = {\n  id: string\n}\n\ntype GeneratePartKeyArgs = {\n  id: string\n  isIncomplete?: boolean\n}\n\ntype GetMetadataArgs = {\n  id: string\n}\n\ntype SaveMetadataArgs = {\n  upload: Upload\n  uploadId: string\n}\n\ntype CompleteMetadataArgs = {\n  upload: Upload\n}\n\ntype ClearCacheArgs = {\n  id: string\n}\n\nexport class S3MetadataManager {\n  constructor(\n    private client: S3,\n    private bucket: string,\n    private cache: KvStore<TusUploadMetadata>,\n    private shouldUseExpirationTags: () => boolean,\n    private generateCompleteTag: (value: 'false' | 'true') => string | undefined\n  ) {}\n\n  /**\n   * Generates the S3 key for metadata info files\n   * @param args - The function arguments\n   * @param args.id - The file ID\n   * @returns The S3 key for the metadata file\n   */\n  generateInfoKey(args: GenerateInfoKeyArgs): string {\n    const { id } = args\n    return `${id}.info`\n  }\n\n  /**\n   * Generates the S3 key for part files\n   * @param args - The function arguments\n   * @param args.id - The file ID\n   * @param args.isIncomplete - Whether this is an incomplete part\n   * @returns The S3 key for the part file\n   */\n  generatePartKey(args: GeneratePartKeyArgs): string {\n    const { id, isIncomplete = false } = args\n    let key = id\n    if (isIncomplete) {\n      key += '.part'\n    }\n\n    // TODO: introduce ObjectPrefixing for parts and incomplete parts.\n    // ObjectPrefix is prepended to the name of each S3 object that is created\n    // to store uploaded files. It can be used to create a pseudo-directory\n    // structure in the bucket, e.g. \"path/to/my/uploads\".\n    return key\n  }\n\n  /**\n   * Retrieves upload metadata previously saved in `${file_id}.info`.\n   * There's a small and simple caching mechanism to avoid multiple\n   * HTTP calls to S3.\n   * @param args - The function arguments\n   * @param args.id - The file ID to retrieve metadata for\n   * @returns Promise that resolves to the upload metadata\n   */\n  async getMetadata(args: GetMetadataArgs): Promise<TusUploadMetadata> {\n    const { id } = args\n    const cached = await this.cache.get(id)\n    if (cached) {\n      return cached\n    }\n\n    const { Body, Metadata } = await this.client.getObject({\n      Bucket: this.bucket,\n      Key: this.generateInfoKey({ id }),\n    })\n    const file = JSON.parse((await Body?.transformToString()) as string)\n    const metadata: TusUploadMetadata = {\n      file: new Upload({\n        id,\n        creation_date: file.creation_date,\n        metadata: file.metadata,\n        offset: Number.parseInt(file.offset, 10),\n        size: Number.isFinite(file.size)\n          ? Number.parseInt(file.size, 10)\n          : undefined,\n        storage: file.storage,\n      }),\n      'tus-version': Metadata?.['tus-version'] as string,\n      'upload-id': Metadata?.['upload-id'] as string,\n    }\n    await this.cache.set(id, metadata)\n    return metadata\n  }\n\n  /**\n   * Saves upload metadata to a `${file_id}.info` file on S3.\n   * Please note that the file is empty and the metadata is saved\n   * on the S3 object's `Metadata` field, so that only a `headObject`\n   * is necessary to retrieve the data.\n   * @param args - The function arguments\n   * @param args.upload - The upload object containing metadata\n   * @param args.uploadId - The upload ID for the multipart upload\n   * @returns Promise that resolves when metadata is saved\n   */\n  async saveMetadata(args: SaveMetadataArgs): Promise<void> {\n    const { upload, uploadId } = args\n    log(`[${upload.id}] saving metadata`)\n    await this.client.putObject({\n      Body: JSON.stringify(upload),\n      Bucket: this.bucket,\n      Key: this.generateInfoKey({ id: upload.id }),\n      Metadata: {\n        'tus-version': TUS_RESUMABLE,\n        'upload-id': uploadId,\n      },\n      Tagging: this.generateCompleteTag('false'),\n    })\n    log(`[${upload.id}] metadata file saved`)\n  }\n\n  /**\n   * Completes metadata by updating it with completion tags\n   * @param args - The function arguments\n   * @param args.upload - The completed upload object\n   * @returns Promise that resolves when metadata is updated\n   */\n  async completeMetadata(args: CompleteMetadataArgs): Promise<void> {\n    const { upload } = args\n    // Always update the cache with the completed upload\n    const metadata = await this.getMetadata({ id: upload.id })\n    const completedMetadata: TusUploadMetadata = {\n      ...metadata,\n      file: upload,\n    }\n    await this.cache.set(upload.id, completedMetadata)\n\n    if (!this.shouldUseExpirationTags()) {\n      return\n    }\n\n    const { 'upload-id': uploadId } = metadata\n    await this.client.putObject({\n      Body: JSON.stringify(upload),\n      Bucket: this.bucket,\n      Key: this.generateInfoKey({ id: upload.id }),\n      Metadata: {\n        'tus-version': TUS_RESUMABLE,\n        'upload-id': uploadId,\n      },\n      Tagging: this.generateCompleteTag('true'),\n    })\n  }\n\n  /**\n   * Removes cached data for a given file\n   * @param args - The function arguments\n   * @param args.id - The file ID to remove from cache\n   * @returns Promise that resolves when cache is cleared\n   */\n  async clearCache(args: ClearCacheArgs): Promise<void> {\n    const { id } = args\n    log(`[${id}] removing cached data`)\n    await this.cache.delete(id)\n  }\n}\n"],"mappings":";;;;AAiCA,IAAa,oBAAb,MAA+B;CAC7B,YACUA,QACAC,QACAC,OACAC,yBACAC,qBACR;EALQ;EACA;EACA;EACA;EACA;CACN;;;;;;;CAQJ,gBAAgBC,MAAmC;EACjD,MAAM,EAAE,IAAI,GAAG;AACf,SAAO,GAAG,GAAG,KAAK,CAAC;CACpB;;;;;;;;CASD,gBAAgBC,MAAmC;EACjD,MAAM,EAAE,IAAI,eAAe,OAAO,GAAG;EACrC,IAAI,MAAM;AACV,MAAI,cACF,OAAO;AAOT,SAAO;CACR;;;;;;;;;CAUD,MAAM,YAAYC,MAAmD;EACnE,MAAM,EAAE,IAAI,GAAG;EACf,MAAM,SAAS,MAAM,KAAK,MAAM,IAAI,GAAG;AACvC,MAAI,OACF,QAAO;EAGT,MAAM,EAAE,MAAM,UAAU,GAAG,MAAM,KAAK,OAAO,UAAU;GACrD,QAAQ,KAAK;GACb,KAAK,KAAK,gBAAgB,EAAE,GAAI,EAAC;EAClC,EAAC;EACF,MAAM,OAAO,KAAK,MAAO,MAAM,MAAM,mBAAmB,CAAY;EACpE,MAAMC,WAA8B;GAClC,MAAM,IAAI,OAAO;IACf;IACA,eAAe,KAAK;IACpB,UAAU,KAAK;IACf,QAAQ,OAAO,SAAS,KAAK,QAAQ,GAAG;IACxC,MAAM,OAAO,SAAS,KAAK,KAAK,GAC5B,OAAO,SAAS,KAAK,MAAM,GAAG,GAC9B;IACJ,SAAS,KAAK;GACf;GACD,eAAe,WAAW;GAC1B,aAAa,WAAW;EACzB;EACD,MAAM,KAAK,MAAM,IAAI,IAAI,SAAS;AAClC,SAAO;CACR;;;;;;;;;;;CAYD,MAAM,aAAaC,MAAuC;EACxD,MAAM,EAAE,QAAQ,UAAU,GAAG;EAC7B,IAAI,CAAC,CAAC,EAAE,OAAO,GAAG,iBAAiB,CAAC,CAAC;EACrC,MAAM,KAAK,OAAO,UAAU;GAC1B,MAAM,KAAK,UAAU,OAAO;GAC5B,QAAQ,KAAK;GACb,KAAK,KAAK,gBAAgB,EAAE,IAAI,OAAO,GAAI,EAAC;GAC5C,UAAU;IACR,eAAe;IACf,aAAa;GACd;GACD,SAAS,KAAK,oBAAoB,QAAQ;EAC3C,EAAC;EACF,IAAI,CAAC,CAAC,EAAE,OAAO,GAAG,qBAAqB,CAAC,CAAC;CAC1C;;;;;;;CAQD,MAAM,iBAAiBC,MAA2C;EAChE,MAAM,EAAE,QAAQ,GAAG;EAEnB,MAAM,WAAW,MAAM,KAAK,YAAY,EAAE,IAAI,OAAO,GAAI,EAAC;EAC1D,MAAMC,oBAAuC;GAC3C,GAAG;GACH,MAAM;EACP;EACD,MAAM,KAAK,MAAM,IAAI,OAAO,IAAI,kBAAkB;AAElD,MAAI,CAAC,KAAK,yBAAyB,CACjC;EAGF,MAAM,EAAE,aAAa,UAAU,GAAG;EAClC,MAAM,KAAK,OAAO,UAAU;GAC1B,MAAM,KAAK,UAAU,OAAO;GAC5B,QAAQ,KAAK;GACb,KAAK,KAAK,gBAAgB,EAAE,IAAI,OAAO,GAAI,EAAC;GAC5C,UAAU;IACR,eAAe;IACf,aAAa;GACd;GACD,SAAS,KAAK,oBAAoB,OAAO;EAC1C,EAAC;CACH;;;;;;;CAQD,MAAM,WAAWC,MAAqC;EACpD,MAAM,EAAE,IAAI,GAAG;EACf,IAAI,CAAC,CAAC,EAAE,GAAG,sBAAsB,CAAC,CAAC;EACnC,MAAM,KAAK,MAAM,OAAO,GAAG;CAC5B;AACF"}

package/dist/tus/stores/s3/parts-manager.d.ts

@@ -0,0 +1,130 @@
+import { Semaphore } from "./semaphore.js";
+import { S3FileOperations } from "./file-operations.js";
+import { IncompletePartInfo, TusUploadMetadata } from "../../../types/index.js";
+import { S3MetadataManager } from "./metadata-manager.js";
+import stream, { Readable } from "node:stream";
+import AWS, { S3 } from "@aws-sdk/client-s3";
+import fs from "node:fs";
+
+//#region src/tus/stores/s3/parts-manager.d.ts
+type RetrievePartsArgs = {
+  id: string;
+  partNumberMarker?: string;
+};
+type FinishMultipartUploadArgs = {
+  metadata: TusUploadMetadata;
+  parts: Array<AWS.Part>;
+};
+type GetIncompletePartArgs = {
+  id: string;
+};
+type GetIncompletePartSizeArgs = {
+  id: string;
+};
+type DeleteIncompletePartArgs = {
+  id: string;
+};
+type DownloadIncompletePartArgs = {
+  id: string;
+};
+type UploadIncompletePartArgs = {
+  id: string;
+  readStream: fs.ReadStream | Readable;
+};
+type UploadPartArgs = {
+  metadata: TusUploadMetadata;
+  readStream: fs.ReadStream | Readable;
+  partNumber: number;
+};
+type UploadPartsArgs = {
+  metadata: TusUploadMetadata;
+  readStream: stream.Readable;
+  currentPartNumber: number;
+  offset: number;
+};
+declare class S3PartsManager {
+  private client;
+  private bucket;
+  private minPartSize;
+  private partUploadSemaphore;
+  private metadataManager;
+  private fileOperations;
+  private generateCompleteTag;
+  constructor(client: S3, bucket: string, minPartSize: number, partUploadSemaphore: Semaphore, metadataManager: S3MetadataManager, fileOperations: S3FileOperations, generateCompleteTag: (value: 'false' | 'true') => string | undefined);
+  /**
+   * Gets the number of complete parts/chunks already uploaded to S3.
+   * Retrieves only consecutive parts.
+   * @param args - The function arguments
+   * @param args.id - The upload ID
+   * @param args.partNumberMarker - Marker for pagination (optional)
+   * @returns Promise that resolves to array of uploaded parts
+   */
+  retrieveParts(args: RetrievePartsArgs): Promise<Array<AWS.Part>>;
+  /**
+   * Completes a multipart upload on S3.
+   * This is where S3 concatenates all the uploaded parts.
+   * @param args - The function arguments
+   * @param args.metadata - The upload metadata
+   * @param args.parts - Array of uploaded parts to complete
+   * @returns Promise that resolves to the location URL (optional)
+   */
+  finishMultipartUpload(args: FinishMultipartUploadArgs): Promise<string | undefined>;
+  /**
+   * Gets incomplete part from S3
+   * @param args - The function arguments
+   * @param args.id - The upload ID
+   * @returns Promise that resolves to readable stream or undefined if not found
+   */
+  getIncompletePart(args: GetIncompletePartArgs): Promise<Readable | undefined>;
+  /**
+   * Gets the size of an incomplete part
+   * @param args - The function arguments
+   * @param args.id - The upload ID
+   * @returns Promise that resolves to part size or undefined if not found
+   */
+  getIncompletePartSize(args: GetIncompletePartSizeArgs): Promise<number | undefined>;
+  /**
+   * Deletes an incomplete part
+   * @param args - The function arguments
+   * @param args.id - The upload ID
+   * @returns Promise that resolves when deletion is complete
+   */
+  deleteIncompletePart(args: DeleteIncompletePartArgs): Promise<void>;
+  /**
+   * Downloads incomplete part to temporary file
+   * @param args - The function arguments
+   * @param args.id - The upload ID
+   * @returns Promise that resolves to incomplete part info or undefined if not found
+   */
+  downloadIncompletePart(args: DownloadIncompletePartArgs): Promise<IncompletePartInfo | undefined>;
+  /**
+   * Uploads an incomplete part
+   * @param args - The function arguments
+   * @param args.id - The upload ID
+   * @param args.readStream - The stream to read data from
+   * @returns Promise that resolves to the ETag of the uploaded part
+   */
+  uploadIncompletePart(args: UploadIncompletePartArgs): Promise<string>;
+  /**
+   * Uploads a single part
+   * @param args - The function arguments
+   * @param args.metadata - The upload metadata
+   * @param args.readStream - The stream to read data from
+   * @param args.partNumber - The part number to upload
+   * @returns Promise that resolves to the ETag of the uploaded part
+   */
+  uploadPart(args: UploadPartArgs): Promise<AWS.Part>;
+  /**
+   * Uploads a stream to s3 using multiple parts
+   * @param args - The function arguments
+   * @param args.metadata - The upload metadata
+   * @param args.readStream - The stream to read data from
+   * @param args.currentPartNumber - The current part number to start from
+   * @param args.offset - The byte offset to start from
+   * @returns Promise that resolves to the number of bytes uploaded
+   */
+  uploadParts(args: UploadPartsArgs): Promise<number>;
+}
+//#endregion
+export { S3PartsManager };
+//# sourceMappingURL=parts-manager.d.ts.map

package/dist/tus/stores/s3/parts-manager.js

@@ -0,0 +1,328 @@
+import { MediaCloudError } from "../../../types/errors.js";
+import { useErrorHandler } from "../../../hooks/useErrorHandler.js";
+import { log } from "./log.js";
+import stream from "node:stream";
+import { NoSuchKey, NotFound } from "@aws-sdk/client-s3";
+import { StreamSplitter } from "@tus/utils";
+import fs from "node:fs";
+import os from "node:os";
+
+//#region src/tus/stores/s3/parts-manager.ts
+const { throwError } = useErrorHandler();
+var S3PartsManager = class {
+	constructor(client, bucket, minPartSize, partUploadSemaphore, metadataManager, fileOperations, generateCompleteTag) {
+		this.client = client;
+		this.bucket = bucket;
+		this.minPartSize = minPartSize;
+		this.partUploadSemaphore = partUploadSemaphore;
+		this.metadataManager = metadataManager;
+		this.fileOperations = fileOperations;
+		this.generateCompleteTag = generateCompleteTag;
+	}
+	/**
+	* Gets the number of complete parts/chunks already uploaded to S3.
+	* Retrieves only consecutive parts.
+	* @param args - The function arguments
+	* @param args.id - The upload ID
+	* @param args.partNumberMarker - Marker for pagination (optional)
+	* @returns Promise that resolves to array of uploaded parts
+	*/
+	async retrieveParts(args) {
+		const { id, partNumberMarker } = args;
+		const metadata = await this.metadataManager.getMetadata({ id });
+		if (!metadata["upload-id"]) {
+			throwError(MediaCloudError.MUX_UPLOAD_ID_MISSING);
+			throw new Error();
+		}
+		const params = {
+			Bucket: this.bucket,
+			Key: id,
+			PartNumberMarker: partNumberMarker,
+			UploadId: metadata["upload-id"]
+		};
+		const data = await this.client.listParts(params);
+		let parts = data.Parts ?? [];
+		if (data.IsTruncated) {
+			const rest = await this.retrieveParts({
+				id,
+				partNumberMarker: data.NextPartNumberMarker
+			});
+			parts = [...parts, ...rest];
+		}
+		if (!partNumberMarker) parts.sort((a, b) => (a.PartNumber || 0) - (b.PartNumber || 0));
+		return parts;
+	}
+	/**
+	* Completes a multipart upload on S3.
+	* This is where S3 concatenates all the uploaded parts.
+	* @param args - The function arguments
+	* @param args.metadata - The upload metadata
+	* @param args.parts - Array of uploaded parts to complete
+	* @returns Promise that resolves to the location URL (optional)
+	*/
+	async finishMultipartUpload(args) {
+		const { metadata, parts } = args;
+		const params = {
+			Bucket: this.bucket,
+			Key: metadata.file.id,
+			MultipartUpload: { Parts: parts.map((part) => {
+				return {
+					ETag: part.ETag,
+					PartNumber: part.PartNumber
+				};
+			}) },
+			UploadId: metadata["upload-id"]
+		};
+		try {
+			const result = await this.client.completeMultipartUpload(params);
+			return result.Location;
+		} catch (_error) {
+			throwError(MediaCloudError.TUS_UPLOAD_ERROR);
+			throw new Error();
+		}
+	}
+	/**
+	* Gets incomplete part from S3
+	* @param args - The function arguments
+	* @param args.id - The upload ID
+	* @returns Promise that resolves to readable stream or undefined if not found
+	*/
+	async getIncompletePart(args) {
+		const { id } = args;
+		try {
+			const data = await this.client.getObject({
+				Bucket: this.bucket,
+				Key: this.metadataManager.generatePartKey({
+					id,
+					isIncomplete: true
+				})
+			});
+			return data.Body;
+		} catch (error) {
+			if (error instanceof NoSuchKey) return void 0;
+			throw error;
+		}
+	}
+	/**
+	* Gets the size of an incomplete part
+	* @param args - The function arguments
+	* @param args.id - The upload ID
+	* @returns Promise that resolves to part size or undefined if not found
+	*/
+	async getIncompletePartSize(args) {
+		const { id } = args;
+		try {
+			const data = await this.client.headObject({
+				Bucket: this.bucket,
+				Key: this.metadataManager.generatePartKey({
+					id,
+					isIncomplete: true
+				})
+			});
+			return data.ContentLength;
+		} catch (error) {
+			if (error instanceof NotFound) return void 0;
+			throw error;
+		}
+	}
+	/**
+	* Deletes an incomplete part
+	* @param args - The function arguments
+	* @param args.id - The upload ID
+	* @returns Promise that resolves when deletion is complete
+	*/
+	async deleteIncompletePart(args) {
+		const { id } = args;
+		await this.client.deleteObject({
+			Bucket: this.bucket,
+			Key: this.metadataManager.generatePartKey({
+				id,
+				isIncomplete: true
+			})
+		});
+	}
+	/**
+	* Downloads incomplete part to temporary file
+	* @param args - The function arguments
+	* @param args.id - The upload ID
+	* @returns Promise that resolves to incomplete part info or undefined if not found
+	*/
+	async downloadIncompletePart(args) {
+		const { id } = args;
+		const incompletePart = await this.getIncompletePart({ id });
+		if (!incompletePart) return;
+		const filePath = await this.fileOperations.generateUniqueTmpFileName({ template: "tus-s3-incomplete-part-" });
+		try {
+			let incompletePartSize = 0;
+			const byteCounterTransform = new stream.Transform({ transform(chunk, _, callback) {
+				incompletePartSize += chunk.length;
+				callback(null, chunk);
+			} });
+			await stream.promises.pipeline(incompletePart, byteCounterTransform, fs.createWriteStream(filePath));
+			const createReadStream = (options) => {
+				const fileReader = fs.createReadStream(filePath);
+				if (options.cleanUpOnEnd) {
+					fileReader.on("end", () => {
+						fs.unlink(filePath, () => {});
+					});
+					fileReader.on("error", (err) => {
+						fileReader.destroy(err);
+						fs.unlink(filePath, () => {});
+					});
+				}
+				return fileReader;
+			};
+			return {
+				createReader: createReadStream,
+				path: filePath,
+				size: incompletePartSize
+			};
+		} catch (err) {
+			fs.promises.rm(filePath).catch(() => {});
+			throw err;
+		}
+	}
+	/**
+	* Uploads an incomplete part
+	* @param args - The function arguments
+	* @param args.id - The upload ID
+	* @param args.readStream - The stream to read data from
+	* @returns Promise that resolves to the ETag of the uploaded part
+	*/
+	async uploadIncompletePart(args) {
+		const { id, readStream } = args;
+		const data = await this.client.putObject({
+			Body: readStream,
+			Bucket: this.bucket,
+			Key: this.metadataManager.generatePartKey({
+				id,
+				isIncomplete: true
+			}),
+			Tagging: this.generateCompleteTag("false")
+		});
+		log(`[${id}] finished uploading incomplete part`);
+		return data.ETag;
+	}
+	/**
+	* Uploads a single part
+	* @param args - The function arguments
+	* @param args.metadata - The upload metadata
+	* @param args.readStream - The stream to read data from
+	* @param args.partNumber - The part number to upload
+	* @returns Promise that resolves to the ETag of the uploaded part
+	*/
+	async uploadPart(args) {
+		const { metadata, readStream, partNumber } = args;
+		const permit = await this.partUploadSemaphore.acquire();
+		if (!metadata["upload-id"]) {
+			throwError(MediaCloudError.MUX_UPLOAD_ID_MISSING);
+			throw new Error();
+		}
+		const params = {
+			Body: readStream,
+			Bucket: this.bucket,
+			Key: metadata.file.id,
+			PartNumber: partNumber,
+			UploadId: metadata["upload-id"]
+		};
+		try {
+			const data = await this.client.uploadPart(params);
+			return {
+				ETag: data.ETag,
+				PartNumber: partNumber
+			};
+		} catch (_error) {
+			throwError(MediaCloudError.TUS_UPLOAD_ERROR);
+			throw new Error();
+		} finally {
+			permit();
+		}
+	}
+	/**
+	* Uploads a stream to s3 using multiple parts
+	* @param args - The function arguments
+	* @param args.metadata - The upload metadata
+	* @param args.readStream - The stream to read data from
+	* @param args.currentPartNumber - The current part number to start from
+	* @param args.offset - The byte offset to start from
+	* @returns Promise that resolves to the number of bytes uploaded
+	*/
+	async uploadParts(args) {
+		const { metadata, readStream, offset: initialOffset } = args;
+		let { currentPartNumber } = args;
+		let offset = initialOffset;
+		const size = metadata.file.size;
+		const promises = [];
+		let pendingChunkFilepath = null;
+		let bytesUploaded = 0;
+		let permit = void 0;
+		const splitterStream = new StreamSplitter({
+			chunkSize: this.fileOperations.calculateOptimalPartSize({ size }),
+			directory: os.tmpdir()
+		}).on("beforeChunkStarted", async () => {
+			permit = await this.partUploadSemaphore.acquire();
+		}).on("chunkStarted", (filepath) => {
+			pendingChunkFilepath = filepath;
+		}).on("chunkFinished", ({ path, size: partSize }) => {
+			pendingChunkFilepath = null;
+			const acquiredPermit = permit;
+			const partNumber = currentPartNumber++;
+			offset += partSize;
+			const isFinalPart = size === offset;
+			const uploadChunk = async () => {
+				try {
+					const readable = fs.createReadStream(path);
+					readable.on("error", function(error) {
+						throw error;
+					});
+					switch (true) {
+						case partSize >= this.minPartSize || isFinalPart:
+							await this.uploadPart({
+								metadata,
+								readStream: readable,
+								partNumber
+							});
+							break;
+						default:
+							await this.uploadIncompletePart({
+								id: metadata.file.id,
+								readStream: readable
+							});
+							break;
+					}
+					bytesUploaded += partSize;
+				} catch (error) {
+					const mappedError = error instanceof Error ? error : new Error(String(error));
+					splitterStream.destroy(mappedError);
+					throw mappedError;
+				} finally {
+					fs.promises.rm(path).catch(function() {});
+					acquiredPermit?.();
+				}
+			};
+			const deferred = uploadChunk();
+			promises.push(deferred);
+		}).on("chunkError", () => {
+			permit?.();
+		});
+		try {
+			await stream.promises.pipeline(readStream, splitterStream);
+		} catch (error) {
+			if (pendingChunkFilepath !== null) try {
+				await fs.promises.rm(pendingChunkFilepath);
+			} catch {
+				log(`[${metadata.file.id}] failed to remove chunk ${String(pendingChunkFilepath)}`);
+			}
+			const mappedError = error instanceof Error ? error : new Error(String(error));
+			promises.push(Promise.reject(mappedError));
+		} finally {
+			await Promise.allSettled(promises);
+			await Promise.all(promises);
+		}
+		return bytesUploaded;
+	}
+};
+
+//#endregion
+export { S3PartsManager };
+//# sourceMappingURL=parts-manager.js.map