@maas/payload-plugin-media-cloud 0.0.0

package/dist/hooks/useErrorHandler.d.ts

@@ -0,0 +1,11 @@
+import { MediaCloudError } from "../types/errors.js";
+import { ErrorLevel } from "@maas/error-handler";
+
+//#region src/hooks/useErrorHandler.d.ts
+declare function useErrorHandler(): {
+  logError: (errorKey: MediaCloudError, level?: ErrorLevel) => void;
+  throwError: (errorKey: MediaCloudError) => never;
+};
+//#endregion
+export { useErrorHandler };
+//# sourceMappingURL=useErrorHandler.d.ts.map

package/dist/hooks/useErrorHandler.js

@@ -0,0 +1,19 @@
+import { MediaCloudError } from "../types/errors.js";
+import { ErrorLevel, createErrorHandler } from "@maas/error-handler";
+
+//#region src/hooks/useErrorHandler.ts
+function useErrorHandler() {
+	const { logError, throwError } = createErrorHandler({
+		prefix: "PLUGIN-MEDIA-CLOUD",
+		level: ErrorLevel.ERROR,
+		errors: MediaCloudError
+	});
+	return {
+		logError,
+		throwError
+	};
+}
+
+//#endregion
+export { useErrorHandler };
+//# sourceMappingURL=useErrorHandler.js.map

package/dist/hooks/useErrorHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useErrorHandler.js","names":[],"sources":["../../src/hooks/useErrorHandler.ts"],"sourcesContent":["import { createErrorHandler, ErrorLevel } from '@maas/error-handler'\nimport { MediaCloudError } from '../types/errors'\n\nexport function useErrorHandler() {\n  const { logError, throwError } = createErrorHandler({\n    prefix: 'PLUGIN-MEDIA-CLOUD',\n    level: ErrorLevel.ERROR,\n    errors: MediaCloudError,\n  })\n\n  return {\n    logError,\n    throwError,\n  }\n}\n"],"mappings":";;;;AAGA,SAAgB,kBAAkB;CAChC,MAAM,EAAE,UAAU,YAAY,GAAG,mBAAmB;EAClD,QAAQ;EACR,OAAO,WAAW;EAClB,QAAQ;CACT,EAAC;AAEF,QAAO;EACL;EACA;CACD;AACF"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { MediaCloudPluginOptions } from "./types/index.js";
+import { mediaCloudPlugin } from "./plugin.js";
+export { type MediaCloudPluginOptions, mediaCloudPlugin };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { mediaCloudPlugin } from "./plugin.js";
+
+export { mediaCloudPlugin };

package/dist/plugin.d.ts

@@ -0,0 +1,15 @@
+import { MediaCloudPluginOptions } from "./types/index.js";
+import { Config } from "payload";
+
+//#region src/plugin.d.ts
+
+/**
+ * Media Cloud Plugin for Payload CMS
+ * Provides file upload capabilities using S3 storage and Mux video processing
+ * @param pluginOptions - Configuration options for the plugin
+ * @returns A function that configures the Payload config
+ */
+declare function mediaCloudPlugin(pluginOptions: MediaCloudPluginOptions): (config: Config) => Config;
+//#endregion
+export { mediaCloudPlugin };
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.js

@@ -0,0 +1,242 @@
+import { MediaCloudError } from "./types/errors.js";
+import { useErrorHandler } from "./hooks/useErrorHandler.js";
+import { getStorageAdapter } from "./adapter/storageAdapter.js";
+import { getMediaCollection } from "./collections/mediaCollection.js";
+import { getMuxAssetHandler } from "./endpoints/muxAssetHandler.js";
+import { getMuxCreateUploadHandler } from "./endpoints/muxCreateUploadHandler.js";
+import { getMuxWebhookHandler } from "./endpoints/muxWebhookHandler.js";
+import { S3Store } from "./tus/stores/s3/s3-store.js";
+import { generateUniqueFilename } from "./utils/file.js";
+import Mux from "@mux/mux-node";
+import { cloudStoragePlugin } from "@payloadcms/plugin-cloud-storage";
+import { initClientUploads } from "@payloadcms/plugin-cloud-storage/utilities";
+import { getPayload, sanitizeConfig } from "payload";
+import { Server } from "@tus/server";
+
+//#region src/plugin.ts
+const { logError, throwError } = useErrorHandler();
+let muxClient = null;
+/**
+* Validates Mux configuration options
+* @param muxConfig - The Mux configuration to validate
+* @throws {Error} When required Mux configuration is missing
+*/
+function validateMuxConfig(muxConfig) {
+	if (!muxConfig?.tokenId || !muxConfig?.tokenSecret) throwError(MediaCloudError.MUX_CONFIG_MISSING);
+}
+/**
+* Creates a new Mux client instance
+* @param muxConfig - The Mux configuration options
+* @returns A configured Mux client
+*/
+function createMuxClient(muxConfig) {
+	return new Mux({
+		tokenId: muxConfig.tokenId,
+		tokenSecret: muxConfig.tokenSecret,
+		webhookSecret: muxConfig.webhookSecret
+	});
+}
+/**
+* Creates and configures an S3Store instance
+* @param s3Config - The S3 configuration options
+* @returns A configured S3Store instance
+* @throws {Error} When required S3 configuration is missing
+*/
+function createS3Store(s3Config) {
+	if (!s3Config?.bucket || !s3Config?.region || !s3Config?.accessKeyId || !s3Config?.secretAccessKey) throwError(MediaCloudError.S3_CONFIG_MISSING);
+	return new S3Store({ s3ClientConfig: {
+		acl: "public-read",
+		bucket: s3Config.bucket,
+		credentials: {
+			accessKeyId: s3Config.accessKeyId,
+			secretAccessKey: s3Config.secretAccessKey
+		},
+		endpoint: s3Config.endpoint,
+		forcePathStyle: true,
+		region: s3Config.region
+	} });
+}
+/**
+* Creates a TUS server instance with S3 storage
+* @param args - The arguments for creating the TUS server
+* @returns A configured TusServer instance
+*/
+function createTusServer(args) {
+	const { config, s3Store } = args;
+	return new Server({
+		datastore: s3Store,
+		namingFunction: async (req, metadata) => {
+			try {
+				const payload = await getPayload({ config: sanitizeConfig(config) });
+				const { docs } = await payload.find({
+					collection: "media",
+					where: { filename: { equals: metadata?.filename || "" } }
+				});
+				if (docs.length > 0) return generateUniqueFilename(metadata?.filename ?? "");
+				else return metadata?.filename || generateUniqueFilename("");
+			} catch (_error) {
+				logError(MediaCloudError.NAMING_FUNCTION_ERROR);
+				return metadata?.filename || generateUniqueFilename("");
+			}
+		},
+		path: "/api/uploads"
+	});
+}
+/**
+* Creates TUS upload endpoints for file handling
+* @param tusServer - The TUS server instance
+* @returns An array of endpoint configurations
+*/
+function createTusEndpoints(tusServer) {
+	/**
+	* Handles TUS requests through the server
+	* @param req - The payload request object
+	* @returns The server response
+	*/
+	function tusHandler(req) {
+		return tusServer.handleWeb(req);
+	}
+	return [
+		{
+			handler: tusHandler,
+			method: "options",
+			path: "/uploads"
+		},
+		{
+			handler: tusHandler,
+			method: "post",
+			path: "/uploads"
+		},
+		{
+			handler: tusHandler,
+			method: "get",
+			path: "/uploads/:id"
+		},
+		{
+			handler: tusHandler,
+			method: "put",
+			path: "/uploads/:id"
+		},
+		{
+			handler: tusHandler,
+			method: "patch",
+			path: "/uploads/:id"
+		},
+		{
+			handler: tusHandler,
+			method: "delete",
+			path: "/uploads/:id"
+		}
+	];
+}
+/**
+* Creates Mux-related endpoints for asset handling
+* @param args - The arguments for creating Mux endpoints
+* @returns An array of Mux endpoint configurations
+*/
+function createMuxEndpoints(args) {
+	const { getMuxClient, pluginOptions } = args;
+	return [
+		{
+			handler: getMuxWebhookHandler({ getMuxClient }),
+			method: "get",
+			path: "/mux/webhook"
+		},
+		{
+			handler: getMuxCreateUploadHandler({
+				getMuxClient,
+				pluginOptions
+			}),
+			method: "post",
+			path: "/mux/upload"
+		},
+		{
+			handler: getMuxAssetHandler({ getMuxClient }),
+			method: "get",
+			path: "/mux/asset"
+		}
+	];
+}
+/**
+* Media Cloud Plugin for Payload CMS
+* Provides file upload capabilities using S3 storage and Mux video processing
+* @param pluginOptions - Configuration options for the plugin
+* @returns A function that configures the Payload config
+*/
+function mediaCloudPlugin(pluginOptions) {
+	return function(config) {
+		if (!pluginOptions) {
+			logError(MediaCloudError.PLUGIN_NOT_CONFIGURED);
+			return config;
+		}
+		const isPluginDisabled = pluginOptions.enabled === false;
+		/**
+		* Gets or creates a Mux client instance
+		* @returns The Mux client instance
+		*/
+		function getMuxClient() {
+			if (muxClient) return muxClient;
+			return createMuxClient(pluginOptions.mux);
+		}
+		if (pluginOptions.mux) {
+			validateMuxConfig(pluginOptions.mux);
+			muxClient = getMuxClient();
+		} else {
+			logError(MediaCloudError.MUX_CONFIG_INCOMPLETE);
+			muxClient = null;
+		}
+		const s3Store = createS3Store(pluginOptions.s3);
+		const tusServer = createTusServer({
+			config,
+			s3Store
+		});
+		const mediaCollection = getMediaCollection({ s3Store });
+		if (isPluginDisabled) return config;
+		initClientUploads({
+			clientHandler: "@maas/payload-plugin-media-cloud/components#UploadHandler",
+			collections: { media: {
+				clientUploads: true,
+				disableLocalStorage: true
+			} },
+			config,
+			enabled: true,
+			serverHandler: () => {
+				return Response.json({ message: "Server handler is not implemented" }, { status: 501 });
+			},
+			serverHandlerPath: "/media-cloud/upload"
+		});
+		const cloudStorageConfig = { collections: { media: {
+			adapter: getStorageAdapter({
+				getMuxClient,
+				pluginOptions,
+				s3Store
+			}),
+			clientUploads: true,
+			disableLocalStorage: true
+		} } };
+		const mappedConfig = {
+			...config,
+			admin: {
+				...config.admin ?? {},
+				components: {
+					...config.admin?.components ?? {},
+					providers: ["@maas/payload-plugin-media-cloud/components#UploadManagerProvider", ...config.admin?.components?.providers ?? []]
+				}
+			},
+			collections: [...config.collections ?? [], mediaCollection],
+			endpoints: [
+				...config.endpoints ?? [],
+				...createTusEndpoints(tusServer),
+				...createMuxEndpoints({
+					getMuxClient,
+					pluginOptions
+				})
+			]
+		};
+		return cloudStoragePlugin(cloudStorageConfig)(mappedConfig);
+	};
+}
+
+//#endregion
+export { mediaCloudPlugin };
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","names":["muxClient: Mux | null","muxConfig: MediaCloudPluginOptions['mux']","s3Config: MediaCloudPluginOptions['s3']","args: CreateTusServerArgs","TusServer","tusServer: TusServer","req: PayloadRequest","args: CreateMuxEndpointsArgs","pluginOptions: MediaCloudPluginOptions","config: Config","mappedConfig: Config"],"sources":["../src/plugin.ts"],"sourcesContent":["import Mux from '@mux/mux-node'\n\nimport { cloudStoragePlugin } from '@payloadcms/plugin-cloud-storage'\nimport { initClientUploads } from '@payloadcms/plugin-cloud-storage/utilities'\nimport { getPayload, sanitizeConfig } from 'payload'\nimport { Server as TusServer, type DataStore } from '@tus/server'\n\nimport { MediaCloudError } from './types/errors'\nimport { useErrorHandler } from './hooks/useErrorHandler'\nimport { getStorageAdapter } from './adapter/storageAdapter'\nimport { getMediaCollection } from './collections/mediaCollection'\nimport { getMuxAssetHandler } from './endpoints/muxAssetHandler'\nimport { getMuxCreateUploadHandler } from './endpoints/muxCreateUploadHandler'\nimport { getMuxWebhookHandler } from './endpoints/muxWebhookHandler'\nimport { S3Store } from './tus/stores/s3/s3-store'\nimport { generateUniqueFilename } from './utils/file'\n\nimport type { Config, PayloadRequest } from 'payload'\nimport type { MediaCloudPluginOptions } from './types'\n\ninterface CreateTusServerArgs {\n  config: Config\n  s3Store: DataStore\n}\n\ninterface CreateMuxEndpointsArgs {\n  getMuxClient: () => Mux\n  pluginOptions: MediaCloudPluginOptions\n}\n\nconst { logError, throwError } = useErrorHandler()\n\nlet muxClient: Mux | null = null\n\n/**\n * Validates Mux configuration options\n * @param muxConfig - The Mux configuration to validate\n * @throws {Error} When required Mux configuration is missing\n */\nfunction validateMuxConfig(muxConfig: MediaCloudPluginOptions['mux']): void {\n  if (!muxConfig?.tokenId || !muxConfig?.tokenSecret) {\n    throwError(MediaCloudError.MUX_CONFIG_MISSING)\n  }\n}\n\n/**\n * Creates a new Mux client instance\n * @param muxConfig - The Mux configuration options\n * @returns A configured Mux client\n */\nfunction createMuxClient(muxConfig: MediaCloudPluginOptions['mux']): Mux {\n  // Create and return Mux client instance\n  return new Mux({\n    tokenId: muxConfig.tokenId,\n    tokenSecret: muxConfig.tokenSecret,\n    webhookSecret: muxConfig.webhookSecret,\n  })\n}\n\n/**\n * Creates and configures an S3Store instance\n * @param s3Config - The S3 configuration options\n * @returns A configured S3Store instance\n * @throws {Error} When required S3 configuration is missing\n */\nfunction createS3Store(s3Config: MediaCloudPluginOptions['s3']): S3Store {\n  // Validate S3 configuration\n  if (\n    !s3Config?.bucket ||\n    !s3Config?.region ||\n    !s3Config?.accessKeyId ||\n    !s3Config?.secretAccessKey\n  ) {\n    throwError(MediaCloudError.S3_CONFIG_MISSING)\n  }\n\n  // Create and return S3Store instance\n  return new S3Store({\n    s3ClientConfig: {\n      acl: 'public-read',\n      bucket: s3Config.bucket,\n      credentials: {\n        accessKeyId: s3Config.accessKeyId,\n        secretAccessKey: s3Config.secretAccessKey,\n      },\n      endpoint: s3Config.endpoint,\n      forcePathStyle: true,\n      region: s3Config.region,\n    },\n  })\n}\n\n/**\n * Creates a TUS server instance with S3 storage\n * @param args - The arguments for creating the TUS server\n * @returns A configured TusServer instance\n */\nfunction createTusServer(args: CreateTusServerArgs): TusServer {\n  const { config, s3Store } = args\n\n  return new TusServer({\n    datastore: s3Store,\n    namingFunction: async (req, metadata) => {\n      try {\n        // Get Payload instance\n        const payload = await getPayload({\n          config: sanitizeConfig(config),\n        })\n\n        // Check if a file with the same name already exists in the media collection\n        const { docs } = await payload.find({\n          collection: 'media',\n          where: {\n            filename: {\n              equals: metadata?.filename || '',\n            },\n          },\n        })\n\n        // If a file with the same name exists, generate a unique filename\n        if (docs.length > 0) {\n          return generateUniqueFilename(metadata?.filename ?? '')\n        } else {\n          // If no file with the same name exists, return the original filename\n          return metadata?.filename || generateUniqueFilename('')\n        }\n      } catch (_error) {\n        // If an error occurs, log it and return the original filename\n        logError(MediaCloudError.NAMING_FUNCTION_ERROR)\n        return metadata?.filename || generateUniqueFilename('')\n      }\n    },\n    path: '/api/uploads',\n  })\n}\n\n/**\n * Creates TUS upload endpoints for file handling\n * @param tusServer - The TUS server instance\n * @returns An array of endpoint configurations\n */\nfunction createTusEndpoints(tusServer: TusServer) {\n  /**\n   * Handles TUS requests through the server\n   * @param req - The payload request object\n   * @returns The server response\n   */\n  function tusHandler(req: PayloadRequest) {\n    return tusServer.handleWeb(req as Request)\n  }\n\n  return [\n    { handler: tusHandler, method: 'options' as const, path: '/uploads' },\n    { handler: tusHandler, method: 'post' as const, path: '/uploads' },\n    { handler: tusHandler, method: 'get' as const, path: '/uploads/:id' },\n    { handler: tusHandler, method: 'put' as const, path: '/uploads/:id' },\n    { handler: tusHandler, method: 'patch' as const, path: '/uploads/:id' },\n    { handler: tusHandler, method: 'delete' as const, path: '/uploads/:id' },\n  ]\n}\n\n/**\n * Creates Mux-related endpoints for asset handling\n * @param args - The arguments for creating Mux endpoints\n * @returns An array of Mux endpoint configurations\n */\nfunction createMuxEndpoints(args: CreateMuxEndpointsArgs) {\n  const { getMuxClient, pluginOptions } = args\n  return [\n    {\n      handler: getMuxWebhookHandler({ getMuxClient }),\n      method: 'get' as const,\n      path: '/mux/webhook',\n    },\n    {\n      handler: getMuxCreateUploadHandler({ getMuxClient, pluginOptions }),\n      method: 'post' as const,\n      path: '/mux/upload',\n    },\n    {\n      handler: getMuxAssetHandler({ getMuxClient }),\n      method: 'get' as const,\n      path: '/mux/asset',\n    },\n  ]\n}\n\n/**\n * Media Cloud Plugin for Payload CMS\n * Provides file upload capabilities using S3 storage and Mux video processing\n * @param pluginOptions - Configuration options for the plugin\n * @returns A function that configures the Payload config\n */\nexport function mediaCloudPlugin(pluginOptions: MediaCloudPluginOptions) {\n  return function (config: Config): Config {\n    if (!pluginOptions) {\n      logError(MediaCloudError.PLUGIN_NOT_CONFIGURED)\n      return config\n    }\n\n    const isPluginDisabled = pluginOptions.enabled === false\n\n    /**\n     * Gets or creates a Mux client instance\n     * @returns The Mux client instance\n     */\n    function getMuxClient(): Mux {\n      // Return existing Mux client if already created\n      if (muxClient) {\n        return muxClient\n      }\n      // Create and return a new Mux client\n      return createMuxClient(pluginOptions.mux)\n    }\n\n    // Validate Mux configuration\n    if (pluginOptions.mux) {\n      validateMuxConfig(pluginOptions.mux)\n      muxClient = getMuxClient()\n    } else {\n      logError(MediaCloudError.MUX_CONFIG_INCOMPLETE)\n      muxClient = null\n    }\n\n    const s3Store = createS3Store(pluginOptions.s3)\n    const tusServer = createTusServer({ config, s3Store })\n    const mediaCollection = getMediaCollection({ s3Store })\n\n    if (isPluginDisabled) {\n      return config\n    }\n\n    // Initialize client uploads\n    initClientUploads({\n      clientHandler:\n        '@maas/payload-plugin-media-cloud/components#UploadHandler',\n      collections: {\n        media: {\n          clientUploads: true,\n          disableLocalStorage: true,\n        },\n      },\n      config,\n      enabled: true,\n      serverHandler: () => {\n        return Response.json(\n          { message: 'Server handler is not implemented' },\n          { status: 501 }\n        )\n      },\n      serverHandlerPath: '/media-cloud/upload',\n    })\n\n    const cloudStorageConfig = {\n      collections: {\n        media: {\n          adapter: getStorageAdapter({ getMuxClient, pluginOptions, s3Store }),\n          clientUploads: true,\n          disableLocalStorage: true,\n        },\n      },\n    }\n\n    const mappedConfig: Config = {\n      ...config,\n      admin: {\n        ...(config.admin ?? {}),\n        components: {\n          ...(config.admin?.components ?? {}),\n          providers: [\n            '@maas/payload-plugin-media-cloud/components#UploadManagerProvider',\n            ...(config.admin?.components?.providers ?? []),\n          ],\n        },\n      },\n      collections: [...(config.collections ?? []), mediaCollection],\n      endpoints: [\n        ...(config.endpoints ?? []),\n        ...createTusEndpoints(tusServer),\n        ...createMuxEndpoints({ getMuxClient, pluginOptions }),\n      ],\n    }\n\n    return cloudStoragePlugin(cloudStorageConfig)(mappedConfig)\n  }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,36 @@
+import { S3 } from "@aws-sdk/client-s3";
+
+//#region src/tus/stores/s3/expiration-manager.d.ts
+type GetExpirationDateArgs = {
+  createdAt: string;
+};
+declare class S3ExpirationManager {
+  private client;
+  private bucket;
+  private expirationPeriodInMilliseconds;
+  private generateInfoKey;
+  private generatePartKey;
+  constructor(client: S3, bucket: string, expirationPeriodInMilliseconds: number, generateInfoKey: (id: string) => string, generatePartKey: (id: string, isIncompletePart: boolean) => string);
+  /**
+   * Calculates the expiration date for a file based on a creation date
+   * @param args - The function arguments
+   * @param args.createdAt - The creation date as a string
+   * @returns The expiration date
+   */
+  getExpirationDate(args: GetExpirationDateArgs): Date;
+  /**
+   * Gets the expiration period in milliseconds
+   * @returns The expiration period in milliseconds
+   */
+  getExpiration(): number;
+  /**
+   * Deletes expired incomplete uploads based on their initialization date.
+   * Returns the number of deleted uploads.
+   * @param args - The function arguments (empty object)
+   * @returns Promise that resolves to the number of deleted uploads
+   */
+  deleteExpired(): Promise<number>;
+}
+//#endregion
+export { S3ExpirationManager };
+//# sourceMappingURL=expiration-manager.d.ts.map

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

@@ -0,0 +1,76 @@
+//#region src/tus/stores/s3/expiration-manager.ts
+var S3ExpirationManager = class {
+	constructor(client, bucket, expirationPeriodInMilliseconds, generateInfoKey, generatePartKey) {
+		this.client = client;
+		this.bucket = bucket;
+		this.expirationPeriodInMilliseconds = expirationPeriodInMilliseconds;
+		this.generateInfoKey = generateInfoKey;
+		this.generatePartKey = generatePartKey;
+	}
+	/**
+	* Calculates the expiration date for a file based on a creation date
+	* @param args - The function arguments
+	* @param args.createdAt - The creation date as a string
+	* @returns The expiration date
+	*/
+	getExpirationDate(args) {
+		const { createdAt } = args;
+		const date = new Date(createdAt);
+		return new Date(date.getTime() + this.expirationPeriodInMilliseconds);
+	}
+	/**
+	* Gets the expiration period in milliseconds
+	* @returns The expiration period in milliseconds
+	*/
+	getExpiration() {
+		return this.expirationPeriodInMilliseconds;
+	}
+	/**
+	* Deletes expired incomplete uploads based on their initialization date.
+	* Returns the number of deleted uploads.
+	* @param args - The function arguments (empty object)
+	* @returns Promise that resolves to the number of deleted uploads
+	*/
+	async deleteExpired() {
+		if (this.getExpiration() === 0) return 0;
+		let keyMarker = void 0;
+		let uploadIdMarker = void 0;
+		let isTruncated = true;
+		let deleted = 0;
+		while (isTruncated) {
+			const listResponse = await this.client.listMultipartUploads({
+				Bucket: this.bucket,
+				KeyMarker: keyMarker,
+				UploadIdMarker: uploadIdMarker
+			});
+			const expiredUploads = listResponse.Uploads?.filter((multiPartUpload) => {
+				const initiatedDate = multiPartUpload.Initiated;
+				return initiatedDate && (/* @__PURE__ */ new Date()).getTime() > this.getExpirationDate({ createdAt: initiatedDate.toISOString() }).getTime();
+			}) || [];
+			const objectsToDelete = expiredUploads.reduce((all, expiredUpload) => {
+				all.push({ Key: this.generateInfoKey(expiredUpload.Key) }, { Key: this.generatePartKey(expiredUpload.Key, true) });
+				return all;
+			}, []);
+			const deletions = [];
+			if (objectsToDelete.length > 0) deletions.push(this.client.deleteObjects({
+				Bucket: this.bucket,
+				Delete: { Objects: objectsToDelete }
+			}));
+			const abortions = expiredUploads.map((expiredUpload) => this.client.abortMultipartUpload({
+				Bucket: this.bucket,
+				Key: expiredUpload.Key,
+				UploadId: expiredUpload.UploadId
+			}));
+			await Promise.all([...deletions, ...abortions]);
+			deleted += expiredUploads.length;
+			isTruncated = listResponse.IsTruncated || false;
+			keyMarker = listResponse.NextKeyMarker;
+			uploadIdMarker = listResponse.NextUploadIdMarker;
+		}
+		return deleted;
+	}
+};
+
+//#endregion
+export { S3ExpirationManager };
+//# sourceMappingURL=expiration-manager.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expiration-manager.js","names":["client: S3","bucket: string","expirationPeriodInMilliseconds: number","generateInfoKey: (id: string) => string","generatePartKey: (id: string, isIncompletePart: boolean) => string","args: GetExpirationDateArgs","keyMarker: string | undefined","uploadIdMarker: string | undefined","listResponse: AWS.ListMultipartUploadsCommandOutput","multiPartUpload: AWS.MultipartUpload","all: { Key: string }[]","expiredUpload: AWS.MultipartUpload","deletions: Promise<AWS.DeleteObjectsCommandOutput>[]"],"sources":["../../../../src/tus/stores/s3/expiration-manager.ts"],"sourcesContent":["import type AWS from '@aws-sdk/client-s3'\nimport type { S3 } from '@aws-sdk/client-s3'\n\ntype GetExpirationDateArgs = {\n  createdAt: string\n}\n\nexport class S3ExpirationManager {\n  constructor(\n    private client: S3,\n    private bucket: string,\n    private expirationPeriodInMilliseconds: number,\n    private generateInfoKey: (id: string) => string,\n    private generatePartKey: (id: string, isIncompletePart: boolean) => string\n  ) {}\n\n  /**\n   * Calculates the expiration date for a file based on a creation date\n   * @param args - The function arguments\n   * @param args.createdAt - The creation date as a string\n   * @returns The expiration date\n   */\n  getExpirationDate(args: GetExpirationDateArgs): Date {\n    const { createdAt } = args\n    const date = new Date(createdAt)\n    return new Date(date.getTime() + this.expirationPeriodInMilliseconds)\n  }\n\n  /**\n   * Gets the expiration period in milliseconds\n   * @returns The expiration period in milliseconds\n   */\n  getExpiration(): number {\n    return this.expirationPeriodInMilliseconds\n  }\n\n  /**\n   * Deletes expired incomplete uploads based on their initialization date.\n   * Returns the number of deleted uploads.\n   * @param args - The function arguments (empty object)\n   * @returns Promise that resolves to the number of deleted uploads\n   */\n  async deleteExpired(): Promise<number> {\n    // No arguments to destructure\n    if (this.getExpiration() === 0) {\n      return 0\n    }\n\n    let keyMarker: string | undefined = undefined\n    let uploadIdMarker: string | undefined = undefined\n    let isTruncated = true\n    let deleted = 0\n\n    while (isTruncated) {\n      const listResponse: AWS.ListMultipartUploadsCommandOutput =\n        await this.client.listMultipartUploads({\n          Bucket: this.bucket,\n          KeyMarker: keyMarker,\n          UploadIdMarker: uploadIdMarker,\n        })\n\n      const expiredUploads =\n        listResponse.Uploads?.filter((multiPartUpload: AWS.MultipartUpload) => {\n          const initiatedDate = multiPartUpload.Initiated\n          return (\n            initiatedDate &&\n            new Date().getTime() >\n              this.getExpirationDate({\n                createdAt: initiatedDate.toISOString(),\n              }).getTime()\n          )\n        }) || []\n\n      const objectsToDelete = expiredUploads.reduce(\n        (all: { Key: string }[], expiredUpload: AWS.MultipartUpload) => {\n          all.push(\n            {\n              Key: this.generateInfoKey(expiredUpload.Key as string),\n            },\n            {\n              Key: this.generatePartKey(expiredUpload.Key as string, true),\n            }\n          )\n          return all\n        },\n        [] as { Key: string }[]\n      )\n\n      const deletions: Promise<AWS.DeleteObjectsCommandOutput>[] = []\n\n      if (objectsToDelete.length > 0) {\n        deletions.push(\n          this.client.deleteObjects({\n            Bucket: this.bucket,\n            Delete: {\n              Objects: objectsToDelete,\n            },\n          })\n        )\n      }\n\n      const abortions = expiredUploads.map(\n        (expiredUpload: AWS.MultipartUpload) =>\n          this.client.abortMultipartUpload({\n            Bucket: this.bucket,\n            Key: expiredUpload.Key,\n            UploadId: expiredUpload.UploadId,\n          })\n      )\n\n      await Promise.all([...deletions, ...abortions])\n\n      deleted += expiredUploads.length\n\n      isTruncated = listResponse.IsTruncated || false\n      keyMarker = listResponse.NextKeyMarker\n      uploadIdMarker = listResponse.NextUploadIdMarker\n    }\n\n    return deleted\n  }\n}\n"],"mappings":";AAOA,IAAa,sBAAb,MAAiC;CAC/B,YACUA,QACAC,QACAC,gCACAC,iBACAC,iBACR;EALQ;EACA;EACA;EACA;EACA;CACN;;;;;;;CAQJ,kBAAkBC,MAAmC;EACnD,MAAM,EAAE,WAAW,GAAG;EACtB,MAAM,OAAO,IAAI,KAAK;AACtB,SAAO,IAAI,KAAK,KAAK,SAAS,GAAG,KAAK;CACvC;;;;;CAMD,gBAAwB;AACtB,SAAO,KAAK;CACb;;;;;;;CAQD,MAAM,gBAAiC;AAErC,MAAI,KAAK,eAAe,KAAK,EAC3B,QAAO;EAGT,IAAIC,YAAgC;EACpC,IAAIC,iBAAqC;EACzC,IAAI,cAAc;EAClB,IAAI,UAAU;AAEd,SAAO,aAAa;GAClB,MAAMC,eACJ,MAAM,KAAK,OAAO,qBAAqB;IACrC,QAAQ,KAAK;IACb,WAAW;IACX,gBAAgB;GACjB,EAAC;GAEJ,MAAM,iBACJ,aAAa,SAAS,OAAO,CAACC,oBAAyC;IACrE,MAAM,gBAAgB,gBAAgB;AACtC,WACE,kCACA,IAAI,QAAO,SAAS,GAClB,KAAK,kBAAkB,EACrB,WAAW,cAAc,aAAa,CACvC,EAAC,CAAC,SAAS;GAEjB,EAAC,IAAI,CAAE;GAEV,MAAM,kBAAkB,eAAe,OACrC,CAACC,KAAwBC,kBAAuC;IAC9D,IAAI,KACF,EACE,KAAK,KAAK,gBAAgB,cAAc,IAAc,CACvD,GACD,EACE,KAAK,KAAK,gBAAgB,cAAc,KAAe,KAAK,CAC7D,EACF;AACD,WAAO;GACR,GACD,CAAE,EACH;GAED,MAAMC,YAAuD,CAAE;AAE/D,OAAI,gBAAgB,SAAS,GAC3B,UAAU,KACR,KAAK,OAAO,cAAc;IACxB,QAAQ,KAAK;IACb,QAAQ,EACN,SAAS,gBACV;GACF,EAAC,CACH;GAGH,MAAM,YAAY,eAAe,IAC/B,CAACD,kBACC,KAAK,OAAO,qBAAqB;IAC/B,QAAQ,KAAK;IACb,KAAK,cAAc;IACnB,UAAU,cAAc;GACzB,EAAC,CACL;GAED,MAAM,QAAQ,IAAI,CAAC,GAAG,WAAW,GAAG,SAAU,EAAC;GAE/C,WAAW,eAAe;GAE1B,cAAc,aAAa,eAAe;GAC1C,YAAY,aAAa;GACzB,iBAAiB,aAAa;EAC/B;AAED,SAAO;CACR;AACF"}

package/dist/tus/stores/s3/file-operations.d.ts

@@ -0,0 +1,66 @@
+import AWS from "@aws-sdk/client-s3";
+
+//#region src/tus/stores/s3/file-operations.d.ts
+type CalculateOptimalPartSizeArgs = {
+  size?: number;
+};
+type CalculateOffsetFromPartsArgs = {
+  parts?: Array<AWS.Part>;
+};
+type CalculatePartNumberArgs = {
+  parts: Array<AWS.Part>;
+};
+type GenerateUniqueTmpFileNameArgs = {
+  template: string;
+};
+type CalculateOffsetFromPartsExportArgs = {
+  parts?: Array<{
+    Size?: number;
+  }>;
+};
+declare class S3FileOperations {
+  private maxMultipartParts;
+  private maxUploadSize;
+  private minPartSize;
+  private preferredPartSize;
+  constructor(maxMultipartParts: number, maxUploadSize: number, minPartSize: number, preferredPartSize: number);
+  /**
+   * Calculates the optimal part size for S3 multipart upload
+   * @param args - The function arguments
+   * @param args.size - The upload size in bytes (optional)
+   * @returns The optimal part size in bytes
+   */
+  calculateOptimalPartSize(args: CalculateOptimalPartSizeArgs): number;
+  /**
+   * Calculates the offset based on uploaded parts
+   * @param args - The function arguments
+   * @param args.parts - Array of uploaded parts (optional)
+   * @returns The total offset in bytes
+   */
+  calculateOffsetFromParts(args: CalculateOffsetFromPartsArgs): number;
+  /**
+   * Calculates the next part number based on existing parts
+   * @param args - The function arguments
+   * @param args.parts - Array of uploaded parts
+   * @returns The next part number to use
+   */
+  calculatePartNumber(args: CalculatePartNumberArgs): number;
+  /**
+   * Generates a unique temporary file name
+   * @param args - The function arguments
+   * @param args.template - The template string for the file name
+   * @returns Promise that resolves to the unique file path
+   * @throws Error if unable to find unique name after max tries
+   */
+  generateUniqueTmpFileName(args: GenerateUniqueTmpFileNameArgs): Promise<string>;
+}
+/**
+ * Calculates the total offset from uploaded parts
+ * @param args - The function arguments
+ * @param args.parts - Array of parts with size information (optional)
+ * @returns The total offset in bytes
+ */
+declare function calculateOffsetFromParts(args: CalculateOffsetFromPartsExportArgs): number;
+//#endregion
+export { S3FileOperations, calculateOffsetFromParts };
+//# sourceMappingURL=file-operations.d.ts.map

package/dist/tus/stores/s3/file-operations.js

@@ -0,0 +1,90 @@
+import { MediaCloudError } from "../../../types/errors.js";
+import { useErrorHandler } from "../../../hooks/useErrorHandler.js";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+//#region src/tus/stores/s3/file-operations.ts
+const { throwError } = useErrorHandler();
+var S3FileOperations = class {
+	constructor(maxMultipartParts, maxUploadSize, minPartSize, preferredPartSize) {
+		this.maxMultipartParts = maxMultipartParts;
+		this.maxUploadSize = maxUploadSize;
+		this.minPartSize = minPartSize;
+		this.preferredPartSize = preferredPartSize;
+	}
+	/**
+	* Calculates the optimal part size for S3 multipart upload
+	* @param args - The function arguments
+	* @param args.size - The upload size in bytes (optional)
+	* @returns The optimal part size in bytes
+	*/
+	calculateOptimalPartSize(args) {
+		const { size } = args;
+		let uploadSize = size;
+		if (uploadSize === void 0) uploadSize = this.maxUploadSize;
+		let optimalPartSize;
+		if (uploadSize <= this.preferredPartSize) optimalPartSize = uploadSize;
+		else if (uploadSize <= this.preferredPartSize * this.maxMultipartParts) optimalPartSize = this.preferredPartSize;
+		else optimalPartSize = Math.ceil(uploadSize / this.maxMultipartParts);
+		return Math.max(optimalPartSize, this.minPartSize);
+	}
+	/**
+	* Calculates the offset based on uploaded parts
+	* @param args - The function arguments
+	* @param args.parts - Array of uploaded parts (optional)
+	* @returns The total offset in bytes
+	*/
+	calculateOffsetFromParts(args) {
+		const { parts } = args;
+		return parts && parts.length > 0 ? parts.reduce((a, b) => a + (b.Size ?? 0), 0) : 0;
+	}
+	/**
+	* Calculates the next part number based on existing parts
+	* @param args - The function arguments
+	* @param args.parts - Array of uploaded parts
+	* @returns The next part number to use
+	*/
+	calculatePartNumber(args) {
+		const { parts } = args;
+		return parts.length > 0 ? parts[parts.length - 1].PartNumber + 1 : 1;
+	}
+	/**
+	* Generates a unique temporary file name
+	* @param args - The function arguments
+	* @param args.template - The template string for the file name
+	* @returns Promise that resolves to the unique file path
+	* @throws Error if unable to find unique name after max tries
+	*/
+	async generateUniqueTmpFileName(args) {
+		const { template } = args;
+		const tries = 5;
+		for (let i = 0; i < tries; i++) {
+			const randomId = crypto.randomBytes(16).toString("hex");
+			const filePath = path.join(os.tmpdir(), `${template}${randomId}`);
+			try {
+				await fs.promises.access(filePath, fs.constants.F_OK);
+			} catch (error) {
+				const nodeError = error;
+				if (nodeError.code === "ENOENT") return filePath;
+			}
+		}
+		throwError(MediaCloudError.S3_UNIQUE_NAME_ERROR);
+		throw new Error();
+	}
+};
+/**
+* Calculates the total offset from uploaded parts
+* @param args - The function arguments
+* @param args.parts - Array of parts with size information (optional)
+* @returns The total offset in bytes
+*/
+function calculateOffsetFromParts(args) {
+	const { parts } = args;
+	return parts && parts.length > 0 ? parts.reduce((a, b) => a + (b.Size ?? 0), 0) : 0;
+}
+
+//#endregion
+export { S3FileOperations, calculateOffsetFromParts };
+//# sourceMappingURL=file-operations.js.map

package/dist/tus/stores/s3/file-operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-operations.js","names":["maxMultipartParts: number","maxUploadSize: number","minPartSize: number","preferredPartSize: number","args: CalculateOptimalPartSizeArgs","optimalPartSize: number","args: CalculateOffsetFromPartsArgs","args: CalculatePartNumberArgs","args: GenerateUniqueTmpFileNameArgs","args: CalculateOffsetFromPartsExportArgs"],"sources":["../../../../src/tus/stores/s3/file-operations.ts"],"sourcesContent":["import crypto from 'node:crypto'\nimport fs from 'node:fs'\nimport os from 'node:os'\nimport path from 'node:path'\n\nimport { useErrorHandler } from '../../../hooks/useErrorHandler'\nimport { MediaCloudError } from '../../../types/errors'\n\nimport type { NodeFSError } from '../../../types'\nimport type AWS from '@aws-sdk/client-s3'\n\ntype CalculateOptimalPartSizeArgs = {\n  size?: number\n}\n\ntype CalculateOffsetFromPartsArgs = {\n  parts?: Array<AWS.Part>\n}\n\ntype CalculatePartNumberArgs = {\n  parts: Array<AWS.Part>\n}\n\ntype GenerateUniqueTmpFileNameArgs = {\n  template: string\n}\n\ntype CalculateOffsetFromPartsExportArgs = {\n  parts?: Array<{ Size?: number }>\n}\n\nconst { throwError } = useErrorHandler()\n\nexport class S3FileOperations {\n  constructor(\n    private maxMultipartParts: number,\n    private maxUploadSize: number,\n    private minPartSize: number,\n    private preferredPartSize: number\n  ) {}\n\n  /**\n   * Calculates the optimal part size for S3 multipart upload\n   * @param args - The function arguments\n   * @param args.size - The upload size in bytes (optional)\n   * @returns The optimal part size in bytes\n   */\n  calculateOptimalPartSize(args: CalculateOptimalPartSizeArgs): number {\n    const { size } = args\n    // When upload size is not known we assume largest possible value (`maxUploadSize`)\n    let uploadSize = size\n    if (uploadSize === undefined) {\n      uploadSize = this.maxUploadSize\n    }\n\n    let optimalPartSize: number\n\n    // When upload is smaller or equal to PreferredPartSize, we upload in just one part.\n    if (uploadSize <= this.preferredPartSize) {\n      optimalPartSize = uploadSize\n    }\n    // Does the upload fit in MaxMultipartParts parts or less with PreferredPartSize.\n    else if (uploadSize <= this.preferredPartSize * this.maxMultipartParts) {\n      optimalPartSize = this.preferredPartSize\n      // The upload is too big for the preferred size.\n      // We divide the size with the max amount of parts and round it up.\n    } else {\n      optimalPartSize = Math.ceil(uploadSize / this.maxMultipartParts)\n    }\n\n    // Always ensure the part size is at least minPartSize\n    return Math.max(optimalPartSize, this.minPartSize)\n  }\n\n  /**\n   * Calculates the offset based on uploaded parts\n   * @param args - The function arguments\n   * @param args.parts - Array of uploaded parts (optional)\n   * @returns The total offset in bytes\n   */\n  calculateOffsetFromParts(args: CalculateOffsetFromPartsArgs): number {\n    const { parts } = args\n    return parts && parts.length > 0\n      ? parts.reduce((a, b) => a + (b.Size ?? 0), 0)\n      : 0\n  }\n\n  /**\n   * Calculates the next part number based on existing parts\n   * @param args - The function arguments\n   * @param args.parts - Array of uploaded parts\n   * @returns The next part number to use\n   */\n  calculatePartNumber(args: CalculatePartNumberArgs): number {\n    const { parts } = args\n    return parts.length > 0 ? parts[parts.length - 1].PartNumber! + 1 : 1\n  }\n\n  /**\n   * Generates a unique temporary file name\n   * @param args - The function arguments\n   * @param args.template - The template string for the file name\n   * @returns Promise that resolves to the unique file path\n   * @throws Error if unable to find unique name after max tries\n   */\n  async generateUniqueTmpFileName(\n    args: GenerateUniqueTmpFileNameArgs\n  ): Promise<string> {\n    const { template } = args\n    const tries = 5\n    for (let i = 0; i < tries; i++) {\n      const randomId = crypto.randomBytes(16).toString('hex')\n      const filePath = path.join(os.tmpdir(), `${template}${randomId}`)\n      try {\n        await fs.promises.access(filePath, fs.constants.F_OK)\n      } catch (error) {\n        const nodeError = error as NodeFSError\n        if (nodeError.code === 'ENOENT') {\n          return filePath\n        }\n      }\n    }\n    throwError(MediaCloudError.S3_UNIQUE_NAME_ERROR)\n    throw new Error() // This will never execute but satisfies TypeScript\n  }\n}\n\n/**\n * Calculates the total offset from uploaded parts\n * @param args - The function arguments\n * @param args.parts - Array of parts with size information (optional)\n * @returns The total offset in bytes\n */\nexport function calculateOffsetFromParts(\n  args: CalculateOffsetFromPartsExportArgs\n) {\n  const { parts } = args\n  return parts && parts.length > 0\n    ? parts.reduce((a, b) => a + (b.Size ?? 0), 0)\n    : 0\n}\n"],"mappings":";;;;;;;;AA+BA,MAAM,EAAE,YAAY,GAAG,iBAAiB;AAExC,IAAa,mBAAb,MAA8B;CAC5B,YACUA,mBACAC,eACAC,aACAC,mBACR;EAJQ;EACA;EACA;EACA;CACN;;;;;;;CAQJ,yBAAyBC,MAA4C;EACnE,MAAM,EAAE,MAAM,GAAG;EAEjB,IAAI,aAAa;AACjB,MAAI,eAAe,QACjB,aAAa,KAAK;EAGpB,IAAIC;AAGJ,MAAI,cAAc,KAAK,mBACrB,kBAAkB;WAGX,cAAc,KAAK,oBAAoB,KAAK,mBACnD,kBAAkB,KAAK;OAIvB,kBAAkB,KAAK,KAAK,aAAa,KAAK,kBAAkB;AAIlE,SAAO,KAAK,IAAI,iBAAiB,KAAK,YAAY;CACnD;;;;;;;CAQD,yBAAyBC,MAA4C;EACnE,MAAM,EAAE,OAAO,GAAG;AAClB,SAAO,SAAS,MAAM,SAAS,IAC3B,MAAM,OAAO,CAAC,GAAG,MAAM,KAAK,EAAE,QAAQ,IAAI,EAAE,GAC5C;CACL;;;;;;;CAQD,oBAAoBC,MAAuC;EACzD,MAAM,EAAE,OAAO,GAAG;AAClB,SAAO,MAAM,SAAS,IAAI,MAAM,MAAM,SAAS,GAAG,aAAc,IAAI;CACrE;;;;;;;;CASD,MAAM,0BACJC,MACiB;EACjB,MAAM,EAAE,UAAU,GAAG;EACrB,MAAM,QAAQ;AACd,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK;GAC9B,MAAM,WAAW,OAAO,YAAY,GAAG,CAAC,SAAS,MAAM;GACvD,MAAM,WAAW,KAAK,KAAK,GAAG,QAAQ,EAAE,GAAG,WAAW,UAAU,CAAC;AACjE,OAAI;IACF,MAAM,GAAG,SAAS,OAAO,UAAU,GAAG,UAAU,KAAK;GACtD,SAAQ,OAAO;IACd,MAAM,YAAY;AAClB,QAAI,UAAU,SAAS,SACrB,QAAO;GAEV;EACF;EACD,WAAW,gBAAgB,qBAAqB;AAChD,QAAM,IAAI;CACX;AACF;;;;;;;AAQD,SAAgB,yBACdC,MACA;CACA,MAAM,EAAE,OAAO,GAAG;AAClB,QAAO,SAAS,MAAM,SAAS,IAC3B,MAAM,OAAO,CAAC,GAAG,MAAM,KAAK,EAAE,QAAQ,IAAI,EAAE,GAC5C;AACL"}

package/dist/tus/stores/s3/log.d.ts

@@ -0,0 +1,5 @@
+//#region src/tus/stores/s3/log.d.ts
+declare function log(message: string, ...args: unknown[]): void;
+//#endregion
+export { log };
+//# sourceMappingURL=log.d.ts.map

package/dist/tus/stores/s3/log.js

@@ -0,0 +1,8 @@
+//#region src/tus/stores/s3/log.ts
+function log(message, ...args) {
+	console.log(`tus:stores:s3store - ${message}`, ...args);
+}
+
+//#endregion
+export { log };
+//# sourceMappingURL=log.js.map

package/dist/tus/stores/s3/log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.js","names":["message: string"],"sources":["../../../../src/tus/stores/s3/log.ts"],"sourcesContent":["export function log(message: string, ...args: unknown[]) {\n  console.log(`tus:stores:s3store - ${message}`, ...args)\n}\n"],"mappings":";AAAA,SAAgB,IAAIA,SAAiB,GAAG,MAAiB;CACvD,QAAQ,IAAI,CAAC,qBAAqB,EAAE,SAAS,EAAE,GAAG,KAAK;AACxD"}