@ic-reactor/candid 3.0.11-beta.1 → 3.0.12-beta.0

package/src/visitor/returns/index.test.ts

@@ -1,5 +1,4 @@
 import { describe, it, expect } from "vitest"
-import { IDL } from "../types"
 import { ResultFieldVisitor } from "./index"
 import type {
   ResultNode,
@@ -19,6 +18,7 @@ import type {
   MethodMeta,
   ServiceMeta,
 } from "./types"
+import { IDL } from "@icp-sdk/core/candid"
 
 describe("ResultFieldVisitor", () => {
   const visitor = new ResultFieldVisitor()
@@ -1974,3 +1974,165 @@ describe("ResultFieldVisitor", () => {
     })
   })
 })
+
+describe("ResultFieldVisitor Reproduction - User reported issue", () => {
+  const visitor = new ResultFieldVisitor()
+
+  it("should handle record data provided as an array (tuple-like) even if IDL has names", () => {
+    const Rule = IDL.Variant({
+      Quorum: IDL.Record({
+        min_approved: IDL.Nat,
+        approvers: IDL.Variant({ Group: IDL.Vec(IDL.Principal) }),
+      }),
+    })
+
+    const NamedRule = IDL.Record({
+      description: IDL.Opt(IDL.Text),
+      id: IDL.Text,
+      name: IDL.Text,
+      rule: Rule,
+    })
+
+    const field = visitor.visitRecord(
+      NamedRule,
+      [
+        ["description", IDL.Opt(IDL.Text)],
+        ["id", IDL.Text],
+        ["name", IDL.Text],
+        ["rule", Rule],
+      ],
+      "NamedRule"
+    )
+
+    // Simulate lib-agent returning an array for a named record
+    const arrayData = [
+      [], // description (empty opt)
+      "1253ec41-ef1d-4317-bb82-2366fc34f37c", // id
+      "Admin approval", // name
+      { Quorum: { min_approved: BigInt(1), approvers: { Group: [] } } }, // rule
+    ]
+
+    // Before the fix, this would throw because arrayData["rule"] is undefined
+    const resolved = field.resolve(arrayData)
+
+    expect(resolved.fields.id.value).toBe(
+      "1253ec41-ef1d-4317-bb82-2366fc34f37c"
+    )
+    expect(resolved.fields.name.value).toBe("Admin approval")
+
+    const ruleNode = resolved.fields.rule as VariantNode
+    expect(ruleNode.selected).toBe("Quorum")
+  })
+
+  it("should handle already transformed variant data with _type", () => {
+    const Rule = IDL.Variant({
+      Quorum: IDL.Text,
+    })
+
+    const field = visitor.visitVariant(Rule, [["Quorum", IDL.Text]], "Rule")
+
+    // Data transformed by DisplayCodecVisitor
+    const transformedData = {
+      _type: "Quorum",
+      Quorum: "some text",
+    }
+
+    // Before the fix, this would throw because transformedData["Quorum"] is there but
+    // Object.keys(transformedData)[0] is "_type"
+    const resolved = field.resolve(transformedData)
+
+    expect(resolved.selected).toBe("Quorum")
+    expect(resolved.selectedOption.value).toBe("some text")
+  })
+
+  it("should handle already transformed optional data (unwrapped)", () => {
+    const OptText = IDL.Opt(IDL.Text)
+    const field = visitor.visitOpt(OptText, IDL.Text, "maybeText")
+
+    // Raw format is [value]
+    expect(field.resolve(["hello"]).value?.value).toBe("hello")
+    expect(field.resolve([]).value).toBeNull()
+
+    // Transformed format is just the value
+    expect(field.resolve("hello").value?.value).toBe("hello")
+    expect(field.resolve(null).value).toBeNull()
+    expect(field.resolve(undefined).value).toBeNull()
+  })
+
+  it("should provide a better error message when an option is missing", () => {
+    const MyVariant = IDL.Variant({ A: IDL.Null, B: IDL.Null })
+    const field = visitor.visitVariant(
+      MyVariant,
+      [
+        ["A", IDL.Null],
+        ["B", IDL.Null],
+      ],
+      "MyVariant"
+    )
+
+    expect(() => field.resolve({ C: null })).toThrow(
+      /Option C not found in variant MyVariant. Available options: A, B/
+    )
+  })
+
+  describe("Recursive types", () => {
+    it("should handle recursive variant with transformed data", () => {
+      const Rule = IDL.Rec()
+      const RuleType = IDL.Variant({
+        Quorum: IDL.Record({
+          min_approved: IDL.Nat,
+        }),
+        Nested: Rule,
+      })
+      Rule.fill(RuleType)
+
+      const field = visitor.visitRec(Rule, RuleType, "rule")
+
+      // Transformed data (using _type)
+      const transformedData = {
+        _type: "Quorum",
+        Quorum: {
+          min_approved: "1",
+        },
+      }
+
+      // This should work because Rule.resolve calls Variant.resolve
+      const resolved = field.resolve(transformedData) as RecursiveNode
+      const variantNode = resolved.inner as VariantNode
+
+      expect(variantNode.selected).toBe("Quorum")
+      expect(variantNode.selectedOption.type).toBe("record")
+    })
+
+    it("should handle deeply nested recursive variant with transformed data", () => {
+      const Rule = IDL.Rec()
+      const RuleType = IDL.Variant({
+        Quorum: IDL.Record({
+          min_approved: IDL.Nat,
+        }),
+        Nested: Rule,
+      })
+      Rule.fill(RuleType)
+
+      const field = visitor.visitRec(Rule, RuleType, "rule")
+
+      const transformedData = {
+        _type: "Nested",
+        Nested: {
+          _type: "Quorum",
+          Quorum: {
+            min_approved: "2",
+          },
+        },
+      }
+
+      const resolved = field.resolve(transformedData) as RecursiveNode
+      const variantNode = resolved.inner as VariantNode
+      expect(variantNode.selected).toBe("Nested")
+
+      const nestedResolved = variantNode.selectedOption as RecursiveNode
+      const innerVariant = nestedResolved.inner as VariantNode
+      expect(innerVariant.selected).toBe("Quorum")
+    })
+  })
+})

package/src/visitor/returns/index.ts

@@ -1,6 +1,5 @@
 import { isQuery } from "../helpers"
 import { checkTextFormat, checkNumberFormat } from "../constants"
-import { IDL } from "../types"
 import type {
   ResultNode,
   ResolvedNode,
@@ -12,8 +11,8 @@ import type {
   TextFormat,
 } from "./types"
 
-export * from "./types"
-import { sha256 } from "@noble/hashes/sha2"
+import { sha256 } from "@noble/hashes/sha2.js"
+import { IDL } from "@icp-sdk/core/candid"
 import { DisplayCodecVisitor, uint8ArrayToHex } from "@ic-reactor/core"
 import type {
   ActorMethodReturnType,
@@ -48,11 +47,17 @@ function primitiveNode<T extends NodeType>(
     displayType,
     ...extras,
     resolve(data: unknown): ResolvedNode<T> {
-      return {
-        ...node,
-        value: codec.decode(data),
-        raw: data,
-      } as unknown as ResolvedNode<T>
+      try {
+        return {
+          ...node,
+          value: codec.decode(data),
+          raw: data,
+        } as unknown as ResolvedNode<T>
+      } catch (e) {
+        throw new Error(
+          `Failed to decode field "${label}" of type ${type} (${candidType}) with data: ${JSON.stringify(data)}. Error: ${e}`
+        )
+      }
     },
   } as unknown as ResultNode<T>
   return node
@@ -68,8 +73,19 @@ export class ResultFieldVisitor<A = BaseActor> extends IDL.Visitor<
 > {
   private codec = new DisplayCodecVisitor()
 
+  private recCache = new Map<IDL.RecClass<any>, ResultNode<"recursive">>()
+
   private getCodec(t: IDL.Type): Codec {
-    return t.accept(this.codec, null) as Codec
+    const codec = t.accept(this.codec, null) as any
+    return {
+      decode: (v: unknown) => {
+        try {
+          return typeof codec?.decode === "function" ? codec.decode(v) : v
+        } catch {
+          return v
+        }
+      },
+    }
   }
 
   // ══════════════════════════════════════════════════════════════════════════
@@ -138,8 +154,20 @@ export class ResultFieldVisitor<A = BaseActor> extends IDL.Visitor<
         }
         const recordData = data as Record<string, unknown>
         const resolvedFields: Record<string, ResolvedNode> = {}
+        let index = 0
         for (const [key, field] of Object.entries(fields)) {
-          resolvedFields[key] = field.resolve(recordData[key])
+          // Try named key first, then try numeric index (for tuples/indexed records)
+          const value =
+            recordData[key] !== undefined ? recordData[key] : recordData[index]
+
+          if (!field || typeof field.resolve !== "function") {
+            throw new Error(
+              `Field "${key}" in record "${label}" is not a valid ResultNode. Got: ${JSON.stringify(field)}`
+            )
+          }
+
+          resolvedFields[key] = field.resolve(value)
+          index++
         }
         return { ...node, fields: resolvedFields, raw: data }
       },
@@ -170,10 +198,15 @@ export class ResultFieldVisitor<A = BaseActor> extends IDL.Visitor<
           )
         }
         const variantData = data as Record<string, unknown>
-        const selected = Object.keys(variantData)[0]
+        // Support both raw { Selected: value } and transformed { _type: 'Selected', Selected: value }
+        const selected =
+          (variantData._type as string) || Object.keys(variantData)[0]
         const optionNode = selectedOption[selected]
+
         if (!optionNode) {
-          throw new Error(`Option ${selected} not found in variant`)
+          throw new Error(
+            `Option ${selected} not found in variant ${label}. Available options: ${Object.keys(selectedOption).join(", ")}`
+          )
         }
         return {
           ...node,
@@ -230,9 +263,16 @@ export class ResultFieldVisitor<A = BaseActor> extends IDL.Visitor<
       displayType: "nullable",
       value: null, // null until resolved
       resolve(data: unknown): ResolvedNode<"optional"> {
-        const opt = data as T[]
-        const resolved =
-          Array.isArray(opt) && opt.length > 0 ? inner.resolve(opt[0]) : null
+        // If data is an array (raw format [T] or []), unwrap it.
+        // Otherwise, use data directly (already transformed or null/undefined).
+        const resolved = Array.isArray(data)
+          ? data.length > 0
+            ? inner.resolve(data[0])
+            : null
+          : data !== null && data !== undefined
+            ? inner.resolve(data)
+            : null
+
         return { ...node, value: resolved, raw: data }
       },
     }
@@ -300,10 +340,14 @@ export class ResultFieldVisitor<A = BaseActor> extends IDL.Visitor<
   }
 
   public visitRec<T>(
-    _t: IDL.RecClass<T>,
+    t: IDL.RecClass<T>,
     ty: IDL.ConstructType<T>,
     label: string
   ): ResultNode<"recursive"> {
+    if (this.recCache.has(t)) {
+      return this.recCache.get(t)! as ResultNode<"recursive">
+    }
+
     const self = this
     // Lazy extraction to prevent infinite loops
     let innerSchema: ResultNode | null = null
@@ -320,6 +364,8 @@ export class ResultFieldVisitor<A = BaseActor> extends IDL.Visitor<
         return { ...node, inner: getInner().resolve(data), raw: data }
       },
     }
+
+    this.recCache.set(t, node)
     return node
   }
 

package/src/visitor/types.ts

@@ -17,10 +17,9 @@ export type FieldType =
   | "boolean"
   | "null"
 
-export { IDL } from "@icp-sdk/core/candid"
-export { Principal } from "@icp-sdk/core/principal"
+export type { Principal } from "@icp-sdk/core/principal"
 
-import { IDL } from "@icp-sdk/core/candid"
+import type { IDL } from "@icp-sdk/core/candid"
 export type AllNumberTypes =
   | IDL.NatClass
   | IDL.IntClass