refactor: Move type and verifyIdentity into IDP function. Pass provider as using provider param.

docs/IDENTITIES.md

@@ -167,9 +167,9 @@ To use it, add it to the list of known identity providers:
 
 ```js
 import { addIdentityProvider } from '@orbitdb/core'
-import * as MyCustomIdentityProvider from 'my-custom-identity-provider'
+import MyCustomIdentityProvider from 'my-custom-identity-provider'
 addIdentityProvider(MyCustomIdentityProvider)
-const identity = await createIdentity({ type: MyCustomIdentityProvider.default(options) })
+const identity = await createIdentity({ type: MyCustomIdentityProvider(options) })
 ```
 
 where my-custom-identity-provider is the custom module.

src/identities/identities.js

@@ -10,7 +10,6 @@ import { getIdentityProvider } from './providers/index.js'
 // import EthIdentityProvider from './identity-providers/ethereum.js'
 import KeyStore, { signMessage, verifyMessage } from '../key-store.js'
 import { LRUStorage, IPFSBlockStorage, MemoryStorage, ComposedStorage } from '../storage/index.js'
-import * as PublicKeyIdentityProvider from './providers/publickey.js' 
 import pathJoin from '../utils/path-join.js'
 
 const DefaultIdentityKeysPath = pathJoin('./orbitdb', 'identities')
@@ -65,15 +64,15 @@ const Identities = async ({ keystore, path, storage, ipfs } = {}) => {
   /**
    * Creates an identity, adding it to storage.
    * @param {Object} options Various options for configuring a new identity.
-   * @param {Function} [options.type=PublicKey()] The type of provider to use for generating an identity.
+   * @param {Function} [options.provider=PublicKeyIdentityProvider()] An instance of the Provider to use for generating an identity, e.g. PublicKeyIdentityProvider({ keystore })
    * @return {module:Identities~Identity} An instance of identity.
    * @memberof module:Identities~Identities
    * @instance
    */
   const createIdentity = async (options = {}) => {
     options.keystore = keystore
-    const DefaultIdentityProviderType = PublicKeyIdentityProvider.default({ keystore })
-    const IdentityProvider = options.type || DefaultIdentityProviderType
+    const DefaultIdentityProviderType = getIdentityProvider('publickey')
+    const IdentityProvider = options.provider || DefaultIdentityProviderType({ keystore })
     const identityProvider = IdentityProvider()
     const id = await identityProvider.getId(options)
     const privateKey = await keystore.getKey(id) || await keystore.createKey(id)

src/identities/providers/index.js

@@ -1,4 +1,4 @@
-import * as PublicKeyIdentityProvider from './publickey.js'
+import PublicKeyIdentityProvider from './publickey.js'
 
 const identityProviders = {
   publickey: PublicKeyIdentityProvider

src/identities/providers/publickey.js

@@ -84,4 +84,6 @@ const PublicKeyIdentityProvider = ({ keystore }) => () => {
   }
 }
 
-export { PublicKeyIdentityProvider as default, verifyIdentity, type }
+PublicKeyIdentityProvider.verifyIdentity = verifyIdentity
+
+export default PublicKeyIdentityProvider

src/orbitdb.js

@@ -22,9 +22,9 @@ const DefaultAccessController = IPFSAccessController
  * @param {Object} params One or more parameters for configuring OrbitDB.
  * @param {IPFS} params.ipfs An IPFS instance.
  * @param {string} [params.id] The id of the user to use for this OrbitDB instance.
- * @param {module:Identity} [params.identity] An identity instance.
- * @param {Function} [params.identityProvider] An initialized identity provider. 
- * @param {module:Identities} [params.identities] An Identities system instance.
+ * @param {module:Identity|Object} [params.identity] An identity instance or an object containing an id and an Identity Provider instance.
+ * @param {String} [params.identity.id] An initialized identity provider. 
+ * @param {Function} [params.identity.provider] An initialized identity provider. 
  * @param {module:Identities} [params.identities] An Identities system instance.
  * @param {string} [params.directory] A location for storing OrbitDB data.
  * @return {module:OrbitDB~OrbitDB} An instance of OrbitDB.
@@ -54,13 +54,12 @@ const OrbitDB = async ({ ipfs, id, identity, identityProvider, identities, direc
     identities = await Identities({ ipfs, keystore })
   }
 
-  // identity takes precedence, then idP, then create from id.
-  if (!identity) {
-    if (identityProvider) {
-      identity = await identities.createIdentity({ type: identityProvider })
-    } else {
-      identity = await identities.createIdentity({ id })
+  if (identity) {
+    if (provider) {
+      identity = await identities.createIdentity({ id, provider: identityProvider })
     }
+  } else {
+    identity = await identities.createIdentity({ id })
   }
 
   const manifestStore = await ManifestStore({ ipfs })

test/identities/identities.test.js

@@ -69,7 +69,7 @@ describe('Identities', function () {
     it('Passes in an identity provider', async () => {
       const keystore = await KeyStore({ path: keysPath })
       identities = await Identities({ keystore })
-      identity = await identities.createIdentity({ id, type: PublicKeyIdentityProvider.default({ keystore }) })
+      identity = await identities.createIdentity({ id, provider: PublicKeyIdentityProvider.default({ keystore }) })
       const result = await identities.getIdentity(identity.hash)
       assert.strictEqual(result.id, identity.id)
       assert.strictEqual(result.hash, identity.hash)
@@ -230,7 +230,7 @@ describe('Identities', function () {
 
     it('false signature doesn\'t verify', async () => {
       addIdentityProvider(FakeIdentityProvider)
-      identity = await identities.createIdentity({ type: FakeIdentityProvider.default() })
+      identity = await identities.createIdentity({ provider: FakeIdentityProvider.default() })
       const verified = await identities.verifyIdentity(identity)
       assert.strictEqual(verified, false)
     })