@kontor/kontor-sdk 1.0.0-alpha.39 → 1.0.0-alpha.40

package/src/wit/wit-parser/core/user-defined.test.ts

@@ -0,0 +1,609 @@
+import { describe, expect, test } from "vitest";
+import { parseTypes, execWitType } from "./user-defined.js";
+
+describe("execWitType (locked contract)", () => {
+  test("plain identifier", () => {
+    expect(execWitType("u64")).toEqual({ base: "u64" });
+    expect(execWitType("proc-context")).toEqual({ base: "proc-context" });
+  });
+
+  test("single-arg wrappers", () => {
+    expect(execWitType("list<u64>")).toEqual({ wrapper: "list", base: "u64" });
+    expect(execWitType("option<signer>")).toEqual({
+      wrapper: "option",
+      base: "signer",
+    });
+    expect(execWitType("borrow<proc-context>")).toEqual({
+      wrapper: "borrow",
+      base: "proc-context",
+    });
+  });
+
+  test("wrapper payload is opaque (no recursion here)", () => {
+    expect(execWitType("option<list<u64>>")).toEqual({
+      wrapper: "option",
+      base: "list<u64>",
+    });
+  });
+
+  test("result<ok, error>", () => {
+    expect(execWitType("result<integer, error>")).toEqual({
+      wrapper: "result",
+      base: "integer",
+    });
+    expect(execWitType("result< list<u8> , error >")).toEqual({
+      wrapper: "result",
+      base: "list<u8>",
+    });
+  });
+
+  test("rejects result with non-error err channel", () => {
+    expect(execWitType("result<integer, string>")).toBeNull();
+    expect(execWitType("result<integer>")).toBeNull();
+  });
+
+  test("rejects malformed wrappers", () => {
+    expect(execWitType("list<u64")).toBeNull();
+    expect(execWitType("list<u64>>")).toBeNull();
+    expect(execWitType("")).toBeNull();
+    expect(execWitType("1abc")).toBeNull();
+  });
+});
+
+describe("parseTypes - records", () => {
+  test("parse basic records", () => {
+    const result = parseTypes([
+      "record contract-address {  name: string, height: s64, tx-index: s64 }",
+      "record token-pair {  a: contract-address, b: contract-address }",
+    ]);
+
+    expect(result.records).toEqual({
+      "contract-address": [
+        { name: "name", type: "string", internalType: "string" },
+        { name: "height", type: "s64", internalType: "s64" },
+        { name: "tx-index", type: "s64", internalType: "s64" },
+      ],
+      "token-pair": [
+        {
+          type: "record",
+          name: "a",
+          internalType: "contract-address",
+          components: [
+            { name: "name", type: "string", internalType: "string" },
+            { name: "height", type: "s64", internalType: "s64" },
+            { name: "tx-index", type: "s64", internalType: "s64" },
+          ],
+        },
+        {
+          type: "record",
+          name: "b",
+          internalType: "contract-address",
+          components: [
+            { name: "name", type: "string", internalType: "string" },
+            { name: "height", type: "s64", internalType: "s64" },
+            { name: "tx-index", type: "s64", internalType: "s64" },
+          ],
+        },
+      ],
+    });
+  });
+
+  test("record with generic types", () => {
+    const result = parseTypes(["record generic {  values: list<string> }"]);
+
+    expect(result.records).toEqual({
+      generic: [
+        { name: "values", type: "list<string>", internalType: "list<string>" },
+      ],
+    });
+  });
+
+  test("record with wrapped generics", () => {
+    const result = parseTypes([
+      "record contract-address {  name: string, height: s64, tx-index: s64 }",
+      "record generic {  as-list: list<contract-address>, as-option: option<contract-address>, as-result: result<contract-address, error> }",
+    ]);
+
+    expect(result.records).toEqual({
+      "contract-address": [
+        { name: "name", type: "string", internalType: "string" },
+        { name: "height", type: "s64", internalType: "s64" },
+        { name: "tx-index", type: "s64", internalType: "s64" },
+      ],
+      generic: [
+        {
+          name: "as-list",
+          type: "list<record>",
+          internalType: "list<contract-address>",
+          components: [
+            { name: "name", type: "string", internalType: "string" },
+            { name: "height", type: "s64", internalType: "s64" },
+            { name: "tx-index", type: "s64", internalType: "s64" },
+          ],
+        },
+        {
+          name: "as-option",
+          type: "option<record>",
+          internalType: "option<contract-address>",
+          components: [
+            { name: "name", type: "string", internalType: "string" },
+            { name: "height", type: "s64", internalType: "s64" },
+            { name: "tx-index", type: "s64", internalType: "s64" },
+          ],
+        },
+        {
+          name: "as-result",
+          type: "result<record, error>",
+          internalType: "result<contract-address, error>",
+          components: [
+            { name: "name", type: "string", internalType: "string" },
+            { name: "height", type: "s64", internalType: "s64" },
+            { name: "tx-index", type: "s64", internalType: "s64" },
+          ],
+        },
+      ],
+    });
+  });
+
+  test("record referencing variant", () => {
+    const result = parseTypes([
+      "variant color { hex(string), literal(string) }",
+      "record palette { a: color, b: list<color> }",
+    ]);
+
+    expect(result.records).toEqual({
+      palette: [
+        {
+          name: "a",
+          type: "variant",
+          internalType: "color",
+          components: [
+            { name: "hex", type: "string", internalType: "string" },
+            { name: "literal", type: "string", internalType: "string" },
+          ],
+        },
+        {
+          name: "b",
+          type: "list<variant>",
+          internalType: "list<color>",
+          components: [
+            { name: "hex", type: "string", internalType: "string" },
+            { name: "literal", type: "string", internalType: "string" },
+          ],
+        },
+      ],
+    });
+
+    expect(result.variants).toEqual({
+      color: [
+        { name: "hex", type: "string", internalType: "string" },
+        { name: "literal", type: "string", internalType: "string" },
+      ],
+    });
+  });
+
+  test("variant with nested record reference", () => {
+    const result = parseTypes([
+      "record rgb { r: u8, g: u8, b: u8 }",
+      "variant color { hex(string), rgb(rgb) }",
+      "record palette { a: color, b: list<color> }",
+    ]);
+
+    expect(result.records).toEqual({
+      rgb: [
+        { name: "r", type: "u8", internalType: "u8" },
+        { name: "g", type: "u8", internalType: "u8" },
+        { name: "b", type: "u8", internalType: "u8" },
+      ],
+      palette: [
+        {
+          name: "a",
+          type: "variant",
+          internalType: "color",
+          components: [
+            { name: "hex", type: "string", internalType: "string" },
+            {
+              name: "rgb",
+              type: "record",
+              internalType: "rgb",
+              components: [
+                { name: "r", type: "u8", internalType: "u8" },
+                { name: "g", type: "u8", internalType: "u8" },
+                { name: "b", type: "u8", internalType: "u8" },
+              ],
+            },
+          ],
+        },
+        {
+          name: "b",
+          type: "list<variant>",
+          internalType: "list<color>",
+          components: [
+            { name: "hex", type: "string", internalType: "string" },
+            {
+              name: "rgb",
+              type: "record",
+              internalType: "rgb",
+              components: [
+                { name: "r", type: "u8", internalType: "u8" },
+                { name: "g", type: "u8", internalType: "u8" },
+                { name: "b", type: "u8", internalType: "u8" },
+              ],
+            },
+          ],
+        },
+      ],
+    });
+  });
+});
+
+describe("parseTypes - variants", () => {
+  test("parse basic variants", () => {
+    const result = parseTypes([
+      "variant response { ok(string), err(string) }",
+      "variant complex { success(response), failure(string) }",
+    ]);
+
+    expect(result.variants).toEqual({
+      response: [
+        { name: "ok", type: "string", internalType: "string" },
+        { name: "err", type: "string", internalType: "string" },
+      ],
+      complex: [
+        {
+          name: "success",
+          type: "variant",
+          internalType: "response",
+          components: [
+            { name: "ok", type: "string", internalType: "string" },
+            { name: "err", type: "string", internalType: "string" },
+          ],
+        },
+        { name: "failure", type: "string", internalType: "string" },
+      ],
+    });
+  });
+
+  test("parse variants with generics", () => {
+    const result = parseTypes([
+      "variant response { ok(string), err(string) }",
+      "variant error { msg(string), code(u64) }",
+      "variant envelope { maybe(option<string>), many(list<string>), nested(response) }",
+    ]);
+
+    expect(result.variants).toEqual({
+      response: [
+        { name: "ok", type: "string", internalType: "string" },
+        { name: "err", type: "string", internalType: "string" },
+      ],
+      error: [
+        { name: "msg", type: "string", internalType: "string" },
+        { name: "code", type: "u64", internalType: "u64" },
+      ],
+      envelope: [
+        {
+          name: "maybe",
+          type: "option<string>",
+          internalType: "option<string>",
+        },
+        { name: "many", type: "list<string>", internalType: "list<string>" },
+        {
+          name: "nested",
+          type: "variant",
+          internalType: "response",
+          components: [
+            { name: "ok", type: "string", internalType: "string" },
+            { name: "err", type: "string", internalType: "string" },
+          ],
+        },
+      ],
+    });
+  });
+
+  test("variant with unit cases (no payload)", () => {
+    const result = parseTypes(["variant status { pending, complete, failed }"]);
+
+    expect(result.variants).toEqual({
+      status: [
+        { name: "pending", type: "_", internalType: "_" },
+        { name: "complete", type: "_", internalType: "_" },
+        { name: "failed", type: "_", internalType: "_" },
+      ],
+    });
+  });
+});
+
+describe("parseTypes - enums", () => {
+  test("parse basic enum", () => {
+    const result = parseTypes(["enum color { red, green, blue }"]);
+
+    expect(result.enums).toEqual({
+      color: ["red", "green", "blue"],
+    });
+  });
+
+  test("parse multiple enums", () => {
+    const result = parseTypes([
+      "enum color { red, green, blue }",
+      "enum status { pending, complete, failed }",
+    ]);
+
+    expect(result.enums).toEqual({
+      color: ["red", "green", "blue"],
+      status: ["pending", "complete", "failed"],
+    });
+  });
+
+  test("record referencing enum", () => {
+    const result = parseTypes([
+      "enum color { red, green, blue }",
+      "record palette { primary: color, secondary: color }",
+    ]);
+
+    expect(result.records).toEqual({
+      palette: [
+        {
+          name: "primary",
+          type: "enum",
+          internalType: "color",
+          components: [
+            { name: "red", type: "_" },
+            { name: "green", type: "_" },
+            { name: "blue", type: "_" },
+          ],
+        },
+        {
+          name: "secondary",
+          type: "enum",
+          internalType: "color",
+          components: [
+            { name: "red", type: "_" },
+            { name: "green", type: "_" },
+            { name: "blue", type: "_" },
+          ],
+        },
+      ],
+    });
+  });
+
+  test("enum wrapped in generics", () => {
+    const result = parseTypes([
+      "enum status { pending, complete, failed }",
+      "record task { current: status, history: list<status>, maybe: option<status> }",
+    ]);
+
+    expect(result.records).toEqual({
+      task: [
+        {
+          name: "current",
+          type: "enum",
+          internalType: "status",
+          components: [
+            { name: "pending", type: "_" },
+            { name: "complete", type: "_" },
+            { name: "failed", type: "_" },
+          ],
+        },
+        {
+          name: "history",
+          type: "list<enum>",
+          internalType: "list<status>",
+          components: [
+            { name: "pending", type: "_" },
+            { name: "complete", type: "_" },
+            { name: "failed", type: "_" },
+          ],
+        },
+        {
+          name: "maybe",
+          type: "option<enum>",
+          internalType: "option<status>",
+          components: [
+            { name: "pending", type: "_" },
+            { name: "complete", type: "_" },
+            { name: "failed", type: "_" },
+          ],
+        },
+      ],
+    });
+  });
+
+  test("variant referencing enum", () => {
+    const result = parseTypes([
+      "enum status { pending, complete, failed }",
+      "variant response { ok(status), err(string) }",
+    ]);
+
+    expect(result.variants).toEqual({
+      response: [
+        {
+          name: "ok",
+          type: "enum",
+          internalType: "status",
+          components: [
+            { name: "pending", type: "_" },
+            { name: "complete", type: "_" },
+            { name: "failed", type: "_" },
+          ],
+        },
+        { name: "err", type: "string", internalType: "string" },
+      ],
+    });
+  });
+});
+
+describe("parseTypes - mixed types", () => {
+  test("parse all three types together", () => {
+    const result = parseTypes([
+      "enum status { pending, complete, failed }",
+      "record user { name: string, status: status }",
+      "variant response { ok(user), err(string) }",
+    ]);
+
+    expect(result.enums).toEqual({
+      status: ["pending", "complete", "failed"],
+    });
+
+    expect(result.records).toEqual({
+      user: [
+        { name: "name", type: "string", internalType: "string" },
+        {
+          name: "status",
+          type: "enum",
+          internalType: "status",
+          components: [
+            { name: "pending", type: "_" },
+            { name: "complete", type: "_" },
+            { name: "failed", type: "_" },
+          ],
+        },
+      ],
+    });
+
+    expect(result.variants).toEqual({
+      response: [
+        {
+          name: "ok",
+          type: "record",
+          internalType: "user",
+          components: [
+            { name: "name", type: "string", internalType: "string" },
+            {
+              name: "status",
+              type: "enum",
+              internalType: "status",
+              components: [
+                { name: "pending", type: "_" },
+                { name: "complete", type: "_" },
+                { name: "failed", type: "_" },
+              ],
+            },
+          ],
+        },
+        { name: "err", type: "string", internalType: "string" },
+      ],
+    });
+  });
+
+  test("complex nested types", () => {
+    const result = parseTypes([
+      "enum color { red, green, blue }",
+      "record point { x: u32, y: u32 }",
+      "record rectangle { top-left: point, bottom-right: point }",
+      "variant shape { circle(u32), rect(rectangle), colored(color) }",
+      "record canvas { shapes: list<shape>, background: color }",
+    ]);
+
+    expect(result.records.canvas).toEqual([
+      {
+        name: "shapes",
+        type: "list<variant>",
+        internalType: "list<shape>",
+        components: [
+          { name: "circle", type: "u32", internalType: "u32" },
+          {
+            name: "rect",
+            type: "record",
+            internalType: "rectangle",
+            components: [
+              {
+                name: "top-left",
+                type: "record",
+                internalType: "point",
+                components: [
+                  { name: "x", type: "u32", internalType: "u32" },
+                  { name: "y", type: "u32", internalType: "u32" },
+                ],
+              },
+              {
+                name: "bottom-right",
+                type: "record",
+                internalType: "point",
+                components: [
+                  { name: "x", type: "u32", internalType: "u32" },
+                  { name: "y", type: "u32", internalType: "u32" },
+                ],
+              },
+            ],
+          },
+          {
+            name: "colored",
+            type: "enum",
+            internalType: "color",
+            components: [
+              { name: "red", type: "_" },
+              { name: "green", type: "_" },
+              { name: "blue", type: "_" },
+            ],
+          },
+        ],
+      },
+      {
+        name: "background",
+        type: "enum",
+        internalType: "color",
+        components: [
+          { name: "red", type: "_" },
+          { name: "green", type: "_" },
+          { name: "blue", type: "_" },
+        ],
+      },
+    ]);
+  });
+});
+
+describe("parseTypes - error handling", () => {
+  test("detects namespace collision between record and variant", () => {
+    expect(() =>
+      parseTypes([
+        "record user { name: string }",
+        "variant user { ok(string), err(string) }",
+      ]),
+    ).toThrow('Namespace collision: "user" is both record and variant.');
+  });
+
+  test("detects namespace collision between record and enum", () => {
+    expect(() =>
+      parseTypes([
+        "record status { value: string }",
+        "enum status { pending, complete, failed }",
+      ]),
+    ).toThrow('Namespace collision: "status" is both record and enum.');
+  });
+
+  test("detects namespace collision between variant and enum", () => {
+    expect(() =>
+      parseTypes([
+        "record rgb { r: u8, g: u8, b: u8 }",
+        "variant color { hex(string), rgb(rbg) }",
+        "enum color { red, green, blue }",
+      ]),
+    ).toThrow('Namespace collision: "color" is both variant and enum.');
+  });
+
+  test("detects circular reference in records", () => {
+    expect(() =>
+      parseTypes(["record a { b: b }", "record b { a: a }"]),
+    ).toThrow('Circular reference detected at "b".');
+  });
+
+  test("detects circular reference in variants", () => {
+    expect(() =>
+      parseTypes(["variant a { wraps(b) }", "variant b { wraps(a) }"]),
+    ).toThrow('Circular reference detected at "b".');
+  });
+
+  test("detects circular reference across record and variant", () => {
+    expect(() =>
+      parseTypes(["record r { value: v }", "variant v { wraps(r) }"]),
+    ).toThrow('Circular reference detected at "v".');
+  });
+
+  test("rejects enum with payload", () => {
+    expect(() =>
+      parseTypes(["enum status { pending(string), complete, failed }"]),
+    ).toThrow(
+      "Invalid enum case: pending(string). Enums cannot have payloads.",
+    );
+  });
+});