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

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

@@ -19,7 +19,7 @@ expectTypeOf<ParseWit<typeof nativeToken.raw>>().toEqualTypeOf<
       ];
       readonly outputs: readonly [
         {
-          readonly type: "result<tuple, error>";
+          readonly type: "result<record, error>";
           readonly internalType: "result<mint, error>";
 
           readonly components: readonly [
@@ -50,7 +50,7 @@ expectTypeOf<ParseWit<typeof nativeToken.raw>>().toEqualTypeOf<
       ];
       readonly outputs: readonly [
         {
-          readonly type: "result<tuple, error>";
+          readonly type: "result<record, error>";
           readonly internalType: "result<burn, error>";
 
           readonly components: readonly [
@@ -86,7 +86,7 @@ expectTypeOf<ParseWit<typeof nativeToken.raw>>().toEqualTypeOf<
       ];
       readonly outputs: readonly [
         {
-          readonly type: "result<tuple, error>";
+          readonly type: "result<record, error>";
           readonly internalType: "result<transfer, error>";
 
           readonly components: readonly [
@@ -135,7 +135,7 @@ expectTypeOf<ParseWit<typeof nativeToken.raw>>().toEqualTypeOf<
       readonly inputs: readonly [];
       readonly outputs: readonly [
         {
-          readonly type: "list<tuple>";
+          readonly type: "list<record>";
           readonly internalType: "list<balance>";
           readonly components: readonly [
             {
@@ -183,7 +183,7 @@ expectTypeOf<ParseWit<typeof nativeToken.raw>>().toEqualTypeOf<
       ];
       readonly outputs: readonly [
         {
-          readonly type: "result<tuple, error>";
+          readonly type: "result<record, error>";
           readonly internalType: "result<transfer, error>";
           readonly components: readonly [
             {
@@ -212,7 +212,7 @@ expectTypeOf<ParseWit<typeof nativeToken.raw>>().toEqualTypeOf<
       readonly inputs: readonly [];
       readonly outputs: readonly [
         {
-          readonly type: "result<tuple, error>";
+          readonly type: "result<record, error>";
           readonly internalType: "result<transfer, error>";
           readonly components: readonly [
             {
@@ -255,7 +255,7 @@ describe("parseWit (runtime)", () => {
         ],
         outputs: [
           {
-            type: "result<tuple, error>",
+            type: "result<record, error>",
             internalType: "result<mint, error>",
             components: [
               {
@@ -285,7 +285,7 @@ describe("parseWit (runtime)", () => {
         ],
         outputs: [
           {
-            type: "result<tuple, error>",
+            type: "result<record, error>",
             internalType: "result<burn, error>",
             components: [
               {
@@ -320,7 +320,7 @@ describe("parseWit (runtime)", () => {
         ],
         outputs: [
           {
-            type: "result<tuple, error>",
+            type: "result<record, error>",
             internalType: "result<transfer, error>",
             components: [
               {
@@ -367,7 +367,7 @@ describe("parseWit (runtime)", () => {
         inputs: [],
         outputs: [
           {
-            type: "list<tuple>",
+            type: "list<record>",
             internalType: "list<balance>",
             components: [
               {
@@ -414,7 +414,7 @@ describe("parseWit (runtime)", () => {
         ],
         outputs: [
           {
-            type: "result<tuple, error>",
+            type: "result<record, error>",
             internalType: "result<transfer, error>",
             components: [
               {
@@ -443,7 +443,7 @@ describe("parseWit (runtime)", () => {
         inputs: [],
         outputs: [
           {
-            type: "result<tuple, error>",
+            type: "result<record, error>",
             internalType: "result<transfer, error>",
             components: [
               {
@@ -468,3 +468,729 @@ describe("parseWit (runtime)", () => {
     ]);
   });
 });
+
+const taskManagerWit = [
+  // Enums
+  "enum priority { low, medium, high, urgent }",
+  "enum status { pending, active, completed, cancelled }",
+
+  // Records
+  "record task-id { id: u64 }",
+  "record timestamp { unix-ms: u64 }",
+  "record user { name: string, email: string }",
+  "record task-metadata { created-at: timestamp, updated-at: timestamp, owner: user }",
+  "record task { id: task-id, title: string, description: string, priority: priority, status: status, metadata: task-metadata }",
+
+  // Variants
+  "variant task-event { created(task), updated(task), deleted(task-id), status-changed(status) }",
+  "variant filter { by-status(status), by-priority(priority), by-user(user), all }",
+
+  // Functions
+  "export create-task: func(ctx: borrow<proc-context>, title: string, description: string, priority: priority) -> result<task, error>;",
+  "export update-status: func(ctx: borrow<proc-context>, id: task-id, new-status: status) -> result<task, error>;",
+  "export get-task: func(ctx: borrow<view-context>, id: task-id) -> option<task>;",
+  "export list-tasks: func(ctx: borrow<view-context>, filter: filter) -> list<task>;",
+  "export get-events: func(ctx: borrow<view-context>) -> list<task-event>;",
+  "export delete-task: func(ctx: borrow<proc-context>, id: task-id) -> result<task-id, error>;",
+] as const;
+
+type TaskManagerWit = ParseWit<typeof taskManagerWit>;
+
+test("ParseWit - create-task function", () => {
+  expectTypeOf<TaskManagerWit[0]>().toEqualTypeOf<{
+    readonly name: "create-task";
+    readonly type: "function";
+    readonly context: "proc";
+    readonly inputs: readonly [
+      {
+        readonly name: "title";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+      {
+        readonly name: "description";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+      {
+        readonly name: "priority";
+        readonly type: "enum";
+        readonly internalType: "priority";
+        readonly components: readonly [
+          {
+            readonly name: "low";
+            readonly type: "_";
+          },
+          {
+            readonly name: "medium";
+            readonly type: "_";
+          },
+          {
+            readonly name: "high";
+            readonly type: "_";
+          },
+          {
+            readonly name: "urgent";
+            readonly type: "_";
+          },
+        ];
+      },
+    ];
+    readonly outputs: readonly [
+      {
+        readonly type: "result<record, error>";
+        readonly internalType: "result<task, error>";
+        readonly components: readonly [
+          {
+            readonly name: "id";
+            readonly type: "record";
+            readonly internalType: "task-id";
+            readonly components: readonly [
+              {
+                readonly name: "id";
+                readonly type: "u64";
+                readonly internalType: "u64";
+              },
+            ];
+          },
+          {
+            readonly name: "title";
+            readonly type: "string";
+            readonly internalType: "string";
+          },
+          {
+            readonly name: "description";
+            readonly type: "string";
+            readonly internalType: "string";
+          },
+          {
+            readonly name: "priority";
+            readonly type: "enum";
+            readonly internalType: "priority";
+            readonly components: readonly [
+              {
+                readonly name: "low";
+                readonly type: "_";
+              },
+              {
+                readonly name: "medium";
+                readonly type: "_";
+              },
+              {
+                readonly name: "high";
+                readonly type: "_";
+              },
+              {
+                readonly name: "urgent";
+                readonly type: "_";
+              },
+            ];
+          },
+          {
+            readonly name: "status";
+            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: "_";
+              },
+            ];
+          },
+          {
+            readonly name: "metadata";
+            readonly type: "record";
+            readonly internalType: "task-metadata";
+            readonly components: readonly [
+              {
+                readonly name: "created-at";
+                readonly type: "record";
+                readonly internalType: "timestamp";
+                readonly components: readonly [
+                  {
+                    readonly name: "unix-ms";
+                    readonly type: "u64";
+                    readonly internalType: "u64";
+                  },
+                ];
+              },
+              {
+                readonly name: "updated-at";
+                readonly type: "record";
+                readonly internalType: "timestamp";
+                readonly components: readonly [
+                  {
+                    readonly name: "unix-ms";
+                    readonly type: "u64";
+                    readonly internalType: "u64";
+                  },
+                ];
+              },
+              {
+                readonly name: "owner";
+                readonly type: "record";
+                readonly internalType: "user";
+                readonly components: readonly [
+                  {
+                    readonly name: "name";
+                    readonly type: "string";
+                    readonly internalType: "string";
+                  },
+                  {
+                    readonly name: "email";
+                    readonly type: "string";
+                    readonly internalType: "string";
+                  },
+                ];
+              },
+            ];
+          },
+        ];
+      },
+    ];
+  }>();
+});
+
+test("ParseWit - update-status function", () => {
+  expectTypeOf<TaskManagerWit[1]>().toEqualTypeOf<{
+    readonly name: "update-status";
+    readonly type: "function";
+    readonly context: "proc";
+    readonly inputs: readonly [
+      {
+        readonly name: "id";
+        readonly type: "record";
+        readonly internalType: "task-id";
+        readonly components: readonly [
+          {
+            readonly name: "id";
+            readonly type: "u64";
+            readonly internalType: "u64";
+          },
+        ];
+      },
+      {
+        readonly name: "new-status";
+        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: "_";
+          },
+        ];
+      },
+    ];
+    readonly outputs: readonly [
+      {
+        readonly type: "result<record, error>";
+        readonly internalType: "result<task, error>";
+        readonly components: readonly [
+          {
+            readonly name: "id";
+            readonly type: "record";
+            readonly internalType: "task-id";
+            readonly components: readonly [
+              {
+                readonly name: "id";
+                readonly type: "u64";
+                readonly internalType: "u64";
+              },
+            ];
+          },
+          {
+            readonly name: "title";
+            readonly type: "string";
+            readonly internalType: "string";
+          },
+          {
+            readonly name: "description";
+            readonly type: "string";
+            readonly internalType: "string";
+          },
+          {
+            readonly name: "priority";
+            readonly type: "enum";
+            readonly internalType: "priority";
+            readonly components: readonly [
+              {
+                readonly name: "low";
+                readonly type: "_";
+              },
+              {
+                readonly name: "medium";
+                readonly type: "_";
+              },
+              {
+                readonly name: "high";
+                readonly type: "_";
+              },
+              {
+                readonly name: "urgent";
+                readonly type: "_";
+              },
+            ];
+          },
+          {
+            readonly name: "status";
+            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: "_";
+              },
+            ];
+          },
+          {
+            readonly name: "metadata";
+            readonly type: "record";
+            readonly internalType: "task-metadata";
+            readonly components: readonly [
+              {
+                readonly name: "created-at";
+                readonly type: "record";
+                readonly internalType: "timestamp";
+                readonly components: readonly [
+                  {
+                    readonly name: "unix-ms";
+                    readonly type: "u64";
+                    readonly internalType: "u64";
+                  },
+                ];
+              },
+              {
+                readonly name: "updated-at";
+                readonly type: "record";
+                readonly internalType: "timestamp";
+                readonly components: readonly [
+                  {
+                    readonly name: "unix-ms";
+                    readonly type: "u64";
+                    readonly internalType: "u64";
+                  },
+                ];
+              },
+              {
+                readonly name: "owner";
+                readonly type: "record";
+                readonly internalType: "user";
+                readonly components: readonly [
+                  {
+                    readonly name: "name";
+                    readonly type: "string";
+                    readonly internalType: "string";
+                  },
+                  {
+                    readonly name: "email";
+                    readonly type: "string";
+                    readonly internalType: "string";
+                  },
+                ];
+              },
+            ];
+          },
+        ];
+      },
+    ];
+  }>();
+});
+
+test("ParseWit - get-task function", () => {
+  expectTypeOf<TaskManagerWit[2]>().toEqualTypeOf<{
+    readonly name: "get-task";
+    readonly type: "function";
+    readonly context: "view";
+    readonly inputs: readonly [
+      {
+        readonly name: "id";
+        readonly type: "record";
+        readonly internalType: "task-id";
+        readonly components: readonly [
+          {
+            readonly name: "id";
+            readonly type: "u64";
+            readonly internalType: "u64";
+          },
+        ];
+      },
+    ];
+    readonly outputs: readonly [
+      {
+        readonly type: "option<record>";
+        readonly internalType: "option<task>";
+        readonly components: readonly [
+          {
+            readonly name: "id";
+            readonly type: "record";
+            readonly internalType: "task-id";
+            readonly components: readonly [
+              {
+                readonly name: "id";
+                readonly type: "u64";
+                readonly internalType: "u64";
+              },
+            ];
+          },
+          {
+            readonly name: "title";
+            readonly type: "string";
+            readonly internalType: "string";
+          },
+          {
+            readonly name: "description";
+            readonly type: "string";
+            readonly internalType: "string";
+          },
+          {
+            readonly name: "priority";
+            readonly type: "enum";
+            readonly internalType: "priority";
+            readonly components: readonly [
+              {
+                readonly name: "low";
+                readonly type: "_";
+              },
+              {
+                readonly name: "medium";
+                readonly type: "_";
+              },
+              {
+                readonly name: "high";
+                readonly type: "_";
+              },
+              {
+                readonly name: "urgent";
+                readonly type: "_";
+              },
+            ];
+          },
+          {
+            readonly name: "status";
+            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: "_";
+              },
+            ];
+          },
+          {
+            readonly name: "metadata";
+            readonly type: "record";
+            readonly internalType: "task-metadata";
+            readonly components: readonly [
+              {
+                readonly name: "created-at";
+                readonly type: "record";
+                readonly internalType: "timestamp";
+                readonly components: readonly [
+                  {
+                    readonly name: "unix-ms";
+                    readonly type: "u64";
+                    readonly internalType: "u64";
+                  },
+                ];
+              },
+              {
+                readonly name: "updated-at";
+                readonly type: "record";
+                readonly internalType: "timestamp";
+                readonly components: readonly [
+                  {
+                    readonly name: "unix-ms";
+                    readonly type: "u64";
+                    readonly internalType: "u64";
+                  },
+                ];
+              },
+              {
+                readonly name: "owner";
+                readonly type: "record";
+                readonly internalType: "user";
+                readonly components: readonly [
+                  {
+                    readonly name: "name";
+                    readonly type: "string";
+                    readonly internalType: "string";
+                  },
+                  {
+                    readonly name: "email";
+                    readonly type: "string";
+                    readonly internalType: "string";
+                  },
+                ];
+              },
+            ];
+          },
+        ];
+      },
+    ];
+  }>();
+});
+
+test("ParseWit - list-tasks function - debug", () => {
+  type ListTasks = TaskManagerWit[3];
+
+  // Check basic properties
+  expectTypeOf<ListTasks["name"]>().toEqualTypeOf<"list-tasks">();
+  expectTypeOf<ListTasks["type"]>().toEqualTypeOf<"function">();
+  expectTypeOf<ListTasks["context"]>().toEqualTypeOf<"view">();
+
+  // Check inputs
+  type Inputs = ListTasks["inputs"];
+  expectTypeOf<Inputs["length"]>().toEqualTypeOf<1>();
+
+  type FilterInput = Inputs[0];
+  expectTypeOf<FilterInput["name"]>().toEqualTypeOf<"filter">();
+  expectTypeOf<FilterInput["type"]>().toEqualTypeOf<"variant">();
+  expectTypeOf<FilterInput["internalType"]>().toEqualTypeOf<"filter">();
+
+  // Check variant components
+  type FilterComponents = FilterInput["components"];
+  expectTypeOf<FilterComponents["length"]>().toEqualTypeOf<4>();
+
+  expectTypeOf<FilterComponents[0]>().toEqualTypeOf<{
+    readonly name: "by-status";
+    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<FilterComponents[1]>().toEqualTypeOf<{
+    readonly name: "by-priority";
+    readonly type: "enum";
+    readonly internalType: "priority";
+    readonly components: readonly [
+      {
+        readonly name: "low";
+        readonly type: "_";
+      },
+      {
+        readonly name: "medium";
+        readonly type: "_";
+      },
+      {
+        readonly name: "high";
+        readonly type: "_";
+      },
+      {
+        readonly name: "urgent";
+        readonly type: "_";
+      },
+    ];
+  }>();
+  expectTypeOf<FilterComponents[2]>().toEqualTypeOf<{
+    readonly name: "by-user";
+    readonly type: "record";
+    readonly internalType: "user";
+    readonly components: readonly [
+      {
+        readonly name: "name";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+      {
+        readonly name: "email";
+        readonly type: "string";
+        readonly internalType: "string";
+      },
+    ];
+  }>();
+  //
+  expectTypeOf<FilterComponents[3]>().toEqualTypeOf<{
+    readonly name: "all";
+    readonly internalType: "_";
+    readonly type: "_";
+  }>();
+
+  // Now check the outputs
+  type Outputs = ListTasks["outputs"];
+  expectTypeOf<Outputs["length"]>().toEqualTypeOf<1>();
+
+  type FirstOutput = Outputs[0];
+  expectTypeOf<FirstOutput["type"]>().toEqualTypeOf<"list<record>">();
+  expectTypeOf<FirstOutput["internalType"]>().toEqualTypeOf<"list<task>">();
+});
+
+test("ParseWit - get-events function", () => {
+  type GetEventsFunction = TaskManagerWit[4];
+
+  // Test basic function properties
+  expectTypeOf<GetEventsFunction["name"]>().toEqualTypeOf<"get-events">();
+  expectTypeOf<GetEventsFunction["type"]>().toEqualTypeOf<"function">();
+  expectTypeOf<GetEventsFunction["context"]>().toEqualTypeOf<"view">();
+  expectTypeOf<GetEventsFunction["inputs"]>().toEqualTypeOf<readonly []>();
+
+  // Test outputs structure
+  type Outputs = GetEventsFunction["outputs"];
+  type OutputType = Outputs[0];
+  expectTypeOf<OutputType["type"]>().toEqualTypeOf<"list<variant>">();
+  expectTypeOf<
+    OutputType["internalType"]
+  >().toEqualTypeOf<"list<task-event>">();
+
+  // Test components (the 4 variant cases)
+  type Components = OutputType["components"];
+  expectTypeOf<Components["length"]>().toEqualTypeOf<4>();
+
+  // Test "created" variant
+  type CreatedVariant = Components[0];
+  expectTypeOf<CreatedVariant["name"]>().toEqualTypeOf<"created">();
+  expectTypeOf<CreatedVariant["type"]>().toEqualTypeOf<"record">();
+  expectTypeOf<CreatedVariant["internalType"]>().toEqualTypeOf<"task">();
+
+  // Test created task structure (spot check a few fields)
+  type CreatedComponents = CreatedVariant["components"];
+  expectTypeOf<CreatedComponents[0]["name"]>().toEqualTypeOf<"id">();
+  expectTypeOf<CreatedComponents[1]["name"]>().toEqualTypeOf<"title">();
+  expectTypeOf<CreatedComponents[2]["name"]>().toEqualTypeOf<"description">();
+
+  // Test "updated" variant (should be same structure as created)
+  type UpdatedVariant = Components[1];
+  expectTypeOf<UpdatedVariant["name"]>().toEqualTypeOf<"updated">();
+  expectTypeOf<UpdatedVariant["type"]>().toEqualTypeOf<"record">();
+  expectTypeOf<UpdatedVariant["internalType"]>().toEqualTypeOf<"task">();
+
+  // Test "deleted" variant
+  type DeletedVariant = Components[2];
+  expectTypeOf<DeletedVariant["name"]>().toEqualTypeOf<"deleted">();
+  expectTypeOf<DeletedVariant["type"]>().toEqualTypeOf<"record">();
+  expectTypeOf<DeletedVariant["internalType"]>().toEqualTypeOf<"task-id">();
+  expectTypeOf<DeletedVariant["components"][0]["name"]>().toEqualTypeOf<"id">();
+  expectTypeOf<
+    DeletedVariant["components"][0]["type"]
+  >().toEqualTypeOf<"u64">();
+
+  // Test "status-changed" variant - THIS IS THE TRICKY ONE
+  type StatusChangedVariant = Components[3];
+  expectTypeOf<StatusChangedVariant>().toEqualTypeOf<{
+    readonly name: "status-changed";
+    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: "_";
+      },
+    ];
+  }>();
+});
+
+test("ParseWit - delete-task function", () => {
+  type DeleteTaskFunction = TaskManagerWit[5];
+
+  // Test basic function properties
+  expectTypeOf<DeleteTaskFunction["name"]>().toEqualTypeOf<"delete-task">();
+  expectTypeOf<DeleteTaskFunction["type"]>().toEqualTypeOf<"function">();
+  expectTypeOf<DeleteTaskFunction["context"]>().toEqualTypeOf<"proc">();
+
+  // Test inputs
+  type Inputs = DeleteTaskFunction["inputs"];
+  expectTypeOf<Inputs["length"]>().toEqualTypeOf<1>();
+
+  type IdInput = Inputs[0];
+  expectTypeOf<IdInput["name"]>().toEqualTypeOf<"id">();
+  expectTypeOf<IdInput["type"]>().toEqualTypeOf<"record">();
+  expectTypeOf<IdInput["internalType"]>().toEqualTypeOf<"task-id">();
+  expectTypeOf<IdInput["components"][0]["name"]>().toEqualTypeOf<"id">();
+  expectTypeOf<IdInput["components"][0]["type"]>().toEqualTypeOf<"u64">();
+  expectTypeOf<
+    IdInput["components"][0]["internalType"]
+  >().toEqualTypeOf<"u64">();
+
+  // Test outputs
+  type Outputs = DeleteTaskFunction["outputs"];
+  expectTypeOf<Outputs["length"]>().toEqualTypeOf<1>();
+
+  type OutputType = Outputs[0];
+  expectTypeOf<OutputType["type"]>().toEqualTypeOf<"result<record, error>">();
+  expectTypeOf<
+    OutputType["internalType"]
+  >().toEqualTypeOf<"result<task-id, error>">();
+
+  // Test result components (task-id structure)
+  type OutputComponents = OutputType["components"];
+  expectTypeOf<OutputComponents["length"]>().toEqualTypeOf<1>();
+  expectTypeOf<OutputComponents[0]["name"]>().toEqualTypeOf<"id">();
+  expectTypeOf<OutputComponents[0]["type"]>().toEqualTypeOf<"u64">();
+  expectTypeOf<OutputComponents[0]["internalType"]>().toEqualTypeOf<"u64">();
+});