register old methods as legacy

Author: ggazzo

apps/meteor/app/api/server/api.ts

@@ -3,7 +3,9 @@ import { Logger } from '@rocket.chat/logger';
 import { Users } from '@rocket.chat/models';
 import { Random } from '@rocket.chat/random';
 import type { JoinPathPattern, Method } from '@rocket.chat/rest-typings';
+import { ajv } from '@rocket.chat/rest-typings/src/v1/Ajv';
 import { tracerSpan } from '@rocket.chat/tracing';
+import type { ValidateFunction } from 'ajv';
 import { Accounts } from 'meteor/accounts-base';
 import { DDP } from 'meteor/ddp';
 import { DDPCommon } from 'meteor/ddp-common';
@@ -493,51 +495,119 @@ export class APIClass<
 		return routeActions.map((action) => this.getFullRouteName(route, action, apiVersion));
 	}
 
-	private method<TSubPathPattern extends string, TOptions extends TypedOptions, TPathPattern extends `${TBasePath}/${TSubPathPattern}`>(
+	private registerTypedRoutesLegacy<TSubPathPattern extends string, TOptions extends Options>(
 		method: Method,
 		subpath: TSubPathPattern,
 		options: TOptions,
-		action: TypedAction<TOptions>,
-	): APIClass<
-		TBasePath,
-		| TOperations
-		| ({
-				method: Method;
-				path: TPathPattern;
-		  } & Omit<TOptions, 'response'>)
-	> {
-		const path = `${this._config.apiPath}/${subpath}`.replace('//', '/') as TPathPattern;
-		this.addRoute([subpath], { ...options }, { [method.toLowerCase()]: { action } } as any);
+	): void {
+		const { authRequired, validateParams } = options;
+
+		const opt = {
+			authRequired,
+			...(validateParams &&
+				method.toLowerCase() === 'get' &&
+				('GET' in validateParams
+					? { query: validateParams.GET }
+					: {
+							query: validateParams as ValidateFunction<any>,
+						})),
+
+			...(validateParams &&
+				method.toLowerCase() === 'post' &&
+				('POST' in validateParams ? { query: validateParams.POST } : { body: validateParams as ValidateFunction<any> })),
+
+			...(validateParams &&
+				method.toLowerCase() === 'put' &&
+				('PUT' in validateParams ? { query: validateParams.PUT } : { body: validateParams as ValidateFunction<any> })),
+			...(validateParams &&
+				method.toLowerCase() === 'delete' &&
+				('DELETE' in validateParams ? { query: validateParams.DELETE } : { body: validateParams as ValidateFunction<any> })),
+
+			tags: ['Missing Documentation'],
+			response: {
+				200: ajv.compile({
+					type: 'object',
+					properties: {
+						success: { type: 'boolean' },
+						error: { type: 'string' },
+					},
+					required: ['success'],
+				}),
+			},
+		};
+
+		this.registerTypedRoutes(method, subpath, opt);
+	}
+
+	private registerTypedRoutes<
+		TSubPathPattern extends string,
+		TOptions extends TypedOptions,
+		TPathPattern extends `${TBasePath}/${TSubPathPattern}`,
+	>(method: Method, subpath: TSubPathPattern, options: TOptions): void {
+		const path = `/${this._config.apiPath}/${subpath}`.replaceAll('//', '/') as TPathPattern;
 		this.typedRoutes = this.typedRoutes || {};
 		this.typedRoutes[path] = this.typedRoutes[subpath] || {};
-		const { query, authRequired, response, body, ...rest } = options;
+		const { query, authRequired, response, body, tags, ...rest } = options;
 		this.typedRoutes[path][method.toLowerCase()] = {
-			...rest,
 			...(response && {
-				responses: {
-					...Object.fromEntries(
-						Object.entries(response).map(([status, schema]) => [
-							status,
-							{
-								content: {
-									'application/json': 'schema' in schema ? { schema: schema.schema } : schema,
-								},
+				responses: Object.fromEntries(
+					Object.entries(response).map(([status, schema]) => [
+						status,
+						{
+							description: '',
+							content: {
+								'application/json': 'schema' in schema ? { schema: schema.schema } : schema,
 							},
-						]),
-					),
+						},
+					]),
+				),
+			}),
+			...(query && {
+				parameters: [
+					{
+						schema: query.schema,
+						in: 'query',
+						name: 'query',
+						required: true,
+					},
+				],
+			}),
+			...(body && {
+				requestBody: {
+					required: true,
+					content: {
+						'application/json': { schema: body.schema },
+					},
 				},
 			}),
-			...(query && { query: query.schema }),
-			...(body && { body: body.schema }),
 			...(authRequired && {
+				...rest,
 				security: [
 					{
 						userId: [],
 						authToken: [],
 					},
 				],
 			}),
+			tags,
 		};
+	}
+
+	private method<TSubPathPattern extends string, TOptions extends TypedOptions, TPathPattern extends `${TBasePath}/${TSubPathPattern}`>(
+		method: Method,
+		subpath: TSubPathPattern,
+		options: TOptions,
+		action: TypedAction<TOptions>,
+	): APIClass<
+		TBasePath,
+		| TOperations
+		| ({
+				method: Method;
+				path: TPathPattern;
+		  } & Omit<TOptions, 'response'>)
+	> {
+		this.addRoute([subpath], { ...options }, { [method.toLowerCase()]: { action } } as any);
+		this.registerTypedRoutes(method, subpath, options);
 		return this;
 	}
 
@@ -869,6 +939,11 @@ export class APIClass<
 
 				// Allow the endpoints to make usage of the logger which respects the user's settings
 				(operations[method as keyof Operations<TPathPattern, TOptions>] as Record<string, any>).logger = logger;
+
+				this.registerTypedRoutesLegacy(method as Method, route, {
+					...options,
+					...operations[method as keyof Operations<TPathPattern, TOptions>],
+				});
 			});
 			super.addRoute(route, options, operations);
 		});