@kontor/kontor-sdk 1.0.0-alpha.0

package/src/wit/wit-parser/core/types/utils.test-d.ts

@@ -0,0 +1,216 @@
+import { assertType, test } from "vitest";
+import type {
+  ParseWitParameter,
+  ParseSignature,
+  SplitParameters,
+  _ParseFunctionParametersAndContext,
+} from "./utils.js";
+
+// TODO: restore this but don't pass a build in type
+// type OptionsWithRecords = {
+//   records: {
+//     "contract-address": [
+//       {
+//         type: "string";
+//         name: "name";
+//       },
+//       {
+//         name: "height";
+//         type: "s64";
+//       },
+//       {
+//         name: "tx-index";
+//         type: "s64";
+//       },
+//     ];
+//   };
+// };
+//
+type OptionsWithRecords = {
+  records: {
+    dog: [
+      {
+        type: "string";
+        name: "name";
+      },
+      {
+        name: "breed";
+        type: "string";
+      },
+    ];
+  };
+};
+
+test("ParseWitParameter", () => {
+  // everything in fib contrct
+  assertType<ParseWitParameter<"ctx: borrow<proc-context>">>({
+    name: "ctx",
+    type: "borrow<proc-context>",
+  });
+
+  assertType<ParseWitParameter<"arith-address: contract-address">>({
+    name: "arith-address",
+    type: "contract-address",
+  });
+
+  assertType<ParseWitParameter<"n: u64">>({
+    name: "n",
+    type: "u64",
+  });
+
+  assertType<ParseWitParameter<"u64">>({
+    type: "u64",
+  });
+
+  assertType<ParseWitParameter<"x: string">>({
+    name: "x",
+    type: "string",
+  });
+
+  assertType<ParseWitParameter<"y: string">>({
+    name: "y",
+    type: "string",
+  });
+
+  assertType<ParseWitParameter<"option-string: option<string>">>({
+    name: "option-string",
+    type: "option<string>",
+  });
+
+  assertType<ParseWitParameter<"option-list-string: option<list<string>>">>({
+    name: "option-list-string",
+    type: "option<list<string>>",
+  });
+
+  assertType<
+    ParseWitParameter<"option-list-result-string-contract-address: option<list<result<string, contract-address>>>">
+  >({
+    name: "option-list-result-string-contract-address",
+    type: "option<list<result<string, contract-address>>>",
+  });
+
+  assertType<ParseWitParameter<"contract-address">>({
+    type: "contract-address",
+  });
+  assertType<ParseWitParameter<"ctx: borrow<view-context>">>({
+    name: "ctx",
+    type: "borrow<view-context>",
+  });
+
+  assertType<ParseWitParameter<"arith-address: contract-address">>({
+    name: "arith-address",
+    type: "contract-address",
+  });
+});
+
+test("_ParseFunctionParametersAndContext", () => {
+  assertType<
+    _ParseFunctionParametersAndContext<"export fib: func(ctx: borrow<proc-context>, arith-address: contract-address, n: u64) -> u64;">
+  >({
+    Inputs: "arith-address: contract-address, n: u64",
+    Context: "proc",
+  });
+
+  assertType<
+    _ParseFunctionParametersAndContext<"export cached-values: func(ctx: borrow<view-context>) -> list<u64>;">
+  >({
+    Inputs: "",
+    Context: "view",
+  });
+
+  assertType<
+    _ParseFunctionParametersAndContext<"export cached-values: func(ctx: borrow<view-context>) -> list<u64>;">
+  >({
+    Inputs: "",
+    Context: "view",
+  });
+
+  assertType<
+    _ParseFunctionParametersAndContext<"export cached-values: func(ctx: borrow<core-context>) -> list<u64>;">
+  >({
+    Inputs: "",
+    Context: "core",
+  });
+});
+
+test("SplitParameters", () => {
+  assertType<SplitParameters<"u64">>(["u64"]);
+  assertType<SplitParameters<"arith-address: contract-address, n: list<u64>">>([
+    "arith-address: contract-address",
+    "n: list<u64>",
+  ]);
+});
+
+test("Parse Signature", () => {
+  assertType<
+    ParseSignature<"export fib: func(ctx: borrow<proc-context>, arith-address: contract-address, n: list<u64>) -> u64;">
+  >({
+    type: "function",
+    name: "fib",
+    context: "proc",
+    inputs: [
+      { name: "arith-address", type: "contract-address" },
+      { name: "n", type: "list<u64>" },
+    ],
+    outputs: [
+      {
+        type: "u64",
+      },
+    ],
+  });
+  assertType<
+    ParseSignature<"export fib: func(ctx: borrow<proc-context>, arith-address: contract-address, n: list<u64>) -> contract-address;">
+  >({
+    type: "function",
+    name: "fib",
+    context: "proc",
+    inputs: [
+      { name: "arith-address", type: "contract-address" },
+      { name: "n", type: "list<u64>" },
+    ],
+    outputs: [
+      {
+        type: "contract-address",
+      },
+    ],
+  });
+  assertType<
+    ParseSignature<"export fib: func(ctx: borrow<proc-context>, arith-address: contract-address, n: list<u64>) -> contract-address;">
+  >({
+    type: "function",
+    name: "fib",
+    context: "proc",
+    inputs: [
+      {
+        name: "arith-address",
+        type: "contract-address",
+      },
+      { name: "n", type: "list<u64>" },
+    ],
+    outputs: [
+      {
+        type: "contract-address",
+      },
+    ],
+  });
+  assertType<
+    ParseSignature<
+      "export get-dogs: func(ctx: borrow<proc-context>) -> list<dog>;",
+      OptionsWithRecords["records"]
+    >
+  >({
+    type: "function",
+    name: "get-dogs",
+    context: "proc",
+    inputs: [],
+    outputs: [
+      {
+        type: "list<tuple>",
+        components: [
+          { type: "string", name: "name" },
+          { type: "string", name: "breed" },
+        ],
+      },
+    ],
+  });
+});

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

@@ -0,0 +1,235 @@
+import type { RecordLookup } from "./records.js";
+import type { Trim, Pretty } from "../../../type-utils.js";
+import type { FunctionSignature, IsFunctionSignature } from "./signatures.js";
+import type { Error_ } from "../../../error.js";
+
+type ParseOptions = {
+  records?: RecordLookup | unknown;
+};
+type DefaultParseOptions = {};
+
+type Readonlyify<T> = { readonly [K in keyof T]: T[K] };
+type HasRecords<Opts> = Opts extends { records: Record<string, unknown> }
+  ? true
+  : false;
+
+type RecordsOf<Opts> = Opts extends { records: infer R extends RecordLookup }
+  ? R
+  : never;
+type WithName<Shallow> = Shallow extends { name: infer N extends string }
+  ? { readonly name: N }
+  : {};
+type GetComponents<T> = T extends { components: infer C }
+  ? { readonly components: C }
+  : {};
+
+type AsTupleFromRecord<T extends string, Opts extends ParseOptions> =
+  HasRecords<Opts> extends true
+    ? T extends keyof RecordsOf<Opts>
+      ? Readonlyify<{ type: "tuple"; components: RecordsOf<Opts>[T] }>
+      : Readonlyify<{ type: T }>
+    : Readonlyify<{ type: T }>;
+
+type SplitResultInner<S extends string> = S extends `${infer L}, ${infer R}`
+  ? [Trim<L>, Trim<R>]
+  : S extends `${infer L},${infer R}`
+    ? [Trim<L>, Trim<R>]
+    : never;
+type MaybeResultComponents<
+  Ok extends { type: string },
+  _Err extends { type: string },
+> = Ok extends { components: infer _C } ? GetComponents<Ok> : {};
+
+// type MaybeResultComponents<
+//   L extends { type: string },
+//   R extends { type: string },
+// > = L extends { components: infer _LC }
+//   ? R extends { components: infer _RC }
+//     ? {
+//         readonly components: [
+//           {
+//             readonly name: "left";
+//             readonly type: L["type"];
+//           } & GetComponents<L>,
+//           {
+//             readonly name: "right";
+//             readonly type: R["type"];
+//           } & GetComponents<R>,
+//         ];
+//       }
+//     : {
+//         readonly components: [
+//           {
+//             readonly name: "left";
+//             readonly type: L["type"];
+//           } & GetComponents<L>,
+//           { readonly name: "right"; readonly type: R["type"] },
+//         ];
+//       }
+//   : R extends { components: infer _RC }
+//     ? {
+//         readonly components: [
+//           { readonly name: "left"; readonly type: L["type"] },
+//           {
+//             readonly name: "right";
+//             readonly type: R["type"];
+//           } & GetComponents<R>,
+//         ];
+//       }
+//     : {}; // neither side has components → omit components entirely
+
+type MapGenericType<T extends string, Opts extends ParseOptions> =
+  // list<...>
+  T extends `list<${infer U}>`
+    ? MapGenericType<Trim<U>, Opts> extends infer M extends { type: string }
+      ? Readonlyify<{ type: `list<${M["type"]}>` } & GetComponents<M>>
+      : never
+    : T extends `option<${infer U}>`
+      ? MapGenericType<Trim<U>, Opts> extends infer M extends { type: string }
+        ? Readonlyify<{ type: `option<${M["type"]}>` } & GetComponents<M>>
+        : never
+      : // result<L, R>
+        T extends `result<${infer Inner}>`
+        ? SplitResultInner<Trim<Inner>> extends [
+            infer LRaw extends string,
+            infer RRaw extends string,
+          ]
+          ? MapGenericType<Trim<LRaw>, Opts> extends infer LMapped extends {
+              type: string;
+            }
+            ? MapGenericType<Trim<RRaw>, Opts> extends infer RMapped extends {
+                type: string;
+              }
+              ? Readonlyify<
+                  {
+                    type: `result<${LMapped["type"]}, ${RMapped["type"]}>`;
+                  } & MaybeResultComponents<LMapped, RMapped>
+                >
+              : never
+            : never
+          : never
+        : // scalar or record-mapped
+          AsTupleFromRecord<T, Opts>;
+
+export type ParseWitParameter<
+  signature extends string,
+  options extends ParseOptions = DefaultParseOptions,
+> = (
+  signature extends `${infer left}: ${infer right}`
+    ? { readonly type: Trim<right> } & { readonly name: Trim<left> }
+    : { readonly type: Trim<signature> }
+) extends infer Shallow extends { type: string; name?: string } // TODO audit this
+  ? Pretty<WithName<Shallow> & MapGenericType<Shallow["type"], options>>
+  : never;
+
+export type ParseWitParameters<
+  signatures extends readonly string[],
+  options extends ParseOptions = DefaultParseOptions,
+> = signatures extends [""]
+  ? readonly []
+  : readonly [
+      ...{
+        [key in keyof signatures]: ParseWitParameter<signatures[key], options>;
+      },
+    ];
+
+// TODO: make this extend "view" | "proc" exp
+export type _ParseFunctionParametersAndContext<signature extends string> =
+  signature extends `${infer head}-> ${string}`
+    ? _ParseFunctionParametersAndContext<Trim<head>>
+    : signature extends `export ${string}: func(ctx: borrow<${infer context}-context>,${infer parameters})`
+      ? {
+          Inputs: Trim<parameters>;
+          Context: context;
+        }
+      : signature extends `export ${string}: func(ctx: borrow<${infer context}-context>)`
+        ? {
+            Inputs: "";
+            Context: context;
+          }
+        : never;
+
+export type SplitParameters<
+  signature extends string,
+  result extends unknown[] = [],
+  current extends string = "",
+  depth extends readonly number[] = [],
+> =
+  // end of input
+  signature extends ""
+    ? current extends ""
+      ? [...result]
+      : depth["length"] extends 0
+        ? [...result, Trim<current>]
+        : Error_<`Unbalanced <>. "${current}" has too many opening "<".`>
+    : signature extends `${infer char}${infer tail}`
+      ? char extends ","
+        ? // split only at top level
+          depth["length"] extends 0
+          ? SplitParameters<tail, [...result, Trim<current>], "">
+          : SplitParameters<tail, result, `${current}${char}`, depth>
+        : char extends "<"
+          ? // enter deeper generic
+            SplitParameters<tail, result, `${current}${char}`, [...depth, 1]>
+          : char extends ">"
+            ? // too many closing '>'
+              depth["length"] extends 0
+              ? Error_<`Unbalanced <>. "${current}${char}" has too many closing ">".`>
+              : SplitParameters<tail, result, `${current}${char}`, Pop<depth>>
+            : // accumulate any other char
+              SplitParameters<tail, result, `${current}${char}`, depth>
+      : [];
+
+type Pop<type extends readonly number[]> = type extends [...infer head, any]
+  ? head
+  : [];
+
+// | (IsFunctionSignature<signature> extends true
+//     ? signature extends FunctionSignature<infer name, infer tail>
+//       ? {
+//           readonly name: name
+//           readonly type: 'function'
+//           readonly stateMutability: _ParseFunctionParametersAndStateMutability<signature>['StateMutability']
+//           readonly inputs: ParseAbiParameters<
+//             SplitParameters<
+//               _ParseFunctionParametersAndStateMutability<signature>['Inputs']
+//             >,
+//             { modifier: FunctionModifier; structs: structs }
+//           >
+//           readonly outputs: tail extends
+//             | `${string}returns (${infer returns})`
+//             | `${string}returns(${infer returns})`
+//             ? ParseAbiParameters<
+//                 SplitParameters<returns>,
+//                 { modifier: FunctionModifier; structs: structs }
+//               >
+//             : readonly []
+//         }
+//       : never
+//     : never)
+
+export type ParseSignature<
+  signature extends string,
+  records extends RecordLookup | unknown = unknown,
+> =
+  IsFunctionSignature<signature> extends true
+    ? signature extends FunctionSignature<infer name, infer tail>
+      ? {
+          readonly name: name;
+          readonly type: "function";
+          readonly context: _ParseFunctionParametersAndContext<signature>["Context"];
+          readonly inputs: ParseWitParameters<
+            SplitParameters<
+              _ParseFunctionParametersAndContext<signature>["Inputs"]
+            >,
+            { records: records }
+          >;
+          readonly outputs: tail extends `${string} -> ${infer returns};`
+            ? ParseWitParameters<
+                SplitParameters<Trim<returns>>,
+                { records: records }
+              >
+            : readonly [];
+        }
+      : never
+    : never;