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

apps/meteor/server/api/v1/custom-sounds.ts

@@ -0,0 +1,339 @@
+import type { ICustomSound } from '@rocket.chat/core-typings';
+import { CustomSounds } from '@rocket.chat/models';
+import type { PaginatedResult } from '@rocket.chat/rest-typings';
+import {
+	isCustomSoundsGetOneProps,
+	isCustomSoundsListProps,
+	isCustomSoundsCreateProps,
+	isCustomSoundsDeleteProps,
+	isCustomSoundsUpdateProps,
+	ajv,
+	validateBadRequestErrorResponse,
+	validateNotFoundErrorResponse,
+	validateForbiddenErrorResponse,
+	validateUnauthorizedErrorResponse,
+	validateInternalErrorResponse,
+} from '@rocket.chat/rest-typings';
+import { escapeRegExp } from '@rocket.chat/tools';
+import { Meteor } from 'meteor/meteor';
+
+import { getExtension, getMimeTypeFromFileName } from '../../../app/utils/lib/mimeTypes';
+import { MAX_CUSTOM_SOUND_SIZE_BYTES, CUSTOM_SOUND_ALLOWED_MIME_TYPES } from '../../../lib/constants';
+import { SystemLogger } from '../../lib/logger/system';
+import { deleteCustomSound } from '../../lib/media/custom-sounds/lib/deleteCustomSound';
+import { insertOrUpdateSound } from '../../lib/media/custom-sounds/lib/insertOrUpdateSound';
+import { uploadCustomSound } from '../../lib/media/custom-sounds/lib/uploadCustomSound';
+import type { ExtractRoutesFromAPI } from '../ApiClass';
+import { API } from '../api';
+import { getPaginationItems } from '../lib/getPaginationItems';
+import { getUploadFormData } from '../lib/getUploadFormData';
+
+const createCustomSoundsResponse = ajv.compile<{ sound: Pick<ICustomSound, '_id'>; success: boolean }>({
+	additionalProperties: false,
+	type: 'object',
+	properties: {
+		success: {
+			type: 'boolean',
+			description: 'Indicates if the request was successful.',
+		},
+		sound: {
+			type: 'object',
+			properties: {
+				_id: {
+					type: 'string',
+					description: 'The ID of the sound.',
+				},
+			},
+			required: ['_id'],
+		},
+	},
+	required: ['success', 'sound'],
+});
+
+const updateCustomSoundsResponse = ajv.compile<{ success: boolean }>({
+	additionalProperties: false,
+	type: 'object',
+	properties: {
+		success: {
+			type: 'boolean',
+			description: 'Indicates if the request was successful.',
+		},
+	},
+	required: ['success'],
+});
+
+const deleteCustomSoundsResponse = ajv.compile<void>({
+	additionalProperties: false,
+	type: 'object',
+	properties: {
+		success: {
+			type: 'boolean',
+			description: 'Indicates if the request was successful.',
+		},
+	},
+	required: ['success'],
+});
+
+const customSoundsEndpoints = API.v1
+	.get(
+		'custom-sounds.list',
+		{
+			response: {
+				400: validateBadRequestErrorResponse,
+				401: validateUnauthorizedErrorResponse,
+				403: validateForbiddenErrorResponse,
+				200: ajv.compile<
+					PaginatedResult<{
+						sounds: ICustomSound[];
+					}>
+				>({
+					additionalProperties: false,
+					type: 'object',
+					properties: {
+						count: {
+							type: 'number',
+							description: 'The number of sounds returned in this response.',
+						},
+						offset: {
+							type: 'number',
+							description: 'The number of sounds that were skipped in this response.',
+						},
+						total: {
+							type: 'number',
+							description: 'The total number of sounds that match the query.',
+						},
+						success: {
+							type: 'boolean',
+							description: 'Indicates if the request was successful.',
+						},
+						sounds: {
+							type: 'array',
+							items: {
+								$ref: '#/components/schemas/ICustomSound',
+							},
+						},
+					},
+					required: ['count', 'offset', 'total', 'sounds', 'success'],
+				}),
+			},
+			query: isCustomSoundsListProps,
+			authRequired: true,
+		},
+		async function action() {
+			const { offset, count } = await getPaginationItems(this.queryParams);
+			const { sort, query } = await this.parseJsonQuery();
+
+			const { name } = this.queryParams;
+
+			const filter = {
+				...query,
+				...(name ? { name: { $regex: escapeRegExp(name), $options: 'i' } } : {}),
+			};
+
+			const { cursor, totalCount } = CustomSounds.findPaginated(filter, {
+				sort: sort || { name: 1 },
+				skip: offset,
+				limit: count,
+			});
+			const [sounds, total] = await Promise.all([cursor.toArray(), totalCount]);
+
+			return API.v1.success({
+				sounds,
+				count: sounds.length,
+				offset,
+				total,
+			});
+		},
+	)
+	.get(
+		'custom-sounds.getOne',
+		{
+			response: {
+				200: ajv.compile<{ sound: ICustomSound; success: boolean }>({
+					additionalProperties: false,
+					type: 'object',
+					properties: {
+						sound: {
+							$ref: '#/components/schemas/ICustomSound',
+						},
+						success: {
+							type: 'boolean',
+							description: 'Indicates if the request was successful.',
+						},
+					},
+					required: ['sound', 'success'],
+				}),
+				400: validateBadRequestErrorResponse,
+				401: validateUnauthorizedErrorResponse,
+				403: validateForbiddenErrorResponse,
+				404: validateNotFoundErrorResponse,
+			},
+			query: isCustomSoundsGetOneProps,
+			authRequired: true,
+		},
+		async function action() {
+			const { _id } = this.queryParams;
+
+			const sound = await CustomSounds.findOneById(_id);
+
+			if (!sound) {
+				return API.v1.notFound('Custom Sound not found.');
+			}
+
+			return API.v1.success({ sound });
+		},
+	)
+	.post(
+		'custom-sounds.create',
+		{
+			response: {
+				200: createCustomSoundsResponse,
+				400: validateBadRequestErrorResponse,
+				401: validateUnauthorizedErrorResponse,
+				403: validateForbiddenErrorResponse,
+			},
+			authRequired: true,
+			permissionsRequired: ['manage-sounds'],
+		},
+		async function action() {
+			const { fields, fileBuffer, filename } = await getUploadFormData(
+				{
+					request: this.request,
+				},
+				{
+					field: 'sound',
+					sizeLimit: MAX_CUSTOM_SOUND_SIZE_BYTES,
+					validate: isCustomSoundsCreateProps,
+				},
+			);
+
+			const computedMimeType = getMimeTypeFromFileName(filename);
+			if (!CUSTOM_SOUND_ALLOWED_MIME_TYPES.includes(computedMimeType)) {
+				return API.v1.failure('MIME type not allowed');
+			}
+
+			// We extract its extension from the name or use getExtension() as fallback.
+			const soundExtension =
+				(filename.includes('.') ? filename.split('.').pop()?.toLowerCase() : undefined) || getExtension(computedMimeType);
+
+			try {
+				const _id = await insertOrUpdateSound({
+					name: fields.name,
+					extension: soundExtension,
+				});
+				await uploadCustomSound(fileBuffer, computedMimeType, { _id, name: fields.name, extension: soundExtension });
+				return API.v1.success({ sound: { _id } });
+			} catch (error) {
+				SystemLogger.error({ error });
+				return API.v1.failure(error instanceof Error ? error.message : 'Unknown error');
+			}
+		},
+	)
+	.post(
+		'custom-sounds.update',
+		{
+			response: {
+				200: updateCustomSoundsResponse,
+				400: validateBadRequestErrorResponse,
+				401: validateUnauthorizedErrorResponse,
+				403: validateForbiddenErrorResponse,
+			},
+			authRequired: true,
+			permissionsRequired: ['manage-sounds'],
+		},
+		async function action() {
+			const { fields, fileBuffer, filename } = await getUploadFormData(
+				{
+					request: this.request,
+				},
+				{
+					field: 'sound',
+					fileOptional: true,
+					sizeLimit: MAX_CUSTOM_SOUND_SIZE_BYTES,
+					validate: isCustomSoundsUpdateProps,
+				},
+			);
+
+			let computedMimeType = '';
+			if (fileBuffer) {
+				computedMimeType = getMimeTypeFromFileName(filename);
+				if (!CUSTOM_SOUND_ALLOWED_MIME_TYPES.includes(computedMimeType)) {
+					return API.v1.failure('MIME type not allowed');
+				}
+			}
+
+			const soundToUpdate = await CustomSounds.findOneById<Pick<ICustomSound, '_id' | 'name' | 'extension'>>(fields._id, {
+				projection: { _id: 1, name: 1, extension: 1 },
+			});
+			if (!soundToUpdate) {
+				return API.v1.failure('Custom Sound not found.');
+			}
+
+			// If new file, we'll extract its extension or use getExtension() as fallback. If there's no new file, we will keep the current extension.
+			const nextExtension = fileBuffer
+				? (filename.includes('.') ? filename.split('.').pop()?.toLowerCase() : undefined) || getExtension(computedMimeType)
+				: soundToUpdate.extension;
+
+			try {
+				await insertOrUpdateSound({
+					_id: fields._id,
+					name: fields.name,
+					extension: nextExtension,
+					previousName: soundToUpdate.name,
+					previousExtension: soundToUpdate.extension,
+				});
+				if (fileBuffer) {
+					await uploadCustomSound(fileBuffer, computedMimeType, {
+						_id: fields._id,
+						name: fields.name,
+						previousExtension: soundToUpdate.extension,
+						extension: nextExtension,
+					});
+				}
+				return API.v1.success({});
+			} catch (error) {
+				SystemLogger.error({ error });
+				return API.v1.failure(error instanceof Error ? error.message : 'Unknown error');
+			}
+		},
+	)
+	.post(
+		'custom-sounds.delete',
+		{
+			response: {
+				200: deleteCustomSoundsResponse,
+				400: validateBadRequestErrorResponse,
+				401: validateUnauthorizedErrorResponse,
+				403: validateForbiddenErrorResponse,
+				404: validateNotFoundErrorResponse,
+				500: validateInternalErrorResponse,
+			},
+			authRequired: true,
+			body: isCustomSoundsDeleteProps,
+			permissionsRequired: ['manage-sounds'],
+		},
+		async function action() {
+			const { _id } = this.bodyParams;
+
+			try {
+				await deleteCustomSound(_id);
+
+				return API.v1.success();
+			} catch (error: unknown) {
+				this.logger.error({ error });
+
+				if (error instanceof Meteor.Error && error.error === 'Custom_Sound_Error_Invalid_Sound') {
+					return API.v1.failure(error.error);
+				}
+
+				return API.v1.internalError();
+			}
+		},
+	);
+
+export type CustomSoundEndpoints = ExtractRoutesFromAPI<typeof customSoundsEndpoints>;
+
+declare module '@rocket.chat/rest-typings' {
+	// eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-empty-interface
+	interface Endpoints extends CustomSoundEndpoints {}
+}