feat(protocol-parser): add new schema helpers (#2478)

packages/protocol-parser/package.json

@@ -35,6 +35,7 @@
   },
   "dependencies": {
     "@latticexyz/common": "workspace:*",
+    "@latticexyz/config": "workspace:*",
     "@latticexyz/schema-type": "workspace:*",
     "abitype": "1.0.0",
     "viem": "2.7.12"

packages/protocol-parser/src/exports/internal.ts

@@ -25,3 +25,7 @@ export * from "../schemaToHex";
 export * from "../staticDataLength";
 export * from "../valueSchemaToFieldLayoutHex";
 export * from "../valueSchemaToHex";
+
+export * from "../getKeySchema";
+export * from "../getValueSchema";
+export * from "../getSchemaTypes";

packages/protocol-parser/src/getKeySchema.ts

@@ -0,0 +1,9 @@
+import { Table } from "@latticexyz/config";
+
+export type getKeySchema<table extends Table> = {
+  [fieldName in table["key"][number]]: table["schema"][fieldName];
+};
+
+export function getKeySchema<table extends Table>(table: table): getKeySchema<table> {
+  return Object.fromEntries(table.key.map((fieldName) => [fieldName, table.schema[fieldName]])) as getKeySchema<table>;
+}

packages/protocol-parser/src/getSchemaTypes.ts

@@ -0,0 +1,10 @@
+import { Schema } from "@latticexyz/config";
+import { mapObject } from "@latticexyz/common/utils";
+
+export type getSchemaTypes<schema extends Schema> = {
+  readonly [k in keyof schema]: schema[k]["type"];
+};
+
+export function getSchemaTypes<schema extends Schema>(schema: schema): getSchemaTypes<schema> {
+  return mapObject(schema, (value) => value.type);
+}

packages/protocol-parser/src/getValueSchema.ts

@@ -0,0 +1,11 @@
+import { Table } from "@latticexyz/config";
+
+export type getValueSchema<table extends Table> = {
+  [fieldName in Exclude<keyof table["schema"], table["key"][number]>]: table["schema"][fieldName];
+};
+
+export function getValueSchema<table extends Table>(table: table): getValueSchema<table> {
+  return Object.fromEntries(
+    Object.entries(table.schema).filter(([fieldName]) => !table.key.includes(fieldName)),
+  ) as getValueSchema<table>;
+}

packages/store-sync/src/query-cache/createStorageAdapter.ts

@@ -2,11 +2,16 @@ import { StorageAdapter } from "../common";
 import { QueryCacheStore, RawTableRecord, TableRecord } from "./createStore";
 import { hexToResource, resourceToLabel, spliceHex } from "@latticexyz/common";
 import { Hex, concatHex, size } from "viem";
-import { decodeKey, decodeValueArgs } from "@latticexyz/protocol-parser/internal";
+import {
+  KeySchema,
+  decodeKey,
+  decodeValueArgs,
+  getKeySchema,
+  getValueSchema,
+} from "@latticexyz/protocol-parser/internal";
 import { flattenSchema } from "../flattenSchema";
 import debug from "debug";
 import { Tables } from "./common";
-import { getKeySchema, getValueSchema } from "@latticexyz/store/config/v2";
 
 function getRecordId({ tableId, keyTuple }: { tableId: Hex; keyTuple: readonly Hex[] }): string {
   return `${tableId}:${concatHex(keyTuple)}`;
@@ -110,7 +115,8 @@ export function createStorageAdapter({ store }: CreateStorageAdapterOptions<Quer
     const records: readonly TableRecord[] = [
       ...previousRecords.filter((record) => !touchedIds.has(record.id)),
       ...Object.values(updatedRawRecords).map((rawRecord): TableRecord => {
-        const key = decodeKey(flattenSchema(getKeySchema(rawRecord.table)), rawRecord.keyTuple);
+        const keySchema = flattenSchema(getKeySchema(rawRecord.table));
+        const key = decodeKey(keySchema as KeySchema, rawRecord.keyTuple);
         const value = decodeValueArgs(flattenSchema(getValueSchema(rawRecord.table)), rawRecord);
 
         return {

packages/store-sync/src/query-cache/createStore.ts

@@ -1,9 +1,10 @@
 import { StoreApi, UseBoundStore, create } from "zustand";
-import { Table, getKeySchema, getValueSchema } from "@latticexyz/store/config/v2";
+import { Table } from "@latticexyz/store/config/v2";
 import { Tables } from "./common";
 import { Hex } from "viem";
 import { StaticPrimitiveType } from "@latticexyz/schema-type/internal";
 import { SchemaToPrimitives } from "@latticexyz/store";
+import { getKeySchema, getValueSchema } from "@latticexyz/protocol-parser/internal";
 
 export type RawTableRecord<table extends Table = Table> = {
   readonly table: table;

packages/store/ts/config/v2/compat.ts

@@ -1,7 +1,7 @@
 import { conform } from "@arktype/util";
 import { Schema, Store, Table } from "./output";
 import { mapObject } from "@latticexyz/common/utils";
-import { getKeySchema, getValueSchema } from "./table";
+import { getKeySchema, getValueSchema } from "@latticexyz/protocol-parser/internal";
 
 export type storeToV1<store> = store extends Store
   ? {

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

@@ -1,9 +1,10 @@
 import { attest } from "@arktype/attest";
 import { describe, it } from "vitest";
 import { getStaticAbiTypeKeys, AbiTypeScope, extendScope } from "./scope";
-import { validateKeys, defineTable, getKeySchema, getValueSchema } from "./table";
+import { validateKeys, defineTable } from "./table";
 import { TABLE_CODEGEN_DEFAULTS } from "./defaults";
 import { resourceToHex } from "@latticexyz/common";
+import { getKeySchema, getValueSchema } from "@latticexyz/protocol-parser/internal";
 
 describe("validateKeys", () => {
   it("should return a tuple of valid keys", () => {
@@ -186,6 +187,7 @@ describe("resolveTable", () => {
   });
 });
 
+// TODO: move tests to protocol parser after we add arktype
 describe("getKeySchema", () => {
   it("should return the fields of the schema that are part of the key", () => {
     const scope = extendScope(AbiTypeScope, { Static: "address", Dynamic: "string" });
@@ -209,6 +211,7 @@ describe("getKeySchema", () => {
   });
 });
 
+// TODO: move tests to protocol parser after we add arktype
 describe("getValueSchema", () => {
   it("should return the fields of the schema that are not part of the key", () => {
     const scope = extendScope(AbiTypeScope, { Static: "address", Dynamic: "string" });

packages/store/ts/config/v2/table.ts

@@ -8,7 +8,6 @@ import { TableCodegen } from "./output";
 import { TABLE_CODEGEN_DEFAULTS, TABLE_DEFAULTS } from "./defaults";
 import { resourceToHex } from "@latticexyz/common";
 import { SchemaInput, TableInput } from "./input";
-import { Table } from "@latticexyz/config";
 
 export type ValidKeys<schema extends SchemaInput, scope extends Scope> = readonly [
   getStaticAbiTypeKeys<schema, scope>,
@@ -160,21 +159,3 @@ export function defineTable<input, scope extends Scope = AbiTypeScope>(
   validateTable(input, scope);
   return resolveTable(input, scope) as resolveTable<input, scope>;
 }
-
-export type getKeySchema<table extends Table> = {
-  [fieldName in table["key"][number]]: table["schema"][fieldName];
-};
-
-export function getKeySchema<table extends Table>(table: table): getKeySchema<table> {
-  return Object.fromEntries(table.key.map((fieldName) => [fieldName, table.schema[fieldName]])) as getKeySchema<table>;
-}
-
-export type getValueSchema<table extends Table> = {
-  [fieldName in Exclude<keyof table["schema"], table["key"][number]>]: table["schema"][fieldName];
-};
-
-export function getValueSchema<table extends Table>(table: table): getValueSchema<table> {
-  return Object.fromEntries(
-    Object.entries(table.schema).filter(([fieldName]) => !table.key.includes(fieldName)),
-  ) as getValueSchema<table>;
-}