Merge master into merge/feature/org-admin-refresh (using imerge)

libs/common/src/services/api.service.ts

@@ -170,6 +170,11 @@ import { TwoFactorYubiKeyResponse } from "../models/response/two-factor-yubi-key
 import { UserKeyResponse } from "../models/response/user-key.response";
 import { SendAccessView } from "../models/view/send-access.view";
 
+/**
+ * @deprecated The `ApiService` class is deprecated and calls should be extracted into individual
+ * api services. The `send` method is still allowed to be used within api services. For background
+ * of this decision please read https://contributing.bitwarden.com/architecture/adr/refactor-api-service.
+ */
 export class ApiService implements ApiServiceAbstraction {
   private device: DeviceType;
   private deviceType: string;
@@ -2021,7 +2026,7 @@ export class ApiService implements ApiServiceAbstraction {
     request.headers.set("Bitwarden-Client-Name", this.platformUtilsService.getClientType());
     request.headers.set(
       "Bitwarden-Client-Version",
-      await this.platformUtilsService.getApplicationVersion()
+      await this.platformUtilsService.getApplicationVersionNumber()
     );
     return this.nativeFetch(request);
   }

libs/common/src/services/cipher.service.ts

@@ -412,7 +412,7 @@ export class CipherService implements CipherServiceAbstraction {
         : firstValueFrom(this.settingsService.settings$).then(
             (settings: AccountSettingsSettings) => {
               let matches: any[] = [];
-              settings.equivalentDomains?.forEach((eqDomain: any) => {
+              settings?.equivalentDomains?.forEach((eqDomain: any) => {
                 if (eqDomain.length && eqDomain.indexOf(domain) >= 0) {
                   matches = matches.concat(eqDomain);
                 }

libs/common/src/services/event.service.ts

@@ -1,107 +0,0 @@
-import { ApiService } from "../abstractions/api.service";
-import { CipherService } from "../abstractions/cipher.service";
-import { EventService as EventServiceAbstraction } from "../abstractions/event.service";
-import { LogService } from "../abstractions/log.service";
-import { OrganizationService } from "../abstractions/organization/organization.service.abstraction";
-import { StateService } from "../abstractions/state.service";
-import { EventType } from "../enums/eventType";
-import { EventData } from "../models/data/event.data";
-import { EventRequest } from "../models/request/event.request";
-
-export class EventService implements EventServiceAbstraction {
-  private inited = false;
-
-  constructor(
-    private apiService: ApiService,
-    private cipherService: CipherService,
-    private stateService: StateService,
-    private logService: LogService,
-    private organizationService: OrganizationService
-  ) {}
-
-  init(checkOnInterval: boolean) {
-    if (this.inited) {
-      return;
-    }
-
-    this.inited = true;
-    if (checkOnInterval) {
-      this.uploadEvents();
-      setInterval(() => this.uploadEvents(), 60 * 1000); // check every 60 seconds
-    }
-  }
-
-  async collect(
-    eventType: EventType,
-    cipherId: string = null,
-    uploadImmediately = false,
-    organizationId: string = null
-  ): Promise<any> {
-    const authed = await this.stateService.getIsAuthenticated();
-    if (!authed) {
-      return;
-    }
-    const organizations = await this.organizationService.getAll();
-    if (organizations == null) {
-      return;
-    }
-    const orgIds = new Set<string>(organizations.filter((o) => o.useEvents).map((o) => o.id));
-    if (orgIds.size === 0) {
-      return;
-    }
-    if (cipherId != null) {
-      const cipher = await this.cipherService.get(cipherId);
-      if (cipher == null || cipher.organizationId == null || !orgIds.has(cipher.organizationId)) {
-        return;
-      }
-    }
-    if (organizationId != null) {
-      if (!orgIds.has(organizationId)) {
-        return;
-      }
-    }
-    let eventCollection = await this.stateService.getEventCollection();
-    if (eventCollection == null) {
-      eventCollection = [];
-    }
-    const event = new EventData();
-    event.type = eventType;
-    event.cipherId = cipherId;
-    event.date = new Date().toISOString();
-    event.organizationId = organizationId;
-    eventCollection.push(event);
-    await this.stateService.setEventCollection(eventCollection);
-    if (uploadImmediately) {
-      await this.uploadEvents();
-    }
-  }
-
-  async uploadEvents(userId?: string): Promise<any> {
-    const authed = await this.stateService.getIsAuthenticated({ userId: userId });
-    if (!authed) {
-      return;
-    }
-    const eventCollection = await this.stateService.getEventCollection({ userId: userId });
-    if (eventCollection == null || eventCollection.length === 0) {
-      return;
-    }
-    const request = eventCollection.map((e) => {
-      const req = new EventRequest();
-      req.type = e.type;
-      req.cipherId = e.cipherId;
-      req.date = e.date;
-      req.organizationId = e.organizationId;
-      return req;
-    });
-    try {
-      await this.apiService.postEventsCollect(request);
-      this.clearEvents(userId);
-    } catch (e) {
-      this.logService.error(e);
-    }
-  }
-
-  async clearEvents(userId?: string): Promise<any> {
-    await this.stateService.setEventCollection(null, { userId: userId });
-  }
-}

libs/common/src/services/event/event-collection.service.ts

@@ -0,0 +1,61 @@
+import { CipherService } from "../../abstractions/cipher.service";
+import { EventCollectionService as EventCollectionServiceAbstraction } from "../../abstractions/event/event-collection.service";
+import { EventUploadService } from "../../abstractions/event/event-upload.service";
+import { OrganizationService } from "../../abstractions/organization/organization.service.abstraction";
+import { StateService } from "../../abstractions/state.service";
+import { EventType } from "../../enums/eventType";
+import { EventData } from "../../models/data/event.data";
+
+export class EventCollectionService implements EventCollectionServiceAbstraction {
+  constructor(
+    private cipherService: CipherService,
+    private stateService: StateService,
+    private organizationService: OrganizationService,
+    private eventUploadService: EventUploadService
+  ) {}
+
+  async collect(
+    eventType: EventType,
+    cipherId: string = null,
+    uploadImmediately = false,
+    organizationId: string = null
+  ): Promise<any> {
+    const authed = await this.stateService.getIsAuthenticated();
+    if (!authed) {
+      return;
+    }
+    const organizations = await this.organizationService.getAll();
+    if (organizations == null) {
+      return;
+    }
+    const orgIds = new Set<string>(organizations.filter((o) => o.useEvents).map((o) => o.id));
+    if (orgIds.size === 0) {
+      return;
+    }
+    if (cipherId != null) {
+      const cipher = await this.cipherService.get(cipherId);
+      if (cipher == null || cipher.organizationId == null || !orgIds.has(cipher.organizationId)) {
+        return;
+      }
+    }
+    if (organizationId != null) {
+      if (!orgIds.has(organizationId)) {
+        return;
+      }
+    }
+    let eventCollection = await this.stateService.getEventCollection();
+    if (eventCollection == null) {
+      eventCollection = [];
+    }
+    const event = new EventData();
+    event.type = eventType;
+    event.cipherId = cipherId;
+    event.date = new Date().toISOString();
+    event.organizationId = organizationId;
+    eventCollection.push(event);
+    await this.stateService.setEventCollection(eventCollection);
+    if (uploadImmediately) {
+      await this.eventUploadService.uploadEvents();
+    }
+  }
+}

libs/common/src/services/event/event-upload.service.ts

@@ -0,0 +1,55 @@
+import { ApiService } from "../../abstractions/api.service";
+import { EventUploadService as EventUploadServiceAbstraction } from "../../abstractions/event/event-upload.service";
+import { LogService } from "../../abstractions/log.service";
+import { StateService } from "../../abstractions/state.service";
+import { EventRequest } from "../../models/request/event.request";
+
+export class EventUploadService implements EventUploadServiceAbstraction {
+  private inited = false;
+  constructor(
+    private apiService: ApiService,
+    private stateService: StateService,
+    private logService: LogService
+  ) {}
+
+  init(checkOnInterval: boolean) {
+    if (this.inited) {
+      return;
+    }
+
+    this.inited = true;
+    if (checkOnInterval) {
+      this.uploadEvents();
+      setInterval(() => this.uploadEvents(), 60 * 1000); // check every 60 seconds
+    }
+  }
+
+  async uploadEvents(userId?: string): Promise<void> {
+    const authed = await this.stateService.getIsAuthenticated({ userId: userId });
+    if (!authed) {
+      return;
+    }
+    const eventCollection = await this.stateService.getEventCollection({ userId: userId });
+    if (eventCollection == null || eventCollection.length === 0) {
+      return;
+    }
+    const request = eventCollection.map((e) => {
+      const req = new EventRequest();
+      req.type = e.type;
+      req.cipherId = e.cipherId;
+      req.date = e.date;
+      req.organizationId = e.organizationId;
+      return req;
+    });
+    try {
+      await this.apiService.postEventsCollect(request);
+      this.clearEvents(userId);
+    } catch (e) {
+      this.logService.error(e);
+    }
+  }
+
+  private async clearEvents(userId?: string): Promise<any> {
+    await this.stateService.setEventCollection(null, { userId: userId });
+  }
+}

libs/common/src/services/i18n.service.ts

@@ -122,7 +122,7 @@ export class I18nService implements I18nServiceAbstraction {
     return this.translate(id, p1, p2, p3);
   }
 
-  translate(id: string, p1?: string, p2?: string, p3?: string): string {
+  translate(id: string, p1?: string | number, p2?: string | number, p3?: string | number): string {
     let result: string;
     // eslint-disable-next-line
     if (this.localeMessages.hasOwnProperty(id) && this.localeMessages[id]) {
@@ -136,13 +136,13 @@ export class I18nService implements I18nServiceAbstraction {
 
     if (result !== "") {
       if (p1 != null) {
-        result = result.split("__$1__").join(p1);
+        result = result.split("__$1__").join(p1.toString());
       }
       if (p2 != null) {
-        result = result.split("__$2__").join(p2);
+        result = result.split("__$2__").join(p2.toString());
       }
       if (p3 != null) {
-        result = result.split("__$3__").join(p3);
+        result = result.split("__$3__").join(p3.toString());
       }
     }
 

libs/common/src/services/memoryStorage.service.ts

@@ -18,7 +18,7 @@ export class MemoryStorageService
   }
 
   async has(key: string): Promise<boolean> {
-    return this.get(key) != null;
+    return (await this.get(key)) != null;
   }
 
   save(key: string, obj: any): Promise<any> {

libs/common/src/services/organization/organization.service.ts

@@ -1,21 +1,16 @@
-import { BehaviorSubject, concatMap, filter } from "rxjs";
+import { BehaviorSubject, concatMap } from "rxjs";
 
-import { OrganizationService as OrganizationServiceAbstraction } from "../../abstractions/organization/organization.service.abstraction";
+import { InternalOrganizationService as InternalOrganizationServiceAbstraction } from "../../abstractions/organization/organization.service.abstraction";
 import { StateService } from "../../abstractions/state.service";
-import { SyncNotifierService } from "../../abstractions/sync/syncNotifier.service.abstraction";
 import { OrganizationData } from "../../models/data/organization.data";
 import { Organization } from "../../models/domain/organization";
-import { isSuccessfullyCompleted } from "../../types/syncEventArgs";
 
-export class OrganizationService implements OrganizationServiceAbstraction {
-  private _organizations = new BehaviorSubject<Organization[]>([]);
+export class OrganizationService implements InternalOrganizationServiceAbstraction {
+  protected _organizations = new BehaviorSubject<Organization[]>([]);
 
   organizations$ = this._organizations.asObservable();
 
-  constructor(
-    private stateService: StateService,
-    private syncNotifierService: SyncNotifierService
-  ) {
+  constructor(private stateService: StateService) {
     this.stateService.activeAccountUnlocked$
       .pipe(
         concatMap(async (unlocked) => {
@@ -29,28 +24,6 @@ export class OrganizationService implements OrganizationServiceAbstraction {
         })
       )
       .subscribe();
-
-    this.syncNotifierService.sync$
-      .pipe(
-        filter(isSuccessfullyCompleted),
-        concatMap(async ({ data }) => {
-          const { profile } = data;
-          const organizations: { [id: string]: OrganizationData } = {};
-          profile.organizations.forEach((o) => {
-            organizations[o.id] = new OrganizationData(o);
-          });
-
-          profile.providerOrganizations.forEach((o) => {
-            if (organizations[o.id] == null) {
-              organizations[o.id] = new OrganizationData(o);
-              organizations[o.id].isProviderUser = true;
-            }
-          });
-
-          await this.updateStateAndObservables(organizations);
-        })
-      )
-      .subscribe();
   }
 
   async getAll(userId?: string): Promise<Organization[]> {
@@ -78,7 +51,7 @@ export class OrganizationService implements OrganizationServiceAbstraction {
 
     organizations[organization.id] = organization;
 
-    await this.updateStateAndObservables(organizations);
+    await this.replace(organizations);
   }
 
   async delete(id: string): Promise<void> {
@@ -92,7 +65,7 @@ export class OrganizationService implements OrganizationServiceAbstraction {
     }
 
     delete organizations[id];
-    await this.updateStateAndObservables(organizations);
+    await this.replace(organizations);
   }
 
   get(id: string): Organization {
@@ -121,9 +94,9 @@ export class OrganizationService implements OrganizationServiceAbstraction {
     return organizations.find((organization) => organization.identifier === identifier);
   }
 
-  private async updateStateAndObservables(organizationsMap: { [id: string]: OrganizationData }) {
-    await this.stateService.setOrganizations(organizationsMap);
-    this.updateObservables(organizationsMap);
+  async replace(organizations: { [id: string]: OrganizationData }) {
+    await this.stateService.setOrganizations(organizations);
+    this.updateObservables(organizations);
   }
 
   private updateObservables(organizationsMap: { [id: string]: OrganizationData }) {

libs/common/src/services/policy/policy.service.ts

@@ -16,7 +16,7 @@ import { ListResponse } from "../../models/response/list.response";
 import { PolicyResponse } from "../../models/response/policy.response";
 
 export class PolicyService implements InternalPolicyServiceAbstraction {
-  private _policies: BehaviorSubject<Policy[]> = new BehaviorSubject([]);
+  protected _policies: BehaviorSubject<Policy[]> = new BehaviorSubject([]);
 
   policies$ = this._policies.asObservable();
 

libs/common/src/services/settings.service.ts

@@ -6,7 +6,7 @@ import { Utils } from "../misc/utils";
 import { AccountSettingsSettings } from "../models/domain/account";
 
 export class SettingsService implements SettingsServiceAbstraction {
-  private _settings: BehaviorSubject<AccountSettingsSettings> = new BehaviorSubject({});
+  protected _settings: BehaviorSubject<AccountSettingsSettings> = new BehaviorSubject({});
 
   settings$ = this._settings.asObservable();
 

libs/common/src/services/state.service.ts

@@ -1,4 +1,5 @@
 import { BehaviorSubject, concatMap } from "rxjs";
+import { Jsonify } from "type-fest";
 
 import { LogService } from "../abstractions/log.service";
 import { StateService as StateServiceAbstraction } from "../abstractions/state.service";
@@ -13,6 +14,7 @@ import { StorageLocation } from "../enums/storageLocation";
 import { ThemeType } from "../enums/themeType";
 import { UriMatchType } from "../enums/uriMatchType";
 import { StateFactory } from "../factories/stateFactory";
+import { Utils } from "../misc/utils";
 import { CipherData } from "../models/data/cipher.data";
 import { CollectionData } from "../models/data/collection.data";
 import { EncryptedOrganizationKeyData } from "../models/data/encrypted-organization-key.data";
@@ -65,19 +67,22 @@ export class StateService<
   TAccount extends Account = Account
 > implements StateServiceAbstraction<TAccount>
 {
-  private accountsSubject = new BehaviorSubject<{ [userId: string]: TAccount }>({});
+  protected accountsSubject = new BehaviorSubject<{ [userId: string]: TAccount }>({});
   accounts$ = this.accountsSubject.asObservable();
 
-  private activeAccountSubject = new BehaviorSubject<string | null>(null);
+  protected activeAccountSubject = new BehaviorSubject<string | null>(null);
   activeAccount$ = this.activeAccountSubject.asObservable();
 
-  private activeAccountUnlockedSubject = new BehaviorSubject<boolean>(false);
+  protected activeAccountUnlockedSubject = new BehaviorSubject<boolean>(false);
   activeAccountUnlocked$ = this.activeAccountUnlockedSubject.asObservable();
 
   private hasBeenInited = false;
   private isRecoveredSession = false;
 
-  private accountDiskCache = new Map<string, TAccount>();
+  protected accountDiskCache = new BehaviorSubject<Record<string, TAccount>>({});
+
+  // default account serializer, must be overridden by child class
+  protected accountDeserializer = Account.fromJSON as (json: Jsonify<TAccount>) => TAccount;
 
   constructor(
     protected storageService: AbstractStorageService,
@@ -676,7 +681,7 @@ export class StateService<
     const account = await this.getAccount(
       this.reconcileOptions(options, await this.defaultInMemoryOptions())
     );
-    return this.recordToMap(account?.keys?.organizationKeys?.decrypted);
+    return Utils.recordToMap(account?.keys?.organizationKeys?.decrypted);
   }
 
   async setDecryptedOrganizationKeys(
@@ -686,7 +691,7 @@ export class StateService<
     const account = await this.getAccount(
       this.reconcileOptions(options, await this.defaultInMemoryOptions())
     );
-    account.keys.organizationKeys.decrypted = this.mapToRecord(value);
+    account.keys.organizationKeys.decrypted = Utils.mapToRecord(value);
     await this.saveAccount(
       account,
       this.reconcileOptions(options, await this.defaultInMemoryOptions())
@@ -774,7 +779,7 @@ export class StateService<
     const account = await this.getAccount(
       this.reconcileOptions(options, await this.defaultInMemoryOptions())
     );
-    return this.recordToMap(account?.keys?.providerKeys?.decrypted);
+    return Utils.recordToMap(account?.keys?.providerKeys?.decrypted);
   }
 
   async setDecryptedProviderKeys(
@@ -784,7 +789,7 @@ export class StateService<
     const account = await this.getAccount(
       this.reconcileOptions(options, await this.defaultInMemoryOptions())
     );
-    account.keys.providerKeys.decrypted = this.mapToRecord(value);
+    account.keys.providerKeys.decrypted = Utils.mapToRecord(value);
     await this.saveAccount(
       account,
       this.reconcileOptions(options, await this.defaultInMemoryOptions())
@@ -2378,7 +2383,7 @@ export class StateService<
     }
 
     if (this.useAccountCache) {
-      const cachedAccount = this.accountDiskCache.get(options.userId);
+      const cachedAccount = this.accountDiskCache.value[options.userId];
       if (cachedAccount != null) {
         return cachedAccount;
       }
@@ -2392,9 +2397,7 @@ export class StateService<
         ))
       : await this.storageService.get<TAccount>(options.userId, options);
 
-    if (this.useAccountCache) {
-      this.accountDiskCache.set(options.userId, account);
-    }
+    this.setDiskCache(options.userId, account);
     return account;
   }
 
@@ -2425,9 +2428,7 @@ export class StateService<
 
     await storageLocation.save(`${options.userId}`, account, options);
 
-    if (this.useAccountCache) {
-      this.accountDiskCache.delete(options.userId);
-    }
+    this.deleteDiskCache(options.userId);
   }
 
   protected async saveAccountToMemory(account: TAccount): Promise<void> {
@@ -2638,9 +2639,7 @@ export class StateService<
       userId = userId ?? state.activeUserId;
       delete state.accounts[userId];
 
-      if (this.useAccountCache) {
-        this.accountDiskCache.delete(userId);
-      }
+      this.deleteDiskCache(userId);
 
       return state;
     });
@@ -2744,7 +2743,7 @@ export class StateService<
 
   protected async state(): Promise<State<TGlobalState, TAccount>> {
     const state = await this.memoryStorageService.get<State<TGlobalState, TAccount>>(keys.state, {
-      deserializer: (s) => State.fromJSON(s),
+      deserializer: (s) => State.fromJSON(s, this.accountDeserializer),
     });
     return state;
   }
@@ -2766,51 +2765,21 @@ export class StateService<
     });
   }
 
-  private mapToRecord<V>(map: Map<string, V>): Record<string, V> {
-    return map == null ? null : Object.fromEntries(map);
+  private setDiskCache(key: string, value: TAccount, options?: StorageOptions) {
+    if (this.useAccountCache) {
+      this.accountDiskCache.value[key] = value;
+      this.accountDiskCache.next(this.accountDiskCache.value);
+    }
   }
 
-  private recordToMap<V>(record: Record<string, V>): Map<string, V> {
-    return record == null ? null : new Map(Object.entries(record));
+  private deleteDiskCache(key: string) {
+    if (this.useAccountCache) {
+      delete this.accountDiskCache.value[key];
+      this.accountDiskCache.next(this.accountDiskCache.value);
+    }
   }
 }
 
-export function withPrototype<T>(
-  constructor: new (...args: any[]) => T,
-  converter: (input: any) => T = (i) => i
-): (
-  target: any,
-  propertyKey: string | symbol,
-  descriptor: PropertyDescriptor
-) => { value: (...args: any[]) => Promise<T> } {
-  return (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
-    const originalMethod = descriptor.value;
-
-    return {
-      value: function (...args: any[]) {
-        const originalResult: Promise<T> = originalMethod.apply(this, args);
-
-        if (!(originalResult instanceof Promise)) {
-          throw new Error(
-            `Error applying prototype to stored value -- result is not a promise for method ${String(
-              propertyKey
-            )}`
-          );
-        }
-
-        return originalResult.then((result) => {
-          return result == null ||
-            result.constructor.name === constructor.prototype.constructor.name
-            ? converter(result as T)
-            : converter(
-                Object.create(constructor.prototype, Object.getOwnPropertyDescriptors(result)) as T
-              );
-        });
-      },
-    };
-  };
-}
-
 function withPrototypeForArrayMembers<T>(
   memberConstructor: new (...args: any[]) => T,
   memberConverter: (input: any) => T = (i) => i
@@ -2847,7 +2816,7 @@ function withPrototypeForArrayMembers<T>(
             return result.map((r) => {
               return r == null ||
                 r.constructor.name === memberConstructor.prototype.constructor.name
-                ? memberConverter(r)
+                ? r
                 : memberConverter(
                     Object.create(memberConstructor.prototype, Object.getOwnPropertyDescriptors(r))
                   );

libs/common/src/services/sync/sync.service.ts

@@ -7,17 +7,18 @@ import { InternalFolderService } from "../../abstractions/folder/folder.service.
 import { KeyConnectorService } from "../../abstractions/keyConnector.service";
 import { LogService } from "../../abstractions/log.service";
 import { MessagingService } from "../../abstractions/messaging.service";
+import { InternalOrganizationService } from "../../abstractions/organization/organization.service.abstraction";
 import { InternalPolicyService } from "../../abstractions/policy/policy.service.abstraction";
 import { ProviderService } from "../../abstractions/provider.service";
 import { SendService } from "../../abstractions/send.service";
 import { SettingsService } from "../../abstractions/settings.service";
 import { StateService } from "../../abstractions/state.service";
 import { SyncService as SyncServiceAbstraction } from "../../abstractions/sync/sync.service.abstraction";
-import { SyncNotifierService } from "../../abstractions/sync/syncNotifier.service.abstraction";
 import { sequentialize } from "../../misc/sequentialize";
 import { CipherData } from "../../models/data/cipher.data";
 import { CollectionData } from "../../models/data/collection.data";
 import { FolderData } from "../../models/data/folder.data";
+import { OrganizationData } from "../../models/data/organization.data";
 import { PolicyData } from "../../models/data/policy.data";
 import { ProviderData } from "../../models/data/provider.data";
 import { SendData } from "../../models/data/send.data";
@@ -52,7 +53,7 @@ export class SyncService implements SyncServiceAbstraction {
     private stateService: StateService,
     private providerService: ProviderService,
     private folderApiService: FolderApiServiceAbstraction,
-    private syncNotifierService: SyncNotifierService,
+    private organizationService: InternalOrganizationService,
     private logoutCallback: (expired: boolean) => Promise<void>
   ) {}
 
@@ -76,10 +77,8 @@ export class SyncService implements SyncServiceAbstraction {
   @sequentialize(() => "fullSync")
   async fullSync(forceSync: boolean, allowThrowOnError = false): Promise<boolean> {
     this.syncStarted();
-    this.syncNotifierService.next({ status: "Started" });
     const isAuthenticated = await this.stateService.getIsAuthenticated();
     if (!isAuthenticated) {
-      this.syncNotifierService.next({ status: "Completed", successfully: false });
       return this.syncCompleted(false);
     }
 
@@ -95,7 +94,6 @@ export class SyncService implements SyncServiceAbstraction {
 
     if (!needsSync) {
       await this.setLastSync(now);
-      this.syncNotifierService.next({ status: "Completed", successfully: false });
       return this.syncCompleted(false);
     }
 
@@ -112,13 +110,11 @@ export class SyncService implements SyncServiceAbstraction {
       await this.syncPolicies(response.policies);
 
       await this.setLastSync(now);
-      this.syncNotifierService.next({ status: "Completed", successfully: true, data: response });
       return this.syncCompleted(true);
     } catch (e) {
       if (allowThrowOnError) {
         throw e;
       } else {
-        this.syncNotifierService.next({ status: "Completed", successfully: false });
         return this.syncCompleted(false);
       }
     }
@@ -315,11 +311,24 @@ export class SyncService implements SyncServiceAbstraction {
     await this.stateService.setForcePasswordReset(response.forcePasswordReset);
     await this.keyConnectorService.setUsesKeyConnector(response.usesKeyConnector);
 
+    const organizations: { [id: string]: OrganizationData } = {};
+    response.organizations.forEach((o) => {
+      organizations[o.id] = new OrganizationData(o);
+    });
+
     const providers: { [id: string]: ProviderData } = {};
     response.providers.forEach((p) => {
       providers[p.id] = new ProviderData(p);
     });
 
+    response.providerOrganizations.forEach((o) => {
+      if (organizations[o.id] == null) {
+        organizations[o.id] = new OrganizationData(o);
+        organizations[o.id].isProviderUser = true;
+      }
+    });
+
+    await this.organizationService.replace(organizations);
     await this.providerService.save(providers);
 
     if (await this.keyConnectorService.userNeedsMigration()) {

libs/common/src/services/usernameGeneration.service.ts

@@ -2,13 +2,13 @@ import { ApiService } from "../abstractions/api.service";
 import { CryptoService } from "../abstractions/crypto.service";
 import { StateService } from "../abstractions/state.service";
 import { UsernameGenerationService as BaseUsernameGenerationService } from "../abstractions/usernameGeneration.service";
-import { AnonAddyForwarder } from "../emailForwarders/anonAddyForwarder";
-import { DuckDuckGoForwarder } from "../emailForwarders/duckDuckGoForwarder";
-import { FastmailForwarder } from "../emailForwarders/fastmailForwarder";
-import { FirefoxRelayForwarder } from "../emailForwarders/firefoxRelayForwarder";
-import { Forwarder } from "../emailForwarders/forwarder";
-import { ForwarderOptions } from "../emailForwarders/forwarderOptions";
-import { SimpleLoginForwarder } from "../emailForwarders/simpleLoginForwarder";
+import { AnonAddyForwarder } from "../email-forwarders/anon-addy-forwarder";
+import { DuckDuckGoForwarder } from "../email-forwarders/duck-duck-go-forwarder";
+import { FastmailForwarder } from "../email-forwarders/fastmail-forwarder";
+import { FirefoxRelayForwarder } from "../email-forwarders/firefox-relay-forwarder";
+import { Forwarder } from "../email-forwarders/forwarder";
+import { ForwarderOptions } from "../email-forwarders/forwarder-options";
+import { SimpleLoginForwarder } from "../email-forwarders/simple-login-forwarder";
 import { EFFLongWordList } from "../misc/wordlist";
 
 const DefaultOptions = {