@wishknish/knishio-client-js 0.6.0 → 0.6.2

package/src/query/QueryMetaTypeViaAtom.js

@@ -46,16 +46,16 @@ 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'
-import { gql } from '@apollo/client/core'
 import ResponseMetaTypeViaAtom from '../response/ResponseMetaTypeViaAtom'
+import { gql } from '@urql/core'
 
 export default class QueryMetaTypeViaAtom extends Query {
   /**
-   * @param {ApolloClientWrapper} apolloClient
+   * @param {UrqlClientWrapper} graphQLClient
    * @param {KnishIOClient} knishIOClient
    */
-  constructor (apolloClient, knishIOClient) {
-    super(apolloClient, knishIOClient)
+  constructor (graphQLClient, knishIOClient) {
+    super(graphQLClient, knishIOClient)
 
     this.$__query = gql`query ($metaTypes: [String!], $metaIds: [String!], $values: [String!], $keys: [String!], $latest: Boolean, $filter: [MetaFilter!], $queryArgs: QueryArgs, $countBy: String, $atomValues: [String!] ) {
       MetaTypeViaAtom(

package/src/query/QueryPolicy.js

@@ -47,16 +47,16 @@ License: https://github.com/WishKnish/KnishIO-Client-JS/blob/master/LICENSE
 */
 
 import Query from './Query'
-import { gql } from '@apollo/client/core'
 import ResponsePolicy from '../response/ResponsePolicy'
+import { gql } from "@urql/core";
 
 export default class QueryPolicy extends Query {
   /**
-   * @param {ApolloClientWrapper} apolloClient
+   * @param {UrqlClientWrapper} graphQLClient
    * @param {KnishIOClient} knishIOClient
    */
-  constructor (apolloClient, knishIOClient) {
-    super(apolloClient, knishIOClient)
+  constructor (graphQLClient, knishIOClient) {
+    super(graphQLClient, knishIOClient)
 
     this.$__query = gql`query( $metaType: String, $metaId: String, ) {
       Policy( metaType: $metaType, metaId: $metaId ) {

package/src/query/QueryToken.js

@@ -46,19 +46,19 @@ 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'
-import { gql } from '@apollo/client/core'
 import Response from '../response/Response'
+import { gql } from '@urql/core'
 
 /**
  * Query for getting the token info
  */
 export default class QueryToken extends Query {
   /**
-   * @param {ApolloClientWrapper} apolloClient
+   * @param {UrqlClientWrapper} graphQLClient
    * @param {KnishIOClient} knishIOClient
    */
-  constructor (apolloClient, knishIOClient) {
-    super(apolloClient, knishIOClient)
+  constructor (graphQLClient, knishIOClient) {
+    super(graphQLClient, knishIOClient)
 
     this.$__query = gql`query( $slug: String, $slugs: [ String! ], $limit: Int, $order: String ) {
       Token( slug: $slug, slugs: $slugs, limit: $limit, order: $order ) {

package/src/query/QueryUserActivity.js

@@ -47,18 +47,18 @@ License: https://github.com/WishKnish/KnishIO-Client-JS/blob/master/LICENSE
 */
 import Query from './Query'
 import ResponseQueryUserActivity from '../response/ResponseQueryUserActivity'
-import { gql } from '@apollo/client/core'
+import { gql } from '@urql/core'
 
 /**
  * Query for retrieving information about user activity
  */
 export default class QueryUserActivity extends Query {
   /**
-   * @param {ApolloClientWrapper} apolloClient
+   * @param {UrqlClientWrapper} graphQLClient
    * @param {KnishIOClient} knishIOClient
    */
-  constructor (apolloClient, knishIOClient) {
-    super(apolloClient, knishIOClient)
+  constructor (graphQLClient, knishIOClient) {
+    super(graphQLClient, knishIOClient)
 
     this.$__query = gql`query UserActivity (
       $bundleHash:String,

package/src/query/QueryWalletBundle.js

@@ -47,18 +47,18 @@ License: https://github.com/WishKnish/KnishIO-Client-JS/blob/master/LICENSE
 */
 import Query from './Query'
 import ResponseWalletBundle from '../response/ResponseWalletBundle'
-import { gql } from '@apollo/client/core'
+import { gql } from '@urql/core'
 
 /**
  * Query for retrieving information about Wallet Bundles
  */
 export default class QueryWalletBundle extends Query {
   /**
-   * @param {ApolloClientWrapper} apolloClient
+   * @param {UrqlClientWrapper} graphQLClient
    * @param {KnishIOClient} knishIOClient
    */
-  constructor (apolloClient, knishIOClient) {
-    super(apolloClient, knishIOClient)
+  constructor (graphQLClient, knishIOClient) {
+    super(graphQLClient, knishIOClient)
 
     this.$__query = gql`query( $bundleHashes: [ String! ] ) {
       WalletBundle( bundleHashes: $bundleHashes ) {

package/src/query/QueryWalletList.js

@@ -47,18 +47,18 @@ License: https://github.com/WishKnish/KnishIO-Client-JS/blob/master/LICENSE
 */
 import Query from './Query'
 import ResponseWalletList from '../response/ResponseWalletList'
-import { gql } from '@apollo/client/core'
+import { gql } from '@urql/core'
 
 /**
  * Query for getting a list of Wallets
  */
 export default class QueryWalletList extends Query {
   /**
-   * @param {ApolloClientWrapper} apolloClient
+   * @param {UrqlClientWrapper} graphQLClient
    * @param {KnishIOClient} knishIOClient
    */
-  constructor (apolloClient, knishIOClient) {
-    super(apolloClient, knishIOClient)
+  constructor (graphQLClient, knishIOClient) {
+    super(graphQLClient, knishIOClient)
 
     this.$__query = gql`query( $bundleHash: String, $tokenSlug: String ) {
       Wallet( bundleHash: $bundleHash, tokenSlug: $tokenSlug ) {

package/src/subscribe/ActiveSessionSubscribe.js

@@ -1,9 +1,9 @@
 import Subscribe from './Subscribe'
-import { gql } from '@apollo/client/core'
+import { gql } from '@urql/core'
 
 export default class ActiveSessionSubscribe extends Subscribe {
-  constructor (apolloClient) {
-    super(apolloClient)
+  constructor (graphQLClient) {
+    super(graphQLClient)
     this.$__subscribe = gql`
       subscription onActiveUser ( $metaType: String!, $metaId: String! ) {
         ActiveUser( metaType: $metaType, metaId: $metaId ) {

package/src/subscribe/ActiveWalletSubscribe.js

@@ -1,9 +1,9 @@
 import Subscribe from './Subscribe'
-import { gql } from '@apollo/client/core'
+import { gql } from '@urql/core'
 
 export default class ActiveWalletSubscribe extends Subscribe {
-  constructor (apolloClient) {
-    super(apolloClient)
+  constructor (graphQLClient) {
+    super(graphQLClient)
     this.$__subscribe = gql`
       subscription onActiveWallet ( $bundle: String! ) {
         ActiveWallet( bundle: $bundle ) {

package/src/subscribe/CreateMoleculeSubscribe.js

@@ -1,9 +1,9 @@
 import Subscribe from './Subscribe'
-import { gql } from '@apollo/client/core'
+import { gql } from '@urql/core'
 
 export default class CreateMoleculeSubscribe extends Subscribe {
-  constructor (apolloClient) {
-    super(apolloClient)
+  constructor (graphQLClient) {
+    super(graphQLClient)
     this.$__subscribe = gql`
       subscription onCreateMolecule ( $bundle: String! ) {
         CreateMolecule( bundle: $bundle ) {

package/src/subscribe/Subscribe.js

@@ -3,10 +3,10 @@ import CodeException from '../exception/CodeException'
 export default class Subscribe {
   /**
    *
-   * @param {ApolloClientWrapper} apolloClient
+   * @param {UrqlClientWrapper} graphQLClient
    */
-  constructor (apolloClient) {
-    this.client = apolloClient
+  constructor (graphQLClient) {
+    this.client = graphQLClient
     this.$__variables = null
     this.$__subscribe = null
   }

package/src/subscribe/WalletStatusSubscribe.js

@@ -1,9 +1,9 @@
 import Subscribe from './Subscribe'
-import { gql } from '@apollo/client/core'
+import { gql } from '@urql/core'
 
 export default class WalletStatusSubscribe extends Subscribe {
-  constructor (apolloClient) {
-    super(apolloClient)
+  constructor (graphQLClient) {
+    super(graphQLClient)
     this.$__subscribe = gql`
       subscription onWalletStatus ( $bundle: String!, $token: String! ) {
         WalletStatus( bundle: $bundle, token: $token ) {

package/src/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/libraries/apollo/ApolloClientWrapper.js

@@ -1,143 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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

package/src/libraries/apollo/Client.js

@@ -1,154 +0,0 @@
-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

@@ -1,32 +0,0 @@
-/**
- * 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
-}