chore: remove proxifyWithWait and waitAndCall

apps/meteor/ee/server/sdk/index.ts

@@ -1,7 +1,7 @@
-import { proxifyWithWait } from '@rocket.chat/core-services';
+import { proxify } from '@rocket.chat/core-services';
 
 import type { IInstanceService } from './types/IInstanceService';
 import type { ILDAPEEService } from './types/ILDAPEEService';
 
-export const LDAPEE = proxifyWithWait<ILDAPEEService>('ldap-enterprise');
-export const Instance = proxifyWithWait<IInstanceService>('instance');
+export const LDAPEE = proxify<ILDAPEEService>('ldap-enterprise');
+export const Instance = proxify<IInstanceService>('instance');

apps/meteor/server/services/authorization/canAccessRoomLivechat.ts

@@ -1,9 +1,9 @@
 import type { IAuthorizationLivechat, RoomAccessValidator } from '@rocket.chat/core-services';
-import { proxifyWithWait } from '@rocket.chat/core-services';
+import { proxify } from '@rocket.chat/core-services';
 import type { IOmnichannelRoom } from '@rocket.chat/core-typings';
 import { Rooms } from '@rocket.chat/models';
 
-const AuthorizationLivechat = proxifyWithWait<IAuthorizationLivechat>('authorization-livechat');
+const AuthorizationLivechat = proxify<IAuthorizationLivechat>('authorization-livechat');
 
 export const canAccessRoomLivechat: RoomAccessValidator = async (room, user, extraData): Promise<boolean> => {
 	// If we received a partial room and its type is not `l` or `v`, skip all checks.

apps/meteor/server/services/authorization/canAccessRoomVoip.ts

@@ -1,8 +1,8 @@
 import type { IAuthorizationVoip, RoomAccessValidator } from '@rocket.chat/core-services';
-import { proxifyWithWait } from '@rocket.chat/core-services';
+import { proxify } from '@rocket.chat/core-services';
 import { Rooms } from '@rocket.chat/models';
 
-const AuthorizationVoip = proxifyWithWait<IAuthorizationVoip>('authorization-livechat');
+const AuthorizationVoip = proxify<IAuthorizationVoip>('authorization-livechat');
 
 export const canAccessRoomVoip: RoomAccessValidator = async (room, user, extraData): Promise<boolean> => {
 	// room can be sent as `null` but in that case a `rid` is also sent on extraData

apps/meteor/tests/mocks/server/BrokerMocked.ts

@@ -15,10 +15,6 @@ export class BrokerMocked {
 		return this.actions[method](data);
 	}
 
-	async waitAndCall(method: string, data: any): Promise<any> {
-		return this.actions[method](data);
-	}
-
 	async broadcastToServices(): Promise<void> {
 		// no op
 	}

ee/packages/network-broker/src/NetworkBroker.ts

@@ -61,30 +61,6 @@ export class NetworkBroker implements IBroker {
 		});
 	}
 
-	async waitAndCall(method: string, data: any): Promise<any> {
-		if (!(await this.started)) {
-			return;
-		}
-
-		try {
-			await this.broker.waitForServices(method.split('.')[0], waitForServicesTimeout);
-		} catch (err) {
-			console.error(err);
-			throw new Error('Dependent services not available');
-		}
-
-		const context = asyncLocalStorage.getStore();
-		if (context?.ctx?.call) {
-			return context.ctx.call(method, data);
-		}
-
-		return this.broker.call(method, data, {
-			meta: {
-				optl: injectCurrentContext(),
-			},
-		});
-	}
-
 	async destroyService(instance: IServiceClass): Promise<void> {
 		const name = instance.getName();
 		if (!name) {

ee/packages/omnichannel-services/src/QueueWorker.ts

@@ -76,7 +76,7 @@ export class QueueWorker extends ServiceClass implements IQueueWorkerService {
 		this.logger.info(`Processing queue item ${queueItem._id} for work`);
 		this.logger.info(`Queue item is trying to call ${queueItem.message.to}`);
 		try {
-			await api.waitAndCall(queueItem.message.to, [queueItem.message]);
+			await api.call(queueItem.message.to, [queueItem.message]);
 			this.logger.info(`Queue item ${queueItem._id} completed`);
 			return 'Completed' as const;
 		} catch (err: unknown) {

packages/core-services/src/LocalBroker.ts

@@ -30,10 +30,6 @@ export class LocalBroker implements IBroker {
 		return result;
 	}
 
-	async waitAndCall(method: string, data: any): Promise<any> {
-		return this.call(method, data);
-	}
-
 	async destroyService(instance: ServiceClass): Promise<void> {
 		const namespace = instance.getName();
 

packages/core-services/src/index.ts

@@ -1,4 +1,4 @@
-import { proxify, proxifyWithWait } from './lib/proxify';
+import { proxify } from './lib/proxify';
 import type { IAccount, ILoginResult } from './types/IAccount';
 import type { IAnalyticsService } from './types/IAnalyticsService';
 import { IApiService } from './types/IApiService';
@@ -124,7 +124,7 @@ export {
 	IVoipFreeSwitchService,
 	NPSCreatePayload,
 	NPSVotePayload,
-	proxifyWithWait,
+	proxify,
 	ResizeResult,
 	RoomAccessValidator,
 	TelemetryEvents,
@@ -155,42 +155,42 @@ export const dbWatchersDisabled =
 	(process.env.NODE_ENV !== 'production' && !['no', 'false'].includes(disabledEnvVar));
 
 // TODO think in a way to not have to pass the service name to proxify here as well
-export const Authorization = proxifyWithWait<IAuthorization>('authorization');
-export const Apps = proxifyWithWait<IAppsEngineService>('apps-engine');
-export const Presence = proxifyWithWait<IPresence>('presence');
-export const Account = proxifyWithWait<IAccount>('accounts');
-export const License = proxifyWithWait<ILicense>('license');
-export const MeteorService = proxifyWithWait<IMeteor>('meteor');
-export const Banner = proxifyWithWait<IBannerService>('banner');
-export const UiKitCoreApp = proxifyWithWait<IUiKitCoreAppService>('uikit-core-app');
-export const NPS = proxifyWithWait<INPSService>('nps');
-export const Team = proxifyWithWait<ITeamService>('team');
-export const MessageReads = proxifyWithWait<IMessageReadsService>('message-reads');
-export const Room = proxifyWithWait<IRoomService>('room');
-export const Media = proxifyWithWait<IMediaService>('media');
-export const VoipAsterisk = proxifyWithWait<IVoipService>('voip-asterisk');
-export const VoipFreeSwitch = proxifyWithWait<IVoipFreeSwitchService>('voip-freeswitch');
-export const LivechatVoip = proxifyWithWait<IOmnichannelVoipService>('omnichannel-voip');
-export const Analytics = proxifyWithWait<IAnalyticsService>('analytics');
-export const LDAP = proxifyWithWait<ILDAPService>('ldap');
-export const SAUMonitor = proxifyWithWait<ISAUMonitorService>('sau-monitor');
-export const DeviceManagement = proxifyWithWait<IDeviceManagementService>('device-management');
-export const VideoConf = proxifyWithWait<IVideoConfService>('video-conference');
-export const Upload = proxifyWithWait<IUploadService>('upload');
-export const Calendar = proxifyWithWait<ICalendarService>('calendar');
-export const QueueWorker = proxifyWithWait<IQueueWorkerService>('queue-worker');
-export const OmnichannelTranscript = proxifyWithWait<IOmnichannelTranscriptService>('omnichannel-transcript');
-export const Message = proxifyWithWait<IMessageService>('message');
-export const Translation = proxifyWithWait<ITranslationService>('translation');
-export const Settings = proxifyWithWait<ISettingsService>('settings');
-export const OmnichannelIntegration = proxifyWithWait<IOmnichannelIntegrationService>('omnichannel-integration');
-export const Federation = proxifyWithWait<IFederationService>('federation');
-export const FederationEE = proxifyWithWait<IFederationServiceEE>('federation-enterprise');
-export const Omnichannel = proxifyWithWait<IOmnichannelService>('omnichannel');
-export const OmnichannelEEService = proxifyWithWait<IOmnichannelEEService>('omnichannel-ee');
-export const Import = proxifyWithWait<IImportService>('import');
-export const OmnichannelAnalytics = proxifyWithWait<IOmnichannelAnalyticsService>('omnichannel-analytics');
-export const User = proxifyWithWait<IUserService>('user');
+export const Authorization = proxify<IAuthorization>('authorization');
+export const Apps = proxify<IAppsEngineService>('apps-engine');
+export const Presence = proxify<IPresence>('presence');
+export const Account = proxify<IAccount>('accounts');
+export const License = proxify<ILicense>('license');
+export const MeteorService = proxify<IMeteor>('meteor');
+export const Banner = proxify<IBannerService>('banner');
+export const UiKitCoreApp = proxify<IUiKitCoreAppService>('uikit-core-app');
+export const NPS = proxify<INPSService>('nps');
+export const Team = proxify<ITeamService>('team');
+export const MessageReads = proxify<IMessageReadsService>('message-reads');
+export const Room = proxify<IRoomService>('room');
+export const Media = proxify<IMediaService>('media');
+export const VoipAsterisk = proxify<IVoipService>('voip-asterisk');
+export const VoipFreeSwitch = proxify<IVoipFreeSwitchService>('voip-freeswitch');
+export const LivechatVoip = proxify<IOmnichannelVoipService>('omnichannel-voip');
+export const Analytics = proxify<IAnalyticsService>('analytics');
+export const LDAP = proxify<ILDAPService>('ldap');
+export const SAUMonitor = proxify<ISAUMonitorService>('sau-monitor');
+export const DeviceManagement = proxify<IDeviceManagementService>('device-management');
+export const VideoConf = proxify<IVideoConfService>('video-conference');
+export const Upload = proxify<IUploadService>('upload');
+export const Calendar = proxify<ICalendarService>('calendar');
+export const QueueWorker = proxify<IQueueWorkerService>('queue-worker');
+export const OmnichannelTranscript = proxify<IOmnichannelTranscriptService>('omnichannel-transcript');
+export const Message = proxify<IMessageService>('message');
+export const Translation = proxify<ITranslationService>('translation');
+export const Settings = proxify<ISettingsService>('settings');
+export const OmnichannelIntegration = proxify<IOmnichannelIntegrationService>('omnichannel-integration');
+export const Federation = proxify<IFederationService>('federation');
+export const FederationEE = proxify<IFederationServiceEE>('federation-enterprise');
+export const Omnichannel = proxify<IOmnichannelService>('omnichannel');
+export const OmnichannelEEService = proxify<IOmnichannelEEService>('omnichannel-ee');
+export const Import = proxify<IImportService>('import');
+export const OmnichannelAnalytics = proxify<IOmnichannelAnalyticsService>('omnichannel-analytics');
+export const User = proxify<IUserService>('user');
 
 // Calls without wait. Means that the service is optional and the result may be an error
 // of service/method not available

packages/core-services/src/lib/Api.ts

@@ -41,10 +41,6 @@ export class Api implements IApiService {
 		return this.broker?.call(method, data);
 	}
 
-	async waitAndCall(method: string, data: any): Promise<any> {
-		return this.broker?.waitAndCall(method, data);
-	}
-
 	async broadcast<T extends keyof EventSignatures>(event: T, ...args: Parameters<EventSignatures[T]>): Promise<void> {
 		if (!this.broker) {
 			throw new Error(`No broker set to broadcast: ${event}, ${JSON.stringify(args)}`);

packages/core-services/src/lib/proxify.ts

@@ -16,20 +16,15 @@ type PromOrError<T> = {
 		: never;
 };
 
-function handler<T extends object>(namespace: string, waitService: boolean): ProxyHandler<T> {
+function handler<T extends object>(namespace: string): ProxyHandler<T> {
 	return {
 		get:
 			(_target: T, prop: string): any =>
 			(...params: any): Promise<any> =>
-				api[waitService ? 'waitAndCall' : 'call'](`${namespace}.${prop}`, params),
+				api.call(`${namespace}.${prop}`, params),
 	};
 }
 
-// TODO remove the need to wait for a service, if that is really needed it should have a dependency on startup
-export function proxifyWithWait<T>(namespace: string): Prom<T> {
-	return new Proxy({}, handler(namespace, true)) as unknown as Prom<T>;
-}
-
 export function proxify<T>(namespace: string): PromOrError<T> {
-	return new Proxy({}, handler(namespace, false)) as unknown as PromOrError<T>;
+	return new Proxy({}, handler(namespace)) as unknown as PromOrError<T>;
 }

packages/core-services/src/types/IApiService.ts

@@ -11,8 +11,6 @@ export interface IApiService {
 
 	call(method: string, data?: unknown): Promise<any>;
 
-	waitAndCall(method: string, data: any): Promise<any>;
-
 	broadcast<T extends keyof EventSignatures>(event: T, ...args: Parameters<EventSignatures[T]>): Promise<void>;
 
 	broadcastToServices<T extends keyof EventSignatures>(

packages/core-services/src/types/IBroker.ts

@@ -51,7 +51,6 @@ export interface IBroker {
 	destroyService(service: IServiceClass): Promise<void>;
 	createService(service: IServiceClass, serviceDependencies?: string[]): void;
 	call(method: string, data: any): Promise<any>;
-	waitAndCall(method: string, data: any): Promise<any>;
 	broadcastToServices<T extends keyof EventSignatures>(
 		services: string[],
 		event: T,