@wishknish/knishio-client-js 0.5.2 → 0.6.0

package/src/libraries/Decimal.js

@@ -1,18 +1,17 @@
 // Value determines by min sql decimal precision
-const multiplier = 10 ** 18;
+const multiplier = 10 ** 18
 
 export default class Decimal {
-
   /**
    * @param {number} value
    * @return {number}
    */
-  static val ( value ) {
-    if ( Math.abs( value * multiplier ) < 1 ) {
-      return 0.0;
+  static val (value) {
+    if (Math.abs(value * multiplier) < 1) {
+      return 0.0
     }
 
-    return value;
+    return value
   }
 
   /**
@@ -21,19 +20,17 @@ export default class Decimal {
    * @param {boolean} debug
    * @return {number}
    */
-  static cmp ( value1, value2, debug = false ) {
-
-    const val1 = Decimal.val( value1 ) * multiplier,
-      val2 = Decimal.val( value2 ) * multiplier;
+  static cmp (value1, value2, debug = false) {
+    const val1 = Decimal.val(value1) * multiplier
+    const val2 = Decimal.val(value2) * multiplier
 
     // Equal
-    if ( Math.abs( val1 - val2 ) < 1 ) {
-      return 0;
+    if (Math.abs(val1 - val2) < 1) {
+      return 0
     }
 
     // Greater or smaller
-    return ( val1 > val2 ) ? 1 : -1;
-
+    return (val1 > val2) ? 1 : -1
   }
 
   /**
@@ -41,8 +38,7 @@ export default class Decimal {
    * @param {number} value2
    * @return {boolean}
    */
-  static equal ( value1, value2 ) {
-    return ( Decimal.cmp( value1, value2 ) === 0 );
+  static equal (value1, value2) {
+    return (Decimal.cmp(value1, value2) === 0)
   }
-
 }

package/src/libraries/Dot.js

@@ -1,81 +1,107 @@
 /**
- *
+ * Utility class for accessing nested object properties using dot notation
  */
 export default class Dot {
-
   /**
-   * @param {object|array} obj
-   * @param {string} keys
+   * Initialize the Dot utility with the given object and key path
+   * @param {object|array} obj - The object or array to traverse
+   * @param {string} keys - The dot-notated string of keys
    * @private
    */
-  static __init ( obj, keys ) {
-
-    this.arr = [];
-    this.key = null;
-
-    this.arr = String( keys ).split( '.' );
-    this.key = this.arr.shift();
-
-    const numberKey = Number( this.key );
-
-    if ( Number.isInteger( numberKey ) ) {
-      this.key = numberKey;
+  static __init (obj, keys) {
+    this.arr = String(keys).split('.')
+    this.key = this.arr.shift()
+
+    // Convert to number if the key is a valid integer
+    const numberKey = Number(this.key)
+    if (Number.isInteger(numberKey)) {
+      this.key = numberKey
     }
 
-    this.__nextKey = this.arr.length;
-    this.__next = this.__tic( obj );
+    this.__nextKey = this.arr.length
+    this.__next = this.__tic(obj)
   }
 
   /**
-   * @param {object|array} obj
-   * @return {boolean}
+   * Check if the current key exists in the object
+   * @param {object|array} obj - The object or array to check
+   * @return {boolean} - Whether the key exists
    * @private
    */
-  static __tic ( obj ) {
-
-    if ( !Array.isArray( obj ) && !( obj instanceof Object ) ) {
-      return false;
+  static __tic (obj) {
+    if (!Array.isArray(obj) && !(obj instanceof Object)) {
+      return false
     }
 
-    return typeof obj[ this.key ] !== 'undefined';
+    return typeof obj[this.key] !== 'undefined'
   }
 
   /**
-   * @param {object|array} obj
-   * @param {string} keys
-   * @return {boolean}
+   * Check if a nested property exists in an object using dot notation
+   * @param {object|array} obj - The object or array to search
+   * @param {string} keys - The path to the property, using dot notation
+   * @return {boolean} - True if the property exists, false otherwise
    */
-  static has ( obj, keys ) {
+  static has (obj, keys) {
+    this.__init(obj, keys)
 
-    this.__init( obj, keys );
-
-    if ( !this.__next ) {
-      return false;
+    if (!this.__next) {
+      return false
     }
-    if ( this.__nextKey === 0 ) {
-      return true;
+    if (this.__nextKey === 0) {
+      return true
     }
 
-    return this.has( obj[ this.key ], this.arr.join( '.' ) );
+    return this.has(obj[this.key], this.arr.join('.'))
   }
 
   /**
-   * @param {object|array} obj
-   * @param {string} keys
-   * @param {*} def
-   * @return {*}
+   * Get a nested property from an object using dot notation
+   * @param {object|array} obj - The object or array to search
+   * @param {string} keys - The path to the property, using dot notation
+   * @param {*} [def=null] - The default value to return if the property is not found
+   * @return {*} - The value of the property, or the default value if not found
    */
-  static get ( obj, keys, def = null ) {
-
-    this.__init( obj, keys );
+  static get (obj, keys, def = null) {
+    this.__init(obj, keys)
 
-    if ( !this.__next ) {
-      return def;
+    if (!this.__next) {
+      return def
     }
-    if ( this.__nextKey === 0 ) {
-      return obj[ this.key ];
+    if (this.__nextKey === 0) {
+      return obj[this.key]
     }
 
-    return this.get( obj[ this.key ], this.arr.join( '.' ), def );
+    return this.get(obj[this.key], this.arr.join('.'), def)
+  }
+
+  /**
+   * Set a nested property in an object using dot notation
+   * @param {object|array} obj - The object or array to modify
+   * @param {string} keys - The path to the property, using dot notation
+   * @param {*} value - The value to set
+   * @return {object|array} - The modified object or array
+   */
+  static set (obj, keys, value) {
+    const parts = keys.split('.')
+    let current = obj
+    const lastIndex = parts.length - 1
+
+    for (let i = 0; i < lastIndex; i++) {
+      const key = parts[i]
+      const numberKey = Number(key)
+      const useNumberKey = Number.isInteger(numberKey)
+
+      if (!(useNumberKey ? numberKey : key in current)) {
+        current[useNumberKey ? numberKey : key] = parts[i + 1].match(/^\d+$/) ? [] : {}
+      }
+      current = current[useNumberKey ? numberKey : key]
+    }
+
+    const lastKey = parts[lastIndex]
+    const lastNumberKey = Number(lastKey)
+    current[Number.isInteger(lastNumberKey) ? lastNumberKey : lastKey] = value
+
+    return obj
   }
 }

package/src/libraries/Hex.js

@@ -1,8 +1,12 @@
 /**
  * Create Uint8Array buffers from hexadecimal strings, and vice versa.
  */
-export default class Hex {
 
+if (typeof self === 'undefined') {
+  global.self = global
+}
+
+export default class Hex {
   /**
    * Converts the given buffer to a string containing its hexadecimal representation.
    *
@@ -19,58 +23,52 @@ export default class Hex {
    * @param {object} options
    * @return {string}
    */
-  static toHex ( arr, options ) {
-
+  static toHex (arr, options) {
     /**
      * @param {number} val
      * @param {boolean} uppercase
      * @return {*}
      */
-    const numberToHex = ( val, uppercase ) => {
-
-        const set = uppercase ?
-          [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' ] :
-          [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' ];
-
-        return set[ Math.floor( val / 16 ) ] + set[ val % 16 ];
+    const numberToHex = (val, uppercase) => {
+      const set = uppercase
+        ? ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F']
+        : ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f']
 
+      return set[Math.floor(val / 16)] + set[val % 16]
+    }
+    const opts = Object.assign(
+      {
+        grouping: 0,
+        rowlength: 0,
+        uppercase: false
       },
-      opts = Object.assign(
-        {
-          grouping: 0,
-          rowlength: 0,
-          uppercase: false
-        },
-        options || {}
-      );
-
-    let str = '',
-      group = 0,
-      column = 0;
+      options || {}
+    )
 
-    for ( let i = 0; i < arr.length; ++i ) {
+    let str = ''
+    let group = 0
+    let column = 0
 
-      str += numberToHex( arr[ i ], opts.uppercase );
+    for (let i = 0; i < arr.length; ++i) {
+      str += numberToHex(arr[i], opts.uppercase)
 
-      if ( i === arr.length - 1 ) {
-        break;
+      if (i === arr.length - 1) {
+        break
       }
 
-      if ( opts.grouping > 0 && ++group === opts.grouping ) {
-
-        group = 0;
-
-        if ( opts.rowlength > 0 && ++column === opts.rowlength ) {
+      if (opts.grouping > 0 && ++group === opts.grouping) {
+        group = 0
 
-          column = 0;
-          str += '\n';
+        if (opts.rowlength > 0 && ++column === opts.rowlength) {
+          column = 0
+          str += '\n'
         } else {
-          str += ' ';
+          str += ' '
         }
       }
     }
 
-    return str;
+    return str
   }
 
   /**
@@ -84,35 +82,32 @@ export default class Hex {
    * @param {string} str
    * @return {Uint8Array}
    */
-  static toUint8Array ( str ) {
+  static toUint8Array (str) {
+    let target = str.toLowerCase().replace(/\s/g, '')
 
-    let target = str.toLowerCase().replace( /\s/g, '' );
-
-    if ( target.length % 2 === 1 ) {
-      target = `0${ target }`;
+    if (target.length % 2 === 1) {
+      target = `0${ target }`
     }
 
-    let buffer = new Uint8Array( Math.floor( target.length / 2 ) ),
-      curr = -1;
-
-    for ( let i = 0; i < target.length; ++i ) {
+    const buffer = new Uint8Array(Math.floor(target.length / 2))
+    let curr = -1
 
-      let c = target[ i ],
-        val = [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' ].indexOf( c );
+    for (let i = 0; i < target.length; ++i) {
+      const c = target[i]
+      const val = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'].indexOf(c)
 
-      if ( val === -1 ) {
-        throw Error( 'unexpected character' );
+      if (val === -1) {
+        throw Error('unexpected character')
       }
 
-      if ( curr === -1 ) {
-        curr = 16 * val;
+      if (curr === -1) {
+        curr = 16 * val
       } else {
-
-        buffer[ Math.floor( i / 2 ) ] = curr + val;
-        curr = -1;
+        buffer[Math.floor(i / 2)] = curr + val
+        curr = -1
       }
     }
 
-    return buffer;
+    return buffer
   }
 }

package/src/libraries/apollo/ApolloClientWrapper.js

@@ -0,0 +1,143 @@
+import Client from './Client'
+import SubscriptionManager from './SubscriptionManager'
+
+/**
+ * ApolloClient wrapper class
+ * Provides a high-level interface for interacting with the GraphQL server
+ */
+export default class ApolloClientWrapper {
+  /**
+   * @param {Object} config - Configuration object
+   * @param {string} config.serverUri - URI of the GraphQL server
+   * @param {Object|null} config.socket - WebSocket configuration (optional)
+   * @param {boolean} config.encrypt - Whether to use encryption (default: false)
+   */
+  constructor ({ serverUri, socket = null, encrypt = false }) {
+    // Initialize the underlying Apollo Client
+    this.$__client = new Client({ serverUri, soketi: socket, encrypt })
+
+    // Initialize the subscription manager
+    this.$__subscriptionManager = new SubscriptionManager(this.$__client)
+  }
+
+  /**
+   * Set encryption for the client
+   * @param {boolean} encrypt - Whether to use encryption
+   */
+  setEncryption (encrypt = false) {
+    const clientConfig = {
+      serverUri: this.$__client.getServerUri(),
+      soketi: {
+        socketUri: this.$__client.getSocketUri(),
+        appKey: 'knishio'
+      },
+      encrypt
+    }
+    this.$__client = new Client(clientConfig)
+    this.$__subscriptionManager.setClient(this.$__client)
+  }
+
+  /**
+   * Unsubscribe from a specific subscription
+   * @param {string} operationName - Name of the operation to unsubscribe from
+   */
+  unsubscribe (operationName) {
+    this.$__subscriptionManager.unsubscribe(operationName)
+  }
+
+  /**
+   * Unsubscribe from all subscriptions
+   */
+  unsubscribeAll () {
+    this.$__subscriptionManager.unsubscribeAll()
+  }
+
+  /**
+   * Disconnect the WebSocket
+   */
+  socketDisconnect () {
+    this.$__client.socketDisconnect()
+    this.$__subscriptionManager.clear()
+  }
+
+  /**
+   * Create a new subscription
+   * @param {Object} request - Subscription request
+   * @param {Function} closure - Callback function for subscription updates
+   * @returns {Object} Subscription object
+   */
+  subscribe (request, closure) {
+    return this.$__subscriptionManager.subscribe(request, closure)
+  }
+
+  /**
+   * Execute a query
+   * @param {Object} request - Query request
+   * @returns {Promise} Promise resolving to the query result
+   */
+  async query (request) {
+    return this.$__client.query(request)
+  }
+
+  /**
+   * Execute a mutation
+   * @param {Object} request - Mutation request
+   * @returns {Promise} Promise resolving to the mutation result
+   */
+  async mutate (request) {
+    return this.$__client.mutate(request)
+  }
+
+  /**
+   * Set authentication data for the client
+   * @param {Object} authData - Authentication data
+   * @param {string} authData.token - Authentication token
+   * @param {string} authData.pubkey - Public key
+   * @param {Object} authData.wallet - Wallet object
+   */
+  setAuthData ({ token, pubkey, wallet }) {
+    this.$__client.setAuthData({ token, pubkey, wallet })
+  }
+
+  // Getter methods
+  getAuthToken () { return this.$__client.getAuthToken() }
+
+  getUri () {
+    return this.$__client ? this.$__client.getServerUri() : null
+  }
+
+  getSocketUri () { return this.$__client.getSocketUri() }
+
+  /**
+   * Set the server URI
+   * @param {string} uri - New server URI
+   */
+  setUri (uri) {
+    const clientConfig = {
+      serverUri: uri,
+      soketi: {
+        socketUri: this.$__client.getSocketUri(),
+        appKey: 'knishio'
+      },
+      encrypt: !!this.$__client.cipherLink
+    }
+    this.$__client = new Client(clientConfig)
+    this.$__subscriptionManager.setClient(this.$__client)
+  }
+
+  /**
+   * Set the WebSocket URI
+   * @param {Object} config - WebSocket configuration
+   * @param {string} config.socketUri - New WebSocket URI
+   * @param {string} config.appKey - Application key for the WebSocket
+   */
+  setSocketUri ({ socketUri, appKey }) {
+    const clientConfig = {
+      serverUri: this.$__client.getServerUri(),
+      soketi: { socketUri, appKey },
+      encrypt: !!this.$__client.cipherLink
+    }
+    this.$__client = new Client(clientConfig)
+    this.$__subscriptionManager.setClient(this.$__client)
+  }
+}

package/src/libraries/apollo/CipherLink.js

@@ -0,0 +1,116 @@
+import { ApolloLink, gql } from '@apollo/client/core'
+import { print } from 'graphql'
+import { operationName, operationType } from './operationUtils'
+import CodeException from '../../exception/CodeException'
+import Dot from '../Dot'
+
+/**
+ * Custom Apollo Link for handling encryption and decryption of GraphQL operations
+ */
+class CipherLink extends ApolloLink {
+  constructor () {
+    super()
+    this.__wallet = null
+    this.__pubkey = null
+  }
+
+  /**
+   * Set the wallet for encryption
+   * @param {Object|null} wallet - Wallet object
+   */
+  setWallet (wallet) {
+    this.__wallet = wallet
+  }
+
+  /**
+   * Get the current wallet
+   * @returns {Object|null} Wallet object
+   */
+  getWallet () {
+    return this.__wallet
+  }
+
+  /**
+   * Set the public key for encryption
+   * @param {string|null} pubkey - Public key
+   */
+  setPubKey (pubkey) {
+    this.__pubkey = pubkey
+  }
+
+  /**
+   * Get the current public key
+   * @returns {string|null} Public key
+   */
+  getPubKey () {
+    return this.__pubkey
+  }
+
+  /**
+   * Handle the request and apply encryption if necessary
+   * @param {Object} operation - GraphQL operation
+   * @param {function} forward - Function to forward the operation
+   * @returns {Observable} Observable of the operation result
+   */
+  request (operation, forward) {
+    const requestName = operationName(operation)
+    const requestType = operationType(operation)
+    const isMoleculeMutation = (requestType === 'mutation' && requestName === 'ProposeMolecule')
+
+    // Check if encryption should be skipped
+    const skipEncryption = [
+      (requestType === 'query' && ['__schema', 'ContinuId'].includes(requestName)),
+      (requestType === 'mutation' && requestName === 'AccessToken'),
+      (isMoleculeMutation && Dot.get(operation, 'variables.molecule.atoms.0.isotope') === 'U')
+    ].some(condition => condition)
+
+    if (skipEncryption) {
+      return forward(operation)
+    }
+
+    const wallet = this.getWallet()
+    const pubKey = this.getPubKey()
+
+    if (!pubKey) {
+      throw new CodeException('CipherLink::request() - Node public key missing!')
+    }
+
+    if (!wallet) {
+      throw new CodeException('CipherLink::request() - Authorized wallet missing!')
+    }
+
+    const cipher = {
+      query: print(operation.query),
+      variables: JSON.stringify(operation.variables)
+    }
+
+    // Encrypt the operation
+    operation.operationName = null
+    operation.query = gql`query ($Hash: String!) { CipherHash(Hash: $Hash) { hash } }`
+    operation.variables = { Hash: JSON.stringify(wallet.encryptMessage(cipher, pubKey)) }
+
+    // Forward the encrypted operation and handle the response
+    return forward(operation).map(data => {
+      let response = data.data
+
+      if (response.data) {
+        response = response.data
+      }
+
+      if (response.CipherHash && response.CipherHash.hash) {
+        const encrypted = JSON.parse(response.CipherHash.hash)
+        const decryption = wallet.decryptMessage(encrypted)
+
+        if (decryption === null) {
+          throw new CodeException('CipherLink::request() - Unable to decrypt response!')
+        }
+
+        return decryption
+      }
+
+      return data
+    })
+  }
+}
+
+export default CipherLink