@reventlessdev/reventless-local 3.0.0-alpha.199 → 3.0.0-alpha.201

package/tests/reset/LocalSeedResetTest.res

@@ -0,0 +1,252 @@
+// Classification tests for the scoped local reset.
+//
+// The fixture is not invented: it is the table set, checkpoint names and plugin
+// structures captured from a live hybrid store on 2026-08-05 — including the four
+// components (`qdb_ImportProductAudit` and the three `*Todo` tables) that appear in
+// NO plugin structure, and `qdb_UiFragments`, which the platform's own structure
+// omits. Those omissions are the reason classification is discovery-first rather
+// than structure-driven, so a fixture without them would test the easy case only.
+//
+// This is the pinning test the module's header refers to: if core gains a
+// platform-owned component and the allowlist is not updated with it, "platform
+// claims exactly the platform set" fails.
+
+@@warning("-44")
+
+open JestGlobals
+
+let tempRoot = (): string =>
+  NodeFs.mkdtempSync(NodePath.join([NodeOs.tmpdir(), "reventless-reset-"]))
+
+// Every qdb table a live hybrid store holds.
+let platformTables = ["qdb_Plugins", "qdb_UiFragments"]
+let catalogTables = ["qdb_Categories", "qdb_ProductDemand", "qdb_Products"]
+let orderingTables = ["qdb_AvailableProducts", "qdb_Customers", "qdb_Orders"]
+// Claimed by no structure at all — reachable only through a domain-wide scope.
+let unclaimedTables = [
+  "qdb_AutoShipOrderTodo",
+  "qdb_GeocodeCustomerAddressTodo",
+  "qdb_ImportProductAudit",
+  "qdb_SendOrderConfirmationTodo",
+]
+
+let structureJson = (~queryables, ~writables, ~stores) =>
+  Dict.fromArray([
+    (
+      "readModels",
+      queryables
+      ->Array.map(n => Dict.fromArray([("name", JSON.Encode.string(n))])->JSON.Encode.object)
+      ->JSON.Encode.array,
+    ),
+    ("stateViewSlices", []->JSON.Encode.array),
+    (
+      "aggregates",
+      writables
+      ->Array.map(n => Dict.fromArray([("name", JSON.Encode.string(n))])->JSON.Encode.object)
+      ->JSON.Encode.array,
+    ),
+    ("stateChangeSlices", []->JSON.Encode.array),
+    ("requiredStores", stores->Array.map(JSON.Encode.string)->JSON.Encode.array),
+  ])->JSON.Encode.object
+
+// A store shaped like the live one, with one row in every table so counts are
+// non-zero and a plan that claims a table is visible as such.
+let makeStore = (): (SqliteDriver.t, string) => {
+  let root = tempRoot()
+  let db = SqliteDriver.openDb(~path=NodePath.join([root, "local.db"]))
+
+  let allTables = [platformTables, catalogTables, orderingTables, unclaimedTables]->Array.flat
+  allTables->Array.forEach(t => {
+    db->SqliteDriver.exec(
+      `CREATE TABLE ${t} (partition_key TEXT NOT NULL, sub_key TEXT NOT NULL DEFAULT '', item TEXT NOT NULL, expires_at INTEGER, PRIMARY KEY (partition_key, sub_key))`,
+    )
+    // qdb_Plugins gets the two registry rows below and nothing else, so its count
+    // stays the number of connected plugins.
+    if t != "qdb_Plugins" {
+      db
+      ->SqliteDriver.prepare(`INSERT INTO ${t}(partition_key, item) VALUES(?, ?)`)
+      ->SqliteDriver.run([JSON.Encode.string("row1"), JSON.Encode.string("{}")])
+    }
+  })
+
+  db->SqliteDriver.exec(
+    "CREATE TABLE event_log (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, payload TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id, seq_nr))",
+  )
+  db->SqliteDriver.exec(
+    "CREATE TABLE dcb_event (log_name TEXT NOT NULL, position INTEGER NOT NULL, event_type TEXT NOT NULL, data TEXT NOT NULL, meta TEXT NOT NULL, recorded_at TEXT NOT NULL, PRIMARY KEY (log_name, position))",
+  )
+  db->SqliteDriver.exec(
+    "CREATE TABLE projection_checkpoint (read_model TEXT NOT NULL PRIMARY KEY, position INTEGER NOT NULL)",
+  )
+
+  [("PluginAggrEventLog", "plugin1"), ("CustomerAggrEventLog", "cust1")]->Array.forEach(((
+    log,
+    id,
+  )) =>
+    db
+    ->SqliteDriver.prepare("INSERT INTO event_log VALUES(?, ?, 1, '{}')")
+    ->SqliteDriver.run([JSON.Encode.string(log), JSON.Encode.string(id)])
+  )
+  db
+  ->SqliteDriver.prepare("INSERT INTO dcb_event VALUES(?, 1, 'X', '{}', '{}', '')")
+  ->SqliteDriver.run([JSON.Encode.string("CatalogDcbEventLog")])
+
+  // All four checkpoint shapes the live store holds.
+  [
+    "CategoriesEventColl",
+    "CustomersReadModelEventColl",
+    "UiFragmentsEventColl",
+    "PluginsReadModelEventColl",
+    "dcb:CategoriesEventColl",
+  ]->Array.forEach(rm =>
+    db
+    ->SqliteDriver.prepare("INSERT INTO projection_checkpoint VALUES(?, 1)")
+    ->SqliteDriver.run([JSON.Encode.string(rm)])
+  )
+
+  // The registry rows the reset reads its mapping from.
+  let plugin = (name, structure) =>
+    db
+    ->SqliteDriver.prepare("INSERT INTO qdb_Plugins(partition_key, item) VALUES(?, ?)")
+    ->SqliteDriver.run([
+      JSON.Encode.string(name),
+      JSON.Encode.string(
+        Dict.fromArray([("structure", structure)])->JSON.Encode.object->JSON.stringify,
+      ),
+    ])
+  plugin(
+    "Catalog",
+    structureJson(
+      ~queryables=["Categories", "ProductDemand", "Products"],
+      ~writables=[],
+      ~stores=["Catalog.productImages"],
+    ),
+  )
+  plugin(
+    "Ordering",
+    structureJson(
+      ~queryables=["AvailableProducts", "Customers", "Orders"],
+      ~writables=["Customer"],
+      ~stores=[],
+    ),
+  )
+
+  (db, root)
+}
+
+let labels = (p: LocalSeedReset.plan) => p.items->Array.map(i => i.label)
+
+describe("checkpointComponent", () => {
+  testSync("recovers the component from every checkpoint shape the store holds", () => {
+    expect(LocalSeedReset.checkpointComponent("CategoriesEventColl"))->toEqual("Categories")
+    expect(LocalSeedReset.checkpointComponent("CustomersReadModelEventColl"))->toEqual("Customers")
+    expect(LocalSeedReset.checkpointComponent("UiFragmentsEventColl"))->toEqual("UiFragments")
+    expect(LocalSeedReset.checkpointComponent("PluginsReadModelEventColl"))->toEqual("Plugins")
+    expect(LocalSeedReset.checkpointComponent("dcb:CategoriesEventColl"))->toEqual("Categories")
+  })
+})
+
+describe("scope classification", () => {
+  testSync("domain claims every non-platform table, including what no structure lists", () => {
+    let (db, root) = makeStore()
+    let plan = LocalSeedReset.build(db, ~root, ~scope=Domain)
+    let claimed = labels(plan)
+
+    [catalogTables, orderingTables, unclaimedTables]
+    ->Array.flat
+    ->Array.forEach(t => expect(claimed->Array.includes(t))->toEqual(true))
+    platformTables->Array.forEach(t => expect(claimed->Array.includes(t))->toEqual(false))
+    db->SqliteDriver.close
+  })
+
+  testSync("domain leaves the plugin registry's own log and the offload store alone", () => {
+    let (db, root) = makeStore()
+    let claimed = labels(LocalSeedReset.build(db, ~root, ~scope=Domain))
+    expect(claimed->Array.includes("event_log (PluginAggrEventLog)"))->toEqual(false)
+    expect(claimed->Array.includes("offload/"))->toEqual(false)
+    // A domain aggregate's log is claimed.
+    expect(claimed->Array.includes("event_log (CustomerAggrEventLog)"))->toEqual(true)
+    expect(claimed->Array.includes("dcb_event (CatalogDcbEventLog)"))->toEqual(true)
+    db->SqliteDriver.close
+  })
+
+  testSync("platform claims exactly the platform set — the allowlist pin", () => {
+    let (db, root) = makeStore()
+    let claimed = labels(LocalSeedReset.build(db, ~root, ~scope=Platform))
+    platformTables->Array.forEach(t => expect(claimed->Array.includes(t))->toEqual(true))
+    expect(claimed->Array.includes("event_log (PluginAggrEventLog)"))->toEqual(true)
+    [catalogTables, orderingTables, unclaimedTables]
+    ->Array.flat
+    ->Array.forEach(t => expect(claimed->Array.includes(t))->toEqual(false))
+    db->SqliteDriver.close
+  })
+
+  testSync("checkpoints follow their component across scopes", () => {
+    let (db, root) = makeStore()
+    let domain = labels(LocalSeedReset.build(db, ~root, ~scope=Domain))
+    expect(domain->Array.includes("projection_checkpoint (CategoriesEventColl)"))->toEqual(true)
+    expect(domain->Array.includes("projection_checkpoint (dcb:CategoriesEventColl)"))->toEqual(true)
+    expect(domain->Array.includes("projection_checkpoint (UiFragmentsEventColl)"))->toEqual(false)
+
+    let platform = labels(LocalSeedReset.build(db, ~root, ~scope=Platform))
+    expect(platform->Array.includes("projection_checkpoint (UiFragmentsEventColl)"))->toEqual(true)
+    expect(platform->Array.includes("projection_checkpoint (PluginsReadModelEventColl)"))->toEqual(
+      true,
+    )
+    db->SqliteDriver.close
+  })
+
+  testSync("a plugin scope claims only its own components", () => {
+    let (db, root) = makeStore()
+    let claimed = labels(LocalSeedReset.build(db, ~root, ~scope=OnePlugin("Catalog")))
+    catalogTables->Array.forEach(t => expect(claimed->Array.includes(t))->toEqual(true))
+    orderingTables->Array.forEach(t => expect(claimed->Array.includes(t))->toEqual(false))
+    platformTables->Array.forEach(t => expect(claimed->Array.includes(t))->toEqual(false))
+    db->SqliteDriver.close
+  })
+
+  testSync("a plugin scope reports only what NO plugin claims, not the other plugin's", () => {
+    let (db, root) = makeStore()
+    let plan = LocalSeedReset.build(db, ~root, ~scope=OnePlugin("Catalog"))
+    expect(plan.unattributed->Array.toSorted(String.compare))->toEqual(unclaimedTables)
+    db->SqliteDriver.close
+  })
+})
+
+describe("execution", () => {
+  testSync("emptying the domain scope leaves the platform rows in place", () => {
+    let (db, root) = makeStore()
+    LocalSeedReset.execute(db, LocalSeedReset.build(db, ~root, ~scope=Domain))
+
+    let count = table =>
+      switch db->SqliteDriver.prepare(`SELECT COUNT(*) AS c FROM ${table}`)->SqliteDriver.get([]) {
+      | Some(row) =>
+        switch row->Dict.get("c") {
+        | Some(JSON.Number(n)) => n->Float.toInt
+        | _ => -1
+        }
+      | None => -1
+      }
+
+    expect(count("qdb_Categories"))->toEqual(0)
+    expect(count("qdb_ImportProductAudit"))->toEqual(0)
+    expect(count("qdb_Plugins"))->toEqual(2)
+    expect(count("qdb_UiFragments"))->toEqual(1)
+    // The registry's own event log survives, so the plugins stay registered.
+    expect(count("event_log"))->toEqual(1)
+    db->SqliteDriver.close
+  })
+
+  testSync("the tables themselves survive — contents are deleted, not dropped", () => {
+    let (db, root) = makeStore()
+    LocalSeedReset.execute(db, LocalSeedReset.build(db, ~root, ~scope=Everything))
+    // A dropped table would make this throw rather than return 0.
+    expect(
+      db
+      ->SqliteDriver.prepare("SELECT COUNT(*) AS c FROM qdb_Categories")
+      ->SqliteDriver.get([])
+      ->Option.isSome,
+    )->toEqual(true)
+    db->SqliteDriver.close
+  })
+})

package/tests/reset/LocalSeedResetTest.res.mjs

@@ -0,0 +1,280 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodeos from "node:os";
+import * as Nodepath from "node:path";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as SqliteDriver$ReventlessLocal from "../../src/adapter/SqliteDriver.res.mjs";
+import * as LocalSeedReset$ReventlessLocal from "../../src/reset/LocalSeedReset.res.mjs";
+
+function tempRoot() {
+  return Nodefs.mkdtempSync(Nodepath.join(Nodeos.tmpdir(), "reventless-reset-"));
+}
+
+let platformTables = [
+  "qdb_Plugins",
+  "qdb_UiFragments"
+];
+
+let catalogTables = [
+  "qdb_Categories",
+  "qdb_ProductDemand",
+  "qdb_Products"
+];
+
+let orderingTables = [
+  "qdb_AvailableProducts",
+  "qdb_Customers",
+  "qdb_Orders"
+];
+
+let unclaimedTables = [
+  "qdb_AutoShipOrderTodo",
+  "qdb_GeocodeCustomerAddressTodo",
+  "qdb_ImportProductAudit",
+  "qdb_SendOrderConfirmationTodo"
+];
+
+function structureJson(queryables, writables, stores) {
+  return Object.fromEntries([
+    [
+      "readModels",
+      queryables.map(n => Object.fromEntries([[
+          "name",
+          n
+        ]]))
+    ],
+    [
+      "stateViewSlices",
+      []
+    ],
+    [
+      "aggregates",
+      writables.map(n => Object.fromEntries([[
+          "name",
+          n
+        ]]))
+    ],
+    [
+      "stateChangeSlices",
+      []
+    ],
+    [
+      "requiredStores",
+      stores.map(prim => prim)
+    ]
+  ]);
+}
+
+function makeStore() {
+  let root = tempRoot();
+  let db = SqliteDriver$ReventlessLocal.openDb(Nodepath.join(root, "local.db"));
+  let allTables = [
+    platformTables,
+    catalogTables,
+    orderingTables,
+    unclaimedTables
+  ].flat();
+  allTables.forEach(t => {
+    SqliteDriver$ReventlessLocal.exec(db, `CREATE TABLE ` + t + ` (partition_key TEXT NOT NULL, sub_key TEXT NOT NULL DEFAULT '', item TEXT NOT NULL, expires_at INTEGER, PRIMARY KEY (partition_key, sub_key))`);
+    if (t !== "qdb_Plugins") {
+      return SqliteDriver$ReventlessLocal.run(SqliteDriver$ReventlessLocal.prepare(db, `INSERT INTO ` + t + `(partition_key, item) VALUES(?, ?)`), [
+        "row1",
+        "{}"
+      ]);
+    }
+  });
+  SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE event_log (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, payload TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id, seq_nr))");
+  SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE dcb_event (log_name TEXT NOT NULL, position INTEGER NOT NULL, event_type TEXT NOT NULL, data TEXT NOT NULL, meta TEXT NOT NULL, recorded_at TEXT NOT NULL, PRIMARY KEY (log_name, position))");
+  SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE projection_checkpoint (read_model TEXT NOT NULL PRIMARY KEY, position INTEGER NOT NULL)");
+  [
+    [
+      "PluginAggrEventLog",
+      "plugin1"
+    ],
+    [
+      "CustomerAggrEventLog",
+      "cust1"
+    ]
+  ].forEach(param => SqliteDriver$ReventlessLocal.run(SqliteDriver$ReventlessLocal.prepare(db, "INSERT INTO event_log VALUES(?, ?, 1, '{}')"), [
+    param[0],
+    param[1]
+  ]));
+  SqliteDriver$ReventlessLocal.run(SqliteDriver$ReventlessLocal.prepare(db, "INSERT INTO dcb_event VALUES(?, 1, 'X', '{}', '{}', '')"), ["CatalogDcbEventLog"]);
+  [
+    "CategoriesEventColl",
+    "CustomersReadModelEventColl",
+    "UiFragmentsEventColl",
+    "PluginsReadModelEventColl",
+    "dcb:CategoriesEventColl"
+  ].forEach(rm => SqliteDriver$ReventlessLocal.run(SqliteDriver$ReventlessLocal.prepare(db, "INSERT INTO projection_checkpoint VALUES(?, 1)"), [rm]));
+  let plugin = (name, structure) => SqliteDriver$ReventlessLocal.run(SqliteDriver$ReventlessLocal.prepare(db, "INSERT INTO qdb_Plugins(partition_key, item) VALUES(?, ?)"), [
+    name,
+    JSON.stringify(Object.fromEntries([[
+        "structure",
+        structure
+      ]]))
+  ]);
+  plugin("Catalog", structureJson([
+    "Categories",
+    "ProductDemand",
+    "Products"
+  ], [], ["Catalog.productImages"]));
+  plugin("Ordering", structureJson([
+    "AvailableProducts",
+    "Customers",
+    "Orders"
+  ], ["Customer"], []));
+  return [
+    db,
+    root
+  ];
+}
+
+function labels(p) {
+  return p.items.map(i => i.label);
+}
+
+globalThis.describe("checkpointComponent", () => {
+  globalThis.test("recovers the component from every checkpoint shape the store holds", () => {
+    globalThis.expect(LocalSeedReset$ReventlessLocal.checkpointComponent("CategoriesEventColl")).toEqual("Categories");
+    globalThis.expect(LocalSeedReset$ReventlessLocal.checkpointComponent("CustomersReadModelEventColl")).toEqual("Customers");
+    globalThis.expect(LocalSeedReset$ReventlessLocal.checkpointComponent("UiFragmentsEventColl")).toEqual("UiFragments");
+    globalThis.expect(LocalSeedReset$ReventlessLocal.checkpointComponent("PluginsReadModelEventColl")).toEqual("Plugins");
+    globalThis.expect(LocalSeedReset$ReventlessLocal.checkpointComponent("dcb:CategoriesEventColl")).toEqual("Categories");
+  });
+});
+
+globalThis.describe("scope classification", () => {
+  globalThis.test("domain claims every non-platform table, including what no structure lists", () => {
+    let match = makeStore();
+    let db = match[0];
+    let plan = LocalSeedReset$ReventlessLocal.build(db, match[1], "Domain");
+    let claimed = labels(plan);
+    [
+      catalogTables,
+      orderingTables,
+      unclaimedTables
+    ].flat().forEach(t => {
+      globalThis.expect(claimed.includes(t)).toEqual(true);
+    });
+    platformTables.forEach(t => {
+      globalThis.expect(claimed.includes(t)).toEqual(false);
+    });
+    SqliteDriver$ReventlessLocal.close(db);
+  });
+  globalThis.test("domain leaves the plugin registry's own log and the offload store alone", () => {
+    let match = makeStore();
+    let db = match[0];
+    let claimed = labels(LocalSeedReset$ReventlessLocal.build(db, match[1], "Domain"));
+    globalThis.expect(claimed.includes("event_log (PluginAggrEventLog)")).toEqual(false);
+    globalThis.expect(claimed.includes("offload/")).toEqual(false);
+    globalThis.expect(claimed.includes("event_log (CustomerAggrEventLog)")).toEqual(true);
+    globalThis.expect(claimed.includes("dcb_event (CatalogDcbEventLog)")).toEqual(true);
+    SqliteDriver$ReventlessLocal.close(db);
+  });
+  globalThis.test("platform claims exactly the platform set — the allowlist pin", () => {
+    let match = makeStore();
+    let db = match[0];
+    let claimed = labels(LocalSeedReset$ReventlessLocal.build(db, match[1], "Platform"));
+    platformTables.forEach(t => {
+      globalThis.expect(claimed.includes(t)).toEqual(true);
+    });
+    globalThis.expect(claimed.includes("event_log (PluginAggrEventLog)")).toEqual(true);
+    [
+      catalogTables,
+      orderingTables,
+      unclaimedTables
+    ].flat().forEach(t => {
+      globalThis.expect(claimed.includes(t)).toEqual(false);
+    });
+    SqliteDriver$ReventlessLocal.close(db);
+  });
+  globalThis.test("checkpoints follow their component across scopes", () => {
+    let match = makeStore();
+    let root = match[1];
+    let db = match[0];
+    let domain = labels(LocalSeedReset$ReventlessLocal.build(db, root, "Domain"));
+    globalThis.expect(domain.includes("projection_checkpoint (CategoriesEventColl)")).toEqual(true);
+    globalThis.expect(domain.includes("projection_checkpoint (dcb:CategoriesEventColl)")).toEqual(true);
+    globalThis.expect(domain.includes("projection_checkpoint (UiFragmentsEventColl)")).toEqual(false);
+    let platform = labels(LocalSeedReset$ReventlessLocal.build(db, root, "Platform"));
+    globalThis.expect(platform.includes("projection_checkpoint (UiFragmentsEventColl)")).toEqual(true);
+    globalThis.expect(platform.includes("projection_checkpoint (PluginsReadModelEventColl)")).toEqual(true);
+    SqliteDriver$ReventlessLocal.close(db);
+  });
+  globalThis.test("a plugin scope claims only its own components", () => {
+    let match = makeStore();
+    let db = match[0];
+    let claimed = labels(LocalSeedReset$ReventlessLocal.build(db, match[1], {
+      TAG: "OnePlugin",
+      _0: "Catalog"
+    }));
+    catalogTables.forEach(t => {
+      globalThis.expect(claimed.includes(t)).toEqual(true);
+    });
+    orderingTables.forEach(t => {
+      globalThis.expect(claimed.includes(t)).toEqual(false);
+    });
+    platformTables.forEach(t => {
+      globalThis.expect(claimed.includes(t)).toEqual(false);
+    });
+    SqliteDriver$ReventlessLocal.close(db);
+  });
+  globalThis.test("a plugin scope reports only what NO plugin claims, not the other plugin's", () => {
+    let match = makeStore();
+    let db = match[0];
+    let plan = LocalSeedReset$ReventlessLocal.build(db, match[1], {
+      TAG: "OnePlugin",
+      _0: "Catalog"
+    });
+    globalThis.expect(plan.unattributed.toSorted(Primitive_string.compare)).toEqual(unclaimedTables);
+    SqliteDriver$ReventlessLocal.close(db);
+  });
+});
+
+globalThis.describe("execution", () => {
+  globalThis.test("emptying the domain scope leaves the platform rows in place", () => {
+    let match = makeStore();
+    let db = match[0];
+    LocalSeedReset$ReventlessLocal.execute(db, LocalSeedReset$ReventlessLocal.build(db, match[1], "Domain"));
+    let count = table => {
+      let row = SqliteDriver$ReventlessLocal.get(SqliteDriver$ReventlessLocal.prepare(db, `SELECT COUNT(*) AS c FROM ` + table), []);
+      if (row === undefined) {
+        return -1;
+      }
+      let match = row["c"];
+      if (typeof match === "number") {
+        return match | 0;
+      } else {
+        return -1;
+      }
+    };
+    globalThis.expect(count("qdb_Categories")).toEqual(0);
+    globalThis.expect(count("qdb_ImportProductAudit")).toEqual(0);
+    globalThis.expect(count("qdb_Plugins")).toEqual(2);
+    globalThis.expect(count("qdb_UiFragments")).toEqual(1);
+    globalThis.expect(count("event_log")).toEqual(1);
+    SqliteDriver$ReventlessLocal.close(db);
+  });
+  globalThis.test("the tables themselves survive — contents are deleted, not dropped", () => {
+    let match = makeStore();
+    let db = match[0];
+    LocalSeedReset$ReventlessLocal.execute(db, LocalSeedReset$ReventlessLocal.build(db, match[1], "Everything"));
+    globalThis.expect(Stdlib_Option.isSome(SqliteDriver$ReventlessLocal.get(SqliteDriver$ReventlessLocal.prepare(db, "SELECT COUNT(*) AS c FROM qdb_Categories"), []))).toEqual(true);
+    SqliteDriver$ReventlessLocal.close(db);
+  });
+});
+
+export {
+  tempRoot,
+  platformTables,
+  catalogTables,
+  orderingTables,
+  unclaimedTables,
+  structureJson,
+  makeStore,
+  labels,
+}
+/*  Not a pure module */

package/src/adapter/LocalObjectStore.res

@@ -1,70 +0,0 @@
-// Process-local object store backing the dev platform's served-bucket routes.
-//
-// The AWS path fronts a private S3 bucket through CloudFront (served-buckets
-// plan); in dev there is no bucket, so uploaded and served objects live in this
-// process-local map. Ephemeral by design — contents are lost on restart, which
-// matches the plan's dev-only, non-durable stance. Held here (not in
-// EventLog/QueryDb storage) because it is raw bytes, not event/query state, and
-// has no SQLite arm — hence the `Local` prefix and no `_InMemory` suffix.
-
-// Node Buffer, opaque here — produced by the PUT handler (concat of request
-// chunks) and handed straight back to the response by the GET handler.
-type buffer
-
-@val @scope("Buffer") external concatBuffers: array<buffer> => buffer = "concat"
-
-type entry = {
-  bytes: buffer,
-  contentType: string,
-}
-
-let objects: dict<entry> = Dict.make()
-
-// The prefix the local upload route mints keys under. Mirrors the AWS presign
-// `SERVED_PREFIX` (default "uploads"); the hybrid example uses "uploads".
-let defaultUploadPrefix = "uploads"
-
-// Prefixes the dev server serves at `/{prefix}/*` (PUT stores, GET reads).
-// Seeded with the default upload prefix; a deployment serving another prefix
-// registers it before the servers start.
-let servedPrefixes: ref<array<string>> = ref([defaultUploadPrefix])
-
-let registerServedPrefix = (prefix: string): unit =>
-  if !(servedPrefixes.contents->Array.includes(prefix)) {
-    servedPrefixes.contents = servedPrefixes.contents->Array.concat([prefix])
-  }
-
-// A request path is a served-object path when its first segment is a registered
-// served prefix and at least one key segment follows. Returns the storage key
-// (the path without its leading slash), or None for GraphQL / other paths.
-let servedKey = (path: string): option<string> => {
-  let trimmed = path->String.startsWith("/") ? path->String.slice(~start=1, ~end=path->String.length) : path
-  let prefix = trimmed->String.split("/")->Array.get(0)->Option.getOr("")
-  if (
-    prefix->String.length > 0 &&
-    servedPrefixes.contents->Array.includes(prefix) &&
-    trimmed->String.length > prefix->String.length + 1
-  ) {
-    Some(trimmed)
-  } else {
-    None
-  }
-}
-
-let put = (~key: string, ~bytes: buffer, ~contentType: string): unit =>
-  objects->Dict.set(key, {bytes, contentType})
-
-let get = (~key: string): option<entry> => objects->Dict.get(key)
-
-// Remove a stored object. Idempotent — deleting an absent key is a no-op, matching
-// the release contract (see docs/plans/done/upload-release-path.md, Step 3). The dev
-// store has no identities or clock, so the release resolver enforces only the
-// *shape* of the rule (key under a served prefix), not the identity/age conditions.
-let delete = (~key: string): unit => objects->Dict.delete(key)
-
-// Clear stored objects and restore the default served prefix — used between
-// isolated test suites (called from DomainGraphQL_Server.reset).
-let reset = (): unit => {
-  objects->Dict.keysToArray->Array.forEach(k => objects->Dict.delete(k))
-  servedPrefixes.contents = [defaultUploadPrefix]
-}

package/src/adapter/LocalObjectStore.res.mjs

@@ -1,60 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-
-let objects = {};
-
-let defaultUploadPrefix = "uploads";
-
-let servedPrefixes = {
-  contents: [defaultUploadPrefix]
-};
-
-function registerServedPrefix(prefix) {
-  if (!servedPrefixes.contents.includes(prefix)) {
-    servedPrefixes.contents = servedPrefixes.contents.concat([prefix]);
-    return;
-  }
-}
-
-function servedKey(path) {
-  let trimmed = path.startsWith("/") ? path.slice(1, path.length) : path;
-  let prefix = Stdlib_Option.getOr(trimmed.split("/")[0], "");
-  if (prefix.length > 0 && servedPrefixes.contents.includes(prefix) && trimmed.length > (prefix.length + 1 | 0)) {
-    return trimmed;
-  }
-}
-
-function put(key, bytes, contentType) {
-  objects[key] = {
-    bytes: bytes,
-    contentType: contentType
-  };
-}
-
-function get(key) {
-  return objects[key];
-}
-
-function $$delete(key) {
-  Stdlib_Dict.$$delete(objects, key);
-}
-
-function reset() {
-  Object.keys(objects).forEach(k => Stdlib_Dict.$$delete(objects, k));
-  servedPrefixes.contents = [defaultUploadPrefix];
-}
-
-export {
-  objects,
-  defaultUploadPrefix,
-  servedPrefixes,
-  registerServedPrefix,
-  servedKey,
-  put,
-  get,
-  $$delete,
-  reset,
-}
-/* No side effect */