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

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

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest"
 import { IDL } from "@icp-sdk/core/candid"
-import { ArgumentFieldVisitor } from "./index"
+import { ArgumentFieldVisitor, VectorField } from "./index"
 
 describe("ArgumentFieldVisitor", () => {
   const visitor = new ArgumentFieldVisitor()
@@ -53,51 +53,70 @@ describe("ArgumentFieldVisitor", () => {
     it("should handle nat type", () => {
       const field = visitor.visitNat(IDL.Nat, "amount")
 
-      expect(field.type).toBe("number")
+      expect(field.type).toBe("text")
       expect(field.label).toBe("amount")
       expect(field.candidType).toBe("nat")
       expect(field.defaultValue).toBe("")
+      // TextField doesn't have isFloat or unsigned properties in the types
     })
 
     it("should handle int type", () => {
       const field = visitor.visitInt(IDL.Int, "balance")
 
-      expect(field.type).toBe("number")
+      expect(field.type).toBe("text")
       expect(field.candidType).toBe("int")
     })
 
-    it("should handle nat8 type", () => {
+    it("should handle nat8 type with min/max", () => {
       const field = visitor.visitFixedNat(IDL.Nat8 as IDL.FixedNatClass, "byte")
 
-      expect(field.type).toBe("number")
-      expect(field.candidType).toBe("nat8")
+      if (field.type === "number") {
+        expect(field.type).toBe("number")
+        expect(field.candidType).toBe("nat8")
+        expect(field.bits).toBe(8)
+        expect(field.min).toBe("0")
+        expect(field.max).toBe("255")
+      } else {
+        throw new Error("Expected number field for nat8")
+      }
     })
 
-    it("should handle nat64 type", () => {
+    it("should handle nat64 type with min/max", () => {
       const field = visitor.visitFixedNat(
         IDL.Nat64 as IDL.FixedNatClass,
         "timestamp"
       )
 
-      expect(field.type).toBe("number")
+      expect(field.type).toBe("text")
       expect(field.candidType).toBe("nat64")
+      // Large numbers are now text fields and don't carry bit/min/max metadata in the same way
     })
 
-    it("should handle int32 type", () => {
+    it("should handle int32 type with min/max", () => {
       const field = visitor.visitFixedInt(
         IDL.Int32 as IDL.FixedIntClass,
         "count"
       )
 
-      expect(field.type).toBe("number")
-      expect(field.candidType).toBe("int32")
+      if (field.type === "number") {
+        expect(field.type).toBe("number")
+        expect(field.candidType).toBe("int32")
+        expect(field.bits).toBe(32)
+        expect(field.min).toBe("-2147483648")
+        expect(field.max).toBe("2147483647")
+      } else {
+        throw new Error("Expected number field for int32")
+      }
     })
 
     it("should handle float64 type", () => {
       const field = visitor.visitFloat(IDL.Float64 as IDL.FloatClass, "price")
 
       expect(field.type).toBe("number")
-      expect(field.candidType).toBe("float")
+      expect(field.candidType).toBe("float64")
+      if (field.type === "number") {
+        expect(field.isFloat).toBe(true)
+      }
     })
   })
 
@@ -123,6 +142,8 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.type).toBe("record")
       expect(field.label).toBe("person")
       expect(field.fields).toHaveLength(2)
+      expect(field.fieldMap.has("name")).toBe(true)
+      expect(field.fieldMap.has("age")).toBe(true)
 
       const nameField = field.fields.find((f) => f.label === "name")
       if (!nameField || nameField.type !== "text") {
@@ -132,13 +153,13 @@ describe("ArgumentFieldVisitor", () => {
       expect(nameField.defaultValue).toBe("")
 
       const ageField = field.fields.find((f) => f.label === "age")
-      if (!ageField || ageField.type !== "number") {
-        throw new Error("Age field not found or not number")
+      if (!ageField || ageField.type !== "text") {
+        throw new Error("Age field not found or not text")
       }
-      expect(ageField.type).toBe("number")
+      expect(ageField.type).toBe("text")
       expect(ageField.candidType).toBe("nat")
 
-      expect(field.defaultValues).toEqual({
+      expect(field.defaultValue).toEqual({
         name: "",
         age: "",
       })
@@ -172,7 +193,7 @@ describe("ArgumentFieldVisitor", () => {
       expect(addressField.type).toBe("record")
       expect(addressField.fields).toHaveLength(2)
 
-      expect(field.defaultValues).toEqual({
+      expect(field.defaultValue).toEqual({
         name: "",
         address: {
           street: "",
@@ -223,10 +244,10 @@ describe("ArgumentFieldVisitor", () => {
 
       // Check 'amount' field
       const amountField = field.fields.find((f) => f.label === "amount")
-      if (!amountField || amountField.type !== "number") {
-        throw new Error("Amount field not found or not number")
+      if (!amountField || amountField.type !== "text") {
+        throw new Error("Amount field not found or not text")
       }
-      expect(amountField.type).toBe("number")
+      expect(amountField.type).toBe("text")
       expect(amountField.candidType).toBe("nat")
 
       // Check optional 'fee' field
@@ -235,7 +256,7 @@ describe("ArgumentFieldVisitor", () => {
         throw new Error("Fee field not found or not optional")
       }
       expect(feeField.type).toBe("optional")
-      expect(feeField.innerField.type).toBe("number")
+      expect(feeField.innerField.type).toBe("text")
     })
   })
 
@@ -261,10 +282,15 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.options).toEqual(["Inactive", "Active", "Pending"])
       expect(field.defaultOption).toBe("Inactive")
       expect(field.fields).toHaveLength(3)
+      expect(field.optionMap.has("Active")).toBe(true)
 
       field.fields.forEach((f) => {
         expect(f.type).toBe("null")
       })
+
+      // Test getOptionDefault helper
+      expect(field.getOptionDefault("Active")).toEqual({ Active: null })
+      expect(field.getOptionDefault("Pending")).toEqual({ Pending: null })
     })
 
     it("should handle variant with payloads", () => {
@@ -312,10 +338,10 @@ describe("ArgumentFieldVisitor", () => {
       expect(transferField.fields).toHaveLength(2)
 
       const burnField = field.fields.find((f) => f.label === "Burn")
-      if (!burnField || burnField.type !== "number") {
-        throw new Error("Burn field not found or not number")
+      if (!burnField || burnField.type !== "text") {
+        throw new Error("Burn field not found or not text")
       }
-      expect(burnField.type).toBe("number")
+      expect(burnField.type).toBe("text")
     })
 
     it("should handle Result variant (Ok/Err)", () => {
@@ -337,10 +363,10 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.options).toContain("Err")
 
       const okField = field.fields.find((f) => f.label === "Ok")
-      if (!okField || okField.type !== "number") {
-        throw new Error("Ok field not found or not number")
+      if (!okField || okField.type !== "text") {
+        throw new Error("Ok field not found or not text")
       }
-      expect(okField.type).toBe("number")
+      expect(okField.type).toBe("text")
 
       const errField = field.fields.find((f) => f.label === "Err")
       if (!errField || errField.type !== "text") {
@@ -359,8 +385,8 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.label).toBe("pair")
       expect(field.fields).toHaveLength(2)
       expect(field.fields[0].type).toBe("text")
-      expect(field.fields[1].type).toBe("number")
-      expect(field.defaultValues).toEqual(["", ""])
+      expect(field.fields[1].type).toBe("text")
+      expect(field.defaultValue).toEqual(["", ""])
     })
 
     it("triple tuple", () => {
@@ -374,9 +400,9 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.type).toBe("tuple")
       expect(field.fields).toHaveLength(3)
       expect(field.fields[0].type).toBe("principal")
-      expect(field.fields[1].type).toBe("number")
+      expect(field.fields[1].type).toBe("text")
       expect(field.fields[2].type).toBe("boolean")
-      expect(field.defaultValues).toEqual(["", "", false])
+      expect(field.defaultValue).toEqual(["", "", false])
     })
   })
 
@@ -389,6 +415,7 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.label).toBe("nickname")
       expect(field.defaultValue).toBe(null)
       expect(field.innerField.type).toBe("text")
+      expect(field.getInnerDefault()).toBe("")
     })
 
     it("should handle optional record", () => {
@@ -408,6 +435,9 @@ describe("ArgumentFieldVisitor", () => {
       } else {
         throw new Error("Inner field is not record")
       }
+
+      // Test getInnerDefault helper
+      expect(field.getInnerDefault()).toEqual({ name: "", value: "" })
     })
 
     it("should handle nested optional", () => {
@@ -420,7 +450,7 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.innerField.type).toBe("optional")
       const inner = field.innerField
       if (inner.type === "optional") {
-        expect(inner.innerField.type).toBe("number")
+        expect(inner.innerField.type).toBe("text")
       } else {
         throw new Error("Inner field is not optional")
       }
@@ -430,12 +460,13 @@ describe("ArgumentFieldVisitor", () => {
   describe("Vector Types", () => {
     it("should handle vector of primitives", () => {
       const vecType = IDL.Vec(IDL.Text)
-      const field = visitor.visitVec(vecType, IDL.Text, "tags")
+      const field = visitor.visitVec(vecType, IDL.Text, "tags") as VectorField
 
       expect(field.type).toBe("vector")
       expect(field.label).toBe("tags")
       expect(field.defaultValue).toEqual([])
       expect(field.itemField.type).toBe("text")
+      expect(field.getItemDefault()).toBe("")
     })
 
     it("should handle vector of records", () => {
@@ -444,7 +475,7 @@ describe("ArgumentFieldVisitor", () => {
         name: IDL.Text,
       })
       const vecType = IDL.Vec(recType)
-      const field = visitor.visitVec(vecType, recType, "items")
+      const field = visitor.visitVec(vecType, recType, "items") as VectorField
 
       expect(field.type).toBe("vector")
       expect(field.itemField.type).toBe("record")
@@ -454,6 +485,9 @@ describe("ArgumentFieldVisitor", () => {
       } else {
         throw new Error("Item field is not record")
       }
+
+      // Test getItemDefault helper
+      expect(field.getItemDefault()).toEqual({ id: "", name: "" })
     })
 
     it("blob (vec nat8)", () => {
@@ -463,6 +497,9 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.type).toBe("blob")
       expect(field.label).toBe("data")
       expect(field.defaultValue).toBe("")
+      if (field.type === "blob") {
+        expect(field.acceptedFormats).toEqual(["hex", "base64", "file"])
+      }
     })
 
     it("should handle nested vectors", () => {
@@ -474,7 +511,7 @@ describe("ArgumentFieldVisitor", () => {
       expect(field.itemField.type).toBe("vector")
       const item = field.itemField
       if (item.type === "vector") {
-        expect(item.itemField.type).toBe("number")
+        expect(item.itemField.type).toBe("text")
       } else {
         throw new Error("Item field is not vector")
       }
@@ -508,7 +545,9 @@ describe("ArgumentFieldVisitor", () => {
 
       expect(field.type).toBe("recursive")
       expect(field.label).toBe("tree")
+      expect(field.typeName).toBeDefined()
       expect(typeof field.extract).toBe("function")
+      expect(typeof field.getInnerDefault).toBe("function")
 
       // Extract should return a variant
       const extracted = field.extract()
@@ -576,6 +615,8 @@ describe("ArgumentFieldVisitor", () => {
       expect(meta.fields).toHaveLength(1)
       expect(meta.fields[0].type).toBe("text")
       expect(meta.defaultValues).toEqual([""])
+      expect(meta.argCount).toBe(1)
+      expect(meta.isNoArgs).toBe(false)
     })
 
     it("should handle update function", () => {
@@ -618,8 +659,9 @@ describe("ArgumentFieldVisitor", () => {
 
       expect(meta.fields).toHaveLength(3)
       expect(meta.fields[0].type).toBe("principal")
-      expect(meta.fields[1].type).toBe("number")
+      expect(meta.fields[1].type).toBe("text")
       expect(meta.fields[2].type).toBe("optional")
+      expect(meta.argCount).toBe(3)
     })
 
     it("should handle function with no arguments", () => {
@@ -629,6 +671,8 @@ describe("ArgumentFieldVisitor", () => {
       expect(meta.functionType).toBe("query")
       expect(meta.fields).toHaveLength(0)
       expect(meta.defaultValues).toEqual([])
+      expect(meta.argCount).toBe(0)
+      expect(meta.isNoArgs).toBe(true)
     })
   })
 
@@ -685,15 +729,16 @@ describe("ArgumentFieldVisitor", () => {
       const getMetadataMeta = serviceMeta["get_metadata"]
       expect(getMetadataMeta.functionType).toBe("query")
       expect(getMetadataMeta.fields).toHaveLength(0)
+      expect(getMetadataMeta.isNoArgs).toBe(true)
     })
   })
 
   // ════════════════════════════════════════════════════════════════════════
-  // Path Generation
+  // Name (Path) Generation
   // ════════════════════════════════════════════════════════════════════════
 
-  describe("Path Generation", () => {
-    it("should generate correct paths for nested records", () => {
+  describe("Name Generation", () => {
+    it("should generate correct names for nested records", () => {
       const funcType = IDL.Func(
         [
           IDL.Record({
@@ -713,28 +758,28 @@ describe("ArgumentFieldVisitor", () => {
       if (argRecord.type !== "record") {
         throw new Error("Expected record field")
       }
-      expect(argRecord.path).toBe("[0]")
+      expect(argRecord.name).toBe("[0]")
 
       const userRecord = argRecord.fields.find((f) => f.label === "user")
       if (!userRecord || userRecord.type !== "record") {
         throw new Error("User record not found or not record")
       }
-      expect(userRecord.path).toBe("[0].user")
+      expect(userRecord.name).toBe("[0].user")
 
       const nameField = userRecord.fields.find((f) => f.label === "name")
       if (!nameField || nameField.type !== "text") {
         throw new Error("Name field not found or not text")
       }
-      expect(nameField.path).toBe("[0].user.name")
+      expect(nameField.name).toBe("[0].user.name")
 
       const ageField = userRecord.fields.find((f) => f.label === "age")
-      if (!ageField || ageField.type !== "number") {
-        throw new Error("Age field not found or not number")
+      if (!ageField || ageField.type !== "text") {
+        throw new Error("Age field not found or not text")
       }
-      expect(ageField.path).toBe("[0].user.age")
+      expect(ageField.name).toBe("[0].user.age")
     })
 
-    it("should generate correct paths for vectors", () => {
+    it("should generate correct names for vectors", () => {
       const funcType = IDL.Func([IDL.Vec(IDL.Text)], [], [])
       const meta = visitor.visitFunc(funcType, "addTags")
 
@@ -742,8 +787,8 @@ describe("ArgumentFieldVisitor", () => {
       if (vecField.type !== "vector") {
         throw new Error("Expected vector field")
       }
-      expect(vecField.path).toBe("[0]")
-      expect(vecField.itemField.path).toBe("[0][0]")
+      expect(vecField.name).toBe("[0]")
+      expect(vecField.itemField.name).toBe("[0][0]")
     })
   })
 
@@ -801,10 +846,10 @@ describe("ArgumentFieldVisitor", () => {
 
       // Check amount field
       const amountField = field.fields.find((f) => f.label === "amount")
-      if (!amountField || amountField.type !== "number") {
-        throw new Error("Amount field not found or not number")
+      if (!amountField || amountField.type !== "text") {
+        throw new Error("Amount field not found or not text")
       }
-      expect(amountField.type).toBe("number")
+      expect(amountField.type).toBe("text")
       expect(amountField.candidType).toBe("nat")
     })
 
@@ -879,4 +924,52 @@ describe("ArgumentFieldVisitor", () => {
       expect(transferField.fields.length).toBeGreaterThan(3)
     })
   })
+
+  // ════════════════════════════════════════════════════════════════════════
+  // Helper Methods
+  // ════════════════════════════════════════════════════════════════════════
+
+  describe("Helper Methods", () => {
+    it("variant getOptionDefault should return correct defaults", () => {
+      const statusType = IDL.Variant({
+        Active: IDL.Null,
+        Pending: IDL.Record({ reason: IDL.Text }),
+      })
+      const field = visitor.visitVariant(
+        statusType,
+        [
+          ["Active", IDL.Null],
+          ["Pending", IDL.Record({ reason: IDL.Text })],
+        ],
+        "status"
+      )
+
+      expect(field.getOptionDefault("Active")).toEqual({ Active: null })
+      expect(field.getOptionDefault("Pending")).toEqual({
+        Pending: { reason: "" },
+      })
+    })
+
+    it("vector getItemDefault should return item default", () => {
+      const vecType = IDL.Vec(IDL.Record({ name: IDL.Text }))
+      const field = visitor.visitVec(
+        vecType,
+        IDL.Record({ name: IDL.Text }),
+        "items"
+      ) as VectorField
+
+      expect(field.getItemDefault()).toEqual({ name: "" })
+    })
+
+    it("optional getInnerDefault should return inner default", () => {
+      const optType = IDL.Opt(IDL.Record({ value: IDL.Nat }))
+      const field = visitor.visitOpt(
+        optType,
+        IDL.Record({ value: IDL.Nat }),
+        "config"
+      )
+
+      expect(field.getInnerDefault()).toEqual({ value: "" })
+    })
+  })
 })