@lowdefy/server-dev 6.1.0 → 7.1.0

package/lib/docs/dataSets/describeDataSetResult.js

@@ -0,0 +1,25 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { countDataSetDocuments } from '@lowdefy/node-utils';
+
+// The `data` a journey result carries: which data set it ran on, how many documents it loaded and
+// how long the load took, which lowdefy test prints.
+function describeDataSetResult({ dataSet, loadMs }) {
+  return { name: dataSet.name, loadMs, documents: countDataSetDocuments({ dataSet }) };
+}
+
+export default describeDataSetResult;

package/lib/docs/dataSets/describeDatabaseTarget.js

@@ -0,0 +1,46 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { type } from '@lowdefy/helpers';
+
+function withoutMarkers(value) {
+  if (!type.isObject(value)) return value;
+  return Object.fromEntries(Object.entries(value).filter(([key]) => !key.startsWith('~')));
+}
+
+// Which database a connection reads, as far as the built artifact can tell before any request:
+// a literal databaseName (or none) and the databaseUri's _secret name (or literal). Returns null
+// when either is computed per request, since such a connection cannot be compared.
+function describeDatabaseTarget({ properties }) {
+  const databaseName = properties?.databaseName;
+  if (!type.isUndefined(databaseName) && !type.isString(databaseName)) return null;
+  const databaseUri = withoutMarkers(properties?.databaseUri);
+  let uri;
+  if (type.isString(databaseUri)) {
+    uri = `literal:${databaseUri}`;
+  } else if (
+    type.isObject(databaseUri) &&
+    Object.keys(databaseUri).length === 1 &&
+    type.isString(databaseUri._secret)
+  ) {
+    uri = `secret:${databaseUri._secret}`;
+  } else {
+    return null;
+  }
+  return { databaseName: databaseName ?? null, uri };
+}
+
+export default describeDatabaseTarget;

package/lib/docs/dataSets/describeTargetKey.js

@@ -0,0 +1,29 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { type } from '@lowdefy/helpers';
+
+import describeDatabaseTarget from './describeDatabaseTarget.js';
+
+// The key a data session gives each database target its own database by, or null when the target
+// is computed per request.
+function describeTargetKey({ properties }) {
+  const target = describeDatabaseTarget({ properties });
+  if (type.isNone(target)) return null;
+  return JSON.stringify([target.uri, target.databaseName]);
+}
+
+export default describeTargetKey;

package/lib/docs/dataSets/deserializeFixture.js

@@ -0,0 +1,34 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { ObjectId } from 'mongodb';
+import { serializer, type } from '@lowdefy/helpers';
+
+function reviver(_, value) {
+  if (type.isObject(value) && type.isString(value._oid)) {
+    return ObjectId.createFromHexString(value._oid);
+  }
+  return value;
+}
+
+// A fixture document as the database stores it: `~d` markers become Dates (the serializer) and
+// { _oid: '<hex>' } becomes an ObjectId, the convention connection-mongodb's serialize.js uses for
+// request payloads.
+function deserializeFixture(document) {
+  return serializer.copy(document, { reviver });
+}
+
+export default deserializeFixture;

package/lib/docs/dataSets/drainSessionWork.js

@@ -0,0 +1,37 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+// Waits until every promise in `work` has settled, including any added while it waits (a background
+// task can schedule another), or until `timeoutMs` passes. Returns true when the work drained.
+async function drainSessionWork({ work, timeoutMs }) {
+  let timer;
+  const timedOut = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(false), timeoutMs);
+  });
+  async function settleAll() {
+    while (work.size > 0) {
+      await Promise.allSettled([...work]);
+    }
+    return true;
+  }
+  try {
+    return await Promise.race([settleAll(), timedOut]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export default drainSessionWork;

package/lib/docs/dataSets/drainSessionWork.test.mjs

@@ -0,0 +1,64 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { jest } from '@jest/globals';
+
+import drainSessionWork from './drainSessionWork.js';
+
+afterEach(() => {
+  jest.useRealTimers();
+});
+
+test('drainSessionWork resolves true once every promise, including one added while waiting, settles', async () => {
+  const work = new Set();
+  let releaseFirst;
+  let releaseSecond;
+  const second = new Promise((resolve) => {
+    releaseSecond = resolve;
+  });
+  const first = new Promise((resolve) => {
+    releaseFirst = resolve;
+  }).then(() => {
+    work.delete(first);
+    work.add(second);
+  });
+  second.then(() => work.delete(second));
+  work.add(first);
+  const draining = drainSessionWork({ work, timeoutMs: 30000 });
+  releaseFirst();
+  await Promise.resolve();
+  releaseSecond();
+  await expect(draining).resolves.toBe(true);
+});
+
+test('drainSessionWork resolves true at once with no work', async () => {
+  await expect(drainSessionWork({ work: new Set(), timeoutMs: 30000 })).resolves.toBe(true);
+});
+
+test('drainSessionWork resolves false after the timeout when work never settles', async () => {
+  jest.useFakeTimers({ doNotFake: ['performance'] });
+  const work = new Set([new Promise(() => {})]);
+  const draining = drainSessionWork({ work, timeoutMs: 30000 });
+  let done = false;
+  draining.then(() => {
+    done = true;
+  });
+  jest.advanceTimersByTime(29999);
+  await Promise.resolve();
+  expect(done).toBe(false);
+  jest.advanceTimersByTime(1);
+  await expect(draining).resolves.toBe(false);
+});

package/lib/docs/dataSets/duplicateIndexName.js

@@ -0,0 +1,24 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+// The index a duplicate key error names, from the server's message ("... index: number_1 dup
+// key: ..."), or "unknown".
+function duplicateIndexName(message) {
+  const match = /index: (\S+)/.exec(message ?? '');
+  return match === null ? 'unknown' : match[1];
+}
+
+export default duplicateIndexName;

package/lib/docs/dataSets/getDataStore.js

@@ -0,0 +1,106 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import { MongoClient } from 'mongodb';
+import { MongoMemoryReplSet } from 'mongodb-memory-server-core';
+import { DryMongoBinary } from 'mongodb-memory-server-core/lib/util/DryMongoBinary.js';
+
+import pickDataStorePort from './pickDataStorePort.js';
+import registerDataStoreShutdown from './registerDataStoreShutdown.js';
+import removeDataStoreFiles from './removeDataStoreFiles.js';
+
+// One store per dev server process. Kept on globalThis because the journey route that opens a data
+// session and the API context that reads it may load as separate module instances (Vite's SSR
+// module graph and Node's), like the journey actor token.
+const STORE_KEY = Symbol.for('lowdefy.devServer.dataStore');
+
+// The store is a local mongod: a client that cannot reach it within this long is looking at a dead
+// store, and the journey should say so rather than wait the driver's default 30 s.
+const SERVER_SELECTION_TIMEOUT_MS = 5000;
+
+async function announceDownload() {
+  const options = await DryMongoBinary.generateOptions();
+  const binary = await DryMongoBinary.locateBinary(options);
+  if (binary === undefined) {
+    // eslint-disable-next-line no-console
+    console.info(`Downloading MongoDB ${options.version} for journey data sets (once).`);
+  }
+}
+
+// A replica set, not a standalone server: transactions and change streams need one, and the app's
+// own cluster is one. MONGOMS_VERSION, read by mongodb-memory-server, pins the MongoDB version.
+async function startDataStore() {
+  await announceDownload();
+  const replSet = await MongoMemoryReplSet.create({
+    instanceOpts: [{ port: await pickDataStorePort() }],
+    replSet: { count: 1, storageEngine: 'wiredTiger' },
+  });
+  const uri = replSet.getUri();
+  const client = new MongoClient(uri, { serverSelectionTimeoutMS: SERVER_SELECTION_TIMEOUT_MS });
+  try {
+    await client.connect();
+  } catch (error) {
+    await replSet.stop({ doCleanup: true });
+    throw error;
+  }
+  // Past the awaits above, getDataStore has cached the promise this call returned.
+  const storePromise = globalThis[STORE_KEY];
+  let unregisterShutdown;
+  let stopping;
+  // Stops mongod and removes its temporary database directory. A later getDataStore() starts a new
+  // store; the cache is cleared only while it still holds this one.
+  function stop() {
+    stopping =
+      stopping ??
+      (async () => {
+        if (globalThis[STORE_KEY] === storePromise) {
+          delete globalThis[STORE_KEY];
+        }
+        await client.close().catch(() => {});
+        // stop() skips or fails its cleanup when mongod has already died, which is when this store
+        // most needs it: its directory may still hold a session's rows.
+        try {
+          await replSet.stop({ doCleanup: true });
+        } finally {
+          removeDataStoreFiles({ replSet });
+          // Kept until the files are gone: Vite's SIGTERM handler can exit the process mid-stop,
+          // and the exit hook then finishes the removal.
+          unregisterShutdown();
+        }
+      })();
+    return stopping;
+  }
+  unregisterShutdown = registerDataStoreShutdown({ replSet, stop });
+  return { client, uri, stop };
+}
+
+// The in-memory MongoDB replica set journey data sessions load into, started on first use. There
+// is no idle stop: an idle store holds no session databases, and a restart would land on a new port
+// while the connection plugin's cached clients keep polling the old one. It stops, with its
+// temporary directory removed, when the dev server process shuts down. A failed start is not
+// cached, so the next call tries again, and a store found dead (openDataSession) is stopped, so the
+// next call starts a fresh one.
+function getDataStore() {
+  if (globalThis[STORE_KEY] === undefined) {
+    globalThis[STORE_KEY] = startDataStore().catch((error) => {
+      delete globalThis[STORE_KEY];
+      throw error;
+    });
+  }
+  return globalThis[STORE_KEY];
+}
+
+export default getDataStore;

package/lib/docs/dataSets/getDataStore.mongodb.test.mjs

@@ -0,0 +1,63 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import fs from 'node:fs';
+import { jest } from '@jest/globals';
+
+import getDataStore from './getDataStore.js';
+import openDataSession from './openDataSession.js';
+import { MIN_PORT } from './pickDataStorePort.js';
+
+jest.setTimeout(120000);
+
+// The real memory replica set, in a process of its own (jest runs each file in its own worker), so
+// killing its mongod here touches no other suite's store.
+
+async function describeMongod(store) {
+  const admin = store.client.db('admin');
+  const { pid } = await admin.command({ serverStatus: 1 });
+  const { parsed } = await admin.command({ getCmdLineOpts: 1 });
+  return { pid, dbPath: parsed.storage.dbPath };
+}
+
+test('the data store binds a port in the dynamic range and removes its directory when it stops', async () => {
+  const store = await getDataStore();
+  const port = Number(new URL(store.uri).port);
+  expect(port).toBeGreaterThanOrEqual(MIN_PORT);
+  expect(port).toBeLessThanOrEqual(65535);
+  const { dbPath } = await describeMongod(store);
+  expect(fs.existsSync(dbPath)).toBe(true);
+  await store.stop();
+  expect(fs.existsSync(dbPath)).toBe(false);
+});
+
+test('a store whose mongod died is replaced: the next session reports it, the one after runs on a new store', async () => {
+  const dead = await getDataStore();
+  const { pid, dbPath } = await describeMongod(dead);
+  process.kill(pid, 'SIGKILL');
+  await expect(openDataSession({ dataSet: { name: 'shop' } })).rejects.toThrow(
+    'The journey data store stopped responding'
+  );
+  expect(fs.existsSync(dbPath)).toBe(false);
+  const fresh = await getDataStore();
+  expect(fresh).not.toBe(dead);
+  expect(fresh.uri).not.toEqual(dead.uri);
+  const opened = await openDataSession({
+    dataSet: { name: 'shop', fixtures: {}, generated: {}, indexes: {}, collections: {} },
+  });
+  await opened.close();
+  await fresh.stop();
+});

package/lib/docs/dataSets/getDataStore.test.mjs

@@ -0,0 +1,195 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { jest } from '@jest/globals';
+
+const create = jest.fn();
+const connect = jest.fn();
+const listDatabases = jest.fn();
+
+jest.unstable_mockModule('mongodb-memory-server-core', () => ({
+  MongoMemoryReplSet: { create },
+}));
+jest.unstable_mockModule('mongodb-memory-server-core/lib/util/DryMongoBinary.js', () => ({
+  DryMongoBinary: {
+    generateOptions: jest.fn(async () => ({ version: '6.0.14' })),
+    locateBinary: jest.fn(async () => '/cache/mongod'),
+  },
+}));
+const actualMongodb = await import('mongodb');
+jest.unstable_mockModule('mongodb', () => ({
+  BSON: actualMongodb.BSON,
+  ObjectId: actualMongodb.ObjectId,
+  MongoClient: jest.fn(() => ({
+    connect,
+    close: jest.fn(async () => {}),
+    db: () => ({ admin: () => ({ listDatabases }), dropDatabase: async () => {} }),
+  })),
+}));
+
+const { default: getDataStore } = await import('./getDataStore.js');
+const { default: openDataSession } = await import('./openDataSession.js');
+const { MIN_PORT } = await import('./pickDataStorePort.js');
+
+function createReplSet({ uri = 'mongodb://127.0.0.1:50001/?replicaSet=x', instanceInfo } = {}) {
+  return {
+    getUri: () => uri,
+    stop: jest.fn(async () => true),
+    servers: [{ instanceInfo }],
+  };
+}
+
+// The listeners a started store added for a process event, so a test runs the store's own handler
+// without signalling the test process.
+function addedListeners(event, before) {
+  return process.listeners(event).filter((listener) => !before.includes(listener));
+}
+
+function snapshotListeners() {
+  return {
+    SIGTERM: process.listeners('SIGTERM'),
+    SIGINT: process.listeners('SIGINT'),
+    SIGHUP: process.listeners('SIGHUP'),
+    exit: process.listeners('exit'),
+  };
+}
+
+afterEach(async () => {
+  const cached = globalThis[Symbol.for('lowdefy.devServer.dataStore')];
+  if (cached !== undefined) {
+    const store = await cached.catch(() => null);
+    await store?.stop();
+  }
+  delete globalThis[Symbol.for('lowdefy.devServer.dataStore')];
+  jest.restoreAllMocks();
+  create.mockReset();
+  listDatabases.mockReset();
+});
+
+test('getDataStore starts one replica set and returns the same store on every call', async () => {
+  create.mockResolvedValue(createReplSet());
+  const first = await getDataStore();
+  const second = await getDataStore();
+  expect(first).toBe(second);
+  expect(first.uri).toEqual('mongodb://127.0.0.1:50001/?replicaSet=x');
+  expect(create).toHaveBeenCalledTimes(1);
+  expect(create).toHaveBeenCalledWith({
+    instanceOpts: [{ port: expect.any(Number) }],
+    replSet: { count: 1, storageEngine: 'wiredTiger' },
+  });
+});
+
+test('getDataStore binds the store to a port in the dynamic range, above the usual app ports', async () => {
+  create.mockResolvedValue(createReplSet());
+  await getDataStore();
+  const [[{ instanceOpts }]] = create.mock.calls;
+  expect(instanceOpts[0].port).toBeGreaterThanOrEqual(MIN_PORT);
+  expect(instanceOpts[0].port).toBeLessThanOrEqual(65535);
+});
+
+test('getDataStore clears a failed start so the next call retries', async () => {
+  create.mockRejectedValueOnce(new Error('no mongod'));
+  await expect(getDataStore()).rejects.toThrow('no mongod');
+  create.mockResolvedValueOnce(createReplSet({ uri: 'mongodb://127.0.0.1:50002/' }));
+  const store = await getDataStore();
+  expect(store.uri).toEqual('mongodb://127.0.0.1:50002/');
+});
+
+test('a SIGTERM stops the store with cleanup, then raises the signal again', async () => {
+  const replSet = createReplSet();
+  create.mockResolvedValue(replSet);
+  const kill = jest.spyOn(process, 'kill').mockImplementation(() => true);
+  const before = snapshotListeners();
+  await getDataStore();
+  const [onSigterm] = addedListeners('SIGTERM', before.SIGTERM);
+  expect(addedListeners('SIGINT', before.SIGINT)).toHaveLength(1);
+  expect(addedListeners('SIGHUP', before.SIGHUP)).toHaveLength(1);
+  await onSigterm('SIGTERM');
+  expect(replSet.stop).toHaveBeenCalledWith({ doCleanup: true });
+  expect(kill).toHaveBeenCalledWith(process.pid, 'SIGTERM');
+  expect(globalThis[Symbol.for('lowdefy.devServer.dataStore')]).toBeUndefined();
+  expect(addedListeners('SIGTERM', before.SIGTERM)).toEqual([]);
+  expect(addedListeners('SIGINT', before.SIGINT)).toEqual([]);
+  expect(addedListeners('SIGHUP', before.SIGHUP)).toEqual([]);
+  expect(addedListeners('exit', before.exit)).toEqual([]);
+});
+
+test('a SIGHUP from a closed terminal stops the store with cleanup, then raises the signal again', async () => {
+  const replSet = createReplSet();
+  create.mockResolvedValue(replSet);
+  const kill = jest.spyOn(process, 'kill').mockImplementation(() => true);
+  const before = snapshotListeners();
+  await getDataStore();
+  const [onSighup] = addedListeners('SIGHUP', before.SIGHUP);
+  await onSighup('SIGHUP');
+  expect(replSet.stop).toHaveBeenCalledWith({ doCleanup: true });
+  expect(kill).toHaveBeenCalledWith(process.pid, 'SIGHUP');
+  expect(addedListeners('SIGHUP', before.SIGHUP)).toEqual([]);
+});
+
+test('the exit hook kills mongod and removes its temporary directory when no stop finished', async () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mongo-mem-test-'));
+  fs.writeFileSync(path.join(tmpDir, 'WiredTiger'), '');
+  const mongodProcess = { kill: jest.fn() };
+  create.mockResolvedValue(
+    createReplSet({ instanceInfo: { tmpDir, dbPath: tmpDir, instance: { mongodProcess } } })
+  );
+  const before = snapshotListeners();
+  await getDataStore();
+  const [onExit] = addedListeners('exit', before.exit);
+  onExit();
+  expect(mongodProcess.kill).toHaveBeenCalledWith('SIGKILL');
+  expect(fs.existsSync(tmpDir)).toBe(false);
+});
+
+test('a stopped store is replaced by a new one on the next getDataStore', async () => {
+  const first = createReplSet({ uri: 'mongodb://127.0.0.1:50003/' });
+  const second = createReplSet({ uri: 'mongodb://127.0.0.1:50004/' });
+  create.mockResolvedValueOnce(first).mockResolvedValueOnce(second);
+  const store = await getDataStore();
+  await store.stop();
+  await store.stop();
+  expect(first.stop).toHaveBeenCalledTimes(1);
+  expect((await getDataStore()).uri).toEqual('mongodb://127.0.0.1:50004/');
+});
+
+test('a store whose mongod died is stopped by the next data session, and the one after starts a new store', async () => {
+  const dead = createReplSet({ uri: 'mongodb://127.0.0.1:50005/' });
+  const fresh = createReplSet({ uri: 'mongodb://127.0.0.1:50006/' });
+  create.mockResolvedValueOnce(dead).mockResolvedValueOnce(fresh);
+  await getDataStore();
+  const gone = new Error('Server selection timed out after 5000 ms');
+  gone.name = 'MongoServerSelectionError';
+  listDatabases.mockRejectedValueOnce(gone);
+  const error = await openDataSession({ dataSet: { name: 'shop' } }).catch((caught) => caught);
+  expect(error.message).toEqual(
+    'The journey data store stopped responding (Server selection timed out after 5000 ms). The next journey starts a new one.'
+  );
+  expect(error.cause).toBe(gone);
+  expect(dead.stop).toHaveBeenCalledWith({ doCleanup: true });
+  expect((await getDataStore()).uri).toEqual('mongodb://127.0.0.1:50006/');
+});
+
+test('a data set that fails to load for another reason keeps the store', async () => {
+  create.mockResolvedValueOnce(createReplSet());
+  const store = await getDataStore();
+  listDatabases.mockRejectedValueOnce(new Error('not authorized'));
+  await expect(openDataSession({ dataSet: { name: 'shop' } })).rejects.toThrow('not authorized');
+  expect(await getDataStore()).toBe(store);
+});