@sphereon/ssi-sdk.agent-config 0.33.1-feature.vcdm2.tsup.31 → 0.33.1-next.2

package/dist/index.d.ts

@@ -1,186 +1,10 @@
-import { IPluginMethodMap, IAgentContext, IKeyManager, IResolver, IDIDManager, ICredentialIssuer, ICredentialVerifier, ICredentialStatusVerifier, IDataStore, IDataStoreORM, TAgent, IAgentOptions } from '@veramo/core';
-import { DataSource } from 'typeorm/data-source/DataSource.js';
-import { BaseDataSourceOptions } from 'typeorm/data-source/BaseDataSourceOptions.js';
-import { DataSourceOptions } from 'typeorm/data-source/DataSourceOptions.js';
-
 /**
- * Allows to get a type agent context plugin methods based on provided or inferred types and at least one method for these plugin(s)
- * @param context Tje agent context to check against
- * @param requiredMethod One or more method the plugin provides, so we can check availability and thus plugin presence
- */
-declare function contextHasPlugin<Plugins extends IPluginMethodMap>(context: IAgentContext<any>, requiredMethod: string | string[]): context is IAgentContext<Plugins>;
-/**
- * The below methods are convenience methods to directly get the appropriate context after calling the respective method
- *
- * @param context
- */
-declare function contextHasKeyManager(context: IAgentContext<IPluginMethodMap>): context is IAgentContext<IKeyManager>;
-declare function contextHasDidManager(context: IAgentContext<IPluginMethodMap>): context is IAgentContext<IResolver & IDIDManager>;
-declare function contextHasDidResolver(context: IAgentContext<IPluginMethodMap>): context is IAgentContext<IResolver>;
-declare function contextHasCredentialIssuer(context: IAgentContext<IPluginMethodMap>): context is IAgentContext<ICredentialIssuer>;
-declare function contextHasCredentialVerifier(context: IAgentContext<IPluginMethodMap>): context is IAgentContext<ICredentialVerifier>;
-declare function contextHasCredentialStatusVerifier(context: IAgentContext<IPluginMethodMap>): context is IAgentContext<ICredentialStatusVerifier>;
-declare function contextHasDataStore(context: IAgentContext<IPluginMethodMap>): context is IAgentContext<IDataStore>;
-declare function contextHasDataStoreORM(context: IAgentContext<IPluginMethodMap>): context is IAgentContext<IDataStoreORM>;
-
-declare class DataSources {
-    get defaultDbType(): SupportedDatabaseType;
-    set defaultDbType(value: SupportedDatabaseType);
-    private dataSources;
-    private configs;
-    private _defaultDbType;
-    private static singleton;
-    static singleInstance(): DataSources;
-    static newInstance(configs?: Map<string, DataSourceOptions>): DataSources;
-    private constructor();
-    addConfig(dbName: string, config: DataSourceOptions): this;
-    deleteConfig(dbName: string): this;
-    has(dbName: string): boolean;
-    delete(dbName: string): this;
-    getConfig(dbName: string): BaseDataSourceOptions;
-    getDbNames(): string[];
-    getDbConnection(dbName: string): Promise<DataSource>;
-}
-type SupportedDatabaseType = 'postgres' | 'sqlite' | 'react-native';
-type DateTimeType = 'timestamp' | 'datetime';
-type DateType = 'date';
-/**
- * Gets the database connection.
- *
- * Also makes sure that migrations are run (versioning for DB schema's), so we can properly update over time
- *
- * @param connectionName The database name
- * @param opts
- */
-declare const getDbConnection: (connectionName: string, opts?: {
-    config: BaseDataSourceOptions | any;
-}) => Promise<DataSource>;
-declare const dropDatabase: (dbName: string, opts?: {
-    removeDataSource?: boolean;
-}) => Promise<void>;
-/**
- * Runs a migration down (drops DB schema)
- * @param dataSource
- */
-declare const revertMigration: (dataSource: DataSource) => Promise<void>;
-declare const resetDatabase: (dbName: string) => Promise<void>;
-
-/**
- * Creates a Veramo agent from a config object containing an `/agent` pointer.
- * @param config - The configuration object
- *
- * @see {@link https://veramo.io/docs/veramo_agent/configuration_internals | Configuration Internals} for details on
- *   the configuration options.
- *
- * @beta - This API may change without a major version bump
- */
-declare function createAgentFromConfig<T extends IPluginMethodMap>(config: object): Promise<TAgent<T>>;
-/**
- * Helper function to create a new instance of the {@link Agent} class with correct type
- *
- * @remarks
- * Use {@link TAgent} to configure agent type (list of available methods) for autocomplete in IDE
- *
- * @example
- * ```typescript
- * import { createAgent, IResolver, IMessageHandler } from '@veramo/core'
- * import { AgentRestClient } from '@veramo/remote-client'
- * import { CredentialIssuer, ICredentialIssuer } from '@veramo/credential-w3c'
- * const agent = createAgent<IResolver & IMessageHandler & ICredentialIssuer>({
- *   plugins: [
- *     new CredentialIssuer(),
- *     new AgentRestClient({
- *       url: 'http://localhost:3002/agent',
- *       enabledMethods: [
- *         'resolveDid',
- *         'handleMessage',
- *       ],
- *     }),
- *   ],
- * })
- * ```
- * @param options - Agent configuration options
- * @returns configured agent
  * @public
  */
-declare function createAgent<T extends IPluginMethodMap, C = Record<string, any>>(options: IAgentOptions & {
-    context?: C;
-}): Promise<TAgent<T> & {
-    context?: C;
-}>;
-/**
- * Parses a yaml config file and returns a config object
- * @param filePath
- */
-declare const getConfig: (filePath: string | Buffer | URL) => Promise<{
-    version?: number;
-    [x: string]: any;
-}>;
-declare function getAgent<T extends IPluginMethodMap>(fileName: string): Promise<TAgent<T>>;
-
-/**
- * Creates objects from a configuration object and a set of pointers.
- *
- * Example:
- * ```ts
- * const { url } = createObjects({ "rpcUrl": "http://localhost:8545", }, { url: '/rpcUrl' })
- * ```
- *
- * The config can contain references (`$ref`) to other objects within using JSON pointers.
- * Example:
- * ```json
- * {
- *   "rpcUrl": "http://localhost:8545",
- *   "endpoint": {
- *     "url": {
- *       "$ref": "/rpcUrl"
- *     }
- *   }
- * }
- * ```
- *
- * The config object can also contain references to NPM modules using the `$require` property.
- * Example:
- * ```json
- * {
- *   "agent": {
- *     "$require": "@veramo/core#Agent",
- *     "$args": {
- *       "plugins": [
- *         { "$require": "@veramo/did-comm#DIDComm" },
- *       ]
- *     }
- *   }
- * }
- * ```
- *
- * Environment variables can also be specified using the `$env` property.
- *
- * @see Please see {@link https://veramo.io/docs/veramo_agent/configuration_internals | Configuration Internals} for
- *   more information.
- *
- * @param config - The configuration object
- * @param pointers - A map of JSON pointers to objects within that config that you wish to create
- *
- * @beta - This API may change without a major version bump
- */
-declare function createObjects(config: object, pointers: Record<string, string>): Promise<Record<string, any>>;
-
-/**
- * Accept a Type or a Promise of that Type.
- *
- * @internal
- */
-type OrPromise<T> = T | Promise<T>;
-
-declare const getDbType: (opts?: {
-    defaultType: SupportedDatabaseType;
-}) => SupportedDatabaseType;
-declare const typeOrmDateTime: (opts?: {
-    defaultType: SupportedDatabaseType;
-}) => DateTimeType;
-declare const typeormDate: (opts?: {
-    defaultType: SupportedDatabaseType;
-}) => DateType;
-
-export { DataSources, type DateTimeType, type DateType, type OrPromise, type SupportedDatabaseType, contextHasCredentialIssuer, contextHasCredentialStatusVerifier, contextHasCredentialVerifier, contextHasDataStore, contextHasDataStoreORM, contextHasDidManager, contextHasDidResolver, contextHasKeyManager, contextHasPlugin, createAgent, createAgentFromConfig, createObjects, dropDatabase, getAgent, getConfig, getDbConnection, getDbType, resetDatabase, revertMigration, typeOrmDateTime, typeormDate };
+export * from './agentContextUtils';
+export * from './dataSources';
+export * from './agentCreator';
+export * from './objectCreator';
+export * from './generic';
+export * from './typeormTypes';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,qBAAqB,CAAA;AACnC,cAAc,eAAe,CAAA;AAC7B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,WAAW,CAAA;AACzB,cAAc,gBAAgB,CAAA"}

package/dist/index.js

@@ -1,402 +1,26 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/agentContextUtils.ts
-function contextHasPlugin(context, requiredMethod) {
-  const methods = Array.isArray(requiredMethod) ? requiredMethod : [
-    requiredMethod
-  ];
-  const allMethods = context.agent.availableMethods();
-  return methods.every((method) => allMethods.includes(method));
-}
-__name(contextHasPlugin, "contextHasPlugin");
-function contextHasKeyManager(context) {
-  return contextHasPlugin(context, "keyManagerGet");
-}
-__name(contextHasKeyManager, "contextHasKeyManager");
-function contextHasDidManager(context) {
-  return contextHasPlugin(context, "didManagerGet");
-}
-__name(contextHasDidManager, "contextHasDidManager");
-function contextHasDidResolver(context) {
-  return contextHasPlugin(context, "resolveDid");
-}
-__name(contextHasDidResolver, "contextHasDidResolver");
-function contextHasCredentialIssuer(context) {
-  return contextHasPlugin(context, [
-    "createVerifiableCredential",
-    "createVerifiablePresentation"
-  ]);
-}
-__name(contextHasCredentialIssuer, "contextHasCredentialIssuer");
-function contextHasCredentialVerifier(context) {
-  return contextHasPlugin(context, [
-    "verifyCredential",
-    "verifyPresentation"
-  ]);
-}
-__name(contextHasCredentialVerifier, "contextHasCredentialVerifier");
-function contextHasCredentialStatusVerifier(context) {
-  return contextHasPlugin(context, [
-    "checkCredentialStatus"
-  ]);
-}
-__name(contextHasCredentialStatusVerifier, "contextHasCredentialStatusVerifier");
-function contextHasDataStore(context) {
-  return contextHasPlugin(context, [
-    "dataStoreGetVerifiableCredential",
-    "dataStoreGetVerifiablePresentation"
-  ]);
-}
-__name(contextHasDataStore, "contextHasDataStore");
-function contextHasDataStoreORM(context) {
-  return contextHasPlugin(context, [
-    "dataStoreORMGetVerifiableCredentials",
-    "dataStoreORMGetVerifiablePresentations"
-  ]);
-}
-__name(contextHasDataStoreORM, "contextHasDataStoreORM");
-
-// src/dataSources.ts
-import Debug from "debug";
-import { DataSource } from "typeorm/data-source/DataSource.js";
-var debug = Debug(`sphereon:ssi-sdk:database`);
-var DataSources = class _DataSources {
-  static {
-    __name(this, "DataSources");
-  }
-  get defaultDbType() {
-    return this._defaultDbType;
-  }
-  set defaultDbType(value) {
-    this._defaultDbType = value;
-  }
-  dataSources = /* @__PURE__ */ new Map();
-  configs = /* @__PURE__ */ new Map();
-  _defaultDbType = "sqlite";
-  static singleton;
-  static singleInstance() {
-    if (!_DataSources.singleton) {
-      _DataSources.singleton = new _DataSources();
-    }
-    return _DataSources.singleton;
-  }
-  static newInstance(configs) {
-    return new _DataSources(configs);
-  }
-  constructor(configs) {
-    ;
-    (configs ?? /* @__PURE__ */ new Map()).forEach((config, name) => this.addConfig(name, config));
-  }
-  addConfig(dbName, config) {
-    this.configs.set(dbName, config);
-    this._defaultDbType = config.type;
-    return this;
-  }
-  deleteConfig(dbName) {
-    this.configs.delete(dbName);
-    return this;
-  }
-  has(dbName) {
-    return this.configs.has(dbName) && this.dataSources.has(dbName);
-  }
-  delete(dbName) {
-    this.deleteConfig(dbName);
-    this.dataSources.delete(dbName);
-    return this;
-  }
-  getConfig(dbName) {
-    const config = this.configs.get(dbName);
-    if (!config) {
-      throw Error(`No DB config found for ${dbName}`);
-    }
-    return config;
-  }
-  getDbNames() {
-    return [
-      ...this.configs.keys()
-    ];
-  }
-  async getDbConnection(dbName) {
-    const config = this.getConfig(dbName);
-    if (!this._defaultDbType) {
-      this._defaultDbType = config.type;
-    }
-    let dataSource = this.dataSources.get(dbName);
-    if (dataSource) {
-      return dataSource;
-    }
-    dataSource = await new DataSource({
-      ...config,
-      name: dbName
-    }).initialize();
-    this.dataSources.set(dbName, dataSource);
-    if (config.synchronize) {
-      debug(`WARNING: Automatic migrations need to be disabled in this app! Adjust the database configuration and set synchronize to false`);
-    } else if (config.migrationsRun) {
-      debug(`Migrations are currently managed from config. Please set migrationsRun and synchronize to false to get consistent behaviour. We run migrations from code explicitly`);
-    } else {
-      debug(`Running ${dataSource.migrations.length} migration(s) from code if needed...`);
-      await dataSource.runMigrations();
-      debug(`${dataSource.migrations.length} migration(s) from code were inspected and applied`);
-    }
-    return dataSource;
-  }
-};
-var getDbConnection = /* @__PURE__ */ __name(async (connectionName, opts) => {
-  if (!DataSources.singleInstance().has(connectionName) && opts?.config) {
-    DataSources.singleInstance().addConfig(connectionName, opts?.config);
-  }
-  return DataSources.singleInstance().getDbConnection(connectionName);
-}, "getDbConnection");
-var dropDatabase = /* @__PURE__ */ __name(async (dbName, opts) => {
-  const { removeDataSource = false } = {
-    ...opts
-  };
-  if (!DataSources.singleInstance().has(dbName)) {
-    return Promise.reject(Error(`No database present with name: ${dbName}`));
-  }
-  const connection = await getDbConnection(dbName);
-  await connection.dropDatabase();
-  if (removeDataSource) {
-    DataSources.singleInstance().delete(dbName);
-  } else if (!connection.isInitialized) {
-    await connection.initialize();
-  }
-}, "dropDatabase");
-var revertMigration = /* @__PURE__ */ __name(async (dataSource) => {
-  if (dataSource.isInitialized) {
-    await dataSource.undoLastMigration();
-  } else {
-    console.error("DataSource is not initialized");
-  }
-}, "revertMigration");
-var resetDatabase = /* @__PURE__ */ __name(async (dbName) => {
-  await dropDatabase(dbName);
-  const connection = await getDbConnection(dbName);
-  await connection.runMigrations();
-}, "resetDatabase");
-
-// src/objectCreator.ts
-import { set, get } from "jsonpointer";
-import parse from "url-parse";
-async function createObjects(config, pointers) {
-  const objects = {};
-  async function resolveRefs(input) {
-    if (Array.isArray(input)) {
-      const resolved = [];
-      for (const item of input) {
-        resolved.push(await resolveRefs(item));
-      }
-      return resolved;
-    }
-    if (typeof input === "object") {
-      const resolved = {};
-      for (const property in input) {
-        if (input.hasOwnProperty(property)) {
-          if (property === "$ref") {
-            const pointer = input[property];
-            return await objectFromPointer(pointer);
-          } else if (property === "$require") {
-            return await objectFromConfig(input);
-          } else if (property === "$env") {
-            return process.env[input[property]];
-          } else {
-            resolved[property] = await resolveRefs(input[property]);
-          }
-        }
-      }
-      return resolved;
-    }
-    return input;
-  }
-  __name(resolveRefs, "resolveRefs");
-  async function objectFromConfig(objectConfig) {
-    console.log("Requiring", objectConfig["$require"]);
-    const parsed = parse(objectConfig["$require"], {}, true);
-    let npmModule = parsed.pathname;
-    const member = parsed.hash.length > 1 ? parsed.hash.slice(1) : void 0;
-    console.log(`member: ${member}`);
-    const type = parsed.query["t"] || "class";
-    const pointer = parsed.query["p"];
-    const args = objectConfig["$args"];
-    console.log({
-      module,
-      member,
-      type,
-      query: parsed.query,
-      pointer,
-      args
-    });
-    if (npmModule.slice(0, 2) === "./" || npmModule.slice(0, 3) === "../") {
-      console.log("objectFromConfig: Resolving relative path", npmModule);
-      const { resolve } = await import("path");
-      npmModule = resolve(npmModule);
-    }
-    const resolvedArgs = args !== void 0 ? await resolveRefs(args) : [];
-    console.error(`npmModule: ${npmModule}`);
-    return await Promise.resolve(await import(
-      /*@metro-ignore*/
-      npmModule
-    ).then((mod) => {
-      if (member) {
-        return mod[member];
-      }
-      return mod;
-    }).then((required) => {
-      let object;
-      if (type === "class") {
-        object = new required(...resolvedArgs);
-      } else if (type === "function") {
-        object = required(...resolvedArgs);
-      } else if (type === "object") {
-        object = required;
-      } else {
-        console.error(`Likely we have a bug in agent object creation. type = ${type} is not of type class, function or object`);
-      }
-      if (!pointer) {
-        return object;
-      }
-      if (!object) {
-        return Promise.reject(Error(`Error creating ${npmModule}['${member}']: Object is undefined and pointer was present requiring an object.`));
-      }
-      return get(object, pointer);
-    }).catch((e) => {
-      console.error(e);
-      return Promise.reject(Error(`Error creating ${npmModule}['${member}']: ${e.message}`));
-    }));
-  }
-  __name(objectFromConfig, "objectFromConfig");
-  async function objectFromPointer(pointer) {
-    const existingObject = get(objects, pointer);
-    if (existingObject) {
-      return existingObject;
-    } else {
-      const objectConfig = get(config, pointer);
-      if (!objectConfig) throw Error("Pointer not found: " + pointer);
-      try {
-        let object;
-        if (objectConfig["$require"]) {
-          object = await objectFromConfig(objectConfig);
-        } else if (objectConfig["$env"]) {
-          object = process.env[objectConfig["$env"]];
-        } else {
-          object = await resolveRefs(objectConfig);
-        }
-        set(objects, pointer, object);
-        return object;
-      } catch (e) {
-        console.log(e);
-        throw Error(e.message + ". While creating object from pointer: " + pointer);
-      }
-    }
-  }
-  __name(objectFromPointer, "objectFromPointer");
-  const result = {};
-  for (const key of Object.keys(pointers)) {
-    if (pointers.hasOwnProperty(key)) {
-      result[key] = await objectFromPointer(pointers[key]);
-    }
-  }
-  return result;
-}
-__name(createObjects, "createObjects");
-
-// src/agentCreator.ts
-import yaml from "yaml";
-async function createAgentFromConfig(config) {
-  const { agent } = await createObjects(config, {
-    agent: "/agent"
-  });
-  return agent;
-}
-__name(createAgentFromConfig, "createAgentFromConfig");
-async function createAgent(options) {
-  return new Agent(options);
-}
-__name(createAgent, "createAgent");
-var getConfig = /* @__PURE__ */ __name(async (filePath) => {
-  let fileContent;
-  try {
-    const fs = await import(
-      /* webpackIgnore: true */
-      "fs"
-    );
-    fileContent = await fs.promises.readFile(filePath, "utf8");
-  } catch (e) {
-    console.log("Config file not found: " + filePath);
-    console.log('Use "veramo config create" to create one');
-    process.exit(1);
-  }
-  let config;
-  try {
-    config = yaml.parse(fileContent, {
-      prettyErrors: true
-    });
-  } catch (e) {
-    console.error(`Unable to parse config file: ${e.message} ${e.linePos}`);
-    process.exit(1);
-  }
-  if (config?.version != 3) {
-    console.error("Unsupported configuration file version:", config.version);
-    process.exit(1);
-  }
-  return config;
-}, "getConfig");
-async function getAgent(fileName) {
-  try {
-    return await createAgentFromConfig(await getConfig(fileName));
-  } catch (e) {
-    console.log("Unable to create agent from " + fileName + ".", e.message);
-    process.exit(1);
-  }
-}
-__name(getAgent, "getAgent");
-
-// src/typeormTypes.ts
-var getDbType = /* @__PURE__ */ __name((opts) => {
-  const type = (typeof process === "object" ? process?.env?.DB_TYPE : void 0) ?? DataSources.singleInstance().defaultDbType ?? opts?.defaultType;
-  if (!type) {
-    throw Error(`Could not determine DB type. Please set the DB_TYPE global variable or env var to one of 'postgres' or 'sqlite'`);
-  }
-  return type;
-}, "getDbType");
-var typeOrmDateTime = /* @__PURE__ */ __name((opts) => {
-  switch (getDbType(opts)) {
-    case "postgres":
-      return "timestamp";
-    case "sqlite":
-    case "react-native":
-      return "datetime";
-    default:
-      throw Error(`DB type ${getDbType(opts)} not supported. Right now only sqlite, react-native and postgresql are supported`);
-  }
-}, "typeOrmDateTime");
-var typeormDate = /* @__PURE__ */ __name((opts) => {
-  return "date";
-}, "typeormDate");
-export {
-  DataSources,
-  contextHasCredentialIssuer,
-  contextHasCredentialStatusVerifier,
-  contextHasCredentialVerifier,
-  contextHasDataStore,
-  contextHasDataStoreORM,
-  contextHasDidManager,
-  contextHasDidResolver,
-  contextHasKeyManager,
-  contextHasPlugin,
-  createAgent,
-  createAgentFromConfig,
-  createObjects,
-  dropDatabase,
-  getAgent,
-  getConfig,
-  getDbConnection,
-  getDbType,
-  resetDatabase,
-  revertMigration,
-  typeOrmDateTime,
-  typeormDate
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @public
+ */
+__exportStar(require("./agentContextUtils"), exports);
+__exportStar(require("./dataSources"), exports);
+__exportStar(require("./agentCreator"), exports);
+__exportStar(require("./objectCreator"), exports);
+__exportStar(require("./generic"), exports);
+__exportStar(require("./typeormTypes"), exports);
 //# sourceMappingURL=index.js.map