@sphereon/ssi-sdk.kv-store-temp 0.33.1-next.3 → 0.33.1-next.68

package/dist/index.cjs

@@ -0,0 +1,709 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  KeyValueStore: () => KeyValueStore,
+  KeyValueStoreEntity: () => KeyValueStoreEntity,
+  KeyValueTieredStoreAdapter: () => KeyValueTieredStoreAdapter,
+  KeyValueTypeORMStoreAdapter: () => KeyValueTypeORMStoreAdapter,
+  _getConnectedDb: () => _getConnectedDb,
+  kvStoreMigrations: () => kvStoreMigrations
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/keyv/keyv.ts
+var import_events = require("events");
+var import_json_buffer = __toESM(require("json-buffer"), 1);
+var Keyv = class extends import_events.EventEmitter {
+  static {
+    __name(this, "Keyv");
+  }
+  opts;
+  namespace;
+  iterator;
+  constructor(uri, options) {
+    super();
+    const emitErrors = options?.emitErrors === void 0 ? true : options.emitErrors;
+    uri = uri ?? options?.uri;
+    this.opts = {
+      namespace: "keyv",
+      serialize: import_json_buffer.default.stringify,
+      deserialize: import_json_buffer.default.parse,
+      ...typeof uri === "string" ? {
+        uri
+      } : uri,
+      ...options
+    };
+    if (!this.opts.store) {
+      if (typeof uri !== "string") {
+        this.opts.store = uri;
+      }
+    }
+    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 = /* @__PURE__ */ __name((iterator, keyv) => 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
+        ];
+      }
+    }, "generateIterator");
+    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() {
+    return this.opts.store;
+  }
+  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) {
+    return `${this.opts.namespace}:${key}`;
+  }
+  _getKeyPrefixArray(keys) {
+    return keys.map((key) => this._getKeyPrefix(key));
+  }
+  _getKeyUnprefix(key) {
+    return key.split(":").splice(1).join(":");
+  }
+  async getMany(keys, options) {
+    const keyPrefixed = this._getKeyPrefixArray(keys);
+    let promise;
+    if (this.store.getMany !== void 0) {
+      promise = this.store.getMany(keyPrefixed, options);
+    } else if (this.isMapWithEntries(this.store)) {
+      promise = this.getFromMapWithPrefix(keyPrefixed);
+    } else {
+      promise = Promise.all(keyPrefixed.map((k) => this.store.get(k, options)));
+    }
+    const allValues = Promise.resolve(promise);
+    const results = [];
+    return Promise.resolve(allValues).then((all) => {
+      const entries = Array.isArray(all) ? all : [
+        all
+      ];
+      entries.forEach((data, 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(keys[index]);
+          result = void 0;
+        }
+        const final = options && options.raw ? result : result && typeof result === "object" && "value" in result ? result.value : result;
+        results.push(final);
+      });
+    }).then(() => Promise.all(results));
+  }
+  isMapWithEntries(store) {
+    return store instanceof Map && typeof store.entries === "function";
+  }
+  async getFromMapWithPrefix(prefixes) {
+    if (!this.isMapWithEntries(this.store)) {
+      return [];
+    }
+    const map = this.store;
+    return prefixes.flatMap((prefix) => {
+      const matchedValues = Array.from(map.entries()).filter(([key]) => key.startsWith(prefix)).map(([, value]) => value);
+      return matchedValues.length > 0 ? matchedValues : [
+        void 0
+      ];
+    });
+  }
+  async get(key, options) {
+    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 === void 0 || data === null) {
+        return void 0;
+      }
+      const rows = Array.isArray(data) ? data : [
+        data
+      ];
+      if (isArray) {
+        const result = [];
+        for (let row of rows) {
+          if (row === void 0 || row === null) {
+            result.push(void 0);
+            continue;
+          }
+          if (this.isExpired(row)) {
+            this.delete(key).then(() => void 0);
+            result.push(void 0);
+          } 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(() => void 0);
+        }
+      }
+      return options && options.raw ? data : Array.isArray(data) ? data.map((d) => toValue(d)) : toValue(data);
+    });
+  }
+  isExpired(data) {
+    return typeof data !== "string" && data && typeof data === "object" && "expires" in data && typeof data.expires === "number" && Date.now() > data.expires;
+  }
+  set(key, value, ttl) {
+    const keyPrefixed = this._getKeyPrefix(key);
+    if (typeof ttl === "undefined") {
+      ttl = this.opts.ttl;
+    }
+    if (ttl === 0) {
+      ttl = void 0;
+    }
+    return Promise.resolve().then(() => {
+      const expires = typeof ttl === "number" ? Date.now() + ttl : void 0;
+      if (typeof value === "symbol") {
+        this.emit("error", "symbol cannot be serialized");
+      }
+      const input = {
+        value,
+        expires
+      };
+      return this.serialize(input);
+    }).then((value2) => this.store.set(keyPrefixed, value2, ttl)).then(() => true);
+  }
+  delete(key) {
+    if (!Array.isArray(key)) {
+      const keyPrefixed2 = this._getKeyPrefix(key);
+      return Promise.resolve().then(() => this.store.delete(keyPrefixed2));
+    }
+    const keyPrefixed = this._getKeyPrefixArray(key);
+    if (this.store.deleteMany !== void 0) {
+      return Promise.resolve().then(() => this.store.deleteMany(keyPrefixed));
+    }
+    const promises = [];
+    for (const key2 of keyPrefixed) {
+      promises.push(this.store.delete(key2));
+    }
+    return Promise.allSettled(promises).then((values) => values.every((x) => x.valueOf() === true));
+  }
+  async clear() {
+    return Promise.resolve().then(() => this.store.clear());
+  }
+  has(key) {
+    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 !== void 0;
+    });
+  }
+  disconnect() {
+    if (typeof this.store.disconnect === "function") {
+      return this.store.disconnect();
+    }
+  }
+};
+var iterableAdapters = [
+  "sqlite",
+  "postgres",
+  "mysql",
+  "mongo",
+  "redis",
+  "tiered"
+];
+function toValue(input) {
+  return input !== null && typeof input === "object" && "value" in input ? input.value : input;
+}
+__name(toValue, "toValue");
+
+// src/key-value-store.ts
+var KeyValueStore = class {
+  static {
+    __name(this, "KeyValueStore");
+  }
+  /**
+  * The main keyv typescript port which delegates to the storage adapters and takes care of some common functionality
+  *
+  * @internal
+  */
+  keyv;
+  constructor(options) {
+    this.keyv = new Keyv(options.uri, options);
+  }
+  async get(key) {
+    const result = await this.keyv.get(key, {
+      raw: false
+    });
+    if (result === null || result === void 0) {
+      return void 0;
+    }
+    return result;
+  }
+  async getAsValueData(key) {
+    const result = await this.keyv.get(key, {
+      raw: true
+    });
+    if (result === null || result === void 0) {
+      return {
+        value: void 0,
+        expires: void 0
+      };
+    }
+    return this.toDeserializedValueData(result);
+  }
+  async getMany(keys) {
+    if (!keys || keys.length === 0) {
+      return [];
+    }
+    let result = await this.keyv.getMany(keys, {
+      raw: false
+    });
+    if (result === null || result === void 0 || result.length === 0) {
+      result = new Array();
+      keys.forEach(() => result.push(void 0));
+    }
+    return result.map((v) => !!v ? v : void 0);
+  }
+  async getManyAsValueData(keys) {
+    if (!keys || keys.length === 0) {
+      return [];
+    }
+    let result = await this.keyv.getMany(keys, {
+      raw: true
+    });
+    if (result === null || result === void 0 || result.length === 0) {
+      result = new Array();
+      keys.forEach(() => result.push({
+        value: void 0,
+        expires: void 0
+      }));
+    }
+    return result.map((v) => !!v ? this.toDeserializedValueData(v) : {
+      value: void 0,
+      expires: void 0
+    });
+  }
+  async set(key, value, ttl) {
+    return this.keyv.set(key, value, ttl).then(() => this.getAsValueData(key));
+  }
+  async has(key) {
+    return this.keyv.has(key);
+  }
+  async delete(key) {
+    return this.keyv.delete(key);
+  }
+  async deleteMany(keys) {
+    return Promise.all(keys.map((key) => this.keyv.delete(key)));
+  }
+  async clear() {
+    return this.keyv.clear().then(() => this);
+  }
+  async disconnect() {
+    return this.keyv.disconnect();
+  }
+  // Public so parties using the kv store directly can add listeners if they want
+  async kvStoreOn(args) {
+    this.keyv.on(args.eventName, args.listener);
+    return this;
+  }
+  toDeserializedValueData(result) {
+    if (result === null || result === void 0) {
+      throw Error(`Result cannot be undefined or null at this this point`);
+    } else if (typeof result !== "object") {
+      return {
+        value: result,
+        expires: void 0
+      };
+    } else if (!("value" in result)) {
+      return {
+        value: result,
+        expires: void 0
+      };
+    }
+    if (!("expires" in result)) {
+      result.expires = void 0;
+    }
+    return result;
+  }
+};
+
+// src/store-adapters/tiered/index.ts
+var import_events2 = require("events");
+var KeyValueTieredStoreAdapter = class extends import_events2.EventEmitter {
+  static {
+    __name(this, "KeyValueTieredStoreAdapter");
+  }
+  opts;
+  remote;
+  local;
+  iterationLimit;
+  namespace;
+  constructor({ remote, local, ...options }) {
+    super();
+    this.opts = {
+      validator: /* @__PURE__ */ __name(() => true, "validator"),
+      dialect: "tiered",
+      ...options
+    };
+    this.local = isMap(local) ? new Keyv(local) : local;
+    this.remote = isMap(remote) ? new Keyv(remote) : remote;
+    this.namespace = this.local.namespace;
+  }
+  async get(key, options) {
+    if (Array.isArray(key)) {
+      return await this.getMany(key, options);
+    }
+    const localResult = await this.local.get(key, options);
+    if (localResult === void 0 || !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 : void 0;
+        const ttl = !!remoteResult && typeof remoteResult === "object" && "expires" in remoteResult && remoteResult.expires ? remoteResult.expires - Date.now() : void 0;
+        if (!ttl || ttl > 0) {
+          await this.local.set(key, value, ttl);
+        } else {
+          this.local.delete(key);
+        }
+      }
+      return remoteResult;
+    }
+    return localResult;
+  }
+  async getMany(keys, options) {
+    const promises = [];
+    for (const key of keys) {
+      promises.push(this.get(key, options));
+    }
+    const values = await Promise.all(promises);
+    const data = [];
+    for (const value of values) {
+      data.push(value);
+    }
+    return data;
+  }
+  async set(key, value, ttl) {
+    const toSet = [
+      "local",
+      "remote"
+    ];
+    return Promise.all(toSet.map(async (store) => this[store].set(key, value, ttl)));
+  }
+  async clear() {
+    const toClear = [
+      "local"
+    ];
+    if (!this.opts.localOnly) {
+      toClear.push("remote");
+    }
+    await Promise.all(toClear.map(async (store) => this[store].clear()));
+    return void 0;
+  }
+  async delete(key) {
+    const toDelete = [
+      "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) {
+    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) {
+    let response;
+    if (typeof this.local.has === "function") {
+      response = this.local.has(key);
+    } else {
+      const value = await this.local.get(key);
+      response = value !== void 0;
+    }
+    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 !== void 0;
+      }
+    }
+    return response;
+  }
+  async *iterator(namespace) {
+    const limit = Number.parseInt(this.iterationLimit, 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) {
+  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;
+}
+__name(isMap, "isMap");
+
+// src/store-adapters/typeorm/index.ts
+var import_events3 = require("events");
+var import_typeorm3 = require("typeorm");
+
+// src/store-adapters/typeorm/entities/keyValueStoreEntity.ts
+var import_typeorm = require("typeorm");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var KeyValueStoreEntity = class extends import_typeorm.BaseEntity {
+  static {
+    __name(this, "KeyValueStoreEntity");
+  }
+  key;
+  data;
+  expires;
+};
+_ts_decorate([
+  (0, import_typeorm.PrimaryColumn)("text"),
+  _ts_metadata("design:type", String)
+], KeyValueStoreEntity.prototype, "key", void 0);
+_ts_decorate([
+  (0, import_typeorm.Column)({
+    type: "text"
+  }),
+  _ts_metadata("design:type", String)
+], KeyValueStoreEntity.prototype, "data", void 0);
+KeyValueStoreEntity = _ts_decorate([
+  (0, import_typeorm.Entity)("keyvaluestore")
+], KeyValueStoreEntity);
+
+// src/store-adapters/typeorm/index.ts
+var import_json_buffer2 = __toESM(require("json-buffer"), 1);
+
+// src/store-adapters/typeorm/migrations/1.createKVDatabase.ts
+var import_typeorm2 = require("typeorm");
+var import_debug = __toESM(require("debug"), 1);
+var debug = (0, import_debug.default)("veramo:kv-store:initial-migration");
+var CreateKVDatabaseMigration = class {
+  static {
+    __name(this, "CreateKVDatabaseMigration");
+  }
+  _tableName;
+  name;
+  constructor(tableName) {
+    this._tableName = tableName || "keyvaluestore";
+    this.name = `CreateKVDatabase${tableName}1680297189001`;
+  }
+  async up(queryRunner) {
+    function getTableName(givenName) {
+      return queryRunner.connection.entityMetadatas.find((meta) => meta.givenTableName === givenName)?.tableName || givenName;
+    }
+    __name(getTableName, "getTableName");
+    debug(`creating ${this._tableName} table`);
+    await queryRunner.createTable(new import_typeorm2.Table({
+      name: getTableName(this._tableName),
+      columns: [
+        {
+          name: "key",
+          type: "varchar",
+          isPrimary: true
+        },
+        {
+          name: "data",
+          type: "text",
+          isNullable: false
+        }
+      ],
+      indices: [
+        {
+          columnNames: [
+            "key"
+          ],
+          isUnique: true
+        }
+      ]
+    }), true);
+  }
+  async down(queryRunner) {
+    throw new Error("illegal_operation: cannot roll back initial migration");
+  }
+};
+
+// src/store-adapters/typeorm/migrations/index.ts
+var kvStoreMigrations = [
+  CreateKVDatabaseMigration
+];
+
+// src/store-adapters/typeorm/index.ts
+var KeyValueTypeORMStoreAdapter = class extends import_events3.EventEmitter {
+  static {
+    __name(this, "KeyValueTypeORMStoreAdapter");
+  }
+  dbConnection;
+  namespace;
+  opts;
+  constructor(options) {
+    super();
+    this.dbConnection = options.dbConnection;
+    this.namespace = options.namespace || "keyv";
+    this.opts = {
+      validator: /* @__PURE__ */ __name(() => true, "validator"),
+      dialect: "typeorm",
+      serialize: import_json_buffer2.default.stringify,
+      deserialize: import_json_buffer2.default.parse,
+      ...options
+    };
+  }
+  async get(key, options) {
+    if (Array.isArray(key)) {
+      return this.getMany(key, options);
+    }
+    const connection = await _getConnectedDb(this.dbConnection);
+    const result = await connection.getRepository(KeyValueStoreEntity).findOneBy({
+      key
+    });
+    return options?.raw !== true || !result ? result?.data : {
+      value: result?.data,
+      expires: result?.expires
+    };
+  }
+  async getMany(keys, options) {
+    const connection = await _getConnectedDb(this.dbConnection);
+    const results = await connection.getRepository(KeyValueStoreEntity).findBy({
+      key: (0, import_typeorm3.In)(keys)
+    });
+    const values = keys.map(async (key) => {
+      const result = results.find((result2) => result2.key === key);
+      return options?.raw !== true || !result ? result?.data : {
+        value: result?.data ? (await this.opts.deserialize(result.data))?.value : void 0,
+        expires: result?.expires
+      };
+    });
+    return Promise.all(values);
+  }
+  async set(key, value, ttl) {
+    const connection = await _getConnectedDb(this.dbConnection);
+    const entity = new KeyValueStoreEntity();
+    entity.key = key;
+    entity.data = value;
+    entity.expires = ttl;
+    await connection.getRepository(KeyValueStoreEntity).save(entity);
+    return {
+      value,
+      expires: ttl
+    };
+  }
+  async delete(key) {
+    if (Array.isArray(key)) {
+      return this.deleteMany(key);
+    }
+    const connection = await _getConnectedDb(this.dbConnection);
+    const result = await connection.getRepository(KeyValueStoreEntity).delete({
+      key
+    });
+    return result.affected === 1;
+  }
+  async deleteMany(keys) {
+    const connection = await _getConnectedDb(this.dbConnection);
+    const results = await connection.getRepository(KeyValueStoreEntity).delete({
+      key: (0, import_typeorm3.In)(keys)
+    });
+    return !!results.affected && results.affected >= 1;
+  }
+  async clear() {
+    const connection = await _getConnectedDb(this.dbConnection);
+    await connection.getRepository(KeyValueStoreEntity).delete({
+      key: (0, import_typeorm3.Like)(`${this.namespace}:%`)
+    });
+  }
+  async has(key) {
+    const connection = await _getConnectedDb(this.dbConnection);
+    const result = await connection.getRepository(KeyValueStoreEntity).countBy({
+      key
+    });
+    return result === 1;
+  }
+  async disconnect() {
+    const connection = await _getConnectedDb(this.dbConnection);
+    await connection.destroy();
+  }
+};
+async function _getConnectedDb(dbConnection) {
+  if (dbConnection instanceof Promise) {
+    return await dbConnection;
+  } else if (!dbConnection.isInitialized) {
+    return await dbConnection.initialize();
+  } else {
+    return dbConnection;
+  }
+}
+__name(_getConnectedDb, "_getConnectedDb");
+//# sourceMappingURL=index.cjs.map