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

package/.yalc/@veramo/kv-store/build/store-adapters/typeorm/migrations/1.createKVDatabase.js

@@ -0,0 +1,90 @@
+'use strict'
+var __awaiter =
+  (this && this.__awaiter) ||
+  function (thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P
+        ? value
+        : new P(function (resolve) {
+            resolve(value)
+          })
+    }
+    return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value))
+        } catch (e) {
+          reject(e)
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator['throw'](value))
+        } catch (e) {
+          reject(e)
+        }
+      }
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected)
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next())
+    })
+  }
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod }
+  }
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.CreateKVDatabaseMigration = void 0
+const typeorm_1 = require('typeorm')
+const debug_1 = __importDefault(require('debug'))
+const debug = (0, debug_1.default)('veramo:kv-store:initial-migration')
+/**
+ * Create the database layout for Veramo 3.0
+ *
+ * @public
+ */
+class CreateKVDatabaseMigration {
+  constructor(tableName) {
+    this._tableName = tableName || 'keyvaluestore'
+    this.name = `CreateKVDatabase${tableName}1680297189001`
+  }
+  up(queryRunner) {
+    return __awaiter(this, void 0, void 0, function* () {
+      function getTableName(givenName) {
+        var _a
+        return (
+          ((_a = queryRunner.connection.entityMetadatas.find((meta) => meta.givenTableName === givenName)) === null || _a === void 0
+            ? void 0
+            : _a.tableName) || givenName
+        )
+      }
+      debug(`creating ${this._tableName} table`)
+      // CREATE TABLE "keyvaluestore" ("key" varchar PRIMARY KEY NOT NULL, "data" text NOT NULL)
+      yield queryRunner.createTable(
+        new typeorm_1.Table({
+          name: getTableName(this._tableName),
+          columns: [
+            { name: 'key', type: 'varchar', isPrimary: true },
+            { name: 'data', type: 'text', isNullable: false },
+          ],
+          indices: [
+            {
+              columnNames: ['key'],
+              isUnique: true,
+            },
+          ],
+        }),
+        true
+      )
+    })
+  }
+  down(queryRunner) {
+    return __awaiter(this, void 0, void 0, function* () {
+      throw new Error('illegal_operation: cannot roll back initial migration')
+    })
+  }
+}
+exports.CreateKVDatabaseMigration = CreateKVDatabaseMigration
+//# sourceMappingURL=1.createKVDatabase.js.map

package/.yalc/@veramo/kv-store/build/store-adapters/typeorm/migrations/index.d.ts

@@ -0,0 +1,10 @@
+import { CreateKVDatabaseMigration } from './1.createKVDatabase'
+/**
+ * The migrations array that SHOULD be used when initializing a TypeORM database connection.
+ *
+ * These ensure the correct creation of tables and the proper migrations of data when tables change between versions.
+ *
+ * @public
+ */
+export declare const kvStoreMigrations: (typeof CreateKVDatabaseMigration)[]
+//# sourceMappingURL=index.d.ts.map

package/.yalc/@veramo/kv-store/build/store-adapters/typeorm/migrations/index.js

@@ -0,0 +1,13 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.kvStoreMigrations = void 0
+const _1_createKVDatabase_1 = require('./1.createKVDatabase')
+/**
+ * The migrations array that SHOULD be used when initializing a TypeORM database connection.
+ *
+ * These ensure the correct creation of tables and the proper migrations of data when tables change between versions.
+ *
+ * @public
+ */
+exports.kvStoreMigrations = [_1_createKVDatabase_1.CreateKVDatabaseMigration]
+//# sourceMappingURL=index.js.map

package/.yalc/@veramo/kv-store/build/store-adapters/typeorm/types.d.ts

@@ -0,0 +1,15 @@
+import { OrPromise } from '@veramo/utils'
+import { DataSource } from 'typeorm'
+import { KeyvDeserializedData } from '../../keyv/keyv-types'
+export type KeyValueTypeORMOptions = {
+  dbConnection: OrPromise<DataSource>
+  namespace?: string
+}
+export type Options_<Value> = {
+  validator: (value: any, key: string) => boolean
+  dialect: string
+  serialize: (data: KeyvDeserializedData<Value>) => OrPromise<string | undefined>
+  /** A custom deserialization function. */
+  deserialize: (data: any) => OrPromise<KeyvDeserializedData<Value> | undefined>
+}
+//# sourceMappingURL=types.d.ts.map

package/.yalc/@veramo/kv-store/build/store-adapters/typeorm/types.js

@@ -0,0 +1,3 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+//# sourceMappingURL=types.js.map

package/.yalc/@veramo/kv-store/build/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.33.7"
+    }
+  ]
+}

package/.yalc/@veramo/kv-store/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@veramo/kv-store",
+  "description": "Veramo Key Value Store plugin",
+  "version": "4.3.0",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --config=../../jest.config.mjs",
+    "test:ci": "jest --config=../../jest.config.mjs",
+    "extract-api": "node ../cli/bin/veramo.js dev extract-api"
+  },
+  "dependencies": {
+    "@veramo/utils": "4.3.0",
+    "debug": "^4.3.4",
+    "events": "^3.3.0",
+    "json-buffer": "^3.0.1",
+    "typeorm": "^0.3.10",
+    "uint8arrays": "^3.1.1"
+  },
+  "files": [
+    "build/**/*",
+    "src/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": "git@github.com:uport-project/veramo.git",
+  "author": "Niels Klomp <nklomp@sphereon.com>",
+  "license": "Apache-2.0",
+  "keywords": [
+    "Veramo",
+    "Key Value Store",
+    "keyv"
+  ],
+  "yalcSig": "bfd8bfc89f0050ba31664b2d7c3efc7a"
+}

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

@@ -0,0 +1,204 @@
+import KeyvSqlite from '@keyv/sqlite'
+
+import timekeeper from 'timekeeper'
+import { Keyv } from '../keyv/keyv'
+import { DataSource } from 'typeorm'
+import { KeyValueStoreEntity } from '../store-adapters/typeorm/entities/keyValueStoreEntity'
+import { KeyValueTieredStoreAdapter, KeyValueTypeORMStoreAdapter } from '../store-adapters'
+import { KeyvOptions } from '../keyv/keyv-types'
+import { kvStoreMigrations } from '../store-adapters/typeorm/migrations'
+
+let dbConnection: DataSource
+beforeEach(async () => {
+  dbConnection = await new DataSource({
+    type: 'sqlite',
+    database: ':memory:',
+    logging: ['error'],
+    migrationsRun: true,
+    synchronize: false,
+    migrations: [...kvStoreMigrations],
+    entities: [KeyValueStoreEntity],
+  }).initialize()
+})
+afterEach(async () => {
+  try {
+    if (dbConnection?.isInitialized) {
+      await (await dbConnection).destroy()
+    }
+  } catch (error) {
+    // the disconnect test will close the DB anyway
+  }
+})
+describe('keyv MAP store', () => {
+  it('should respect ttl', async () => {
+    const store = new Map<string, string>()
+    const keyv = new Keyv<string>(store)
+    await keyv.set('key', 'value', 100)
+
+    expect(await keyv.get('key')).toEqual('value')
+    timekeeper.freeze(Date.now() + 150)
+    expect(await keyv.get('key')).toBeUndefined()
+  })
+  it('should work for all methods', async () => {
+    const store = new Map<string, string>()
+    await testAllKeyvMethods(store)
+  })
+})
+
+describe('keyv sqlite store', () => {
+  it('should respect ttl', async () => {
+    const keyv = new Keyv<string>(new KeyvSqlite<string>())
+    await keyv.set('key', 'value', 100)
+
+    expect(await keyv.get('key')).toEqual('value')
+    timekeeper.freeze(Date.now() + 150)
+    expect(await keyv.get('key')).toBeUndefined()
+  })
+  it('should work for all methods', async () => {
+    const store = new KeyvSqlite<string>()
+    await testAllKeyvMethods(store)
+  })
+})
+
+describe('keyv TypeORM store', () => {
+  /*let dbConnection: DataSource
+
+  beforeEach(async () => {
+    dbConnection = await new DataSource({
+      type: 'sqlite',
+      database: ':memory:',
+      logging: 'all',
+      migrationsRun: true,
+      synchronize: false,
+      migrations: [...kvStoreMigrations],
+      entities: [KeyValueStoreEntity],
+    }).initialize()
+  })
+
+  afterEach(async () => {
+    try {
+      (await dbConnection).destroy()
+    } catch (error) {
+      // the disconnect test will close the DB anyway
+    }
+
+  })
+*/
+  it('should respect ttl', async () => {
+    const store = new KeyValueTypeORMStoreAdapter({ dbConnection, namespace: 'test' })
+    const keyv = new Keyv<string>(store)
+    await keyv.set('key', 'value', 100)
+
+    expect(await keyv.get('key')).toEqual('value')
+    timekeeper.freeze(Date.now() + 150)
+    expect(await keyv.get('key')).toBeUndefined()
+  })
+
+  it('should set a value that can be retrieved from the proper namespace', async () => {
+    const store = new KeyValueTypeORMStoreAdapter({ dbConnection, namespace: 'test' })
+    const keyv = new Keyv<string>(store)
+    await keyv.set('key', 'value')
+    expect(await keyv.get('key')).toEqual('value')
+
+    const alternateStore = new KeyValueTypeORMStoreAdapter({ dbConnection, namespace: 'another' })
+    const alternateKeyv = new Keyv<string>(alternateStore)
+    expect(await alternateKeyv.get('key')).toBeUndefined()
+  })
+
+  it('should set multiple values that can be retrieved', async () => {
+    const store = new KeyValueTypeORMStoreAdapter({ dbConnection, namespace: 'test' })
+    const keyv = new Keyv<string>(store)
+    for (let i = 0; i < 10; i++) {
+      await keyv.set(`${i}`, `value${i}`)
+    }
+
+    let values = await keyv.getMany(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'nope'])
+    expect(values).toHaveLength(11)
+
+    await keyv.delete('0')
+    expect(await keyv.getMany(['0'])).toHaveLength(1)
+    values = await keyv.getMany(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'nope'])
+    expect(values).toHaveLength(11)
+    expect(values[9]).toBe('value9')
+    expect(values[10]).toBeUndefined()
+
+    await keyv.clear()
+    values = await keyv.getMany(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'nope'])
+    expect(values).toHaveLength(11)
+    expect(values[0]).toBeUndefined()
+    expect(values[9]).toBeUndefined()
+    expect(values[10]).toBeUndefined()
+  })
+  it('should work for all methods', async () => {
+    const store = new KeyValueTypeORMStoreAdapter({ dbConnection, namespace: 'test-all' })
+    await testAllKeyvMethods(store)
+    await store.disconnect()
+  })
+})
+
+describe('keyv tiered store', () => {
+  it('should respect ttl', async () => {
+    const local: Map<string, string> = new Map()
+    const remote = new KeyValueTypeORMStoreAdapter({ dbConnection })
+
+    const options: KeyvOptions<string> = {
+      namespace: 'example',
+      store: new KeyValueTieredStoreAdapter({ local, remote }),
+    }
+    const keyv = new Keyv<string>(undefined, options)
+    await keyv.set('key', 'value', 100)
+
+    expect(await keyv.get('key')).toEqual('value')
+    timekeeper.freeze(Date.now() + 150)
+    expect(await keyv.get('key')).toBeUndefined()
+    await keyv.disconnect()
+  })
+  it('should work for all methods', async () => {
+    const local: Map<string, string> = new Map()
+    const remote = new KeyValueTypeORMStoreAdapter({ dbConnection })
+
+    const options: KeyvOptions<string> = {
+      namespace: 'example',
+      store: new KeyValueTieredStoreAdapter({ local, remote }),
+    }
+    const store = new Keyv<string>(undefined, options)
+
+    // No raw match test, as remote and local have different raw values
+    await testAllKeyvMethods(store, false)
+  })
+})
+
+async function testAllKeyvMethods(store: any, rawMatchTest = true) {
+  const keyv = new Keyv<string>(store)
+
+  // set value
+  await expect(keyv.set('key1', 'value1')).resolves.toEqual(true)
+  await expect(keyv.set('key2', 'value2')).resolves.toEqual(true)
+
+  // get value by key
+  await expect(keyv.get('key1', { raw: false })).resolves.toEqual('value1')
+  await expect(keyv.get('key1', { raw: true })).resolves.toMatchObject({ value: 'value1' })
+
+  // get value by non-existing key
+  await expect(keyv.get('key3', { raw: false })).resolves.toBeUndefined()
+  await expect(keyv.get('key3', { raw: true })).resolves.toBeUndefined()
+
+  // Get many as non-raw and raw
+  await expect(keyv.getMany(['key1', 'key2'], { raw: false })).resolves.toMatchObject(['value1', 'value2'])
+  if (rawMatchTest) {
+    await expect(keyv.getMany(['key1', 'key2'], { raw: true })).resolves.toMatchObject([{ value: 'value1' }, { value: 'value2' }])
+  }
+
+  // Check existence
+  await expect(keyv.has('key1')).resolves.toEqual(true)
+  await expect(keyv.has('key3')).resolves.toEqual(false)
+
+  // delete key1 only
+  await expect(keyv.delete('key1')).resolves.toEqual(true)
+  await expect(keyv.has('key1')).resolves.toEqual(false)
+  await expect(keyv.has('key2')).resolves.toEqual(true)
+
+  // clear
+  await keyv.clear()
+  await expect(keyv.has('key2')).resolves.toEqual(false)
+}

package/.yalc/@veramo/kv-store/src/__tests__/kvstore.test.ts

@@ -0,0 +1,93 @@
+import { KeyValueStore } from '../key-value-store'
+import { IKeyValueStore } from '../key-value-types'
+
+interface TestValue {
+  stringProp: string
+  numberProp: number
+  objectProp: {
+    value: string | number
+  }
+}
+
+let testValues: TestValue[] = []
+
+for (let i = 0; i < 10; i++) {
+  testValues.push({
+    stringProp: `stringValue${i}`,
+    numberProp: i,
+    objectProp: {
+      value: `objectValue${i}`,
+    },
+  })
+}
+describe('kvStore with MAP adapter', () => {
+  let kvStore: IKeyValueStore<TestValue>
+  beforeEach(async () => {
+    const store = new Map<string, TestValue>()
+    kvStore = new KeyValueStore({ store })
+    for (let i = 0; i < 10; i++) {
+      await kvStore.set(`key${i}`, testValues[i])
+    }
+  })
+  afterEach(async () => {
+    try {
+      await kvStore.clear()
+      await kvStore.disconnect()
+    } catch (error) {}
+  })
+  it('should get non-existing keys as undefined', async () => {
+    await expect(kvStore.get('nope')).resolves.toBeUndefined()
+    await expect(kvStore.getAsValueData('nope')).resolves.toMatchObject({
+      value: undefined,
+      expires: undefined,
+    })
+  })
+
+  it('should get single results', async () => {
+    for (let i = 0; i < 10; i++) {
+      await expect(kvStore.get(`key${i}`)).resolves.toEqual(testValues[i])
+      await expect(kvStore.getAsValueData(`key${i}`)).resolves.toMatchObject({
+        value: testValues[i],
+        expires: undefined,
+      })
+    }
+  })
+
+  it('should get multiple results', async () => {
+    // Let's get multiple results
+    const manyResult = await kvStore.getMany(['key1', 'nope', 'key4'])
+    expect(manyResult).toHaveLength(3)
+    expect(manyResult[0]).toEqual(testValues[1])
+    expect(manyResult[1]).toBeUndefined()
+    expect(manyResult[2]).toEqual(testValues[4])
+    const manyValueResult = await kvStore.getManyAsValueData(['key1', 'nope', 'key4'])
+    expect(manyValueResult).toHaveLength(3)
+    expect(manyValueResult[0]).toEqual({ value: testValues[1], expires: undefined })
+    expect(manyValueResult[1]).toEqual({ value: undefined, expires: undefined })
+    expect(manyValueResult[2]).toEqual({ value: testValues[4], expires: undefined })
+  })
+
+  it('should check existence of keys', async () => {
+    await expect(kvStore.has(`key1`)).resolves.toEqual(true)
+    await expect(kvStore.has(`nope`)).resolves.toEqual(false)
+  })
+
+  it('should delete an existing key', async () => {
+    await expect(kvStore.has(`key1`)).resolves.toEqual(true)
+    await expect(kvStore.delete(`key1`)).resolves.toEqual(true)
+    await expect(kvStore.has(`key1`)).resolves.toEqual(false)
+  })
+
+  it('should not throw an error when deleting a non-existing key', async () => {
+    await expect(kvStore.delete(`nope`)).resolves.toEqual(false)
+  })
+
+  it('should delete multiple values', async () => {
+    await expect(kvStore.deleteMany(['key2', 'nope', 'key6'])).resolves.toEqual([true, false, true])
+  })
+
+  it('should clear all', async () => {
+    await kvStore.clear()
+    await expect(kvStore.has(`key1`)).resolves.toEqual(false)
+  })
+})

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

@@ -0,0 +1,10 @@
+/**
+ * Provides a {@link @veramo/kv-store#KeyValueStore} for the
+ * {@link @veramo/core#Agent} plugin that implements {@link @veramo/kv-store#IKeyValueStore} interface
+ *
+ * @packageDocumentation
+ */
+export { KeyValueStore } from './key-value-store'
+export * from './store-adapters/tiered/index'
+export * from './store-adapters/typeorm/index'
+export * from './key-value-types'

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

@@ -0,0 +1,109 @@
+import { IKeyValueStore, IKeyValueStoreOnArgs, IKeyValueStoreOptions, IValueData } from './key-value-types'
+import { Keyv } from './keyv/keyv'
+import { KeyvDeserializedData, KeyvOptions, KeyvStoredData } from './keyv/keyv-types'
+
+/**
+ * Agent plugin that implements {@link @veramo/kv-store#IKeyValueStore} interface
+ * @public
+ */
+export class KeyValueStore<ValueType> implements IKeyValueStore<ValueType> {
+  /**
+   * The main keyv typescript port which delegates to the storage adapters and takes care of some common functionality
+   *
+   * @private
+   */
+  private readonly keyv: Keyv<ValueType>
+
+  constructor(options: IKeyValueStoreOptions<ValueType>) {
+    this.keyv = new Keyv(options.uri, options as KeyvOptions<ValueType>)
+  }
+
+  async get(key: string): Promise<ValueType | undefined> {
+    const result = await this.keyv.get(key, { raw: false })
+    if (result === null || result === undefined) {
+      return undefined
+    }
+    return result as ValueType
+  }
+
+  async getAsValueData(key: string): Promise<IValueData<ValueType>> {
+    const result = await this.keyv.get(key, { raw: true })
+    if (result === null || result === undefined) {
+      // We always return a ValueData object for this method
+      return { value: undefined, expires: undefined }
+    }
+    return this.toDeserializedValueData(result)
+  }
+
+  async getMany(keys: string[]): Promise<Array<ValueType | undefined>> {
+    if (!keys || keys.length === 0) {
+      return []
+    }
+    let result = await this.keyv.getMany(keys, { raw: false })
+
+    // Making sure we return the same array length as the amount of key(s) passed in
+    if (result === null || result === undefined || result.length === 0) {
+      result = new Array<ValueType | undefined>()
+      keys.forEach(() => result.push(undefined))
+    }
+    return result.map((v) => (!!v ? (v as ValueType) : undefined))
+  }
+
+  async getManyAsValueData(keys: string[]): Promise<Array<IValueData<ValueType>>> {
+    if (!keys || keys.length === 0) {
+      return []
+    }
+    let result = await this.keyv.getMany(keys, { raw: true })
+
+    // Making sure we return the same array length as the amount of key(s) passed in
+    if (result === null || result === undefined || result.length === 0) {
+      result = new Array<KeyvStoredData<ValueType>>()
+      keys.forEach(() => result.push({ value: undefined, expires: undefined } as KeyvDeserializedData<ValueType>))
+    }
+    return result.map((v) => (!!v ? this.toDeserializedValueData(v) : { value: undefined, expires: undefined }))
+  }
+
+  async set(key: string, value: ValueType, ttl?: number): Promise<IValueData<ValueType>> {
+    return this.keyv.set(key, value, ttl).then(() => this.getAsValueData(key))
+  }
+
+  async has(key: string): Promise<boolean> {
+    return this.keyv.has(key)
+  }
+
+  async delete(key: string): Promise<boolean> {
+    return this.keyv.delete(key)
+  }
+
+  async deleteMany(keys: string[]): Promise<boolean[]> {
+    return Promise.all(keys.map((key) => this.keyv.delete(key)))
+  }
+
+  async clear(): Promise<IKeyValueStore<ValueType>> {
+    return this.keyv.clear().then(() => this)
+  }
+
+  async disconnect(): Promise<void> {
+    return this.keyv.disconnect()
+  }
+
+  // Public so parties using the kv store directly can add listeners if they want
+  async kvStoreOn(args: IKeyValueStoreOnArgs): Promise<IKeyValueStore<ValueType>> {
+    this.keyv.on(args.eventName, args.listener)
+    return this
+  }
+
+  private toDeserializedValueData<ValueType>(result: any): IValueData<ValueType> {
+    if (result === null || result === undefined) {
+      throw Error(`Result cannot be undefined or null at this this point`)
+    } else if (typeof result !== 'object') {
+      return { value: result, expires: undefined }
+    } else if (!('value' in result)) {
+      return { value: result, expires: undefined }
+    }
+    if (!('expires' in result)) {
+      result.expires = undefined
+    }
+    return result as IValueData<ValueType>
+  }
+}