DX-1204: throw on v1 callback shape in 14 method families

Author: umair-ably

scripts/moduleReport.ts

@@ -6,7 +6,7 @@ import { gzip } from 'zlib';
 import Table from 'cli-table';
 
 // The maximum size we allow for a minimal useful Realtime bundle (i.e. one that can subscribe to a channel)
-const minimalUsefulRealtimeBundleSizeThresholdsKiB = { raw: 106, gzip: 32 };
+const minimalUsefulRealtimeBundleSizeThresholdsKiB = { raw: 107, gzip: 33 };
 
 const baseClientNames = ['BaseRest', 'BaseRealtime'];
 

src/common/lib/client/auth.ts

@@ -254,7 +254,12 @@ class Auth {
    */
   async authorize(tokenParams: API.TokenParams | null, authOptions: AuthOptions | null): Promise<API.TokenDetails>;
 
-  async authorize(
+  authorize(...args: any[]): Promise<API.TokenDetails> {
+    Utils.detectV1Callback(args, 0);
+    return this._authorizeImpl(args[0], args[1]);
+  }
+
+  private async _authorizeImpl(
     tokenParams?: Record<string, any> | null,
     authOptions?: AuthOptions | null,
   ): Promise<API.TokenDetails> {
@@ -390,7 +395,15 @@ class Auth {
    */
   async requestToken(tokenParams: API.TokenParams | null, authOptions: AuthOptions): Promise<API.TokenDetails>;
 
-  async requestToken(tokenParams?: API.TokenParams | null, authOptions?: AuthOptions): Promise<API.TokenDetails> {
+  requestToken(...args: any[]): Promise<API.TokenDetails> {
+    Utils.detectV1Callback(args, 0);
+    return this._requestTokenImpl(args[0], args[1]);
+  }
+
+  private async _requestTokenImpl(
+    tokenParams?: API.TokenParams | null,
+    authOptions?: AuthOptions,
+  ): Promise<API.TokenDetails> {
     /* RSA8e: if authOptions passed in, they're used instead of stored, don't merge them */
     const resolvedAuthOptions = authOptions || this.authOptions;
     const resolvedTokenParams = tokenParams || Utils.copy(this.tokenParams);
@@ -744,7 +757,15 @@ class Auth {
    * - timestamp:     (optional) the time in ms since the epoch. If none is specified,
    *                  the system will be queried for a time value to use.
    */
-  async createTokenRequest(tokenParams: API.TokenParams | null, authOptions: any): Promise<API.TokenRequest> {
+  createTokenRequest(...args: any[]): Promise<API.TokenRequest> {
+    Utils.detectV1Callback(args, 0);
+    return this._createTokenRequestImpl(args[0], args[1]);
+  }
+
+  private async _createTokenRequestImpl(
+    tokenParams: API.TokenParams | null,
+    authOptions: any,
+  ): Promise<API.TokenRequest> {
     /* RSA9h: if authOptions passed in, they're used instead of stored, don't merge them */
     authOptions = authOptions || this.authOptions;
     tokenParams = tokenParams || Utils.copy<API.TokenParams>(this.tokenParams);

src/common/lib/client/connection.ts

@@ -3,6 +3,7 @@ import ConnectionManager from '../transport/connectionmanager';
 import Logger from '../util/logger';
 import ConnectionStateChange from './connectionstatechange';
 import ErrorInfo from '../types/errorinfo';
+import * as Utils from '../util/utils';
 import { NormalisedClientOptions } from '../../types/ClientOptions';
 import BaseRealtime from './baserealtime';
 import Platform from 'common/platform';
@@ -46,7 +47,12 @@ class Connection extends EventEmitter {
     this.connectionManager.requestState({ state: 'connecting' });
   }
 
-  async ping(): Promise<number> {
+  ping(...args: any[]): Promise<number> {
+    Utils.detectV1Callback(args, 0);
+    return this._pingImpl();
+  }
+
+  private async _pingImpl(): Promise<number> {
     Logger.logAction(this.logger, Logger.LOG_MINOR, 'Connection.ping()', '');
     return this.connectionManager.ping();
   }

src/common/lib/client/realtimechannel.ts

@@ -250,7 +250,15 @@ class RealtimeChannel extends EventEmitter {
     return false;
   }
 
-  async publish(...args: any[]): Promise<API.PublishResult> {
+  publish(...args: any[]): Promise<API.PublishResult> {
+    // Detect a v1-shape trailing callback synchronously, before the async body
+    // starts — agents pasting v1 patterns need the throw to surface at the call
+    // site, not as an unobserved Promise rejection.
+    Utils.detectV1Callback(args, 0);
+    return this._publishImpl(args);
+  }
+
+  private async _publishImpl(args: any[]): Promise<API.PublishResult> {
     const first = args[0],
       second = args[1];
     let messages: Message[];
@@ -453,7 +461,12 @@ class RealtimeChannel extends EventEmitter {
     this.send(msg);
   }
 
-  async subscribe(...args: unknown[] /* [event], listener */): Promise<ChannelStateChange | null> {
+  subscribe(...args: unknown[] /* [event], listener */): Promise<ChannelStateChange | null> {
+    Utils.detectV1Callback(args, 2);
+    return this._subscribeImpl(args);
+  }
+
+  private async _subscribeImpl(args: unknown[]): Promise<ChannelStateChange | null> {
     const [event, listener] = RealtimeChannel.processListenerArgs(args);
 
     if (this.state === 'failed') {
@@ -476,6 +489,7 @@ class RealtimeChannel extends EventEmitter {
   }
 
   unsubscribe(...args: unknown[] /* [event], listener */): void {
+    Utils.detectV1Callback(args, 2);
     const [event, listener] = RealtimeChannel.processListenerArgs(args);
 
     // If we either have a filtered listener, a filter or both we need to do additional processing to find the original function(s)
@@ -985,7 +999,12 @@ class RealtimeChannel extends EventEmitter {
     }
   }
 
-  history = async function (
+  history = function (this: RealtimeChannel, ...args: any[]): Promise<PaginatedResult<Message>> {
+    Utils.detectV1Callback(args, 0);
+    return this._historyImpl(args[0]);
+  } as any;
+
+  private _historyImpl = async function (
     this: RealtimeChannel,
     params: RealtimeHistoryParams | null,
   ): Promise<PaginatedResult<Message>> {

src/common/lib/client/realtimepresence.ts

@@ -54,14 +54,24 @@ class RealtimePresence extends EventEmitter {
     this.pendingPresence = [];
   }
 
-  async enter(data: unknown): Promise<void> {
+  enter(...args: any[]): Promise<void> {
+    Utils.detectV1Callback(args, 0);
+    return this._enterImpl(args[0]);
+  }
+
+  private async _enterImpl(data: unknown): Promise<void> {
     if (isAnonymousOrWildcard(this)) {
       throw new ErrorInfo('clientId must be specified to enter a presence channel', 40012, 400);
     }
     return this._enterOrUpdateClient(undefined, undefined, data, 'enter');
   }
 
-  async update(data: unknown): Promise<void> {
+  update(...args: any[]): Promise<void> {
+    Utils.detectV1Callback(args, 0);
+    return this._updateImpl(args[0]);
+  }
+
+  private async _updateImpl(data: unknown): Promise<void> {
     if (isAnonymousOrWildcard(this)) {
       throw new ErrorInfo('clientId must be specified to update presence data', 40012, 400);
     }
@@ -129,7 +139,12 @@ class RealtimePresence extends EventEmitter {
     }
   }
 
-  async leave(data: unknown): Promise<void> {
+  leave(...args: any[]): Promise<void> {
+    Utils.detectV1Callback(args, 0);
+    return this._leaveImpl(args[0]);
+  }
+
+  private async _leaveImpl(data: unknown): Promise<void> {
     if (isAnonymousOrWildcard(this)) {
       throw new ErrorInfo('clientId must have been specified to enter or leave a presence channel', 40012, 400);
     }
@@ -176,7 +191,12 @@ class RealtimePresence extends EventEmitter {
     }
   }
 
-  async get(params?: RealtimePresenceParams): Promise<PresenceMessage[]> {
+  get(...args: any[]): Promise<PresenceMessage[]> {
+    Utils.detectV1Callback(args, 0);
+    return this._getImpl(args[0]);
+  }
+
+  private async _getImpl(params?: RealtimePresenceParams): Promise<PresenceMessage[]> {
     const waitForSync = !params || ('waitForSync' in params ? params.waitForSync : true);
 
     function toMessages(members: PresenceMap): PresenceMessage[] {
@@ -204,7 +224,12 @@ class RealtimePresence extends EventEmitter {
     return toMessages(this.members);
   }
 
-  async history(params: RealtimeHistoryParams | null): Promise<PaginatedResult<PresenceMessage>> {
+  history(...args: any[]): Promise<PaginatedResult<PresenceMessage>> {
+    Utils.detectV1Callback(args, 0);
+    return this._historyImpl(args[0]);
+  }
+
+  private async _historyImpl(params: RealtimeHistoryParams | null): Promise<PaginatedResult<PresenceMessage>> {
     Logger.logAction(this.logger, Logger.LOG_MICRO, 'RealtimePresence.history()', 'channel = ' + this.name);
     // We fetch this first so that any plugin-not-provided error takes priority over other errors
     const restMixin = this.channel.client.rest.presenceMixin;
@@ -407,7 +432,12 @@ class RealtimePresence extends EventEmitter {
     });
   }
 
-  async subscribe(..._args: unknown[] /* [event], listener */): Promise<void> {
+  subscribe(..._args: unknown[] /* [event], listener */): Promise<void> {
+    Utils.detectV1Callback(_args, 2);
+    return this._subscribeImpl(_args);
+  }
+
+  private async _subscribeImpl(_args: unknown[]): Promise<void> {
     const args = RealtimeChannel.processListenerArgs(_args);
     const event = args[0];
     const listener = args[1];