@lowdefy/server-dev 7.0.0 → 7.1.0

package/lib/docs/dataSets/checkSharedCollectionIds.js

@@ -16,12 +16,21 @@
 
 import { type } from '@lowdefy/helpers';
 
+// Where a connection loads: its collection in its database target. Two connections share a
+// collection only when both match.
+function describePlace({ dataSet, connectionId }) {
+  return JSON.stringify([
+    dataSet.targets?.[connectionId] ?? null,
+    dataSet.collections[connectionId],
+  ]);
+}
+
 // `label` names where a document comes from in a message: "fixture " or "generate.".
-function addIds({ held, connectionId, collection, documents, label }) {
-  held[collection] = held[collection] ?? new Map();
+function addIds({ held, connectionId, place, documents, label }) {
+  held[place] = held[place] ?? new Map();
   documents.forEach((document, index) => {
     if (type.isUndefined(document._id)) return;
-    held[collection].set(JSON.stringify(document._id), {
+    held[place].set(JSON.stringify(document._id), {
       connectionId,
       where: `${label}${connectionId}[${index}]`,
     });
@@ -29,23 +38,25 @@ function addIds({ held, connectionId, collection, documents, label }) {
 }
 
 // parseDataSet refuses a generated _id that is also a fixture's or generated twice, within one
-// connection. Two connections can name one collection, and the store loads them into it together,
-// where a fixture would silently replace a generated document with its _id. This refuses the same
-// collisions across connections, which only the dev build's collection map can see.
+// connection. Two connections can name one collection in one database target, and the store loads
+// them into it together, where a fixture would silently replace a generated document with its _id.
+// This refuses the same collisions across connections, which only the dev build's collection and
+// target maps can see.
 function checkSharedCollectionIds({ dataSetName, dataSet }) {
   const held = {};
   Object.entries(dataSet.fixtures).forEach(([connectionId, documents]) => {
     addIds({
       held,
       connectionId,
-      collection: dataSet.collections[connectionId],
+      place: describePlace({ dataSet, connectionId }),
       documents,
       label: 'fixture ',
     });
   });
   Object.entries(dataSet.generated).forEach(([connectionId, documents]) => {
     const collection = dataSet.collections[connectionId];
-    const ids = held[collection] ?? new Map();
+    const place = describePlace({ dataSet, connectionId });
+    const ids = held[place] ?? new Map();
     documents.forEach((document, index) => {
       const key = JSON.stringify(document._id);
       const holder = ids.get(key);
@@ -57,7 +68,7 @@ function checkSharedCollectionIds({ dataSetName, dataSet }) {
     addIds({
       held,
       connectionId,
-      collection,
+      place,
       documents,
       label: 'generate.',
     });

package/lib/docs/dataSets/dataSetJourneys.chromium.mongodb.test.mjs

@@ -49,8 +49,13 @@ const standInDatabase = 'data_set_journeys';
 const standInUrl = new URL(process.env.MONGO_URL);
 standInUrl.pathname = `/${standInDatabase}`;
 const standInUri = standInUrl.toString();
+// The CRM_MONGODB_URI secret's stand-in: another database with a tickets collection of its own.
+const crmStandInDatabase = 'data_set_journeys_crm';
+const crmStandInUrl = new URL(process.env.MONGO_URL);
+crmStandInUrl.pathname = `/${crmStandInDatabase}`;
 
 process.env.LOWDEFY_SECRET_MONGODB_URI = standInUri;
+process.env.LOWDEFY_SECRET_CRM_MONGODB_URI = crmStandInUrl.toString();
 process.env.LOWDEFY_DIRECTORY_CONFIG = appDirectory;
 process.env.LOWDEFY_LOG_LEVEL = 'error';
 process.env.CRON_SECRET = 'data-set-journeys-cron-secret';
@@ -144,6 +149,7 @@ function pageHtml() {
 <div id="bl-create"><button onclick="callEndpoint('create_ticket', { id: 'new-1', title: 'Made' }, 'created')">Create</button></div>
 <div id="bl-create_later"><button onclick="callEndpoint('create_ticket_later', { id: 'later-1' }, 'dispatched')">Later</button></div>
 <div id="bl-list"><button onclick="callEndpoint('list_tickets', {}, 'listed')">List</button></div>
+<div id="bl-list_crm"><button onclick="callEndpoint('list_crm_tickets', {}, 'listedCrm')">List CRM</button></div>
 <div id="bl-watch"><button onclick="watch()">Watch</button></div>
 <div id="bl-archive"><button onclick="callEndpoint('archive/archive_ticket', { id: 'arch-1' }, 'archived')">Archive</button></div>
 <div id="bl-create_later_auth"><button onclick="callEndpoint('create_ticket_later_auth', {}, 'dispatchedAuth')">Later with auth</button></div>
@@ -301,6 +307,11 @@ beforeAll(async () => {
     .db(standInDatabase)
     .collection('tickets')
     .insertOne({ _id: 'real-1', organization_id: 'org_a', title: 'The developer’s own' });
+  await standIn.db(crmStandInDatabase).dropDatabase();
+  await standIn
+    .db(crmStandInDatabase)
+    .collection('tickets')
+    .insertOne({ _id: 'crm-real-1', organization_id: 'org_a' });
 
   store = await getDataStore();
   // Every write on the data store, in order, so a test can tell which session database a detached
@@ -346,6 +357,7 @@ afterAll(async () => {
   await closeClients();
   await store?.stop();
   await standIn?.db(standInDatabase).dropDatabase();
+  await standIn?.db(crmStandInDatabase).dropDatabase();
   await standIn?.close();
   process.chdir(originalCwd);
   fs.rmSync(serverDirectory, { recursive: true, force: true });
@@ -396,7 +408,7 @@ chromiumTest(
     });
     expect(first.status).toBe(200);
     expect(first.result.passed).toBe(true);
-    expect(first.result.data).toEqual({ name: 'shop', loadMs: expect.any(Number), documents: 3 });
+    expect(first.result.data).toEqual({ name: 'shop', loadMs: expect.any(Number), documents: 5 });
 
     const second = await runJourney({
       data: 'shop',
@@ -466,7 +478,7 @@ chromiumTest(
       (event) => event.operationType === 'insert' && event.id === 'later-1'
     );
     expect(insert).toBeDefined();
-    expect(insert.db).toMatch(/^ld_[0-9a-f]{12}$/);
+    expect(insert.db).toMatch(/^ld_[0-9a-f]{12}_\d+$/);
     const insertIndex = storeEvents.indexOf(insert);
     const dropIndex = storeEvents.findIndex(
       (event) => event.operationType === 'dropDatabase' && event.db === insert.db
@@ -523,7 +535,7 @@ chromiumTest(
       (event) => event.operationType === 'insert' && event.id === 'arch-1'
     );
     expect(insert).toBeDefined();
-    expect(insert.db).toMatch(/^ld_[0-9a-f]{12}$/);
+    expect(insert.db).toMatch(/^ld_[0-9a-f]{12}_\d+$/);
     expect(insert.coll).toEqual('archived');
   }
 );
@@ -568,7 +580,7 @@ chromiumTest(
       (event) => event.operationType === 'insert' && event.id === 'later-auth-before'
     );
     expect(before).toBeDefined();
-    expect(before.db).toMatch(/^ld_[0-9a-f]{12}$/);
+    expect(before.db).toMatch(/^ld_[0-9a-f]{12}_\d+$/);
     expect(storeEvents.some((event) => event.id === 'later-auth-after')).toBe(false);
   }
 );
@@ -636,7 +648,7 @@ chromiumTest(
       (event) => event.operationType === 'insert' && event.id === 'later-logged'
     );
     expect(insert).toBeDefined();
-    expect(insert.db).toMatch(/^ld_[0-9a-f]{12}$/);
+    expect(insert.db).toMatch(/^ld_[0-9a-f]{12}_\d+$/);
     expect(storeEvents.some((event) => event.id === 'log-detached')).toBe(false);
     expect(await standInIds()).toEqual(['real-1']);
   }
@@ -673,7 +685,43 @@ chromiumTest(
 
 // Last, after every journey above: the stand-in, auth collections included, is exactly as the
 // snapshot found it, and no session database ever landed on it.
+chromiumTest(
+  'two connections that name tickets in different databases each read their own fixtures',
+  async () => {
+    storeEvents.length = 0;
+    const { result } = await runJourney({
+      data: 'shop',
+      user: 'owner',
+      steps: [
+        { click: 'list' },
+        { expect: { state: { path: 'listed.ids', equals: ['t-a1', 't-a2'] } } },
+        { click: 'list_crm' },
+        { expect: { state: { path: 'listedCrm.ids', equals: ['crm-a2', 't-a1'] } } },
+        { click: 'create' },
+        { expect: { state: { path: 'created.success', equals: true } } },
+        { click: 'list_crm' },
+        { expect: { state: { path: 'listedCrm.ids', equals: ['crm-a2', 't-a1'] } } },
+      ],
+    });
+    expect(result.passed).toBe(true);
+    // Each target's fixtures loaded into a database of its own, and both dropped with the session.
+    const fixtureDatabases = new Set(
+      storeEvents
+        .filter((event) => event.operationType === 'insert' && event.id === 't-a1')
+        .map((event) => event.db)
+    );
+    expect(fixtureDatabases.size).toBe(2);
+    fixtureDatabases.forEach((name) => {
+      expect(
+        storeEvents.some((event) => event.operationType === 'dropDatabase' && event.db === name)
+      ).toBe(true);
+    });
+  }
+);
+
 chromiumTest('the data set journeys left the stand-in database unchanged', async () => {
   expect(await snapshotStandIn()).toEqual(standInBefore);
+  const crmIds = await standIn.db(crmStandInDatabase).collection('tickets').distinct('_id');
+  expect(crmIds).toEqual(['crm-real-1']);
   expect(await standInSessionDatabases()).toEqual([]);
 });

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/groupDataSetByCollection.js

@@ -14,31 +14,39 @@
   limitations under the License.
 */
 
-function ensureGroup({ groups, collection }) {
-  groups[collection] = groups[collection] ?? { fixtures: [], generated: [], indexes: [] };
-  return groups[collection];
+// One group per database target and collection: `target` is the connection's target key (null when
+// computed per request), the database the session loads the group into.
+function ensureGroup({ groups, dataSet, connectionId }) {
+  const target = dataSet.targets?.[connectionId] ?? null;
+  const collection = dataSet.collections[connectionId];
+  const key = JSON.stringify([target, collection]);
+  if (!groups.has(key)) {
+    groups.set(key, { target, collection, fixtures: [], generated: [], indexes: [] });
+  }
+  return groups.get(key);
 }
 
-// The data set keyed by collection, the unit the store loads: fixtures, generated documents and
-// indexes are keyed by connection id, and two connections that name one collection load into it
-// together.
+// The data set keyed by database target and collection, the unit the store loads: fixtures,
+// generated documents and indexes are keyed by connection id, and two connections that name one
+// collection in one target load into it together. Connections in different targets load into
+// different databases, so they never merge.
 function groupDataSetByCollection({ dataSet }) {
-  const groups = {};
+  const groups = new Map();
   Object.entries(dataSet.fixtures).forEach(([connectionId, documents]) => {
-    const group = ensureGroup({ groups, collection: dataSet.collections[connectionId] });
+    const group = ensureGroup({ groups, dataSet, connectionId });
     documents.forEach((document, index) => {
       group.fixtures.push({ connectionId, index, document });
     });
   });
   Object.entries(dataSet.generated).forEach(([connectionId, documents]) => {
-    const group = ensureGroup({ groups, collection: dataSet.collections[connectionId] });
+    const group = ensureGroup({ groups, dataSet, connectionId });
     group.generated.push({ connectionId, documents });
   });
   Object.entries(dataSet.indexes).forEach(([connectionId, indexes]) => {
-    const group = ensureGroup({ groups, collection: dataSet.collections[connectionId] });
+    const group = ensureGroup({ groups, dataSet, connectionId });
     group.indexes.push(...indexes);
   });
-  return groups;
+  return [...groups.values()];
 }
 
 export default groupDataSetByCollection;

package/lib/docs/dataSets/openDataSession.js

@@ -23,10 +23,20 @@ import getDataStore from './getDataStore.js';
 import groupDataSetByCollection from './groupDataSetByCollection.js';
 import isDataStoreGone from './isDataStoreGone.js';
 import loadDataSetCollection from './loadDataSetCollection.js';
+import sessionDatabaseName from './sessionDatabaseName.js';
 import sweepOrphanDatabases from './sweepOrphanDatabases.js';
 
 const DRAIN_TIMEOUT_MS = 30000;
 
+// Every database the session holds, the first included.
+function listSessionDatabases(session) {
+  return [...new Set([session.databaseName, ...session.databases.values()])];
+}
+
+async function dropSessionDatabases({ client, session }) {
+  await Promise.all(listSessionDatabases(session).map((name) => client.db(name).dropDatabase()));
+}
+
 function createClose({ session, client }) {
   let closing;
   async function close() {
@@ -37,14 +47,14 @@ function createClose({ session, client }) {
       console.warn(
         `Data set "${session.name}": background work was still running ${
           DRAIN_TIMEOUT_MS / 1000
-        } s after its journey ended. Dropping its database anyway; that work now fails.`
+        } s after its journey ended. Dropping its databases anyway; that work now fails.`
       );
     }
     // Closed before the drop: a connection read under this session throws from here on, so
-    // nothing that outlived the drain reaches any database.
+    // nothing that outlived the drain reaches any database, and no target is added after the drop.
     session.state = 'closed';
     dataSessionRegistry.delete(session.id);
-    await client.db(session.databaseName).dropDatabase();
+    await dropSessionDatabases({ client, session });
   }
   return function closeOnce() {
     closing = closing ?? close();
@@ -52,20 +62,28 @@ function createClose({ session, client }) {
   };
 }
 
-// Opens a data session for one journey run (or a mutant run): a fresh database on the dev
-// server's memory store, loaded with the data set, registered under a random id. `cookie` is that id,
-// the payload openPage({ dataCookie }) writes into each actor's lowdefy_journey_data cookie. close()
-// waits for the session's background work (context.waitUntil), then drops the database.
+// Opens a data session for one journey run (or a mutant run): fresh databases on the dev server's
+// memory store, one per database target the build names (dataSet.databaseTargets), loaded with the
+// data set and registered under a random id. They are named <prefix>_<n> under the session's own
+// prefix (ld_<hex>), so the orphan sweep and close() find them all; the first, <prefix>_0, is also
+// the database a target computed per request reads. `cookie` is the id, the payload
+// openPage({ dataCookie }) writes into each actor's lowdefy_journey_data cookie. close() waits for
+// the session's background work (context.waitUntil), then drops the databases.
 async function openDataSession({ dataSet }) {
   const store = await getDataStore();
   const { client, uri } = store;
   const id = crypto.randomBytes(16).toString('hex');
+  const prefix = `ld_${crypto.randomBytes(6).toString('hex')}`;
+  const databaseTargets = dataSet.databaseTargets ?? [];
   const session = {
     id,
     databaseUri: uri,
-    databaseName: `ld_${crypto.randomBytes(6).toString('hex')}`,
+    prefix,
+    databaseName: `${prefix}_0`,
+    databases: new Map(databaseTargets.map((target, index) => [target, `${prefix}_${index}`])),
+    databaseCount: Math.max(databaseTargets.length, 1),
     name: dataSet.name,
-    // Registered while it loads, so a concurrent open's orphan sweep leaves its database alone.
+    // Registered while it loads, so a concurrent open's orphan sweep leaves its databases alone.
     // readDataSession serves only open and closing sessions.
     state: 'loading',
     work: new Set(),
@@ -75,15 +93,14 @@ async function openDataSession({ dataSet }) {
   dataSessionRegistry.set(id, session);
   try {
     await sweepOrphanDatabases({ client });
-    const db = client.db(session.databaseName);
     const groups = groupDataSetByCollection({ dataSet });
-    // allSettled, so no collection is still loading when a failed load drops the database.
+    // allSettled, so no collection is still loading when a failed load drops the databases.
     const results = await Promise.allSettled(
-      Object.entries(groups).map(([collectionName, group]) =>
+      groups.map((group) =>
         loadDataSetCollection({
-          db,
+          db: client.db(sessionDatabaseName({ session, target: group.target })),
           dataSetName: dataSet.name,
-          collectionName,
+          collectionName: group.collection,
           group,
         })
       )
@@ -105,10 +122,7 @@ async function openDataSession({ dataSet }) {
     }
     // Best effort: the load error is the one to report, and the next open's orphan sweep drops a
     // database this could not.
-    await client
-      .db(session.databaseName)
-      .dropDatabase()
-      .catch(() => {});
+    await dropSessionDatabases({ client, session }).catch(() => {});
     throw error;
   }
   session.state = 'open';

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

@@ -25,6 +25,8 @@ import dataSessionRegistry from './dataSessionRegistry.js';
 import getDataStore from './getDataStore.js';
 import openDataSession from './openDataSession.js';
 import readDataSession from './readDataSession.js';
+import readDataSet from './readDataSet.js';
+import applyDataSetRedirect from '../../server/applyDataSetRedirect.js';
 import { journeyActorToken } from '../../server/auth/journeyActor.js';
 
 jest.setTimeout(120000);
@@ -281,6 +283,154 @@ test('two sessions on one data set are isolated, and close() drops the database'
   expect(first.session.state).toEqual('closed');
 });
 
+describe('two databases that name one collection', () => {
+  let configDirectory;
+  let buildDirectory;
+
+  const artifacts = {
+    app_users: {
+      connectionId: 'app_users',
+      type: 'MongoDBCollection',
+      properties: { databaseUri: { _secret: 'MONGODB_URI' }, collection: 'users' },
+    },
+    auth_users: {
+      connectionId: 'auth_users',
+      type: 'MongoDBCollection',
+      properties: { databaseUri: { _secret: 'AUTH_MONGODB_URI' }, collection: 'users' },
+    },
+  };
+
+  beforeEach(() => {
+    configDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'lowdefy-data-targets-'));
+    buildDirectory = path.join(configDirectory, '.lowdefy', 'dev', 'build');
+    fs.mkdirSync(path.join(configDirectory, 'tests', 'data'), { recursive: true });
+    fs.mkdirSync(path.join(buildDirectory, 'connections'), { recursive: true });
+    Object.values(artifacts).forEach((artifact) => {
+      fs.writeFileSync(
+        path.join(buildDirectory, 'connections', `${artifact.connectionId}.json`),
+        JSON.stringify(artifact)
+      );
+    });
+    fs.writeFileSync(
+      path.join(configDirectory, 'tests', 'data', 'targets.yaml'),
+      `fixtures:
+  app_users: [{ _id: shared, name: App member }]
+  auth_users: [{ _id: shared, name: Auth user }, { _id: auth-only }]
+indexes:
+  app_users: [{ key: { name: 1 }, name: name_1, unique: true }]
+`
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(configDirectory, { recursive: true, force: true });
+  });
+
+  // The database a request on the connection reads under the session, through the gate.
+  async function redirectedDb({ session, connectionId }) {
+    const context = {
+      readConfigFile: async (filePath) =>
+        artifacts[filePath.replace(/^connections\/(.+)\.json$/, '$1')] ?? null,
+    };
+    applyDataSetRedirect({
+      context,
+      session,
+      connections: { MongoDBCollection: { meta: { dataSet: 'redirect' } } },
+    });
+    const { properties } = await context.readConfigFile(`connections/${connectionId}.json`);
+    expect(properties.databaseUri).toEqual(session.databaseUri);
+    return client.db(properties.databaseName);
+  }
+
+  test('each databaseUri secret loads into and reads its own session database, and close() drops both', async () => {
+    const dataSet = await readDataSet({ configDirectory, buildDirectory, name: 'targets' });
+    const { session, close } = await openDataSession({ dataSet });
+    let names;
+    try {
+      const appDb = await redirectedDb({ session, connectionId: 'app_users' });
+      const authDb = await redirectedDb({ session, connectionId: 'auth_users' });
+      expect(appDb.databaseName).not.toEqual(authDb.databaseName);
+      names = [appDb.databaseName, authDb.databaseName];
+      names.forEach((name) => expect(name.startsWith(`${session.prefix}_`)).toBe(true));
+      expect(await appDb.collection('users').find().toArray()).toEqual([
+        { _id: 'shared', name: 'App member' },
+      ]);
+      expect(await authDb.collection('users').find().sort({ _id: 1 }).toArray()).toEqual([
+        { _id: 'auth-only' },
+        { _id: 'shared', name: 'Auth user' },
+      ]);
+      // Indexes load per target too.
+      const appIndexes = await appDb.collection('users').indexes();
+      const authIndexes = await authDb.collection('users').indexes();
+      expect(appIndexes.map((index) => index.name)).toContain('name_1');
+      expect(authIndexes.map((index) => index.name)).not.toContain('name_1');
+      expect(await listDatabaseNames()).toEqual(expect.arrayContaining(names));
+    } finally {
+      await close();
+    }
+    const left = await listDatabaseNames();
+    names.forEach((name) => expect(left).not.toContain(name));
+  });
+
+  test('a connection whose target is computed loads into the first target database with it', async () => {
+    artifacts.computed_users = {
+      connectionId: 'computed_users',
+      type: 'MongoDBCollection',
+      properties: { databaseUri: { _env: 'URI' }, collection: 'users' },
+    };
+    fs.writeFileSync(
+      path.join(buildDirectory, 'connections', 'computed_users.json'),
+      JSON.stringify(artifacts.computed_users)
+    );
+    fs.writeFileSync(
+      path.join(configDirectory, 'tests', 'data', 'computed.yaml'),
+      'fixtures:\n  auth_users: [{ _id: auth }]\n  computed_users: [{ _id: computed }]\n'
+    );
+    try {
+      const dataSet = await readDataSet({ configDirectory, buildDirectory, name: 'computed' });
+      const { session, close } = await openDataSession({ dataSet });
+      try {
+        // AUTH_MONGODB_URI sorts first, so its database is the session's first.
+        const authDb = await redirectedDb({ session, connectionId: 'auth_users' });
+        const computedDb = await redirectedDb({ session, connectionId: 'computed_users' });
+        expect(authDb.databaseName).toEqual(session.databaseName);
+        expect(computedDb.databaseName).toEqual(session.databaseName);
+        const ids = await authDb.collection('users').distinct('_id');
+        expect(ids.sort()).toEqual(['auth', 'computed']);
+      } finally {
+        await close();
+      }
+    } finally {
+      delete artifacts.computed_users;
+    }
+  });
+
+  test('a session database the gate numbers after open survives a concurrent sweep and drops on close()', async () => {
+    const dataSet = await readDataSet({ configDirectory, buildDirectory, name: 'targets' });
+    const first = await openDataSession({ dataSet });
+    // A target the build did not name, as a config mutant's would be.
+    artifacts.late = {
+      connectionId: 'late',
+      type: 'MongoDBCollection',
+      properties: { databaseUri: { _secret: 'LATE_URI' }, collection: 'users' },
+    };
+    let lateName;
+    try {
+      const db = await redirectedDb({ session: first.session, connectionId: 'late' });
+      await db.collection('users').insertOne({ _id: 'late' });
+      lateName = db.databaseName;
+    } finally {
+      delete artifacts.late;
+    }
+    expect(lateName).toEqual(`${first.session.prefix}_${dataSet.databaseTargets.length}`);
+    const second = await openDataSession({ dataSet });
+    expect(await listDatabaseNames()).toContain(lateName);
+    await second.close();
+    await first.close();
+    expect(await listDatabaseNames()).not.toContain(lateName);
+  });
+});
+
 test('close() waits for background work added to the session', async () => {
   const { session, close } = await openDataSession({ dataSet: makeDataSet({}) });
   let release;

package/lib/docs/dataSets/readDataSet.js

@@ -14,10 +14,11 @@
   limitations under the License.
 */
 
+import { type } from '@lowdefy/helpers';
 import { parseDataSet } from '@lowdefy/node-utils';
 
 import checkSharedCollectionIds from './checkSharedCollectionIds.js';
-import findCollectionCollisions from './findCollectionCollisions.js';
+import describeTargetKey from './describeTargetKey.js';
 import readConnectionArtifacts from './readConnectionArtifacts.js';
 import resolveDataSetCollection from './resolveDataSetCollection.js';
 
@@ -31,38 +32,52 @@ function getKeyedConnectionIds({ dataSet }) {
   ];
 }
 
+// Sorts a URI's default database (no databaseName) before its named ones.
+function sortKey(key) {
+  const [uri, databaseName] = JSON.parse(key);
+  return [uri, databaseName ?? ''].join('\u0000');
+}
+
+// Every database target the built connections name, sorted, so each run numbers them alike and the
+// first one (the database a computed target reads) is the same on every run.
+function listDatabaseTargets({ artifacts }) {
+  const keys = new Set();
+  Object.values(artifacts).forEach((artifact) => {
+    const key = describeTargetKey({ properties: artifact.properties });
+    if (!type.isNone(key)) keys.add(key);
+  });
+  return [...keys].sort((a, b) => sortKey(a).localeCompare(sortKey(b)));
+}
+
 // The data set checks only the dev build can make, on top of parseDataSet's: every connection the
-// data set names is a MongoDBCollection with a literal collection, and connections that would merge
-// into one collection under the one-database redirect are refused (when the data set names one of
-// them) or reported, and a generated _id that another connection on the same collection also holds
-// is refused. Runs before any browser opens.
+// data set names is a MongoDBCollection with a literal collection, and a generated _id that another
+// connection on the same collection in the same database target also holds is refused. Adds the
+// database target of each connection it names (targets) and of every connection in the build
+// (databaseTargets): a data session gives each target a database of its own. Runs before any
+// browser opens.
 async function readDataSet({ configDirectory, buildDirectory, name }) {
   const dataSet = await parseDataSet({ configDirectory, name });
-  const warnings = [...dataSet.warnings];
-
   const artifacts = await readConnectionArtifacts({ buildDirectory });
   const keyedIds = getKeyedConnectionIds({ dataSet });
+  const databaseTargets = listDatabaseTargets({ artifacts });
   const collections = {};
+  const targets = {};
   keyedIds.forEach((connectionId) => {
+    const artifact = artifacts[connectionId];
     collections[connectionId] = resolveDataSetCollection({
       dataSetName: name,
       connectionId,
-      artifact: artifacts[connectionId],
+      artifact,
     }).collection;
+    // A target computed per request reads the session's first database, the first target's, so it
+    // groups and checks _ids with that target's connections.
+    targets[connectionId] =
+      describeTargetKey({ properties: artifact.properties }) ?? databaseTargets[0] ?? null;
   });
 
-  findCollectionCollisions({ artifacts }).forEach(({ collection, connectionIds }) => {
-    const [a, b] = connectionIds;
-    const message = `Connections "${a}" and "${b}" both name collection "${collection}" in different databases; under a data set they read one database, so they share one collection.`;
-    if (keyedIds.includes(a) || keyedIds.includes(b)) {
-      throw new Error(`Data set "${name}": ${message}`);
-    }
-    warnings.push(message);
-  });
-
-  checkSharedCollectionIds({ dataSetName: name, dataSet: { ...dataSet, collections } });
+  checkSharedCollectionIds({ dataSetName: name, dataSet: { ...dataSet, collections, targets } });
 
-  return { ...dataSet, collections, warnings };
+  return { ...dataSet, collections, targets, databaseTargets };
 }
 
 export default readDataSet;