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

package/src/wit/wit-parser/core/utils.ts

@@ -10,15 +10,23 @@ import {
 } from "./errors/signature.js";
 import { InvalidGenericDepthError } from "./errors/split-parameters.js";
 import { execFunctionSignature, isFunctionSignature } from "./signatures.js";
-import type { RecordLookup } from "./types/records.js";
+import type {
+  EnumLookup,
+  EnumToComponents,
+  RecordLookup,
+  VariantLookup,
+} from "./types/user-defined.js";
 
 export type ParseOptions = {
   records?: RecordLookup;
-  type?: WitItemType | "record";
+  variants?: VariantLookup;
+  enums?: EnumLookup;
+  type?: WitItemType | "record" | "variant" | "enum";
+  ancestors?: Set<string>;
 };
 
 export const witParameterRegex =
-  /^(?:(?<name>[a-z][a-z0-9-]*)\s*:\s*)?(?<type>_|(?:borrow|list|option|result|tuple)\s*<[\s\S]+>|[a-z][a-z0-9-]*|(?:record|variant|flags|enum)\s*\{[\s\S]*\})$/;
+  /^(?:(?<name>[a-z][a-z0-9-]*)\s*:\s*)?(?<type>_|(?:borrow|list|option|result)\s*<[\s\S]+>|[a-z][a-z0-9-]*|(?:record|variant|flags|enum)\s*\{[\s\S]*\})$/;
 
 export function isGeneric(type: string): boolean {
   return isGenericRegex.test(type.trim());
@@ -59,13 +67,22 @@ export function parseWitParameter(param: string, options?: ParseOptions) {
 
   const name = match.name ? { name: match.name } : {};
   const records = options?.records ?? {};
+  const variants = options?.variants ?? {};
+  const enums = options?.enums ?? {};
+  const ancestors = options?.ancestors ?? new Set<string>();
+
+  // i think maybe a better approach is to have a merge step here in a separate function so we don't have to do recurssion
+  // except for the generit case
+
   let type: string;
   let components = {};
   if (isGenericType) {
     const g = execGeneric<{ outer: string; inner: string }>(match.type)!;
     const parts = splitParameters(g.inner);
 
-    const parsed = parts.map((p) => parseWitParameter(p, { records }));
+    const parsed = parts.map((p) =>
+      parseWitParameter(p, { records, variants, enums, ancestors }),
+    );
 
     // normalize inner types for the outer type string
     const innerTypeSig = parsed.map((x) => x.type).join(", ");
@@ -93,43 +110,12 @@ export function parseWitParameter(param: string, options?: ParseOptions) {
           });
         }
         const left = parsed[0]!;
-        // @ts-ignore
-        const right = parsed[1]!;
 
         type = `result<${innerTypeSig}>`;
 
         components = {
           ...(left.components && { components: left.components }),
-          // components: [
-          //
-          //   {
-          //     name: "left",
-          //     type: left.type,
-          //     ...(left.components && { components: left.components }),
-          //   },
-          //   {
-          //     name: "right",
-          //     type: right.type,
-          //     ...(right.components && { components: right.components }),
-          //   },
-          // ],
         };
-
-        // the right / error channel is always assumed to be wit built-in `error` primitive
-        // components = {
-        //   components: [
-        //     {
-        //       name: "left",
-        //       type: left.type,
-        //       ...(left.components && { components: left.components }),
-        //     },
-        //     {
-        //       name: "right",
-        //       type: right.type,
-        //       ...(right.components && { components: right.components }),
-        //     },
-        //   ],
-        // };
         break;
       }
 
@@ -140,14 +126,23 @@ export function parseWitParameter(param: string, options?: ParseOptions) {
     }
   } else if (match.type in records) {
     // scalar that maps to a record in `records`
-    type = "tuple";
+    type = "record";
     components = { components: records[match.type] };
+  } else if (match.type in variants) {
+    // scalar that maps to a record in `records`
+    type = "variant";
+    components = { components: variants[match.type] };
+  } else if (match.type in enums) {
+    // scalar that maps to a record in `records`
+    type = "enum";
+    components = { components: enumToComponents(enums[match.type]!) };
   } else {
     type = match.type;
   }
 
   const witParameter: WitParameter = {
     type: `${type}${match.array ?? ""}`,
+    // TODO: this is smell
     internalType: match.type,
     ...(name as { name: string }),
     ...components,
@@ -210,9 +205,14 @@ export function splitParameters(
   return result;
 }
 
-export function parseSignature(signature: string, structs: RecordLookup = {}) {
+export function parseSignature(
+  signature: string,
+  records: RecordLookup = {},
+  variants: VariantLookup = {},
+  enums: EnumLookup = {},
+) {
   if (isFunctionSignature(signature))
-    return parseFunctionSignature(signature, structs);
+    return parseFunctionSignature(signature, records, variants, enums);
 
   throw new UnknownSignatureError({ signature });
 }
@@ -220,6 +220,8 @@ export function parseSignature(signature: string, structs: RecordLookup = {}) {
 export function parseFunctionSignature(
   signature: string,
   records: RecordLookup = {},
+  variants: VariantLookup = {},
+  enums: EnumLookup = {},
 ) {
   const match = execFunctionSignature(signature);
   if (!match) throw new InvalidSignatureError({ signature, type: "func" });
@@ -231,6 +233,8 @@ export function parseFunctionSignature(
     inputs.push(
       parseWitParameter(inputParams[i]!, {
         records,
+        variants,
+        enums,
       }),
     );
   }
@@ -243,6 +247,8 @@ export function parseFunctionSignature(
       outputs.push(
         parseWitParameter(outputParams[i]!, {
           records,
+          variants,
+          enums,
         }),
       );
     }
@@ -263,3 +269,13 @@ export function parseFunctionSignature(
     outputs,
   };
 }
+
+export function enumToComponents<cases extends readonly string[]>(
+  cases: cases,
+): EnumToComponents<cases> {
+  return cases.map((caseName) => ({
+    name: caseName,
+    type: "_" as const,
+    internalType: "_" as const,
+  })) as EnumToComponents<cases>;
+}

package/src/wit/wit-parser/parse-wit-parameter.test.ts

@@ -1,6 +1,7 @@
 import { expectTypeOf, expect, test } from "vitest";
 
 import { parseWitParameter } from "./parse-wit-parameter.js";
+
 import type { ParseWitParameter } from "./parse-wit-parameter.js";
 
 test("ParseWitParameter", () => {
@@ -20,7 +21,7 @@ test("ParseWitParameter", () => {
     >
   >().toEqualTypeOf<{
     readonly name: "arith-address";
-    readonly type: "tuple";
+    readonly type: "record";
     readonly internalType: "contract-address";
     readonly components: readonly [
       {
@@ -50,7 +51,7 @@ test("ParseWitParameter", () => {
     >
   >().toEqualTypeOf<{
     readonly name: "arith-address";
-    readonly type: "result<tuple, error>";
+    readonly type: "result<record, error>";
     readonly internalType: "result<contract-address, error>";
     readonly components: readonly [
       {
@@ -70,6 +71,76 @@ test("ParseWitParameter", () => {
       },
     ];
   }>();
+
+  // Enum type tests
+  expectTypeOf<
+    ParseWitParameter<
+      ["enum status { pending, active, completed, cancelled }", "s: status"]
+    >
+  >().toEqualTypeOf<{
+    readonly name: "s";
+    readonly type: "enum";
+    readonly internalType: "status";
+    readonly components: readonly [
+      {
+        readonly name: "pending";
+        readonly type: "_";
+      },
+      {
+        readonly name: "active";
+        readonly type: "_";
+      },
+      {
+        readonly name: "completed";
+        readonly type: "_";
+      },
+      {
+        readonly name: "cancelled";
+        readonly type: "_";
+      },
+    ];
+  }>();
+  expectTypeOf<
+    ParseWitParameter<
+      ["enum status { pending, active, completed }", "s: option<status>"]
+    >
+  >().toEqualTypeOf<{
+    readonly name: "s";
+    readonly type: "option<enum>";
+    readonly internalType: "option<status>";
+    readonly components: readonly [
+      {
+        readonly name: "pending";
+        readonly type: "_";
+      },
+      {
+        readonly name: "active";
+        readonly type: "_";
+      },
+      {
+        readonly name: "completed";
+        readonly type: "_";
+      },
+    ];
+  }>();
+
+  //    type t = ParseWitParameter
+  //      [
+  // "record rbg {  red: u64, blue: u64, green: u64 }",
+  //        "variant color {  hexkey(string), rgb(rbg) }",
+  //        "c: color ",
+  //      ]
+  //    >
+  //
+  //  expectTypeOf
+  //    ParseWitParameter
+  //      [
+  // "record rbg {  red: u64, blue: u64, green: u64 }",
+  //        "variant color {  hexkey(string), rgb(rbg) }",
+  //        "c: color ",
+  //      ]
+  //    >
+  //  >().toEqualTypeOf<>({});
 });
 
 test("parseWitParameter", () => {
@@ -109,7 +180,7 @@ test.each([
     expected: {
       name: "arith-address",
 
-      type: "tuple",
+      type: "record",
       internalType: "contract-address",
       components: [
         {
@@ -137,7 +208,7 @@ test.each([
     ],
     expected: {
       name: "arith-address",
-      type: "result<tuple, error>",
+      type: "result<record, error>",
       internalType: "result<contract-address, error>",
       components: [
         {
@@ -158,6 +229,213 @@ test.each([
       ],
     },
   },
+  {
+    signature: [
+      "record rgb { red: u64, blue: u64, green: u64 }",
+      "variant color-literal { red, green, blue }",
+      "variant color { hex(string), rgb(rgb), literal(color-literal) }",
+      "c:  color",
+    ],
+    expected: {
+      name: "c",
+      type: "variant",
+      internalType: "color",
+      components: [
+        {
+          name: "hex",
+          type: "string",
+          internalType: "string",
+        },
+        {
+          name: "rgb",
+          type: "record",
+          internalType: "rgb",
+          components: [
+            { name: "red", type: "u64", internalType: "u64" },
+            { name: "blue", type: "u64", internalType: "u64" },
+            { name: "green", type: "u64", internalType: "u64" },
+          ],
+        },
+
+        {
+          name: "literal",
+          internalType: "color-literal",
+          type: "variant",
+          components: [
+            {
+              internalType: "_",
+              name: "red",
+              type: "_",
+            },
+            {
+              internalType: "_",
+              name: "green",
+              type: "_",
+            },
+            {
+              internalType: "_",
+              name: "blue",
+              type: "_",
+            },
+          ],
+        },
+      ],
+    },
+  },
+  // Enum test cases
+  {
+    signature: [
+      "enum status { pending, active, completed, cancelled }",
+      "s: status",
+    ],
+    expected: {
+      name: "s",
+      type: "enum",
+      internalType: "status",
+      components: [
+        {
+          name: "pending",
+          type: "_",
+          internalType: "_",
+        },
+        {
+          name: "active",
+          type: "_",
+          internalType: "_",
+        },
+        {
+          name: "completed",
+          type: "_",
+          internalType: "_",
+        },
+        {
+          name: "cancelled",
+          type: "_",
+          internalType: "_",
+        },
+      ],
+    },
+  },
+  {
+    signature: [
+      "enum priority { low, medium, high, urgent }",
+      "p: option<priority>",
+    ],
+    expected: {
+      name: "p",
+      type: "option<enum>",
+      internalType: "option<priority>",
+      components: [
+        {
+          name: "low",
+          type: "_",
+          internalType: "_",
+        },
+        {
+          name: "medium",
+          type: "_",
+          internalType: "_",
+        },
+        {
+          name: "high",
+          type: "_",
+          internalType: "_",
+        },
+        {
+          name: "urgent",
+          type: "_",
+          internalType: "_",
+        },
+      ],
+    },
+  },
+  {
+    signature: [
+      "enum status { pending, active, completed }",
+      "statuses: list<status>",
+    ],
+    expected: {
+      name: "statuses",
+      type: "list<enum>",
+      internalType: "list<status>",
+      components: [
+        {
+          name: "pending",
+          type: "_",
+          internalType: "_",
+        },
+        {
+          name: "active",
+          type: "_",
+          internalType: "_",
+        },
+        {
+          name: "completed",
+          type: "_",
+          internalType: "_",
+        },
+      ],
+    },
+  },
+  {
+    signature: [
+      "enum status { pending, active, completed }",
+      "s: result<status, error>",
+    ],
+    expected: {
+      name: "s",
+      type: "result<enum, error>",
+      internalType: "result<status, error>",
+      components: [
+        {
+          name: "pending",
+          type: "_",
+          internalType: "_",
+        },
+        {
+          name: "active",
+          type: "_",
+          internalType: "_",
+        },
+        {
+          name: "completed",
+          type: "_",
+          internalType: "_",
+        },
+      ],
+    },
+  },
+  // Mixed enum with record
+  {
+    signature: [
+      "enum status { pending, active, completed }",
+      "record task { id: u64, name: string, task-status: status }",
+      "t: task",
+    ],
+    expected: {
+      name: "t",
+      type: "record",
+      internalType: "task",
+      components: [
+        { name: "id", type: "u64", internalType: "u64" },
+        {
+          name: "name",
+          type: "string",
+          internalType: "string",
+        },
+        {
+          name: "task-status",
+          type: "enum",
+          internalType: "status",
+          components: [
+            { name: "pending", type: "_" },
+            { name: "active", type: "_" },
+            { name: "completed", type: "_" },
+          ],
+        },
+      ],
+    },
+  },
 ])("parseAbiParameter($signature)", ({ signature, expected }) => {
   expect(parseWitParameter<string | string[]>(signature)).toEqual(expected);
 });

package/src/wit/wit-parser/parse-wit-parameter.ts

@@ -3,12 +3,20 @@ import type { WitParameter } from "../wit.js";
 import type { Narrow } from "../narrow.js";
 import type { Filter } from "../type-utils.js";
 import { InvalidWitParameterError } from "./core/errors/wit-parameter.js";
-import { parseRecords } from "./core/records.js";
-import { isRecordSignature } from "./core/signatures.js";
-import type { ParseRecords } from "./core/types/records.js";
-import type { IsRecordSignature } from "./core/types/signatures.js";
+import {
+  isRecordSignature,
+  isVariantSignature,
+  isEnumSignature,
+} from "./core/signatures.js";
+import type {
+  IsRecordSignature,
+  IsVariantSignature,
+  IsEnumSignature,
+} from "./core/types/signatures.js";
 import type { ParseWitParameter as ParseWitParameter_ } from "./core/types/utils.js";
 import { parseWitParameter as parseWitParameter_ } from "./core/utils.js";
+import { parseTypes } from "./core/user-defined.js";
+import type { ParseTypes } from "./core/types/user-defined.js";
 
 export type ParseWitParameter<
   param extends string | readonly string[] | readonly unknown[],
@@ -23,13 +31,28 @@ export type ParseWitParameter<
       : never)
   | (param extends readonly string[]
       ? string[] extends param
-        ? WitParameter // Return generic AbiParameter item since type was no inferrable
-        : ParseRecords<param> extends infer records
+        ? WitParameter // Return generic WitParameter item since type was not inferrable
+        : ParseTypes<param> extends infer types extends {
+              records: any;
+              variants: any;
+              enums: any;
+            }
           ? {
               [key in keyof param]: param[key] extends string
                 ? IsRecordSignature<param[key]> extends true
                   ? never
-                  : ParseWitParameter_<param[key], { records: records }>
+                  : IsVariantSignature<param[key]> extends true
+                    ? never
+                    : IsEnumSignature<param[key]> extends true
+                      ? never
+                      : ParseWitParameter_<
+                          param[key],
+                          {
+                            variants: types["variants"];
+                            records: types["records"];
+                            enums: types["enums"];
+                          }
+                        >
                 : never;
             } extends infer mapped extends readonly unknown[]
             ? Filter<mapped, never>[0] extends infer result
@@ -64,19 +87,22 @@ export function parseWitParameter<
   if (typeof param === "string")
     witParameter = parseWitParameter_(param, {}) as ParseWitParameter<param>;
   else {
-    const records = parseRecords(param as readonly string[]);
+    const types = parseTypes(param as readonly string[]);
     const length = param.length as number;
     for (let i = 0; i < length; i++) {
       const signature = (param as readonly string[])[i]!;
       if (isRecordSignature(signature)) continue;
+      if (isVariantSignature(signature)) continue;
+      if (isEnumSignature(signature)) continue;
+
       witParameter = parseWitParameter_(signature, {
-        records: records,
+        enums: types["enums"],
+        variants: types["variants"],
+        records: types["records"],
       });
       break;
     }
   }
-
   if (!witParameter) throw new InvalidWitParameterError({ param });
-
   return witParameter as ParseWitParameter<param>;
 }