@wishknish/knishio-client-ts 0.7.2 → 0.7.6

package/src/mutation/MutationCreateRule.ts

@@ -65,8 +65,8 @@ export default class MutationCreateRule extends MutationProposeMolecule {
   }: {
     metaType: MetaType
     metaId: MetaId
-    rule: Record<string, any>[]
-    policy: Record<string, any>
+    rule: any[] | any  // Accept single object or array
+    policy?: Record<string, any> | null
   }): void {
     (this.$__molecule as any).createRule({
       metaType,

package/src/mutation/MutationPeering.ts

@@ -0,0 +1,37 @@
+/*
+        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 MutationProposeMolecule from './MutationProposeMolecule'
+import ResponsePeering from '../response/ResponsePeering'
+
+/**
+ * Mutation for registering a peer node via the P-isotope
+ * Matches JavaScript SDK MutationPeering implementation exactly
+ */
+export default class MutationPeering extends MutationProposeMolecule {
+  /**
+   * Fills a molecule with a P-isotope peering atom
+   * Matches JavaScript SDK fillMolecule method exactly
+   */
+  override fillMolecule({ host }: { host: string }): void {
+    (this.$__molecule as any).initPeering({ host });
+    (this.$__molecule as any).sign({});
+    (this.$__molecule as any).check()
+  }
+
+  /**
+   * Builds a Response object out of a JSON object
+   * Matches JavaScript SDK createResponse method exactly
+   */
+  override createResponse(json: any): ResponsePeering {
+    return new ResponsePeering({
+      query: this,
+      json
+    })
+  }
+}

package/src/mutation/MutationRequestAuthorization.ts

@@ -59,9 +59,9 @@ export default class MutationRequestAuthorization extends MutationProposeMolecul
    * Matches JavaScript SDK fillMolecule method exactly
    */
   override fillMolecule({ meta }: { meta: any }): void {
-    (this.$__molecule as any).initAuthorization({ meta });
-    (this.$__molecule as any).sign({});
-    (this.$__molecule as any).check()
+    this.$__molecule.initAuthorization({ meta })
+    this.$__molecule.sign({})
+    this.$__molecule.check()
   }
 
   /**

package/src/query/Query.ts

@@ -151,12 +151,12 @@ export default class Query {
   /**
    * Executes the Query and returns a Response
    */
-  async execute({ 
-    variables = {}, 
-    context = {} 
-  }: { 
-    variables?: Record<string, any>
-    context?: Record<string, any> 
+  async execute({
+    variables = null,
+    context = {}
+  }: {
+    variables?: Record<string, any> | null
+    context?: Record<string, any>
   } = {}): Promise<Response | null> {
     this.$__request = this.createQuery({ variables })
 

package/src/query/QueryActiveSession.ts

@@ -71,7 +71,6 @@ export default class QueryActiveSession extends Query {
           metaId
           jsonData
           createdAt
-          updatedAt
         }
       }
     `

package/src/query/QueryAtom.ts

@@ -156,33 +156,33 @@ export default class QueryAtom extends Query {
     latest,
     queryArgs
   }: {
-    molecularHashes?: string[]
-    molecularHash?: string
-    bundleHashes?: string[]
-    bundleHash?: string
-    positions?: string[]
-    position?: string
-    walletAddresses?: string[]
-    walletAddress?: string
-    isotopes?: string[]
-    isotope?: string
-    tokenSlugs?: string[]
-    tokenSlug?: string
-    cellSlugs?: string[]
-    cellSlug?: string
-    batchIds?: string[]
-    batchId?: string
-    values?: string[]
-    value?: string | number
-    metaTypes?: string[]
-    metaType?: string
-    metaIds?: string[]
-    metaId?: string
-    indexes?: number[]
-    index?: number
-    filter?: object[]
-    latest?: boolean
-    queryArgs?: object
+    molecularHashes?: string[] | null
+    molecularHash?: string | null
+    bundleHashes?: string[] | null
+    bundleHash?: string | null
+    positions?: string[] | null
+    position?: string | null
+    walletAddresses?: string[] | null
+    walletAddress?: string | null
+    isotopes?: string[] | null
+    isotope?: string | null
+    tokenSlugs?: string[] | null
+    tokenSlug?: string | null
+    cellSlugs?: string[] | null
+    cellSlug?: string | null
+    batchIds?: string[] | null
+    batchId?: string | null
+    values?: string[] | null
+    value?: string | number | null
+    metaTypes?: string[] | null
+    metaType?: string | null
+    metaIds?: string[] | null
+    metaId?: string | null
+    indexes?: number[] | null
+    index?: number | null
+    filter?: object[] | null
+    latest?: boolean | null
+    queryArgs?: object | null
   }): Record<string, any> {
     if (molecularHash) {
       molecularHashes = molecularHashes || []

package/src/query/QueryContinuId.ts

@@ -79,6 +79,14 @@ export default class QueryContinuId extends Query {
     }`
   }
 
+  /**
+   * Force network-only for ContinuID queries to prevent URQL cache from
+   * returning stale wallet positions after mutations advance the ContinuID chain
+   */
+  override createQueryContext(): Record<string, any> {
+    return { requestPolicy: 'network-only' }
+  }
+
   /**
    * Returns a Response object
    * Matches JavaScript SDK createResponse method exactly

package/src/query/QueryMetaType.ts

@@ -114,7 +114,7 @@ export default class QueryMetaType extends Query {
     latest?: boolean | null
     filter?: any | null
     queryArgs?: any | null
-    count?: string | null
+    count?: string | number | null
     countBy?: string | null
     cellSlug?: string | null
   } = {}): Record<string, any> {

package/src/query/QueryMetaTypeViaMolecule.ts

@@ -0,0 +1,221 @@
+/*
+                               (
+                              (/(
+                              (//(
+                              (///(
+                             (/////(
+                             (//////(                          )
+                            (////////(                        (/)
+                            (////////(                       (///)
+                           (//////////(                      (////)
+                           (//////////(                     (//////)
+                          (////////////(                    (///////)
+                         (/////////////(                   (/////////)
+                        (//////////////(                  (///////////)
+                        (///////////////(                (//////////////)
+                       (////////////////(               (///////////////)
+                      (((((((((((((((((((              (((((((((((((((
+                     (((((((((((((((((((              ((((((((((((((
+                     (((((((((((((((((((            ((((((((((((((
+                    ((((((((((((((((((((           (((((((((((((
+                    ((((((((((((((((((((          ((((((((((((
+                    (((((((((((((((((((         ((((((((((((
+                    (((((((((((((((((((        ((((((((((
+                    ((((((((((((((((((/      (((((((((
+                    ((((((((((((((((((     ((((((((
+                    (((((((((((((((((    (((((((
+                   ((((((((((((((((((  (((((
+                   #################  ##
+                   ################  #
+                  ################# ##
+                 %################  ###
+                 ###############(   ####
+                ###############      ####
+               ###############       ######
+              %#############(        (#######
+             %#############           #########
+            ############(              ##########
+           ###########                  #############
+          #########                      ##############
+        %######
+
+        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 ResponseMetaTypeViaMolecule from '../response/ResponseMetaTypeViaMolecule'
+import { gql } from '@urql/core'
+import type { GraphQLClient } from '../types/graphql'
+import type KnishIOClient from '../KnishIOClient'
+
+/**
+ * Query for retrieving Meta Asset information via Molecule data.
+ *
+ * Unlike QueryMetaTypeViaAtom, this query includes molecule data with atoms
+ * (including otsFragment and metasJson) for integrity verification and
+ * client-side metadata extraction.
+ */
+export default class QueryMetaTypeViaMolecule extends Query {
+  /**
+   * Create new QueryMetaTypeViaMolecule instance
+   */
+  constructor(graphQLClient: GraphQLClient, knishIOClient: 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!], $cellSlugs: [String!] ) {
+      MetaTypeViaAtom(
+        metaTypes: $metaTypes
+        metaIds: $metaIds
+        atomValues: $atomValues
+        cellSlugs: $cellSlugs
+        filter: $filter,
+        latest: $latest,
+        queryArgs: $queryArgs
+        countBy: $countBy
+      ) {
+        metaType,
+        instanceCount {
+          key,
+          value
+        },
+        instances {
+          metaType,
+          metaId,
+          createdAt,
+          metas( values: $values, keys: $keys ) {
+            molecularHash,
+            position,
+            key,
+            value,
+            createdAt
+          },
+          molecule {
+            molecularHash,
+            bundleHash,
+            cellSlug,
+            status,
+            createdAt,
+            atoms {
+              position,
+              walletAddress,
+              isotope,
+              tokenSlug,
+              value,
+              batchId,
+              metaType,
+              metaId,
+              index,
+              createdAt,
+              otsFragment,
+              metasJson
+            }
+          }
+        },
+        paginatorInfo {
+          currentPage,
+          total
+        }
+      }
+    }`
+  }
+
+  /**
+   * Builds a GraphQL-friendly variables object based on input fields
+   */
+  static createVariables({
+    metaType = null,
+    metaId = null,
+    key = null,
+    value = null,
+    keys = null,
+    values = null,
+    atomValues = null,
+    latest = null,
+    filter = null,
+    queryArgs = null,
+    countBy = null,
+    cellSlug = null
+  }: {
+    metaType?: string | string[] | null
+    metaId?: string | string[] | null
+    key?: string | null
+    value?: string | null
+    keys?: string[] | null
+    values?: string[] | null
+    atomValues?: string[] | null
+    latest?: boolean | null
+    filter?: any[] | null
+    queryArgs?: any | null
+    countBy?: string | null
+    cellSlug?: string | string[] | null
+  } = {}): Record<string, any> {
+    const variables: Record<string, any> = {}
+
+    if (atomValues) {
+      variables.atomValues = atomValues
+    }
+
+    if (keys) {
+      variables.keys = keys
+    }
+
+    if (values) {
+      variables.values = values
+    }
+
+    if (metaType) {
+      variables.metaTypes = typeof metaType === 'string' ? [metaType] : metaType
+    }
+
+    if (metaId) {
+      variables.metaIds = typeof metaId === 'string' ? [metaId] : metaId
+    }
+
+    if (cellSlug) {
+      variables.cellSlugs = typeof cellSlug === 'string' ? [cellSlug] : cellSlug
+    }
+
+    if (countBy) {
+      variables.countBy = countBy
+    }
+
+    if (filter) {
+      variables.filter = filter
+    }
+
+    if (key && value) {
+      variables.filter = variables.filter || []
+      variables.filter.push({
+        key,
+        value,
+        comparison: '='
+      })
+    }
+
+    variables.latest = latest === true
+
+    if (queryArgs) {
+      if (typeof queryArgs.limit === 'undefined' || queryArgs.limit === 0) {
+        queryArgs.limit = '*'
+      }
+
+      variables.queryArgs = queryArgs
+    }
+
+    return variables
+  }
+
+  /**
+   * Returns a Response object
+   */
+  override createResponse(json: any): ResponseMetaTypeViaMolecule {
+    return new ResponseMetaTypeViaMolecule({
+      query: this,
+      json
+    })
+  }
+}

package/src/query/QueryWalletList.ts

@@ -64,8 +64,8 @@ export default class QueryWalletList extends Query {
   constructor(graphQLClient: GraphQLClient, knishIOClient: KnishIOClient) {
     super(graphQLClient, knishIOClient)
 
-    this.$__query = gql`query( $bundleHash: String, $tokenSlug: String ) {
-      Wallet( bundleHash: $bundleHash, tokenSlug: $tokenSlug ) {
+    this.$__query = gql`query( $bundleHash: String, $token: String ) {
+      Wallet( bundleHash: $bundleHash, token: $token ) {
         address,
         bundleHash,
         token {

package/src/response/Response.ts

@@ -95,6 +95,17 @@ export default class Response implements UniversalResponse<any> {
       throw new InvalidResponseException()
     }
 
+    // Check for GraphQL errors array
+    if (this.$__response.errors && Array.isArray(this.$__response.errors) && this.$__response.errors.length > 0) {
+      const errorMessage = this.$__response.errors[0].message || 'Unknown GraphQL error'
+
+      if (errorMessage.includes('Unauthenticated')) {
+        throw new UnauthenticatedException('Unauthenticated request')
+      }
+
+      throw new InvalidResponseException(`GraphQL Error: ${errorMessage}`)
+    }
+
     this.init()
   }
 
@@ -113,9 +124,14 @@ export default class Response implements UniversalResponse<any> {
       return this.response()
     }
 
+    // Check if response has data field
+    if (!this.response().data) {
+      throw new InvalidResponseException('Response has no data field')
+    }
+
     // Check key & return custom data from the response
     if (!Dot.has(this.response(), this.dataKey)) {
-      throw new InvalidResponseException()
+      throw new InvalidResponseException(`Missing expected field: ${this.dataKey}`)
     }
 
     return Dot.get(this.response(), this.dataKey)

package/src/response/ResponseAppendRequest.ts

@@ -0,0 +1,17 @@
+/*
+        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 ResponseProposeMolecule from './ResponseProposeMolecule'
+
+/**
+ * Response for append requests via A-isotope
+ * Matches JavaScript SDK ResponseAppendRequest implementation exactly
+ */
+export default class ResponseAppendRequest extends ResponseProposeMolecule {
+
+}

package/src/response/ResponseBalance.ts

@@ -77,7 +77,10 @@ export default class ResponseBalance extends Response {
    * Matches JavaScript SDK payload() method exactly
    */
   override payload(): Wallet | null {
-    const walletData = this.data() as any
+    const balanceData = this.data() as any
+
+    // Balance query returns an array, get the first result
+    const walletData = Array.isArray(balanceData) ? balanceData[0] : balanceData
 
     if (!walletData || !walletData.bundleHash || !walletData.tokenSlug) {
       return null
@@ -102,7 +105,9 @@ export default class ResponseBalance extends Response {
   }): Wallet {
     let wallet: Wallet
 
-    if (data.position === null || typeof data.position === 'undefined') {
+    // Handle null, undefined, or empty string positions
+    // Empty positions occur for shadow wallets created before this fix
+    if (!data.position) {
       wallet = Wallet.create({
         bundle: data.bundleHash,
         token: data.tokenSlug,
@@ -144,7 +149,7 @@ export default class ResponseBalance extends Response {
     }
 
     // Set balance and other properties
-    wallet.balance = Number(data.amount || 0)
+    wallet.balance = String(data.amount != null ? data.amount : 0)
     wallet.pubkey = data.pubkey
     wallet.createdAt = data.createdAt
 

package/src/response/ResponseContinuId.ts

@@ -93,7 +93,7 @@ export default class ResponseContinuId extends Response {
       wallet.batchId = continuId.batchId
       wallet.characters = continuId.characters
       wallet.pubkey = continuId.pubkey
-      wallet.balance = continuId.amount * 1.0
+      wallet.balance = String(continuId.amount != null ? continuId.amount : 0)
     }
 
     return wallet

package/src/response/ResponseMetaType.ts

@@ -72,37 +72,50 @@ export default class ResponseMetaType extends Response {
     })
   }
 
+  /**
+   * Extracts payload from metaData object
+   */
+  private extractPayload(metaData: any): any {
+    return {
+      instances: metaData?.instances || [],
+      instanceCount: metaData?.instanceCount || [],
+      paginatorInfo: metaData?.paginatorInfo || {}
+    }
+  }
+
   /**
    * Returns meta type instance results
-   * Matches JavaScript SDK payload method exactly
+   * Handles various response formats from server:
+   * - Array of results (normal case)
+   * - Single object (filtered queries)
+   * - null/undefined (no results)
+   * - Empty array (no matching data)
    */
   override payload(): any | null {
     const metaTypeData = this.data()
 
-    if (!metaTypeData || metaTypeData.length === 0) {
+    // Handle null/undefined responses
+    if (metaTypeData === null || metaTypeData === undefined) {
       return null
     }
 
-    const response: any = {
-      instances: {},
-      instanceCount: {},
-      paginatorInfo: {}
-    }
-
-    const metaData = metaTypeData.pop()
-
-    if (metaData.instances) {
-      response.instances = metaData.instances
-    }
-
-    if (metaData.instanceCount) {
-      response.instanceCount = metaData.instanceCount
+    // Handle array response (expected format)
+    if (Array.isArray(metaTypeData)) {
+      if (metaTypeData.length === 0) {
+        // Return empty structure instead of null for empty results
+        return this.extractPayload(null)
+      }
+      // Get last element without mutating the array
+      const metaData = metaTypeData[metaTypeData.length - 1]
+      return this.extractPayload(metaData)
     }
 
-    if (metaData.paginatorInfo) {
-      response.paginatorInfo = metaData.paginatorInfo
+    // Handle single object response (some filtered queries)
+    if (typeof metaTypeData === 'object') {
+      return this.extractPayload(metaTypeData)
     }
 
-    return response
+    // Unknown format, return null
+    return null
   }
 }