feat(sdk): add initial browser and server authentication SDK exports

2026-05-13 23:11:56 +00:00
commit cb41ec6e6f
22 changed files with 10964 additions and 0 deletions
@@ -0,0 +1,318 @@
+import { IdpRequests } from './classes.idprequests.js';
+import * as plugins from './plugins.js';
+
+export class IdpClient {
+  private helpers = {
+    async extractDataFromJwtString(jwtString: string): Promise<plugins.idpInterfaces.data.IJwt> {
+      return plugins.webjwt.getDataFromJwtString(jwtString);
+    },
+  };
+
+  public appData: plugins.idpInterfaces.data.IAppLegacy;
+  public rolesReplaySubject = new plugins.smartrx.rxjs.ReplaySubject(1);
+  public organizationsReplaySubject = new plugins.smartrx.rxjs.ReplaySubject(1);
+
+  public parsedReceptionUrl: plugins.smarturl.Smarturl;
+
+  constructor(receptionBaseUrlArg: string, appDataArg?: plugins.idpInterfaces.data.IAppLegacy) {
+    if (receptionBaseUrlArg.endsWith('/')) {
+      receptionBaseUrlArg = receptionBaseUrlArg.slice(0, -1);
+    }
+    if (!receptionBaseUrlArg.endsWith('/typedrequest')) {
+      receptionBaseUrlArg = `${receptionBaseUrlArg}/typedrequest`;
+    }
+    this.parsedReceptionUrl = plugins.smarturl.Smarturl.createFromUrl(receptionBaseUrlArg);
+    if (!appDataArg) {
+      appDataArg = {
+        id: '',
+        appUrl: typeof window !== 'undefined' ? `https://${window.location.host}/` : '',
+        description: '',
+        logoUrl: '',
+        name: '',
+      };
+    }
+    this.appData = appDataArg;
+  }
+
+  public requests = new IdpRequests(this);
+
+  public checkWetherOnReceptionDomain() {
+    return plugins.smarturl.Smarturl.createFromUrl(window.location.href).hostname ===
+      this.parsedReceptionUrl.hostname;
+  }
+
+  public async getAppDataOnSsoDomain() {
+    if (!window.location.href.startsWith('https://sso.workspace.global/')) {
+      console.error('You are trying to access SSO appData on a non sso domain.');
+      return null;
+    }
+    const appDataString = plugins.smarturl.Smarturl.createFromUrl(window.location.href).searchParams
+      .appdata;
+    if (!appDataString) {
+      console.error('no appdata query arg detected');
+      return null;
+    }
+    return plugins.smartjson.parseBase64(appDataString);
+  }
+
+  public async setJwt(jwtStringArg: string) {
+    await this.storeJwt(jwtStringArg);
+  }
+
+  public async setRefreshToken(refreshTokenArg: string) {
+    await this.storeRefreshToken(refreshTokenArg);
+  }
+
+  public typedsocket!: plugins.typedsocket.TypedSocket;
+  public typedrouter: any = new plugins.typedrequest.TypedRouter();
+  public statusObservable = new plugins.smartrx.rxjs.Subject<plugins.idpInterfaces.data.TLoginStatus>();
+
+  public ssoStore = new plugins.webstore.WebStore({
+    storeName: 'idpglobalStore',
+    dbName: 'main',
+  });
+
+  public async storeJwt(jwtString: string) {
+    await this.ssoStore.set('idpJwt', jwtString);
+  }
+
+  public async storeRefreshToken(refreshToken: string) {
+    await this.ssoStore.set('idpRefreshToken', refreshToken);
+  }
+
+  public async getJwt(): Promise<string> {
+    return await this.ssoStore.get('idpJwt');
+  }
+
+  public async getRefreshToken(): Promise<string> {
+    return await this.ssoStore.get('idpRefreshToken');
+  }
+
+  public async getJwtData(): Promise<plugins.idpInterfaces.data.IJwt> {
+    return this.helpers.extractDataFromJwtString(await this.getJwt());
+  }
+
+  public async deleteJwt() {
+    await this.ssoStore.delete('idpJwt');
+  }
+
+  public async deleteRefreshToken() {
+    await this.ssoStore.delete('idpRefreshToken');
+  }
+
+  public async clearAuthState() {
+    await Promise.all([this.deleteJwt(), this.deleteRefreshToken()]);
+  }
+
+  public async performJwtHousekeeping() {
+    let jwt = await this.getJwt();
+    if (!jwt) {
+      return null;
+    }
+    const extractedJwt = await this.helpers.extractDataFromJwtString(jwt);
+    if (extractedJwt.data.refreshFrom < Date.now() && Date.now() < extractedJwt.data.validUntil) {
+      jwt = await this.refreshJwt();
+    } else if (Date.now() > extractedJwt.data.validUntil) {
+      await this.deleteJwt();
+      jwt = await this.refreshJwt();
+    }
+    return jwt;
+  }
+
+  public async refreshJwt(refreshTokenArg?: string): Promise<string | null> {
+    const refreshToken = refreshTokenArg || (await this.getRefreshToken());
+
+    if (!refreshToken) {
+      return null;
+    }
+
+    await this.typedsocketDeferred.promise;
+    const refreshJwtReq = this.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_RefreshJwt>('refreshJwt');
+    const response = await refreshJwtReq
+      .fire({ refreshToken })
+      .catch(async () => {
+        await this.clearAuthState();
+        return null;
+      });
+
+    if (!response?.jwt) {
+      await this.clearAuthState();
+      this.statusObservable.next(response?.status || 'loggedOut');
+      return null;
+    }
+
+    if (response.refreshToken) {
+      await this.storeRefreshToken(response.refreshToken);
+    }
+    await this.storeJwt(response.jwt);
+    this.statusObservable.next(response.status);
+    return response.jwt;
+  }
+
+  public async getTransferToken(appDataArg?: plugins.idpInterfaces.data.IAppLegacy): Promise<string | null> {
+    await this.performJwtHousekeeping();
+    const refreshToken = await this.getRefreshToken();
+    if (!refreshToken) {
+      return null;
+    }
+    await this.typedsocketDeferred.promise;
+    const getTransferToken = this.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_ExchangeRefreshTokenAndTransferToken>('exchangeRefreshTokenAndTransferToken');
+    const response = await getTransferToken.fire({
+      refreshToken,
+      appData: appDataArg || this.appData,
+    });
+    return response.transferToken;
+  }
+
+  public async getTransferTokenAndSwitchToLocation(newLocationArg: string): Promise<void> {
+    const transferToken = await this.getTransferToken();
+    if (!transferToken) {
+      alert('failed to get transfer token!');
+    }
+    const urlInstance = plugins.smarturl.Smarturl.createFromUrl(newLocationArg, {
+      searchParams: { transfertoken: transferToken },
+    });
+    window.location.href = urlInstance.toString();
+  }
+
+  public async processTransferToken(): Promise<boolean> {
+    const href = window.location.href;
+    const url = plugins.smarturl.Smarturl.createFromUrl(href);
+    const transferToken = url.searchParams['transfertoken'];
+    if (transferToken) {
+      await this.typedsocketDeferred.promise;
+      const getTransferToken = this.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_ExchangeRefreshTokenAndTransferToken>('exchangeRefreshTokenAndTransferToken');
+      const response = await getTransferToken.fire({
+        transferToken,
+        appData: this.appData,
+      });
+      if (response.refreshToken) {
+        await this.refreshJwt(response.refreshToken);
+      } else {
+        globalThis.alert?.('transfer token invalid');
+        return false;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  public async checkJwtPresent() {
+    const jwt = await this.performJwtHousekeeping();
+    return !!jwt;
+  }
+
+  public async determineLoginStatus(requireLoginArg: boolean = false): Promise<boolean> {
+    const jwtPresent = await this.checkJwtPresent();
+    if (jwtPresent) {
+      const jwt = await this.performJwtHousekeeping();
+      return !!jwt;
+    }
+    const refreshToken = await this.getRefreshToken();
+    if (refreshToken) {
+      const jwt = await this.refreshJwt(refreshToken);
+      if (jwt) {
+        return true;
+      }
+    }
+    const transferTokenResult = await this.processTransferToken();
+    if (transferTokenResult) {
+      return true;
+    }
+    if (requireLoginArg) {
+      const urlInstance = plugins.smarturl.Smarturl.createFromUrl(
+        this.parsedReceptionUrl.clone().set('path', '/login').toString(),
+        {
+          searchParams: {
+            appdata: plugins.smartjson.stringifyBase64(this.appData),
+          },
+        },
+      );
+      if (!globalThis.location.href.startsWith(this.parsedReceptionUrl.toString())) {
+        globalThis.location.href = urlInstance.toString();
+      }
+    }
+    return false;
+  }
+
+  public async logout() {
+    const idpLogoutUrl = this.parsedReceptionUrl.clone().set('path', '/logout');
+    const refreshToken = await this.getRefreshToken();
+    if (!globalThis.location.href.startsWith(idpLogoutUrl.origin)) {
+      await this.clearAuthState();
+      globalThis.location.href = idpLogoutUrl.toString();
+      return;
+    }
+    if (!refreshToken) {
+      await this.clearAuthState();
+      window.location.href = this.parsedReceptionUrl.origin;
+      return;
+    }
+    await this.enableTypedSocket();
+    const logoutTr = this.typedsocket.createTypedRequest<plugins.idpInterfaces.request.ILogoutRequest>('logout');
+    await logoutTr.fire({ refreshToken });
+    await this.clearAuthState();
+    const appData = await this.getAppDataOnSsoDomain();
+    if (appData) {
+      window.location.href = appData.appUrl;
+    } else if (window.location.href.startsWith(idpLogoutUrl.origin)) {
+      window.location.href = this.parsedReceptionUrl.origin;
+    }
+  }
+
+  public typedsocketDeferred = plugins.smartpromise.defer<plugins.typedsocket.TypedSocket>();
+
+  public async enableTypedSocket() {
+    if (this.typedsocketDeferred.claimed) {
+      return this.typedsocketDeferred.promise;
+    }
+    this.typedsocketDeferred.claim();
+    this.typedsocket = await plugins.typedsocket.TypedSocket.createClient(
+      this.typedrouter,
+      this.parsedReceptionUrl.toString(),
+    );
+    this.typedsocketDeferred.resolve(this.typedsocket);
+    return this.typedsocketDeferred.promise;
+  }
+
+  public async stop() {
+    await this.typedsocket?.stop();
+  }
+
+  public async createOrganization(orgNameArg: string, orgSlugArg: string, modeArg: 'checkAvailability' | 'manifest') {
+    await this.typedsocketDeferred.promise;
+    const validateOrg = this.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_CreateOrganization>('createOrganization');
+    return validateOrg.fire({
+      jwt: await this.getJwt(),
+      action: modeArg,
+      organizationName: orgNameArg,
+      organizationSlug: orgSlugArg,
+      userId: (await this.getJwtData()).id,
+    });
+  }
+
+  public async getRolesAndOrganizations() {
+    await this.typedsocketDeferred.promise;
+    const rolesAndOrganizationsForUserId = this.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_GetRolesAndOrganizationsForUserId>('getRolesAndOrganizationsForUserId');
+    return rolesAndOrganizationsForUserId.fire({
+      jwt: await this.getJwt(),
+      userId: (await this.getJwtData()).id,
+    });
+  }
+
+  public async updatePaddleCheckoutId(orgIdArg: string, checkoutIdArg: string) {
+    await this.typedsocketDeferred.promise;
+    const updateBillingPlan = this.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_UpdatePaymentMethod>('updatePaymentMethod');
+    return updateBillingPlan.fire({
+      jwtString: await this.getJwt(),
+      orgId: orgIdArg,
+      paddle: { checkoutId: checkoutIdArg },
+    });
+  }
+
+  public async whoIs() {
+    await this.typedsocketDeferred.promise;
+    const whoIs = this.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_WhoIs>('whoIs');
+    return whoIs.fire({ jwt: await this.getJwt() });
+  }
+}
@@ -0,0 +1,218 @@
+import * as plugins from './plugins.js';
+import type { IdpClient } from './classes.idpclient.js';
+
+export class IdpRequests {
+  constructor(private idpClientArg: IdpClient) {}
+
+  public get afterRegistrationEmailClicked() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_AfterRegistrationEmailClicked>('afterRegistrationEmailClicked');
+  }
+
+  public get setData() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_SetDataForRegistration>('setDataForRegistration');
+  }
+
+  public get mobileNumberVerification() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_MobileVerificationForRegistration>('mobileVerificationForRegistration');
+  }
+
+  public get finishRegistration() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_FinishRegistration>('finishRegistration');
+  }
+
+  public get loginWithUserNameAndPassword() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_LoginWithEmailOrUsernameAndPassword>('loginWithEmailOrUsernameAndPassword');
+  }
+
+  public get obtainJwt() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_RefreshJwt>('refreshJwt');
+  }
+
+  public get obtainOneTimeToken() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_ExchangeRefreshTokenAndTransferToken>('exchangeRefreshTokenAndTransferToken');
+  }
+
+  public get loginWithEmail() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_LoginWithEmail>('loginWithEmail');
+  }
+
+  public get loginWithEmailAfterToken() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_LoginWithEmailAfterEmailTokenAquired>('loginWithEmailAfterEmailTokenAquired');
+  }
+
+  public get loginWithApiToken() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_LoginWithApiToken>('loginWithApiToken');
+  }
+
+  public get completeOidcAuthorization() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_CompleteOidcAuthorization>('completeOidcAuthorization');
+  }
+
+  public get prepareOidcAuthorization() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_PrepareOidcAuthorization>('prepareOidcAuthorization');
+  }
+
+  public get resetPassword() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_ResetPassword>('resetPassword');
+  }
+
+  public get setNewPassword() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_SetNewPassword>('setNewPassword');
+  }
+
+  public get obtainDeviceId() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_ObtainDeviceId>('obtainDeviceId');
+  }
+
+  public get attachDeviceId() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_AttachDeviceId>('attachDeviceId');
+  }
+
+  public get firstRegistration() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_FirstRegistration>('firstRegistrationRequest');
+  }
+
+  public get getUserData() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_GetUserData>('getUserData');
+  }
+
+  public get setUserData() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_SetUserData>('setUserData');
+  }
+
+  public get getUserSessions() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_GetUserSessions>('getUserSessions');
+  }
+
+  public get revokeSession() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_RevokeSession>('revokeSession');
+  }
+
+  public get getUserActivity() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_GetUserActivity>('getUserActivity');
+  }
+
+  public get getOrganizationById() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_GetOrganizationById>('getOrganizationById');
+  }
+
+  public get updateOrganization() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_UpdateOrganization>('updateOrganization');
+  }
+
+  public get deleteOrganization() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_DeleteOrganization>('deleteOrganization');
+  }
+
+  public get getOrgRoleDefinitions() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_GetOrgRoleDefinitions>('getOrgRoleDefinitions');
+  }
+
+  public get upsertOrgRoleDefinition() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_UpsertOrgRoleDefinition>('upsertOrgRoleDefinition');
+  }
+
+  public get deleteOrgRoleDefinition() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_DeleteOrgRoleDefinition>('deleteOrgRoleDefinition');
+  }
+
+  public get createInvitation() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_CreateInvitation>('createInvitation');
+  }
+
+  public get getOrgInvitations() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_GetOrgInvitations>('getOrgInvitations');
+  }
+
+  public get getOrgMembers() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_GetOrgMembers>('getOrgMembers');
+  }
+
+  public get cancelInvitation() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_CancelInvitation>('cancelInvitation');
+  }
+
+  public get resendInvitation() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_ResendInvitation>('resendInvitation');
+  }
+
+  public get removeMember() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_RemoveMember>('removeMember');
+  }
+
+  public get updateMemberRoles() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_UpdateMemberRoles>('updateMemberRoles');
+  }
+
+  public get transferOwnership() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_TransferOwnership>('transferOwnership');
+  }
+
+  public get getInvitationByToken() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_GetInvitationByToken>('getInvitationByToken');
+  }
+
+  public get acceptInvitation() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_AcceptInvitation>('acceptInvitation');
+  }
+
+  public get bulkCreateInvitations() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_BulkCreateInvitations>('bulkCreateInvitations');
+  }
+
+  public get updateAppRoleMappings() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_UpdateAppRoleMappings>('updateAppRoleMappings');
+  }
+
+  public get getBillingPlan() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_GetBillingPlan>('getBillingPlan');
+  }
+
+  public get getPaddleConfig() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_GetPaddleConfig>('getPaddleConfig');
+  }
+
+  public get getPublicKeyForValidation() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_GetPublicKeyForValidation>('getPublicKeyForValidation');
+  }
+
+  public get pushPublicKeyForValidation() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_PushPublicKeyForValidation>('pushPublicKeyForValidation');
+  }
+
+  public get pushOrGetJwtIdBlocklist() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_PushOrGetJwtIdBlocklist>('pushOrGetJwtIdBlocklist');
+  }
+
+  public get suspendUser() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_SuspendUser>('suspendUser');
+  }
+
+  public get deleteSuspendedUser() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IDeleteSuspendedUser>('deleteSuspendedUser');
+  }
+
+  public get checkGlobalAdmin() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_CheckGlobalAdmin>('checkGlobalAdmin');
+  }
+
+  public get getGlobalAppStats() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_GetGlobalAppStats>('getGlobalAppStats');
+  }
+
+  public get createGlobalApp() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_CreateGlobalApp>('createGlobalApp');
+  }
+
+  public get updateGlobalApp() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_UpdateGlobalApp>('updateGlobalApp');
+  }
+
+  public get deleteGlobalApp() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_DeleteGlobalApp>('deleteGlobalApp');
+  }
+
+  public get regenerateAppCredentials() {
+    return this.idpClientArg.typedsocket.createTypedRequest<plugins.idpInterfaces.request.IReq_RegenerateAppCredentials>('regenerateAppCredentials');
+  }
+}
@@ -0,0 +1,2 @@
+export * from './classes.idpclient.js';
+export * from './classes.idprequests.js';
@@ -0,0 +1,18 @@
+import * as idpInterfaces from '@idp.global/interfaces';
+
+export { idpInterfaces };
+
+import * as typedrequest from '@api.global/typedrequest';
+import * as typedsocket from '@api.global/typedsocket';
+
+export { typedrequest, typedsocket };
+
+import * as smartjson from '@push.rocks/smartjson';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrx from '@push.rocks/smartrx';
+import * as smarttime from '@push.rocks/smarttime';
+import * as smarturl from '@push.rocks/smarturl';
+import * as webjwt from '@push.rocks/webjwt';
+import * as webstore from '@push.rocks/webstore';
+
+export { smartjson, smartpromise, smartrx, smarttime, smarturl, webjwt, webstore };