feat(store): add types for v2 config resolvers (#2290)

Co-authored-by: David Blass <[email protected]>

.gitignore

@@ -19,3 +19,5 @@ templates/*/pnpm-lock.yaml
 
 test-data/world-logs-bulk-*.json
 test-data/world-logs-query.json
+
+.attest

package.json

@@ -27,14 +27,16 @@
     "release:version": "changeset version && pnpm install --lockfile-only && bun scripts/changelog.ts",
     "sort-package-json": "npx sort-package-json package.json 'packages/*/package.json' 'templates/*/package.json' 'templates/*/packages/*/package.json' 'examples/*/package.json' 'examples/*/packages/*/package.json' 'e2e/*/package.json' 'e2e/*/packages/*/package.json' 'docs/package.json'",
     "test": "pnpm run --recursive --filter=!@latticexyz/services test",
-    "test:ci": "pnpm run --recursive --parallel --filter=!@latticexyz/services test:ci"
+    "test:ci": "pnpm run --recursive --parallel --filter=!@latticexyz/services test:ci",
+    "type-stats-repo": "attest stats packages/*"
   },
   "lint-staged": {
     "*.{ts,tsx}": "eslint --cache --fix",
     "*.{ts,tsx,css,md,mdx,sol}": "prettier --write",
     "package.json": "pnpm sort-package-json"
   },
   "devDependencies": {
+    "@arktype/attest": "0.6.4",
     "@changesets/cli": "^2.26.1",
     "@types/node": "^18.15.11",
     "@typescript-eslint/eslint-plugin": "5.46.1",

packages/store/package.json

@@ -51,11 +51,13 @@
     "test:ci": "pnpm run test"
   },
   "dependencies": {
+    "@arktype/util": "0.0.25",
     "@latticexyz/common": "workspace:*",
     "@latticexyz/config": "workspace:*",
     "@latticexyz/protocol-parser": "workspace:*",
     "@latticexyz/schema-type": "workspace:*",
     "abitype": "1.0.0",
+    "arktype": "1.0.29-alpha",
     "viem": "2.7.12",
     "zod": "^3.21.4"
   },

packages/store/ts/config/index.ts

@@ -2,3 +2,4 @@ export * from "./defaults";
 export * from "./storeConfig";
 
 export * from "./experimental/resolveConfig";
+export * from "./v2/store";

packages/store/ts/config/v2/generics.ts

@@ -0,0 +1 @@
+export type get<input, key> = key extends keyof input ? input[key] : undefined;

packages/store/ts/config/v2/schema.test.ts

@@ -0,0 +1,36 @@
+import { describe, it } from "vitest";
+import { resolveSchema } from "./schema";
+import { extendScope, AbiTypeScope } from "./scope";
+import { attest } from "@arktype/attest";
+
+describe("resolveSchema", () => {
+  it("should map user types to their primitive type", () => {
+    const scope = extendScope(AbiTypeScope, { CustomType: "address" });
+    const resolved = resolveSchema({ regular: "uint256", user: "CustomType" }, scope);
+    const expected = {
+      regular: {
+        type: "uint256",
+        internalType: "uint256",
+      },
+      user: {
+        type: "address",
+        internalType: "CustomType",
+      },
+    } as const;
+    attest<typeof expected>(resolved).type.toString.snap(
+      '{ regular: { type: "uint256"; internalType: "uint256"; }; user: { type: "address"; internalType: "CustomType"; }; }',
+    );
+  });
+
+  it("should throw if a type is not part of the scope", () => {
+    const scope = extendScope(AbiTypeScope, { CustomType: "address" });
+    resolveSchema(
+      {
+        regular: "uint256",
+        // @ts-expect-error Type '"NotACustomType"' is not assignable to type 'AbiType | "CustomType"'.
+        user: "NotACustomType",
+      },
+      scope,
+    );
+  });
+});

packages/store/ts/config/v2/schema.ts

@@ -0,0 +1,23 @@
+import { evaluate } from "@arktype/util";
+import { AbiTypeScope } from "./scope";
+
+export type SchemaInput<scope extends AbiTypeScope = AbiTypeScope> = {
+  [key: string]: keyof scope["types"];
+};
+
+export type resolveSchema<schema extends SchemaInput<scope>, scope extends AbiTypeScope> = evaluate<{
+  [key in keyof schema]: {
+    /** the Solidity primitive ABI type */
+    type: scope["types"][schema[key]];
+    /** the user defined type or Solidity primitive ABI type */
+    internalType: schema[key];
+  };
+}>;
+
+export function resolveSchema<schema extends SchemaInput<scope>, scope extends AbiTypeScope = AbiTypeScope>(
+  schema: schema,
+  scope?: scope,
+): resolveSchema<schema, scope> {
+  // TODO: runtime implementation
+  return {} as never;
+}

packages/store/ts/config/v2/scope.test.ts

@@ -0,0 +1,39 @@
+import { attest } from "@arktype/attest";
+import { describe, it } from "vitest";
+import { AbiTypeScope, EmptyScope, ScopeOptions, extendScope, getStaticAbiTypeKeys } from "./scope";
+
+describe("extendScope", () => {
+  it("should extend the provided scope", () => {
+    const extendedScope = extendScope(EmptyScope, { static: "uint256", dynamic: "string" });
+    attest<ScopeOptions<{ static: "uint256"; dynamic: "string" }>>(extendedScope).type.toString.snap(
+      '{ types: { static: "uint256"; dynamic: "string"; }; }',
+    );
+
+    const furtherExtendedScope = extendScope(extendedScope, { static2: "uint256", dynamic2: "string" });
+    attest<ScopeOptions<{ static: "uint256"; dynamic: "string"; static2: "uint256"; dynamic2: "string" }>>(
+      furtherExtendedScope,
+    ).type.toString.snap(
+      '{ types: { static: "uint256"; dynamic: "string"; static2: "uint256"; dynamic2: "string"; }; }',
+    );
+  });
+});
+
+describe("getStaticAbiTypeKeys", () => {
+  it("returns only static keys", () => {
+    attest<
+      "static" | "otherStatic",
+      getStaticAbiTypeKeys<{ static: "uint256"; otherStatic: "address"; dynamic: "string" }>
+    >();
+  });
+
+  it("returns only static keys with a scope", () => {
+    const extendedScope = extendScope(AbiTypeScope, { static: "uint256", dynamic: "string" });
+    attest<
+      "static" | "customStatic",
+      getStaticAbiTypeKeys<
+        { static: "uint256"; dynamic: "string"; customStatic: "static"; customDynamic: "dynamic" },
+        typeof extendedScope
+      >
+    >();
+  });
+});

packages/store/ts/config/v2/scope.ts

@@ -0,0 +1,36 @@
+import { Dict, evaluate } from "@arktype/util";
+import { SchemaInput } from "./schema";
+import { StaticAbiType, DynamicAbiType } from "@latticexyz/schema-type";
+
+export type AbiType = StaticAbiType | DynamicAbiType;
+
+export const EmptyScope = { types: {} } as const satisfies ScopeOptions;
+export type EmptyScope = typeof EmptyScope;
+
+export type AbiTypeScope = ScopeOptions<{ [t in AbiType]: t }>;
+export const AbiTypeScope = { types: {} } as AbiTypeScope; // TODO: runtime implementation
+
+export type ScopeOptions<types extends Dict<string, AbiType> = Dict<string, AbiType>> = {
+  types: types;
+};
+
+export type getStaticAbiTypeKeys<
+  types extends SchemaInput<scope>,
+  scope extends AbiTypeScope = AbiTypeScope,
+> = SchemaInput extends types
+  ? string
+  : {
+      [key in keyof types]: scope["types"][types[key]] extends StaticAbiType ? key : never;
+    }[keyof types];
+
+export type extendScope<scope extends ScopeOptions, additionalTypes extends Dict<string, AbiType>> = evaluate<
+  ScopeOptions<evaluate<scope["types"] & additionalTypes>>
+>;
+
+export function extendScope<scope extends ScopeOptions, additionalTypes extends Dict<string, AbiType>>(
+  scope: scope,
+  additionalTypes: additionalTypes,
+): extendScope<scope, additionalTypes> {
+  // TODO: runtime implementation
+  return {} as never;
+}