@wishknish/knishio-client-js 0.5.2 → 0.6.1

package/src/libraries/strings.js

@@ -1,27 +1,21 @@
-import bigInt from 'big-integer';
-import Hex from './Hex';
-import {
-  decode as decodeBase64,
-  encode as encodeBase64
-} from '@stablelib/base64';
-import getRandomValues from 'get-random-values';
-
-if ( !String.prototype.trim ) {
+import Hex from './Hex'
+
+if (!String.prototype.trim) {
   String.prototype.trim = function () {
-    return this.replace( /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '' );
-  };
+    return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '')
+  }
 }
 
-if ( !String.prototype.toCamelCase ) {
+if (!String.prototype.toCamelCase) {
   String.prototype.toCamelCase = function () {
-    return this.toLowerCase().replace( /[^a-zA-Z0-9]+(.)/g, ( m, chr ) => chr.toUpperCase() );
-  };
+    return this.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, (m, chr) => chr.toUpperCase())
+  }
 }
 
-if ( !String.prototype.toSnakeCase ) {
+if (!String.prototype.toSnakeCase) {
   String.prototype.toSnakeCase = function () {
-    return this.replace( /[A-Z]/g, letter => `_${ letter.toLowerCase() }` );
-  };
+    return this.replace(/[A-Z]/g, letter => `_${ letter.toLowerCase() }`)
+  }
 }
 
 /**
@@ -31,16 +25,15 @@ if ( !String.prototype.toSnakeCase ) {
  * @param size
  * @return {any[]}
  */
-export function chunkSubstr ( str, size ) {
-
-  const numChunks = Math.ceil( str.length / size ),
-    chunks = [];
+export function chunkSubstr (str, size) {
+  const numChunks = Math.ceil(str.length / size)
+  const chunks = []
 
-  for ( let chunkIndex = 0, o = 0; chunkIndex < numChunks; ++chunkIndex, o += size ) {
-    chunks[ chunkIndex ] = str.substr( o, size );
+  for (let chunkIndex = 0, o = 0; chunkIndex < numChunks; ++chunkIndex, o += size) {
+    chunks[chunkIndex] = str.substr(o, size)
   }
 
-  return chunks;
+  return chunks
 }
 
 /**
@@ -50,78 +43,52 @@ export function chunkSubstr ( str, size ) {
  * @param alphabet
  * @return {string}
  */
-export function randomString ( length = 256, alphabet = 'abcdef0123456789' ) {
-
-  let array = new Uint8Array( length );
+export function randomString (length = 256, alphabet = 'abcdef0123456789') {
+  let array = new Uint8Array(length)
 
-  array = getRandomValues( array );
+  array = crypto.getRandomValues(array)
 
-  array = array.map( x => alphabet.charCodeAt( x % alphabet.length ) );
+  array = array.map(x => alphabet.charCodeAt(x % alphabet.length))
 
-  return String.fromCharCode.apply( null, array );
+  return String.fromCharCode.apply(null, array)
 }
 
 /**
  * Convert charset between bases and alphabets
  *
  * @param src
- * @param fromBase
- * @param toBase
- * @param srcSymbolTable
- * @param destSymbolTable
+ * @param {int} fromBase
+ * @param {int} toBase
+ * @param { string} srcSymbolTable
+ * @param {string} destSymbolTable
  * @return {boolean|string|number}
  */
-export function charsetBaseConvert ( src, fromBase, toBase, srcSymbolTable, destSymbolTable ) {
-
-  // From: convert.js: http://rot47.net/_js/convert.js
-  //	http://rot47.net
-  //	http://helloacm.com
-  //	http://codingforspeed.com
-  //	Dr Zhihua Lai
-  //
-  // Modified by MLM to work with BigInteger: https://github.com/peterolson/BigInteger.js
-  // This is able to convert extremely large numbers; At any base equal to or less than the symbol table length
-
-  // The reasoning behind capital first is because it comes first in an ASCII/Unicode character map
-  // 96 symbols support up to base 96
-  const baseSymbols = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~`!@#$%^&*()-_=+[{]}\\|;:\'",<.>/?¿¡';
-
-  // Default the symbol table to a nice default table that supports up to base 96
-  srcSymbolTable = srcSymbolTable ? srcSymbolTable : baseSymbols;
-  // Default the desttable equal to the srctable if it isn't defined
-  destSymbolTable = destSymbolTable ? destSymbolTable : srcSymbolTable;
-
-  // Make sure we are not trying to convert out of the symbol table range
-  if ( fromBase > srcSymbolTable.length || toBase > destSymbolTable.length ) {
-
-    console.warn( 'Strings::charsetBaseConvert() - Can\'t convert', src, 'to base', toBase, 'greater than symbol table length. src-table:', srcSymbolTable.length, 'dest-table:', destSymbolTable.length );
-    return false;
+export function charsetBaseConvert (src, fromBase, toBase, srcSymbolTable, destSymbolTable) {
+  const baseSymbols = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz~`!@#$%^&*()-_=+[{]}\\|;:\'",<.>/?¿¡'
+  srcSymbolTable = srcSymbolTable || baseSymbols
+  destSymbolTable = destSymbolTable || srcSymbolTable
+
+  if (fromBase > srcSymbolTable.length || toBase > destSymbolTable.length) {
+    console.warn('Strings::charsetBaseConvert() - Can\'t convert', src, 'to base', toBase, 'greater than symbol table length. src-table:', srcSymbolTable.length, 'dest-table:', destSymbolTable.length)
+    return false
   }
 
-  // First convert to base 10
-  let val = bigInt( 0 );
-
-  for ( let charIndex = 0; charIndex < src.length; charIndex++ ) {
-    val = val.multiply( fromBase ).add( srcSymbolTable.indexOf( src.charAt( charIndex ) ) );
-  }
-
-  if ( val.lesser( 0 ) ) {
-    return 0;
+  // Convert from source base to BigInt in base 10
+  let val = BigInt(0)
+  for (let charIndex = 0; charIndex < src.length; charIndex++) {
+    val = val * BigInt(fromBase) + BigInt(srcSymbolTable.indexOf(src.charAt(charIndex)))
   }
 
-  // Then covert to any base
-  let r = val.mod( toBase ),
-    res = destSymbolTable.charAt( r ),
-    q = val.divide( toBase );
-
-  while ( !q.equals( 0 ) ) {
-
-    r = q.mod( toBase );
-    q = q.divide( toBase );
-    res = destSymbolTable.charAt( r ) + res;
+  // Convert from BigInt in base 10 to destination base
+  let res = ''
+  while (val > 0) {
+    const r = val % BigInt(toBase)
+    res = destSymbolTable.charAt(Number(r)) + res
+    val /= BigInt(toBase)
   }
 
-  return res;
+  // If the result is empty, it means the source was 0
+  return res || '0'
 }
 
 /**
@@ -130,8 +97,8 @@ export function charsetBaseConvert ( src, fromBase, toBase, srcSymbolTable, dest
  * @param byteArray
  * @return {string}
  */
-export function bufferToHexString ( byteArray ) {
-  return Hex.toHex( byteArray, {} );
+export function bufferToHexString (byteArray) {
+  return Hex.toHex(byteArray, {})
 }
 
 /**
@@ -140,8 +107,8 @@ export function bufferToHexString ( byteArray ) {
  * @param hexString
  * @return {Uint8Array}
  */
-export function hexStringToBuffer ( hexString ) {
-  return Hex.toUint8Array( hexString );
+export function hexStringToBuffer (hexString) {
+  return Hex.toUint8Array(hexString)
 }
 
 /**
@@ -150,8 +117,8 @@ export function hexStringToBuffer ( hexString ) {
  * @param string
  * @return {string}
  */
-export function hexToBase64 ( string ) {
-  return encodeBase64( Hex.toUint8Array( string ) );
+export function hexToBase64 (string) {
+  return Buffer.from(string, 'hex').toString('base64')
 }
 
 /**
@@ -160,22 +127,22 @@ export function hexToBase64 ( string ) {
  * @param {string} string
  * @return {string}
  */
-export function base64ToHex ( string ) {
-  return Hex.toHex( decodeBase64( string ), {} );
+export function base64ToHex (string) {
+  return Buffer.from(string, 'base64').toString('hex')
 }
 
 /**
  * @param {string} str
  * @return {boolean}
  */
-export function isHex ( str ) {
-  return /^[A-F0-9]+$/i.test( str );
+export function isHex (str) {
+  return /^[A-F0-9]+$/i.test(str)
 }
 
 /**
  * @param {string} str
  * @return {boolean}
  */
-export function isNumeric( str ) {
-  return (typeof(str) === 'number' || typeof(str) === 'string' && str.trim() !== '') && !isNaN(str);
+export function isNumeric (str) {
+  return (typeof (str) === 'number' || (typeof (str) === 'string' && str.trim() !== '')) && !isNaN(str)
 }

package/src/libraries/urql/UrqlClientWrapper.js

@@ -0,0 +1,166 @@
+import {
+  createClient,
+  subscriptionExchange,
+  cacheExchange,
+  fetchExchange
+} from '@urql/core'
+import { createClient as createWSClient } from 'graphql-ws'
+import { pipe, map } from 'wonka'
+
+class UrqlClientWrapper {
+  constructor ({ serverUri, socket = null, encrypt = false }) {
+    this.$__client = this.createUrqlClient({ serverUri, socket, encrypt })
+    this.$__authToken = ''
+    this.$__pubkey = null
+    this.$__wallet = null
+    this.serverUri = serverUri
+    this.soketi = socket
+    this.cipherLink = !!encrypt
+    this.$__subscriptionManager = new Map()
+  }
+
+  createUrqlClient ({ serverUri, socket, encrypt }) {
+    const exchanges = [cacheExchange, fetchExchange]
+
+    // Add subscription support if socket is configured
+    if (socket && socket.socketUri) {
+      const wsClient = createWSClient({
+        url: socket.socketUri,
+        connectionParams: () => ({
+          authToken: this.$__authToken
+        })
+      })
+
+      exchanges.push(subscriptionExchange({
+        forwardSubscription: operation => ({
+          subscribe: sink => {
+            const disposable = wsClient.subscribe(operation, sink)
+            return { unsubscribe: disposable }
+          }
+        })
+      }))
+    }
+
+    return createClient({
+      url: serverUri,
+      exchanges,
+      fetchOptions: () => ({
+        headers: {
+          'X-Auth-Token': this.$__authToken
+        }
+      })
+    })
+  }
+
+  setAuthData ({ token, pubkey, wallet }) {
+    this.$__authToken = token
+    this.$__pubkey = pubkey
+    this.$__wallet = wallet
+
+    // Recreate client with new auth data
+    this.$__client = this.createUrqlClient({
+      serverUri: this.serverUri,
+      socket: this.soketi,
+      encrypt: !!this.cipherLink
+    })
+  }
+
+  async query (request) {
+    const { query, variables } = request
+    const result = await this.$__client.query(query, variables).toPromise()
+    return this.formatResponse(result)
+  }
+
+  async mutate (request) {
+    const { mutation, variables } = request
+    const result = await this.$__client.mutation(mutation, variables).toPromise()
+    return this.formatResponse(result)
+  }
+
+  subscribe (request, closure) {
+    const { query, variables, operationName } = request
+
+    const { unsubscribe } = pipe(
+      this.$__client.subscription(query, variables),
+      map(result => {
+        closure(this.formatResponse(result))
+      })
+    ).subscribe(() => {})
+
+    // Store subscription for later cleanup
+    this.$__subscriptionManager.set(operationName, { unsubscribe })
+
+    return {
+      unsubscribe: () => this.unsubscribe(operationName)
+    }
+  }
+
+  formatResponse (result) {
+    // Match old Apollo response format
+    return {
+      data: result.data,
+      errors: result.error ? [result.error] : undefined
+    }
+  }
+
+  socketDisconnect () {
+    if (this.soketi) {
+      // Unsubscribe from all active subscriptions
+      this.unsubscribeAll()
+    }
+  }
+
+  unsubscribe (operationName) {
+    const subscription = this.$__subscriptionManager.get(operationName)
+    if (subscription) {
+      subscription.unsubscribe()
+      this.$__subscriptionManager.delete(operationName)
+    }
+  }
+
+  unsubscribeAll () {
+    this.$__subscriptionManager.forEach((subscription, operationName) => {
+      this.unsubscribe(operationName)
+    })
+  }
+
+  unsubscribeFromChannel (operationName) {
+    this.unsubscribe(operationName)
+  }
+
+  setEncryption (encrypt = false) {
+    this.cipherLink = encrypt
+    this.$__client = this.createUrqlClient({
+      serverUri: this.serverUri,
+      socket: this.soketi,
+      encrypt
+    })
+  }
+
+  getAuthToken () { return this.$__authToken }
+  getPubKey () { return this.$__pubkey }
+  getWallet () { return this.$__wallet }
+  getServerUri () { return this.serverUri }
+  getSocketUri () { return this.soketi ? this.soketi.socketUri : null }
+  getUri () { return this.serverUri }
+
+  setUri (uri) {
+    this.serverUri = uri
+    this.$__client = this.createUrqlClient({
+      serverUri: uri,
+      socket: this.soketi,
+      encrypt: !!this.cipherLink
+    })
+  }
+
+  setSocketUri ({ socketUri, appKey }) {
+    this.soketi = { socketUri, appKey }
+    this.$__client = this.createUrqlClient({
+      serverUri: this.serverUri,
+      socket: this.soketi,
+      encrypt: !!this.cipherLink
+    })
+  }
+}
+
+export default UrqlClientWrapper

package/src/mutation/Mutation.js

@@ -45,49 +45,68 @@ Please visit https://github.com/WishKnish/KnishIO-Client-JS for information.
 
 License: https://github.com/WishKnish/KnishIO-Client-JS/blob/master/LICENSE
 */
-import Query from '../query/Query';
+import Query from '../query/Query'
+import Response from '../response/Response'
 
 /**
  * Base class used to construct various GraphQL mutations
  */
 export default class Mutation extends Query {
-  /**
-   *
-   * @param {ApolloClient} apolloClient
-   */
-  constructor ( apolloClient ) {
-    super( apolloClient );
-  }
-
   /**
    * Creates a new Request for the given parameters
    *
    * @param {{}} variables
    * @returns {{variables: (Object|null), query: null}}
    */
-  createQuery ( { variables = null } ) {
-    const request = super.createQuery( { variables } );
-    request.mutation = request.query;
-    delete request.query;
-    return request;
+  createQuery ({ variables = null }) {
+    const request = super.createQuery({ variables })
+    request.mutation = request.query
+    delete request.query
+    return request
   }
 
   /**
-   * Sends the Query to a Knish.IO node and returns the Response
-   *
-   * @param variables
-   * @returns {Promise<Response>}
+   * Sends the Mutation to a Knish.IO node and returns the Response
+   * @param {Object||null} variables
+   * @param {Object||null} context
+   * @returns {Promise<Response|null>}
    */
-  async execute ( { variables = null } ) {
-
-    this.$__request = this.createQuery( {
+  async execute ({ variables = {}, context = {} }) {
+    this.$__request = this.createQuery({
       variables
-    } );
+    })
+
+    const mergedContext = {
+      ...context,
+      ...this.createQueryContext()
+    }
 
-    let response = await this.client.mutate( this.$__request );
+    try {
+      const mutationParams = {
+        ...this.$__request,
+        context: mergedContext
+      }
+      const response = await this.client.mutate(mutationParams)
 
-    this.$__response = await this.createResponseRaw( response );
+      this.$__response = await this.createResponseRaw(response)
+
+      return this.$__response
+    } catch (error) {
+      if (error.name === 'AbortError') {
+        this.knishIOClient.log('warn', 'Mutation was cancelled')
+        // You might want to create a custom response for cancelled mutations
+        return new Response({
+          query: this,
+          json: { data: null, errors: [{ message: 'Mutation was cancelled' }] }
+        })
+      } else {
+        throw error
+      }
+    }
+  }
 
-    return this.$__response;
+  createQueryContext () {
+    // Override this method in subclasses if needed
+    return {}
   }
 }

package/src/mutation/MutationActiveSession.js

@@ -45,21 +45,21 @@ Please visit https://github.com/WishKnish/KnishIO-Client-JS for information.
 
 License: https://github.com/WishKnish/KnishIO-Client-JS/blob/master/LICENSE
 */
-import Mutation from '../mutation/Mutation';
-import ResponseActiveSession from '../response/ResponseActiveSession';
-import { gql } from '@apollo/client/core';
+import Mutation from '../mutation/Mutation'
+import ResponseActiveSession from '../response/ResponseActiveSession'
+import { gql } from '@urql/core'
 
 /**
  * Mutation for declaring an active User Session with a given MetaAsset
  */
 export default class MutationActiveSession extends Mutation {
   /**
-   * Class constructor
-   *
-   * @param apolloClient
+   * @param {UrqlClientWrapper} graphQLClient
+   * @param {KnishIOClient} knishIOClient
    */
-  constructor ( apolloClient ) {
-    super( apolloClient );
+  constructor (graphQLClient, knishIOClient) {
+    super(graphQLClient, knishIOClient)
+
     this.$__query = gql`mutation(
       $bundleHash: String!,
       $metaType: String!,
@@ -88,7 +88,7 @@ export default class MutationActiveSession extends Mutation {
         createdAt,
         updatedAt
       }
-    }`;
+    }`
   }
 
   /**
@@ -97,10 +97,10 @@ export default class MutationActiveSession extends Mutation {
    * @param {object} json
    * @return {ResponseActiveSession}
    */
-  createResponse ( json ) {
-    return new ResponseActiveSession( {
+  createResponse (json) {
+    return new ResponseActiveSession({
       query: this,
       json
-    } );
+    })
   }
 }

package/src/mutation/MutationClaimShadowWallet.js

@@ -45,9 +45,9 @@ Please visit https://github.com/WishKnish/KnishIO-Client-JS for information.
 
 License: https://github.com/WishKnish/KnishIO-Client-JS/blob/master/LICENSE
 */
-import MutationProposeMolecule from './MutationProposeMolecule';
-import Wallet from '../Wallet';
-import ResponseClaimShadowWallet from '../response/ResponseClaimShadowWallet';
+import MutationProposeMolecule from './MutationProposeMolecule'
+import Wallet from '../Wallet'
+import ResponseClaimShadowWallet from '../response/ResponseClaimShadowWallet'
 
 /**
  * Mutation for claiming a Shadow Wallet
@@ -59,22 +59,20 @@ export default class MutationClaimShadowWallet extends MutationProposeMolecule {
    * @param {string} token
    * @param {string|null} batchId
    */
-  fillMolecule ( {
+  fillMolecule ({
     token,
     batchId = null
-  } ) {
-    let wallet = Wallet.create( {
-      secretOrBundle: this.$__molecule.secret,
+  }) {
+    const wallet = Wallet.create({
+      secret: this.$__molecule.secret,
+      bundle: this.$__molecule.bundle,
       token,
       batchId
-    } );
+    })
 
-    this.$__molecule.initShadowWalletClaim( {
-      token,
-      wallet
-    } );
-    this.$__molecule.sign( {} );
-    this.$__molecule.check();
+    this.$__molecule.initShadowWalletClaim(wallet)
+    this.$__molecule.sign({})
+    this.$__molecule.check()
   }
 
   /**
@@ -83,10 +81,10 @@ export default class MutationClaimShadowWallet extends MutationProposeMolecule {
    * @param {object} json
    * @return {ResponseClaimShadowWallet}
    */
-  createResponse ( json ) {
-    return new ResponseClaimShadowWallet( {
+  createResponse (json) {
+    return new ResponseClaimShadowWallet({
       query: this,
       json
-    } );
+    })
   }
 }

package/src/mutation/MutationCreateIdentifier.js

@@ -45,25 +45,25 @@ Please visit https://github.com/WishKnish/KnishIO-Client-JS for information.
 
 License: https://github.com/WishKnish/KnishIO-Client-JS/blob/master/LICENSE
 */
-import MutationProposeMolecule from './MutationProposeMolecule';
-import ResponseCreateIdentifier from '../response/ResponseCreateIdentifier';
+import MutationProposeMolecule from './MutationProposeMolecule'
+import ResponseCreateIdentifier from '../response/ResponseCreateIdentifier'
 
 /**
  * Query for creating a new Identifier
  */
 export default class MutationCreateIdentifier extends MutationProposeMolecule {
-  fillMolecule ( {
+  fillMolecule ({
     type,
     contact,
     code
-  } ) {
-    this.$__molecule.initIdentifierCreation( {
+  }) {
+    this.$__molecule.initIdentifierCreation({
       type,
       contact,
       code
-    } );
-    this.$__molecule.sign( {} );
-    this.$__molecule.check();
+    })
+    this.$__molecule.sign({})
+    this.$__molecule.check()
   }
 
   /**
@@ -72,11 +72,10 @@ export default class MutationCreateIdentifier extends MutationProposeMolecule {
    * @param {object} json
    * @return {ResponseCreateIdentifier}
    */
-  createResponse ( json ) {
-    return new ResponseCreateIdentifier( {
+  createResponse (json) {
+    return new ResponseCreateIdentifier({
       query: this,
       json
-    } );
+    })
   }
-
 }