update to new standard rules

Signed-off-by: Timo Glastra <[email protected]>

wrappers/nodejs/src/IndyError.js

@@ -1,7 +1,7 @@
-var util = require('util')
-var capi = require('./indyBinding')
+const util = require('util')
+const capi = require('./indyBinding')
 
-var errors = {
+const errors = {
   100: 'CommonInvalidParam1',
   101: 'CommonInvalidParam2',
   102: 'CommonInvalidParam3',
@@ -65,13 +65,13 @@ function IndyError (err) {
   Error.call(this)
   Error.captureStackTrace(this, this.constructor)
   this.name = this.constructor.name
-  if (errors.hasOwnProperty(err)) {
+  if (Object.prototype.hasOwnProperty.call(errors, err)) {
     this.message = errors[err]
     this.indyCode = err
     this.indyName = errors[err]
     try {
       this.indyCurrentErrorJson = capi.getCurrentError()
-      var details = JSON.parse(this.indyCurrentErrorJson)
+      const details = JSON.parse(this.indyCurrentErrorJson)
       if (typeof details.message === 'string') {
         this.indyMessage = details.message
       }

wrappers/nodejs/src/index.js

@@ -1,9 +1,9 @@
-var capi = require('./indyBinding')
-var wrapIndyCallback = require('./wrapIndyCallback')
-var IndyError = require('./IndyError')
+const capi = require('./indyBinding')
+const wrapIndyCallback = require('./wrapIndyCallback')
+const IndyError = require('./IndyError')
 
 function toJson (val) {
-  if (val === null || val === void 0) {
+  if (val === null || val === undefined) {
     return null
   }
   if (typeof val === 'string') {
@@ -22,26 +22,26 @@ function fromJson (val) {
   return val
 }
 
-var indy = {}
+const indy = {}
 
 indy.capi = capi // if you want to skip the json dance, IndyError, and promise support
 
 indy.setRuntimeConfig = function setRuntimeConfig (config) {
-  var err = capi.setRuntimeConfig(toJson(config))
+  const err = capi.setRuntimeConfig(toJson(config))
   if (err !== 0) {
     throw new IndyError(err)
   }
 }
 
 indy.setDefaultLogger = function setDefaultLogger (pattern) {
-  var err = capi.setDefaultLogger(pattern)
+  const err = capi.setDefaultLogger(pattern)
   if (err !== 0) {
     throw new IndyError(err)
   }
 }
 
 indy.setLogger = function setLogger (logFn) {
-  var err = capi.setLogger(logFn)
+  const err = capi.setLogger(logFn)
   if (err !== 0) {
     throw new IndyError(err)
   }

wrappers/nodejs/src/wrapIndyCallback.js

@@ -1,7 +1,7 @@
-var IndyError = require('./IndyError')
+const IndyError = require('./IndyError')
 
 function wrapIndyCallback (cb, mapResponse) {
-  var promise
+  let promise
   if (!cb) {
     promise = new Promise(function (resolve, reject) {
       cb = function cb (err, data) {

wrappers/nodejs/test/anoncreds.js

@@ -1,100 +1,100 @@
-var test = require('ava')
-var indy = require('../')
-var cuid = require('cuid')
-var initTestPool = require('./helpers/initTestPool')
-var tempy = require('tempy')
+const test = require('ava')
+const indy = require('../')
+const cuid = require('cuid')
+const initTestPool = require('./helpers/initTestPool')
+const tempy = require('tempy')
 
 test('anoncreds', async function (t) {
-  var pool = await initTestPool()
-  var walletConfig = { 'id': 'wallet-' + cuid() }
-  var walletCredentials = { 'key': 'key' }
+  const pool = await initTestPool()
+  const walletConfig = { id: 'wallet-' + cuid() }
+  const walletCredentials = { key: 'key' }
   await indy.createWallet(walletConfig, walletCredentials)
-  var wh = await indy.openWallet(walletConfig, walletCredentials)
-  var issuerDid = 'NcYxiDXkpYi6ov5FcYDi1e'
-  var proverDid = 'VsKV7grR1BUE29mG2Fm2kX'
+  const wh = await indy.openWallet(walletConfig, walletCredentials)
+  const issuerDid = 'NcYxiDXkpYi6ov5FcYDi1e'
+  const proverDid = 'VsKV7grR1BUE29mG2Fm2kX'
 
   // Issuer create a credential schema
-  var [schemaId, schema] = await indy.issuerCreateSchema(issuerDid, 'gvt', '1.0', ['age', 'height', 'name'])
+  const [schemaId, schema] = await indy.issuerCreateSchema(issuerDid, 'gvt', '1.0', ['age', 'height', 'name'])
   t.not(typeof schema, 'string')
 
-  var [credDefId, credDef] = await indy.issuerCreateAndStoreCredentialDef(wh, issuerDid, schema, 'tag1', 'CL', {
+  const [credDefId, credDef] = await indy.issuerCreateAndStoreCredentialDef(wh, issuerDid, schema, 'tag1', 'CL', {
     support_revocation: true
   })
   t.not(typeof credDef, 'string')
 
   // Issuer create Revocation Registry
-  var tailsWriterConfig = {
-    'base_dir': tempy.directory(),
-    'uri_pattern': ''
+  const tailsWriterConfig = {
+    base_dir: tempy.directory(),
+    uri_pattern: ''
   }
-  var tailsWriterHandle = await indy.openBlobStorageWriter('default', tailsWriterConfig)
-  var [revocRegId, revocRegDef, revocRegEntry] = await indy.issuerCreateAndStoreRevocReg(wh, issuerDid, null, 'tag1', credDefId, {
+  const tailsWriterHandle = await indy.openBlobStorageWriter('default', tailsWriterConfig)
+  const [revocRegId, revocRegDef, revocRegEntry] = await indy.issuerCreateAndStoreRevocReg(wh, issuerDid, null, 'tag1', credDefId, {
     max_cred_num: 5
   }, tailsWriterHandle)
   t.not(typeof revocRegDef, 'string')
   t.not(typeof revocRegEntry, 'string')
 
   // Prover create Master Secret
-  var masterSecretName = 'master_secret'
+  const masterSecretName = 'master_secret'
   await indy.proverCreateMasterSecret(wh, masterSecretName)
 
   // Issuer create credential Offer
-  var credOffer = await indy.issuerCreateCredentialOffer(wh, credDefId)
+  const credOffer = await indy.issuerCreateCredentialOffer(wh, credDefId)
 
   // Prover create credential Request
-  var [credReq, credReqMetadata] = await indy.proverCreateCredentialReq(wh, proverDid, credOffer, credDef, 'master_secret')
+  const [credReq, credReqMetadata] = await indy.proverCreateCredentialReq(wh, proverDid, credOffer, credDef, 'master_secret')
   t.not(typeof credReq, 'string')
   t.not(typeof credReqMetadata, 'string')
 
   // Issuer open Tails reader
-  var blobReaderHandle = await indy.openBlobStorageReader('default', tailsWriterConfig)
+  const blobReaderHandle = await indy.openBlobStorageReader('default', tailsWriterConfig)
 
   // Issuer create credential for credential Request
   // note that encoding is not standardized by Indy except that 32-bit integers are encoded as themselves. IS-786
-  var [cred, revId, revDelta] = await indy.issuerCreateCredential(wh, credOffer, credReq, {
-    name: { 'raw': 'Alex', 'encoded': '1139481716457488690172217916278103335' },
-    height: { 'raw': '175', 'encoded': '175' },
-    age: { 'raw': '28', 'encoded': '28' }
+  const [cred, revId, revDelta] = await indy.issuerCreateCredential(wh, credOffer, credReq, {
+    name: { raw: 'Alex', encoded: '1139481716457488690172217916278103335' },
+    height: { raw: '175', encoded: '175' },
+    age: { raw: '28', encoded: '28' }
   }, revocRegId, blobReaderHandle)
   t.not(typeof cred, 'string')
 
   // Prover process and store credential
-  var outCredId = await indy.proverStoreCredential(wh, 'cred_1_id', credReqMetadata, cred, credDef, revocRegDef)
+  const outCredId = await indy.proverStoreCredential(wh, 'cred_1_id', credReqMetadata, cred, credDef, revocRegDef)
   t.is(typeof outCredId, 'string')
 
   // Prover get Credential
-  var credential = await indy.proverGetCredential(wh, outCredId)
+  const credential = await indy.proverGetCredential(wh, outCredId)
   t.not(typeof credential, 'string')
   t.is(credential.schema_id, schemaId)
   t.is(credential.cred_def_id, credDefId)
 
   // Prover searches Credentials
-  var [sh, totalCount] = await indy.proverSearchCredentials(wh, { schema_id: schemaId })
+  let [sh, totalCount] = await indy.proverSearchCredentials(wh, { schema_id: schemaId })
   t.truthy(totalCount > 0)
 
-  var credentials = await indy.proverFetchCredentials(sh, totalCount)
+  let credentials = await indy.proverFetchCredentials(sh, totalCount)
   t.truthy(Array.isArray(credentials))
   t.truthy(credentials.length > 0)
   t.is(credentials[0].schema_id, schemaId)
 
   await indy.proverCloseCredentialsSearch(sh)
 
-  var nonce = await indy.generateNonce()
+  const nonce = await indy.generateNonce()
 
   // Prover gets credentials for Proof Request
-  var proofReq = {
-    'nonce': nonce,
-    'name': 'proof_req_1',
-    'version': '0.1',
-    'requested_attributes': {
-      'attr1_referent': { 'name': 'name' }
+  let proofReq = {
+    nonce: nonce,
+    name: 'proof_req_1',
+    version: '0.1',
+    requested_attributes: {
+      attr1_referent: { name: 'name' }
     },
-    'requested_predicates': {
-      'predicate1_referent': { 'name': 'age', 'p_type': '>=', 'p_value': 18 }
+    requested_predicates: {
+      predicate1_referent: { name: 'age', p_type: '>=', p_value: 18 }
     },
-    'non_revoked': { 'from': 80, 'to': 100 }
+    non_revoked: { from: 80, to: 100 }
   }
-  var credentialsForProof = await indy.proverGetCredentialsForProofReq(wh, proofReq)
+  const credentialsForProof = await indy.proverGetCredentialsForProofReq(wh, proofReq)
 
   credentials = await indy.proverGetCredentials(wh)
   t.truthy(Array.isArray(credentials))
@@ -111,87 +111,87 @@ test('anoncreds', async function (t) {
   credentials = await indy.proverFetchCredentialsForProofReq(sh, 'attr1_referent', 100)
   t.truthy(Array.isArray(credentials))
   t.truthy(credentials.length > 0)
-  t.is(credentials[0]['cred_info'].schema_id, schemaId)
+  t.is(credentials[0].cred_info.schema_id, schemaId)
 
   credentials = await indy.proverFetchCredentialsForProofReq(sh, 'predicate1_referent', 100)
   t.truthy(Array.isArray(credentials))
   t.truthy(credentials.length > 0)
-  t.is(credentials[0]['cred_info'].schema_id, schemaId)
+  t.is(credentials[0].cred_info.schema_id, schemaId)
 
   await indy.proverCloseCredentialsSearchForProofReq(sh)
 
   // Prover gets credentials for Proof Request
-  var timestamp = 100
-  var revState = await indy.createRevocationState(blobReaderHandle, revocRegDef, revDelta, timestamp, revId)
+  let timestamp = 100
+  let revState = await indy.createRevocationState(blobReaderHandle, revocRegDef, revDelta, timestamp, revId)
   t.is(revState.timestamp, 100)
 
   timestamp = 101
   revState = await indy.updateRevocationState(blobReaderHandle, revState, revocRegDef, revDelta, timestamp, revId)
   t.is(revState.timestamp, 101)
 
   // Prover create Proof for Proof Request
-  var referent = credentialsForProof['attrs']['attr1_referent'][0]['cred_info']['referent']
-  var requestedCredentials = {
-    'self_attested_attributes': {},
-    'requested_attributes': { 'attr1_referent': { 'cred_id': referent, 'revealed': true, 'timestamp': timestamp } },
-    'requested_predicates': { 'predicate1_referent': { 'cred_id': referent, 'timestamp': timestamp } }
+  const referent = credentialsForProof.attrs.attr1_referent[0].cred_info.referent
+  const requestedCredentials = {
+    self_attested_attributes: {},
+    requested_attributes: { attr1_referent: { cred_id: referent, revealed: true, timestamp: timestamp } },
+    requested_predicates: { predicate1_referent: { cred_id: referent, timestamp: timestamp } }
   }
 
-  var schemas = {}
+  const schemas = {}
   schemas[schemaId] = schema
 
-  var credentialDefs = {}
+  const credentialDefs = {}
   credentialDefs[credDefId] = credDef
 
-  var revocStates = {}
+  const revocStates = {}
   revocStates[revocRegId] = {}
   revocStates[revocRegId][timestamp] = revState
 
-  var proof = await indy.proverCreateProof(wh, proofReq, requestedCredentials, masterSecretName, schemas, credentialDefs, revocStates)
+  const proof = await indy.proverCreateProof(wh, proofReq, requestedCredentials, masterSecretName, schemas, credentialDefs, revocStates)
 
   // Verify the proof
-  t.is(proof['requested_proof']['revealed_attrs']['attr1_referent']['raw'], 'Alex')
+  t.is(proof.requested_proof.revealed_attrs.attr1_referent.raw, 'Alex')
 
-  var revocRefDefs = {}
+  const revocRefDefs = {}
   revocRefDefs[revocRegId] = revocRegDef
 
-  var revocRegs = {}
+  const revocRegs = {}
   revocRegs[revocRegId] = {}
   revocRegs[revocRegId][timestamp] = revDelta
 
-  var isValid = await indy.verifierVerifyProof(proofReq, proof, schemas, credentialDefs, revocRefDefs, revocRegs)
+  const isValid = await indy.verifierVerifyProof(proofReq, proof, schemas, credentialDefs, revocRefDefs, revocRegs)
   t.is(isValid, true)
 
   // Revoke the credential
-  var revocedDelta = await indy.issuerRevokeCredential(wh, blobReaderHandle, revocRegId, revId)
+  const revocedDelta = await indy.issuerRevokeCredential(wh, blobReaderHandle, revocRegId, revId)
 
   await indy.issuerMergeRevocationRegistryDeltas(revDelta, revocedDelta)
 
   // Verify the proof with changed requested predicate value
   proofReq = {
-    'nonce': nonce,
-    'name': 'proof_req_1',
-    'version': '0.1',
-    'requested_attributes': {
-      'attr1_referent': { 'name': 'name' }
+    nonce: nonce,
+    name: 'proof_req_1',
+    version: '0.1',
+    requested_attributes: {
+      attr1_referent: { name: 'name' }
     },
-    'requested_predicates': {
-      'predicate1_referent': { 'name': 'age', 'p_type': '>=', 'p_value': 50 } // requested value is greater than actual (28)
+    requested_predicates: {
+      predicate1_referent: { name: 'age', p_type: '>=', p_value: 50 } // requested value is greater than actual (28)
     },
-    'non_revoked': { 'from': 80, 'to': 100 }
+    non_revoked: { from: 80, to: 100 }
   }
-  var err = await t.throwsAsync(
+  let err = await t.throwsAsync(
     indy.verifierVerifyProof(proofReq, proof, schemas, credentialDefs, revocRefDefs, revocRegs))
   t.is(err.indyName, 'AnoncredsProofRejected')
 
   // Rotate credential definition
-  var tempCredDef = await indy.issuerRotateCredentialDefStart(wh, credDefId, null)
+  const tempCredDef = await indy.issuerRotateCredentialDefStart(wh, credDefId, null)
   t.not(cred, tempCredDef)
 
   await indy.issuerRotateCredentialDefApply(wh, credDefId)
 
-  var qualified = 'did:sov:NcYxiDXkpYi6ov5FcYDi1e'
-  var unqualified = 'NcYxiDXkpYi6ov5FcYDi1e'
+  const qualified = 'did:sov:NcYxiDXkpYi6ov5FcYDi1e'
+  const unqualified = 'NcYxiDXkpYi6ov5FcYDi1e'
   t.is(unqualified, await indy.toUnqualified(qualified))
   t.is(unqualified, await indy.toUnqualified(unqualified))
 

wrappers/nodejs/test/blob.js

@@ -1,22 +1,22 @@
-var test = require('ava')
-var indy = require('../')
-var tempy = require('tempy')
+const test = require('ava')
+const indy = require('../')
+const tempy = require('tempy')
 
 test('blob_storage', async function (t) {
-  var config = {
-    'base_dir': tempy.directory(),
-    'uri_pattern': ''
+  const config = {
+    base_dir: tempy.directory(),
+    uri_pattern: ''
   }
 
-  var wh = await indy.openBlobStorageWriter('default', config)
+  const wh = await indy.openBlobStorageWriter('default', config)
   t.is(typeof wh, 'number')
   t.truthy(wh >= 0)
 
-  var rh = await indy.openBlobStorageReader('default', config)
+  const rh = await indy.openBlobStorageReader('default', config)
   t.is(typeof rh, 'number')
   t.truthy(rh >= 0)
 
-  var error = await t.throwsAsync(indy.openBlobStorageWriter('foo', config))
+  let error = await t.throwsAsync(indy.openBlobStorageWriter('foo', config))
   t.is(error.indyName, 'CommonInvalidStructure')
 
   error = await t.throwsAsync(indy.openBlobStorageWriter('default', null))