@kontor/kontor-sdk 1.0.0-alpha.0

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

@@ -0,0 +1,215 @@
+import { expectTypeOf, test } from "vitest";
+
+import type {
+  ParseRecords,
+  ParseRecord,
+  ParseRecordProperties,
+  // RecordLookup,
+} from "./records.js";
+
+type Records = {
+  "contract-address": readonly [
+    { readonly name: "name"; readonly type: "string" },
+    { readonly name: "height"; readonly type: "s64" },
+    { readonly name: "tx-index"; readonly type: "s64" },
+  ];
+};
+
+test("ParseRecords", () => {
+  expectTypeOf<
+    ParseRecords<
+      [
+        "record contract-address {  name: string, height: s64, tx-index: s64 }",
+        "record token-pair {  a: contract-address, b: contract-address }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    "contract-address": readonly [
+      { readonly name: "name"; readonly type: "string" },
+      { readonly name: "height"; readonly type: "s64" },
+      { readonly name: "tx-index"; readonly type: "s64" },
+    ];
+
+    "token-pair": readonly [
+      {
+        readonly type: "tuple";
+        readonly name: "a";
+        readonly components: readonly [
+          { readonly name: "name"; readonly type: "string" },
+          { readonly name: "height"; readonly type: "s64" },
+          { readonly name: "tx-index"; readonly type: "s64" },
+        ];
+      },
+      {
+        readonly type: "tuple";
+        readonly name: "b";
+        readonly components: readonly [
+          { readonly name: "name"; readonly type: "string" },
+          { readonly name: "height"; readonly type: "s64" },
+          { readonly name: "tx-index"; readonly type: "s64" },
+        ];
+      },
+    ];
+  }>();
+  expectTypeOf<
+    ParseRecords<
+      [
+        "record contract-address {  name: string, height: s64, tx-index: s64 }",
+        "record token-pair {  values: list<contract-address> }",
+      ]
+    >
+  >().toEqualTypeOf<{
+    "contract-address": readonly [
+      { readonly name: "name"; readonly type: "string" },
+      { readonly name: "height"; readonly type: "s64" },
+      { readonly name: "tx-index"; readonly type: "s64" },
+    ];
+
+    "token-pair": readonly [
+      {
+        readonly name: "values";
+        readonly type: "list<contract-address>";
+      },
+    ];
+  }>();
+  expectTypeOf<
+    ParseRecords<["record contract-address {  cycle: contract-address }"]>
+  >().toEqualTypeOf<{
+    "contract-address": readonly [
+      {
+        readonly name: "cycle";
+        readonly type: "tuple";
+        readonly components: readonly [
+          [
+            'Error: Circular reference detected. Record "contract-address" is a circular reference.',
+          ],
+        ];
+      },
+    ];
+  }>();
+});
+
+test("ParseRecord", () => {
+  expectTypeOf<
+    ParseRecord<"record contract-address {  name: string, height: s64, tx-index: s64 }">
+  >().toEqualTypeOf<{
+    readonly name: "contract-address";
+    readonly components: [
+      { readonly name: "name"; readonly type: "string" },
+      { readonly name: "height"; readonly type: "s64" },
+      { readonly name: "tx-index"; readonly type: "s64" },
+    ];
+  }>();
+
+  expectTypeOf<
+    ParseRecord<"record token-pair {  a: contract-address, b: contract-address }">
+  >().toEqualTypeOf<{
+    readonly name: "token-pair";
+    readonly components: [
+      { readonly name: "a"; readonly type: "contract-address" },
+      { readonly name: "b"; readonly type: "contract-address" },
+    ];
+  }>();
+
+  expectTypeOf<
+    ParseRecord<
+      "record token-pair {  a: contract-address, b: contract-address }",
+      Records
+    >
+  >().toEqualTypeOf<{
+    readonly name: "token-pair";
+    readonly components: [
+      {
+        readonly type: "tuple";
+        readonly name: "a";
+        readonly components: readonly [
+          { readonly name: "name"; readonly type: "string" },
+          { readonly name: "height"; readonly type: "s64" },
+          { readonly name: "tx-index"; readonly type: "s64" },
+        ];
+      },
+      {
+        readonly type: "tuple";
+        readonly name: "b";
+        readonly components: readonly [
+          { readonly name: "name"; readonly type: "string" },
+          { readonly name: "height"; readonly type: "s64" },
+          { readonly name: "tx-index"; readonly type: "s64" },
+        ];
+      },
+    ];
+  }>();
+});
+
+test("ParseRecordProperties", () => {
+  expectTypeOf<
+    ParseRecordProperties<"name: string, height: s64, tx-index: s64">
+  >().toEqualTypeOf<
+    [
+      { readonly name: "name"; readonly type: "string" },
+      { readonly name: "height"; readonly type: "s64" },
+      { readonly name: "tx-index"; readonly type: "s64" },
+    ]
+  >();
+
+  expectTypeOf<
+    ParseRecordProperties<"a: contract-address, b: contract-address">
+  >().toEqualTypeOf<
+    [
+      { readonly name: "a"; readonly type: "contract-address" },
+      { readonly name: "b"; readonly type: "contract-address" },
+    ]
+  >();
+
+  expectTypeOf<
+    ParseRecordProperties<"a: contract-address, b: contract-address", Records>
+  >().toEqualTypeOf<
+    [
+      {
+        readonly type: "tuple";
+        readonly name: "a";
+        readonly components: readonly [
+          { readonly name: "name"; readonly type: "string" },
+          { readonly name: "height"; readonly type: "s64" },
+          { readonly name: "tx-index"; readonly type: "s64" },
+        ];
+      },
+      {
+        readonly type: "tuple";
+        readonly name: "b";
+        readonly components: readonly [
+          { readonly name: "name"; readonly type: "string" },
+          { readonly name: "height"; readonly type: "s64" },
+          { readonly name: "tx-index"; readonly type: "s64" },
+        ];
+      },
+    ]
+  >();
+
+  expectTypeOf<
+    ParseRecordProperties<"values: list<string>", Records>
+  >().toEqualTypeOf<
+    [
+      {
+        readonly name: "values";
+        readonly type: "list<string>";
+      },
+    ]
+  >();
+
+  expectTypeOf<
+    ParseRecordProperties<"values: list<contract-address>", Records>
+  >().toEqualTypeOf<
+    [
+      {
+        readonly name: "values";
+        readonly type: "list<tuple>";
+        readonly components: readonly [
+          { readonly name: "name"; readonly type: "string" },
+          { readonly name: "height"; readonly type: "s64" },
+          { readonly name: "tx-index"; readonly type: "s64" },
+        ];
+      },
+    ]
+  >();
+});

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

@@ -0,0 +1,91 @@
+import type { WitParameter } from "../../../wit.js";
+import type { Trim } from "../../../type-utils.js";
+import type { RecordSignature } from "./signatures.js";
+import type { ParseWitParameter } from "./utils.js";
+import type { Error_ } from "../../../error.js";
+
+export type RecordLookup = Record<string, readonly WitParameter[]>;
+
+export type ParseRecords<signatures extends readonly string[]> =
+  // Create "shallow" version of each record (and filter out non-records or invalid records)
+  {
+    [signature in signatures[number] as ParseRecord<signature> extends infer record extends
+      {
+        name: string;
+      }
+      ? record["name"]
+      : never]: ParseRecord<signature>["components"];
+  } extends infer records extends Record<
+    string,
+    readonly (WitParameter & { type: string })[]
+  >
+    ? // Resolve nested records inside each record
+      {
+        [recordName in keyof records]: ResolveRecords<
+          records[recordName],
+          records
+        >;
+      }
+    : never;
+
+export type ParseRecord<
+  signature extends string,
+  records extends RecordLookup | unknown = unknown,
+> =
+  signature extends RecordSignature<infer name, infer properties>
+    ? {
+        readonly name: Trim<name>;
+        readonly components: ParseRecordProperties<properties, records>;
+      }
+    : never;
+
+export type ParseRecordProperties<
+  signature extends string,
+  records extends RecordLookup | unknown = unknown,
+  result extends any[] = [],
+> =
+  Trim<signature> extends `${infer head},${infer tail}`
+    ? ParseRecordProperties<
+        tail,
+        records,
+        [...result, ParseWitParameter<head, { records: records }>]
+      >
+    : Trim<signature> extends ""
+      ? result
+      : [...result, ParseWitParameter<signature, { records: records }>];
+
+export type ResolveRecords<
+  witParameters extends readonly (WitParameter & { type: string })[],
+  structs extends Record<string, readonly (WitParameter & { type: string })[]>,
+  keyReferences extends { [_: string]: unknown } | unknown = unknown,
+> = readonly [
+  ...{
+    [key in keyof witParameters]: witParameters[key]["type"] extends `${infer head extends
+      string & keyof structs}<${infer tail}>`
+      ? head extends keyof keyReferences
+        ? Error_<`Circular reference detected. Record "${witParameters[key]["type"]}" is a circular reference.`>
+        : {
+            readonly name: witParameters[key]["name"];
+            readonly type: `tuple<${tail}>`;
+            readonly components: ResolveRecords<
+              structs[head],
+              structs,
+              keyReferences & { [_ in head]: true }
+            >;
+          }
+      : // Basic struct (e.g. `type: 'Struct'`)
+        witParameters[key]["type"] extends keyof structs
+        ? witParameters[key]["type"] extends keyof keyReferences
+          ? Error_<`Circular reference detected. Record "${witParameters[key]["type"]}" is a circular reference.`>
+          : {
+              readonly name: witParameters[key]["name"];
+              readonly type: "tuple";
+              readonly components: ResolveRecords<
+                structs[witParameters[key]["type"]],
+                structs,
+                keyReferences & { [_ in witParameters[key]["type"]]: true }
+              >;
+            }
+        : witParameters[key];
+  },
+];

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

@@ -0,0 +1,52 @@
+import { assertType, test } from "vitest";
+
+import type {
+  IsFunctionSignature,
+  IsRecordSignature,
+  IsSignature,
+} from "./signatures.js";
+
+test("IsFunctionSignature", () => {
+  assertType<
+    IsFunctionSignature<"export fib: func(ctx: borrow<proc-context>, arith-address: contract-address, n: u64) -> u64;">
+  >(true);
+
+  assertType<
+    IsFunctionSignature<"export fib-of-sub: func(ctx: borrow<proc-context>, arith-address: contract-address, x: string, y: string) -> result<u64, error>;">
+  >(true);
+
+  assertType<
+    IsFunctionSignature<"export cached-values: func(ctx: borrow<view-context>) -> list<u64>;">
+  >(true);
+});
+
+test("IsRecordSignature", () => {
+  assertType<
+    IsRecordSignature<"record contract-address { name: string, height: s64, tx-index: s64 }">
+  >(true);
+
+  assertType<
+    IsRecordSignature<"record token-pair { a: contract-address, b: contract-address }">
+  >(true);
+});
+test("IsSignature", () => {
+  assertType<
+    IsSignature<"record contract-address { name: string, height: s64, tx-index: s64 }">
+  >(true);
+
+  assertType<
+    IsSignature<"record token-pair { a: contract-address, b: contract-address }">
+  >(true);
+
+  assertType<
+    IsSignature<"export fib: func(ctx: borrow<proc-context>, arith-address: contract-address, n: u64) -> u64;">
+  >(true);
+
+  assertType<
+    IsSignature<"export fib-of-sub: func(ctx: borrow<proc-context>, arith-address: contract-address, x: string, y: string) -> result<u64, error>;">
+  >(true);
+
+  assertType<
+    IsSignature<"export cached-values: func(ctx: borrow<view-context>) -> list<u64>;">
+  >(true);
+});

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

@@ -0,0 +1,180 @@
+import type { Error_ } from "../../../error.js";
+
+export type IsSignature<type extends string> =
+  | (IsFunctionSignature<type> extends true ? true : never)
+  | (IsRecordSignature<type> extends true ? true : never);
+
+export type Signature<
+  string1 extends string,
+  string2 extends string | unknown = unknown,
+> =
+  IsSignature<string1> extends true
+    ? string1
+    : string extends string1 // if exactly `string` (not narrowed), then pass through as valid
+      ? string1
+      : Error_<`Signature "${string1}" is invalid${string2 extends string
+          ? ` at position ${string2}`
+          : ""}.`>;
+
+export type Signatures<signatures extends readonly string[]> = {
+  [key in keyof signatures]: Signature<signatures[key], key>;
+};
+
+export type RecordSignature<
+  name extends string = string,
+  properties extends string = string,
+> = `record ${name} { ${properties} }`;
+
+export type IsRecordSignature<signature extends string> =
+  signature extends RecordSignature<infer name> ? IsName<name> : false;
+
+export type FunctionSignature<
+  name extends string = string,
+  tail extends string = string,
+> = `export ${name}: func(${tail}`;
+
+export type IsFunctionSignature<signature> =
+  signature extends FunctionSignature<infer name>
+    ? IsName<name> extends true
+      ? signature extends ValidFunctionSignatures
+        ? true
+        : false
+      : // : // Check that `Parameters` is not absorbing other types (e.g. `returns)
+        //   signature extends `export ${string}: func(${infer parameters}) ${string}`
+        //   ? parameters extends InvalidFunctionParameters
+        //     ? false
+        //     : true
+        //   : false // i seem to be hitting this case
+        false
+    : false;
+
+export type IsName<name extends string> = name extends ""
+  ? false
+  : ValidateName<name> extends name
+    ? true
+    : false;
+
+export type AssertName<name extends string> =
+  ValidateName<name> extends infer invalidName extends string[]
+    ? `[${invalidName[number]}]`
+    : name;
+
+export type ValidateName<
+  name extends string,
+  checkCharacters extends boolean = false,
+> = name extends `${string}${" "}${string}`
+  ? Error_<`Identifier "${name}" cannot contain whitespace.`>
+  : IsWitKeyword<name> extends true
+    ? Error_<`"${name}" is a protected WIT keyword.`>
+    : name extends `${number}`
+      ? Error_<`Identifier "${name}" cannot be a number string.`>
+      : name extends `${number}${string}`
+        ? Error_<`Identifier "${name}" cannot start with a number.`>
+        : checkCharacters extends true
+          ? IsValidCharacter<name> extends true
+            ? name
+            : Error_<`"${name}" contains invalid character.`>
+          : name;
+
+export type IsWitKeyword<word extends string> = word extends WitKeyword
+  ? true
+  : false;
+
+export type WitKeyword =
+  | "package"
+  | "world"
+  | "interface"
+  | "contract"
+  | "include"
+  | "use"
+  | "import"
+  | "export"
+  | "func"
+  | "borrow"
+  | "record"
+  | "list"
+  | "enum"
+  | "flags"
+  | "variant"
+  | "option"
+  | "result"
+  | "tuple"
+  | "bool"
+  | "s8"
+  | "s16"
+  | "s32"
+  | "s64"
+  | "u8"
+  | "u16"
+  | "u32"
+  | "u64"
+  | "f32"
+  | "f64"
+  | "char"
+  | "string";
+
+export type IsValidCharacter<character extends string> =
+  character extends `${ValidCharacters}${infer tail}`
+    ? tail extends ""
+      ? true
+      : IsValidCharacter<tail>
+    : false;
+
+type ValidCharacters =
+  // lowercase letters
+  | "a"
+  | "b"
+  | "c"
+  | "d"
+  | "e"
+  | "f"
+  | "g"
+  | "h"
+  | "i"
+  | "j"
+  | "k"
+  | "l"
+  | "m"
+  | "n"
+  | "o"
+  | "p"
+  | "q"
+  | "r"
+  | "s"
+  | "t"
+  | "u"
+  | "v"
+  | "w"
+  | "x"
+  | "y"
+  | "z"
+  // special characters
+  | "_";
+
+type Returns = `-> ${string};`;
+type ValidFunctionSignatures =
+  | `export ${string}: func(ctx: borrow<proc-context>) ${Returns}`
+  | `export ${string}: func(ctx: borrow<view-context>) ${Returns}`
+  | `export ${string}: func(ctx: borrow<core-context>) ${Returns}`
+  | `export ${string}: func(ctx: borrow<proc-context>,${string}) ${Returns}`
+  | `export ${string}: func(ctx: borrow<view-context>,${string}) ${Returns}`
+  | `export ${string}: func(ctx: borrow<core-context>,${string}) ${Returns}`;
+
+// @ts-ignore
+type InvalidFunctionParameters =
+  | `${string}${MangledReturns} (${string}`
+  | `${string}) ${MangledReturns}${string}`
+  | `${string})${string}${MangledReturns}${string}(${string}`;
+// r_e_t_u_r_n_s
+type MangledReturns =
+  // single
+  | "${string}->"
+  | "-${string}>"
+  | "->${string}"
+  // double
+  | "${string}-${string}>"
+  | "${string}->${string}"
+  // triple
+  | "${string}-${string}>${string}";
+
+// Single