[PM-19479] Client-Managed SDK state definition

apps/browser/src/background/main.background.ts

@@ -781,6 +781,7 @@ export default class MainBackground {
       this.accountService,
       this.kdfConfigService,
       this.keyService,
+      this.stateProvider,
     );
 
     this.passwordStrengthService = new PasswordStrengthService();

apps/cli/src/service-container/service-container.ts

@@ -606,6 +606,7 @@ export class ServiceContainer {
       this.accountService,
       this.kdfConfigService,
       this.keyService,
+      this.stateProvider,
       customUserAgent,
     );
 

libs/angular/src/services/jslib-services.module.ts

@@ -1475,6 +1475,7 @@ const safeProviders: SafeProvider[] = [
       AccountServiceAbstraction,
       KdfConfigService,
       KeyService,
+      StateProvider,
     ],
   }),
   safeProvider({

libs/common/src/platform/services/sdk/client-managed-state.ts

@@ -0,0 +1,64 @@
+import { firstValueFrom, map } from "rxjs";
+
+import { UserId } from "@bitwarden/common/types/guid";
+import { CipherRecordMapper } from "@bitwarden/common/vault/models/domain/cipher";
+import { StateClient, Repository } from "@bitwarden/sdk-internal";
+
+import { StateProvider, UserKeyDefinition } from "../../state";
+
+export async function initializeState(
+  userId: UserId,
+  stateClient: StateClient,
+  stateProvider: StateProvider,
+): Promise<void> {
+  await stateClient.register_cipher_repository(
+    new RepositoryRecord(userId, stateProvider, new CipherRecordMapper()),
+  );
+}
+
+export interface SdkRecordMapper<ClientType, SdkType> {
+  userKeyDefinition(): UserKeyDefinition<Record<string, ClientType>>;
+  toSdk(value: ClientType): SdkType;
+  fromSdk(value: SdkType): ClientType;
+}
+
+class RepositoryRecord<ClientType, SdkType> implements Repository<SdkType> {
+  constructor(
+    private userId: UserId,
+    private stateProvider: StateProvider,
+    private mapper: SdkRecordMapper<ClientType, SdkType>,
+  ) {}
+
+  async get(id: string): Promise<SdkType | null> {
+    const prov = this.stateProvider.getUser(this.userId, this.mapper.userKeyDefinition());
+    const data = await firstValueFrom(prov.state$.pipe(map((data) => data ?? {})));
+    const element = data[id];
+    if (!element) {
+      return null;
+    }
+    return this.mapper.toSdk(element);
+  }
+
+  async list(): Promise<SdkType[]> {
+    const prov = this.stateProvider.getUser(this.userId, this.mapper.userKeyDefinition());
+    const elements = await firstValueFrom(prov.state$.pipe(map((data) => data ?? {})));
+    return Object.values(elements).map((element) => this.mapper.toSdk(element));
+  }
+
+  async set(id: string, value: SdkType): Promise<void> {
+    const prov = this.stateProvider.getUser(this.userId, this.mapper.userKeyDefinition());
+    const elements = await firstValueFrom(prov.state$.pipe(map((data) => data ?? {})));
+    elements[id] = this.mapper.fromSdk(value);
+    await prov.update(() => elements);
+  }
+
+  async remove(id: string): Promise<void> {
+    const prov = this.stateProvider.getUser(this.userId, this.mapper.userKeyDefinition());
+    const elements = await firstValueFrom(prov.state$.pipe(map((data) => data ?? {})));
+    if (!elements[id]) {
+      return;
+    }
+    delete elements[id];
+    await prov.update(() => elements);
+  }
+}

libs/common/src/platform/services/sdk/default-sdk.service.ts

@@ -36,6 +36,9 @@
 import { compareValues } from "../../misc/compare-values";
 import { Rc } from "../../misc/reference-counting/rc";
 import { EncryptedString } from "../../models/domain/enc-string";
+import { StateProvider } from "../../state";
+
+import { initializeState } from "./client-managed-state";
 
 // A symbol that represents an overriden client that is explicitly set to undefined,
 // blocking the creation of an internal client for that user.
@@ -68,6 +71,7 @@
     private accountService: AccountService,
     private kdfConfigService: KdfConfigService,
     private keyService: KeyService,
+    private stateProvider?: StateProvider,
     private userAgent: string | null = null,
   ) {}
 
@@ -224,6 +228,12 @@
           .map(([k, v]) => [k, v.key]),
       ),
     });
+
+    // This is optional to avoid having to mock it on the tests
+    if (this.stateProvider) {
+      // Initialize the SDK managed database and the client managed repositories.
+      await initializeState(userId, client.platform().state(), this.stateProvider);
+    }
   }
 
   private toSettings(env: Environment): ClientSettings {

libs/common/src/vault/models/domain/cipher.ts

@@ -2,6 +2,8 @@
 // @ts-strict-ignore
 import { Jsonify } from "type-fest";
 
+import { SdkRecordMapper } from "@bitwarden/common/platform/services/sdk/client-managed-state";
+import { UserKeyDefinition } from "@bitwarden/common/platform/state";
 import { Cipher as SdkCipher } from "@bitwarden/sdk-internal";
 
 import { Decryptable } from "../../../platform/interfaces/decryptable.interface";
@@ -12,6 +14,7 @@
 import { InitializerKey } from "../../../platform/services/cryptography/initializer-key";
 import { CipherRepromptType } from "../../enums/cipher-reprompt-type";
 import { CipherType } from "../../enums/cipher-type";
+import { ENCRYPTED_CIPHERS } from "../../services/key-state/ciphers.state";
 import { CipherPermissionsApi } from "../api/cipher-permissions.api";
 import { CipherData } from "../data/cipher.data";
 import { LocalData } from "../data/local.data";
@@ -409,3 +412,17 @@
     return sdkCipher;
   }
 }
+
+export class CipherRecordMapper implements SdkRecordMapper<CipherData, SdkCipher> {
+  userKeyDefinition(): UserKeyDefinition<Record<string, CipherData>> {
+    return ENCRYPTED_CIPHERS;
+  }
+
+  toSdk(value: CipherData): SdkCipher {
+    return new Cipher(value).toSdkCipher();
+  }
+
+  fromSdk(value: SdkCipher): CipherData {
+    throw new Error("Cipher.fromSdk is not implemented yet");
+  }
+}