@credo-ts/askar 0.6.1-pr-2091-20241119140918 → 0.6.1

package/build/AskarApi.d.mts

@@ -0,0 +1,68 @@
+import { AskarModuleConfig } from "./AskarModuleConfig.mjs";
+import { AskarStoreExportOptions, AskarStoreImportOptions, AskarStoreRotateKeyOptions } from "./AskarApiOptions.mjs";
+import { AskarStoreManager } from "./AskarStoreManager.mjs";
+import { AgentContext } from "@credo-ts/core";
+
+//#region src/AskarApi.d.ts
+declare class AskarApi {
+  private agentContext;
+  private askarStoreManager;
+  readonly config: AskarModuleConfig;
+  constructor(agentContext: AgentContext, askarStoreManager: AskarStoreManager, config: AskarModuleConfig);
+  get isStoreOpen(): boolean;
+  /**
+   * @throws {AskarStoreDuplicateError} if the wallet already exists
+   * @throws {AskarStoreError} if another error occurs
+   */
+  provisionStore(): Promise<void>;
+  /**
+   * @throws {AskarStoreNotFoundError} if the wallet does not exist
+   * @throws {AskarStoreError} if another error occurs
+   */
+  openStore(): Promise<void>;
+  /**
+   * Rotate the key of the current askar store.
+   *
+   * NOTE: multiple agent contexts (tenants) can use the same store. This method rotates the key for the whole store,
+   * it is advised to only run this method on the root tenant agent when using profile per wallet database strategy.
+   * After running this method you should change the store configuration in the Askar module.
+   *
+   * @throws {AskarStoreNotFoundError} if the wallet does not exist
+   * @throws {AskarStoreError} if another error occurs
+   */
+  rotateStoreKey(options: AskarStoreRotateKeyOptions): Promise<void>;
+  /**
+   * Exports the current askar store.
+   *
+   * NOTE: a store can contain profiles for multiple tenants. When you export a store
+   * all profiles will be exported with it.
+   *
+   * NOTE: store must be open before store can be expored
+   */
+  exportStore(options: AskarStoreExportOptions): Promise<void>;
+  /**
+   * Imports from an external store config into the current askar store config.
+   *
+   * NOTE: store must be closed first (using `closeStore`) before store can be imported
+   */
+  importStore(options: AskarStoreImportOptions): Promise<void>;
+  /**
+   * Delete the current askar store.
+   *
+   * NOTE: multiple agent contexts (tenants) can use the same store. This method deletes the whole store.
+   *
+   *
+   * @throws {AskarStoreNotFoundError} if the wallet does not exist
+   * @throws {AskarStoreError} if another error occurs
+   */
+  deleteStore(): Promise<void>;
+  /**
+   * Close the current askar store.
+   *
+   * This will close all sessions (also for tenants) in this store.
+   */
+  closeStore(): Promise<void>;
+}
+//#endregion
+export { AskarApi };
+//# sourceMappingURL=AskarApi.d.mts.map

package/build/AskarApi.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AskarApi.d.mts","names":[],"sources":["../src/AskarApi.ts"],"sourcesContent":[],"mappings":";;;;;;cAQa,QAAA;;EAAA,QAAA,iBAAQ;EAIO,SAAA,MAAA,EAAA,iBAAA;EAFF,WAAA,CAAA,YAAA,EAAA,YAAA,EAAA,iBAAA,EACK,iBADL,EAAA,MAAA,EAEE,iBAFF;EACK,IAAA,WAAA,CAAA,CAAA,EAAA,OAAA;EACH;;;;EAiCwC,cAAA,CAAA,CAAA,EAtBnC,OAsBmC,CAAA,IAAA,CAAA;EAYhC;;;;EAsBN,SAAA,CAAA,CAAA,EAhDF,OAgDE,CAAA,IAAA,CAAA;EASL;;;;;;;;;;0BA3Cc,6BAA6B;;;;;;;;;uBAYhC,0BAAuB;;;;;;uBASvB,0BAAuB;;;;;;;;;;iBAa7B;;;;;;gBASL"}

package/build/AskarApi.mjs

@@ -0,0 +1,94 @@
+import { AskarModuleConfig } from "./AskarModuleConfig.mjs";
+import { __decorateMetadata } from "./_virtual/_@oxc-project_runtime@0.99.0/helpers/decorateMetadata.mjs";
+import { __decorate } from "./_virtual/_@oxc-project_runtime@0.99.0/helpers/decorate.mjs";
+import { AskarStoreManager } from "./AskarStoreManager.mjs";
+import { AgentContext } from "@credo-ts/core";
+import { injectable as injectable$1 } from "tsyringe";
+
+//#region src/AskarApi.ts
+var _ref, _ref2, _ref3;
+let AskarApi = class AskarApi$1 {
+	constructor(agentContext, askarStoreManager, config) {
+		this.agentContext = agentContext;
+		this.askarStoreManager = askarStoreManager;
+		this.config = config;
+	}
+	get isStoreOpen() {
+		return this.askarStoreManager.isStoreOpen(this.agentContext);
+	}
+	/**
+	* @throws {AskarStoreDuplicateError} if the wallet already exists
+	* @throws {AskarStoreError} if another error occurs
+	*/
+	async provisionStore() {
+		await this.askarStoreManager.provisionStore(this.agentContext);
+	}
+	/**
+	* @throws {AskarStoreNotFoundError} if the wallet does not exist
+	* @throws {AskarStoreError} if another error occurs
+	*/
+	async openStore() {
+		await this.askarStoreManager.openStore(this.agentContext);
+	}
+	/**
+	* Rotate the key of the current askar store.
+	*
+	* NOTE: multiple agent contexts (tenants) can use the same store. This method rotates the key for the whole store,
+	* it is advised to only run this method on the root tenant agent when using profile per wallet database strategy.
+	* After running this method you should change the store configuration in the Askar module.
+	*
+	* @throws {AskarStoreNotFoundError} if the wallet does not exist
+	* @throws {AskarStoreError} if another error occurs
+	*/
+	async rotateStoreKey(options) {
+		await this.askarStoreManager.rotateStoreKey(this.agentContext, options);
+	}
+	/**
+	* Exports the current askar store.
+	*
+	* NOTE: a store can contain profiles for multiple tenants. When you export a store
+	* all profiles will be exported with it.
+	*
+	* NOTE: store must be open before store can be expored
+	*/
+	async exportStore(options) {
+		await this.askarStoreManager.exportStore(this.agentContext, options);
+	}
+	/**
+	* Imports from an external store config into the current askar store config.
+	*
+	* NOTE: store must be closed first (using `closeStore`) before store can be imported
+	*/
+	async importStore(options) {
+		await this.askarStoreManager.importStore(this.agentContext, options);
+	}
+	/**
+	* Delete the current askar store.
+	*
+	* NOTE: multiple agent contexts (tenants) can use the same store. This method deletes the whole store.
+	*
+	*
+	* @throws {AskarStoreNotFoundError} if the wallet does not exist
+	* @throws {AskarStoreError} if another error occurs
+	*/
+	async deleteStore() {
+		await this.askarStoreManager.deleteStore(this.agentContext);
+	}
+	/**
+	* Close the current askar store.
+	*
+	* This will close all sessions (also for tenants) in this store.
+	*/
+	async closeStore() {
+		await this.askarStoreManager.closeStore(this.agentContext);
+	}
+};
+AskarApi = __decorate([injectable$1(), __decorateMetadata("design:paramtypes", [
+	typeof (_ref = typeof AgentContext !== "undefined" && AgentContext) === "function" ? _ref : Object,
+	typeof (_ref2 = typeof AskarStoreManager !== "undefined" && AskarStoreManager) === "function" ? _ref2 : Object,
+	typeof (_ref3 = typeof AskarModuleConfig !== "undefined" && AskarModuleConfig) === "function" ? _ref3 : Object
+])], AskarApi);
+
+//#endregion
+export { AskarApi };
+//# sourceMappingURL=AskarApi.mjs.map

package/build/AskarApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AskarApi.mjs","names":["AskarApi","agentContext: AgentContext","askarStoreManager: AskarStoreManager","config: AskarModuleConfig","injectable"],"sources":["../src/AskarApi.ts"],"sourcesContent":["import { AgentContext } from '@credo-ts/core'\nimport { injectable } from 'tsyringe'\n\nimport type { AskarStoreExportOptions, AskarStoreImportOptions, AskarStoreRotateKeyOptions } from './AskarApiOptions'\nimport { AskarModuleConfig } from './AskarModuleConfig'\nimport { AskarStoreManager } from './AskarStoreManager'\n\n@injectable()\nexport class AskarApi {\n  public constructor(\n    private agentContext: AgentContext,\n    private askarStoreManager: AskarStoreManager,\n    public readonly config: AskarModuleConfig\n  ) {}\n\n  public get isStoreOpen() {\n    return this.askarStoreManager.isStoreOpen(this.agentContext)\n  }\n\n  /**\n   * @throws {AskarStoreDuplicateError} if the wallet already exists\n   * @throws {AskarStoreError} if another error occurs\n   */\n  public async provisionStore(): Promise<void> {\n    await this.askarStoreManager.provisionStore(this.agentContext)\n  }\n\n  /**\n   * @throws {AskarStoreNotFoundError} if the wallet does not exist\n   * @throws {AskarStoreError} if another error occurs\n   */\n  public async openStore(): Promise<void> {\n    await this.askarStoreManager.openStore(this.agentContext)\n  }\n\n  /**\n   * Rotate the key of the current askar store.\n   *\n   * NOTE: multiple agent contexts (tenants) can use the same store. This method rotates the key for the whole store,\n   * it is advised to only run this method on the root tenant agent when using profile per wallet database strategy.\n   * After running this method you should change the store configuration in the Askar module.\n   *\n   * @throws {AskarStoreNotFoundError} if the wallet does not exist\n   * @throws {AskarStoreError} if another error occurs\n   */\n  public async rotateStoreKey(options: AskarStoreRotateKeyOptions): Promise<void> {\n    await this.askarStoreManager.rotateStoreKey(this.agentContext, options)\n  }\n\n  /**\n   * Exports the current askar store.\n   *\n   * NOTE: a store can contain profiles for multiple tenants. When you export a store\n   * all profiles will be exported with it.\n   *\n   * NOTE: store must be open before store can be expored\n   */\n  public async exportStore(options: AskarStoreExportOptions) {\n    await this.askarStoreManager.exportStore(this.agentContext, options)\n  }\n\n  /**\n   * Imports from an external store config into the current askar store config.\n   *\n   * NOTE: store must be closed first (using `closeStore`) before store can be imported\n   */\n  public async importStore(options: AskarStoreImportOptions) {\n    await this.askarStoreManager.importStore(this.agentContext, options)\n  }\n\n  /**\n   * Delete the current askar store.\n   *\n   * NOTE: multiple agent contexts (tenants) can use the same store. This method deletes the whole store.\n   *\n   *\n   * @throws {AskarStoreNotFoundError} if the wallet does not exist\n   * @throws {AskarStoreError} if another error occurs\n   */\n  public async deleteStore(): Promise<void> {\n    await this.askarStoreManager.deleteStore(this.agentContext)\n  }\n\n  /**\n   * Close the current askar store.\n   *\n   * This will close all sessions (also for tenants) in this store.\n   */\n  public async closeStore() {\n    await this.askarStoreManager.closeStore(this.agentContext)\n  }\n}\n"],"mappings":";;;;;;;;;AAQO,qBAAMA,WAAS;CACpB,AAAO,YACL,AAAQC,cACR,AAAQC,mBACR,AAAgBC,QAChB;EAHQ;EACA;EACQ;;CAGlB,IAAW,cAAc;AACvB,SAAO,KAAK,kBAAkB,YAAY,KAAK,aAAa;;;;;;CAO9D,MAAa,iBAAgC;AAC3C,QAAM,KAAK,kBAAkB,eAAe,KAAK,aAAa;;;;;;CAOhE,MAAa,YAA2B;AACtC,QAAM,KAAK,kBAAkB,UAAU,KAAK,aAAa;;;;;;;;;;;;CAa3D,MAAa,eAAe,SAAoD;AAC9E,QAAM,KAAK,kBAAkB,eAAe,KAAK,cAAc,QAAQ;;;;;;;;;;CAWzE,MAAa,YAAY,SAAkC;AACzD,QAAM,KAAK,kBAAkB,YAAY,KAAK,cAAc,QAAQ;;;;;;;CAQtE,MAAa,YAAY,SAAkC;AACzD,QAAM,KAAK,kBAAkB,YAAY,KAAK,cAAc,QAAQ;;;;;;;;;;;CAYtE,MAAa,cAA6B;AACxC,QAAM,KAAK,kBAAkB,YAAY,KAAK,aAAa;;;;;;;CAQ7D,MAAa,aAAa;AACxB,QAAM,KAAK,kBAAkB,WAAW,KAAK,aAAa;;;uBAlF7DC,cAAY"}

package/build/AskarApiOptions.d.mts

@@ -0,0 +1,29 @@
+import { AskarModuleConfigStoreOptions } from "./AskarModuleConfig.mjs";
+
+//#region src/AskarApiOptions.d.ts
+interface AskarStoreExportOptions {
+  /**
+   * The store config to export the current store to.
+   */
+  exportToStore: AskarModuleConfigStoreOptions;
+}
+interface AskarStoreImportOptions {
+  /**
+   * The store config to import the current store from.
+   */
+  importFromStore: AskarModuleConfigStoreOptions;
+}
+interface AskarStoreRotateKeyOptions {
+  /**
+   * The new key to use for the store.
+   */
+  newKey: string;
+  /**
+   * The new key derivation method to use for the store. If not provided the
+   * key derivation method from the current store config will be used.
+   */
+  newKeyDerivationMethod?: AskarModuleConfigStoreOptions['keyDerivationMethod'];
+}
+//#endregion
+export { AskarStoreExportOptions, AskarStoreImportOptions, AskarStoreRotateKeyOptions };
+//# sourceMappingURL=AskarApiOptions.d.mts.map

package/build/AskarApiOptions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AskarApiOptions.d.mts","names":[],"sources":["../src/AskarApiOptions.ts"],"sourcesContent":[],"mappings":";;;UAEiB,uBAAA;;AAAjB;AAOA;EAOiB,aAAA,EAVA,6BAoBU;;UAjBV,uBAAA;;;;mBAIE;;UAGF,0BAAA;;;;;;;;;2BAUU"}

package/build/AskarModule.d.mts

@@ -0,0 +1,18 @@
+import { AskarModuleConfig, AskarModuleConfigOptions } from "./AskarModuleConfig.mjs";
+import { AskarApi } from "./AskarApi.mjs";
+import { AgentContext, DependencyManager, Module } from "@credo-ts/core";
+
+//#region src/AskarModule.d.ts
+declare class AskarModule implements Module {
+  readonly config: AskarModuleConfig;
+  constructor(config: AskarModuleConfigOptions);
+  api: typeof AskarApi;
+  register(dependencyManager: DependencyManager): void;
+  onInitializeContext(agentContext: AgentContext): Promise<void>;
+  onProvisionContext(agentContext: AgentContext): Promise<void>;
+  onDeleteContext(agentContext: AgentContext): Promise<void>;
+  onCloseContext(agentContext: AgentContext): Promise<void>;
+}
+//#endregion
+export { AskarModule };
+//# sourceMappingURL=AskarModule.d.mts.map

package/build/AskarModule.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AskarModule.d.mts","names":[],"sources":["../src/AskarModule.ts"],"sourcesContent":[],"mappings":";;;;;cAYa,WAAA,YAAuB;EAAvB,SAAA,MAAY,EACC,iBADD;EACC,WAAA,CAAA,MAAA,EAEG,wBAFH;EAEG,GAAA,EAAA,OAIjB,QAJiB;EAIjB,QAAA,CAAA,iBAAA,EAEyB,iBAFzB,CAAA,EAAA,IAAA;EAEyB,mBAAA,CAAA,YAAA,EAgCY,YAhCZ,CAAA,EAgCwB,OAhCxB,CAAA,IAAA,CAAA;EAgCY,kBAAA,CAAA,YAAA,EAKD,YALC,CAAA,EAKW,OALX,CAAA,IAAA,CAAA;EAAY,eAAA,CAAA,YAAA,EAoChB,YApCgB,CAAA,EAoCJ,OApCI,CAAA,IAAA,CAAA;EAKb,cAAA,CAAA,YAAA,EAsCJ,YAtCI,CAAA,EAsCW,OAtCX,CAAA,IAAA,CAAA"}

package/build/AskarModule.mjs

@@ -0,0 +1,61 @@
+import { AskarModuleConfig, AskarMultiWalletDatabaseScheme } from "./AskarModuleConfig.mjs";
+import { storeAskarStoreConfigForContextCorrelationId } from "./tenants.mjs";
+import { AskarErrorCode } from "./utils/askarError.mjs";
+import "./utils/index.mjs";
+import { AskarStoreManager } from "./AskarStoreManager.mjs";
+import { AskarApi } from "./AskarApi.mjs";
+import { AskarKeyManagementService } from "./kms/AskarKeyManagementService.mjs";
+import { AskarStorageService } from "./storage/AskarStorageService.mjs";
+import "./storage/index.mjs";
+import { AgentConfig, CredoError, InjectionSymbols, Kms } from "@credo-ts/core";
+import { AskarError } from "@openwallet-foundation/askar-shared";
+
+//#region src/AskarModule.ts
+var AskarModule = class {
+	constructor(config) {
+		this.api = AskarApi;
+		this.config = new AskarModuleConfig(config);
+	}
+	register(dependencyManager) {
+		dependencyManager.registerInstance(AskarModuleConfig, this.config);
+		if (!this.config.enableKms && !this.config.enableStorage) dependencyManager.resolve(AgentConfig).logger.warn(`Both 'enableKms' and 'enableStorage' are disabled, meaning Askar won't be used by the agent.`);
+		if (this.config.enableKms) {
+			const kmsConfig = dependencyManager.resolve(Kms.KeyManagementModuleConfig);
+			if (kmsConfig.backends.find((backend) => backend.backend === AskarKeyManagementService.backend)) throw new CredoError(`Unable to register AskarKeyManagementService. There is a key management backend with name '${AskarKeyManagementService.backend}' already registered. If you have manually registered the AskarKeyManagementService on the KeyManagementModule, set 'enableKms' to false in the AskarModule.`);
+			kmsConfig.registerBackend(new AskarKeyManagementService());
+		}
+		if (this.config.enableStorage) {
+			if (dependencyManager.isRegistered(InjectionSymbols.StorageService)) throw new CredoError("Unable to register AskarStorageService. There is an instance of StorageService already registered");
+			dependencyManager.registerSingleton(InjectionSymbols.StorageService, AskarStorageService);
+		}
+		dependencyManager.registerSingleton(AskarStoreManager);
+	}
+	async onInitializeContext(agentContext) {
+		await agentContext.dependencyManager.resolve(AskarStoreManager).getInitializedStoreWithProfile(agentContext);
+	}
+	async onProvisionContext(agentContext) {
+		if (agentContext.isRootAgentContext) return;
+		if (this.config.multiWalletDatabaseScheme === AskarMultiWalletDatabaseScheme.ProfilePerWallet) {
+			const { store, profile } = await agentContext.dependencyManager.resolve(AskarStoreManager).getInitializedStoreWithProfile(agentContext);
+			if (!profile) return;
+			try {
+				await store.createProfile(profile);
+			} catch (err) {
+				if (err instanceof AskarError && err.code === AskarErrorCode.Duplicate) return;
+				throw err;
+			}
+			return;
+		}
+		await storeAskarStoreConfigForContextCorrelationId(agentContext, { key: this.config.askar.storeGenerateRawKey({}) });
+	}
+	async onDeleteContext(agentContext) {
+		await agentContext.dependencyManager.resolve(AskarStoreManager).deleteContext(agentContext);
+	}
+	async onCloseContext(agentContext) {
+		await agentContext.dependencyManager.resolve(AskarStoreManager).closeContext(agentContext);
+	}
+};
+
+//#endregion
+export { AskarModule };
+//# sourceMappingURL=AskarModule.mjs.map

package/build/AskarModule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AskarModule.mjs","names":[],"sources":["../src/AskarModule.ts"],"sourcesContent":["import type { AgentContext, DependencyManager, Module } from '@credo-ts/core'\nimport { AgentConfig, CredoError, InjectionSymbols, Kms } from '@credo-ts/core'\nimport { AskarError } from '@openwallet-foundation/askar-shared'\nimport { AskarApi } from './AskarApi'\nimport type { AskarModuleConfigOptions } from './AskarModuleConfig'\nimport { AskarModuleConfig, AskarMultiWalletDatabaseScheme } from './AskarModuleConfig'\nimport { AskarStoreManager } from './AskarStoreManager'\nimport { AskarKeyManagementService } from './kms/AskarKeyManagementService'\nimport { AskarStorageService } from './storage'\nimport { storeAskarStoreConfigForContextCorrelationId } from './tenants'\nimport { AskarErrorCode } from './utils'\n\nexport class AskarModule implements Module {\n  public readonly config: AskarModuleConfig\n\n  public constructor(config: AskarModuleConfigOptions) {\n    this.config = new AskarModuleConfig(config)\n  }\n\n  public api = AskarApi\n\n  public register(dependencyManager: DependencyManager) {\n    dependencyManager.registerInstance(AskarModuleConfig, this.config)\n\n    if (!this.config.enableKms && !this.config.enableStorage) {\n      dependencyManager\n        .resolve(AgentConfig)\n        .logger.warn(`Both 'enableKms' and 'enableStorage' are disabled, meaning Askar won't be used by the agent.`)\n    }\n\n    if (this.config.enableKms) {\n      const kmsConfig = dependencyManager.resolve(Kms.KeyManagementModuleConfig)\n      if (kmsConfig.backends.find((backend) => backend.backend === AskarKeyManagementService.backend)) {\n        throw new CredoError(\n          `Unable to register AskarKeyManagementService. There is a key management backend with name '${AskarKeyManagementService.backend}' already registered. If you have manually registered the AskarKeyManagementService on the KeyManagementModule, set 'enableKms' to false in the AskarModule.`\n        )\n      }\n\n      kmsConfig.registerBackend(new AskarKeyManagementService())\n    }\n\n    if (this.config.enableStorage) {\n      if (dependencyManager.isRegistered(InjectionSymbols.StorageService)) {\n        throw new CredoError(\n          'Unable to register AskarStorageService. There is an instance of StorageService already registered'\n        )\n      }\n      dependencyManager.registerSingleton(InjectionSymbols.StorageService, AskarStorageService)\n    }\n\n    dependencyManager.registerSingleton(AskarStoreManager)\n  }\n\n  public async onInitializeContext(agentContext: AgentContext) {\n    const storeManager = agentContext.dependencyManager.resolve(AskarStoreManager)\n    await storeManager.getInitializedStoreWithProfile(agentContext)\n  }\n\n  public async onProvisionContext(agentContext: AgentContext) {\n    // We don't have any side effects to run\n    if (agentContext.isRootAgentContext) {\n      return\n    }\n\n    // Ensure we have a profile for context\n    if (this.config.multiWalletDatabaseScheme === AskarMultiWalletDatabaseScheme.ProfilePerWallet) {\n      const storeManager = agentContext.dependencyManager.resolve(AskarStoreManager)\n      const { store, profile } = await storeManager.getInitializedStoreWithProfile(agentContext)\n      if (!profile) return\n\n      try {\n        await store.createProfile(profile)\n      } catch (err) {\n        if (err instanceof AskarError && err.code === AskarErrorCode.Duplicate) {\n          return\n        }\n\n        throw err\n      }\n\n      return\n    }\n\n    // For new stores (so not profiles) we need to generate a wallet key\n    await storeAskarStoreConfigForContextCorrelationId(agentContext, {\n      key: this.config.askar.storeGenerateRawKey({}),\n    })\n  }\n\n  public async onDeleteContext(agentContext: AgentContext) {\n    const storeManager = agentContext.dependencyManager.resolve(AskarStoreManager)\n\n    // Will delete either the store (when root agent context or database per wallet) or profile (when not root agent context and profile per wallet)\n    await storeManager.deleteContext(agentContext)\n  }\n\n  public async onCloseContext(agentContext: AgentContext): Promise<void> {\n    const storeManager = agentContext.dependencyManager.resolve(AskarStoreManager)\n\n    await storeManager.closeContext(agentContext)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAYA,IAAa,cAAb,MAA2C;CAGzC,AAAO,YAAY,QAAkC;OAI9C,MAAM;AAHX,OAAK,SAAS,IAAI,kBAAkB,OAAO;;CAK7C,AAAO,SAAS,mBAAsC;AACpD,oBAAkB,iBAAiB,mBAAmB,KAAK,OAAO;AAElE,MAAI,CAAC,KAAK,OAAO,aAAa,CAAC,KAAK,OAAO,cACzC,mBACG,QAAQ,YAAY,CACpB,OAAO,KAAK,+FAA+F;AAGhH,MAAI,KAAK,OAAO,WAAW;GACzB,MAAM,YAAY,kBAAkB,QAAQ,IAAI,0BAA0B;AAC1E,OAAI,UAAU,SAAS,MAAM,YAAY,QAAQ,YAAY,0BAA0B,QAAQ,CAC7F,OAAM,IAAI,WACR,8FAA8F,0BAA0B,QAAQ,8JACjI;AAGH,aAAU,gBAAgB,IAAI,2BAA2B,CAAC;;AAG5D,MAAI,KAAK,OAAO,eAAe;AAC7B,OAAI,kBAAkB,aAAa,iBAAiB,eAAe,CACjE,OAAM,IAAI,WACR,oGACD;AAEH,qBAAkB,kBAAkB,iBAAiB,gBAAgB,oBAAoB;;AAG3F,oBAAkB,kBAAkB,kBAAkB;;CAGxD,MAAa,oBAAoB,cAA4B;AAE3D,QADqB,aAAa,kBAAkB,QAAQ,kBAAkB,CAC3D,+BAA+B,aAAa;;CAGjE,MAAa,mBAAmB,cAA4B;AAE1D,MAAI,aAAa,mBACf;AAIF,MAAI,KAAK,OAAO,8BAA8B,+BAA+B,kBAAkB;GAE7F,MAAM,EAAE,OAAO,YAAY,MADN,aAAa,kBAAkB,QAAQ,kBAAkB,CAChC,+BAA+B,aAAa;AAC1F,OAAI,CAAC,QAAS;AAEd,OAAI;AACF,UAAM,MAAM,cAAc,QAAQ;YAC3B,KAAK;AACZ,QAAI,eAAe,cAAc,IAAI,SAAS,eAAe,UAC3D;AAGF,UAAM;;AAGR;;AAIF,QAAM,6CAA6C,cAAc,EAC/D,KAAK,KAAK,OAAO,MAAM,oBAAoB,EAAE,CAAC,EAC/C,CAAC;;CAGJ,MAAa,gBAAgB,cAA4B;AAIvD,QAHqB,aAAa,kBAAkB,QAAQ,kBAAkB,CAG3D,cAAc,aAAa;;CAGhD,MAAa,eAAe,cAA2C;AAGrE,QAFqB,aAAa,kBAAkB,QAAQ,kBAAkB,CAE3D,aAAa,aAAa"}

package/build/AskarModuleConfig.d.mts

@@ -0,0 +1,125 @@
+import { AskarPostgresStorageConfig, AskarSqliteStorageConfig } from "./AskarStorageConfig.mjs";
+import { Askar, KdfMethod } from "@openwallet-foundation/askar-shared";
+
+//#region src/AskarModuleConfig.d.ts
+declare enum AskarMultiWalletDatabaseScheme {
+  /**
+   * Each wallet get its own database and uses a separate store.
+   */
+  DatabasePerWallet = "DatabasePerWallet",
+  /**
+   * All wallets are stored in a single database, but each wallet uses a separate profile.
+   */
+  ProfilePerWallet = "ProfilePerWallet",
+}
+interface AskarModuleConfigStoreOptions {
+  /**
+   * The id of the store, and also the default profile that will be used for the root agent instance.
+   *
+   * - When SQLite is used that is not in-memory this will influence the path where the SQLite database is stored.
+   * - When Postgres is used, this determines the database.
+   */
+  id: string;
+  /**
+   * The key to open the store
+   */
+  key: string;
+  /**
+   * Key derivation method to use for opening the store.
+   *
+   * - `kdf:argon2i:mod` - most secure
+   * - `kdf:argon2i:int` - faster, less secure
+   * - `raw` - no key derivation. Useful if key is stored in e.g. the keychain on-device backed by biometrics.
+   *
+   * @default 'kdf:argon2i:mod'
+   */
+  keyDerivationMethod?: `${KdfMethod.Argon2IInt}` | `${KdfMethod.Argon2IMod}` | `${KdfMethod.Raw}`;
+  /**
+   * The backend to use with backend specific configuraiton options.
+   *
+   * If not provided SQLite will be used by default
+   */
+  database?: AskarSqliteStorageConfig | AskarPostgresStorageConfig;
+}
+interface AskarModuleConfigOptions {
+  /**
+   * Store configuration used for askar.
+   *
+   * If `multiWalletDatabaseScheme` is set to `AskarMultiWalletDatabaseScheme.DatabasePerWallet` a new store will be created
+   * for each tenant. For performance reasons it is recommended to use `AskarMultiWalletDatabaseScheme.ProfilePerWallet`.
+   */
+  store: AskarModuleConfigStoreOptions;
+  /**
+   *
+   * ## Node.JS
+   *
+   * ```ts
+   * import { askar } from '@openwallet-foundation/askar-nodejs'
+   *
+   * const agent = new Agent({
+   *  config: {},
+   *  dependencies: agentDependencies,
+   *  modules: {
+   *   askar: new AskarModule({
+   *      askar,
+   *   })
+   *  }
+   * })
+   * ```
+   *
+   * ## React Native
+   *
+   * ```ts
+   * import { askar } from '@openwallet-foundation/askar-react-native'
+   *
+   * const agent = new Agent({
+   *  config: {},
+   *  dependencies: agentDependencies,
+   *  modules: {
+   *   askar: new AskarModule({
+   *      askar,
+   *   })
+   *  }
+   * })
+   * ```
+   */
+  askar: Askar;
+  /**
+   * Determine the strategy for storing wallets if multiple wallets are used in a single agent.
+   * This is mostly the case in multi-tenancy, and determines whether each tenant will get a separate
+   * database, or whether all wallets will be stored in a single database, using a different profile
+   * for each wallet.
+   *
+   * @default {@link AskarMultiWalletDatabaseScheme.DatabasePerWallet} (for backwards compatibility)
+   */
+  multiWalletDatabaseScheme?: AskarMultiWalletDatabaseScheme;
+  /**
+   * Whether to enable and register the `AskarKeyManagementService` for key management and cryptographic operations.
+   *
+   * @default true
+   */
+  enableKms?: boolean;
+  /**
+   * Whether to enable and register the `AskarStorageService` for storage
+   *
+   * @default true
+   */
+  enableStorage?: boolean;
+}
+/**
+ * @public
+ */
+declare class AskarModuleConfig {
+  private options;
+  constructor(options: AskarModuleConfigOptions);
+  /** See {@link AskarModuleConfigOptions.askar} */
+  get askar(): Askar;
+  /** See {@link AskarModuleConfigOptions.multiWalletDatabaseScheme} */
+  get multiWalletDatabaseScheme(): AskarMultiWalletDatabaseScheme;
+  get store(): AskarModuleConfigStoreOptions;
+  get enableKms(): boolean;
+  get enableStorage(): boolean;
+}
+//#endregion
+export { AskarModuleConfig, AskarModuleConfigOptions, AskarModuleConfigStoreOptions, AskarMultiWalletDatabaseScheme };
+//# sourceMappingURL=AskarModuleConfig.d.mts.map

package/build/AskarModuleConfig.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AskarModuleConfig.d.mts","names":[],"sources":["../src/AskarModuleConfig.ts"],"sourcesContent":[],"mappings":";;;;aAGY,8BAAA;;AAAZ;AAYA;EAuB2B,iBAAU,GAAA,mBAAA;EAAkB;;;EAOf,gBAAA,GAAA,kBAAA;;AAGvB,UAjCA,6BAAA,CAiCwB;EAOhC;;;;AAkET;;EAQkB,EAAA,EAAA,MAAA;EAKoB;;;;;;;;;;;;;2BAhGX,SAAA,CAAU,kBAAkB,SAAA,CAAU,kBAAkB,SAAA,CAAU;;;;;;aAOhF,2BAA2B;;UAGvB,wBAAA;;;;;;;SAOR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAoCA;;;;;;;;;8BAUqB;;;;;;;;;;;;;;;;;cAoBjB,iBAAA;;uBAGiB;;eAKZ;;mCAKoB;eAIpB"}

package/build/AskarModuleConfig.mjs

@@ -0,0 +1,41 @@
+//#region src/AskarModuleConfig.ts
+let AskarMultiWalletDatabaseScheme = /* @__PURE__ */ function(AskarMultiWalletDatabaseScheme$1) {
+	/**
+	* Each wallet get its own database and uses a separate store.
+	*/
+	AskarMultiWalletDatabaseScheme$1["DatabasePerWallet"] = "DatabasePerWallet";
+	/**
+	* All wallets are stored in a single database, but each wallet uses a separate profile.
+	*/
+	AskarMultiWalletDatabaseScheme$1["ProfilePerWallet"] = "ProfilePerWallet";
+	return AskarMultiWalletDatabaseScheme$1;
+}({});
+/**
+* @public
+*/
+var AskarModuleConfig = class {
+	constructor(options) {
+		this.options = options;
+	}
+	/** See {@link AskarModuleConfigOptions.askar} */
+	get askar() {
+		return this.options.askar;
+	}
+	/** See {@link AskarModuleConfigOptions.multiWalletDatabaseScheme} */
+	get multiWalletDatabaseScheme() {
+		return this.options.multiWalletDatabaseScheme ?? AskarMultiWalletDatabaseScheme.DatabasePerWallet;
+	}
+	get store() {
+		return this.options.store;
+	}
+	get enableKms() {
+		return this.options.enableKms ?? true;
+	}
+	get enableStorage() {
+		return this.options.enableStorage ?? true;
+	}
+};
+
+//#endregion
+export { AskarModuleConfig, AskarMultiWalletDatabaseScheme };
+//# sourceMappingURL=AskarModuleConfig.mjs.map

package/build/AskarModuleConfig.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AskarModuleConfig.mjs","names":[],"sources":["../src/AskarModuleConfig.ts"],"sourcesContent":["import type { Askar, KdfMethod } from '@openwallet-foundation/askar-shared'\nimport type { AskarPostgresStorageConfig, AskarSqliteStorageConfig } from './AskarStorageConfig'\n\nexport enum AskarMultiWalletDatabaseScheme {\n  /**\n   * Each wallet get its own database and uses a separate store.\n   */\n  DatabasePerWallet = 'DatabasePerWallet',\n\n  /**\n   * All wallets are stored in a single database, but each wallet uses a separate profile.\n   */\n  ProfilePerWallet = 'ProfilePerWallet',\n}\n\nexport interface AskarModuleConfigStoreOptions {\n  /**\n   * The id of the store, and also the default profile that will be used for the root agent instance.\n   *\n   * - When SQLite is used that is not in-memory this will influence the path where the SQLite database is stored.\n   * - When Postgres is used, this determines the database.\n   */\n  id: string\n\n  /**\n   * The key to open the store\n   */\n  key: string\n\n  /**\n   * Key derivation method to use for opening the store.\n   *\n   * - `kdf:argon2i:mod` - most secure\n   * - `kdf:argon2i:int` - faster, less secure\n   * - `raw` - no key derivation. Useful if key is stored in e.g. the keychain on-device backed by biometrics.\n   *\n   * @default 'kdf:argon2i:mod'\n   */\n  keyDerivationMethod?: `${KdfMethod.Argon2IInt}` | `${KdfMethod.Argon2IMod}` | `${KdfMethod.Raw}`\n\n  /**\n   * The backend to use with backend specific configuraiton options.\n   *\n   * If not provided SQLite will be used by default\n   */\n  database?: AskarSqliteStorageConfig | AskarPostgresStorageConfig\n}\n\nexport interface AskarModuleConfigOptions {\n  /**\n   * Store configuration used for askar.\n   *\n   * If `multiWalletDatabaseScheme` is set to `AskarMultiWalletDatabaseScheme.DatabasePerWallet` a new store will be created\n   * for each tenant. For performance reasons it is recommended to use `AskarMultiWalletDatabaseScheme.ProfilePerWallet`.\n   */\n  store: AskarModuleConfigStoreOptions\n\n  /**\n   *\n   * ## Node.JS\n   *\n   * ```ts\n   * import { askar } from '@openwallet-foundation/askar-nodejs'\n   *\n   * const agent = new Agent({\n   *  config: {},\n   *  dependencies: agentDependencies,\n   *  modules: {\n   *   askar: new AskarModule({\n   *      askar,\n   *   })\n   *  }\n   * })\n   * ```\n   *\n   * ## React Native\n   *\n   * ```ts\n   * import { askar } from '@openwallet-foundation/askar-react-native'\n   *\n   * const agent = new Agent({\n   *  config: {},\n   *  dependencies: agentDependencies,\n   *  modules: {\n   *   askar: new AskarModule({\n   *      askar,\n   *   })\n   *  }\n   * })\n   * ```\n   */\n  askar: Askar\n\n  /**\n   * Determine the strategy for storing wallets if multiple wallets are used in a single agent.\n   * This is mostly the case in multi-tenancy, and determines whether each tenant will get a separate\n   * database, or whether all wallets will be stored in a single database, using a different profile\n   * for each wallet.\n   *\n   * @default {@link AskarMultiWalletDatabaseScheme.DatabasePerWallet} (for backwards compatibility)\n   */\n  multiWalletDatabaseScheme?: AskarMultiWalletDatabaseScheme\n\n  /**\n   * Whether to enable and register the `AskarKeyManagementService` for key management and cryptographic operations.\n   *\n   * @default true\n   */\n  enableKms?: boolean\n\n  /**\n   * Whether to enable and register the `AskarStorageService` for storage\n   *\n   * @default true\n   */\n  enableStorage?: boolean\n}\n\n/**\n * @public\n */\nexport class AskarModuleConfig {\n  private options: AskarModuleConfigOptions\n\n  public constructor(options: AskarModuleConfigOptions) {\n    this.options = options\n  }\n\n  /** See {@link AskarModuleConfigOptions.askar} */\n  public get askar() {\n    return this.options.askar\n  }\n\n  /** See {@link AskarModuleConfigOptions.multiWalletDatabaseScheme} */\n  public get multiWalletDatabaseScheme() {\n    return this.options.multiWalletDatabaseScheme ?? AskarMultiWalletDatabaseScheme.DatabasePerWallet\n  }\n\n  public get store() {\n    return this.options.store\n  }\n\n  public get enableKms() {\n    return this.options.enableKms ?? true\n  }\n\n  public get enableStorage() {\n    return this.options.enableStorage ?? true\n  }\n}\n"],"mappings":";AAGA,IAAY,4FAAL;;;;AAIL;;;;AAKA;;;;;;AA6GF,IAAa,oBAAb,MAA+B;CAG7B,AAAO,YAAY,SAAmC;AACpD,OAAK,UAAU;;;CAIjB,IAAW,QAAQ;AACjB,SAAO,KAAK,QAAQ;;;CAItB,IAAW,4BAA4B;AACrC,SAAO,KAAK,QAAQ,6BAA6B,+BAA+B;;CAGlF,IAAW,QAAQ;AACjB,SAAO,KAAK,QAAQ;;CAGtB,IAAW,YAAY;AACrB,SAAO,KAAK,QAAQ,aAAa;;CAGnC,IAAW,gBAAgB;AACzB,SAAO,KAAK,QAAQ,iBAAiB"}

package/build/AskarStorageConfig.d.mts

@@ -0,0 +1,32 @@
+//#region src/AskarStorageConfig.d.ts
+interface AskarPostgresConfig {
+  host: string;
+  connectTimeout?: number;
+  idleTimeout?: number;
+  maxConnections?: number;
+  minConnections?: number;
+}
+interface AskarSqliteConfig {
+  maxConnections?: number;
+  minConnections?: number;
+  inMemory?: boolean;
+  path?: string;
+}
+interface AskarPostgresCredentials {
+  account: string;
+  password: string;
+  adminAccount?: string;
+  adminPassword?: string;
+}
+interface AskarPostgresStorageConfig {
+  type: 'postgres';
+  config: AskarPostgresConfig;
+  credentials: AskarPostgresCredentials;
+}
+interface AskarSqliteStorageConfig {
+  type: 'sqlite';
+  config?: AskarSqliteConfig;
+}
+//#endregion
+export { AskarPostgresConfig, AskarPostgresCredentials, AskarPostgresStorageConfig, AskarSqliteConfig, AskarSqliteStorageConfig };
+//# sourceMappingURL=AskarStorageConfig.d.mts.map

package/build/AskarStorageConfig.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AskarStorageConfig.d.mts","names":[],"sources":["../src/AskarStorageConfig.ts"],"sourcesContent":[],"mappings":";UAAiB,mBAAA;EAAA,IAAA,EAAA,MAAA;EAQA,cAAA,CAAA,EAAA,MAAiB;EAUjB,WAAA,CAAA,EAAA,MAAA;EAOA,cAAA,CAAA,EAAA,MAAA;EAMA,cAAA,CAAA,EAAA,MAAA;;UAvBA,iBAAA;;;;;;UAUA,wBAAA;;;;;;UAOA,0BAAA;;UAEP;eACK;;UAGE,wBAAA;;WAEN"}

package/build/AskarStorageConfig.mjs

@@ -0,0 +1,11 @@
+//#region src/AskarStorageConfig.ts
+function isAskarSqliteStorageConfig(config) {
+	return config?.type === "sqlite";
+}
+function isAskarPostgresStorageConfig(config) {
+	return config?.type === "postgres";
+}
+
+//#endregion
+export { isAskarPostgresStorageConfig, isAskarSqliteStorageConfig };
+//# sourceMappingURL=AskarStorageConfig.mjs.map

package/build/AskarStorageConfig.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"AskarStorageConfig.mjs","names":[],"sources":["../src/AskarStorageConfig.ts"],"sourcesContent":["export interface AskarPostgresConfig {\n  host: string\n  connectTimeout?: number\n  idleTimeout?: number\n  maxConnections?: number\n  minConnections?: number\n}\n\nexport interface AskarSqliteConfig {\n  // TODO: add other sqlite config options\n  maxConnections?: number\n  minConnections?: number\n\n  // TODO: split this up into two separate types SqliteInMemory and Sqlite\n  inMemory?: boolean\n  path?: string\n}\n\nexport interface AskarPostgresCredentials {\n  account: string\n  password: string\n  adminAccount?: string\n  adminPassword?: string\n}\n\nexport interface AskarPostgresStorageConfig {\n  type: 'postgres'\n  config: AskarPostgresConfig\n  credentials: AskarPostgresCredentials\n}\n\nexport interface AskarSqliteStorageConfig {\n  type: 'sqlite'\n  config?: AskarSqliteConfig\n}\n\nexport type AskarStorageConfig = AskarPostgresStorageConfig | AskarSqliteStorageConfig\n\nexport function isAskarSqliteStorageConfig(config?: AskarStorageConfig): config is AskarSqliteStorageConfig {\n  return config?.type === 'sqlite'\n}\n\nexport function isAskarPostgresStorageConfig(config?: AskarStorageConfig): config is AskarPostgresStorageConfig {\n  return config?.type === 'postgres'\n}\n"],"mappings":";AAsCA,SAAgB,2BAA2B,QAAiE;AAC1G,QAAO,QAAQ,SAAS;;AAG1B,SAAgB,6BAA6B,QAAmE;AAC9G,QAAO,QAAQ,SAAS"}

package/build/AskarStoreManager.d.mts

@@ -0,0 +1,109 @@
+import { AskarModuleConfig } from "./AskarModuleConfig.mjs";
+import { AskarStoreExportOptions, AskarStoreImportOptions, AskarStoreRotateKeyOptions } from "./AskarApiOptions.mjs";
+import { AgentContext, FileSystem } from "@credo-ts/core";
+import { Session, Store } from "@openwallet-foundation/askar-shared";
+
+//#region src/AskarStoreManager.d.ts
+declare class AskarStoreManager {
+  private fileSystem;
+  private config;
+  constructor(fileSystem: FileSystem, config: AskarModuleConfig);
+  isStoreOpen(agentContext: AgentContext): boolean;
+  private getStoreConfig;
+  /**
+   * When we create storage for a context we need to store the version record
+   */
+  private setCurrentFrameworkStorageVersionOnSession;
+  /**
+   * Deletes all storage related to a context. If on store level, meaning root agent
+   * or when using database per wallet storage, the whole store will be deleted.
+   * Otherwise only a profile within the store will be removed.
+   */
+  deleteContext(agentContext: AgentContext): Promise<void>;
+  /**
+   * Closes an active context. If on store level, meaning root agent
+   * or when using database per wallet storage, the whole store will be closed.
+   * Otherwise nothing will be done as profiles are opened on a store from higher level.
+   */
+  closeContext(agentContext: AgentContext): Promise<void>;
+  /**
+   * @throws {AskarStoreDuplicateError} if the wallet already exists
+   * @throws {AskarStoreError} if another error occurs
+   */
+  provisionStore(agentContext: AgentContext): Promise<Store>;
+  /**
+   * @throws {AskarStoreNotFoundError} if the wallet does not exist
+   * @throws {AskarStoreError} if another error occurs
+   */
+  openStore(agentContext: AgentContext): Promise<Store>;
+  /**
+   * Rotate the key of the current askar store.
+   *
+   * NOTE: multiple agent contexts (tenants) can use the same store. This method rotates the key for the whole store,
+   * it is advised to only run this method on the root tenant agent when using profile per wallet database strategy.
+   * After running this method you should change the store configuration in the Askar module.
+   *
+   * @throws {AskarStoreNotFoundError} if the wallet does not exist
+   * @throws {AskarStoreError} if another error occurs
+   */
+  rotateStoreKey(agentContext: AgentContext, options: AskarStoreRotateKeyOptions): Promise<void>;
+  /**
+   * Exports the current askar store.
+   *
+   * NOTE: a store can contain profiles for multiple tenants. When you export a store
+   * all profiles will be exported with it.
+   */
+  exportStore(agentContext: AgentContext, options: AskarStoreExportOptions): Promise<void>;
+  /**
+   * Imports from an external store config into the current askar store config.
+   */
+  importStore(agentContext: AgentContext, options: AskarStoreImportOptions): Promise<void>;
+  /**
+   * Delete the current askar store.
+   *
+   * NOTE: multiple agent contexts (tenants) can use the same store. This method deletes the whole store,
+   * and if you're using multi-tenancy with profile per wallet it is advised to only run this method on the root tenant agent.
+   *
+   * @throws {AskarStoreNotFoundError} if the wallet does not exist
+   * @throws {AskarStoreError} if another error occurs
+   */
+  deleteStore(agentContext: AgentContext): Promise<void>;
+  /**
+   * Close the current askar store
+   */
+  closeStore(agentContext: AgentContext): Promise<void>;
+  private getAskarStoreConfig;
+  /**
+   * Run callback with a transaction. If the callback resolves the transaction
+   * will be committed if the transaction is not closed yet. If the callback rejects
+   * the transaction will be rolled back if the transaction is not closed yet.
+   *
+   * TODO: update to new `using` syntax so we don't have to use a callback
+   */
+  withTransaction<Return>(agentContext: AgentContext, callback: (session: Session) => Return): Promise<Awaited<Return>>;
+  /**
+   * Run callback with the session provided, the session will
+   * be closed once the callback resolves or rejects if it is not closed yet.
+   *
+   * TODO: update to new `using` syntax so we don't have to use a callback
+   */
+  withSession<Return>(agentContext: AgentContext, callback: (session: Session) => Return): Promise<Awaited<Return>>;
+  private getStore;
+  private _withSession;
+  getInitializedStoreWithProfile(agentContext: AgentContext): Promise<{
+    profile: string | undefined;
+    store: Store;
+  }>;
+  /**
+   * Ensures a command is ran on a store level, preventing a tenant instance from
+   * removing a whole store (and potentially other tennats).
+   */
+  private ensureStoreLevel;
+  /**
+   * Checks whether the current agent context is on store level
+   */
+  private isStoreLevel;
+}
+//#endregion
+export { AskarStoreManager };
+//# sourceMappingURL=AskarStoreManager.d.mts.map