@idp.global/sdk 5.0.1 → 6.0.1

package/ts_server/classes.idp-global-server-client.ts

@@ -2,6 +2,7 @@ import * as plugins from './plugins.js';
 
 export interface IIdpGlobalServerClientOptions {
   baseUrl?: string;
+  backendToken?: string;
 }
 
 export const defaultIdpGlobalBaseUrl = 'https://idp.global';
@@ -27,35 +28,158 @@ export class IdpMfaRequiredError extends Error {
 export class IdpGlobalServerClient {
   private typedrouter: any = new plugins.typedrequest.TypedRouter();
   private typedsocket?: plugins.typedsocket.TypedSocket;
-  private typedsocketDeferred = plugins.smartpromise.defer<plugins.typedsocket.TypedSocket>();
+  private typedsocketDeferred = this.createConnectionDeferred();
+  private publicKeyPushHandlers: Array<(publicKeyPemArg: string) => void | Promise<void>> = [];
+  private blocklistPushHandlers: Array<(blockedJwtIdsArg: string[]) => void | Promise<void>> = [];
+  private connectionGeneration = 0;
+  private pendingSocketPromise?: Promise<plugins.typedsocket.TypedSocket>;
+  private connectionAbortController?: AbortController;
+  private stopWaiters = new Set<(errorArg: Error) => void>();
+  private stopping = false;
 
-  constructor(private optionsArg: IIdpGlobalServerClientOptions = {}) {}
+  constructor(private optionsArg: IIdpGlobalServerClientOptions = {}) {
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<plugins.idpInterfaces.request.IReq_PushPublicKeyForValidation>(
+        'pushPublicKeyForValidation',
+        async (requestArg) => {
+          await Promise.all(this.publicKeyPushHandlers.map((handlerArg) => handlerArg(requestArg.publicKeyPem)));
+          return {};
+        }
+      )
+    );
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<plugins.idpInterfaces.request.IReq_PushOrGetJwtIdBlocklist>(
+        'pushOrGetJwtIdBlocklist',
+        async (requestArg) => {
+          if (requestArg.blockedJwtIds) {
+            await Promise.all(this.blocklistPushHandlers.map((handlerArg) => handlerArg(requestArg.blockedJwtIds!)));
+          }
+          return {};
+        }
+      )
+    );
+  }
 
   public async connect(): Promise<plugins.typedsocket.TypedSocket> {
+    if (this.stopping) {
+      throw new Error('IdpGlobalServerClient is stopping');
+    }
     if (this.typedsocketDeferred.claimed) {
       return this.typedsocketDeferred.promise;
     }
-    this.typedsocketDeferred.claim();
-    this.typedsocket = await plugins.typedsocket.TypedSocket.createClient(
-      this.typedrouter,
-      this.getTypedRequestUrl(),
-    );
-    this.typedsocketDeferred.resolve(this.typedsocket);
-    return this.typedsocketDeferred.promise;
+    const deferred = this.typedsocketDeferred;
+    const generation = this.connectionGeneration;
+    deferred.claim();
+    let createdSocket: plugins.typedsocket.TypedSocket | undefined;
+    let socketPromise: Promise<plugins.typedsocket.TypedSocket> | undefined;
+    const connectionAbortController = new AbortController();
+    try {
+      this.connectionAbortController = connectionAbortController;
+      socketPromise = plugins.typedsocket.TypedSocket.createClient(
+        this.typedrouter,
+        this.getTypedRequestUrl(),
+        { autoReconnect: true, abortSignal: connectionAbortController.signal },
+      );
+      this.pendingSocketPromise = socketPromise;
+      createdSocket = await this.raceWithStop(socketPromise);
+      if (generation !== this.connectionGeneration) {
+        await createdSocket.stop();
+        if (deferred.status === 'pending') {
+          deferred.reject(new Error('IdpGlobalServerClient stopped while connecting'));
+        }
+        return deferred.promise;
+      }
+      this.typedsocket = createdSocket;
+      deferred.resolve(createdSocket);
+    } catch (error) {
+      if (generation === this.connectionGeneration && (!createdSocket || this.typedsocket === createdSocket)) {
+        this.typedsocket = undefined;
+      }
+      await createdSocket?.stop().catch(() => undefined);
+      if (deferred.status === 'pending') {
+        deferred.reject(error);
+      }
+      if (this.typedsocketDeferred === deferred) {
+        this.typedsocketDeferred = this.createConnectionDeferred();
+      }
+      throw error;
+    } finally {
+      if (socketPromise && this.pendingSocketPromise === socketPromise) {
+        this.pendingSocketPromise = undefined;
+      }
+      if (this.connectionAbortController === connectionAbortController) {
+        this.connectionAbortController = undefined;
+      }
+    }
+    return deferred.promise;
   }
 
   public async stop(): Promise<void> {
-    await this.typedsocket?.stop();
+    this.stopping = true;
+    this.connectionGeneration++;
+    const stopError = new Error('IdpGlobalServerClient stopped');
+    this.rejectStopWaiters(stopError);
+    const socket = this.typedsocket;
+    const pendingSocketPromise = this.pendingSocketPromise;
+    this.connectionAbortController?.abort();
+    this.connectionAbortController = undefined;
     this.typedsocket = undefined;
+    if (this.typedsocketDeferred.status === 'pending' && this.typedsocketDeferred.claimed) {
+      this.typedsocketDeferred.reject(stopError);
+    }
+    await socket?.stop();
+    const pendingSocket = await pendingSocketPromise?.catch(() => undefined);
+    if (pendingSocket && pendingSocket !== socket) {
+      await pendingSocket.stop().catch(() => undefined);
+    }
+    this.typedsocketDeferred = this.createConnectionDeferred();
+    this.pendingSocketPromise = undefined;
+    this.stopping = false;
+  }
+
+  public onPublicKeyPush(handlerArg: (publicKeyPemArg: string) => void | Promise<void>): () => void {
+    this.publicKeyPushHandlers.push(handlerArg);
+    return () => {
+      this.publicKeyPushHandlers = this.publicKeyPushHandlers.filter((handler) => handler !== handlerArg);
+    };
+  }
+
+  public onBlocklistPush(handlerArg: (blockedJwtIdsArg: string[]) => void | Promise<void>): () => void {
+    this.blocklistPushHandlers.push(handlerArg);
+    return () => {
+      this.blocklistPushHandlers = this.blocklistPushHandlers.filter((handler) => handler !== handlerArg);
+    };
+  }
+
+  public async registerBackendService(backendTokenArg = this.optionsArg.backendToken): Promise<void> {
+    const backendToken = this.requireBackendToken(backendTokenArg);
+    const socket = await this.connect();
+    await this.applyBackendServiceTag(socket, backendToken);
+  }
+
+  public async getPublicKeyForValidation(backendTokenArg = this.optionsArg.backendToken): Promise<string> {
+    const backendToken = this.requireBackendToken(backendTokenArg);
+    const socket = await this.connect();
+    const request = socket.createTypedRequest<plugins.idpInterfaces.request.IReq_GetPublicKeyForValidation>('getPublicKeyForValidation');
+    const response = await this.raceWithStop(request.fire({ backendToken }));
+    return response.publicKeyPem;
+  }
+
+  public async getJwtIdBlocklist(backendTokenArg = this.optionsArg.backendToken): Promise<string[]> {
+    const backendToken = this.requireBackendToken(backendTokenArg);
+    const socket = await this.connect();
+    const request = socket.createTypedRequest<plugins.idpInterfaces.request.IReq_PushOrGetJwtIdBlocklist>('pushOrGetJwtIdBlocklist');
+    const response = await this.raceWithStop(request.fire({ backendToken }));
+    return response.blockedJwtIds || [];
   }
 
   public async loginWithEmailAndPassword(optionsArg: { email: string; password: string }): Promise<IIdpPasswordAuthResult> {
     const socket = await this.connect();
     const loginRequest = socket.createTypedRequest<plugins.idpInterfaces.request.IReq_LoginWithEmailOrUsernameAndPassword>('loginWithEmailOrUsernameAndPassword');
-    const loginResponse = await loginRequest.fire({
+    const loginResponse = await this.raceWithStop(loginRequest.fire({
       username: optionsArg.email,
       password: optionsArg.password,
-    });
+    }));
     if (loginResponse.twoFaNeeded) {
       throw new IdpMfaRequiredError({
         mfaChallengeToken: (loginResponse as any).mfaChallengeToken,
@@ -67,13 +191,13 @@ export class IdpGlobalServerClient {
     }
 
     const refreshRequest = socket.createTypedRequest<plugins.idpInterfaces.request.IReq_RefreshJwt>('refreshJwt');
-    const refreshResponse = await refreshRequest.fire({ refreshToken: loginResponse.refreshToken });
+    const refreshResponse = await this.raceWithStop(refreshRequest.fire({ refreshToken: loginResponse.refreshToken }));
     if (!refreshResponse.jwt) {
       throw new Error('IdP did not return a JWT');
     }
 
     const whoIsRequest = socket.createTypedRequest<plugins.idpInterfaces.request.IReq_WhoIs>('whoIs');
-    const whoIsResponse = await whoIsRequest.fire({ jwt: refreshResponse.jwt });
+    const whoIsResponse = await this.raceWithStop(whoIsRequest.fire({ jwt: refreshResponse.jwt }));
     return {
       user: whoIsResponse.user,
       jwt: refreshResponse.jwt,
@@ -91,4 +215,47 @@ export class IdpGlobalServerClient {
     }
     return baseUrl;
   }
+
+  private requireBackendToken(backendTokenArg?: string): string {
+    if (!backendTokenArg) {
+      throw new Error('backendToken is required for backend JWT validation APIs');
+    }
+    return backendTokenArg;
+  }
+
+  private async applyBackendServiceTag(
+    socketArg: plugins.typedsocket.TypedSocket,
+    backendTokenArg: string
+  ): Promise<void> {
+    await this.raceWithStop(socketArg.setTag<plugins.idpInterfaces.tags.ITag_BackendService>('backend-service', {
+      backendToken: backendTokenArg,
+    }));
+  }
+
+  private createConnectionDeferred() {
+    const deferred = plugins.smartpromise.defer<plugins.typedsocket.TypedSocket>();
+    deferred.promise.catch(() => undefined);
+    return deferred;
+  }
+
+  private raceWithStop<T>(promiseArg: Promise<T>): Promise<T> {
+    promiseArg.catch(() => undefined);
+    if (this.stopping) {
+      return Promise.reject(new Error('IdpGlobalServerClient stopped'));
+    }
+    return new Promise<T>((resolve, reject) => {
+      const stopReject = (errorArg: Error) => reject(errorArg);
+      this.stopWaiters.add(stopReject);
+      promiseArg.then(resolve, reject).finally(() => {
+        this.stopWaiters.delete(stopReject);
+      });
+    });
+  }
+
+  private rejectStopWaiters(errorArg: Error): void {
+    for (const stopWaiter of this.stopWaiters) {
+      stopWaiter(errorArg);
+    }
+    this.stopWaiters.clear();
+  }
 }