new no identity available event

src/callbackManager.ts

@@ -7,6 +7,7 @@ export enum EventType {
   IdentityUpdated = 'IdentityUpdated',
   SdkLoaded = 'SdkLoaded',
   OptoutReceived = 'OptoutReceived',
+  NoIdentityAvailable = 'NoIdentityAvailable',
 }
 
 export type CallbackPayload = SdkLoadedPayload | PayloadWithIdentity;
@@ -52,12 +53,17 @@ export class CallbackManager {
   public runCallbacks(event: EventType, payload: CallbackPayload) {
     if (event === EventType.InitCompleted) this._sentInit = true;
     if (event === EventType.SdkLoaded) CallbackManager._sentSdkLoaded[this._productName] = true;
-    if (!this._sentInit && event !== EventType.SdkLoaded) return;
+    // if SDK has not been loaded yet, callbacks should not run
+    if (!CallbackManager._sentSdkLoaded[this._productName]) return;
 
     const enrichedPayload = {
       ...payload,
       identity: this._getIdentity() ?? null,
     };
+    if (event === EventType.NoIdentityAvailable && enrichedPayload.identity) {
+      enrichedPayload.identity = null;
+    }
+
     for (const callback of this._sdk.callbacks) {
       this.safeRunCallback(callback, event, enrichedPayload);
     }

src/integrationTests/options.test.ts

@@ -1,7 +1,7 @@
 import { afterEach, beforeEach, describe, expect, jest, test } from '@jest/globals';
 
 import * as mocks from '../mocks';
-import { SdkOptions, sdkWindow, UID2 } from '../uid2Sdk';
+import { EventType, SdkOptions, sdkWindow, UID2 } from '../uid2Sdk';
 import { loadConfig, removeConfig } from '../configManager';
 import { ProductDetails } from '../product';
 
@@ -556,3 +556,139 @@ describe('Store config UID2', () => {
     });
   });
 });
+
+describe('calls the NoIdentityAvailable event', () => {
+  let handler: ReturnType<typeof jest.fn>;
+  let expiredIdentity = makeIdentity({
+    identity_expires: Date.now() - 100000,
+    refresh_expires: Date.now() - 100000,
+  });
+
+  beforeEach(() => {
+    handler = jest.fn();
+    uid2.callbacks.push(handler);
+  });
+
+  test('when init is called for the first time with no identity', () => {
+    uid2.init({});
+
+    expect(handler).toHaveBeenLastCalledWith(EventType.NoIdentityAvailable, { identity: null });
+  });
+  test('when init is already complete and called again with no identity', () => {
+    uid2.init({});
+    uid2.init({});
+
+    expect(handler).toHaveBeenLastCalledWith(EventType.NoIdentityAvailable, { identity: null });
+  });
+  test('when init is already complete and called again with an expired identity', () => {
+    uid2.init({});
+    uid2.init({
+      identity: expiredIdentity,
+    });
+
+    expect(handler).toHaveBeenLastCalledWith(EventType.NoIdentityAvailable, { identity: null });
+  });
+  test('when init is already complete but the existing identity is expired', () => {
+    uid2.init({
+      identity: expiredIdentity,
+    });
+    uid2.init({});
+
+    expect(handler).toHaveBeenLastCalledWith(EventType.NoIdentityAvailable, { identity: null });
+  });
+  test('when identity is expired but refreshable', () => {
+    let expiredRefreshableIdentity = makeIdentity({
+      identity_expires: Date.now() - 10000,
+      refresh_expires: Date.now() + 10000,
+    });
+    uid2.init({ identity: expiredRefreshableIdentity });
+
+    // in this case, identity is temporarily unavailable but still unavailable
+    expect(handler).toHaveBeenLastCalledWith(EventType.NoIdentityAvailable, { identity: null });
+  });
+  test('when login is required', () => {
+    uid2.isLoginRequired();
+
+    expect(handler).toHaveBeenLastCalledWith(EventType.NoIdentityAvailable, { identity: null });
+  });
+  test('when get identity returns null', () => {
+    uid2.getIdentity();
+
+    expect(handler).toHaveBeenLastCalledWith(EventType.NoIdentityAvailable, { identity: null });
+  });
+  test('when there is no advertising token', () => {
+    uid2.getAdvertisingToken();
+
+    expect(handler).toHaveBeenLastCalledWith(EventType.NoIdentityAvailable, { identity: null });
+  });
+  test('when cstg does not succeed', () => {
+    uid2.init({});
+
+    expect(uid2.setIdentityFromEmail('a', mocks.makeUid2CstgOption())).rejects.toThrow(
+      'Invalid email address'
+    );
+    expect(handler).toHaveBeenLastCalledWith(EventType.NoIdentityAvailable, { identity: null });
+  });
+  test('when identity was valid on init but has since expired', () => {
+    const originalIdentity = makeIdentity({
+      advertising_token: 'original_advertising_token',
+      identity_expires: Date.now() + 100,
+    });
+    uid2.init({ identity: originalIdentity });
+
+    expect(handler).not.toHaveBeenLastCalledWith(EventType.NoIdentityAvailable, { identity: null });
+
+    // set time to an expired date for this identity
+    jest.setSystemTime(originalIdentity.refresh_expires * 1000 + 1);
+
+    uid2.isIdentityAvailable();
+
+    expect(handler).toHaveBeenLastCalledWith(EventType.NoIdentityAvailable, { identity: null });
+  });
+});
+
+describe('does not call NoIdentityAvailable event', () => {
+  let validIdentity = makeIdentity();
+  let handler: ReturnType<typeof jest.fn>;
+  beforeEach(() => {
+    handler = jest.fn();
+    uid2.callbacks.push(handler);
+  });
+
+  test('when setIdentity is run with a valid identity, should not call NoIdentityAvailable on set or get', () => {
+    uid2.init({});
+    handler = jest.fn();
+
+    uid2.setIdentity(validIdentity);
+    uid2.getIdentity();
+    uid2.getAdvertisingToken();
+
+    expect(handler).not.toHaveBeenCalledWith(EventType.NoIdentityAvailable, { identity: null });
+  });
+  test('when identity is set with opted out identity', () => {
+    uid2.init({ identity: makeIdentity({ status: 'optout' }) });
+
+    expect(handler).not.toHaveBeenLastCalledWith(EventType.NoIdentityAvailable, { identity: null });
+  });
+  test('when cstg is successful', async () => {
+    uid2.init({});
+    handler = jest.fn();
+
+    expect(async () => {
+      await uid2.setIdentityFromEmail('test@test.com', mocks.makeUid2CstgOption());
+    }).not.toThrow();
+    expect(handler).not.toHaveBeenLastCalledWith(EventType.NoIdentityAvailable, { identity: null });
+  });
+  test('when identity is set with local storage and init has never been called', () => {
+    mocks.setUid2LocalStorage(validIdentity);
+    uid2.isIdentityAvailable();
+
+    expect(handler).not.toHaveBeenLastCalledWith(EventType.NoIdentityAvailable, { identity: null });
+  });
+  test('when identity is set with cookie and init has never been called', () => {
+    mocks.setUid2Cookie(validIdentity);
+    uid2.isIdentityAvailable();
+
+    expect(handler).not.toHaveBeenLastCalledWith(EventType.NoIdentityAvailable, { identity: null });
+  });
+});

src/sdkBase.ts

@@ -84,7 +84,7 @@ export abstract class SdkBase {
     this._callbackManager = new CallbackManager(
       this,
       this._product.name,
-      () => this.getIdentity(),
+      () => this.getIdentityForCallback(),
       this._logger
     );
   }
@@ -159,9 +159,22 @@ export abstract class SdkBase {
       }
       this._callbackManager.runCallbacks(EventType.IdentityUpdated, {});
     }
+    this.isIdentityAvailable();
   }
 
   public getIdentity(): Identity | null {
+    const identity = this._identity ?? this.getIdentityNoInit();
+    const isValid =
+      identity && !this.temporarilyUnavailable(identity) && !isOptoutIdentity(identity);
+    if (!isValid) {
+      this._callbackManager.runCallbacks(EventType.NoIdentityAvailable, {});
+      return null;
+    } else {
+      return identity;
+    }
+  }
+
+  private getIdentityForCallback(): Identity | null {
     const identity = this._identity ?? this.getIdentityNoInit();
     return identity && !this.temporarilyUnavailable(identity) && !isOptoutIdentity(identity)
       ? identity
@@ -181,11 +194,27 @@ export abstract class SdkBase {
   }
 
   public isLoginRequired() {
+    const identity = this._identity ?? this.getIdentityNoInit();
+    // if identity temporarily unavailable, login is not required
+    if (this.temporarilyUnavailable(identity)) {
+      return false;
+    }
     return !this.isIdentityAvailable();
   }
 
   public isIdentityAvailable() {
-    return this.isIdentityValid() || this._apiClient?.hasActiveRequests();
+    const identity = this._identity ?? this.getIdentityNoInit();
+    const identityAvailable =
+      (this.isIdentityValid(identity) && !this.temporarilyUnavailable(identity)) ||
+      this._apiClient?.hasActiveRequests();
+
+    if (!identityAvailable) {
+      if (this._callbackManager) {
+        this._callbackManager.runCallbacks(EventType.NoIdentityAvailable, {});
+      }
+      return false;
+    }
+    return true;
   }
 
   public hasOptedOut() {
@@ -230,10 +259,14 @@ export abstract class SdkBase {
         this._initCallbackManager?.addInitCallback(opts.callback);
       }
 
-      const useNewIdentity =
-        opts.identity &&
-        (!previousOpts.identity ||
-          opts.identity.identity_expires > previousOpts.identity.identity_expires);
+      let useNewIdentity;
+      if (!opts.identity) useNewIdentity = true;
+      else {
+        useNewIdentity =
+          !previousOpts.identity ||
+          opts.identity.identity_expires > previousOpts.identity.identity_expires;
+      }
+
       if (useNewIdentity || opts.callback) {
         let identity = useNewIdentity ? opts.identity : previousOpts.identity ?? null;
         if (identity) {
@@ -277,11 +310,11 @@ export abstract class SdkBase {
 
     this.setInitComplete(true);
     this._callbackManager?.runCallbacks(EventType.InitCompleted, {});
+    this.isIdentityAvailable();
     if (this.hasOptedOut()) this._callbackManager.runCallbacks(EventType.OptoutReceived, {});
   }
 
-  private isIdentityValid() {
-    const identity = this._identity ?? this.getIdentityNoInit();
+  private isIdentityValid(identity: Identity | OptoutIdentity | null | undefined) {
     return identity && !hasExpired(identity.refresh_expires);
   }
 
@@ -499,6 +532,7 @@ export abstract class SdkBase {
     } else {
       const errorText = 'Unexpected status received from CSTG endpoint.';
       this._logger.warn(errorText);
+      this.isIdentityAvailable();
       throw new Error(errorText);
     }
   }