@geekmidas/constructs 10.0.0-alpha.31 → 10.0.0-alpha.33

package/README.md

@@ -933,19 +933,34 @@ Map it once in the app's `package.json` — `"imports": { "#test":
 ```typescript
 import { it } from '#test';
 
-it('shows the signed-in user their profile', async ({ browser, mailbox }) => {
-  await browser.auth.signIn.magicLink({ email: 'ada@shop.test' });
-  await browser.visit((await mailbox('ada@shop.test').last()).link!);
+it('shows the signed-in user their orders', async ({ browser, db, factories }) => {
+  const factory = await factories.get('database');
+  await factory.insert('orders', { email: 'ada@shop.test' });
 
-  expect(await browser.api.get('/profile')).toMatchObject({ email: 'ada@shop.test' });
+  await browser.signIn('ada@shop.test');
+  const { orders } = await browser.api.get('/orders');
+  expect(orders).toHaveLength(1);
+
+  const app = await db.get('database');
+  expect(await app.selectFrom('orders').selectAll().execute()).toHaveLength(1);
 });
 ```
 
 - **`browser`** — already the global `fetch`; its cookie jar follows the
   browser's rules, so a session cookie set for the wrong domain never reaches
   the API.
-- **`db`** — the transaction of the database the endpoints name, typed by its
-  schema.
+- **`browser.signIn(email)`** — when the auth server has the magic-link plugin
+  and the app sends mail: the link requested, read from the inbox and
+  followed, as a person signs in. Returns the session the auth server reports.
+- **`db.get(name)`** — the app's own databases by service name
+  (`db.get('database')`), each this test's transaction, typed by its schema.
+  Opened on first use by whatever reaches it first — the test, a factory, an
+  endpoint — and the same one for all of them. A tenant an auth server owns is
+  not among them: it is reached through the auth server, as the app reaches
+  it. Nor is a reader.
+- **`factories.get(name)`** — each of those databases' factory, from
+  `test/factories/<construct>.ts` at the project root, on the same
+  transaction: `(await factories.get('database')).insert('users', …)`.
 - **`mailbox(address)`** — the mail actually sent, read from Mailpit.
 - **`published(topic | queue)`** — what the test published or enqueued.
   Nothing is delivered: a subscriber or a worker is run on its own with

package/dist/adaptors/testing.cjs

@@ -506,10 +506,14 @@ function featureTest(options = {}) {
 	const manifest = options.manifest ?? loadTestManifest();
 	const BrowserClass = options.browser ?? _geekmidas_testkit_browser.Browser;
 	let app;
+	let factoryDatabases = [];
+	let owned = [];
 	let network;
 	let restoreFetch = () => {};
 	(0, vitest.beforeAll)(async () => {
-		app = await load(manifest, options.database, options.modules ?? {});
+		app = await load(manifest, options.modules ?? {});
+		owned = ownDatabases(app, manifest);
+		factoryDatabases = databasesFor(options.factories ?? {}, owned);
 		for (const database of app.databases) bindToTests(database);
 		network = (0, msw_node.setupServer)(...surfaceHandlers(app.endpoints, manifest.env), ...app.auths.map((auth) => authHandler(auth, manifest.env, app.envParser)));
 		network.listen({ onUnhandledRequest(request, print) {
@@ -532,6 +536,11 @@ function featureTest(options = {}) {
 			addresses: /* @__PURE__ */ new Set(),
 			published: /* @__PURE__ */ new Map()
 		};
+		const readMail = app.readMail;
+		if (readMail) state.mailbox = (address) => {
+			state.addresses.add(address);
+			return readMail(address);
+		};
 		contexts.set(id, state);
 		await state.discovery.register(recorders(app.channels, state));
 		try {
@@ -539,13 +548,29 @@ function featureTest(options = {}) {
 				const browser = new BrowserClass();
 				const restore = browser.install();
 				try {
+					const transaction = (database) => state.transactions.get(database.id, urlOf(database, app.envParser), database.clientConfig);
+					const db = { get: (name) => {
+						const database = owned.find((candidate) => candidate.service.serviceName === name);
+						if (!database) throw new UnknownDatabase(name, owned.map((candidate) => candidate.service.serviceName));
+						return transaction(database);
+					} };
+					const built = /* @__PURE__ */ new Map();
 					await fn({
 						browser,
-						db: app.database ? await state.transactions.get(app.database.id, urlOf(app.database, app.envParser), app.database.clientConfig) : void 0,
+						db,
+						factories: { get: (name) => {
+							const database = factoryDatabases.find(([candidate]) => candidate === name)?.[1];
+							if (!database) throw new UnknownFactory(name, factoryDatabases.map(([candidate]) => candidate));
+							let factory = built.get(name);
+							if (!factory) {
+								factory = transaction(database).then(options.factories[name]);
+								built.set(name, factory);
+							}
+							return factory;
+						} },
 						mailbox: (address) => {
-							if (!app.readMail) throw new NoInbox();
-							state.addresses.add(address);
-							return app.readMail(address);
+							if (!state.mailbox) throw new NoInbox();
+							return state.mailbox(address);
 						},
 						published: (channel) => [...state.published.get(channel.id) ?? []],
 						subscriber: (subscriber) => new TestSubscriberAdaptor(subscriber, state.discovery),
@@ -571,7 +596,7 @@ function featureTest(options = {}) {
 * The same modules the app runs, so a construct here *is* the app's construct —
 * the one its endpoints were built from — never a copy declared again.
 */
-async function load(manifest, database, modules) {
+async function load(manifest, modules) {
 	const envParser = new _geekmidas_envkit.EnvironmentParser({ ...manifest.env });
 	const imported = async ({ file, export: name }) => (modules[file] ?? await import(file))[name];
 	const constructs = await Promise.all(Object.values(manifest.constructs).map(({ source }) => imported(source)));
@@ -589,7 +614,6 @@ async function load(manifest, database, modules) {
 		auths,
 		emails,
 		channels,
-		database: databaseOf(databases, endpoints, database),
 		...inbox ? { readMail: (0, _geekmidas_testkit_mailbox.createMailbox)({ inbox }) } : {}
 	};
 }
@@ -612,18 +636,22 @@ function recorders(channels, state) {
 	});
 }
 /**
-* The database a test sees as `db`: the one named, or else the one the
-* endpoints were given with `.database()` — found by the service they hold,
-* which is the construct's own.
+* The databases a test is handed: the app's own. A schema tenant an auth server
+* owns is reached through that server, as the app reaches it, and a reader is
+* the same database through a read-only role — neither is another database to
+* test against.
 */
-function databaseOf(databases, endpoints, named) {
-	if (named) {
-		const found = databases.find(({ id }) => id === named);
-		if (!found) throw new UnknownDatabase(named, databases.map(({ id }) => id));
-		return found;
-	}
-	const services = new Set(endpoints.map((e) => e.databaseService).filter(Boolean));
-	return databases.find((database) => services.has(database.service));
+function ownDatabases(app, manifest) {
+	const owners = new Set(app.auths.map((auth) => auth.databaseId));
+	return app.databases.filter((database) => !owners.has(database.id) && manifest.constructs[database.id]?.kind !== "database-reader");
+}
+/** Each factory's database, found by the service name it is keyed by. */
+function databasesFor(factories, databases) {
+	return Object.keys(factories).map((name) => {
+		const database = databases.find((candidate) => candidate.service.serviceName === name);
+		if (!database) throw new UnknownFactory(name, databases.map((candidate) => candidate.service.serviceName));
+		return [name, database];
+	});
 }
 /**
 * Make a database resolve, inside a test, to that test's transaction.
@@ -701,6 +729,42 @@ function trim(url) {
 function isLocal(url) {
 	return url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname.endsWith(".localhost");
 }
+/**
+* Sign a test's browser in the way a person does: ask the auth server for a
+* magic link, open the email it sent, follow the link.
+*
+* What the generated `browser.signIn(email)` calls. The address's mail is
+* cleared first — so the link is this request's, not one an earlier test left
+* — and cleared again after the test, like any address a test reads. Returns
+* the session the auth server then reports, as better-auth hands it back.
+*/
+async function signInWithMagicLink(browser, auth, email) {
+	const context = (0, _geekmidas_testkit_context.currentTestContext)();
+	const state = context && contexts.get(context.id);
+	if (!state) throw new UnknownTestContext("signIn", context?.id);
+	if (!state.mailbox) throw new NoInbox();
+	const inbox = state.mailbox(email);
+	await inbox.clear();
+	const requested = await auth.signIn.magicLink({ email });
+	if (requested.error) throw new SignInFailed(email, `the auth server refused the magic link: ${requested.error.message ?? "no reason given"}`);
+	const mail = await inbox.last();
+	if (!mail.link) throw new SignInFailed(email, "its email held no link");
+	await browser.visit(mail.link);
+	const { data } = await auth.getSession();
+	if (!data) throw new SignInFailed(email, "the auth server reported no session after the link was opened");
+	return data;
+}
+/** `browser.signIn` finished without a session. */
+var SignInFailed = class extends Error {
+	email;
+	reason;
+	constructor(email, reason) {
+		super(`Signing ${email} in failed: ${reason}.`);
+		this.email = email;
+		this.reason = reason;
+		this.name = "SignInFailed";
+	}
+};
 /** A request reached an in-process server without a test to belong to. */
 var UnknownTestContext = class extends Error {
 	url;
@@ -719,20 +783,32 @@ var NoInbox = class extends Error {
 		this.name = "NoInbox";
 	}
 };
-/** `featureTest({ database })` named a database the app does not declare. */
+/** `db.get(name)` named no database the test is handed. */
 var UnknownDatabase = class extends Error {
-	id;
-	declared;
-	constructor(id, declared) {
-		super(`featureTest was asked for the database '${id}', and the app declares ${declared.length ? declared.map((d) => `'${d}'`).join(", ") : "none"}.`);
-		this.id = id;
-		this.declared = declared;
+	database;
+	known;
+	constructor(database, known) {
+		super(`db.get('${database}') names no database of this app's. ` + (known.length > 0 ? `Its databases: ${known.join(", ")}. ` : "It declares no database of its own. ") + "A tenant an auth server owns is reached through that server, and a reader through the database it reads.");
+		this.database = database;
+		this.known = known;
 		this.name = "UnknownDatabase";
 	}
 };
+/** A factory keyed by a service name no database the app declares has. */
+var UnknownFactory = class extends Error {
+	factory;
+	known;
+	constructor(factory, known) {
+		super(`There is a test factory for '${factory}', and no database this app declares is called that. ` + (known.length > 0 ? `Its databases: ${known.join(", ")}. ` : "It declares no database. ") + `Name the file after the database construct: test/factories/<construct>.ts.`);
+		this.factory = factory;
+		this.known = known;
+		this.name = "UnknownFactory";
+	}
+};
 //#endregion
 exports.NoInbox = NoInbox;
 exports.NoTestManifest = NoTestManifest;
+exports.SignInFailed = SignInFailed;
 exports.TEST_CONTEXT_HEADER = _geekmidas_testkit_context.TEST_CONTEXT_HEADER;
 exports.TEST_MANIFEST_ENV = TEST_MANIFEST_ENV;
 exports.TestEndpointAdaptor = TestEndpointAdaptor;
@@ -740,9 +816,11 @@ exports.TestFunctionAdaptor = TestFunctionAdaptor;
 exports.TestQueueAdaptor = TestQueueAdaptor;
 exports.TestSubscriberAdaptor = TestSubscriberAdaptor;
 exports.UnknownDatabase = UnknownDatabase;
+exports.UnknownFactory = UnknownFactory;
 exports.UnknownTestContext = UnknownTestContext;
 exports.createMswHandlers = createMswHandlers;
 exports.featureTest = featureTest;
 exports.loadTestManifest = loadTestManifest;
+exports.signInWithMagicLink = signInWithMagicLink;
 
 //# sourceMappingURL=testing.cjs.map