@sphereon/ssi-sdk.presentation-exchange 0.11.1-next.65

package/.yalc/@veramo/kv-store/src/key-value-types.ts

@@ -0,0 +1,97 @@
+/**
+ * This is how the store will actually store the value.
+ * It contains an optional `expires` property, which indicates when the value would expire
+ */
+export interface IValueData<ValueType> {
+  value: ValueType | undefined
+  expires: number | undefined
+}
+
+export interface IKeyValueStoreOnArgs {
+  eventName: string | symbol
+  listener: (...args: any[]) => void
+}
+
+/*export interface IKeyValueStoreGetArgs {
+  key: string
+}
+
+export interface IKeyValueStoreGetManyArgs {
+  keys: string[]
+}
+
+export interface IKeyValueStoreHasArgs {
+  key: string
+}
+
+export interface IKeyValueStoreDeleteArgs {
+  key: string
+}
+
+export interface IKeyValueStoreDeleteManyArgs {
+  keys: string[]
+}
+
+export interface IKeyValueStoreSetArgs<ValueType> {
+  key: string
+  value: ValueType
+  ttl?: number
+}*/
+
+export interface IKeyValueStoreOptions<ValueType> {
+  [key: string]: any
+
+  /** Namespace for the current instance. */
+  namespace?: string | undefined
+
+  /** A custom serialization function. */
+  /*serialize?: ((data: KeyvDeserializedData<ValueType>) => OrPromise<string | undefined>)
+  /!** A custom deserialization function. *!/
+  deserialize?: ((data: any) => OrPromise<KeyvDeserializedData<ValueType> | undefined>);*/
+  /** The connection string URI. */
+  uri?: string | undefined
+  /** The storage adapter instance to be used by Keyv. or any other implementation */
+  store: IKeyValueStoreAdapter<ValueType> | Map<string, ValueType>
+  /** Default TTL. Can be overridden by specifying a TTL on `.set()`. */
+  ttl?: number | undefined
+
+  /** Enable compression option **/
+  /*compression?: KeyvCompressionAdapter | undefined;*/
+
+  emitErrors?: boolean
+}
+
+export interface IKeyValueStoreAdapter<ValueType> {
+  namespace?: string | undefined
+}
+
+export interface IKeyValueStore<ValueType> {
+  /**
+   * Get a single value by key. Can be undefined as the underlying store typically will not throw an error for a non existing key
+   *
+   * @param key Contains the key to search for
+   */
+  get(key: string): Promise<ValueType | undefined>
+
+  /**
+   * Get a single item as Value Data from the store. Will always return a Value Data Object, but the value in it can be undefined in case the actual store does not contain the value
+   * @param key Contains the key to search for
+   */
+  getAsValueData(key: string): Promise<IValueData<ValueType>>
+
+  getMany(keys: string[]): Promise<Array<ValueType | undefined>>
+
+  getManyAsValueData(keys: string[]): Promise<Array<IValueData<ValueType>>>
+
+  set(key: string, value: ValueType, ttl?: number): Promise<IValueData<ValueType>>
+
+  delete(key: string): Promise<boolean>
+
+  deleteMany(keys: string[]): Promise<boolean[]>
+
+  clear(): Promise<IKeyValueStore<ValueType>>
+
+  has(key: string): Promise<boolean>
+
+  disconnect(): Promise<void>
+}

package/.yalc/@veramo/kv-store/src/keyv/keyv-types.ts

@@ -0,0 +1,71 @@
+/**
+ * Please be aware these types are compatible with the keyv package, to ensure we can use its store-adapters for free.
+ *
+ * Be very careful when extending/changing!. Normally you will want to create an adapter or decorator for your additional behaviour or requirements
+ */
+import { OrPromise } from '@veramo/utils'
+
+export interface KeyvOptions<Value> {
+  [key: string]: any
+
+  /** Namespace for the current instance. */
+  namespace?: string | undefined
+  /** A custom serialization function. */
+  serialize?: (data: KeyvDeserializedData<Value>) => OrPromise<string | undefined>
+  /** A custom deserialization function. */
+  deserialize?: (data: any) => OrPromise<KeyvDeserializedData<Value> | undefined>
+  /** The connection string URI. */
+  uri?: string | undefined
+  /** The storage adapter instance to be used by Keyv. */
+  store?: KeyvStore<Value | undefined> | undefined
+  /** Default TTL. Can be overridden by specififying a TTL on `.set()`. */
+  ttl?: number | undefined
+  /** Specify an adapter to use. e.g `'redis'` or `'mongodb'`. */
+  adapter?: 'redis' | 'mongodb' | 'mongo' | 'sqlite' | 'postgresql' | 'postgres' | 'mysql' | object | string | undefined
+  /** Enable compression option **/
+  compression?: KeyvCompressionAdapter | undefined
+
+  emitErrors?: boolean
+}
+
+export interface KeyvCompressionAdapter {
+  compress(value: any, options?: any): OrPromise<any>
+
+  decompress(value: any, options?: any): OrPromise<any>
+
+  serialize(value: any): OrPromise<string>
+
+  deserialize(value: any): OrPromise<any>
+}
+
+export interface KeyvDeserializedData<Value> {
+  value: Value
+  expires: number | undefined
+}
+
+export type KeyvStoredData<Value> = KeyvDeserializedData<Value> | string | Value | undefined
+
+export interface KeyvStore<Value> {
+  namespace?: string | undefined
+
+  opts: KeyvOptions<Value>
+
+  on?(eventName: string | symbol, listener: (...args: any[]) => void): void
+  get(key: string | string[], options?: { raw?: boolean }): OrPromise<KeyvStoredData<Value> | Array<KeyvStoredData<Value>>>
+
+  getMany?(keys: string[], options?: { raw?: boolean }): OrPromise<Array<KeyvStoredData<Value>>> | undefined
+
+  iterator?(namespace?: string | undefined): AsyncGenerator<any, void, any>
+
+  set(key: string, value: Value, ttl?: number): any
+
+  delete(key: string | string[]): OrPromise<boolean>
+
+  deleteMany?(keys: string[]): OrPromise<boolean>
+
+  clear(): OrPromise<void>
+
+  has?(key: string): OrPromise<boolean>
+
+  disconnect?(): void
+}

package/.yalc/@veramo/kv-store/src/keyv/keyv.ts

@@ -0,0 +1,282 @@
+import { EventEmitter } from 'events'
+import JSONB from 'json-buffer'
+import { KeyvDeserializedData, KeyvOptions, KeyvStore, KeyvStoredData } from './keyv-types'
+
+/**
+ * Please note that this is code adapted from @link https://github.com/jaredwray/keyv to support Typescript and ESM in Veramo
+ *
+ * The code should support the storage plugins available for the keyv project.
+ * Veramo itself supports NodeJS, Browser and React-Native environment.
+ * Please be aware that these requirements probably aren't true for any keyv storage plugins.
+ *
+ * One of the big changes compared to the upstream project is that this port does not have dynamic loading of store-adapters based on URIs.
+ * We believe that any Veramo Key Value store should use explicitly defined store-adapters.
+ *
+ * The port is part of the Veramo Key Value Store module, as we do not want to make an official maintained port out of it.
+ * Veramo exposes its own API/interfaces for the Key Value store, meaning we could also support any other implementation in the future
+ *
+ * The Veramo kv-store module provides out of the box support for in memory/maps, sqlite and typeorm implementations,
+ * including a tiered local/remote implementation that support all environments.
+ *
+ * We welcome any new storage modules
+ */
+export class Keyv<Value = any> extends EventEmitter implements KeyvStore<Value> {
+  readonly opts: KeyvOptions<Value>
+  readonly namespace: string
+  iterator?: (namespace?: string) => AsyncGenerator<any, void>
+
+  constructor(uri?: string | Map<string, Value | undefined> | KeyvStore<Value> | undefined, options?: KeyvOptions<Value>) {
+    super()
+    const emitErrors = options?.emitErrors === undefined ? true : options.emitErrors
+    uri = uri ?? options?.uri
+    /*if (!uri) {
+      throw Error('No URI provided')
+    }*/
+    this.opts = {
+      namespace: 'keyv',
+      serialize: JSONB.stringify,
+      deserialize: JSONB.parse,
+      ...(typeof uri === 'string' ? { uri } : uri),
+      ...options,
+    }
+
+    if (!this.opts.store) {
+      if (typeof uri !== 'string') {
+        this.opts.store = uri as KeyvStore<Value | undefined>
+      } /* else {
+        const adapterOptions = { ...this.opts }
+        this.opts.store = loadStore(adapterOptions)
+      }*/
+    }
+    if (!this.opts.store) {
+      throw Error('No store')
+    }
+
+    if (this.opts.compression) {
+      const compression = this.opts.compression
+      this.opts.serialize = compression.serialize.bind(compression)
+      this.opts.deserialize = compression.deserialize.bind(compression)
+    }
+
+    if (typeof this.opts.store.on === 'function' && emitErrors) {
+      this.opts.store.on('error', (error) => this.emit('error', error))
+    }
+
+    this.opts.store.namespace = this.opts.namespace || 'keyv'
+    this.namespace = this.opts.store.namespace
+
+    const generateIterator = (iterator: any, keyv: Keyv<any>) =>
+      async function* () {
+        for await (const [key, raw] of typeof iterator === 'function' ? iterator(keyv.store.namespace) : iterator) {
+          const data = await keyv.deserialize(raw)
+          if (keyv.store.namespace && !key.includes(keyv.store.namespace)) {
+            continue
+          }
+
+          if (data && typeof data.expires === 'number' && Date.now() > data.expires) {
+            keyv.delete(key)
+            continue
+          }
+
+          yield [keyv._getKeyUnprefix(key), data?.value]
+        }
+      }
+
+    // Attach iterators
+    // @ts-ignore
+    if (typeof this.store[Symbol.iterator] === 'function' && this.store instanceof Map) {
+      this.iterator = generateIterator(this.store, this)
+    } else if (typeof this.store.iterator === 'function' && this.store.opts && this._checkIterableAdapter()) {
+      this.iterator = generateIterator(this.store.iterator.bind(this.store), this)
+    }
+  }
+
+  get store(): Required<KeyvStore<Value>> {
+    return this.opts.store as Required<KeyvStore<Value>>
+  }
+
+  get deserialize() {
+    return this.opts.deserialize!
+  }
+
+  get serialize() {
+    return this.opts.serialize!
+  }
+
+  _checkIterableAdapter() {
+    return (
+      (this.store.opts.dialect && iterableAdapters.includes(this.store.opts.dialect)) ||
+      (this.store.opts.url && iterableAdapters.findIndex((element) => this.store.opts.url.includes(element)) >= 0)
+    )
+  }
+
+  _getKeyPrefix(key: string): string {
+    return `${this.opts.namespace}:${key}`
+  }
+
+  _getKeyPrefixArray(keys: string[]): string[] {
+    return keys.map((key) => this._getKeyPrefix(key))
+  }
+
+  _getKeyUnprefix(key: string): string {
+    return key.split(':').splice(1).join(':')
+  }
+
+  async getMany(keys: string[], options?: { raw?: boolean }): Promise<Array<KeyvStoredData<Value>>> {
+    const keyPrefixed = this._getKeyPrefixArray(keys)
+    let promise: Promise<Array<KeyvStoredData<Value>>>
+    if (this.store.getMany !== undefined) {
+      promise = this.store.getMany(keyPrefixed, options) as Promise<KeyvStoredData<Value>[]> //.then(value => !!value ? value.values() : undefined)
+      // todo: Probably wise to check expired ValueData here, if the getMany does not implement this feature itself!
+    } else {
+      promise = Promise.all(keyPrefixed.map((k) => this.store.get(k, options) as Promise<KeyvStoredData<Value>>))
+    }
+    const allValues = Promise.resolve(promise)
+    const results: Promise<KeyvStoredData<Value>>[] = []
+
+    return Promise.resolve(allValues)
+      .then((all) => {
+        keys.forEach((key, index) => {
+          const data = all[index]
+
+          let result = typeof data === 'string' ? this.deserialize(data) : !!data && this.opts.compression ? this.deserialize(data) : data
+
+          if (result && typeof result === 'object' && 'expires' in result && typeof result.expires === 'number' && Date.now() > result.expires) {
+            this.delete(key)
+            result = undefined
+          }
+
+          const final = (
+            options && options.raw ? result : result && typeof result === 'object' && 'value' in result ? result.value : result
+          ) as Promise<KeyvStoredData<Value>>
+
+          results.push(final)
+        })
+      })
+      .then(() => Promise.all(results))
+  }
+
+  async get(
+    key: string | string[],
+    options?: { raw?: boolean }
+  ): Promise<Value | string | KeyvDeserializedData<Value> | KeyvStoredData<Value>[] | undefined> {
+    const isArray = Array.isArray(key)
+    return Promise.resolve()
+      .then(() => (isArray ? this.getMany(this._getKeyPrefixArray(key), options) : this.store.get(this._getKeyPrefix(key))))
+      .then((data) => (typeof data === 'string' ? this.deserialize(data) : this.opts.compression ? this.deserialize(data) : data))
+      .then((data) => {
+        if (data === undefined || data === null) {
+          return undefined
+        }
+        const rows = Array.isArray(data) ? data : [data]
+
+        if (isArray) {
+          const result = []
+
+          for (let row of rows) {
+            if (row === undefined || row === null) {
+              result.push(undefined)
+              continue
+            }
+
+            if (this.isExpired(row)) {
+              this.delete(key).then(() => undefined)
+              result.push(undefined)
+            } else {
+              result.push(options && options.raw ? row : toValue(row))
+            }
+          }
+
+          return result
+        } else if (!Array.isArray(data)) {
+          if (this.isExpired(data)) {
+            return this.delete(key).then(() => undefined)
+          }
+        }
+
+        return options && options.raw ? data : Array.isArray(data) ? data.map((d) => toValue(d)) : toValue(data)
+      })
+  }
+
+  private isExpired(data: KeyvDeserializedData<any> | string | Value): boolean {
+    return (
+      typeof data !== 'string' &&
+      data &&
+      typeof data === 'object' &&
+      'expires' in data &&
+      typeof data.expires === 'number' &&
+      Date.now() > data.expires
+    )
+  }
+
+  set(key: string, value: Value, ttl?: number) {
+    const keyPrefixed = this._getKeyPrefix(key)
+    if (typeof ttl === 'undefined') {
+      ttl = this.opts.ttl
+    }
+    if (ttl === 0) {
+      ttl = undefined
+    }
+
+    // @ts-ignore
+    return Promise.resolve()
+      .then(() => {
+        const expires = typeof ttl === 'number' ? Date.now() + ttl : undefined
+        if (typeof value === 'symbol') {
+          this.emit('error', 'symbol cannot be serialized')
+        }
+
+        const input = { value, expires }
+        return this.serialize(input)
+      })
+      .then((value) => this.store.set(keyPrefixed, value as Value, ttl))
+      .then(() => true)
+  }
+
+  delete(key: string | string[]) {
+    if (!Array.isArray(key)) {
+      const keyPrefixed = this._getKeyPrefix(key)
+      return Promise.resolve().then(() => this.store.delete(keyPrefixed))
+    }
+
+    const keyPrefixed = this._getKeyPrefixArray(key)
+    if (this.store.deleteMany !== undefined) {
+      return Promise.resolve().then(() => this.store.deleteMany!(keyPrefixed))
+    }
+
+    const promises = []
+    for (const key of keyPrefixed) {
+      promises.push(this.store.delete(key))
+    }
+
+    return Promise.allSettled(promises).then((values) => values.every((x) => x.valueOf() === true))
+  }
+
+  async clear(): Promise<void> {
+    return Promise.resolve().then(() => this.store.clear())
+  }
+
+  has(key: string) {
+    const keyPrefixed = this._getKeyPrefix(key)
+    return Promise.resolve().then(async () => {
+      if (typeof this.store.has === 'function') {
+        return this.store.has(keyPrefixed)
+      }
+
+      const value = await this.store.get(keyPrefixed)
+      return value !== undefined
+    })
+  }
+
+  disconnect() {
+    if (typeof this.store.disconnect === 'function') {
+      return this.store.disconnect()
+    }
+  }
+}
+
+const iterableAdapters = ['sqlite', 'postgres', 'mysql', 'mongo', 'redis', 'tiered']
+
+function toValue<Value>(input: KeyvDeserializedData<Value> | string | Value) {
+  return input !== null && typeof input === 'object' && 'value' in input ? input.value : input
+}

package/.yalc/@veramo/kv-store/src/store-adapters/index.ts

@@ -0,0 +1,2 @@
+export * from './tiered/index'
+export * from './typeorm/index'

package/.yalc/@veramo/kv-store/src/store-adapters/tiered/index.ts

@@ -0,0 +1,158 @@
+import { EventEmitter } from 'events'
+import type { Options, Options_ } from './types'
+import { KeyvStore, KeyvStoredData } from '../../keyv/keyv-types'
+import { Keyv } from '../../keyv/keyv'
+import { IKeyValueStoreAdapter } from '../../key-value-types'
+
+type KeyvTieredIndex = 'local' | 'remote'
+
+export class KeyValueTieredStoreAdapter<Value> extends EventEmitter implements KeyvStore<Value>, IKeyValueStoreAdapter<Value> {
+  opts: Options_
+  remote: KeyvStore<Value>
+  local: KeyvStore<Value>
+  iterationLimit?: string | number
+
+  namespace?: string | undefined
+
+  constructor({ remote, local, ...options }: Options<Value>) {
+    super()
+    this.opts = {
+      validator: () => true,
+      dialect: 'tiered',
+      ...options,
+    }
+
+    // todo: since we are instantiating a new Keyv object in case we encounter a map, the key prefix applied twice, given it will be part of a an outer keyv object as well.
+    // Probably wise to simply create a Map Store class. As it is an in memory construct, and will work in terms of resolution it does not have highest priority
+    this.local = (isMap(local) ? new Keyv<Value>(local as Map<string, Value>) : local) as KeyvStore<Value>
+    this.remote = (isMap(remote) ? new Keyv<Value>(remote as Map<string, Value>) : remote) as KeyvStore<Value>
+    this.namespace = this.local.namespace
+  }
+
+  async get(key: string | string[], options?: { raw?: boolean }): Promise<KeyvStoredData<Value> | Array<KeyvStoredData<Value>>> {
+    if (Array.isArray(key)) {
+      return await this.getMany(key, options)
+    }
+    const localResult = (await this.local.get(key, options)) as KeyvStoredData<Value>
+
+    if (localResult === undefined || !this.opts.validator(localResult, key)) {
+      const remoteResult = await this.remote.get(key, options)
+
+      if (remoteResult !== localResult) {
+        const value = (
+          !!remoteResult ? (typeof remoteResult === 'object' && 'value' in remoteResult ? remoteResult.value : remoteResult) : undefined
+        ) as Value
+        const ttl =
+          !!remoteResult && typeof remoteResult === 'object' && 'expires' in remoteResult && remoteResult.expires
+            ? remoteResult.expires - Date.now()
+            : undefined
+        if (!ttl || ttl > 0) {
+          await this.local.set(key, value, ttl)
+        } else {
+          this.local.delete(key)
+        }
+      }
+      return remoteResult
+    }
+
+    return localResult
+  }
+
+  async getMany(keys: string[], options?: { raw?: boolean }): Promise<Array<KeyvStoredData<Value>>> {
+    const promises: Array<Promise<KeyvStoredData<Value>>> = []
+    for (const key of keys) {
+      promises.push(this.get(key, options) as Promise<KeyvStoredData<Value>>)
+    }
+
+    const values = await Promise.all(promises)
+    const data: Array<KeyvStoredData<Value>> | undefined = []
+    for (const value of values) {
+      data.push(value as KeyvStoredData<Value>)
+    }
+    return data
+  }
+
+  async set(key: string, value: any, ttl?: number) {
+    const toSet: KeyvTieredIndex[] = ['local', 'remote']
+    return Promise.all(toSet.map(async (store) => this[store].set(key, value, ttl)))
+  }
+
+  async clear(): Promise<undefined> {
+    const toClear: KeyvTieredIndex[] = ['local']
+    if (!this.opts.localOnly) {
+      toClear.push('remote')
+    }
+
+    await Promise.all(toClear.map(async (store) => this[store].clear()))
+
+    return undefined
+  }
+
+  async delete(key: string): Promise<boolean> {
+    const toDelete: KeyvTieredIndex[] = ['local']
+    if (!this.opts.localOnly) {
+      toDelete.push('remote')
+    }
+
+    const deleted = await Promise.all(toDelete.map(async (store) => this[store].delete(key)))
+
+    return deleted.every(Boolean)
+  }
+
+  async deleteMany(keys: string[]): Promise<boolean> {
+    const promises = []
+    for (const key of keys) {
+      promises.push(this.delete(key))
+    }
+
+    const values = await Promise.all(promises)
+
+    return values.every(Boolean)
+  }
+
+  async has(key: string): Promise<boolean> {
+    let response
+    if (typeof this.local.has === 'function') {
+      response = this.local.has(key)
+    } else {
+      const value = await this.local.get(key)
+      response = value !== undefined
+    }
+    if (!response || !this.opts.validator(response, key)) {
+      if (typeof this.remote.has === 'function') {
+        response = this.remote.has(key)
+      } else {
+        const value = await this.remote.get(key)
+        response = value !== undefined
+      }
+    }
+    return response
+  }
+
+  async *iterator(namespace?: string): AsyncGenerator<any, void, any> {
+    const limit = Number.parseInt(this.iterationLimit as string, 10) || 10
+    this.remote.opts.iterationLimit = limit
+    if (this.remote && typeof this.remote.iterator === 'function') {
+      for await (const entries of this.remote.iterator(namespace)) {
+        yield entries
+      }
+    }
+  }
+}
+
+function isMap(map: any) {
+  if (map instanceof Map) {
+    return true
+  } else if (
+    map &&
+    typeof map.clear === 'function' &&
+    typeof map.delete === 'function' &&
+    typeof map.get === 'function' &&
+    typeof map.has === 'function' &&
+    typeof map.set === 'function'
+  ) {
+    return true
+  }
+
+  return false
+}

package/.yalc/@veramo/kv-store/src/store-adapters/tiered/types.ts

@@ -0,0 +1,16 @@
+import { IKeyValueStoreAdapter } from '../../key-value-types'
+
+export type Options<ValueType> = {
+  local: IKeyValueStoreAdapter<ValueType> | Map<string, ValueType>
+  remote: IKeyValueStoreAdapter<ValueType> | Map<string, ValueType>
+  localOnly?: boolean
+  iterationLimit?: number | string
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export type Options_ = {
+  validator: (value: any, key: string) => boolean
+  dialect: string
+  iterationLimit?: number | string
+  localOnly?: boolean
+}

package/.yalc/@veramo/kv-store/src/store-adapters/typeorm/entities/keyValueStoreEntity.ts

@@ -0,0 +1,20 @@
+import { BaseEntity, Column, Entity, PrimaryColumn } from 'typeorm'
+
+/**
+ *
+ * @beta This API may change without a BREAKING CHANGE notice.
+ */
+@Entity('keyvaluestore')
+export class KeyValueStoreEntity extends BaseEntity {
+  @PrimaryColumn()
+  // @ts-ignore
+  key: string
+
+  @Column({
+    type: 'text',
+  })
+  // @ts-ignore
+  data: string
+
+  expires?: number
+}