@aws-amplify/pubsub 5.0.12 → 5.0.13-push-notification-dryrun.43

package/src/Providers/MqttOverWSProvider.ts

@@ -5,7 +5,11 @@ import { v4 as uuid } from 'uuid';
 import Observable, { ZenObservable } from 'zen-observable-ts';
 
 import { AbstractPubSubProvider } from './PubSubProvider';
-import { SubscriptionObserver, ConnectionState } from '../types/PubSub';
+import {
+	ConnectionState,
+	PubSubContentObserver,
+	PubSubContent,
+} from '../types/PubSub';
 import { ProviderOptions } from '../types/Provider';
 import { ConsoleLogger as Logger, Hub } from '@aws-amplify/core';
 import {
@@ -37,19 +41,39 @@ export function mqttTopicMatch(filter: string, topic: string) {
 export interface MqttProviderOptions extends ProviderOptions {
 	clientId?: string;
 	url?: string;
+	aws_pubsub_endpoint?: string;
+}
+
+interface PahoClient {
+	onMessageArrived: (params: {
+		destinationName: string;
+		payloadString: string;
+	}) => void;
+	onConnectionLost: (params: { errorCode: number }) => void;
+	connect: (params: {
+		[k: string]: string | number | boolean | (() => void);
+	}) => void;
+	disconnect: () => void;
+	isConnected: () => boolean;
+	subscribe: (topic: string) => void;
+	unsubscribe: (topic: string) => void;
+	send(topic: string, message: string);
 }
 
 class ClientsQueue {
-	private promises: Map<string, Promise<any>> = new Map();
+	private promises: Map<string, Promise<PahoClient | undefined>> = new Map();
 
-	async get(clientId: string, clientFactory?: (input: string) => Promise<any>) {
+	async get(
+		clientId: string,
+		clientFactory?: (input: string) => Promise<PahoClient | undefined>
+	) {
 		const cachedPromise = this.promises.get(clientId);
 		if (cachedPromise) return cachedPromise;
 
 		if (clientFactory) {
 			const newPromise = clientFactory(clientId);
 			this.promises.set(clientId, newPromise);
-			newPromise.catch(v => this.promises.delete(clientId));
+			newPromise.catch(() => this.promises.delete(clientId));
 			return newPromise;
 		}
 
@@ -65,13 +89,17 @@ class ClientsQueue {
 	}
 }
 
-const dispatchPubSubEvent = (event: string, data: any, message: string) => {
+const dispatchPubSubEvent = (
+	event: string,
+	data: Record<string, unknown>,
+	message: string
+) => {
 	Hub.dispatch('pubsub', { event, data, message }, 'PubSub', AMPLIFY_SYMBOL);
 };
 
 const topicSymbol = typeof Symbol !== 'undefined' ? Symbol('topic') : '@@topic';
 
-export class MqttOverWSProvider extends AbstractPubSubProvider {
+export class MqttOverWSProvider extends AbstractPubSubProvider<MqttProviderOptions> {
 	private _clientsQueue = new ClientsQueue();
 	private connectionState: ConnectionState;
 	private readonly connectionStateMonitor = new ConnectionStateMonitor();
@@ -106,11 +134,11 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 	}
 
 	protected get clientId() {
-		return this.options.clientId;
+		return this.options.clientId!;
 	}
 
-	protected get endpoint() {
-		return this.options.aws_pubsub_endpoint;
+	protected get endpoint(): Promise<string | undefined> {
+		return Promise.resolve(this.options.aws_pubsub_endpoint);
 	}
 
 	protected get clientsQueue() {
@@ -118,12 +146,9 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 	}
 
 	protected get isSSLEnabled() {
-		return !this.options
-			.aws_appsync_dangerously_connect_to_http_endpoint_for_testing;
-	}
-
-	protected getTopicForValue(value: any) {
-		return typeof value === 'object' && value[topicSymbol];
+		return !this.options[
+			'aws_appsync_dangerously_connect_to_http_endpoint_for_testing'
+		];
 	}
 
 	getProviderName() {
@@ -152,12 +177,15 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 		}
 	}
 
-	public async newClient({ url, clientId }: MqttProviderOptions): Promise<any> {
+	public async newClient({
+		url,
+		clientId,
+	}: MqttProviderOptions): Promise<PahoClient> {
 		logger.debug('Creating new MQTT client', clientId);
 
 		this.connectionStateMonitor.record(CONNECTION_CHANGE.OPENING_CONNECTION);
 		// @ts-ignore
-		const client = new Paho.Client(url, clientId);
+		const client = new Paho.Client(url, clientId) as PahoClient;
 
 		client.onMessageArrived = ({
 			destinationName: topic,
@@ -183,7 +211,7 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 				useSSL: this.isSSLEnabled,
 				mqttVersion: 3,
 				onSuccess: () => resolve(true),
-				onFailure: x => {
+				onFailure: () => {
 					if (clientId) this._clientsQueue.remove(clientId);
 					this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
 					resolve(false);
@@ -203,14 +231,17 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 	protected async connect(
 		clientId: string,
 		options: MqttProviderOptions = {}
-	): Promise<any> {
+	): Promise<PahoClient | undefined> {
 		return await this.clientsQueue.get(clientId, async clientId => {
 			const client = await this.newClient({ ...options, clientId });
 
 			if (client) {
 				// Once connected, subscribe to all topics registered observers
 				this._topicObservers.forEach(
-					(_value: Set<SubscriptionObserver<any>>, key: string) => {
+					(
+						_value: Set<ZenObservable.SubscriptionObserver<any>>,
+						key: string
+					) => {
 						client.subscribe(key);
 					}
 				);
@@ -229,7 +260,7 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 		this.connectionStateMonitor.record(CONNECTION_CHANGE.CLOSED);
 	}
 
-	async publish(topics: string[] | string, msg: any) {
+	async publish(topics: string[] | string, msg: PubSubContent) {
 		const targetTopics = ([] as string[]).concat(topics);
 		const message = JSON.stringify(msg);
 
@@ -247,23 +278,26 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 		}
 	}
 
-	protected _topicObservers: Map<string, Set<SubscriptionObserver<any>>> =
+	protected _topicObservers: Map<string, Set<PubSubContentObserver>> =
 		new Map();
 
-	protected _clientIdObservers: Map<string, Set<SubscriptionObserver<any>>> =
+	protected _clientIdObservers: Map<string, Set<PubSubContentObserver>> =
 		new Map();
 
-	private _onMessage(topic: string, msg: any) {
+	private _onMessage(topic: string, msg: string) {
 		try {
-			const matchedTopicObservers: Set<SubscriptionObserver<any>>[] = [];
+			const matchedTopicObservers: Set<
+				ZenObservable.SubscriptionObserver<any>
+			>[] = [];
 			this._topicObservers.forEach((observerForTopic, observerTopic) => {
 				if (mqttTopicMatch(observerTopic, topic)) {
 					matchedTopicObservers.push(observerForTopic);
 				}
 			});
-			const parsedMessage = JSON.parse(msg);
+			const parsedMessage: PubSubContent = JSON.parse(msg);
 
 			if (typeof parsedMessage === 'object') {
+				// @ts-ignore
 				parsedMessage[topicSymbol] = topic;
 			}
 
@@ -278,7 +312,7 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 	subscribe(
 		topics: string[] | string,
 		options: MqttProviderOptions = {}
-	): Observable<any> {
+	): Observable<PubSubContent> {
 		const targetTopics = ([] as string[]).concat(topics);
 		logger.debug('Subscribing to topic(s)', targetTopics.join(','));
 		let reconnectSubscription: ZenObservable.Subscription;
@@ -302,10 +336,12 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 			// this._clientIdObservers is used to close observers when client gets disconnected
 			let observersForClientId = this._clientIdObservers.get(clientId);
 			if (!observersForClientId) {
-				observersForClientId = new Set();
+				observersForClientId = new Set<PubSubContentObserver>();
+			}
+			if (observersForClientId) {
+				observersForClientId.add(observer);
+				this._clientIdObservers.set(clientId, observersForClientId);
 			}
-			observersForClientId.add(observer);
-			this._clientIdObservers.set(clientId, observersForClientId);
 
 			(async () => {
 				const getClient = async () => {
@@ -352,7 +388,7 @@ export class MqttOverWSProvider extends AbstractPubSubProvider {
 					targetTopics.forEach(topic => {
 						const observersForTopic =
 							this._topicObservers.get(topic) ||
-							(new Set() as Set<SubscriptionObserver<any>>);
+							(new Set() as Set<ZenObservable.SubscriptionObserver<any>>);
 
 						observersForTopic.delete(observer);
 

package/src/Providers/PubSubProvider.ts

@@ -3,17 +3,20 @@
 import Observable from 'zen-observable-ts';
 import { PubSubProvider, ProviderOptions } from '../types/Provider';
 import { ConsoleLogger as Logger } from '@aws-amplify/core';
+import { PubSubContent } from '../types/PubSub';
 
 const logger = new Logger('AbstractPubSubProvider');
 
-export abstract class AbstractPubSubProvider implements PubSubProvider {
-	private _config: ProviderOptions;
+export abstract class AbstractPubSubProvider<T extends ProviderOptions>
+	implements PubSubProvider
+{
+	private _config: T;
 
-	constructor(options: ProviderOptions = {}) {
+	constructor(options: T) {
 		this._config = options;
 	}
 
-	configure(config: ProviderOptions = {}): ProviderOptions {
+	configure(config: T): T {
 		this._config = { ...config, ...this._config };
 
 		logger.debug(`configure ${this.getProviderName()}`, this._config);
@@ -27,20 +30,20 @@ export abstract class AbstractPubSubProvider implements PubSubProvider {
 
 	abstract getProviderName(): string;
 
-	protected get options(): ProviderOptions {
+	protected get options(): T {
 		return { ...this._config };
 	}
 
-	public abstract newClient(clientOptions: ProviderOptions): Promise<any>;
+	public abstract newClient(clientOptions: T): Promise<any>;
 
 	public abstract publish(
 		topics: string[] | string,
-		msg: any,
-		options?: ProviderOptions
+		msg: PubSubContent,
+		options?: T
 	): void;
 
 	public abstract subscribe(
 		topics: string[] | string,
-		options?: ProviderOptions
-	): Observable<any>;
+		options?: T
+	): Observable<PubSubContent>;
 }

package/src/Providers/index.ts

@@ -1,7 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 export { AbstractPubSubProvider } from './PubSubProvider';
-export { AWSAppSyncProvider } from './AWSAppSyncProvider';
 export {
 	AWSAppSyncRealTimeProvider,
 	AWSAppSyncRealTimeProviderOptions,

package/src/PubSub.ts

@@ -11,10 +11,16 @@ import {
 } from '@aws-amplify/core';
 import { PubSubProvider, PubSubOptions, ProviderOptions } from './types';
 import { AWSAppSyncRealTimeProvider } from './Providers';
+import { PubSubContent } from './types/PubSub';
 
 const { isNode } = browserOrNode();
 const logger = new Logger('PubSub');
 
+type PubSubObservable = {
+	provider: PubSubProvider;
+	value: string | Record<string, unknown>;
+};
+
 export class PubSubClass {
 	private _options: PubSubOptions;
 
@@ -60,7 +66,9 @@ export class PubSubClass {
 	 * @return {Object} - The current configuration
 	 */
 	configure(options: PubSubOptions) {
-		const opt = options ? options.PubSub || options : {};
+		const opt: Record<string, unknown> = options
+			? options.PubSub || options
+			: {};
 		logger.debug('configure PubSub', { opt });
 
 		this._options = Object.assign({}, this._options, opt);
@@ -105,14 +113,14 @@ export class PubSubClass {
 	}
 
 	private getProviders(options: ProviderOptions = {}) {
-		const { provider: providerName } = options;
+		const providerName = options.provider;
 		if (!providerName) {
 			return this._pluggables;
 		}
 
 		const provider = this.getProviderByName(providerName);
 		if (!provider) {
-			throw new Error(`Could not find provider named ${providerName}`);
+			throw new Error(`Could not find provider named ${String(providerName)}`);
 		}
 
 		return [provider];
@@ -120,7 +128,7 @@ export class PubSubClass {
 
 	async publish(
 		topics: string[] | string,
-		msg: any,
+		msg: PubSubContent,
 		options?: ProviderOptions
 	) {
 		return Promise.all(
@@ -133,7 +141,7 @@ export class PubSubClass {
 	subscribe(
 		topics: string[] | string,
 		options?: ProviderOptions
-	): Observable<any> {
+	): Observable<PubSubObservable> {
 		if (isNode && this._options && this._options.ssr) {
 			throw new Error(
 				'Subscriptions are not supported for Server-Side Rendering (SSR)'
@@ -144,7 +152,7 @@ export class PubSubClass {
 
 		const providers = this.getProviders(options);
 
-		return new Observable(observer => {
+		return new Observable<PubSubObservable>(observer => {
 			const observables = providers.map(provider => ({
 				provider,
 				observable: provider.subscribe(topics, options),
@@ -153,8 +161,8 @@ export class PubSubClass {
 			const subscriptions = observables.map(({ provider, observable }) =>
 				observable.subscribe({
 					start: console.error,
-					next: value => observer.next({ provider, value }),
-					error: error => observer.error({ provider, error }),
+					next: (value: PubSubContent) => observer.next({ provider, value }),
+					error: (error: unknown) => observer.error({ provider, error }),
 					// complete: observer.complete, // TODO: when all completed, complete the outer one
 				})
 			);

package/src/index.ts

@@ -5,7 +5,6 @@ export { PubSub } from './PubSub';
 export { CONNECTION_STATE_CHANGE } from './Providers/constants';
 export { ConnectionState, CONTROL_MSG } from './types';
 export {
-	AWSAppSyncProvider,
 	AWSAppSyncRealTimeProvider,
 	AWSAppSyncRealTimeProviderOptions,
 	AWSIoTProvider,

package/src/types/Provider.ts

@@ -1,18 +1,22 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import Observable from 'zen-observable-ts';
+import { PubSubContent } from './PubSub';
 
 export interface PubSubOptions {
 	[key: string]: any;
+	ssr?: boolean;
+	PubSub?: {};
 }
 
 export interface ProviderOptions {
 	[key: string]: any;
+	provider?: string | symbol;
 }
 
 export interface PubSubProvider {
 	// configure your provider
-	configure(config: object): object;
+	configure(config: Record<string, unknown>): Record<string, unknown>;
 
 	// return 'Analytics';
 	getCategory(): string;
@@ -20,10 +24,14 @@ export interface PubSubProvider {
 	// return the name of you provider
 	getProviderName(): string;
 
-	publish(topics: string[] | string, msg: any, options?: ProviderOptions): void;
+	publish(
+		topics: string[] | string,
+		msg: PubSubContent,
+		options?: ProviderOptions
+	): void;
 
 	subscribe(
 		topics: string[] | string,
 		options?: ProviderOptions
-	): Observable<any>;
+	): Observable<PubSubContent>;
 }

package/src/types/PubSub.ts

@@ -1,5 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
+import { ZenObservable } from 'zen-observable-ts';
 
 export interface SubscriptionObserver<T> {
 	closed: boolean;
@@ -51,3 +52,7 @@ export enum ConnectionState {
 	 */
 	ConnectedPendingKeepAlive = 'ConnectedPendingKeepAlive',
 }
+
+export type PubSubContent = Record<string, unknown> | string;
+export type PubSubContentObserver =
+	ZenObservable.SubscriptionObserver<PubSubContent>;

package/src/types/index.ts

@@ -1,4 +1,4 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 export * from './Provider';
-export * from './PubSub';
+export { SubscriptionObserver, CONTROL_MSG, ConnectionState } from './PubSub';

package/src/utils/ConnectionStateMonitor.ts

@@ -1,7 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import { Reachability } from '@aws-amplify/core';
 import Observable, { ZenObservable } from 'zen-observable-ts';
 import { ConnectionState } from '../types/PubSub';
 import { ReachabilityMonitor } from './ReachabilityMonitor';