@wishknish/knishio-client-ts 0.7.0

package/src/query/QueryWalletList.ts

@@ -0,0 +1,106 @@
+/*
+                               (
+                              (/(
+                              (//(
+                              (///(
+                             (/////(
+                             (//////(                          )
+                            (////////(                        (/)
+                            (////////(                       (///)
+                           (//////////(                      (////)
+                           (//////////(                     (//////)
+                          (////////////(                    (///////)
+                         (/////////////(                   (/////////)
+                        (//////////////(                  (///////////)
+                        (///////////////(                (/////////////)
+                       (////////////////(               (//////////////)
+                      (((((((((((((((((((              (((((((((((((((
+                     (((((((((((((((((((              ((((((((((((((
+                     (((((((((((((((((((            ((((((((((((((
+                    ((((((((((((((((((((           (((((((((((((
+                    ((((((((((((((((((((          ((((((((((((
+                    (((((((((((((((((((         ((((((((((((
+                    (((((((((((((((((((        ((((((((((
+                    ((((((((((((((((((/      (((((((((
+                    ((((((((((((((((((     ((((((((
+                    (((((((((((((((((    (((((((
+                   ((((((((((((((((((  (((((
+                   #################  ##
+                   ################  #
+                  ################# ##
+                 %################  ###
+                 ###############(   ####
+                ###############      ####
+               ###############       ######
+              %#############(        (#######
+             %#############           #########
+            ############(              ##########
+           ###########                  #############
+          #########                      ##############
+        %######
+
+        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 Query from './Query'
+import ResponseWalletList from '../response/ResponseWalletList'
+import type { UrqlClientWrapper } from '../client/GraphQLClient'
+import type KnishIOClient from '../KnishIOClient'
+
+/**
+ * QueryWalletList class - Query for getting a list of Wallets
+ * Matches JavaScript SDK QueryWalletList implementation exactly
+ */
+export default class QueryWalletList extends Query {
+  /**
+   * Create new QueryWalletList instance
+   * Matches JavaScript SDK constructor signature exactly
+   */
+  constructor(graphQLClient: UrqlClientWrapper, knishIOClient: KnishIOClient) {
+    super(graphQLClient, knishIOClient)
+
+    this.$__query = `query( $bundleHash: String, $tokenSlug: String ) {
+      Wallet( bundleHash: $bundleHash, tokenSlug: $tokenSlug ) {
+        address,
+        bundleHash,
+        token {
+          name,
+          amount,
+          fungibility,
+          supply
+        },
+        tokenSlug,
+        batchId,
+        position,
+        amount,
+        characters,
+        pubkey,
+        createdAt,
+        tokenUnits {
+          id,
+          name,
+          metas
+        },
+        tradeRates {
+          tokenSlug,
+          amount
+        }
+      }
+    }`
+  }
+
+  /**
+   * Builds a Response object out of a JSON object
+   * Matches JavaScript SDK createResponse method exactly
+   */
+  override createResponse(json: any): ResponseWalletList {
+    return new ResponseWalletList({
+      query: this,
+      json
+    })
+  }
+}

package/src/response/EnhancedResponse.ts

@@ -0,0 +1,345 @@
+/*
+  Enhanced Response Implementation for TypeScript SDK Gold Standard
+  
+  Provides comprehensive response interface with ValidationResult patterns,
+  functional programming support, and enhanced error handling.
+*/
+
+import { z } from 'zod'
+import { 
+  UniversalResponse, 
+  EnhancedResponse, 
+  ValidationResult, 
+  ResponseError, 
+  ResponseMetadata,
+  ResponseErrorSchema,
+  ValidationResultSchema,
+  isSuccessResponse,
+  isErrorResponse
+} from '@/types/response'
+
+/**
+ * Enhanced response implementation providing comprehensive interface
+ * and functional programming patterns
+ */
+export class StandardResponse<T> implements EnhancedResponse<T> {
+  private readonly _successful: boolean
+  private readonly _payload: T | null
+  private readonly _errorMessage: string | null
+  private readonly _rawData: any
+  private readonly _metadata: ResponseMetadata
+
+  constructor(
+    successful: boolean,
+    payload: T | null = null,
+    errorMessage: string | null = null,
+    rawData: any = null,
+    metadata?: Partial<ResponseMetadata>
+  ) {
+    this._successful = successful
+    this._payload = payload
+    this._errorMessage = errorMessage
+    this._rawData = rawData
+    this._metadata = {
+      timestamp: new Date().toISOString(),
+      operation: 'unknown',
+      clientVersion: '1.0.0',
+      ...metadata
+    }
+  }
+
+  // Core response interface methods
+  success(): boolean {
+    return this._successful
+  }
+
+  payload(): T | null {
+    return this._payload
+  }
+
+  reason(): string | null {
+    return this._errorMessage
+  }
+
+  data(): any {
+    return this._rawData
+  }
+
+  // Enhanced ValidationResult integration
+  toValidationResult(): ValidationResult<T> {
+    if (this._successful && this._payload !== null) {
+      return {
+        success: true,
+        data: this._payload,
+        warnings: []
+      }
+    } else {
+      return {
+        success: false,
+        error: {
+          message: this._errorMessage || 'Unknown error',
+          context: this._rawData,
+          timestamp: this._metadata.timestamp,
+          operation: this._metadata.operation
+        }
+      }
+    }
+  }
+
+  // Functional programming combinators
+  map<U>(mapper: (value: T) => U): EnhancedResponse<U> {
+    if (this._successful && this._payload !== null) {
+      try {
+        const mappedValue = mapper(this._payload)
+        return new StandardResponse(true, mappedValue, null, this._rawData, this._metadata)
+      } catch (error) {
+        return new StandardResponse(false, null, `Mapping failed: ${error instanceof Error ? error.message : String(error)}`, this._rawData, this._metadata)
+      }
+    } else {
+      return new StandardResponse(false, null, this._errorMessage, this._rawData, this._metadata)
+    }
+  }
+
+  flatMap<U>(mapper: (value: T) => EnhancedResponse<U>): EnhancedResponse<U> {
+    if (this._successful && this._payload !== null) {
+      try {
+        return mapper(this._payload)
+      } catch (error) {
+        return new StandardResponse(false, null, `FlatMap failed: ${error instanceof Error ? error.message : String(error)}`, this._rawData, this._metadata)
+      }
+    } else {
+      return new StandardResponse(false, null, this._errorMessage, this._rawData, this._metadata)
+    }
+  }
+
+  filter(predicate: (value: T) => boolean): EnhancedResponse<T> {
+    if (this._successful && this._payload !== null) {
+      try {
+        if (predicate(this._payload)) {
+          return this
+        } else {
+          return new StandardResponse(false, null, 'Filter predicate failed', this._rawData, this._metadata)
+        }
+      } catch (error) {
+        return new StandardResponse(false, null, `Filter failed: ${error instanceof Error ? error.message : String(error)}`, this._rawData, this._metadata)
+      }
+    } else {
+      return this
+    }
+  }
+
+  // Enhanced error handling with callbacks
+  onSuccess(callback: (payload: T) => void): EnhancedResponse<T> {
+    if (this._successful && this._payload !== null) {
+      try {
+        callback(this._payload)
+      } catch (error) {
+        console.warn('Response.onSuccess callback failed:', error)
+      }
+    }
+    return this
+  }
+
+  onFailure(callback: (error: string) => void): EnhancedResponse<T> {
+    if (!this._successful) {
+      try {
+        callback(this._errorMessage || 'Unknown error')
+      } catch (error) {
+        console.warn('Response.onFailure callback failed:', error)
+      }
+    }
+    return this
+  }
+
+  // Promise integration for async patterns
+  toPromise(): Promise<T> {
+    if (this._successful && this._payload !== null) {
+      return Promise.resolve(this._payload)
+    } else {
+      return Promise.reject(new Error(this._errorMessage || 'Unknown error'))
+    }
+  }
+
+  // Enhanced debugging with optional labels
+  debug(label?: string): EnhancedResponse<T> {
+    const debugPrefix = label ? `[${label}]` : '[Response]'
+    
+    if (this._successful) {
+      console.debug(`${debugPrefix} Success:`, {
+        payload: this._payload,
+        metadata: this._metadata
+      })
+    } else {
+      console.debug(`${debugPrefix} Failure:`, {
+        error: this._errorMessage,
+        rawData: this._rawData,
+        metadata: this._metadata
+      })
+    }
+    
+    return this
+  }
+
+  // Factory methods for enhanced response creation
+  static success<T>(payload: T, rawData?: any, metadata?: Partial<ResponseMetadata>): StandardResponse<T> {
+    return new StandardResponse(true, payload, null, rawData, metadata)
+  }
+
+  static failure<T>(errorMessage: string | ResponseError, rawData?: any, metadata?: Partial<ResponseMetadata>): StandardResponse<T> {
+    const message = typeof errorMessage === 'string' ? errorMessage : errorMessage.message
+    return new StandardResponse(false, null, message, rawData, metadata)
+  }
+
+  static fromValidationResult<T>(result: ValidationResult<T>, rawData?: any, metadata?: Partial<ResponseMetadata>): StandardResponse<T> {
+    if (result.success && result.data !== undefined) {
+      return new StandardResponse(true, result.data, null, rawData, {
+        ...metadata,
+        warnings: result.warnings
+      })
+    } else {
+      return new StandardResponse(false, null, result.error?.message || 'Validation failed', rawData, {
+        ...metadata,
+        error: result.error
+      })
+    }
+  }
+
+  // Enhanced error information extraction
+  getErrorDetails(): ResponseError | null {
+    if (!this._successful) {
+      return {
+        message: this._errorMessage || 'Unknown error',
+        context: this._metadata.operation,
+        timestamp: this._metadata.timestamp,
+        operation: this._metadata.operation
+      }
+    }
+    return null
+  }
+
+  // Response metadata access
+  getMetadata(): ResponseMetadata {
+    return { ...this._metadata }
+  }
+
+  // Enhanced response validation
+  validate(): ValidationResult<T> {
+    try {
+      const validationResult = ValidationResultSchema.parse(this.toValidationResult())
+      return {
+        success: true,
+        data: this._payload as T,
+        warnings: ['Response validation successful']
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          message: 'Response validation failed',
+          details: [error instanceof Error ? error.message : String(error)]
+        }
+      }
+    }
+  }
+}
+
+// Factory class for creating standardized responses
+export class ResponseFactory {
+  
+  static createSuccessResponse<T>(
+    payload: T, 
+    operation: string,
+    rawData?: any,
+    duration?: number
+  ): StandardResponse<T> {
+    return StandardResponse.success(payload, rawData, {
+      operation,
+      duration,
+      timestamp: new Date().toISOString()
+    })
+  }
+
+  static createErrorResponse<T>(
+    errorMessage: string,
+    operation: string, 
+    rawData?: any,
+    duration?: number
+  ): StandardResponse<T> {
+    return StandardResponse.failure(errorMessage, rawData, {
+      operation,
+      duration,
+      timestamp: new Date().toISOString()
+    })
+  }
+
+  static fromLegacyResponse<T>(
+    legacyResponse: any,
+    operation: string
+  ): StandardResponse<T> {
+    try {
+      const isSuccessful = legacyResponse?.success?.() ?? false
+      const payload = legacyResponse?.payload?.() ?? null
+      const errorMessage = legacyResponse?.error?.() ?? legacyResponse?.reason?.() ?? null
+      const rawData = legacyResponse?.data?.() ?? legacyResponse
+
+      return isSuccessful 
+        ? StandardResponse.success(payload, rawData, { operation })
+        : StandardResponse.failure(errorMessage || 'Unknown error', rawData, { operation })
+    } catch (error) {
+      return StandardResponse.failure(
+        `Legacy response conversion failed: ${error instanceof Error ? error.message : String(error)}`,
+        legacyResponse,
+        { operation }
+      )
+    }
+  }
+}
+
+// Enhanced response utilities
+export class ResponseUtils {
+  
+  static combineResponses<T>(responses: EnhancedResponse<T>[]): EnhancedResponse<T[]> {
+    const successful = responses.every(r => r.success())
+    
+    if (successful) {
+      const payloads = responses.map(r => r.payload()).filter((p): p is T => p !== null)
+      return StandardResponse.success(payloads, responses, { operation: 'combineResponses' })
+    } else {
+      const errors = responses.filter(r => !r.success()).map(r => r.reason()).join('; ')
+      return StandardResponse.failure(`Combined operation failed: ${errors}`, responses, { operation: 'combineResponses' })
+    }
+  }
+
+  static async sequenceResponses<T>(
+    operations: (() => Promise<EnhancedResponse<T>>)[]
+  ): Promise<EnhancedResponse<T[]>> {
+    const results: EnhancedResponse<T>[] = []
+    
+    for (const operation of operations) {
+      try {
+        const result = await operation()
+        results.push(result)
+        
+        if (!result.success()) {
+          // Fail fast on first error
+          return StandardResponse.failure(
+            `Sequence failed at operation ${results.length}: ${result.reason()}`,
+            results,
+            { operation: 'sequenceResponses' }
+          )
+        }
+      } catch (error) {
+        return StandardResponse.failure(
+          `Sequence failed with exception: ${error instanceof Error ? error.message : String(error)}`,
+          results,
+          { operation: 'sequenceResponses' }
+        )
+      }
+    }
+    
+    const payloads = results.map(r => r.payload()).filter((p): p is T => p !== null)
+    return StandardResponse.success(payloads, results, { operation: 'sequenceResponses' })
+  }
+}
+
+export default StandardResponse

package/src/response/Response.ts

@@ -0,0 +1,254 @@
+/*
+                               (
+                              (/(
+                              (//(
+                              (///(
+                             (/////(
+                             (//////(                          )
+                            (////////(                        (/)
+                            (////////(                       (///)
+                           (//////////(                      (////)
+                           (//////////(                     (//////)
+                          (////////////(                    (///////)
+                         (/////////////(                   (/////////)
+                        (//////////////(                  (///////////)
+                        (///////////////(                (/////////////)
+                       (////////////////(               (//////////////)
+                      (((((((((((((((((((              (((((((((((((((
+                     (((((((((((((((((((              ((((((((((((((
+                     (((((((((((((((((((            ((((((((((((((
+                    ((((((((((((((((((((           (((((((((((((
+                    ((((((((((((((((((((          ((((((((((((
+                    (((((((((((((((((((         ((((((((((((
+                    (((((((((((((((((((        ((((((((((
+                    ((((((((((((((((((/      (((((((((
+                    ((((((((((((((((((     ((((((((
+                    (((((((((((((((((    (((((((
+                   ((((((((((((((((((  (((((
+                   #################  ##
+                   ################  #
+                  ################# ##
+                 %################  ###
+                 ###############(   ####
+                ###############      ####
+               ###############       ######
+              %#############(        (#######
+             %#############           #########
+            ############(              ##########
+           ###########                  #############
+          #########                      ##############
+        %######
+
+        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 { InvalidResponseException, UnauthenticatedException } from '@/exception'
+import Dot from '@/libraries/Dot'
+import type Query from '@/query/Query'
+import { StandardResponse, ResponseFactory } from './EnhancedResponse'
+import { UniversalResponse, ValidationResult } from '@/types/response'
+
+/**
+ * Base Response class for processing node responses
+ * Enhanced with standardized interface and ValidationResult support
+ */
+export default class Response implements UniversalResponse<any> {
+  protected dataKey: string | null
+  protected errorKey: string = 'exception'
+  protected $__payload: any = null
+  protected $__query: Query
+  protected $__originResponse: any
+  protected $__response: any
+
+  /**
+   * Class constructor
+   */
+  constructor({
+    query,
+    json,
+    dataKey = null
+  }: {
+    query: Query
+    json: any
+    dataKey?: string | null
+  }) {
+    this.dataKey = dataKey
+    this.$__query = query
+    this.$__originResponse = json
+    this.$__response = json
+
+    if (typeof this.$__response === 'undefined' || this.$__response === null) {
+      throw new InvalidResponseException()
+    }
+
+    if (Dot.has(this.$__response, this.errorKey)) {
+      const error = Dot.get(this.$__response, this.errorKey)
+
+      if (String(error).includes('Unauthenticated')) {
+        throw new UnauthenticatedException()
+      }
+
+      throw new InvalidResponseException()
+    }
+
+    this.init()
+  }
+
+  /**
+   * Initialize response - can be overridden by subclasses
+   */
+  protected init(): void {
+    // Override in subclasses
+  }
+
+  /**
+   * Get response data
+   */
+  data(): any {
+    if (!this.dataKey) {
+      return this.response()
+    }
+
+    // Check key & return custom data from the response
+    if (!Dot.has(this.response(), this.dataKey)) {
+      throw new InvalidResponseException()
+    }
+
+    return Dot.get(this.response(), this.dataKey)
+  }
+
+  /**
+   * Get raw response
+   */
+  response(): any {
+    return this.$__response
+  }
+
+  /**
+   * Get response payload
+   */
+  payload(): any {
+    return this.$__payload
+  }
+
+  /**
+   * Check if response was successful
+   */
+  success(): boolean {
+    // Default implementation - can be overridden
+    return !this.$__response?.errors?.length
+  }
+
+  /**
+   * Get error message if any
+   */
+  error(): string | null {
+    if (this.$__response?.errors?.length) {
+      return this.$__response.errors[0].message || 'Unknown error'
+    }
+    return null
+  }
+
+  /**
+   * Enhanced interface methods for standardized response handling
+   */
+  
+  /**
+   * Get error reason (alias for error() to match standardized interface)
+   */
+  reason(): string | null {
+    return this.error()
+  }
+
+  /**
+   * Convert to enhanced response with ValidationResult support
+   */
+  toEnhanced<T>(): StandardResponse<T> {
+    return ResponseFactory.fromLegacyResponse<T>(this, this.constructor.name)
+  }
+
+  /**
+   * Convert to ValidationResult for enhanced error handling
+   */
+  toValidationResult<T>(): ValidationResult<T> {
+    if (this.success() && this.payload() !== null) {
+      return {
+        success: true,
+        data: this.payload() as T,
+        warnings: []
+      }
+    } else {
+      return {
+        success: false,
+        error: {
+          message: this.reason() || 'Unknown error',
+          context: this.constructor.name,
+          details: this.$__response?.errors || []
+        }
+      }
+    }
+  }
+
+  /**
+   * Enhanced error handling with callbacks (matches enhanced interface)
+   */
+  onSuccess(callback: (payload: any) => void): Response {
+    if (this.success() && this.payload() !== null) {
+      try {
+        callback(this.payload())
+      } catch (error) {
+        console.warn('Response.onSuccess callback failed:', error)
+      }
+    }
+    return this
+  }
+
+  onFailure(callback: (error: string) => void): Response {
+    if (!this.success()) {
+      try {
+        callback(this.reason() || 'Unknown error')
+      } catch (error) {
+        console.warn('Response.onFailure callback failed:', error)
+      }
+    }
+    return this
+  }
+
+  /**
+   * Debug logging with enhanced context
+   */
+  debug(label?: string): Response {
+    const debugPrefix = label ? `[${label}]` : `[${this.constructor.name}]`
+    
+    if (this.success()) {
+      console.debug(`${debugPrefix} Success:`, {
+        payload: this.payload(),
+        query: this.$__query?.constructor?.name,
+        dataKey: this.dataKey
+      })
+    } else {
+      console.debug(`${debugPrefix} Failure:`, {
+        error: this.reason(),
+        errors: this.$__response?.errors,
+        rawData: this.$__response
+      })
+    }
+    
+    return this
+  }
+
+  /**
+   * Promise conversion for enhanced async patterns
+   */
+  toPromise<T>(): Promise<T> {
+    if (this.success() && this.payload() !== null) {
+      return Promise.resolve(this.payload() as T)
+    } else {
+      return Promise.reject(new Error(this.reason() || 'Unknown error'))
+    }
+  }
+}