@wishknish/knishio-client-js 0.5.2 → 0.6.0

package/src/libraries/apollo/Client.js

@@ -0,0 +1,154 @@
+import {
+  ApolloClient,
+  InMemoryCache,
+  from,
+  split
+} from '@apollo/client/core'
+import { onError } from '@apollo/client/link/error'
+import { getMainDefinition } from '@apollo/client/utilities'
+import { createHttpLink } from '@apollo/client/link/http'
+import { setContext } from '@apollo/client/link/context'
+import { GraphQLWsLink } from '@apollo/client/link/subscriptions'
+import { createClient } from 'graphql-ws'
+import fetch from 'isomorphic-fetch'
+import { errorHandler } from './errorHandler'
+import CipherLink from './CipherLink'
+
+/**
+ * Custom Apollo Client implementation
+ * Extends ApolloClient with additional functionality
+ */
+class Client extends ApolloClient {
+  /**
+   * @param {Object} config - Configuration object
+   * @param {string} config.serverUri - URI of the GraphQL server
+   * @param {Object|null} config.soketi - WebSocket configuration (optional)
+   * @param {boolean} config.encrypt - Whether to use encryption (default: false)
+   */
+  constructor ({ serverUri, soketi = null, encrypt = false }) {
+    // Create HTTP link
+    const httpLink = createHttpLink({
+      uri: serverUri,
+      fetch
+    })
+
+    // Initialize empty auth token
+    const authToken = ''
+
+    // Create auth link to add token to headers
+    const authLink = setContext((_, { headers }) => ({
+      headers: {
+        ...headers,
+        'X-Auth-Token': authToken
+      }
+    }))
+
+    // Create error handling link
+    const errorLink = onError(errorHandler)
+
+    // Combine links
+    let link = from([authLink, errorLink, httpLink])
+
+    // Add encryption link if enabled
+    let cipherLink
+    if (encrypt) {
+      cipherLink = new CipherLink()
+      link = from([cipherLink, link])
+    }
+
+    // Add WebSocket link if configured
+    let wsLink
+    if (soketi && soketi.socketUri) {
+      wsLink = new GraphQLWsLink(createClient({
+        url: soketi.socketUri,
+        connectionParams: () => ({
+          authToken
+        })
+      }))
+
+      // Split queries between WebSocket and HTTP
+      link = split(
+        ({ query }) => {
+          const definition = getMainDefinition(query)
+          return (
+            definition.kind === 'OperationDefinition' &&
+            definition.operation === 'subscription'
+          )
+        },
+        wsLink,
+        link
+      )
+    }
+
+    // Call parent constructor with configured options
+    super({
+      link,
+      cache: new InMemoryCache(),
+      defaultOptions: {
+        watchQuery: {
+          fetchPolicy: 'no-cache',
+          errorPolicy: 'ignore'
+        },
+        query: {
+          fetchPolicy: 'no-cache',
+          errorPolicy: 'all'
+        },
+        mutate: {
+          fetchPolicy: 'no-cache',
+          errorPolicy: 'all'
+        }
+      }
+    })
+
+    // Store configuration and links
+    this.serverUri = serverUri
+    this.soketi = soketi
+    this.authToken = authToken
+    this.pubkey = null
+    this.wallet = null
+    this.cipherLink = cipherLink
+    this.wsLink = wsLink
+  }
+
+  /**
+   * Set authentication data
+   * @param {Object} authData - Authentication data
+   * @param {string} authData.token - Auth token
+   * @param {string} authData.pubkey - Public key
+   * @param {Object} authData.wallet - Wallet object
+   */
+  setAuthData ({ token, pubkey, wallet }) {
+    this.authToken = token
+    this.pubkey = pubkey
+    this.wallet = wallet
+
+    if (this.cipherLink) {
+      this.cipherLink.setWallet(wallet)
+      this.cipherLink.setPubKey(pubkey)
+    }
+
+    if (this.wsLink) {
+      this.wsLink.client.connectionParams = () => ({
+        authToken: this.authToken
+      })
+    }
+  }
+
+  /**
+   * Disconnect the WebSocket connection
+   */
+  socketDisconnect () {
+    if (this.wsLink) {
+      this.wsLink.client.dispose()
+    }
+  }
+
+  // Getter methods
+  getAuthToken () { return this.authToken }
+  getPubKey () { return this.pubkey }
+  getWallet () { return this.wallet }
+  getServerUri () { return this.serverUri }
+  getSocketUri () { return this.soketi ? this.soketi.socketUri : null }
+}
+
+export default Client

package/src/libraries/apollo/ErrorHandler.js

@@ -0,0 +1,32 @@
+/**
+ * Handle GraphQL and network errors
+ * @param {Object} errorInfo - Error information object
+ */
+export function errorHandler ({
+  graphQLErrors,
+  networkError,
+  operation,
+  forward,
+  response
+}) {
+  if (graphQLErrors) {
+    graphQLErrors.forEach(({ message, debugMessage, locations, path }) =>
+      console.error(
+        `[GraphQL error]: ${message}`,
+        `\n  Message : ${debugMessage}`,
+        `\n  Path    : ${path}`,
+        `\n  Location: ${JSON.stringify(locations)}`
+      )
+    )
+  }
+
+  if (networkError) {
+    const { name, statusCode, result = {} } = networkError
+    console.error(`[Network error]: ${name}, status code: ${statusCode}`)
+    // TODO: Implement automatic retry logic for network errors
+    // This could involve using an exponential backoff strategy
+  }
+
+  // You can add custom error handling logic here
+  // For example, you could dispatch actions to update the app state on certain errors
+}

package/src/libraries/apollo/SubscriptionManager.js

@@ -0,0 +1,60 @@
+/**
+ * Manages GraphQL subscriptions
+ */
+class SubscriptionManager {
+  /**
+   * @param {Client} client - Apollo Client instance
+   */
+  constructor (client) {
+    this.$__client = client
+    this.$__subscribers = {}
+  }
+
+  /**
+   * Set the client instance
+   * @param {Client} client - Apollo Client instance
+   */
+  setClient (client) {
+    this.$__client = client
+  }
+
+  /**
+   * Create a new subscription
+   * @param {Object} request - Subscription request
+   * @param {Function} closure - Callback function for subscription updates
+   * @returns {Object} Subscription object
+   */
+  subscribe (request, closure) {
+    const subscription = this.$__client.subscribe(request).subscribe(closure)
+    this.$__subscribers[request.operationName] = subscription
+    return subscription
+  }
+
+  /**
+   * Unsubscribe from a specific subscription
+   * @param {string} operationName - Name of the operation to unsubscribe from
+   */
+  unsubscribe (operationName) {
+    if (this.$__subscribers[operationName]) {
+      this.$__subscribers[operationName].unsubscribe()
+      this.$__client.unsubscribeFromChannel(operationName)
+      delete this.$__subscribers[operationName]
+    }
+  }
+
+  /**
+   * Unsubscribe from all subscriptions
+   */
+  unsubscribeAll () {
+    Object.keys(this.$__subscribers).forEach(this.unsubscribe.bind(this))
+  }
+
+  /**
+   * Clear all subscriptions without unsubscribing
+   */
+  clear () {
+    this.$__subscribers = {}
+  }
+}
+
+export default SubscriptionManager

package/src/libraries/apollo/operationUtils.js

@@ -0,0 +1,26 @@
+/**
+ * Extract the operation name from a GraphQL operation
+ * @param {Object} operation - GraphQL operation object
+ * @returns {string} Operation name
+ */
+export function operationName (operation) {
+  const operationDefinition = operation.query.definitions.find(
+    definitionNode => definitionNode.kind === 'OperationDefinition'
+  )
+  const fieldNode = operationDefinition.selectionSet.selections.find(
+    definitionNode => definitionNode.kind === 'Field'
+  )
+  return fieldNode.name.value
+}
+
+/**
+ * Extract the operation type from a GraphQL operation
+ * @param {Object} operation - GraphQL operation object
+ * @returns {string} Operation type (query, mutation, subscription)
+ */
+export function operationType (operation) {
+  const operationDefinition = operation.query.definitions.find(
+    definitionNode => definitionNode.kind === 'OperationDefinition'
+  )
+  return operationDefinition.operation
+}

package/src/libraries/array.js

@@ -5,69 +5,78 @@
  * @param {number} size
  * @return {array}
  */
-export function chunkArray ( arr, size ) {
-
-  if ( !arr.length ) {
-    return [];
+export function chunkArray (arr, size) {
+  if (!arr.length) {
+    return []
   }
 
-  return [ arr.slice( 0, size ) ].concat( chunkArray( arr.slice( size ), size ) );
+  return [arr.slice(0, size)].concat(chunkArray(arr.slice(size), size))
 }
 
 export function deepCloning (
   o // The only argument passed by user: object to clone
   , h // Cache (organized as array: [key,value,key,value,...])
 ) {
-  let i,
-    r,
-    x // Property indexer, result, temporary variable
-    ,
-    t = [ Array, Date, Number, String, Boolean ] // Types to treat in a special way
-    ,
-    s = Object.prototype.toString; // Shortcut to Object.prototype.toString
-  h = h || []; // If cache is not created yet, create it!
-  for ( i = 0; i < h.length; i += 2 ) // Search cache for our object
-    if ( o === h[ i ] )
-      r = h[ i + 1 ];
-  if ( !r && o && typeof o == 'object' ) { // Clone o if it is uncached object and not null
-    r = {}; // Default result template: plain hash
-    for ( i = 0; i < t.length; i++ ) // To handle multiframe environment, search for type by
-      if ( s.call( o ) === s.call( //   comparing Object.prototype.toString's of our object
-        x = new t[ i ]( o ) ) ) //   and new object x created with the constructor t[i]
-        // Notice that it will create new Date(o), new String(o)
-        //   which is good and new Array(o) which is bad
-        r = i ? x : []; // If i==0, t==Array. We need to recreate it. Else use x
-    h.push( o, r ); // Add object to cache before (!) making recursive call
-    for ( i in o ) // Just copy properties recursively
-      if ( h.hasOwnProperty.call( o, i ) ) // As o might have key 'hasOwnProperty', use something
-        r[ i ] = deepCloning( o[ i ], h ); //   we defined right instead
+  let i
+  let r
+  let x // Property indexer, result, temporary variable
+
+  const t = [Array, Date, Number, String, Boolean] // Types to treat in a special way
+
+  const s = Object.prototype.toString // Shortcut to Object.prototype.toString
+  h = h || [] // If cache is not created yet, create it!
+  // Search cache for our object
+  for (i = 0; i < h.length; i += 2) {
+    if (o === h[i]) {
+      r = h[i + 1]
+    }
+  }
+  // Clone o if it is uncached object and not null
+  if (!r && o && typeof o === 'object') {
+    r = {} // Default result template: plain hash
+    // To handle multiframe environment, search for type by
+    for (i = 0; i < t.length; i++) {
+      //   comparing Object.prototype.toString's of our object
+      //   and new object x created with the constructor t[i]
+      // Notice that it will create new Date(o), new String(o)
+      //   which is good and new Array(o) which is bad
+      if (s.call(o) === s.call(x = new t[i](o))) {
+        r = i ? x : []
+      }
+    } // If i==0, t==Array. We need to recreate it. Else use x
+    h.push(o, r) // Add object to cache before (!) making recursive call
+    // Just copy properties recursively
+    for (i in o) {
+      // As o might have key 'hasOwnProperty', use something
+      if (h.hasOwnProperty.call(o, i)) {
+        r[i] = deepCloning(o[i], h)
+      }
+    } //   we defined right instead
   }
-  return r || o; // Return r if it was found in cache or built in if(){}
+  return r || o // Return r if it was found in cache or built in if(){}
 }
 
 /**
  * @param arrays
  * @returns {*[]}
  */
-export function diff ( ...arrays ) {
+export function diff (...arrays) {
+  return [].concat(...arrays.map((arr, i) => {
+    const others = arrays.slice(0)
 
-  return [].concat( ...arrays.map( ( arr, i ) => {
+    others.splice(i, 1)
 
-    const others = arrays.slice( 0 );
+    const unique = [...new Set([].concat(...others))]
 
-    others.splice( i, 1 );
-
-    const unique = [ ...new Set( [].concat( ...others ) ) ];
-
-    return arr.filter( item => !unique.includes( item ) );
-  } ) );
+    return arr.filter(item => !unique.includes(item))
+  }))
 }
 
- /**
+/**
  *
  * @param arrays
  * @return {*[]}
  */
-export function intersect ( ...arrays ) {
-  return arrays.reduce( ( first, second ) => first.filter( item => second.includes( item ) ) );
+export function intersect (...arrays) {
+  return arrays.reduce((first, second) => first.filter(item => second.includes(item)))
 }

package/src/libraries/crypto.js

@@ -45,8 +45,8 @@ Please visit https://github.com/WishKnish/KnishIO-Client-JS for information.
 
 License: https://github.com/WishKnish/KnishIO-Client-JS/blob/master/LICENSE
  */
-import { shake256 } from 'js-sha3';
-import { randomString } from './strings';
+import { randomString } from './strings'
+import JsSHA from 'jssha'
 
 /**
  * Generates a secret based on an optional seed
@@ -55,17 +55,14 @@ import { randomString } from './strings';
  * @param length
  * @return {string|*}
  */
-export function generateSecret ( seed = null, length = 2048 ) {
-
-  console.info( `Crypto::generateSecret() - Computing new secret${ seed ? ' from existing seed' : '' }...` );
-
-  if ( seed ) {
-    const sponge = shake256.create( length * 2 );
-    sponge.update( seed );
-    return sponge.hex();
-  }
-  else {
-    return randomString( length );
+export function generateSecret (seed = null, length = 2048) {
+  // console.info(`Crypto::generateSecret() - Computing new secret${ seed ? ' from existing seed' : '' }...`)
+  if (seed) {
+    const sponge = new JsSHA('SHAKE256', 'TEXT')
+    sponge.update(seed)
+    return sponge.getHash('HEX', { outputLen: length * 2 })
+  } else {
+    return randomString(length)
   }
 }
 
@@ -73,16 +70,13 @@ export function generateSecret ( seed = null, length = 2048 ) {
  * Hashes the user secret to produce a bundle hash
  *
  * @param {string} secret
+ * @param {string|null} source
  * @return {string}
  */
-export function generateBundleHash ( secret ) {
-
-  console.info( 'Crypto::generateBundleHash() - Computing wallet bundle from secret...' );
-
-  const sponge = shake256.create( 256 );
-  sponge.update( secret );
-  return sponge.hex();
-
+export function generateBundleHash (secret, source = null) {
+  const sponge = new JsSHA('SHAKE256', 'TEXT')
+  sponge.update(secret)
+  return sponge.getHash('HEX', { outputLen: 256 })
 }
 
 /**
@@ -93,14 +87,13 @@ export function generateBundleHash ( secret ) {
  *
  * @return {string}
  */
-export function generateBatchId ( {
+export function generateBatchId ({
   molecularHash = null,
   index = null
-} ) {
-
-  if ( molecularHash !== null && index !== null ) {
-    return generateBundleHash( String( molecularHash ) + String( index ) );
+}) {
+  if (molecularHash !== null && index !== null) {
+    return generateBundleHash(String(molecularHash) + String(index), 'generateBatchId')
   }
 
-  return randomString( 64 );
+  return randomString(64)
 }