@ic-reactor/candid 3.0.12-beta.0 → 3.0.14-beta.0

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

@@ -1,11 +1,11 @@
 import { describe, it, expect } from "vitest"
 import { IDL } from "@icp-sdk/core/candid"
 import { Principal } from "@icp-sdk/core/principal"
-import { ArgumentFieldVisitor } from "./index"
+import { FieldVisitor } from "./index"
 import * as z from "zod"
 
-describe("ArgumentFieldVisitor Schema Generation", () => {
-  const visitor = new ArgumentFieldVisitor()
+describe("FieldVisitor Schema Generation", () => {
+  const visitor = new FieldVisitor()
 
   // ════════════════════════════════════════════════════════════════════════
   // Primitive Types
@@ -62,6 +62,108 @@ describe("ArgumentFieldVisitor Schema Generation", () => {
     })
   })
 
+  // ════════════════════════════════════════════════════════════════════════
+  // Format Detection & Validation
+  // ════════════════════════════════════════════════════════════════════════
+
+  describe("Format Detection & Validation", () => {
+    describe("Text Formats", () => {
+      it("should detect email format", () => {
+        const field = visitor.visitText(IDL.Text, "user_email")
+
+        expect(field.format).toBe("email")
+        expect(field.inputProps).toMatchObject({
+          type: "email",
+          inputMode: "email",
+        })
+
+        // Valid email
+        expect(field.schema.parse("test@example.com")).toBe("test@example.com")
+        // Invalid email
+        expect(() => field.schema.parse("invalid-email")).toThrow()
+      })
+
+      it("should detect url format", () => {
+        const field = visitor.visitText(IDL.Text, "website_link")
+
+        expect(field.format).toBe("url")
+        expect(field.inputProps).toMatchObject({
+          type: "url",
+          inputMode: "url",
+        })
+
+        // Valid URL
+        expect(field.schema.parse("https://example.com")).toBe(
+          "https://example.com"
+        )
+        // Invalid URL
+        expect(() => field.schema.parse("not-a-url")).toThrow()
+      })
+
+      it("should detect uuid format", () => {
+        const field = visitor.visitText(IDL.Text, "transaction_uuid")
+
+        expect(field.format).toBe("uuid")
+
+        const validUuid = "123e4567-e89b-12d3-a456-426614174000"
+        expect(field.schema.parse(validUuid)).toBe(validUuid)
+
+        expect(() => field.schema.parse("invalid-uuid")).toThrow()
+      })
+
+      it("should detect ethereum address format", () => {
+        const field = visitor.visitText(IDL.Text, "eth_address")
+
+        expect(field.format).toBe("eth")
+        expect(field.inputProps.pattern).toContain("0x")
+      })
+
+      it("should fallback to plain text for unknown formats", () => {
+        const field = visitor.visitText(IDL.Text, "some_random_field")
+
+        expect(field.format).toBe("plain")
+        expect(field.inputProps).toMatchObject({
+          type: "text",
+        })
+      })
+    })
+
+    describe("Number Formats", () => {
+      it("should detect timestamp format", () => {
+        const field = visitor.visitInt(IDL.Int, "created_at")
+
+        expect(field.format).toBe("timestamp")
+      })
+
+      it("should detect cycle format", () => {
+        const field = visitor.visitNat(IDL.Nat, "cycles_balance")
+
+        expect(field.format).toBe("cycle")
+      })
+
+      it("should fallback to normal format", () => {
+        const field = visitor.visitNat(IDL.Nat, "quantity")
+
+        expect(field.format).toBe("plain")
+      })
+    })
+
+    describe("Principal Format", () => {
+      it("should detect principal format and set properties", () => {
+        const field = visitor.visitPrincipal(
+          IDL.Principal,
+          "controller_principal"
+        )
+
+        expect(field.format).toBe("principal")
+        expect(field.inputProps).toMatchObject({
+          minLength: 7,
+          maxLength: 64,
+        })
+      })
+    })
+  })
+
   // ════════════════════════════════════════════════════════════════════════
   // Compound Types
   // ════════════════════════════════════════════════════════════════════════
@@ -106,10 +208,16 @@ describe("ArgumentFieldVisitor Schema Generation", () => {
       )
       const schema = field.schema as z.ZodUnion<any>
 
-      expect(schema.parse({ Ok: "Success" })).toEqual({ Ok: "Success" })
-      expect(schema.parse({ Err: "Error" })).toEqual({ Err: "Error" })
+      expect(schema.parse({ _type: "Ok", Ok: "Success" })).toEqual({
+        _type: "Ok",
+        Ok: "Success",
+      })
+      expect(schema.parse({ _type: "Err", Err: "Error" })).toEqual({
+        _type: "Err",
+        Err: "Error",
+      })
 
-      expect(() => schema.parse({ Other: "value" })).toThrow()
+      expect(() => schema.parse({ _type: "Other", Other: "value" })).toThrow()
     })
   })
 
@@ -179,12 +287,14 @@ describe("ArgumentFieldVisitor Schema Generation", () => {
       const schema = field.schema
 
       const validList = {
+        _type: "Cons",
         Cons: {
           head: "1",
           tail: {
+            _type: "Cons",
             Cons: {
               head: "2",
-              tail: { Nil: null },
+              tail: { _type: "Nil" },
             },
           },
         },