@selfkey/node-lib v1.2.2

@selfkey/node-lib

Selfkey sdk for third party integrations written in Node.js

Contents

• Install
• Usage
• API
• Examples
• License

Install

Requires Node version 10 or above

npm install --save @selfkey/node-lib

Usage

const sk = require('@selfkey/node-lib');

or ES6 syntax

import sk from '@selfkey/node-lib';

API

Modules

auth/generate-access-token

auth/generate-access-token~generateAccessToken(did, algorithm, secret, [expiresIn]) ⇒ Promise.<string>

Generate access token

Kind: inner method of auth/generate-access-token
Returns: Promise.<string> - jwtToken

Example

await sk.auth.generateAccessToken(did, 'rsa', 'secret')

auth/generate-challenge-token

auth/generate-challenge-token~generateChallengeToken(did, algorithm, secret, [expiresIn]) ⇒ Promise.<string>

Generate challenge token

Kind: inner method of auth/generate-challenge-token
Returns: Promise.<string> - jwtToken

Example

await sk.auth.generateChallengeToken(did, 'rsa', 'secret')

auth/generate-nonce

auth/generate-nonce~generateNonce([length]) ⇒ Promise.<string>

Generates base64 encoded random string

Kind: inner method of auth/generate-nonce
Returns: Promise.<string> - nonce

Example

await sk.auth.generateNonce();

auth/validate-access-token

auth/validate-access-token~validateAccessToken(token, algorithm, key) ⇒ Promise.<object>

Validates access token

Kind: inner method of auth/validate-access-token
Returns: Promise.<object> - decodedToken
Throws:

• If token is invalid
• if subject is not did
• if token type is not access

Example

await sk.auth.validateAccessToken(token, 'hmac', 'secret');

auth/validate-challenge-token

auth/validate-challenge-token~validateChallengeToken(token, algorithm, key) ⇒ Promise.<object>

Validates challenge token

Kind: inner method of auth/validate-challenge-token
Returns: Promise.<object> - decodedToken
Throws:

• If token is invalid
• if subject is not did
• if token type is not challenge

Example

await sk.auth.validateChallengeToken(token, 'hmac', 'secret');

auth/verify-challenge-signature

auth/verify-challenge-signature~verifyChallengeSignature(nonce, signature, did) ⇒ Promise.<boolean>

Validates challenge Signature

Kind: inner method of auth/verify-challenge-signature
Returns: Promise.<boolean> - is valid signature
Throws:

• key not found in resolved did document
• if no registered verifier for that key type

Example

await sk.auth.verifyChallengeSignature(nonce, signature, did);

did/parse

did/parse~parse(did) ⇒ object

Parses did string to components

Kind: inner method of did/parse
Returns: object - parsedDid
Throws:

• if invalid did is provided

Example

sk.did.parse('did:selfkey:0xdsdasddasdsa...');

did/resolver

• did/resolver
  • ~resolvers : object
  • ~isSupported(did) ⇒ boolean
  • ~resolve(did) ⇒ object
  • ~registerMethodResolver(method, resolver)

did/resolver~resolvers : object

Kind: inner constant of did/resolver
Properties

did/resolver~isSupported(did) ⇒ boolean

Checks if a resolver exists for that particular did

Kind: inner method of did/resolver
Returns: boolean - isSuppored

Example

sk.did.isSupported('did:selfkey:0xdsdasddasdsa...'); // true
sk.did.isSupported('did:eth:0xdsdasddasdsa...'); // true
sk.did.isSupported('did:unknown:0xdsdasddasdsa...'); // false

did/resolver~resolve(did) ⇒ object

Resolves did document

Kind: inner method of did/resolver
Returns: object - didDocument

Example

await sk.did.resolve('did:selfkey:0xdsdasddasdsa...');

did/resolver~registerMethodResolver(method, resolver)

Register custom resolver for a did method

Kind: inner method of did/resolver

Example

sk.did.register('new-method', resolver);

identity/attribute-manager

• identity/attribute-manager
  • static
    • .AttributeManager
      • new exports.AttributeManager()
      • instance
        • .addRepository(repository)
        • .removeRepository(repository)
        • .findRepositoryForAttribute(attr) ⇒ identity.Repository | null
        • .zipAttributesWithRequirements(attributes, [requirements]) ⇒ Array
        • .validateOneAttribute(attr, requirement) ⇒ object
        • .validateAttributes(attributes, requirements) ⇒ object
      • static
        • .createWithSelfkeyRepository(options) ⇒ AttributeManager
  • inner
    • ~AttributeManager

identity/attribute-manager.AttributeManager

Kind: static class of identity/attribute-manager

• .AttributeManager
  • new exports.AttributeManager()
  • instance
    • .addRepository(repository)
    • .removeRepository(repository)
    • .findRepositoryForAttribute(attr) ⇒ identity.Repository | null
    • .zipAttributesWithRequirements(attributes, [requirements]) ⇒ Array
    • .validateOneAttribute(attr, requirement) ⇒ object
    • .validateAttributes(attributes, requirements) ⇒ object
  • static
    • .createWithSelfkeyRepository(options) ⇒ AttributeManager

new exports.AttributeManager()

Creates an instance of AttributeManager.

attributeManager.addRepository(repository)

Adds a new repository

Kind: instance method of AttributeManager

attributeManager.removeRepository(repository)

Remove a repository

Kind: instance method of AttributeManager

attributeManager.findRepositoryForAttribute(attr) ⇒ identity.Repository | null

Finds a repository for a given attribute

Kind: instance method of AttributeManager

attributeManager.zipAttributesWithRequirements(attributes, [requirements]) ⇒ Array

Given an array of attributes and requirements, tries to much between them

Kind: instance method of AttributeManager

attributeManager.validateOneAttribute(attr, requirement) ⇒ object

Given an attribute and requirement validates the attribute

Kind: instance method of AttributeManager

attributeManager.validateAttributes(attributes, requirements) ⇒ object

Given a list of attribute and requirements, validates all attributes

Kind: instance method of AttributeManager

AttributeManager.createWithSelfkeyRepository(options) ⇒ AttributeManager

Creates an AttributeManager and initializes it with selfkey repository

Kind: static method of AttributeManager

identity/attribute-manager~AttributeManager

Attribute Manager, manages multiple repositories of attributes

Kind: inner class of identity/attribute-manager

identity/repository

• identity/repository
  • static
    • .Repository
      • new exports.Repository([config])
      • instance
        • .resolveAll()
        • .resolveJsonSchema(schema, [config]) ⇒ object
        • .resolveUiSchema(schema, [config]) ⇒ object
        • .getValidator() ⇒
        • .validateData(schemaId, data) ⇒ object
      • static
        • .createSelfkeyRepo([options]) ⇒ Repository
        • .fromConfig(config, [ui]) ⇒ Repository
        • .fromSchemaId(schemaId, [ui]) ⇒ Repository
  • inner
    • ~Repository

identity/repository.Repository

Kind: static class of identity/repository

• .Repository
  • new exports.Repository([config])
  • instance
    • .resolveAll()
    • .resolveJsonSchema(schema, [config]) ⇒ object
    • .resolveUiSchema(schema, [config]) ⇒ object
    • .getValidator() ⇒
    • .validateData(schemaId, data) ⇒ object
  • static
    • .createSelfkeyRepo([options]) ⇒ Repository
    • .fromConfig(config, [ui]) ⇒ Repository
    • .fromSchemaId(schemaId, [ui]) ⇒ Repository

new exports.Repository([config])

Creates an instance of Repository.

repository.resolveAll()

Resolve all repository data

Kind: instance method of Repository

repository.resolveJsonSchema(schema, [config]) ⇒ object

Resolve one JSON schema

Kind: instance method of Repository

repository.resolveUiSchema(schema, [config]) ⇒ object

Resolve one ui schema

Kind: instance method of Repository

repository.getValidator() ⇒

Creates an Ajv validator for the repository data

Kind: instance method of Repository
Returns: Ajv instance

repository.validateData(schemaId, data) ⇒ object

Given schemaId and data, validates the data based on relevant schema

Kind: instance method of Repository
Returns: object - {valid:boolean, errors: array}

Repository.createSelfkeyRepo([options]) ⇒ Repository

Creates a repository initialized with selfkey data

Kind: static method of Repository

Repository.fromConfig(config, [ui]) ⇒ Repository

Creates and preloads a Repository from a config object

Kind: static method of Repository

Repository.fromSchemaId(schemaId, [ui]) ⇒ Repository

Creates and preloads a Repository based on attribute schema id

Kind: static method of Repository

identity/repository~Repository

Repository Class allows to load identity attribute repository and validate schemas

Part of identity namespace

Kind: inner class of identity/repository

identity/utils

• identity/utils
  • ~attributeMapBySchema(attributes) ⇒ object
  • ~resolveAttributeFiles(all, fileProcessor) ⇒ object
  • ~denormalizeDocumentsSchema(typeSchema, value, documents, maxDepth) ⇒ object
  • ~normalizeDocumentsSchema(typeSchema, value, documents, maxDepth) ⇒ object
  • ~schemaContainsFile(schema, maxDepth) ⇒ boolean
  • ~fetchJson(url, options) ⇒ Promise.<object>
  • ~dereferenceSchema(schema, options) ⇒ Promise.<object>

identity/utils~attributeMapBySchema(attributes) ⇒ object

Map list of attributes to schema name

Kind: inner method of identity/utils
Returns: object - an object with attribute name as keys

identity/utils~resolveAttributeFiles(all, fileProcessor) ⇒ object

Given a attribute data object and a file processor, process all files in the data object

Kind: inner method of identity/utils
Returns: object - a new attribute data object with processed files

identity/utils~denormalizeDocumentsSchema(typeSchema, value, documents, maxDepth) ⇒ object

Given a attribute data object and an array of documents, insert the documents into the data object where they are referenced from

Kind: inner method of identity/utils

identity/utils~normalizeDocumentsSchema(typeSchema, value, documents, maxDepth) ⇒ object

Given a attribute data object export all documents from the object to a separate array, leaving documnent references behind

Kind: inner method of identity/utils

identity/utils~schemaContainsFile(schema, maxDepth) ⇒ boolean

Check if schema contains a file

Kind: inner method of identity/utils

identity/utils~fetchJson(url, options) ⇒ Promise.<object>

Fetch json from remote server. Optionally specify max number of attempts to do on failure (3 by default)

Kind: inner method of identity/utils
Returns: Promise.<object> - json loaded from server

Example

async sk.identity.utils.fetchJson('http://platform.selfkey.org/schema/attribute/first-name.json', {maxAttempts: 10});

identity/utils~dereferenceSchema(schema, options) ⇒ Promise.<object>

Given a scheme object, load all references from the schema And combine into one json schema object

Kind: inner method of identity/utils
Returns: Promise.<object> - dereferences json schema object

jwt/constants

jwt/issue

jwt/issue~issueJWT(subject, requestedAlgorithm, secret, [expiresIn], additionalClaims) ⇒ Promise.<string>

Issue a new JWT token

Kind: inner method of jwt/issue
Returns: Promise.<string> - jwt
Throws:

• if unknown algorithm provided
• if secret deemed as not secure enough

Example

sk.jwt.issueJWT('simple-session', 'hmac', 'test');

jwt/parse

jwt/parse~parseJWT(token) ⇒ object

Parse a JWT token

Kind: inner method of jwt/parse
Returns: object - decodedJwt

Example

sk.jwt.parseJWT(token);

jwt/validate

jwt/validate~validateJWT(token, requestedAlgorithm, key) ⇒ Promise.<(object|null)>

Validate a JWT token

Kind: inner method of jwt/validate
Returns: Promise.<(object|null)> - decodedJwt
Throws:

• if unknown algorithm provided

Example

sk.jwt.validateJWT(token, 'hmac', key);

key/hmac

• key/hmac
  • ~generateHMACKey([length], [encoding]) ⇒ Promise.<(string|Buffer)>
  • ~generateHMACKey(secret, [encoding]) ⇒

key/hmac~generateHMACKey([length], [encoding]) ⇒ Promise.<(string|Buffer)>

Generate a HMAC Key

Kind: inner method of key/hmac
Returns: Promise.<(string|Buffer)> - key

Example

sk.key.generateHMACKey();

key/hmac~generateHMACKey(secret, [encoding]) ⇒

Calculate the bytes length of secret key

Kind: inner method of key/hmac
Returns: number

Example

sk.key.getSecretLength(secret);

key/rsa

key/rsa~generateRSAKeyPair([length]) ⇒ Promise.<object>

Generate a RSA Key Pair

Kind: inner method of key/rsa
Returns: Promise.<object> - keypair - contains publicKey adn privateKey

Example

sk.key.generateRSAKeyPair();

key/validate-private-key

key/validate-private-key~checkSecretLength(key, algorithm) ⇒ boolean

Checks if secret length is good enough

Kind: inner method of key/validate-private-key
Returns: boolean - - isKeyLongEnough

Example

sk.key.checkSecretLength();

kycc/get-user-data-for-token

• kycc/get-user-data-for-token
  • ~getUserDataForToken(token, options) ⇒ Promise.<KYCCUserObject>
  • ~FileProcessor
  • ~GetUserDataForTokenOptions
  • ~KYCCUserObject

kycc/get-user-data-for-token~getUserDataForToken(token, options) ⇒ Promise.<KYCCUserObject>

Fetch user data via token

Kind: inner method of kycc/get-user-data-for-token
Returns: Promise.<KYCCUserObject> - user object
Throws:

• if no instanceUrl in options
• if no templateId in options
• if invalid token
• if invalid user for token

Example

async sk.kycc.getUserDataForToken(token, options);

kycc/get-user-data-for-token~FileProcessor

File Processor

Kind: inner typedef of kycc/get-user-data-for-token
Properties

Example

{ stream: false, process: (file, id) => file }

kycc/get-user-data-for-token~GetUserDataForTokenOptions

Options used in getUserDataForToken function

Kind: inner typedef of kycc/get-user-data-for-token
Properties

kycc/get-user-data-for-token~KYCCUserObject

User Object

Kind: inner typedef of kycc/get-user-data-for-token
Properties

Example

{
	id: '5ddd5b1656fbcef0dd389637',
	attributes: {
		firstName: {
			id: '5d076f0a315423134405cbc4',
			label: 'First Name',
			required: true,
			schema: 'http://platform.selfkey.org/schema/attribute/first-name.json',
			valid: true,
			value: 'first-name'
		},
		lastName: {
			label: 'Last Name',
			id: '5d076f20315423f5db05cbc6',
			required: true,
			schema: 'http://platform.selfkey.org/schema/attribute/last-name.json',
			valid: true,
			value: 'last-name'
		},
		email: {
			id: '5d13577f72089544cb86cda7',
			label: 'Email Address',
			required: true,
			schema: 'http://platform.selfkey.org/schema/attribute/email.json',
			valid: true,
			value: 'test-4952@test.com'
		},
	}

kycc/kycc-integrations-client

• kycc/kycc-integrations-client
  • ~listUsersFn(filters, fields) ⇒ Promise.<Array.<KYCCUser>>
  • ~getUserFn(userId, fields) ⇒ Promise.<KYCCUser>
  • ~listApplicationsFn(filters, fields) ⇒ Promise.<Array.<KYCCApplication>>
  • ~getApplicationFn(applicationID, fields) ⇒ Promise.<KYCCApplication>
  • ~changeApplicationStatusFn(applicationID, statusCode, note) ⇒ Promise.<KYCCApplication>
  • ~invalidateApplicationAttributesFn(applicationID, attributes) ⇒ Promise.<string>
  • ~invalidateApplicationQuestionsFn(applicationID, questions) ⇒ Promise.<string>
  • ~addApplicationQuestionFn(applicationID, question) ⇒ Promise.<string>
  • ~addApplicationAttributeFn(applicationID, attribute) ⇒ Promise.<string>
  • ~applicationAddAttachment(applicationId, attachmentType, attachment) ⇒ Promise.<string>
  • ~updateApplicationFn(applicationID, update) ⇒ Promise.<KYCCApplication>
  • ~getFileFn(fileId, options) ⇒ Promise.<KYCCApplicationFile>
  • ~createClient(options) ⇒ KYCCIntegrationsApiClient
  • ~KYCCQuestion
  • ~KYCCAttribute
  • ~Document
  • ~KYCCApplication
  • ~KYCCIntegrationsApiClient ⇒ Array.<KYCCApplication>
  • ~KYCCIntegrationsApiOptions : Object

kycc/kycc-integrations-client~listUsersFn(filters, fields) ⇒ Promise.<Array.<KYCCUser>>

Kind: inner method of kycc/kycc-integrations-client
Returns: Promise.<Array.<KYCCUser>> - users

Example

const users = await kyccClient.users.list();

kycc/kycc-integrations-client~getUserFn(userId, fields) ⇒ Promise.<KYCCUser>

Kind: inner method of kycc/kycc-integrations-client
Returns: Promise.<KYCCUser> - user

Example

const user = await kyccClient.users.get("asdasdasdas");

kycc/kycc-integrations-client~listApplicationsFn(filters, fields) ⇒ Promise.<Array.<KYCCApplication>>

Kind: inner method of kycc/kycc-integrations-client
Returns: Promise.<Array.<KYCCApplication>> - applications

Example

const applications = await kyccClient.applications.list({templateId: 'sdasdasdsaa'}, ['managers', 'currentStatus']);

kycc/kycc-integrations-client~getApplicationFn(applicationID, fields) ⇒ Promise.<KYCCApplication>

Kind: inner method of kycc/kycc-integrations-client
Returns: Promise.<KYCCApplication> - application

Example

const application = await kyccClient.applications.get("asdasdasdas");

kycc/kycc-integrations-client~changeApplicationStatusFn(applicationID, statusCode, note) ⇒ Promise.<KYCCApplication>

Kind: inner method of kycc/kycc-integrations-client
Returns: Promise.<KYCCApplication> - updated application

Example

const application = await kyccClient.applications.changeStatus("asdasdasdas", 8, 'testing status change');

kycc/kycc-integrations-client~invalidateApplicationAttributesFn(applicationID, attributes) ⇒ Promise.<string>

Kind: inner method of kycc/kycc-integrations-client
Returns: Promise.<string> - OK/Error

Example

await kyccClient.applications.attributes.invalidate("asdasdasdas", ["sdasdasdsa", "dsadasdasdasd"]);

kycc/kycc-integrations-client~invalidateApplicationQuestionsFn(applicationID, questions) ⇒ Promise.<string>

Kind: inner method of kycc/kycc-integrations-client
Returns: Promise.<string> - OK/Error

Example

await kyccClient.applications.questions.invalidate("asdasdasdas", ["sdasdasdsa", "dsadasdasdasd"]);

kycc/kycc-integrations-client~addApplicationQuestionFn(applicationID, question) ⇒ Promise.<string>

Kind: inner method of kycc/kycc-integrations-client
Returns: Promise.<string> - Created/Error

Example

await kyccClient.applications.questions.add("asdasdasdas", {
 description: "test question",
 label: 'test',
 question: 'what would you say about test?'
 optional: false
});

kycc/kycc-integrations-client~addApplicationAttributeFn(applicationID, attribute) ⇒ Promise.<string>

Kind: inner method of kycc/kycc-integrations-client
Returns: Promise.<string> - Created/Error

Example

await kyccClient.applications.attributes.add("asdasdasdas", {
 description: "test attribute",
 label: 'test',
 schema: 'http://platform.selfkey.org/schema/attribute/fingerprint.json'
 optional: false
});

kycc/kycc-integrations-client~applicationAddAttachment(applicationId, attachmentType, attachment) ⇒ Promise.<string>

Kind: inner method of kycc/kycc-integrations-client
Returns: Promise.<string> - Created/Error

Example

await kyccClient.applications.attachments.add("sdasdasda", "credential", {
  buffer: Buffer.from('text file value', 'utf8'),
  mimeType: 'text/plain',
  filename: 'credential.txt'
});

kycc/kycc-integrations-client~updateApplicationFn(applicationID, update) ⇒ Promise.<KYCCApplication>

Kind: inner method of kycc/kycc-integrations-client
Returns: Promise.<KYCCApplication> - updated application

Example

await kyccClient.applications.update("asdasdasdas", {
 attributes: {
		"sdasdasdsa": { value: 'updated value' }
	}
});

kycc/kycc-integrations-client~getFileFn(fileId, options) ⇒ Promise.<KYCCApplicationFile>

Kind: inner method of kycc/kycc-integrations-client
Returns: Promise.<KYCCApplicationFile> - file contents

Example

await kyccClient.files.get("asdasdasdas");

kycc/kycc-integrations-client~createClient(options) ⇒ KYCCIntegrationsApiClient

Create KYC-Chain integrations api client

Kind: inner method of kycc/kycc-integrations-client

Example

const kyccClient = async sk.kycc.createKYCCIntegrationsClient(options);

kycc/kycc-integrations-client~KYCCQuestion

Kind: inner typedef of kycc/kycc-integrations-client
Properties

kycc/kycc-integrations-client~KYCCAttribute

Kind: inner typedef of kycc/kycc-integrations-client
Properties

kycc/kycc-integrations-client~Document

Kind: inner typedef of kycc/kycc-integrations-client
Properties

kycc/kycc-integrations-client~KYCCApplication

KYC-Chain application object

Kind: inner typedef of kycc/kycc-integrations-client

kycc/kycc-integrations-client~KYCCIntegrationsApiClient ⇒ Array.<KYCCApplication>

KYC-Chain integrations api client

Kind: inner typedef of kycc/kycc-integrations-client
Properties

Example

const applicationId = "some application id";
const application = await kyccClient.applications.get(applicationId);
await kyccClient.applications.changeStatus(applicationId, kyccClient.statuses.APPROVED);

kycc/kycc-integrations-client~KYCCIntegrationsApiOptions : Object

Options used in createKYCCIntegrationsClient function

Kind: inner typedef of kycc/kycc-integrations-client
Properties

Examples

• Login with Selfkey for kycc user https://github.com/SelfKeyFoundation/relying-party-kycc-demo
• Login with Selfkey for direct integrations https://github.com/SelfKeyFoundation/relying-party-direct-demo
• Marketplace integrations with kycc as middleware https://github.com/SelfKeyFoundation/relying-party-mp-kycc-demo

License

The GPL-3.0 License

Copyright (c) 2018 SelfKey Foundation https://selfkey.org/