@bitblit/ratchet-warden-common 6.0.145-alpha → 6.0.147-alpha

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@bitblit/ratchet-warden-common",
-  "version": "6.0.145-alpha",
+  "version": "6.0.147-alpha",
   "description": "Typescript library to simplify using simplewebauthn and secondary auth methods over GraphQL",
   "sideEffects": false,
   "type": "module",
   "files": [
+    "src/**",
     "lib/**",
     "bin/**"
   ],
@@ -46,12 +47,12 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@bitblit/ratchet-common": "6.0.145-alpha",
+    "@bitblit/ratchet-common": "6.0.147-alpha",
     "@simplewebauthn/browser": "13.2.2",
     "jwt-decode": "4.0.0"
   },
   "peerDependencies": {
-    "@bitblit/ratchet-common": "^6.0.145-alpha",
+    "@bitblit/ratchet-common": "^6.0.147-alpha",
     "@simplewebauthn/browser": "^13.2.2",
     "jwt-decode": "^4.0.0"
   }

package/src/build/ratchet-warden-common-info.ts

@@ -0,0 +1,19 @@
+import { BuildInformation } from '@bitblit/ratchet-common/build/build-information';
+
+export class RatchetWardenCommonInfo {
+  // Empty constructor prevents instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  public static buildInformation(): BuildInformation {
+    const val: BuildInformation = {
+      version: 'LOCAL-SNAPSHOT',
+      hash: 'LOCAL-HASH',
+      branch: 'LOCAL-BRANCH',
+      tag: 'LOCAL-TAG',
+      timeBuiltISO: 'LOCAL-TIME-ISO',
+      notes: 'LOCAL-NOTES',
+    };
+    return val;
+  }
+}

package/src/client/provider/warden-client-abstract-recent-login-provider.ts

@@ -0,0 +1,53 @@
+import { WardenClientRecentLoginProvider } from './warden-client-recent-login-provider.js';
+import { WardenRecentLoginDescriptor } from './warden-recent-login-descriptor.js';
+
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { WardenEntrySummary } from '../../common/model/warden-entry-summary.js';
+import { WardenContact } from '../../common/model/warden-contact.js';
+import { WardenUtils } from '../../common/util/warden-utils.js';
+
+export abstract class WardenClientAbstractRecentLoginProvider implements WardenClientRecentLoginProvider {
+  public abstract fetchCache(): WardenRecentLoginDescriptor[];
+  public abstract updateCache(newValue: WardenRecentLoginDescriptor[]);
+
+  public saveRecentLogin(entry: WardenEntrySummary): void {
+    if (entry?.userId) {
+      Logger.info('Saving recent login : %j', entry);
+      let list: WardenRecentLoginDescriptor[] = this.fetchCache();
+      list = list.filter((s) => s.user.userId !== entry.userId);
+      list.push({
+        user: entry,
+        lastLoginEpochMS: Date.now(),
+      });
+      this.updateCache(list);
+    } else {
+      Logger.warn('Cannot save recent login - no login provided :  %s', entry);
+    }
+  }
+
+  public saveNewUser(userId: string, label: string, contact: WardenContact): void {
+    if (StringRatchet.trimToNull(userId) && WardenUtils.validContact(contact)) {
+      this.saveRecentLogin({
+        userId: userId,
+        contactMethods: [contact],
+        webAuthnAuthenticatorSummaries: [],
+        userLabel: label,
+      });
+    } else {
+      Logger.warn('Cannot save new user - invalid data : %s : %j', userId, contact);
+    }
+  }
+
+  public removeUser(userId: string): void {
+    let list: WardenRecentLoginDescriptor[] = this.fetchCache();
+    list = list.filter((c) => c.user.userId !== userId);
+    this.updateCache(list);
+  }
+  public fetchAllLogins(): WardenRecentLoginDescriptor[] {
+    return Object.assign([], this.fetchCache());
+  }
+  public clearAllLogins(): void {
+    this.updateCache([]);
+  }
+}

package/src/client/provider/warden-client-current-logged-in-jwt-token-provider.ts

@@ -0,0 +1,3 @@
+export interface WardenClientCurrentLoggedInJwtTokenProvider {
+  fetchCurrentLoggedInJwtToken(): string;
+}

package/src/client/provider/warden-client-recent-login-provider.ts

@@ -0,0 +1,11 @@
+import { WardenRecentLoginDescriptor } from './warden-recent-login-descriptor.js';
+import { WardenEntrySummary } from '../../common/model/warden-entry-summary.js';
+import { WardenContact } from '../../common/model/warden-contact.js';
+
+export interface WardenClientRecentLoginProvider {
+  saveRecentLogin(entry: WardenEntrySummary): void;
+  saveNewUser(userId: string, label: string, contact: WardenContact): void;
+  removeUser(userId: string): void;
+  fetchAllLogins(): WardenRecentLoginDescriptor[];
+  clearAllLogins(): void;
+}

package/src/client/provider/warden-client-storage-based-logged-in-user-provider.ts

@@ -0,0 +1,54 @@
+import { WardenLoggedInUserProvider } from "./warden-logged-in-user-provider.js";
+import { WardenLoggedInUserWrapper } from "./warden-logged-in-user-wrapper.js";
+
+import { RequireRatchet } from "@bitblit/ratchet-common/lang/require-ratchet";
+import { StringRatchet } from "@bitblit/ratchet-common/lang/string-ratchet";
+import { Logger } from "@bitblit/ratchet-common/logger/logger";
+
+export class WardenClientStorageBasedLoggedInUserProvider<T> implements WardenLoggedInUserProvider<T> {
+
+  constructor(
+    private storageProv: Storage | (() => Storage),
+    private storageKey: string,
+  ) {
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(this.storageKey, 'storageKey');
+    RequireRatchet.notNullOrUndefined(this.storageProv, 'storageProv');
+  }
+
+  public get storage(): Storage {
+    if (typeof this.storageProv === 'function') {
+      return this.storageProv();
+    } else {
+      return this.storageProv;
+    }
+  }
+
+  public fetchLoggedInUserWrapper(): WardenLoggedInUserWrapper<T> {
+    const storage: Storage = this.storage;
+    if (storage) {
+      const asString: string = storage.getItem(this.storageKey);
+      const rval: WardenLoggedInUserWrapper<T> = StringRatchet.trimToNull(asString) ? JSON.parse(asString) : null;
+      return rval;
+    } else {
+      Logger.debug('Tried to fetch logged in user before storage ready - returning null');
+      return null;
+    }
+  }
+
+  public logOutUser(): void {
+    this.setLoggedInUserWrapper(null);
+  }
+
+  public setLoggedInUserWrapper(wrapper: WardenLoggedInUserWrapper<T>) {
+    const storage: Storage = this.storage;
+    if (storage) {
+      if (wrapper) {
+        storage.setItem(this.storageKey, JSON.stringify(wrapper));
+      } else {
+        storage.removeItem(this.storageKey);
+      }
+    } else {
+      Logger.warn('Tried to set logged in user before storage was ready, ignoring : %j', wrapper);
+    }
+  }
+}

package/src/client/provider/warden-client-storage-based-recent-login-provider.ts

@@ -0,0 +1,46 @@
+import { WardenRecentLoginDescriptor } from './warden-recent-login-descriptor.js';
+
+import { RequireRatchet } from '@bitblit/ratchet-common/lang/require-ratchet';
+import { StringRatchet } from '@bitblit/ratchet-common/lang/string-ratchet';
+import { WardenClientAbstractRecentLoginProvider } from './warden-client-abstract-recent-login-provider.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+
+export class WardenClientStorageBasedRecentLoginProvider extends WardenClientAbstractRecentLoginProvider {
+  constructor(
+    private storageProv: Storage | (() => Storage),
+    private storageKey: string,
+  ) {
+    super();
+    RequireRatchet.notNullOrUndefined(this.storageProv, 'storageProv');
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(this.storageKey, 'storageKey');
+  }
+
+  public get storage(): Storage {
+    if (typeof this.storageProv === 'function') {
+      return this.storageProv();
+    } else {
+      return this.storageProv;
+    }
+  }
+
+  fetchCache(): WardenRecentLoginDescriptor[] {
+    const storage: Storage = this.storage;
+    if (storage) {
+      const asString: string = StringRatchet.trimToNull(storage.getItem(StringRatchet.trimToNull(this.storageKey)));
+      return asString ? JSON.parse(asString) : [];
+    } else {
+      Logger.debug('Tried to fetch cache before storage was ready, returning empty');
+      return [];
+    }
+  }
+
+  updateCache(newValue: WardenRecentLoginDescriptor[]) {
+    const storage: Storage = this.storage;
+    if (storage) {
+      const asString: string = newValue ? JSON.stringify(newValue) : '[]';
+      storage.setItem(StringRatchet.trimToNull(this.storageKey), asString);
+    } else {
+      Logger.debug('Tried to update cache before storage was ready, ignoring update to %j', newValue);
+    }
+  }
+}

package/src/client/provider/warden-client-transient-memory-logged-in-user-provider.ts

@@ -0,0 +1,19 @@
+import { WardenLoggedInUserProvider } from "./warden-logged-in-user-provider.js";
+import { WardenLoggedInUserWrapper } from "./warden-logged-in-user-wrapper.js";
+
+export class WardenClientTransientMemoryLoggedInUserProvider<T> implements WardenLoggedInUserProvider<T> {
+  private wrapper: WardenLoggedInUserWrapper<T>;
+
+  public fetchLoggedInUserWrapper(): WardenLoggedInUserWrapper<T> {
+    return this.wrapper;
+  }
+
+  public logOutUser(): void {
+    this.wrapper = null;
+  }
+
+  public setLoggedInUserWrapper(wrapper: WardenLoggedInUserWrapper<T>) {
+    this.wrapper = wrapper;
+  }
+
+}

package/src/client/provider/warden-client-transient-memory-recent-login-provider.ts

@@ -0,0 +1,15 @@
+import { WardenRecentLoginDescriptor } from './warden-recent-login-descriptor.js';
+import { WardenClientAbstractRecentLoginProvider } from './warden-client-abstract-recent-login-provider.js';
+
+// Stores everything in transient memory - basically just for testing
+export class WardenClientTransientMemoryRecentLoginProvider extends WardenClientAbstractRecentLoginProvider {
+  private _cache: WardenRecentLoginDescriptor[] = [];
+
+  fetchCache(): WardenRecentLoginDescriptor[] {
+    return this._cache;
+  }
+
+  updateCache(newValue: WardenRecentLoginDescriptor[]) {
+    this._cache = newValue;
+  }
+}

package/src/client/provider/warden-command-exchange-provider.ts

@@ -0,0 +1,8 @@
+/**
+ * Classes implementing WardenMessageSendingProvider are able to
+ * send expiring, single
+ */
+
+export interface WardenCommandExchangeProvider {
+  sendCommand(cmdString: string, jwtToken: string): Promise<string>;
+}

package/src/client/provider/warden-logged-in-user-provider.ts

@@ -0,0 +1,7 @@
+import { WardenLoggedInUserWrapper } from "./warden-logged-in-user-wrapper.js";
+
+export interface WardenLoggedInUserProvider<T> {
+  fetchLoggedInUserWrapper(): WardenLoggedInUserWrapper<T>;
+  setLoggedInUserWrapper(wrapper: WardenLoggedInUserWrapper<T>);
+  logOutUser(): void;
+}

package/src/client/provider/warden-logged-in-user-wrapper.ts

@@ -0,0 +1,7 @@
+import { WardenJwtToken } from '../../common/model/warden-jwt-token.js';
+
+export interface WardenLoggedInUserWrapper<T> {
+  userObject: WardenJwtToken<T>;
+  jwtToken: string;
+  expirationEpochSeconds: number;
+}

package/src/client/provider/warden-recent-login-descriptor.ts

@@ -0,0 +1,6 @@
+import { WardenEntrySummary } from '../../common/model/warden-entry-summary.js';
+
+export interface WardenRecentLoginDescriptor {
+  user: WardenEntrySummary;
+  lastLoginEpochMS: number;
+}

package/src/client/provider/warden-user-service-event-processing-provider.ts

@@ -0,0 +1,14 @@
+import { WardenLoggedInUserWrapper } from './warden-logged-in-user-wrapper.js';
+
+/**
+ * Notifies the containing system when significant events happen
+ */
+
+export interface WardenUserServiceEventProcessingProvider<T> {
+  onLogout(): void;
+  onSuccessfulLogin(newUser: WardenLoggedInUserWrapper<T>): void;
+  onLoginFailure(reason: string): void;
+
+  onAutomaticTokenRefresh(refreshUser: WardenLoggedInUserWrapper<T>): void;
+  onAutomaticLogout(): void;
+}

package/src/client/provider/warden-user-service-options.ts

@@ -0,0 +1,17 @@
+import { WardenLoggedInUserProvider } from './warden-logged-in-user-provider.js';
+import { WardenClient } from '../warden-client.js';
+import { WardenUserServiceEventProcessingProvider } from './warden-user-service-event-processing-provider.js';
+import { WardenClientRecentLoginProvider } from './warden-client-recent-login-provider.js';
+
+export interface WardenUserServiceOptions<T> {
+  recentLoginProvider?: WardenClientRecentLoginProvider;
+  loggedInUserProvider: WardenLoggedInUserProvider<T>;
+  wardenClient: WardenClient;
+  eventProcessor: WardenUserServiceEventProcessingProvider<T>;
+  loginCheckTimerPingSeconds?: number;
+  autoLoginHandlingThresholdSeconds?: number;
+  allowAutoRefresh?: boolean;
+
+  applicationName: string;
+  deviceLabelGenerator?: () => string;
+}

package/src/client/warden-client.spec.ts

@@ -0,0 +1,32 @@
+import { WardenClient } from './warden-client.js';
+
+import { WardenCommandExchangeProvider } from './provider/warden-command-exchange-provider.js';
+import { WardenClientCurrentLoggedInJwtTokenProvider } from './provider/warden-client-current-logged-in-jwt-token-provider.js';
+import { WardenCommand } from '../common/command/warden-command.js';
+import { WardenCommandResponse } from '../common/command/warden-command-response.js';
+import { beforeEach, describe, expect, test } from 'vitest';
+import { mock, MockProxy } from 'vitest-mock-extended';
+
+let mockCommandExchangeProvider: MockProxy<WardenCommandExchangeProvider>;
+let mockLoggedInJwtTokenProvider: MockProxy<WardenClientCurrentLoggedInJwtTokenProvider>;
+
+describe('#wardenClient', function () {
+  beforeEach(() => {
+    mockCommandExchangeProvider = mock<WardenCommandExchangeProvider>();
+    mockLoggedInJwtTokenProvider = mock<WardenClientCurrentLoggedInJwtTokenProvider>();
+  });
+
+  test('should instantiate and exchange commands', async () => {
+    const wc: WardenClient = new WardenClient(mockCommandExchangeProvider, mockLoggedInJwtTokenProvider);
+    expect(wc).not.toBeNull();
+    const cmd: WardenCommand = {
+      generateWebAuthnAuthenticationChallengeForUserId: 'test',
+    };
+
+    mockCommandExchangeProvider.sendCommand.mockResolvedValue('{"generateWebAuthnAuthenticationChallengeForUserId": { "dataAsJson": {} }}');
+
+    const result: WardenCommandResponse = await wc.exchangeCommand(cmd);
+    expect(result).not.toBeNull();
+    expect(result.generateWebAuthnRegistrationChallengeForLoggedInUser).not.toBeNull();
+  });
+});

package/src/client/warden-client.ts

@@ -0,0 +1,239 @@
+//    Service for interacting with positions for a given user
+import { WardenCommand } from "../common/command/warden-command.js";
+import { WardenContact } from "../common/model/warden-contact.js";
+import { WardenCommandExchangeProvider } from "./provider/warden-command-exchange-provider.js";
+import { WardenCommandResponse } from "../common/command/warden-command-response.js";
+
+import { RequireRatchet } from "@bitblit/ratchet-common/lang/require-ratchet";
+import { Logger } from "@bitblit/ratchet-common/logger/logger";
+import { ErrorRatchet } from "@bitblit/ratchet-common/lang/error-ratchet";
+import { StringRatchet } from "@bitblit/ratchet-common/lang/string-ratchet";
+import {
+  PublicKeyCredentialRequestOptionsJSON,
+  RegistrationResponseJSON,
+  StartRegistrationOpts
+} from "@simplewebauthn/browser";
+import { WardenLoginResults } from "../common/model/warden-login-results.js";
+import { WardenLoginRequest } from "../common/model/warden-login-request.js";
+import {
+  WardenClientCurrentLoggedInJwtTokenProvider
+} from "./provider/warden-client-current-logged-in-jwt-token-provider.js";
+import { WardenEntrySummary } from "../common/model/warden-entry-summary.js";
+import { WardenContactType } from "../common/model/warden-contact-type.js";
+import {
+  AddWebAuthnRegistrationToLoggedInUser
+} from "../common/command/add-web-authn-registration-to-logged-in-user.js";
+import { SendMagicLink } from "../common/command/send-magic-link.js";
+import { WardenLoginRequestType } from "../common/model/warden-login-request-type";
+
+export class WardenClient {
+  constructor(
+    private commandSender: WardenCommandExchangeProvider,
+    private jwtProvider: WardenClientCurrentLoggedInJwtTokenProvider,
+  ) {
+    RequireRatchet.notNullOrUndefined(commandSender, 'commandSender');
+    RequireRatchet.notNullOrUndefined(jwtProvider, 'jwtProvider');
+  }
+
+  public async exchangeCommand(cmd: WardenCommand, returnErrors?: boolean): Promise<WardenCommandResponse> {
+    const asString: string = JSON.stringify(cmd);
+    const resp: string = await this.commandSender.sendCommand(asString, this.jwtProvider.fetchCurrentLoggedInJwtToken());
+    const parsed: WardenCommandResponse = JSON.parse(resp);
+
+    if (parsed?.error && !returnErrors) {
+      ErrorRatchet.throwFormattedErr('%s', parsed.error);
+    }
+    return parsed;
+  }
+
+  public async createAccount(contact: WardenContact, sendCode?: boolean, label?: string, tags?: string[]): Promise<string> {
+    const cmd: WardenCommand = {
+      createAccount: {
+        contact: contact,
+        sendCode: sendCode,
+        label: label,
+        tags: tags,
+      },
+    };
+    const rval: WardenCommandResponse = await this.exchangeCommand(cmd);
+
+    return rval.createAccount;
+  }
+
+  public async sendMagicLinkRaw(smlCmd: SendMagicLink): Promise<boolean> {
+    if (smlCmd) {
+      const cmd: WardenCommand = {
+        sendMagicLink: smlCmd,
+      };
+      const rval: WardenCommandResponse = await this.exchangeCommand(cmd);
+      return rval.sendMagicLink;
+    } else {
+      Logger.warn('Skipping magic link command - none supplied');
+      return false;
+    }
+  }
+
+  public async sendMagicLinkByUserId(
+    userId: string,
+    landingUrl: string,
+    contactType?: WardenContactType,
+    meta?: Record<string, string>,
+  ): Promise<boolean> {
+    const cmd: SendMagicLink = {
+      contactLookup: {
+        userId: userId,
+        contactType: contactType,
+      },
+      landingUrl: landingUrl,
+      meta: meta,
+    };
+    return this.sendMagicLinkRaw(cmd);
+  }
+
+  public async sendMagicLink(contact: WardenContact, landingUrl: string, meta?: Record<string, string>): Promise<boolean> {
+    const cmd: SendMagicLink = {
+      contact: contact,
+      landingUrl: landingUrl,
+      meta: meta,
+    };
+    return this.sendMagicLinkRaw(cmd);
+  }
+
+  public async generateWebAuthnAuthenticationChallengeForUserId(userId: string): Promise<PublicKeyCredentialRequestOptionsJSON> {
+    const cmd: WardenCommand = {
+      generateWebAuthnAuthenticationChallengeForUserId: userId,
+    };
+    const rval: WardenCommandResponse = await this.exchangeCommand(cmd);
+    const parsed: PublicKeyCredentialRequestOptionsJSON = JSON.parse(rval.generateWebAuthnAuthenticationChallengeForUserId.dataAsJson);
+    return parsed;
+  }
+
+  public async exportWebAuthnRegistrationEntryForLoggedInUser(origin: string): Promise<string> {
+    const cmd: WardenCommand = {
+      exportWebAuthnRegistrationEntryForLoggedInUser: origin,
+    };
+    const rval: WardenCommandResponse = await this.exchangeCommand(cmd);
+    return rval.exportWebAuthnRegistrationEntryForLoggedInUser;
+  }
+  public async importWebAuthnRegistrationEntryForLoggedInUser(token: string): Promise<boolean> {
+    const cmd: WardenCommand = {
+      importWebAuthnRegistrationEntryForLoggedInUser: token,
+    };
+    const rval: WardenCommandResponse = await this.exchangeCommand(cmd);
+    return rval.importWebAuthnRegistrationEntryForLoggedInUser;
+  }
+
+
+  public async generateWebAuthnRegistrationChallengeForLoggedInUser(): Promise<StartRegistrationOpts> {
+    const cmd: WardenCommand = {
+      generateWebAuthnRegistrationChallengeForLoggedInUser: true,
+    };
+    const rval: WardenCommandResponse = await this.exchangeCommand(cmd);
+    //Logger.info('generateWebAuthnRegistrationChallengeForLoggedInUser: %j', rval);
+    const parsed: StartRegistrationOpts = JSON.parse(rval.generateWebAuthnRegistrationChallengeForLoggedInUser.dataAsJson);
+    return parsed;
+  }
+
+  public async removeWebAuthnRegistration(userId: string, credId: string): Promise<WardenEntrySummary> {
+    const cmd: WardenCommand = {
+      removeWebAuthnRegistration: {
+        userId: userId,
+        credentialId: credId,
+      },
+    };
+    const rval: WardenCommandResponse = await this.exchangeCommand(cmd);
+    return rval.removeWebAuthnRegistration;
+  }
+
+  public async removeWebAuthnRegistrationFromLoggedInUser(input: string): Promise<WardenEntrySummary> {
+    const cmd: WardenCommand = {
+      removeWebAuthnRegistrationFromLoggedInUser: input,
+    };
+    const rval: WardenCommandResponse = await this.exchangeCommand(cmd);
+    return rval.removeWebAuthnRegistrationFromLoggedInUser;
+  }
+
+  public async removeContactFromLoggedInUser(input: WardenContact): Promise<WardenEntrySummary> {
+    const cmd: WardenCommand = {
+      removeContactFromLoggedInUser: input,
+    };
+    const rval: WardenCommandResponse = await this.exchangeCommand(cmd);
+    return rval.removeContactFromLoggedInUser;
+  }
+
+  public async sendExpiringValidationToken(contact: WardenContact): Promise<boolean> {
+    const cmd: WardenCommand = {
+      sendExpiringValidationToken: contact,
+    };
+    const rval: WardenCommandResponse = await this.exchangeCommand(cmd);
+    return rval.sendExpiringValidationToken;
+  }
+
+  public async addContactToLoggedInUser(contact: WardenContact): Promise<boolean> {
+    const cmd: WardenCommand = {
+      addContactToLoggedInUser: contact,
+    };
+    const rval: WardenCommandResponse = await this.exchangeCommand(cmd);
+    return rval.addContactToLoggedInUser;
+  }
+
+  public async addWebAuthnRegistrationToLoggedInUser(
+    applicationName: string,
+    deviceLabel: string,
+    data: RegistrationResponseJSON,
+  ): Promise<WardenEntrySummary> {
+    const inCmd: AddWebAuthnRegistrationToLoggedInUser = {
+      webAuthn: {
+        dataAsJson: JSON.stringify(data),
+      },
+      applicationName: applicationName,
+      deviceLabel: deviceLabel,
+    };
+
+    const cmd: WardenCommand = {
+      addWebAuthnRegistrationToLoggedInUser: inCmd,
+    };
+    const rval: WardenCommandResponse = await this.exchangeCommand(cmd);
+    return rval.addWebAuthnRegistrationToLoggedInUser;
+  }
+
+  public async performLoginCmd(login: WardenLoginRequest): Promise<WardenLoginResults> {
+    const loginCmd: WardenCommand = {
+      performLogin: login,
+    };
+    const cmdResponse: WardenCommandResponse = await this.exchangeCommand(loginCmd);
+
+    return cmdResponse.performLogin;
+  }
+
+  public async refreshJwtToken(oldJwtToken: string): Promise<string> {
+    let rval: string = null;
+    if (StringRatchet.trimToNull(oldJwtToken)) {
+      try {
+        const resp: WardenCommandResponse = await this.exchangeCommand({ refreshJwtToken: oldJwtToken });
+        rval = resp.refreshJwtToken;
+      } catch (err) {
+        Logger.error('JwtRefresh Failed : %s', err);
+      }
+    }
+    return rval;
+  }
+
+  public async executeExpiringTokenBasedLogin(contact: WardenContact, expiringToken: string): Promise<WardenLoginResults> {
+    let rval: WardenLoginResults = null;
+    try {
+      const loginCmd: WardenLoginRequest = {
+        type: WardenLoginRequestType.ExpiringToken,
+        contact: contact,
+        expiringToken: expiringToken,
+      };
+      rval = await this.performLoginCmd(loginCmd);
+      if (rval?.jwtToken) {
+        //rval = true;
+      }
+    } catch (err) {
+      Logger.error('ExpiringToken login Failed : %s', err);
+    }
+    return rval;
+  }
+}

package/src/client/warden-delegating-current-user-providing-user-service-event-processing-provider.ts

@@ -0,0 +1,76 @@
+import { WardenUserServiceEventProcessingProvider } from './provider/warden-user-service-event-processing-provider.js';
+import { WardenLoggedInUserWrapper } from './provider/warden-logged-in-user-wrapper.js';
+import { BehaviorSubject } from 'rxjs';
+import { WardenClientCurrentLoggedInJwtTokenProvider } from './provider/warden-client-current-logged-in-jwt-token-provider.js';
+import { WardenUtils } from '../common/util/warden-utils.js';
+import { Logger } from '@bitblit/ratchet-common/logger/logger';
+
+/**
+ * This class maintains a BehaviorSubject of the current user for things that want to be
+ * notified on change without depending on the WardenUserService (most commonly, the
+ * API provider with both needs the token for auth'd calls, but also is responsible for
+ * doing the login call itself and therefor cannot depend on the UserService which depends
+ * on the WardenClient which likely depends on the API provider - prevents a circular
+ * dependency to just depend on this)
+ *
+ * Delegates so that you still can also register other behavior, and just tack this onto it
+ *
+ * By default this will never serve expired credentials - if a call is made, and the credentials found are
+ * expired, they will be cleared and null will be returned
+ */
+export class WardenDelegatingCurrentUserProvidingUserServiceEventProcessingProvider<T>
+  implements WardenUserServiceEventProcessingProvider<T>, WardenClientCurrentLoggedInJwtTokenProvider
+{
+  private _currentUserSubject: BehaviorSubject<WardenLoggedInUserWrapper<T>> = new BehaviorSubject<WardenLoggedInUserWrapper<T>>(null);
+
+  constructor(
+    private wrapped?: Partial<WardenUserServiceEventProcessingProvider<T>>,
+    private serveExpiredCredentials: boolean = false,
+  ) {}
+
+  public fetchCurrentLoggedInJwtToken(): string {
+    let val: WardenLoggedInUserWrapper<T> = this?._currentUserSubject?.getValue();
+    if (!this.serveExpiredCredentials && val && WardenUtils.wrapperIsExpired(val)) {
+      Logger.info('Current wrapper in the subject is expired - autostripping');
+      this.currentUserSubject.next(null);
+      val = null;
+    }
+    return val?.jwtToken;
+  }
+
+  public get currentUserSubject(): BehaviorSubject<WardenLoggedInUserWrapper<T>> {
+    return this._currentUserSubject;
+  }
+
+  public onAutomaticLogout(): void {
+    if (this.wrapped) {
+      this.wrapped.onAutomaticLogout();
+    }
+  }
+
+  public onAutomaticTokenRefresh(refreshUser: WardenLoggedInUserWrapper<T>): void {
+    if (this?.wrapped?.onAutomaticTokenRefresh) {
+      this.wrapped.onAutomaticTokenRefresh(refreshUser);
+    }
+  }
+
+  public onLoginFailure(reason: string): void {
+    if (this?.wrapped?.onLoginFailure) {
+      this.wrapped.onLoginFailure(reason);
+    }
+  }
+
+  public onLogout(): void {
+    if (this?.wrapped?.onLogout) {
+      this.wrapped.onLogout();
+    }
+    this.currentUserSubject.next(null);
+  }
+
+  public onSuccessfulLogin(newUser: WardenLoggedInUserWrapper<T>): void {
+    if (this?.wrapped?.onSuccessfulLogin) {
+      this.wrapped.onSuccessfulLogin(newUser);
+    }
+    this.currentUserSubject.next(newUser);
+  }
+}