@ultimabase/testing 0.0.0-stage → 0.1.1

package/dist/counts.js

@@ -0,0 +1,158 @@
+import { defineModel, master } from 'ultimabase';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { suiteUser } from './as-user.js';
+import { started } from './suite.js';
+const M = { as: master };
+const user = { as: suiteUser('00000000-0000-4000-8000-000000000000') };
+const open = () => true;
+const Firm = defineModel({
+    name: 'Firm',
+    fields: (f) => ({ name: f.string(), authors: f.many(() => Author) }),
+}).with({ access: { read: open } });
+/** A user reads the authors who are not retired. */
+const Author = defineModel({
+    name: 'Author',
+    fields: (f) => ({
+        name: f.string(),
+        retired: f.boolean({ default: false }),
+        firm: f.one(() => Firm, { optional: true }),
+        articles: f.many(() => Article),
+    }),
+}).with({ access: { read: ({ where }) => where({ retired: false }) } });
+const Article = defineModel({
+    name: 'Article',
+    fields: (f) => ({
+        title: f.string({ unique: true }),
+        author: f.one(() => Author, { optional: true }),
+        remarks: f.many(() => Remark),
+        labels: f.many(() => Label),
+    }),
+}).with({ access: { read: open } });
+/** A user reads the remarks that are not hidden. */
+const Remark = defineModel({
+    name: 'Remark',
+    fields: (f) => ({
+        body: f.string(),
+        hidden: f.boolean({ default: false }),
+        article: f.one(() => Article, { onDelete: 'cascade' }),
+    }),
+}).with({ access: { read: ({ where }) => where({ hidden: false }) } });
+const Label = defineModel({
+    name: 'Label',
+    fields: (f) => ({ text: f.string(), articles: f.many(() => Article) }),
+}).with({ access: { read: open } });
+const titles = (rows) => rows.map((row) => row.title);
+const connect = (id) => ({ connect: { id } });
+/** The articles' titles, by their author's firm name, then their title. */
+const byFirm = async (direction, as = M) => titles(await Article.findMany({
+    orderBy: [{ author: { firm: { name: direction } } }, { title: 'asc' }],
+}, as));
+export function counts(create) {
+    describe('counts and sorts through relations', () => {
+        started(create, [Firm, Author, Article, Remark, Label]);
+        let ada = '';
+        beforeEach(async () => {
+            const zeta = await Firm.create({ data: { name: 'Zeta' } }, M);
+            const acme = await Firm.create({ data: { name: 'Acme' } }, M);
+            ada = (await Author.create({ data: { name: 'Ada', firm: connect(zeta.id) } }, M)).id;
+            const bob = await Author.create({ data: { name: 'Bob', retired: true, firm: connect(acme.id) } }, M);
+            await Author.create({ data: { name: 'Cy' } }, M);
+            const ts = await Label.create({ data: { text: 'ts' } }, M);
+            const go = await Label.create({ data: { text: 'go' } }, M);
+            const article = async (title, author, remarks, labels) => Article.create({
+                data: {
+                    title,
+                    ...(author === undefined ? {} : { author: connect(author) }),
+                    remarks: { create: remarks },
+                    labels: { connect: labels.map((id) => ({ id })) },
+                },
+            }, M);
+            const hidden = true;
+            await article('One', ada, [{ body: 'r1' }, { body: 'r2', hidden }, { body: 'x', hidden }], [ts.id, go.id]);
+            await article('Two', bob.id, [], [ts.id]);
+            await article('Three', ada, [{ body: 'r3' }, { body: 'r4' }], []);
+            await article('Four', undefined, [], []);
+        });
+        it('counts every many relation, or the ones it names, filtered', async () => {
+            const authors = await Author.findMany({ orderBy: { name: 'asc' }, include: { _count: true } }, M);
+            expect(authors.map((row) => [row.name, row._count])).toEqual([
+                ['Ada', { articles: 2 }],
+                ['Bob', { articles: 1 }],
+                ['Cy', { articles: 0 }],
+            ]);
+            const articles = await Article.findMany({
+                orderBy: { title: 'asc' },
+                select: {
+                    title: true,
+                    _count: {
+                        select: {
+                            remarks: { where: { body: { startsWith: 'r' } } },
+                            labels: true,
+                        },
+                    },
+                },
+            }, M);
+            expect(articles).toEqual([
+                { title: 'Four', _count: { remarks: 0, labels: 0 } },
+                { title: 'One', _count: { remarks: 2, labels: 2 } },
+                { title: 'Three', _count: { remarks: 2, labels: 0 } },
+                { title: 'Two', _count: { remarks: 0, labels: 1 } },
+            ]);
+        });
+        it('counts at any depth, the rows the caller reads', async () => {
+            const args = {
+                where: { id: ada },
+                include: {
+                    articles: {
+                        orderBy: { title: 'asc' },
+                        include: { _count: { select: { remarks: true } } },
+                    },
+                },
+            };
+            const counted = async (as) => (await Author.findUnique(args, as))?.articles.map((row) => [
+                row.title,
+                row._count.remarks,
+            ]);
+            expect(await counted(M)).toEqual([
+                ['One', 3],
+                ['Three', 2],
+            ]);
+            expect(await counted(user)).toEqual([
+                ['One', 1],
+                ['Three', 2],
+            ]);
+        });
+        it('sorts through one relations, an absent row last ascending', async () => {
+            expect(await byFirm('asc')).toEqual(['Two', 'One', 'Three', 'Four']);
+            expect(await byFirm('desc')).toEqual(['Four', 'One', 'Three', 'Two']);
+            // Bob, whom a user does not read, sorts as an absent author.
+            expect(await byFirm('asc', user)).toEqual(['One', 'Three', 'Four', 'Two']);
+        });
+        it('sorts by a count of the rows the caller reads', async () => {
+            const by = async (as) => titles(await Article.findMany({
+                where: { remarks: { some: {} } },
+                orderBy: { remarks: { _count: 'desc' } },
+            }, as));
+            expect(await by(M)).toEqual(['One', 'Three']);
+            expect(await by(user)).toEqual(['Three', 'One']);
+            const authors = await Author.findMany({ orderBy: [{ articles: { _count: 'desc' } }, { name: 'asc' }] }, M);
+            expect(authors.map((row) => row.name)).toEqual(['Ada', 'Bob', 'Cy']);
+        });
+        it('pages exactly from a cursor through a relation sort', async () => {
+            const orderBy = [
+                { author: { name: 'desc' } },
+                { remarks: { _count: 'asc' } },
+            ];
+            const all = titles(await Article.findMany({ orderBy }, M));
+            expect(all).toEqual(['Four', 'Two', 'Three', 'One']);
+            const rows = await Article.findMany({ orderBy }, M);
+            for (const [at, row] of rows.entries()) {
+                const cursor = { id: row.id };
+                const after = await Article.findMany({ orderBy, cursor, take: 2 }, M);
+                expect(titles(after)).toEqual(all.slice(at, at + 2));
+                const before = await Article.findMany({ orderBy, cursor, take: -2 }, M);
+                expect(titles(before)).toEqual(all.slice(Math.max(0, at - 1), at + 1));
+            }
+        });
+    });
+}

package/dist/days.d.ts

@@ -0,0 +1,3 @@
+import type { Adapter } from 'ultimabase';
+export declare function calendarDays(create: () => Adapter): void;
+//# sourceMappingURL=days.d.ts.map

package/dist/days.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"days.d.ts","sourceRoot":"","sources":["../src/days.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAY,MAAM,YAAY,CAAA;AA2BnD,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,OAAO,GAAG,IAAI,CA6ExD"}

package/dist/days.js

@@ -0,0 +1,74 @@
+import { defineModel, master } from 'ultimabase';
+import { describe, expect, it } from 'vitest';
+import { started } from './suite.js';
+const M = { as: master };
+const Shift = defineModel({
+    name: 'Shift',
+    fields: (f) => ({
+        on: f.date(),
+        off: f.date({ optional: true, unique: true }),
+        team: f.string(),
+    }),
+});
+const days = (rows) => rows.map((row) => row.on);
+const rows = [
+    { on: '2026-07-31', team: 'a' },
+    { on: '0001-01-01', team: 'b', off: '2026-12-25' },
+    { on: '2024-02-29', team: 'a' },
+    { on: '9999-12-31', team: 'b' },
+    { on: '2026-07-31', team: 'b' },
+];
+export function calendarDays(create) {
+    describe('calendar days', () => {
+        started(create, [Shift]);
+        it('reads each day as written, and finds it unique', async () => {
+            const created = await Shift.create({ data: { on: '2026-07-31', team: 'a', off: '2026-08-01' } }, M);
+            expect(created).toMatchObject({ on: '2026-07-31', off: '2026-08-01' });
+            const updated = await Shift.update({ where: { id: created.id }, data: { on: '0001-01-01', off: null } }, M);
+            expect(updated).toMatchObject({ on: '0001-01-01', off: null });
+            await Shift.update({ where: { id: created.id }, data: { off: '2024-02-29' } }, M);
+            const found = await Shift.findUnique({ where: { off: '2024-02-29' } }, M);
+            expect(found).toMatchObject({ id: created.id, on: '0001-01-01' });
+        });
+        it('filters and sorts in the calendar order', async () => {
+            await Shift.createMany({ data: rows }, M);
+            const sorted = await Shift.findMany({ orderBy: [{ on: 'desc' }, { team: 'asc' }] }, M);
+            expect(days(sorted)).toEqual([
+                '9999-12-31',
+                '2026-07-31',
+                '2026-07-31',
+                '2024-02-29',
+                '0001-01-01',
+            ]);
+            const where = { on: { gt: '0001-01-01', lte: '2026-07-31' } };
+            expect(await Shift.count({ where }, M)).toBe(3);
+            const listed = { on: { in: ['2024-02-29', '9999-12-31'] } };
+            expect(await Shift.count({ where: listed }, M)).toBe(2);
+            const others = { on: { notIn: ['2026-07-31'], not: '0001-01-01' } };
+            expect(await Shift.count({ where: others }, M)).toBe(2);
+            expect(await Shift.count({ where: { on: '2026-07-31' } }, M)).toBe(2);
+        });
+        it('groups, picks one row per day and takes the least and the most', async () => {
+            await Shift.createMany({ data: rows }, M);
+            const groups = await Shift.groupBy({ by: ['on'], _count: true, orderBy: { on: 'asc' } }, M);
+            expect(groups).toStrictEqual([
+                { on: '0001-01-01', _count: 1 },
+                { on: '2024-02-29', _count: 1 },
+                { on: '2026-07-31', _count: 2 },
+                { on: '9999-12-31', _count: 1 },
+            ]);
+            const distinct = await Shift.findMany({ distinct: ['on'], orderBy: { on: 'asc' } }, M);
+            expect(days(distinct)).toEqual([
+                '0001-01-01',
+                '2024-02-29',
+                '2026-07-31',
+                '9999-12-31',
+            ]);
+            const result = await Shift.aggregate({ _min: { on: true, off: true }, _max: { on: true, off: true } }, M);
+            expect(result).toEqual({
+                _min: { on: '0001-01-01', off: '2026-12-25' },
+                _max: { on: '9999-12-31', off: '2026-12-25' },
+            });
+        });
+    });
+}

package/dist/decimals.d.ts

@@ -0,0 +1,3 @@
+import type { Adapter } from 'ultimabase';
+export declare function decimals(create: () => Adapter): void;
+//# sourceMappingURL=decimals.d.ts.map

package/dist/decimals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimals.d.ts","sourceRoot":"","sources":["../src/decimals.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAY,MAAM,YAAY,CAAA;AAmBnD,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,OAAO,GAAG,IAAI,CAgFpD"}

package/dist/decimals.js

@@ -0,0 +1,70 @@
+import { defineModel, master } from 'ultimabase';
+import { describe, expect, it } from 'vitest';
+import { started } from './suite.js';
+const M = { as: master };
+const Price = defineModel({
+    name: 'Price',
+    fields: (f) => ({
+        amount: f.decimal({ precision: 6, scale: 2 }),
+        code: f.decimal({ precision: 4, scale: 1, optional: true, unique: true }),
+        exact: f.decimal({ precision: 30, scale: 10, optional: true }),
+    }),
+});
+const amounts = (rows) => rows.map((row) => row.amount);
+export function decimals(create) {
+    describe('decimals', () => {
+        started(create, [Price]);
+        it('stores each value at its scale, beyond a double', async () => {
+            const exact = '12345678901234567890.0123456789';
+            const created = await Price.create({ data: { amount: '012.5', code: '-0', exact } }, M);
+            expect(created).toMatchObject({ amount: '12.50', code: '0.0', exact });
+            const updated = await Price.update({ where: { id: created.id }, data: { amount: '7.500', exact: null } }, M);
+            expect(updated).toMatchObject({ amount: '7.50', exact: null });
+            const found = await Price.findUnique({ where: { code: '0' } }, M);
+            expect(found?.id).toBe(created.id);
+        });
+        it('filters and sorts by value, not by text', async () => {
+            const nine = await Price.create({ data: { amount: '9.5' } }, M);
+            await Price.createMany({ data: ['10', '-2.25', '100'].map((amount) => ({ amount })) }, M);
+            const sorted = await Price.findMany({ orderBy: { amount: 'asc' } }, M);
+            expect(amounts(sorted)).toEqual(['-2.25', '9.50', '10.00', '100.00']);
+            const where = { amount: { gt: '9.5', lte: '100.00' } };
+            expect(amounts(await Price.findMany({ where }, M))).toEqual([
+                '10.00',
+                '100.00',
+            ]);
+            const listed = { amount: { in: ['10', '-2.250'] } };
+            expect(await Price.count({ where: listed }, M)).toBe(2);
+            const after = await Price.findMany({
+                orderBy: { amount: 'desc' },
+                cursor: { id: nine.id },
+                skip: 1,
+            }, M);
+            expect(amounts(after)).toEqual(['-2.25']);
+            const before = await Price.findMany({ orderBy: { amount: 'asc' }, cursor: { id: nine.id } }, M);
+            expect(amounts(before)).toEqual(['9.50', '10.00', '100.00']);
+        });
+        it('sums exactly, at the scale, and compares by value', async () => {
+            await Price.createMany({
+                data: [
+                    { amount: '0.10', exact: '0.1' },
+                    { amount: '0.20', exact: '99999999999999999999.9999999999' },
+                    { amount: '-10' },
+                    { amount: '9' },
+                ],
+            }, M);
+            const result = await Price.aggregate({
+                _sum: { amount: true, exact: true },
+                _avg: { amount: true },
+                _min: { amount: true },
+                _max: { amount: true, code: true },
+            }, M);
+            expect(result).toEqual({
+                _sum: { amount: '-0.70', exact: '100000000000000000000.0999999999' },
+                _avg: { amount: -0.175 },
+                _min: { amount: '-10.00' },
+                _max: { amount: '9.00', code: null },
+            });
+        });
+    });
+}

package/dist/distincts.d.ts

@@ -0,0 +1,3 @@
+import type { Adapter } from 'ultimabase';
+export declare function distincts(create: () => Adapter): void;
+//# sourceMappingURL=distincts.d.ts.map

package/dist/distincts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distincts.d.ts","sourceRoot":"","sources":["../src/distincts.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAY,MAAM,YAAY,CAAA;AA+BnD,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,OAAO,GAAG,IAAI,CAwErD"}

package/dist/distincts.js

@@ -0,0 +1,80 @@
+import { defineModel, master } from 'ultimabase';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { suiteUser } from './as-user.js';
+import { started } from './suite.js';
+const M = { as: master };
+const user = { as: suiteUser('00000000-0000-4000-8000-000000000000') };
+/** A user reads the clubs that are not hidden. */
+const Club = defineModel({
+    name: 'Club',
+    fields: (f) => ({
+        hidden: f.boolean({ default: false }),
+        visits: f.many(() => Visit),
+    }),
+}).with({ access: { read: ({ where }) => where({ hidden: false }) } });
+const Visit = defineModel({
+    name: 'Visit',
+    fields: (f) => ({
+        score: f.number({ integer: true }),
+        region: f.string({ optional: true }),
+        club: f.one(() => Club, { optional: true }),
+    }),
+}).with({ access: { read: () => true } });
+const select = { score: true };
+const scores = (rows) => rows.map((row) => row.score);
+export function distincts(create) {
+    describe('distincts', () => {
+        started(create, [Club, Visit]);
+        beforeEach(async () => {
+            const red = (await Club.create({ data: {} }, M)).id;
+            const blue = (await Club.create({ data: { hidden: true } }, M)).id;
+            const rows = [
+                { score: 1, region: 'n', club: red },
+                { score: 2, region: 'n', club: blue },
+                { score: 3, region: 's', club: red },
+                { score: 4 },
+                { score: 5, region: 's', club: blue },
+                { score: 6, club: red },
+            ];
+            for (const { club, ...row } of rows) {
+                const data = club === undefined ? row : { ...row, club: { connect: { id: club } } };
+                await Visit.create({ data }, M);
+            }
+        });
+        it('keeps the first row of each key in the order, the rows with no value together', async () => {
+            const first = await Visit.findMany({ distinct: ['region'], orderBy: { score: 'asc' }, select }, M);
+            expect(scores(first)).toStrictEqual([1, 3, 4]);
+            const last = await Visit.findMany({ distinct: ['region'], orderBy: { score: 'desc' }, select }, M);
+            expect(scores(last)).toStrictEqual([6, 5, 2]);
+        });
+        it('filters before it keeps, and pages after', async () => {
+            const filtered = await Visit.findMany({
+                distinct: ['region'],
+                where: { score: { gte: 3 } },
+                orderBy: { score: 'asc' },
+                select,
+            }, M);
+            expect(scores(filtered)).toStrictEqual([3, 4]);
+            const args = {
+                distinct: ['region'],
+                orderBy: { score: 'desc' },
+                select,
+            };
+            const paged = await Visit.findMany({ ...args, skip: 1, take: 1 }, M);
+            expect(scores(paged)).toStrictEqual([5]);
+            const back = await Visit.findMany({ ...args, take: -1 }, M);
+            expect(scores(back)).toStrictEqual([2]);
+        });
+        it('compares a relation by its target, none when unread', async () => {
+            const args = {
+                distinct: ['club'],
+                orderBy: { score: 'asc' },
+                select,
+            };
+            expect(scores(await Visit.findMany(args, M))).toStrictEqual([1, 2, 4]);
+            expect(scores(await Visit.findMany(args, user))).toStrictEqual([1, 2]);
+            const both = await Visit.findMany({ ...args, distinct: ['region', 'club'] }, M);
+            expect(scores(both)).toStrictEqual([1, 2, 3, 4, 5, 6]);
+        });
+    });
+}

package/dist/feeds.d.ts

@@ -0,0 +1,3 @@
+import type { Adapter } from 'ultimabase';
+export declare function feeds(create: () => Adapter): void;
+//# sourceMappingURL=feeds.d.ts.map

package/dist/feeds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feeds.d.ts","sourceRoot":"","sources":["../src/feeds.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAW,MAAM,YAAY,CAAA;AA2ElD,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,OAAO,GAAG,IAAI,CAuHjD"}

package/dist/feeds.js

@@ -0,0 +1,164 @@
+import { defineApp, defineModel, definePlugin, master, transaction, } from 'ultimabase';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { silent } from './silent.js';
+const M = { as: master };
+const Card = defineModel({
+    name: 'Card',
+    fields: (f) => ({
+        title: f.string({ unique: true }),
+        rank: f.number({ integer: true, optional: true }),
+        tags: f.many(() => Tag),
+    }),
+});
+const Tag = defineModel({
+    name: 'Tag',
+    fields: (f) => ({ label: f.string(), cards: f.many(() => Card) }),
+});
+const long = Array.from({ length: 30 }, (_, index) => `field${index}`.padEnd(52, 'x'));
+const Wide = defineModel({
+    name: 'Wide',
+    fields: (f) => Object.fromEntries(long.map((name) => [name, f.string({ optional: true })])),
+});
+/** Written last: once its insert arrives, so have the changes before it. */
+const Mark = defineModel({
+    name: 'Mark',
+    fields: (f) => ({ at: f.number({ integer: true }) }),
+});
+const manifest = {
+    name: 'watcher',
+    version: '1.0.0',
+    peerDependencies: { ultimabase: '*' },
+};
+/** The changes `seen` holds, one entry per kind and target, lists sorted. */
+function merged(seen) {
+    const entries = new Map();
+    for (const change of seen) {
+        const target = 'field' in change ? change.field : change.fields?.toSorted();
+        const key = JSON.stringify([change.kind, change.model, target]);
+        const rows = 'field' in change ? change.pairs : change.ids;
+        const known = entries.get(key);
+        const listed = rows === undefined || (known !== undefined && known.listed === undefined)
+            ? undefined
+            : [
+                ...(known?.listed ?? []),
+                ...rows.map((row) => (typeof row === 'string' ? row : row.join())),
+            ];
+        entries.set(key, listed === undefined ? { change } : { change, listed });
+    }
+    return [...entries.values()].map(({ change, listed }) => {
+        const { kind, model } = change;
+        const rows = listed?.toSorted();
+        if ('field' in change)
+            return { kind, model, field: change.field, rows };
+        return { kind, model, fields: change.fields?.toSorted(), rows };
+    });
+}
+export function feeds(create) {
+    describe('the change feed', () => {
+        let seen = [];
+        let marks = 0;
+        let app;
+        const watcher = definePlugin({
+            name: 'watcher',
+            manifest,
+            changed: (changes) => {
+                seen.push(...changes);
+            },
+        });
+        beforeEach(async () => {
+            app = defineApp({
+                database: create(),
+                models: [Card, Tag, Wide, Mark],
+                plugins: [watcher.plugin()],
+                logger: silent,
+            });
+            await app.start();
+            seen = [];
+        });
+        afterEach(async () => app.stop());
+        /** The changes the commits so far made, once all of them arrived. */
+        const settled = async () => {
+            marks += 1;
+            const { id } = await Mark.create({ data: { at: marks } }, M);
+            await vi.waitFor(() => {
+                expect(seen.some((change) => 'ids' in change && change.ids?.includes(id))).toBe(true);
+            });
+            const changes = merged(seen.filter((change) => change.model !== 'Mark'));
+            seen = [];
+            return changes;
+        };
+        it('reports the rows each commit inserted, updated and deleted', async () => {
+            const a = await Card.create({ data: { title: 'a' } }, M);
+            const b = await Card.create({ data: { title: 'b' } }, M);
+            await Card.update({ where: { id: a.id }, data: { rank: 2 } }, M);
+            await Card.delete({ where: { id: b.id } }, M);
+            expect(await settled()).toEqual([
+                { kind: 'insert', model: 'Card', rows: [a.id, b.id].toSorted() },
+                {
+                    kind: 'update',
+                    model: 'Card',
+                    fields: ['rank', 'updatedAt'],
+                    rows: [a.id],
+                },
+                { kind: 'delete', model: 'Card', rows: [b.id] },
+            ]);
+        });
+        it('reports the links a write added or removed, not those it found', async () => {
+            const card = await Card.create({ data: { title: 'a' } }, M);
+            const tag = await Tag.create({ data: { label: 'red' } }, M);
+            await settled();
+            const tags = { connect: [{ id: tag.id }] };
+            await Card.update({ where: { id: card.id }, data: { tags } }, M);
+            await Card.update({ where: { id: card.id }, data: { tags } }, M);
+            const pair = [card.id, tag.id].join();
+            const link = { model: 'Card', field: 'tags', rows: [pair] };
+            const updated = { kind: 'update', model: 'Card', fields: ['updatedAt'] };
+            expect(await settled()).toEqual([
+                { ...updated, rows: [card.id, card.id] },
+                { kind: 'link', ...link },
+            ]);
+            const disconnect = [{ id: tag.id }];
+            await Card.update({ where: { id: card.id }, data: { tags: { disconnect } } }, M);
+            expect(await settled()).toEqual([
+                { ...updated, rows: [card.id] },
+                { kind: 'unlink', ...link },
+            ]);
+        });
+        it('reports nothing of a rollback, a failed write or an empty update', async () => {
+            await Card.create({ data: { title: 'a' } }, M);
+            await settled();
+            const failed = transaction(async () => {
+                await Card.create({ data: { title: 'b' } }, M);
+                throw new Error('Stop.');
+            });
+            await expect(failed).rejects.toThrow('Stop.');
+            const taken = Card.create({ data: { title: 'a' } }, M);
+            await expect(taken).rejects.toMatchObject({ code: 'UNIQUE_VIOLATION' });
+            await Card.updateMany({ where: { title: 'none' }, data: { rank: 1 } }, M);
+            expect(await settled()).toEqual([]);
+        });
+        it("reports a transaction's writes once it commits", async () => {
+            const [a, b] = await transaction(async () => [
+                await Card.create({ data: { title: 'a' } }, M),
+                await Card.create({ data: { title: 'b' } }, M),
+            ]);
+            expect(await settled()).toEqual([
+                { kind: 'insert', model: 'Card', rows: [a?.id, b?.id].toSorted() },
+            ]);
+        });
+        it('lists no ids past a thousand, no fields past their limit', async () => {
+            const data = Array.from({ length: 1001 }, (_, index) => ({
+                title: `${index}`,
+            }));
+            await Card.createMany({ data }, M);
+            const wide = await Wide.create({ data: {} }, M);
+            const set = Object.fromEntries(long.map((name) => [name, 'v']));
+            await Wide.update({ where: { id: wide.id }, data: set }, M);
+            expect(await settled()).toEqual([
+                { kind: 'insert', model: 'Card', rows: undefined },
+                { kind: 'insert', model: 'Wide', rows: [wide.id] },
+                { kind: 'update', model: 'Wide', fields: undefined, rows: [wide.id] },
+            ]);
+        });
+    });
+}

package/dist/groups.d.ts

@@ -0,0 +1,3 @@
+import type { Adapter } from 'ultimabase';
+export declare function groups(create: () => Adapter): void;
+//# sourceMappingURL=groups.d.ts.map

package/dist/groups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"groups.d.ts","sourceRoot":"","sources":["../src/groups.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAY,MAAM,YAAY,CAAA;AAmCnD,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,GAAG,IAAI,CAiJlD"}