Merge pull request #978 from OneSignal/user-model/login-fixes

User model/login fixes

Author: rgomezp

src/core/CoreModuleDirector.ts

@@ -18,15 +18,10 @@ import OneSignal from "../onesignal/OneSignal";
 /* Contains OneSignal User-Model-specific logic*/
 
 export class CoreModuleDirector {
-  private initPromise: Promise<void>;
 
-  constructor(private core: CoreModule) {
-    this.initPromise = core.initPromise.then(() => {}).catch(e => {
-      Log.error(e);
-    });
-  }
+  constructor(private core: CoreModule) {}
 
-  public async generatePushSubscriptionModel(rawPushSubscription: RawPushSubscription): Promise<void> {
+  public generatePushSubscriptionModel(rawPushSubscription: RawPushSubscription): void {
     logMethodCall("CoreModuleDirector.generatePushSubscriptionModel", { rawPushSubscription });
     // new subscription
     const pushModel = new OSModel<SupportedSubscription>(
@@ -39,19 +34,18 @@ export class CoreModuleDirector {
       pushModel.setOneSignalId(user.onesignalId);
     }
     // don't propagate since we will be including the subscription in the user create call
-    await OneSignal.coreDirector.add(ModelName.PushSubscriptions, pushModel as OSModel<SupportedModel>, false);
+    OneSignal.coreDirector.add(ModelName.PushSubscriptions, pushModel as OSModel<SupportedModel>, false);
   }
 
   public async resetModelRepoAndCache(): Promise<void> {
     await this.core.resetModelRepoAndCache();
   }
 
-  public async hydrateUser(user: UserData): Promise<void> {
+  public hydrateUser(user: UserData): void {
     logMethodCall("CoreModuleDirector.hydrateUser", { user });
     try {
-      await this.initPromise;
-      const identity = await this.getIdentityModel();
-      const properties = await this.getPropertiesModel();
+      const identity = this.getIdentityModel();
+      const properties = this.getPropertiesModel();
 
       const { onesignal_id: onesignalId } = user.identity;
 
@@ -69,23 +63,20 @@ export class CoreModuleDirector {
 
       // subscriptions are duplicable, so we hydrate them separately
       // when hydrating, we should have the full subscription object (i.e. include ID from server)
-      this._hydrateSubscriptions(user.subscriptions as SubscriptionModel[], onesignalId).catch(e => {
-        throw new OneSignalError(`Error hydrating subscriptions: ${e}`);
-      });
+      this._hydrateSubscriptions(user.subscriptions as SubscriptionModel[], onesignalId);
     } catch (e) {
       Log.error(`Error hydrating user: ${e}`);
     }
   }
 
-  private async _hydrateSubscriptions(subscriptions: SubscriptionModel[], onesignalId: string): Promise<void> {
+  private _hydrateSubscriptions(subscriptions: SubscriptionModel[], onesignalId: string): void {
     logMethodCall("CoreModuleDirector._hydrateSubscriptions", { subscriptions });
 
     if (!subscriptions) {
       return;
     }
 
-    await this.initPromise;
-    const modelStores = await this.getModelStores();
+    const modelStores = this.getModelStores();
 
     const getModelName = (subscription: SupportedSubscription) => {
       if (subscription.type === "Email") {
@@ -104,7 +95,7 @@ export class CoreModuleDirector {
        * We don't want to create a new model in this case, so we use the token to identify the model.
        */
       const existingSubscription = !!subscription.token ?
-        await this.getSubscriptionOfTypeWithToken(modelName, subscription.token) :
+        this.getSubscriptionOfTypeWithToken(modelName, subscription.token) :
         undefined;
 
       if (existingSubscription) {
@@ -127,59 +118,54 @@ export class CoreModuleDirector {
 
   /* O P E R A T I O N S */
 
-  public async add(modelName: ModelName, model: OSModel<SupportedModel>, propagate: boolean = true): Promise<void> {
+  public add(modelName: ModelName, model: OSModel<SupportedModel>, propagate: boolean = true): void {
     logMethodCall("CoreModuleDirector.add", { modelName, model });
-    const modelStores = await this.getModelStores();
+    const modelStores = this.getModelStores();
     modelStores[modelName].add(model, propagate);
   }
 
-  public async remove(modelName: ModelName, modelId: string): Promise<void> {
+  public remove(modelName: ModelName, modelId: string): void {
     logMethodCall("CoreModuleDirector.remove", { modelName, modelId });
-    const modelStores = await this.getModelStores();
+    const modelStores = this.getModelStores();
     modelStores[modelName].remove(modelId);
   }
 
   /* G E T T E R S */
 
-  public async getModelByTypeAndId(modelName: ModelName, modelId: string):
-    Promise<OSModel<SupportedModel> | undefined> {
+  public getModelByTypeAndId(modelName: ModelName, modelId: string): OSModel<SupportedModel> | undefined {
       logMethodCall("CoreModuleDirector.getModelByTypeAndId", { modelName, modelId });
-      await this.initPromise;
-      const modelStores = await this.getModelStores();
+      const modelStores = this.getModelStores();
       return modelStores[modelName].models[modelId];
   }
 
-  public async getEmailSubscriptionModels(): Promise<{ [key: string]: OSModel<SupportedSubscription> }> {
+  public getEmailSubscriptionModels(): { [key: string]: OSModel<SupportedSubscription> } {
     logMethodCall("CoreModuleDirector.getEmailSubscriptionModels");
-    await this.initPromise;
-    const modelStores = await this.getModelStores();
+    const modelStores = this.getModelStores();
     return modelStores.emailSubscriptions.models as { [key: string]: OSModel<SupportedSubscription> };
   }
 
-  public async getSmsSubscriptionModels(): Promise<{ [key: string]: OSModel<SupportedSubscription> }> {
+  public getSmsSubscriptionModels(): { [key: string]: OSModel<SupportedSubscription> } {
     logMethodCall("CoreModuleDirector.getSmsSubscriptionModels");
-    await this.initPromise;
-    const modelStores = await this.getModelStores();
+    const modelStores = this.getModelStores();
     return modelStores.smsSubscriptions.models as { [key: string]: OSModel<SupportedSubscription> };
   }
 
   /**
    * Returns all push subscription models, including push subscriptions from other browsers.
    */
-  public async getAllPushSubscriptionModels(): Promise<{ [key: string]: OSModel<SupportedSubscription> }> {
+  public getAllPushSubscriptionModels(): { [key: string]: OSModel<SupportedSubscription> } {
     logMethodCall("CoreModuleDirector.getAllPushSubscriptionModels");
-    await this.initPromise;
-    const modelStores = await this.getModelStores();
+    const modelStores = this.getModelStores();
     return modelStores.pushSubscriptions.models as { [key: string]: OSModel<SupportedSubscription> };
   }
 
   /**
    * Gets the current push subscription model for the current browser.
    * @returns The push subscription model for the current browser, or undefined if no push subscription exists.
    */
+  // TO DO: make synchronous by making getting the current push token synchronous
   public async getCurrentPushSubscriptionModel(): Promise<OSModel<SupportedSubscription> | undefined> {
     logMethodCall("CoreModuleDirector.getPushSubscriptionModel");
-    await this.initPromise;
     const pushToken = await MainHelper.getCurrentPushToken();
 
     if (!pushToken) {
@@ -189,27 +175,24 @@ export class CoreModuleDirector {
     return this.getSubscriptionOfTypeWithToken(ModelName.PushSubscriptions, pushToken);
   }
 
-  public async getIdentityModel(): Promise<OSModel<SupportedIdentity> | undefined> {
+  public getIdentityModel(): OSModel<SupportedIdentity> | undefined {
     logMethodCall("CoreModuleDirector.getIdentityModel");
-    await this.initPromise;
-    const modelStores = await this.getModelStores();
+    const modelStores = this.getModelStores();
     const modelKeys = Object.keys(modelStores.identity.models);
     return modelStores.identity.models[modelKeys[0]] as OSModel<SupportedIdentity>;
   }
 
-  public async getPropertiesModel(): Promise<OSModel<UserPropertiesModel> | undefined> {
+  public getPropertiesModel(): OSModel<UserPropertiesModel> | undefined {
     logMethodCall("CoreModuleDirector.getPropertiesModel");
-    await this.initPromise;
-    const modelStores = await this.getModelStores();
+    const modelStores = this.getModelStores();
     const modelKeys = Object.keys(modelStores.properties.models);
     return modelStores.properties.models[modelKeys[0]] as OSModel<UserPropertiesModel>;
   }
 
   public async getAllSubscriptionsModels(): Promise<OSModel<SupportedSubscription>[]> {
     logMethodCall("CoreModuleDirector.getAllSubscriptionsModels");
-    await this.initPromise;
-    const emailSubscriptions = await this.getEmailSubscriptionModels();
-    const smsSubscriptions = await this.getSmsSubscriptionModels();
+    const emailSubscriptions = this.getEmailSubscriptionModels();
+    const smsSubscriptions = this.getSmsSubscriptionModels();
     const pushSubscription = await this.getCurrentPushSubscriptionModel();
 
     const subscriptions = Object.values(emailSubscriptions)
@@ -218,20 +201,18 @@ export class CoreModuleDirector {
     return subscriptions;
   }
 
-  public async getSubscriptionOfTypeWithToken(type: ModelName, token: string):
-    Promise<OSModel<SupportedSubscription> | undefined>
+  public getSubscriptionOfTypeWithToken(type: ModelName, token: string): OSModel<SupportedSubscription> | undefined
     {
       logMethodCall("CoreModuleDirector.getSubscriptionOfTypeWithToken", { type, token });
-      await this.initPromise;
       switch (type) {
         case ModelName.EmailSubscriptions:
-          const emailSubscriptions = await this.getEmailSubscriptionModels();
+          const emailSubscriptions = this.getEmailSubscriptionModels();
           return Object.values(emailSubscriptions).find(subscription => subscription.data.token === token);
         case ModelName.SmsSubscriptions:
-          const smsSubscriptions = await this.getSmsSubscriptionModels();
+          const smsSubscriptions = this.getSmsSubscriptionModels();
           return Object.values(smsSubscriptions).find(subscription => subscription.data.token === token);
         case ModelName.PushSubscriptions:
-          const pushSubscriptions = await this.getAllPushSubscriptionModels();
+          const pushSubscriptions = this.getAllPushSubscriptionModels();
           return Object.values(pushSubscriptions).find(subscription => subscription.data.token === token);
         default:
           return undefined;
@@ -240,8 +221,7 @@ export class CoreModuleDirector {
 
   /* P R I V A T E */
 
-  private async getModelStores(): Promise<ModelStoresMap<SupportedModel>> {
-    await this.initPromise;
+  private getModelStores(): ModelStoresMap<SupportedModel> {
     return (this.core.modelRepo?.modelStores as ModelStoresMap<SupportedModel>);
   }
 }

src/core/operationRepo/Operation.ts

@@ -73,7 +73,7 @@ export class Operation<Model> {
       if (!model) {
         throw new OneSignalError("Operation.fromJSON: model is undefined");
       }
-      const osModel = await OneSignal.coreDirector?.getModelByTypeAndId(modelName, model.modelId);
+      const osModel = OneSignal.coreDirector?.getModelByTypeAndId(modelName, model.modelId);
 
       if (!!osModel) {
         const operation = new Operation<SupportedModel>(changeType, modelName);

src/onesignal/OneSignal.ts

@@ -45,10 +45,12 @@ import { OneSignalDeferredLoadedCallback } from "../page/models/OneSignalDeferre
 import UserDirector from "./UserDirector";
 import { ModelName, SupportedModel } from "../core/models/SupportedModels";
 import { OSModel } from "../core/modelRepo/OSModel";
+import UserData from "../core/models/UserData";
 
 export default class OneSignal {
   private static async _initializeCoreModuleAndUserNamespace() {
     const core = new CoreModule();
+    await core.initPromise;
     OneSignal.coreDirector = new CoreModuleDirector(core);
     OneSignal.User = new UserNamespace();
   }
@@ -101,7 +103,7 @@ export default class OneSignal {
         await Database.setJWTToken(token);
       }
 
-      const identityModel = await this.coreDirector.getIdentityModel();
+      const identityModel = this.coreDirector.getIdentityModel();
 
       if (!identityModel) {
         throw new OneSignalError('Login: No identity model found');
@@ -127,7 +129,21 @@ export default class OneSignal {
       // set the external id on the user locally
       LoginManager.setExternalId(identityModel, externalId);
 
-      const userData = await UserDirector.getAllUserData();
+      let userData: Partial<UserData>;
+      const pushSubscription = await this.coreDirector.getCurrentPushSubscriptionModel();
+      if (!isIdentified) {
+        userData = await UserDirector.getAllUserData();
+      } else {
+        userData = {
+          identity: {
+            external_id: externalId,
+          }
+        };
+
+        if (pushSubscription) {
+          userData.subscriptions = [pushSubscription.data];
+        }
+      }
       await this.coreDirector.resetModelRepoAndCache();
       await UserDirector.initializeUser(true);
       await OneSignal.User.PushSubscription._resubscribeToPushModelChanges();
@@ -158,7 +174,7 @@ export default class OneSignal {
     const pushSubModel = await this.coreDirector.getCurrentPushSubscriptionModel();
     await this.coreDirector.resetModelRepoAndCache();
     // add the push subscription model back to the repo since we need at least 1 sub to create a new user
-    await this.coreDirector.add(ModelName.PushSubscriptions, pushSubModel as OSModel<SupportedModel>, false);
+    this.coreDirector.add(ModelName.PushSubscriptions, pushSubModel as OSModel<SupportedModel>, false);
     await UserDirector.initializeUser(false);
     await OneSignal.User.PushSubscription._resubscribeToPushModelChanges();
   }