@hot-updater/server 1.0.0-rc.18 → 1.0.0-rc.21

package/src/database/engineAggregates.ts

@@ -1,189 +0,0 @@
-import {
-  type DatabaseAdapter,
-  type DatabaseKey,
-  type DatabaseKeyValue,
-  DATABASE_VERSION_COLUMN,
-  isKeyValue,
-  mergeDistinct,
-  type StoredRow,
-  type WriteOp,
-} from "@hot-updater/plugin-core/internal";
-
-import { fnv1a } from "./cursor";
-import type { AggregateShape } from "./definitions";
-import { DatabaseTransactionError } from "./errors";
-import type { ResolvedModel } from "./resolveSchema";
-
-/** The pending changes to one shard row of an aggregate. */
-export interface AggregateChange {
-  readonly model: ResolvedModel;
-  /** The identity values in key order, then the shard. */
-  readonly key: DatabaseKey;
-  readonly deltas: Record<string, number>;
-  readonly sketches: Record<string, string>;
-}
-
-const definitionOf = (model: ResolvedModel) =>
-  model.definition as AggregateShape;
-
-/** Every change keyed by one value lands on one shard. */
-export const shardOf = (value: string, shards: number): number =>
-  fnv1a(value) % shards;
-
-/** Merges one `tx.aggregate` call into its shard row's pending changes. */
-export const recordAggregate = (
-  changes: Map<string, AggregateChange>,
-  model: ResolvedModel,
-  identity: Readonly<Record<string, unknown>>,
-  values: Readonly<Record<string, unknown>>,
-  shardBy: string | undefined,
-) => {
-  const {
-    key: fields,
-    counters,
-    gauges,
-    distinct,
-    shards,
-  } = definitionOf(model);
-  const fail = (message: string) =>
-    new DatabaseTransactionError(`${model.table.name}: ${message}`);
-  if (
-    Object.keys(identity).length !== fields.length ||
-    !fields.every((name) => isKeyValue(identity[name]))
-  ) {
-    throw fail(
-      `aggregate takes exactly its identity fields: ${fields.join(", ")}.`,
-    );
-  }
-  if (
-    shardBy === undefined &&
-    shards > 1 &&
-    gauges.some((gauge) => gauge in values)
-  ) {
-    throw fail("gauges of a sharded aggregate need shardBy.");
-  }
-  const shard =
-    shardBy === undefined
-      ? Math.floor(Math.random() * shards)
-      : shardOf(shardBy, shards);
-  const key = [
-    ...fields.map((name) => identity[name] as DatabaseKeyValue),
-    shard,
-  ];
-  const id = JSON.stringify([model.table.name, key]);
-  const change = changes.get(id) ?? { model, key, deltas: {}, sketches: {} };
-  changes.set(id, change);
-  for (const [metric, value] of Object.entries(values)) {
-    if (distinct.includes(metric) && typeof value === "string") {
-      change.sketches[metric] = mergeDistinct([change.sketches[metric], value]);
-    } else if (
-      (counters.includes(metric) || gauges.includes(metric)) &&
-      Number.isSafeInteger(value)
-    ) {
-      change.deltas[metric] = (change.deltas[metric] ?? 0) + Number(value);
-    } else {
-      throw fail(
-        `${metric} is not a counter, gauge, or sketch of this aggregate.`,
-      );
-    }
-  }
-};
-
-/** A shard row before its first change: every metric zero or empty. */
-const blank = (model: ResolvedModel, key: DatabaseKey): StoredRow => {
-  const { counters, gauges, distinct } = definitionOf(model);
-  return Object.fromEntries([
-    ...model.table.key.map((column, position) => [column, key[position]!]),
-    ...[...counters, ...gauges].map((name) => [name, 0]),
-    ...distinct.map((name) => [name, null]),
-    [DATABASE_VERSION_COLUMN, 0],
-  ]);
-};
-
-/**
- * A gauge computed below zero. Deltas from a row another writer has since
- * moved do this, so the transaction reruns; it is thrown only when it lasts.
- */
-export class NegativeGaugeError extends DatabaseTransactionError {}
-
-/** The guarded write that merges `change` into `current`: insert, patch, or delete at zero. */
-const rewrite = (
-  { model, key, deltas, sketches }: AggregateChange,
-  current: StoredRow | null,
-): WriteOp | undefined => {
-  const { table } = model;
-  const { counters, gauges, distinct } = definitionOf(model);
-  const base = current ?? blank(model, key);
-  const set: Record<string, number | string> = {};
-  for (const [metric, delta] of Object.entries(deltas)) {
-    set[metric] = Number(base[metric] ?? 0) + delta;
-  }
-  for (const [metric, sketch] of Object.entries(sketches)) {
-    set[metric] = mergeDistinct([base[metric] as string | null, sketch]);
-  }
-  // A merge that changes nothing (a sketch already counting its value) is not written.
-  if (
-    current &&
-    Object.entries(set).every(([metric, value]) => current[metric] === value)
-  ) {
-    return undefined;
-  }
-  const row = { ...base, ...set };
-  if (gauges.some((gauge) => Number(row[gauge]) < 0)) {
-    // Retention deleted the row whose gauges this change takes back.
-    if (current === null && table.retention) return undefined;
-    throw new NegativeGaugeError(`${table.name}: a gauge went below 0.`);
-  }
-  const zero =
-    distinct.length === 0 &&
-    [...counters, ...gauges].every((metric) => Number(row[metric]) === 0);
-  if (current === null)
-    return zero ? undefined : { type: "insert", table, row };
-  const guard = { v: Number(current[DATABASE_VERSION_COLUMN]) };
-  return zero
-    ? { type: "delete", table, key, guard, previous: current }
-    : { type: "patch", table, key, set, guard, previous: current };
-};
-
-/**
- * Counter-only rows become blind increments that create the row when it is
- * missing. Rows with gauges or sketches are read in one parallel batch per
- * table, merged, and written back under a guard, so a conflict resends only
- * them.
- */
-export const compileAggregates = async (
-  adapter: DatabaseAdapter,
-  changes: Iterable<AggregateChange>,
-): Promise<WriteOp[]> => {
-  const ops: WriteOp[] = [];
-  const merged = new Map<ResolvedModel, AggregateChange[]>();
-  for (const change of changes) {
-    const { model, key, deltas, sketches } = change;
-    if (
-      Object.keys(sketches).length > 0 ||
-      definitionOf(model).gauges.some((gauge) => (deltas[gauge] ?? 0) !== 0)
-    ) {
-      merged.set(model, [...(merged.get(model) ?? []), change]);
-    } else if (Object.values(deltas).some((delta) => delta !== 0)) {
-      const { table } = model;
-      const init = blank(model, key);
-      ops.push({ type: "increment", table, key, by: deltas, init });
-    }
-  }
-  const groups = [...merged.values()];
-  const current = await Promise.all(
-    groups.map((group) =>
-      adapter.get(
-        group[0]!.model.table,
-        group.map(({ key }) => key),
-      ),
-    ),
-  );
-  groups.forEach((group, index) =>
-    group.forEach((change, position) => {
-      const op = rewrite(change, current[index]![position] ?? null);
-      if (op !== undefined) ops.push(op);
-    }),
-  );
-  return ops;
-};

package/src/database/engineReads.spec.ts

@@ -1,219 +0,0 @@
-import {
-  createMemoryAdapter,
-  type StoredRow,
-} from "@hot-updater/plugin-core/internal";
-import { beforeEach, describe, expect, it } from "vitest";
-
-import { DatabaseCursorError } from "./cursor";
-import { createDatabaseEngine } from "./database";
-import { DatabaseQueryError } from "./engineReads";
-import { resolveSchema } from "./resolveSchema";
-import { defineAggregate, defineTable } from "./schema";
-
-const bundles = defineTable(
-  {
-    id: { type: "string", maxLength: 36 },
-    platform: { type: "string", maxLength: 16 },
-    hash: { type: "string", unique: true },
-  },
-  {
-    key: ["id"],
-    indexes: {
-      all: { eq: [], sort: ["id"] },
-      byPlatform: { eq: ["platform"], sort: ["id"] },
-    },
-  },
-);
-
-const totals = defineAggregate(
-  { scope: { type: "string", maxLength: 32 }, bucket: { type: "integer" } },
-  {
-    key: ["scope", "bucket"],
-    counters: ["hits"],
-    shards: 3,
-    indexes: { byScope: { eq: ["scope"], sort: ["bucket"] } },
-  },
-);
-
-const core = { id: "core", schema: { bundles, totals } } as const;
-const schema = resolveSchema([core]);
-
-const bundle = (id: string, platform = "ios"): StoredRow => ({
-  id,
-  platform,
-  hash: `hash-${id}`,
-  _v: 0,
-});
-
-const shard = (
-  bucket: number,
-  shardNumber: number,
-  hits: number,
-): StoredRow => ({
-  scope: "s",
-  bucket,
-  _shard: shardNumber,
-  hits,
-  _v: 1,
-});
-
-describe("engine reads", () => {
-  let engine: ReturnType<typeof createDatabaseEngine>;
-  let db: ReturnType<typeof engine.database<typeof core.schema>>;
-
-  beforeEach(async () => {
-    const adapter = createMemoryAdapter();
-    await adapter.migrations?.apply(schema.tables);
-    await adapter.write([
-      ...["b1", "b2", "b3", "b4", "b5"].map((id) => ({
-        type: "insert" as const,
-        table: schema.models.get("bundles")!.table,
-        row: bundle(id, id === "b3" ? "android" : "ios"),
-      })),
-      ...[
-        shard(1, 0, 1),
-        shard(1, 2, 2),
-        shard(2, 0, 3),
-        shard(2, 1, 4),
-        shard(2, 2, 5),
-        shard(3, 1, 6),
-      ].map((row) => ({
-        type: "insert" as const,
-        table: schema.models.get("totals")!.table,
-        row,
-      })),
-    ]);
-    engine = createDatabaseEngine({
-      adapter,
-      schema,
-      verify: true,
-      maxPageSize: 100,
-    });
-    db = engine.database(core);
-  });
-
-  it("reads one row by key or by a unique field, never by another field", async () => {
-    await expect(db.findOne("bundles", { id: "b2" })).resolves.toMatchObject({
-      id: "b2",
-    });
-    await expect(
-      db.findOne("bundles", { hash: "hash-b4" }),
-    ).resolves.toMatchObject({
-      id: "b4",
-    });
-    await expect(db.findOne("bundles", { id: "missing" })).resolves.toBeNull();
-    await expect(
-      // @ts-expect-error platform is neither the key nor unique.
-      db.findOne("bundles", { platform: "ios" }),
-    ).rejects.toThrow(DatabaseQueryError);
-  });
-
-  it("pages an index with bound cursors and returns next only after a full page", async () => {
-    const first = await db.findMany("bundles", {
-      index: "byPlatform",
-      where: { platform: "ios" },
-      limit: 2,
-    });
-    expect(first.rows.map((row) => row.id)).toEqual(["b1", "b2"]);
-    const second = await db.findMany("bundles", {
-      index: "byPlatform",
-      where: { platform: "ios" },
-      limit: 2,
-      cursor: first.next,
-    });
-    expect(second.rows.map((row) => row.id)).toEqual(["b4", "b5"]);
-    const last = await db.findMany("bundles", {
-      index: "byPlatform",
-      where: { platform: "ios" },
-      limit: 2,
-      cursor: second.next,
-    });
-    expect(last).toEqual({ rows: [] });
-
-    const partial = await db.findMany("bundles", {
-      index: "all",
-      where: {},
-      range: { gt: "b1", lte: "b3" },
-      order: "desc",
-      limit: 5,
-    });
-    expect(partial.rows.map((row) => row.id)).toEqual(["b3", "b2"]);
-    expect(partial.next).toBeUndefined();
-  });
-
-  it("rejects a cursor from another read, a missing eq field, and oversized pages", async () => {
-    const page = await db.findMany("bundles", {
-      index: "byPlatform",
-      where: { platform: "ios" },
-      limit: 1,
-    });
-    await expect(
-      db.findMany("bundles", {
-        index: "byPlatform",
-        where: { platform: "android" },
-        limit: 1,
-        cursor: page.next,
-      }),
-    ).rejects.toThrow(DatabaseCursorError);
-    await expect(
-      // @ts-expect-error byPlatform needs its platform eq field.
-      db.findMany("bundles", { index: "byPlatform", where: {}, limit: 1 }),
-    ).rejects.toThrow("need where on exactly: platform");
-    await expect(
-      db.findMany("bundles", { index: "all", where: {}, limit: 101 }),
-    ).rejects.toThrow("limit must be 1–100");
-  });
-
-  it("merges shards and completes a logical row cut off by the limit", async () => {
-    const measured = await engine.measureReads(() =>
-      db.findAggregates("totals", {
-        index: "byScope",
-        where: { scope: "s" },
-        limit: 4,
-      }),
-    );
-    expect(measured.result.rows).toEqual([
-      { scope: "s", bucket: 1, hits: 3 },
-      { scope: "s", bucket: 2, hits: 12 },
-    ]);
-    expect(measured.adapter).toEqual({ gets: 1, keys: 1, queries: 1, rows: 4 });
-    expect(measured.engine).toEqual({ calls: 1, rows: 2 });
-
-    const rest = await db.findAggregates("totals", {
-      index: "byScope",
-      where: { scope: "s" },
-      limit: 4,
-      cursor: measured.result.next,
-    });
-    expect(rest).toEqual({ rows: [{ scope: "s", bucket: 3, hits: 6 }] });
-  });
-
-  it("returns exactly the rows it reads", async () => {
-    const one = await engine.measureReads(() =>
-      db.findOne("bundles", { id: "b1" }),
-    );
-    expect(one.adapter).toEqual({ gets: 1, keys: 1, queries: 0, rows: 0 });
-    expect(one.engine).toEqual({ calls: 1, rows: 1 });
-
-    const many = await engine.measureReads(() =>
-      db.findMany("bundles", { index: "all", where: {}, limit: 3 }),
-    );
-    expect(many.adapter.rows).toBe(many.engine.rows);
-    expect(many.engine.rows).toBe(3);
-  });
-
-  it("reads tables with findMany and aggregates with findAggregates only", async () => {
-    await expect(
-      // @ts-expect-error totals is an aggregate.
-      db.findMany("totals", {
-        index: "byScope",
-        where: { scope: "s" },
-        limit: 1,
-      }),
-    ).rejects.toThrow("read it with findAggregates");
-    await expect(
-      // @ts-expect-error bundles is a table.
-      db.findAggregates("bundles", { index: "all", where: {}, limit: 1 }),
-    ).rejects.toThrow("read it with findMany");
-  });
-});

package/src/database/engineReads.ts

@@ -1,304 +0,0 @@
-import {
-  type DatabaseAdapter,
-  type DatabaseKey,
-  type DatabaseKeyValue,
-  DATABASE_MAX_QUERY_LIMIT,
-  indexOrderColumns,
-  indexOrderTuple,
-  isKeyValue,
-  mergeDistinct,
-  type QueryBound,
-  type StoredRow,
-} from "@hot-updater/plugin-core/internal";
-
-import { cursorScope, decodeCursor, encodeCursor } from "./cursor";
-import {
-  type ResolvedModel,
-  type ResolvedSchema,
-  SHARD_COLUMN,
-} from "./resolveSchema";
-
-export class DatabaseQueryError extends Error {
-  readonly name = "DatabaseQueryError";
-}
-
-/** A value of the index's first order field, or a prefix of its order tuple. */
-export type RangeValue = DatabaseKeyValue | readonly DatabaseKeyValue[];
-
-export interface ReadRange {
-  readonly gt?: RangeValue;
-  readonly gte?: RangeValue;
-  readonly lt?: RangeValue;
-  readonly lte?: RangeValue;
-}
-
-export interface ReadInput {
-  readonly index: string;
-  /** Values for every eq field of the index. */
-  readonly where?: Readonly<Record<string, DatabaseKeyValue>>;
-  /** Bounds on the index's first order field, or on a prefix of its order tuple. */
-  readonly range?: ReadRange;
-  readonly order?: "asc" | "desc";
-  readonly limit: number;
-  readonly cursor?: string;
-}
-
-export interface Page<TRow> {
-  readonly rows: readonly TRow[];
-  /** Present only after a full page. */
-  readonly next?: string;
-}
-
-export interface EngineReadCount {
-  readonly calls: number;
-  readonly rows: number;
-}
-
-type Lookup = Readonly<Record<string, DatabaseKeyValue>>;
-
-const sameFields = (left: readonly string[], right: readonly string[]) =>
-  left.length === right.length && left.every((field) => right.includes(field));
-
-const keyValue = (value: unknown, field: string): DatabaseKeyValue => {
-  if (isKeyValue(value)) return value;
-  throw new DatabaseQueryError(`${field} needs a string, number, or boolean.`);
-};
-
-const bound = (
-  exclusive: RangeValue | undefined,
-  inclusive: RangeValue | undefined,
-  columns: readonly string[],
-): QueryBound | undefined => {
-  if (exclusive !== undefined && inclusive !== undefined) {
-    throw new DatabaseQueryError(
-      `range on ${columns[0]} sets both bounds of one side.`,
-    );
-  }
-  const value = exclusive ?? inclusive;
-  if (value === undefined) return undefined;
-  const values = Array.isArray(value) ? value : [value];
-  if (values.length === 0 || values.length > columns.length) {
-    throw new DatabaseQueryError(
-      `range on ${columns[0]} takes 1–${columns.length} values of ${columns.join(", ")}.`,
-    );
-  }
-  return {
-    values: values.map((item, position) => keyValue(item, columns[position]!)),
-    inclusive: inclusive !== undefined,
-  };
-};
-
-export const createEngineReads = ({
-  adapter,
-  schema,
-  maxPageSize: requested = DATABASE_MAX_QUERY_LIMIT,
-}: {
-  readonly adapter: DatabaseAdapter;
-  readonly schema: ResolvedSchema;
-  /** The largest `limit` a read accepts (default and maximum 500). */
-  readonly maxPageSize?: number | undefined;
-}) => {
-  const maxPageSize = Math.min(requested, DATABASE_MAX_QUERY_LIMIT);
-  let count: EngineReadCount = { calls: 0, rows: 0 };
-  const returned = <T>(rows: T): T => {
-    const size = Array.isArray(rows) ? rows.length : rows === null ? 0 : 1;
-    count = { calls: count.calls + 1, rows: count.rows + size };
-    return rows;
-  };
-
-  /** A model of `kind` by physical table name, for reads and transactions. */
-  const modelOf = (name: string, kind: "table" | "aggregate" = "table") => {
-    const model = schema.models.get(name);
-    if (model?.definition.kind === kind) return model;
-    throw new DatabaseQueryError(
-      model === undefined
-        ? `Unknown model ${name}.`
-        : kind === "table"
-          ? `${name} is an aggregate; read it with findAggregates and change it with aggregate.`
-          : `${name} is a table; read it with findMany and change it with create, update, or delete.`,
-    );
-  };
-
-  const plan = ({ table }: ResolvedModel, input: ReadInput) => {
-    const index = table.indexes.find(({ name }) => name === input.index);
-    if (index === undefined) {
-      throw new DatabaseQueryError(
-        `${table.name} has no index ${input.index}.`,
-      );
-    }
-    const where = input.where ?? {};
-    if (!sameFields(Object.keys(where), index.eq)) {
-      throw new DatabaseQueryError(
-        `${table.name}.${index.name} reads need where on exactly: ${index.eq.join(", ") || "(none)"}.`,
-      );
-    }
-    const { limit, order = "asc", range } = input;
-    if (!Number.isSafeInteger(limit) || limit < 1 || limit > maxPageSize) {
-      throw new DatabaseQueryError(`limit must be 1–${maxPageSize}.`);
-    }
-    const columns = indexOrderColumns(table, index);
-    const eq = index.eq.map((field) =>
-      keyValue(where[field], `${table.name}.${field}`),
-    );
-    // JSON writes a missing range as null, so every read keeps one scope.
-    const scope = cursorScope([table.name, index.name, eq, order, range]);
-    let lower = bound(range?.gt, range?.gte, columns);
-    let upper = bound(range?.lt, range?.lte, columns);
-    if (input.cursor !== undefined) {
-      const values = decodeCursor(scope, input.cursor);
-      if (order === "asc") lower = { values, inclusive: false };
-      else upper = { values, inclusive: false };
-    }
-    return {
-      request: {
-        index: index.name,
-        eq,
-        order,
-        limit,
-        ...(lower === undefined ? {} : { lower }),
-        ...(upper === undefined ? {} : { upper }),
-      },
-      index,
-      scope,
-    };
-  };
-
-  /** Reads rows by key in one batch; the results follow the keys' order. */
-  const findByKeys = async (
-    name: string,
-    lookups: readonly Lookup[],
-  ): Promise<(StoredRow | null)[]> => {
-    const { table } = modelOf(name, "table");
-    const keys = lookups.map((lookup) => {
-      if (!sameFields(Object.keys(lookup), table.key)) {
-        throw new DatabaseQueryError(
-          `findByKeys on ${name} takes its key: ${table.key.join(", ")}.`,
-        );
-      }
-      return table.key.map((field) =>
-        keyValue(lookup[field], `${name}.${field}`),
-      );
-    });
-    const rows = keys.length === 0 ? [] : await adapter.get(table, keys);
-    returned(rows.filter((row) => row !== null));
-    return rows.map((row) => row ?? null);
-  };
-
-  return {
-    maxPageSize,
-    modelOf,
-    reads: {
-      total: (): EngineReadCount => count,
-      reset: () => {
-        count = { calls: 0, rows: 0 };
-      },
-    },
-    findByKeys,
-
-    /** Reads one row by its key or by the eq fields of a unique index. */
-    async findOne(name: string, lookup: Lookup): Promise<StoredRow | null> {
-      const { table } = modelOf(name, "table");
-      const fields = Object.keys(lookup);
-      if (sameFields(fields, table.key)) {
-        return (await findByKeys(name, [lookup]))[0]!;
-      }
-      const index = table.indexes.find(
-        ({ unique, eq }) => unique && sameFields(fields, eq),
-      );
-      if (index === undefined) {
-        throw new DatabaseQueryError(
-          `findOne on ${name} needs its key or a unique field, not ${fields.join(", ")}.`,
-        );
-      }
-      const [row] = await adapter.query(table, {
-        index: index.name,
-        eq: index.eq.map((field) =>
-          keyValue(lookup[field], `${name}.${field}`),
-        ),
-        order: "asc",
-        limit: 1,
-      });
-      return returned(row ?? null);
-    },
-
-    /** Reads one page of an index range; `next` resumes right after it. */
-    async findMany(name: string, input: ReadInput): Promise<Page<StoredRow>> {
-      const model = modelOf(name, "table");
-      const { request, index, scope } = plan(model, input);
-      const rows = returned(await adapter.query(model.table, request));
-      const last = rows.at(-1);
-      return rows.length === input.limit && last !== undefined
-        ? {
-            rows,
-            next: encodeCursor(
-              scope,
-              indexOrderTuple(model.table, index, last),
-            ),
-          }
-        : { rows };
-    },
-
-    /**
-     * Reads one page of logical aggregate rows, summing counters and gauges
-     * and merging sketches across each row's shards. A row cut off by the
-     * limit is completed by reading only its remaining shards.
-     */
-    async findAggregates(
-      name: string,
-      input: ReadInput,
-    ): Promise<Page<StoredRow>> {
-      const model = modelOf(name, "aggregate");
-      const { table, definition } = model;
-      if (definition.kind !== "aggregate") throw new DatabaseQueryError(name);
-      const { request, index, scope } = plan(model, input);
-      const rows = await adapter.query(table, request);
-      const logicalKey = (row: StoredRow): DatabaseKey =>
-        definition.key.map((column) => keyValue(row[column], column));
-      const groups = new Map<string, StoredRow[]>();
-      for (const row of rows) {
-        const key = JSON.stringify(logicalKey(row));
-        groups.set(key, [...(groups.get(key) ?? []), row]);
-      }
-      const full = rows.length === input.limit;
-      const last = [...groups.values()].at(-1);
-      if (full && last !== undefined) {
-        const seen = new Set(last.map((row) => row[SHARD_COLUMN]));
-        const missing = Array.from(
-          { length: definition.shards },
-          (_, shard) => shard,
-        ).filter((shard) => !seen.has(shard));
-        if (missing.length > 0) {
-          const key = logicalKey(last[0]!);
-          const rest = await adapter.get(
-            table,
-            missing.map((shard) => [...key, shard]),
-          );
-          last.push(...rest.filter((row): row is StoredRow => row !== null));
-        }
-      }
-      const merged = [...groups.values()].map((shards): StoredRow => {
-        const row: Record<string, unknown> = Object.fromEntries(
-          definition.key.map((field) => [field, shards[0]![field]]),
-        );
-        for (const metric of [...definition.counters, ...definition.gauges]) {
-          row[metric] = shards.reduce(
-            (sum, shard) => sum + Number(shard[metric] ?? 0),
-            0,
-          );
-        }
-        for (const metric of definition.distinct) {
-          row[metric] = mergeDistinct(
-            shards.map((shard) => shard[metric] as string | null),
-          );
-        }
-        return row as StoredRow;
-      });
-      returned(merged);
-      if (!full || last === undefined) return { rows: merged };
-      const tuple = indexOrderTuple(table, index, last[0]!);
-      return { rows: merged, next: encodeCursor(scope, tuple.slice(0, -1)) };
-    },
-  };
-};
-
-export type EngineReads = ReturnType<typeof createEngineReads>;