snapshot of https://github.com/RocketChat/Rocket.Chat.git (develop, 2026-09-16; blobs > 131072B omitted)

apps/meteor/server/lib/media/file-upload/ufs/AmazonS3/server.ts

@@ -0,0 +1,212 @@
+import stream from 'node:stream';
+
+import {
+	DeleteObjectCommand,
+	GetObjectCommand,
+	S3Client,
+	type GetObjectCommandInput,
+	type PutObjectCommandInput,
+	type S3ClientConfig,
+} from '@aws-sdk/client-s3';
+import { Upload } from '@aws-sdk/lib-storage';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import type { IUpload } from '@rocket.chat/core-typings';
+import { Random } from '@rocket.chat/random';
+import { check } from 'meteor/check';
+import _ from 'underscore';
+
+import { UploadFS } from '../../../../../ufs';
+import type { StoreOptions } from '../../../../../ufs/ufs-store';
+import { SystemLogger } from '../../../../logger/system';
+import { getUrlExpiryTimeSpanWithFallback } from '../../lib/urlExpiry';
+
+export type S3Options = StoreOptions & {
+	connection: S3ClientConfig;
+	params: {
+		Bucket: string;
+		ACL: string;
+	};
+	URLExpiryTimeSpan: number;
+	getPath: (file: Omit<IUpload, '_updatedAt'>) => string;
+};
+
+class AmazonS3Store extends UploadFS.Store {
+	protected getPath: (file: Omit<IUpload, '_updatedAt'>) => string;
+
+	constructor(options: S3Options) {
+		// Default options
+		// options.secretAccessKey,
+		// options.accessKeyId,
+		// options.region,
+		// options.sslEnabled // optional
+
+		options = _.extend(
+			{
+				httpOptions: {
+					timeout: 6000,
+					agent: false,
+				},
+			},
+			options,
+		);
+
+		super(options);
+
+		const classOptions = options;
+
+		const customUserAgent = process.env.FILE_STORAGE_CUSTOM_USER_AGENT?.trim();
+
+		const s3 = new S3Client({
+			...options.connection,
+			...(customUserAgent && { customUserAgent }),
+		});
+
+		options.getPath =
+			options.getPath ||
+			function (file) {
+				return file._id;
+			};
+
+		this.getPath = function (file) {
+			if (file.AmazonS3) {
+				return file.AmazonS3.path;
+			}
+			// Compatibility
+			// TODO: Migration
+			if (file.s3) {
+				return file.s3.path + file._id;
+			}
+
+			return file._id;
+		};
+
+		this.getRedirectURL = async (file, forceDownload = false) => {
+			const expiresIn = getUrlExpiryTimeSpanWithFallback(classOptions.URLExpiryTimeSpan);
+			return getSignedUrl(
+				s3,
+				new GetObjectCommand({
+					Key: this.getPath(file),
+					ResponseContentDisposition: `${forceDownload ? 'attachment' : 'inline'}; filename="${encodeURI(file.name || '')}"`,
+					Bucket: classOptions.params.Bucket,
+				}),
+				{ expiresIn },
+			);
+		};
+
+		/**
+		 * Creates the file in the collection
+		 */
+		this.create = async (file) => {
+			check(file, Object);
+
+			if (file._id == null) {
+				file._id = Random.id();
+			}
+
+			file.AmazonS3 = {
+				path: classOptions.getPath(file as Omit<IUpload, '_updatedAt'>),
+			};
+
+			file.store = this.options.name; // assign store to file
+
+			return (await this.getCollection().insertOne(file)).insertedId;
+		};
+
+		/**
+		 * Removes the file
+		 */
+		this.delete = async function (fileId) {
+			const file = await this.getCollection().findOne({ _id: fileId });
+			if (!file) {
+				throw new Error('File not found');
+			}
+
+			try {
+				return await s3.send(
+					new DeleteObjectCommand({
+						Key: this.getPath(file),
+						Bucket: classOptions.params.Bucket,
+					}),
+				);
+			} catch (error) {
+				SystemLogger.error({ error, key: this.getPath(file), bucket: classOptions.params.Bucket });
+				throw error;
+			}
+		};
+
+		/**
+		 * Returns the file read stream
+		 */
+		this.getReadStream = async function (_fileId, file, options = {}) {
+			const params: GetObjectCommandInput = {
+				Key: this.getPath(file),
+				Bucket: classOptions.params.Bucket,
+			};
+
+			if (options.start != null && options.end != null) {
+				params.Range = `bytes=${options.start}-${options.end}`;
+			}
+
+			const response = await s3.send(new GetObjectCommand(params));
+
+			if (!response.Body) {
+				throw new Error('File not found');
+			}
+
+			if (!('readable' in response.Body)) {
+				throw new Error('Response body is not a readable stream');
+			}
+
+			return response.Body;
+		};
+
+		/**
+		 * Returns the file write stream
+		 */
+		this.getWriteStream = async function (_fileId, file /* , options*/) {
+			const writeStream = new stream.PassThrough();
+
+			writeStream.on('newListener', (event, listener) => {
+				if (event === 'finish') {
+					process.nextTick(() => {
+						writeStream.removeListener(event, listener);
+						writeStream.on('real_finish', listener);
+					});
+				}
+			});
+
+			const uploadParams: PutObjectCommandInput = {
+				Key: this.getPath(file),
+				Body: writeStream,
+				Bucket: classOptions.params.Bucket,
+				...(file.type && { ContentType: file.type }),
+				...(file.size != null && { ContentLength: file.size }),
+				...(classOptions.params.ACL && { ACL: classOptions.params.ACL as PutObjectCommandInput['ACL'] }),
+			};
+
+			const upload = new Upload({
+				client: s3,
+				params: uploadParams,
+			});
+
+			upload
+				.done()
+				.then(() => {
+					writeStream.emit('real_finish');
+				})
+				.catch((error) => {
+					SystemLogger.error({ err: error });
+					writeStream.emit('error', error);
+				});
+
+			return writeStream;
+		};
+
+		this.getUrlExpiryTimeSpan = async () => {
+			return getUrlExpiryTimeSpanWithFallback(classOptions.URLExpiryTimeSpan);
+		};
+	}
+}
+
+// Add store to UFS namespace
+UploadFS.store.AmazonS3 = AmazonS3Store;

apps/meteor/server/lib/media/file-upload/ufs/GoogleStorage/server.ts

@@ -0,0 +1,163 @@
+import type { GetSignedUrlConfig } from '@google-cloud/storage';
+import { Storage } from '@google-cloud/storage';
+import type { IUpload } from '@rocket.chat/core-typings';
+import { Random } from '@rocket.chat/random';
+import { check } from 'meteor/check';
+
+import { UploadFS } from '../../../../../ufs';
+import type { StoreOptions } from '../../../../../ufs/ufs-store';
+import { SystemLogger } from '../../../../logger/system';
+import { getUrlExpiryTimeSpanWithFallback } from '../../lib/urlExpiry';
+
+type GStoreOptions = StoreOptions & {
+	connection: {
+		credentials: {
+			client_email: string;
+			private_key: string;
+			projectId: string;
+		};
+	};
+	bucket: string;
+	URLExpiryTimeSpan: number;
+	getPath: (file: Omit<IUpload, '_updatedAt'>) => string;
+};
+
+class GoogleStorageStore extends UploadFS.Store {
+	protected getPath: (file: Omit<IUpload, '_updatedAt'>) => string;
+
+	constructor(options: GStoreOptions) {
+		super(options);
+
+		const userAgent = process.env.FILE_STORAGE_CUSTOM_USER_AGENT?.trim();
+
+		const gcs = new Storage({
+			...(userAgent && { userAgent }),
+			...options.connection,
+		});
+		const bucket = gcs.bucket(options.bucket);
+
+		options.getPath =
+			options.getPath ||
+			function (file) {
+				return file._id;
+			};
+
+		this.getPath = function (file) {
+			if (file.GoogleStorage) {
+				return file.GoogleStorage.path;
+			}
+			// Compatibility
+			// TODO: Migration
+			if (file.googleCloudStorage) {
+				return file.googleCloudStorage.path + file._id;
+			}
+
+			return file._id;
+		};
+
+		this.getRedirectURL = async (file, forceDownload = false) => {
+			const expirySeconds = getUrlExpiryTimeSpanWithFallback(options.URLExpiryTimeSpan);
+			const params: GetSignedUrlConfig = {
+				action: 'read',
+				responseDisposition: forceDownload ? 'attachment' : 'inline',
+				version: 'v2',
+				expires: Date.now() + expirySeconds * 1000,
+			};
+
+			const res = await bucket.file(this.getPath(file)).getSignedUrl(params);
+			return res[0];
+		};
+
+		this.getUrlExpiryTimeSpan = async () => {
+			return getUrlExpiryTimeSpanWithFallback(options.URLExpiryTimeSpan);
+		};
+
+		/**
+		 * Creates the file in the collection
+		 * @param file
+		 * @param callback
+		 * @return {string}
+		 */
+		this.create = async function (file) {
+			check(file, Object);
+
+			if (file._id == null) {
+				file._id = Random.id();
+			}
+
+			file.GoogleStorage = {
+				path: options.getPath(file as Omit<IUpload, '_updatedAt'>),
+			};
+
+			file.store = this.options.name; // assign store to file
+
+			return (await this.getCollection().insertOne(file)).insertedId;
+		};
+
+		/**
+		 * Removes the file
+		 * @param fileId
+		 * @param callback
+		 */
+		this.delete = async function (fileId) {
+			// TODO
+			const file = await this.getCollection().findOne({ _id: fileId });
+			if (!file) {
+				throw new Error('File not found');
+			}
+
+			try {
+				return bucket.file(this.getPath(file)).delete();
+			} catch (err: any) {
+				SystemLogger.error({ err });
+			}
+		};
+
+		/**
+		 * Returns the file read stream
+		 * @param fileId
+		 * @param file
+		 * @param options
+		 * @return {*}
+		 */
+		this.getReadStream = async function (_fileId, file, options = {}) {
+			const config: {
+				start?: number;
+				end?: number;
+			} = {};
+
+			if (options.start != null) {
+				config.start = options.start;
+			}
+
+			if (options.end != null) {
+				config.end = options.end;
+			}
+
+			return bucket.file(this.getPath(file)).createReadStream(config);
+		};
+
+		/**
+		 * Returns the file write stream
+		 * @param fileId
+		 * @param file
+		 * @param options
+		 * @return {*}
+		 */
+		this.getWriteStream = async function (_fileId, file /* , options*/) {
+			return bucket.file(this.getPath(file)).createWriteStream({
+				gzip: false,
+				metadata: {
+					contentType: file.type,
+					contentDisposition: `inline; filename=${file.name}`,
+					// metadata: {
+					// 	custom: 'metadata'
+					// }
+				},
+			});
+		};
+	}
+}
+
+// Add store to UFS namespace
+UploadFS.store.GoogleStorage = GoogleStorageStore;

apps/meteor/server/lib/media/file-upload/ufs/Webdav/server.ts

@@ -0,0 +1,154 @@
+import stream from 'node:stream';
+
+import type { IUpload } from '@rocket.chat/core-typings';
+import { Random } from '@rocket.chat/random';
+import { check } from 'meteor/check';
+
+import { WebdavClientAdapter } from '../../../../../bridges/webdav/lib/webdavClientAdapter';
+import { UploadFS } from '../../../../../ufs';
+import type { StoreOptions } from '../../../../../ufs/ufs-store';
+import { SystemLogger } from '../../../../logger/system';
+
+type WebdavOptions = StoreOptions & {
+	connection: {
+		credentials: {
+			server: string;
+			username: string;
+			password: string;
+		};
+	};
+	uploadFolderPath: string;
+	getPath: (file: Omit<IUpload, '_updatedAt'>) => string;
+};
+
+class WebdavStore extends UploadFS.Store {
+	protected getPath: (file: Omit<IUpload, '_updatedAt'>) => string;
+
+	constructor(options: WebdavOptions) {
+		super(options);
+		const { server, username, password } = options.connection.credentials;
+		const client = new WebdavClientAdapter(server, { username, password });
+
+		options.getPath = function (file) {
+			if (options.uploadFolderPath[options.uploadFolderPath.length - 1] !== '/') {
+				options.uploadFolderPath += '/';
+			}
+			return options.uploadFolderPath + file._id;
+		};
+
+		client.stat(options.uploadFolderPath).catch((err) => {
+			if (err.message.toLowerCase() === 'not found') {
+				void client.createDirectory(options.uploadFolderPath);
+			} else if (err.message.toLowerCase() === 'unauthorized') {
+				console.warn('File upload is unauthorized to connect on Webdav, please verify your credentials');
+			}
+		});
+
+		/**
+		 * Returns the file path
+		 * @param file
+		 * @return {string}
+		 */
+		this.getPath = function (file) {
+			if (file.Webdav) {
+				return file.Webdav.path;
+			}
+
+			return file._id;
+		};
+
+		/**
+		 * Creates the file in the col lection
+		 * @param file
+		 * @param callback
+		 * @return {string}
+		 */
+		this.create = async function (file) {
+			check(file, Object);
+
+			if (file._id == null) {
+				file._id = Random.id();
+			}
+
+			file.Webdav = {
+				path: options.getPath(file as Omit<IUpload, '_updatedAt'>),
+			};
+
+			file.store = this.options.name;
+
+			return (await this.getCollection().insertOne(file)).insertedId;
+		};
+
+		/**
+		 * Removes the file
+		 * @param fileId
+		 * @param callback
+		 */
+		this.delete = async function (fileId) {
+			const file = await this.getCollection().findOne({ _id: fileId });
+			if (!file) {
+				throw new Error('File no found');
+			}
+
+			try {
+				return client.deleteFile(this.getPath(file));
+			} catch (err: any) {
+				SystemLogger.error({ err });
+			}
+		};
+
+		/**
+		 * Returns the file read stream
+		 * @param fileId
+		 * @param file
+		 * @param options
+		 * @return {*}
+		 */
+		this.getReadStream = async function (_fileId, file, options = {}) {
+			const range: {
+				start?: number;
+				end?: number;
+			} = {};
+
+			if (options.start != null) {
+				range.start = options.start;
+			}
+
+			if (options.end != null) {
+				range.end = options.end;
+			}
+			return client.createReadStream(this.getPath(file), options);
+		};
+
+		/**
+		 * Returns the file write stream
+		 * @param fileId
+		 * @param file
+		 * @return {*}
+		 */
+		this.getWriteStream = async function (_fileId, file) {
+			const writeStream = new stream.PassThrough();
+			const webdavStream = client.createWriteStream(this.getPath(file), file.size || 0);
+
+			// TODO remove timeout when UploadFS bug resolved
+			const newListenerCallback = (event: string, listener: () => any) => {
+				if (event === 'finish') {
+					process.nextTick(() => {
+						writeStream.removeListener(event, listener);
+						writeStream.removeListener('newListener', newListenerCallback);
+						writeStream.on(event, () => {
+							setTimeout(listener, 500);
+						});
+					});
+				}
+			};
+			writeStream.on('newListener', newListenerCallback);
+
+			writeStream.pipe(webdavStream);
+			return writeStream;
+		};
+	}
+}
+
+// Add store to UFS namespace
+UploadFS.store.Webdav = WebdavStore;