rename things

packages/store-sync/src/dozer/common.ts

@@ -1,7 +1,7 @@
 import { Table } from "@latticexyz/config";
 import { Hex } from "viem";
 
-export type DozerTableQuery = {
+export type TableQuery = {
   table: Table;
   /**
    * SQL to filter the records of this table.
@@ -12,7 +12,7 @@ export type DozerTableQuery = {
   sql: string;
 };
 
-export type DozerLogFilter = {
+export type LogFilter = {
   /**
    * Filter logs by the table ID.
    */
@@ -27,4 +27,4 @@ export type DozerLogFilter = {
   key1?: Hex;
 };
 
-export type DozerSyncFilter = DozerTableQuery | DozerLogFilter;
+export type SyncFilter = TableQuery | LogFilter;

packages/store-sync/src/dozer/fetchRecordsDozerSql.test.ts → packages/store-sync/src/dozer/fetchRecordsSql.test.ts

@@ -1,12 +1,12 @@
 import { describe, expect, it } from "vitest";
-import { fetchRecordsDozerSql } from "./fetchRecordsDozerSql";
+import { fetchRecordsSql } from "./fetchRecordsSql";
 import mudConfig from "@latticexyz/world/mud.config";
 import { selectFrom } from "./selectFrom";
 
-describe("fetch dozer sql", () => {
+describe("fetchRecordsSql", () => {
   // TODO: set up CI test case for this (requires setting up dozer in CI)
   it.skip("should fetch dozer sql", async () => {
-    const result = await fetchRecordsDozerSql({
+    const result = await fetchRecordsSql({
       dozerUrl: "https://redstone2.dozer.skystrife.xyz/q",
       storeAddress: "0x9d05cc196c87104a7196fcca41280729b505dbbf",
       queries: [

packages/store-sync/src/dozer/fetchRecordsDozerSql.ts → packages/store-sync/src/dozer/fetchRecordsSql.ts

@@ -1,6 +1,6 @@
 import { DecodeDozerRecordsResult, DozerQueryResult, decodeDozerRecords } from "./decodeDozerRecords";
 import { Hex } from "viem";
-import { DozerTableQuery } from "./common";
+import { TableQuery } from "./common";
 import { Table } from "@latticexyz/config";
 
 type DozerResponseSuccess = {
@@ -12,13 +12,17 @@ type DozerResponseFail = { msg: string };
 
 type DozerResponse = DozerResponseSuccess | DozerResponseFail;
 
-type FetchDozerSqlArgs = {
+function isDozerResponseFail(response: DozerResponse): response is DozerResponseFail {
+  return "msg" in response;
+}
+
+type FetchRecordsSqlArgs = {
   dozerUrl: string;
   storeAddress: Hex;
-  queries: DozerTableQuery[];
+  queries: TableQuery[];
 };
 
-type FetchDozerSqlResult =
+type FetchRecordsSqlResult =
   | {
       blockHeight: bigint;
       result: {
@@ -28,15 +32,11 @@ type FetchDozerSqlResult =
     }
   | undefined;
 
-function isDozerResponseFail(response: DozerResponse): response is DozerResponseFail {
-  return "msg" in response;
-}
-
-export async function fetchRecordsDozerSql({
+export async function fetchRecordsSql({
   dozerUrl,
   queries,
   storeAddress,
-}: FetchDozerSqlArgs): Promise<FetchDozerSqlResult> {
+}: FetchRecordsSqlArgs): Promise<FetchRecordsSqlResult> {
   const response: DozerResponse = await (
     await fetch(dozerUrl, {
       method: "POST",
@@ -57,7 +57,7 @@ export async function fetchRecordsDozerSql({
     return;
   }
 
-  const result: FetchDozerSqlResult = {
+  const result: FetchRecordsSqlResult = {
     blockHeight: BigInt(response.block_height),
     result: response.result.map((records, index) => ({
       table: queries[index].table,

packages/store-sync/src/dozer/fetchInitialBlockLogsDozer.ts → packages/store-sync/src/dozer/getSnapshot.ts

@@ -1,30 +1,30 @@
-import { DozerLogFilter, DozerSyncFilter, DozerTableQuery } from "./common";
+import { LogFilter, SyncFilter, TableQuery } from "./common";
 import { Hex } from "viem";
-import { StorageAdapterBlock, SyncFilter } from "../common";
-import { fetchRecordsDozerSql } from "./fetchRecordsDozerSql";
+import { StorageAdapterBlock, SyncFilter as LegacyLogFilter } from "../common";
+import { fetchRecordsSql } from "./fetchRecordsSql";
 import { recordToLog } from "../recordToLog";
-import { getSnapshot } from "../getSnapshot";
+import { getSnapshot as getSnapshotLogs } from "../getSnapshot";
 import { bigIntMin, isDefined } from "@latticexyz/common/utils";
 
-export type FetchInitialBlockLogsDozerArgs = {
+export type GetSnapshotArgs = {
   dozerUrl: string;
   storeAddress: Hex;
-  filters?: DozerSyncFilter[];
+  filters?: SyncFilter[];
   startBlock?: bigint;
   chainId: number;
 };
 
-export type FetchInitialBlockLogsDozerResult = {
+export type GetSnapshotResult = {
   initialBlockLogs: StorageAdapterBlock;
 };
 
-export async function fetchInitialBlockLogsDozer({
+export async function getSnapshot({
   dozerUrl,
   storeAddress,
   filters,
   startBlock = 0n,
   chainId,
-}: FetchInitialBlockLogsDozerArgs): Promise<FetchInitialBlockLogsDozerResult> {
+}: GetSnapshotArgs): Promise<GetSnapshotResult> {
   const initialBlockLogs: StorageAdapterBlock = { blockNumber: startBlock, logs: [] };
 
   // We execute the list of provided SQL queries for hydration. For performance
@@ -36,13 +36,13 @@ export async function fetchInitialBlockLogsDozer({
   // partial updates), so we only notify consumers of state updates after the
   // initial hydration is complete.
 
-  const sqlFilters = filters ? (filters.filter((filter) => "sql" in filter) as DozerTableQuery[]) : [];
+  const sqlFilters = filters ? (filters.filter((filter) => "sql" in filter) as TableQuery[]) : [];
 
   // Execute individual SQL queries as separate requests to parallelize on the backend.
   // Each individual request is expected to be executed against the same db state so it
   // can't be parallelized.
   const dozerTables = (
-    await Promise.all(sqlFilters.map((filter) => fetchRecordsDozerSql({ dozerUrl, storeAddress, queries: [filter] })))
+    await Promise.all(sqlFilters.map((filter) => fetchRecordsSql({ dozerUrl, storeAddress, queries: [filter] })))
   ).filter(isDefined);
 
   if (dozerTables.length > 0) {
@@ -54,30 +54,30 @@ export async function fetchInitialBlockLogsDozer({
   }
 
   // Fetch the tables without SQL filter from the snapshot logs API for better performance.
-  const snapshotFilters =
+  const logsFilters =
     filters &&
     filters
       .filter((filter) => !("sql" in filter))
       .map((filter) => {
-        const { table, key0, key1 } = filter as DozerLogFilter;
-        return { tableId: table.tableId, key0, key1 } as SyncFilter;
+        const { table, key0, key1 } = filter as LogFilter;
+        return { tableId: table.tableId, key0, key1 } as LegacyLogFilter;
       });
 
-  const snapshot =
+  const logs =
     // If no filters are provided, the entire state is fetched
-    !snapshotFilters || snapshotFilters.length > 0
-      ? await getSnapshot({
+    !logsFilters || logsFilters.length > 0
+      ? await getSnapshotLogs({
           chainId,
           address: storeAddress,
-          filters: snapshotFilters,
+          filters: logsFilters,
           indexerUrl: dozerUrl,
         })
       : undefined;
 
-  // The block number passed in the overall result will be the min of all queries and the snapshot.
-  if (snapshot) {
-    initialBlockLogs.blockNumber = bigIntMin(initialBlockLogs.blockNumber, snapshot.blockNumber);
-    initialBlockLogs.logs = [...initialBlockLogs.logs, ...snapshot.logs];
+  // The block number passed in the overall result will be the min of all queries and the logs.
+  if (logs) {
+    initialBlockLogs.blockNumber = bigIntMin(initialBlockLogs.blockNumber, logs.blockNumber);
+    initialBlockLogs.logs = [...initialBlockLogs.logs, ...logs.logs];
   }
 
   return { initialBlockLogs };

packages/store-sync/src/dozer/index.ts

@@ -1,4 +1,4 @@
 export * from "./common";
-export * from "./fetchRecordsDozerSql";
+export * from "./fetchRecordsSql";
 export * from "./selectFrom";
-export * from "./fetchInitialBlockLogsDozer";
+export * from "./getSnapshot";

packages/store-sync/src/dozer/selectFrom.ts

@@ -1,12 +1,12 @@
 import { Table } from "@latticexyz/config";
-import { DozerTableQuery } from "./common";
+import { TableQuery } from "./common";
 
 // For autocompletion but still allowing all SQL strings
 export type Where<table extends Table> = `"${keyof table["schema"] & string}"` | (string & {});
 
 export type SelectFromArgs<table extends Table> = { table: table; where?: Where<table>; limit?: number };
 
-export function selectFrom<table extends Table>({ table, where, limit }: SelectFromArgs<table>): DozerTableQuery {
+export function selectFrom<table extends Table>({ table, where, limit }: SelectFromArgs<table>): TableQuery {
   const dozerTableLabel = table.namespace === "" ? table.name : `${table.namespace}__${table.name}`;
   return {
     table: table,