@wishknish/knishio-client-ts 0.7.0

package/src/libraries/Dot.ts

@@ -0,0 +1,202 @@
+/**
+ * Utility class for accessing nested object properties using dot notation
+ * Matches JavaScript SDK Dot class functionality exactly
+ */
+export default class Dot {
+  private static arr: string[]
+  private static key: string | number
+  private static __nextKey: number
+  private static __next: boolean
+
+  /**
+   * Initialize the Dot utility with the given object and key path
+   * @param obj - The object or array to traverse
+   * @param keys - The dot-notated string of keys
+   * @private
+   */
+  private static __init(obj: any, keys: string): void {
+    this.arr = String(keys).split('.')
+    this.key = this.arr.shift() as string
+
+    // 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)
+  }
+
+  /**
+   * Check if the current key exists in the object
+   * @param obj - The object or array to check
+   * @return Whether the key exists
+   * @private
+   */
+  private static __tic(obj: any): boolean {
+    if (!Array.isArray(obj) && !(obj instanceof Object)) {
+      return false
+    }
+
+    return typeof obj[this.key] !== 'undefined'
+  }
+
+  /**
+   * Check if a nested property exists in an object using dot notation
+   * @param obj - The object or array to search
+   * @param keys - The path to the property, using dot notation
+   * @return True if the property exists, false otherwise
+   */
+  static has(obj: any, keys: string): boolean {
+    this.__init(obj, keys)
+
+    if (!this.__next) {
+      return false
+    }
+
+    if (this.__nextKey) {
+      return this.has(obj[this.key], this.arr.join('.'))
+    }
+
+    return true
+  }
+
+  /**
+   * Get a nested property from an object using dot notation
+   * @param obj - The object or array to search
+   * @param keys - The path to the property, using dot notation
+   * @param defaultValue - The default value to return if the property doesn't exist
+   * @return The value at the specified path, or defaultValue if not found
+   */
+  static get(obj: any, keys: string, defaultValue: any = null): any {
+    this.__init(obj, keys)
+
+    if (!this.__next) {
+      return defaultValue
+    }
+
+    if (this.__nextKey) {
+      return this.get(obj[this.key], this.arr.join('.'), defaultValue)
+    }
+
+    return obj[this.key]
+  }
+
+  /**
+   * Set a nested property in an object using dot notation
+   * @param obj - The object or array to modify
+   * @param keys - The path to the property, using dot notation
+   * @param value - The value to set
+   * @return The modified object
+   */
+  static set(obj: any, keys: string, value: any): any {
+    if (typeof obj !== 'object' || obj === null) {
+      obj = {}
+    }
+
+    const keysArray = String(keys).split('.')
+    let current = obj
+
+    for (let i = 0; i < keysArray.length - 1; i++) {
+      const key = keysArray[i]
+      if (!key) continue // Skip undefined keys
+      
+      // Convert to number if valid integer
+      const numberKey = Number(key)
+      const actualKey: string | number = Number.isInteger(numberKey) ? numberKey : key
+
+      if (!(actualKey in current) || typeof current[actualKey] !== 'object') {
+        // Determine if next key is numeric to decide between array or object
+        const nextKey = keysArray[i + 1]
+        const nextNumberKey = Number(nextKey)
+        current[actualKey] = Number.isInteger(nextNumberKey) ? [] : {}
+      }
+
+      current = current[actualKey]
+    }
+
+    const lastKey = keysArray[keysArray.length - 1]
+    if (lastKey !== undefined) {
+      const numberKey = Number(lastKey)
+      const actualLastKey: string | number = Number.isInteger(numberKey) ? numberKey : lastKey
+      current[actualLastKey] = value
+    }
+
+    return obj
+  }
+
+  /**
+   * Delete a nested property from an object using dot notation
+   * @param obj - The object or array to modify
+   * @param keys - The path to the property, using dot notation
+   * @return True if the property was deleted, false otherwise
+   */
+  static delete(obj: any, keys: string): boolean {
+    if (!this.has(obj, keys)) {
+      return false
+    }
+
+    const keysArray = String(keys).split('.')
+    const lastKey = keysArray.pop() as string
+    
+    if (keysArray.length === 0) {
+      const numberKey = Number(lastKey)
+      const actualKey = Number.isInteger(numberKey) ? numberKey : lastKey
+      delete obj[actualKey]
+      return true
+    }
+
+    const parent = this.get(obj, keysArray.join('.'))
+    if (parent && typeof parent === 'object') {
+      const numberKey = Number(lastKey)
+      const actualKey = Number.isInteger(numberKey) ? numberKey : lastKey
+      delete parent[actualKey]
+      return true
+    }
+
+    return false
+  }
+
+  /**
+   * Flatten an object with nested properties into dot notation
+   * @param obj - The object to flatten
+   * @param prefix - The prefix for keys (used recursively)
+   * @return A flattened object with dot-notation keys
+   */
+  static flatten(obj: any, prefix = ''): Record<string, any> {
+    const result: Record<string, any> = {}
+
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        const value = obj[key]
+        const newKey = prefix ? `${prefix}.${key}` : key
+
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+          Object.assign(result, this.flatten(value, newKey))
+        } else {
+          result[newKey] = value
+        }
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * Expand a flattened object with dot-notation keys back to nested structure
+   * @param obj - The flattened object with dot-notation keys
+   * @return The expanded nested object
+   */
+  static expand(obj: Record<string, any>): any {
+    const result: any = {}
+
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        this.set(result, key, obj[key])
+      }
+    }
+
+    return result
+  }
+}

package/src/libraries/GraphQLClient.ts

@@ -0,0 +1,276 @@
+/*
+                               (
+                              (/(
+                              (//(
+                              (///(
+                             (/////(
+                             (//////(                          )
+                            (////////(                        (/)
+                            (////////(                       (///)
+                           (//////////(                      (////)
+                           (//////////(                     (//////)
+                          (////////////(                    (///////)
+                         (/////////////(                   (/////////)
+                        (//////////////(                  (///////////)
+                        (///////////////(                (/////////////)
+                       (////////////////(               (//////////////)
+                      (((((((((((((((((((              (((((((((((((((
+                     (((((((((((((((((((              ((((((((((((((
+                     (((((((((((((((((((            ((((((((((((((
+                    ((((((((((((((((((((           (((((((((((((
+                    ((((((((((((((((((((          ((((((((((((
+                    (((((((((((((((((((         ((((((((((((
+                    (((((((((((((((((((        ((((((((((
+                    ((((((((((((((((((/      (((((((((
+                    ((((((((((((((((((     ((((((((
+                    (((((((((((((((((    (((((((
+                   ((((((((((((((((((  (((((
+                   #################  ##
+                   ################  #
+                  ################# ##
+                 %################  ###
+                 ###############(   ####
+                ###############      ####
+               ###############       ######
+              %#############(        (#######
+             %#############           #########
+            ############(              ##########
+           ###########                  #############
+          #########                      ##############
+        %######
+
+        Powered by Knish.IO: Connecting a Decentralized World
+
+Please visit https://github.com/WishKnish/KnishIO-Client-TS for information.
+
+License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
+*/
+
+import {
+  createClient,
+  Client,
+  subscriptionExchange,
+  cacheExchange,
+  fetchExchange
+} from '@urql/core'
+import { createClient as createWSClient } from 'graphql-ws'
+import { pipe, subscribe } from 'wonka'
+import type { GraphQLClient as IGraphQLClient } from '@/types'
+import type Wallet from '@/core/Wallet'
+
+/**
+ * GraphQL client wrapper for KnishIO SDK
+ * Provides a unified interface for GraphQL operations
+ */
+export default class GraphQLClient implements IGraphQLClient {
+  private $__client: Client
+  private $__authToken: string = ''
+  private $__pubkey: string | null = null
+  private $__wallet: Wallet | null = null
+  private serverUri: string
+  private socketUri: string | null = null
+  private cipherLink: boolean
+  private $__subscriptionManager: Map<string, { unsubscribe: () => void }> = new Map()
+
+  constructor({
+    serverUri,
+    socket = null,
+    encrypt = false
+  }: {
+    serverUri: string
+    socket?: { socketUri: string | null; appKey?: string } | null
+    encrypt?: boolean
+  }) {
+    this.serverUri = serverUri
+    this.socketUri = socket?.socketUri || null
+    this.cipherLink = !!encrypt
+    this.$__client = this.createUrqlClient({ serverUri, socket, encrypt })
+  }
+
+  private createUrqlClient({
+    serverUri,
+    socket,
+    encrypt
+  }: {
+    serverUri: string
+    socket?: { socketUri: string | null } | null
+    encrypt?: boolean
+  }): Client {
+    const exchanges = [cacheExchange, fetchExchange]
+
+    // Add subscription support if socket is configured
+    if (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
+        },
+        // Add 60 second timeout
+        signal: AbortSignal.timeout(60000)
+      })
+    })
+  }
+
+  setAuthData({
+    token,
+    pubkey,
+    wallet
+  }: {
+    token: string
+    pubkey: string
+    wallet?: Wallet
+  }): void {
+    this.$__authToken = token
+    this.$__pubkey = pubkey
+    this.$__wallet = wallet || null
+
+    // Recreate client with new auth data
+    this.$__client = this.createUrqlClient({
+      serverUri: this.serverUri,
+      socket: this.socketUri ? { socketUri: this.socketUri } : null,
+      encrypt: this.cipherLink
+    })
+  }
+
+  async query<TResult = unknown, TVariables = Record<string, any>>(
+    request: { query: string; variables?: TVariables },
+    variables?: TVariables
+  ): Promise<any> {
+    const finalVariables = variables || request.variables || {}
+    const result = await this.$__client.query(request.query, finalVariables).toPromise()
+    return this.formatResponse(result)
+  }
+
+  async mutate<TResult = unknown, TVariables = Record<string, any>>(
+    request: { mutation: string; variables?: TVariables },
+    variables?: TVariables
+  ): Promise<any> {
+    const finalVariables = variables || request.variables || {}
+    const result = await this.$__client.mutation(request.mutation, finalVariables).toPromise()
+    return this.formatResponse(result)
+  }
+
+  async mutation<TResult = unknown, TVariables = Record<string, any>>(
+    request: { mutation: string; variables?: TVariables },
+    variables?: TVariables
+  ): Promise<any> {
+    return this.mutate(request, variables)
+  }
+
+  subscribe(
+    request: {
+      query: string
+      variables?: Record<string, any>
+      operationName?: string
+    },
+    callback: (result: any) => void
+  ): { unsubscribe: () => void } {
+    const { query, variables, operationName = 'subscription' } = request
+
+    const { unsubscribe } = pipe(
+      this.$__client.subscription(query, variables || {}),
+      subscribe((result) => {
+        callback(this.formatResponse(result))
+      })
+    )
+
+    // Store subscription for later cleanup
+    this.$__subscriptionManager.set(operationName, { unsubscribe })
+
+    return {
+      unsubscribe: () => this.unsubscribe(operationName)
+    }
+  }
+
+  private formatResponse(result: any): any {
+    // Match old Apollo response format
+    return {
+      data: result.data,
+      errors: result.error ? [result.error] : undefined
+    }
+  }
+
+  unsubscribe(operationName: string): void {
+    const subscription = this.$__subscriptionManager.get(operationName)
+    if (subscription) {
+      subscription.unsubscribe()
+      this.$__subscriptionManager.delete(operationName)
+    }
+  }
+
+  unsubscribeAll(): void {
+    this.$__subscriptionManager.forEach((subscription, operationName) => {
+      this.unsubscribe(operationName)
+    })
+  }
+
+  setEncryption(encrypt: boolean = false): void {
+    this.cipherLink = encrypt
+    this.$__client = this.createUrqlClient({
+      serverUri: this.serverUri,
+      socket: this.socketUri ? { socketUri: this.socketUri } : null,
+      encrypt
+    })
+  }
+
+  // Getters for compatibility
+  getAuthToken(): string {
+    return this.$__authToken
+  }
+
+  getPubKey(): string | null {
+    return this.$__pubkey
+  }
+
+  getWallet(): Wallet | null {
+    return this.$__wallet
+  }
+
+  getServerUri(): string {
+    return this.serverUri
+  }
+
+  getSocketUri(): string | null {
+    return this.socketUri
+  }
+
+  getUri(): string {
+    return this.serverUri
+  }
+
+  setUri(uri: string): void {
+    this.serverUri = uri
+    this.$__client = this.createUrqlClient({
+      serverUri: uri,
+      socket: this.socketUri ? { socketUri: this.socketUri } : null,
+      encrypt: this.cipherLink
+    })
+  }
+
+  socketDisconnect(): void {
+    if (this.socketUri) {
+      this.unsubscribeAll()
+    }
+  }
+}

package/src/libraries/Hex.ts

@@ -0,0 +1,155 @@
+/*
+                               (
+                              (/(
+                              (//(
+                              (///(
+                             (/////(
+                             (//////(                          )
+                            (////////(                        (/)
+                            (////////(                       (///)
+                           (//////////(                      (////)
+                           (//////////(                     (//////)
+                          (////////////(                    (///////)
+                         (/////////////(                   (/////////)
+                        (//////////////(                  (///////////)
+                        (///////////////(                (/////////////)
+                       (////////////////(               (//////////////)
+                      (((((((((((((((((((              (((((((((((((((
+                     (((((((((((((((((((              ((((((((((((((
+                     (((((((((((((((((((            ((((((((((((((
+                    ((((((((((((((((((((           (((((((((((((
+                    ((((((((((((((((((((          ((((((((((((
+                    (((((((((((((((((((         ((((((((((((
+                    (((((((((((((((((((        ((((((((((
+                    ((((((((((((((((((/      (((((((((
+                    ((((((((((((((((((     ((((((((
+                    (((((((((((((((((    (((((((
+                   ((((((((((((((((((  (((((
+                   #################  ##
+                   ################  #
+                  ################# ##
+                 %################  ###
+                 ###############(   ####
+                ###############      ####
+               ###############       ######
+              %#############(        (#######
+             %#############           #########
+            ############(              ##########
+           ###########                  #############
+          #########                      ##############
+        %######
+
+        Powered by Knish.IO: Connecting a Decentralized World
+
+Please visit https://github.com/WishKnish/KnishIO-Client-TS for information.
+
+License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
+*/
+
+/**
+ * Create Uint8Array buffers from hexadecimal strings, and vice versa.
+ */
+
+// Global polyfill for environments that don't have self
+if (typeof self === 'undefined') {
+  // @ts-ignore - Polyfill for environments without self
+  globalThis.self = globalThis
+}
+
+interface HexOptions {
+  grouping?: number
+  rowlength?: number
+  uppercase?: boolean
+}
+
+export default class Hex {
+  /**
+   * Converts the given buffer to a string containing its hexadecimal representation.
+   */
+  static toHex(arr: ArrayLike<number> | ArrayBuffer | Uint8Array, options?: HexOptions): string {
+    const numberToHex = (val: number, uppercase: boolean): string => {
+      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: Required<HexOptions> = Object.assign(
+      {
+        grouping: 0,
+        rowlength: 0,
+        uppercase: false
+      },
+      options || {}
+    )
+
+    // Convert to array-like structure for consistent access
+    let arrayLike: ArrayLike<number>
+    if (arr instanceof ArrayBuffer) {
+      arrayLike = new Uint8Array(arr)
+    } else {
+      arrayLike = arr as ArrayLike<number>
+    }
+
+    let str = ''
+    let group = 0
+    let column = 0
+
+    for (let i = 0; i < arrayLike.length; ++i) {
+      str += numberToHex(arrayLike[i], opts.uppercase)
+
+      if (i === arrayLike.length - 1) {
+        break
+      }
+
+      if (opts.grouping > 0 && ++group === opts.grouping) {
+        group = 0
+
+        if (opts.rowlength > 0 && ++column === opts.rowlength) {
+          column = 0
+          str += '\n'
+        } else {
+          str += ' '
+        }
+      }
+    }
+
+    return str
+  }
+
+  /**
+   * Takes a string containing hexadecimal and returns the equivalent as a Uint8Array buffer.
+   * 
+   * Whitespace is ignored. If an odd number of characters are specified,
+   * it will act as if preceded with a leading 0; that is, "FFF" is equivalent to "0FFF".
+   */
+  static toUint8Array(str: string): Uint8Array {
+    let target = str.toLowerCase().replace(/\s/g, '')
+
+    if (target.length % 2 === 1) {
+      target = `0${target}`
+    }
+
+    const buffer = new Uint8Array(Math.floor(target.length / 2))
+    let curr = -1
+
+    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 new Error('unexpected character')
+      }
+
+      if (curr === -1) {
+        curr = 16 * val
+      } else {
+        buffer[Math.floor(i / 2)] = curr + val
+        curr = -1
+      }
+    }
+
+    return buffer
+  }
+}