@sudoplatform/sudo-notification 1.0.0

package/types/public/sudoNotificationClient.d.ts

@@ -0,0 +1,109 @@
+import { SendTestNotificationInput } from '../gen/graphqlTypes';
+import { CanonicalPushSubscriptionJSON } from '../private/types/canonicalPushSubscriptionJSON';
+import { NotificationConfiguration } from './types/notificationConfiguration';
+import { NotificationDeviceInfo } from './types/notificationDeviceInfo';
+import { SudoNotificationClientOptions } from './types/sudoNotificationClientOptions';
+/**
+ * Client used to interface with the Sudo Notification Platform service.
+ *
+ * It is recommended to code to this interface, rather than the implementation class (`DefaultSudoNotificationClient`) as
+ * the implementation class is only meant to be used for initializing an instance of the client.
+ */
+export interface SudoNotificationClient {
+    /**
+     * Register to receive Sudo Platform web push notifications on a given
+     * Web Push API subscription.
+     *
+     * @param deviceInfo Information that identifies the user's device and application
+     * @param pushSubscription The web push subscription to register
+     *
+     * @throws NotSignedInError if user is not signed in
+     * @throws DeviceAlreadyRegisteredError if the same subscription has already been registered
+     * @throws DeviceCreateError if some other issue registering the subscription occurs
+     */
+    registerPushSubscription(deviceInfo: NotificationDeviceInfo, pushSubscription: PushSubscription): Promise<void>;
+    /**
+     * Update registration for the user with new push subscription information.
+     *
+     * @param deviceInfo Information that identifies the user's device and application
+     * @param pushSubscription
+     *    Push subscription to update. The push subscription's endpoint must be
+     *    the same. The only reason to update is to change the subscription's
+     *    expiration.
+     *
+     *  @throws {@link DeviceNotFoundError} if the push subscription has not been registered
+     *  @throws {@link DeviceUpdateError} if the device update fails
+     */
+    updatePushSubscription(deviceInfo: NotificationDeviceInfo, pushSubscription: PushSubscription): Promise<void>;
+    /**
+     * Deregister a push subscription for the user
+     *
+     * @param deviceInfo Information that identifies the user's device and application
+     *
+     * @throws {@link DeviceNotFoundError} if the push subscription has not been registered
+     * @throws {@link DeviceDeleteError} if the deregistration fails
+     */
+    deregisterPushSubscription(deviceInfo: NotificationDeviceInfo): Promise<void>;
+    /**
+     * Get the user's current set of notification configurations for a push
+     * subscription.
+     *
+     * @param deviceInfo Information that identifies the user's device and application
+     *
+     * @throws {@link DeviceNotFoundError} if the device has not been registered
+     * @throws {@link DeviceReadError} if the retrieval fails for some other reason
+     */
+    getNotificationConfiguration(deviceInfo: NotificationDeviceInfo): Promise<NotificationConfiguration>;
+    /**
+     * Set the notification configuration for the user.
+     *
+     * @param deviceInfo Information that identifies the user's device and application
+     *
+     * @throws {@link DeviceNotFoundError} if the device has not been registered
+     * @throws {@link SchemaValidationError} if the retrieval fails for some other reason
+     */
+    setNotificationConfiguration(deviceInfo: NotificationDeviceInfo, config: NotificationConfiguration): Promise<void>;
+    /** @ignore */
+    sendTestNotification(input: SendTestNotificationInput): Promise<boolean>;
+}
+/**
+ * Default {@link SudoNotificationClient} for use by Sudo Platform applications.
+ */
+export declare class DefaultSudoNotificationClient implements SudoNotificationClient {
+    private readonly apiClient;
+    private readonly sudoUserClient;
+    private readonly notifiableServices;
+    private readonly notificationServiceConfig;
+    private readonly logger;
+    /**
+     * Constructor
+     *
+     * @param opts Constructor options
+     *    {@link SudoNotificationClientOptions.sudoUserClient} user client to authenticate the user
+     *    {@link SudoNotificationClientOptions.notifiableServices} array of {@link SudoNotificationFilterClient}s from
+     *    other notification enabled Sudo Platform SDKs.
+     *
+     * @throws
+     *    NotificationServiceConfigNotFoundError if the Sudo Platform Notification Service is
+     *    deployed in the Sudo Platform environment in which the SDK is being used.
+     *
+     * @throws
+     *    InvalidConfigurationError if any of the services identified in opts.notifiableServices does
+     *    not have notifications enabled.
+     */
+    constructor(opts: SudoNotificationClientOptions);
+    registerPushSubscription(deviceInfo: NotificationDeviceInfo, pushSubscription: PushSubscription): Promise<void>;
+    updatePushSubscription(deviceInfo: NotificationDeviceInfo, pushSubscription: PushSubscription): Promise<void>;
+    deregisterPushSubscription(deviceInfo: NotificationDeviceInfo): Promise<void>;
+    getNotificationConfiguration(deviceInfo: NotificationDeviceInfo): Promise<NotificationConfiguration>;
+    setNotificationConfiguration(deviceInfo: NotificationDeviceInfo, config: NotificationConfiguration): Promise<void>;
+    /** @ignore */
+    sendTestNotification(input: SendTestNotificationInput): Promise<boolean>;
+    /**
+     * Visible for testing
+     *
+     * @ignore
+     */
+    canonicalPushSubscriptionJson(json: PushSubscriptionJSON): CanonicalPushSubscriptionJSON;
+    private checkIsSignedInOrThrow;
+}

package/types/public/types/buildType.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Build type fo the host application. Allows use of separate VAPID
+ * keys between debug and release deployments of the same application.
+ */
+export declare enum BuildType {
+    RELEASE = "RELEASE",
+    DEBUG = "DEBUG"
+}

package/types/public/types/index.d.ts

@@ -0,0 +1,11 @@
+export * from './buildType';
+export * from './notificationConfiguration';
+export * from './notificationDeviceInfo';
+export * from './notificationEnabledStatus';
+export * from './notificationFilterItem';
+export * from './notificationMetadata';
+export * from './notificationSchemaEntry';
+export * from './sudoNotification';
+export * from './sudoNotificationClientOptions';
+export * from './sudoNotificationData';
+export * from './sudoNotificationFilterClient';

package/types/public/types/notificationConfiguration.d.ts

@@ -0,0 +1,6 @@
+import { NotificationFilterItem } from './notificationFilterItem';
+export declare class NotificationConfiguration {
+    private _configs;
+    constructor(configs: NotificationFilterItem[]);
+    get configs(): ReadonlyArray<NotificationFilterItem>;
+}

package/types/public/types/notificationDeviceInfo.d.ts

@@ -0,0 +1,41 @@
+import { BuildType } from './buildType';
+/**
+ * Information that uniquely identifies the device and application that is
+ * registering to receive web push notifications. Device IDs a scoped
+ * by the user's subject ID and applications' bundle ID and so only needs
+ * to be unique among all the user's devices. If bundle ID is shared across
+ * platforms then the device ID should be further qualified by platform by
+ * the consuming application.
+ *
+ * Notifications are sent to a subscription associated with a particular
+ * device ID, and the device ID is used to contain the notification filter
+ * configuration i.e. the rules for which notifications the user wants
+ * to receive on the particular device. Consuming applications may need to
+ * derive the device ID in a consistent way from the browser environment
+ * or persist a generated random device ID.
+ */
+export interface NotificationDeviceInfo {
+    /**
+     * ID representing user and device that perists beyond
+     * lifetime of a single push subscription
+     */
+    deviceId: string;
+    /**
+     * Reverse DNS name idenfifying the application. For example
+     * com.sudoplatform.examples.notification.
+     */
+    bundleId: string;
+    /**
+     * Type of build. Allows for separate keys to be used in debug vs production
+     * environments.
+     */
+    buildType: BuildType;
+    /**
+     * Version of the application.
+     */
+    appVersion: string;
+    /**
+     * User's locale.
+     */
+    locale: string;
+}

package/types/public/types/notificationEnabledStatus.d.ts

@@ -0,0 +1,4 @@
+export declare enum NotificationEnableStatus {
+    Enable = "ENABLE",
+    Disable = "DISABLE"
+}

package/types/public/types/notificationFilterItem.d.ts

@@ -0,0 +1,13 @@
+import { NotificationEnableStatus } from './notificationEnabledStatus';
+export declare class NotificationFilterItem {
+    static readonly DEFAULT_RULE_STRING = "{\"==\": [1, 1]}";
+    private readonly _name;
+    private readonly _status;
+    private readonly _rules;
+    private readonly _meta;
+    constructor(name: string, status: boolean | undefined, rules: string | undefined, meta: string | undefined);
+    get name(): string;
+    get status(): NotificationEnableStatus;
+    get rules(): string;
+    get meta(): string;
+}

package/types/public/types/notificationMetadata.d.ts

@@ -0,0 +1,22 @@
+import { NotificationSchemaEntry } from './notificationSchemaEntry';
+/**
+ * Definition of all filterable notification properties of a specific
+ * service.
+ */
+export declare class NotificationMetadata {
+    /**
+     * Name of service for the implementing Sudo Platform SDK. Matches the corresponding service's configuration
+     * section within sudoplatformconfig.json
+     */
+    readonly serviceName: string;
+    /** Array of schema entries, one for each filterable property */
+    readonly schema: ReadonlyArray<NotificationSchemaEntry>;
+    constructor(
+    /**
+     * Name of service for the implementing Sudo Platform SDK. Matches the corresponding service's configuration
+     * section within sudoplatformconfig.json
+     */
+    serviceName: string, 
+    /** Array of schema entries, one for each filterable property */
+    schema: ReadonlyArray<NotificationSchemaEntry>);
+}

package/types/public/types/notificationSchemaEntry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Schema of a single filterable property of a notification
+ */
+export declare class NotificationSchemaEntry {
+    /** Description of the filterable property */
+    readonly description: string;
+    /** Name of the filterable property */
+    readonly fieldName: string;
+    /** Type of the filterable property */
+    readonly type: string;
+    constructor(
+    /** Description of the filterable property */
+    description: string, 
+    /** Name of the filterable property */
+    fieldName: string, 
+    /** Type of the filterable property */
+    type: string);
+}

package/types/public/types/sudoNotification.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Base SudoNotification class. Service specific SDKs provide concrete classes extending this
+ * base class that will be returned by SudoNotifiableClient.decodeData.
+ */
+export declare abstract class SudoNotification {
+    /**
+     *  Name of service for the implementing Sudo Platform SDK. Matches the corresponding
+     *  service's configuration section within sudoplatformconfig.json
+     */
+    readonly serviceName: string;
+    /**
+     *  Service specific type of notification.
+     */
+    readonly type: string;
+    constructor(
+    /**
+     *  Name of service for the implementing Sudo Platform SDK. Matches the corresponding
+     *  service's configuration section within sudoplatformconfig.json
+     */
+    serviceName: string, 
+    /**
+     *  Service specific type of notification.
+     */
+    type: string);
+}

package/types/public/types/sudoNotificationClientOptions.d.ts

@@ -0,0 +1,11 @@
+import { SudoUserClient } from '@sudoplatform/sudo-user';
+import { SudoNotificationFilterClient } from './sudoNotificationFilterClient';
+/**
+ * Options passed in to DefaultSudoNotificationClient's constructor
+ */
+export interface SudoNotificationClientOptions {
+    /** Sudo User client to use. No default */
+    sudoUserClient: SudoUserClient;
+    /** Array of notifiable Sudo Platform services */
+    notifiableServices: SudoNotificationFilterClient[];
+}

package/types/public/types/sudoNotificationData.d.ts

@@ -0,0 +1,14 @@
+export declare class SudoNotificationData {
+    readonly serviceName: string;
+    readonly data?: string | undefined;
+    /**
+     *
+     * @param serviceName
+     *  Name of service for the implementing Sudo Platform SDK. Matches the corresponding
+     *  service's configuration section within sudoplatformconfig.json
+     *
+     * @param data
+     *  Opaque, serialized service specific notification data
+     */
+    constructor(serviceName: string, data?: string | undefined);
+}

package/types/public/types/sudoNotificationFilterClient.d.ts

@@ -0,0 +1,17 @@
+import { NotificationMetadata } from './notificationMetadata';
+/**
+ * Client used to provide filter schema information to the notification SDk. Each Sudo Platform service SDK that has
+ * notifications provides an implementation of this protocol that must be passed to `DefaultSudoNotificationClient`
+ * on construction.
+ */
+export interface SudoNotificationFilterClient {
+    /**
+     * Name of service for the implementing Sudo Platform SDK. Matches the corresponding service's configuration
+     * section within sudoplatformconfig.json
+     */
+    serviceName: string;
+    /**
+     * Return the schema describing properties available for filtering for the specific service
+     */
+    getSchema(): NotificationMetadata;
+}