@ultimabase/testing 0.0.0-stage → 0.1.1

package/dist/groups.js

@@ -0,0 +1,149 @@
+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 teams that are not hidden. */
+const Team = defineModel({
+    name: 'Team',
+    fields: (f) => ({
+        hidden: f.boolean({ default: false }),
+        deals: f.many(() => Deal),
+    }),
+}).with({ access: { read: ({ where }) => where({ hidden: false }) } });
+const Deal = defineModel({
+    name: 'Deal',
+    fields: (f) => ({
+        stage: f.enumOf(['b', 'a', 'c']),
+        amount: f.decimal({ precision: 8, scale: 2 }),
+        units: f.number({ integer: true, optional: true }),
+        on: f.dateTime({ optional: true }),
+        region: f.string({ optional: true }),
+        team: f.one(() => Team, { optional: true }),
+    }),
+}).with({ access: { read: () => true } });
+const day = (n) => new Date(Date.UTC(2026, 4, n, 12, 30));
+const stages = async (kept) => (await kept).map((group) => group.stage);
+export function groups(create) {
+    describe('groups', () => {
+        started(create, [Team, Deal]);
+        let red = '';
+        let blue = '';
+        beforeEach(async () => {
+            red = (await Team.create({ data: {} }, M)).id;
+            blue = (await Team.create({ data: { hidden: true } }, M)).id;
+            const rows = [
+                { stage: 'a', amount: '1.10', units: 2, on: day(1), region: 'n' },
+                { stage: 'a', amount: '2.20', units: 3, on: day(1), region: 'n' },
+                { stage: 'b', amount: '5', on: day(2), region: 's' },
+                { stage: 'c', amount: '10', units: 1 },
+                { stage: 'b', amount: '1', units: 4, on: day(2), region: 's' },
+            ];
+            const teams = [red, blue, red, undefined, red];
+            for (const [at, row] of rows.entries()) {
+                const id = teams[at];
+                const data = id === undefined ? row : { ...row, team: { connect: { id } } };
+                await Deal.create({ data }, M);
+            }
+        });
+        it('groups by scalars and dates, the rows with no value together', async () => {
+            const result = await Deal.groupBy({ by: ['region', 'on'], _count: true, _sum: { amount: true } }, M);
+            expect(result).toStrictEqual([
+                { region: 'n', on: day(1), _count: 2, _sum: { amount: '3.30' } },
+                { region: 's', on: day(2), _count: 2, _sum: { amount: '6.00' } },
+                { region: null, on: null, _count: 1, _sum: { amount: '10.00' } },
+            ]);
+            const regions = await Deal.groupBy({ by: ['region'], orderBy: { region: 'desc' } }, M);
+            expect(regions).toStrictEqual([
+                { region: null },
+                { region: 's' },
+                { region: 'n' },
+            ]);
+        });
+        it('sorts by an aggregate, then by the keys, and pages', async () => {
+            const counted = await Deal.groupBy({ by: ['stage'], orderBy: { _count: 'desc' }, _max: { units: true } }, M);
+            expect(counted).toStrictEqual([
+                { stage: 'a', _max: { units: 3 } },
+                { stage: 'b', _max: { units: 4 } },
+                { stage: 'c', _max: { units: 1 } },
+            ]);
+            const summed = { _sum: { amount: 'desc' } };
+            const sorted = await Deal.groupBy({ by: ['stage'], orderBy: summed }, M);
+            expect(sorted).toStrictEqual([
+                { stage: 'c' },
+                { stage: 'b' },
+                { stage: 'a' },
+            ]);
+            const paged = await Deal.groupBy({ by: ['stage'], orderBy: summed, skip: 1, take: 1 }, M);
+            expect(paged).toStrictEqual([{ stage: 'b' }]);
+        });
+        it('groups by a relation, null when unset or unread', async () => {
+            const args = {
+                by: ['team'],
+                orderBy: { _count: 'desc' },
+                _count: true,
+            };
+            expect(await Deal.groupBy(args, M)).toStrictEqual([
+                { team: { id: red }, _count: 3 },
+                { team: { id: blue }, _count: 1 },
+                { team: null, _count: 1 },
+            ]);
+            expect(await Deal.groupBy(args, user)).toStrictEqual([
+                { team: { id: red }, _count: 3 },
+                { team: null, _count: 2 },
+            ]);
+        });
+        it('keeps the groups having passes, by their values and aggregates', async () => {
+            const by = ['stage'];
+            const sum = { amount: { _sum: { gt: '5' } } };
+            expect(await stages(Deal.groupBy({ by, having: sum }, M))).toEqual([
+                'b',
+                'c',
+            ]);
+            const counts = {
+                stage: { in: ['a', 'b'] },
+                amount: { _count: 2 },
+            };
+            expect(await stages(Deal.groupBy({ by, having: counts }, M))).toEqual([
+                'a',
+                'b',
+            ]);
+            const average = { units: { _avg: { lt: 3 } } };
+            expect(await stages(Deal.groupBy({ by, having: average }, M))).toEqual([
+                'a',
+                'c',
+            ]);
+            const least = { on: { _min: { gte: day(2) } } };
+            expect(await stages(Deal.groupBy({ by, having: least }, M))).toEqual([
+                'b',
+            ]);
+            const either = {
+                OR: [{ stage: 'c' }, { units: { _max: { gte: 4 } } }],
+            };
+            expect(await stages(Deal.groupBy({ by, having: either }, M))).toEqual([
+                'b',
+                'c',
+            ]);
+            const dated = { NOT: { on: { _min: { equals: null } } } };
+            expect(await stages(Deal.groupBy({ by, having: dated }, M))).toEqual([
+                'a',
+                'b',
+            ]);
+            const counted = await Deal.groupBy({
+                by: ['stage', 'region'],
+                _count: true,
+                having: { region: { not: null }, amount: { _count: { gt: 1 } } },
+                orderBy: { _sum: { amount: 'desc' } },
+            }, M);
+            expect(counted).toStrictEqual([
+                { stage: 'b', region: 's', _count: 2 },
+                { stage: 'a', region: 'n', _count: 2 },
+            ]);
+        });
+        it('gives no groups without rows', async () => {
+            const where = { region: 'w' };
+            expect(await Deal.groupBy({ by: ['stage'], where, _count: true }, M)).toStrictEqual([]);
+        });
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { asUser } from './as-user.ts';
+export { testAdapter } from './test-adapter.ts';
+export type { TestApplication, TestOptions } from './test-application.ts';
+export { testApplication } from './test-application.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,YAAY,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/index.js

@@ -0,0 +1,5 @@
+// `@ultimabase/testing` (D-40): an application's tests (D-130), the adapter
+// contract suite (D-94) and a test's user caller (D-80).
+export { asUser } from './as-user.js';
+export { testAdapter } from './test-adapter.js';
+export { testApplication } from './test-application.js';

package/dist/json-paths.d.ts

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

package/dist/json-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-paths.d.ts","sourceRoot":"","sources":["../src/json-paths.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAoC,MAAM,YAAY,CAAA;AAsD3E,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,OAAO,GAAG,IAAI,CAgIrD"}

package/dist/json-paths.js

@@ -0,0 +1,143 @@
+import { defineModel, master } from 'ultimabase';
+import { describe, expect, it } from 'vitest';
+import { started } from './suite.js';
+const M = { as: master };
+const Doc = defineModel({
+    name: 'Doc',
+    fields: (f) => ({
+        name: f.string({ unique: true }),
+        meta: f.json({ optional: true }),
+    }),
+});
+const rows = [
+    {
+        name: 'ada',
+        meta: {
+            author: { name: 'Ada', age: 36 },
+            tags: ['x', 'y'],
+            items: [{ id: 1, kind: 'a' }, { id: 2 }],
+            note: null,
+            score: 5,
+        },
+    },
+    {
+        name: 'bob',
+        meta: { author: { name: 'bob' }, tags: ['y'], items: [], score: 'high' },
+    },
+    { name: 'cy', meta: [1, 2, 3] },
+    { name: 'nil' },
+    { name: 'str', meta: '50%_off' },
+];
+const names = async (where) => (await Doc.findMany({ where, orderBy: { name: 'asc' } }, M)).map((doc) => doc.name);
+/** The rows the path filter keeps, and the rows its `NOT` keeps. */
+const kept = async (meta) => [
+    await names({ meta }),
+    await names({ NOT: { meta } }),
+];
+const contains = (path, arrayContains) => names({ meta: { path, arrayContains } });
+const at = (path, equals) => names({ meta: { path, equals } });
+export function jsonPaths(create) {
+    describe('json paths', () => {
+        started(create, [Doc]);
+        const seeded = async () => {
+            for (const data of rows)
+                await Doc.create({ data }, M);
+        };
+        it('tests equality at a path, unknown where the path is missing', async () => {
+            await seeded();
+            const name = ['author', 'name'];
+            expect(await kept({ path: name, equals: 'Ada' })).toEqual([
+                ['ada'],
+                ['bob'],
+            ]);
+            expect(await kept({ path: name, not: 'Ada' })).toEqual([['bob'], ['ada']]);
+            expect(await names({ meta: { path: ['note'], equals: null } })).toEqual([
+                'ada',
+            ]);
+            expect(await names({ meta: { path: [], equals: [1, 2, 3] } })).toEqual([
+                'cy',
+            ]);
+            expect(await names({ meta: { path: [], equals: '50%_off' } })).toEqual([
+                'str',
+            ]);
+            const author = { path: ['author'], equals: { age: 36, name: 'Ada' } };
+            expect(await names({ meta: author })).toEqual(['ada']);
+        });
+        it('compares numbers by value and strings by code point', async () => {
+            await seeded();
+            const score = ['score'];
+            expect(await kept({ path: score, gt: 3 })).toEqual([['ada'], ['bob']]);
+            expect(await kept({ path: score, lt: 10 })).toEqual([['ada'], ['bob']]);
+            expect(await kept({ path: score, gte: 'high' })).toEqual([
+                ['bob'],
+                ['ada'],
+            ]);
+            expect(await names({ meta: { path: score, lte: 5 } })).toEqual(['ada']);
+            const name = ['author', 'name'];
+            expect(await kept({ path: name, gt: 'Z' })).toEqual([['bob'], ['ada']]);
+        });
+        it('matches strings literally, and insensitively with mode', async () => {
+            await seeded();
+            const name = ['author', 'name'];
+            expect(await names({ meta: { path: [], stringContains: '%_' } })).toEqual(['str']);
+            expect(await names({ meta: { path: name, stringContains: '%' } })).toEqual([]);
+            expect(await names({ meta: { path: name, stringStartsWith: 'a' } })).toEqual([]);
+            const insensitive = { mode: 'insensitive' };
+            expect(await names({
+                meta: { path: name, stringStartsWith: 'a', ...insensitive },
+            })).toEqual(['ada']);
+            expect(await names({
+                meta: { path: name, stringEndsWith: 'B', ...insensitive },
+            })).toEqual(['bob']);
+            expect(await kept({ path: ['score'], stringContains: 'h' })).toEqual([
+                ['bob'],
+                ['ada'],
+            ]);
+        });
+        it('tests arrays with arrayContains, arrayStartsWith and arrayEndsWith', async () => {
+            await seeded();
+            const tags = ['tags'];
+            expect(await contains(tags, 'y')).toEqual(['ada', 'bob']);
+            expect(await contains(tags, ['y', 'x'])).toEqual(['ada']);
+            expect(await contains(tags, [])).toEqual(['ada', 'bob']);
+            expect(await contains(['items'], { id: 1 })).toEqual(['ada']);
+            expect(await contains([], 2)).toEqual(['cy']);
+            expect(await contains([], [[1]])).toEqual([]);
+            expect(await kept({ path: ['author'], arrayContains: 'Ada' })).toEqual([
+                [],
+                ['ada', 'bob'],
+            ]);
+            expect(await names({ meta: { path: tags, arrayStartsWith: 'x' } })).toEqual(['ada']);
+            expect(await names({ meta: { path: tags, arrayEndsWith: 'y' } })).toEqual(['ada', 'bob']);
+            const first = { path: ['items'], arrayStartsWith: { kind: 'a', id: 1 } };
+            expect(await kept(first)).toEqual([['ada'], ['bob']]);
+            expect(await kept({ path: ['items'], arrayEndsWith: { id: 2 } })).toEqual([['ada'], ['bob']]);
+        });
+        it('reads an array index as PostgreSQL does', async () => {
+            await seeded();
+            expect(await at(['items', '0', 'id'], 1)).toEqual(['ada']);
+            expect(await at(['items', '-1', 'id'], 2)).toEqual(['ada']);
+            expect(await at(['0'], 1)).toEqual(['cy']);
+            expect(await at(['-3'], 1)).toEqual(['cy']);
+            expect(await at(['-0'], 1)).toEqual(['cy']);
+            expect(await at([' 1'], 2)).toEqual(['cy']);
+            expect(await at(['+1'], 2)).toEqual(['cy']);
+            for (const key of ['1 ', '-4', '3', '99999999999', 'one']) {
+                expect(await kept({ path: [key], equals: 2 })).toEqual([[], []]);
+            }
+            expect(await at(['tags', '0', 'x'], 'x')).toEqual([]);
+        });
+        it('filters nothing with a path and no operator', async () => {
+            await seeded();
+            const all = ['ada', 'bob', 'cy', 'nil', 'str'];
+            expect(await names({ meta: { path: ['author'] } })).toEqual(all);
+            expect(await names({ meta: { path: ['author'], mode: 'insensitive' } })).toEqual(all);
+            const both = {
+                path: ['author', 'name'],
+                stringStartsWith: 'A',
+                not: 'Ada',
+            };
+            expect(await names({ meta: both })).toEqual([]);
+        });
+    });
+}

package/dist/lists.d.ts

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

package/dist/lists.d.ts.map

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

package/dist/lists.js

@@ -0,0 +1,234 @@
+import { defineModel, master } from 'ultimabase';
+import { describe, expect, it } from 'vitest';
+import { started } from './suite.js';
+const M = { as: master };
+const Article = defineModel({
+    name: 'Article',
+    fields: (f) => ({
+        title: f.string({ unique: true }),
+        tags: f.string({ list: true }),
+        labels: f.string({ list: true, default: ['new'] }),
+        scores: f.number({ list: true }),
+        sizes: f.enumOf(['S', 'M', 'L'], { list: true, default: ['M'] }),
+    }),
+    indexes: [
+        { fields: ['tags'] },
+        { fields: ['scores'] },
+        { fields: ['sizes'] },
+    ],
+});
+/** An update hook: `updateMany` locks the rows and groups their writes. */
+const Shelf = defineModel({
+    name: 'Shelf',
+    fields: (f) => ({ tags: f.string({ list: true }) }),
+}).with({ hooks: { beforeUpdate: () => { } } });
+const titles = async (where) => (await Article.findMany({ where }, M)).map((article) => article.title);
+export function lists(create) {
+    describe('lists', () => {
+        started(create, [Article, Shelf]);
+        it('stores a list, [] when unwritten, and replaces it whole', async () => {
+            const ts = await Article.create({ data: { title: 'ts', tags: ['ts', 'node'] } }, M);
+            expect(ts).toMatchObject({ tags: ['ts', 'node'], labels: ['new'] });
+            expect(await Article.create({ data: { title: 'none', labels: [] } }, M)).toMatchObject({ tags: [], labels: [] });
+            await Article.update({ where: { id: ts.id }, data: { tags: ['go', 'go'] } }, M);
+            expect(await Article.findUnique({ where: { title: 'ts' } }, M)).toMatchObject({ tags: ['go', 'go'], labels: ['new'] });
+        });
+        it('filters a list with has, hasSome and NOT', async () => {
+            for (const [title, tags] of [
+                ['a', ['ts', 'node']],
+                ['b', ['go']],
+                ['c', []],
+            ]) {
+                await Article.create({ data: { title, tags } }, M);
+            }
+            expect(await titles({ tags: { has: 'ts' } })).toEqual(['a']);
+            expect(await titles({ tags: { has: 'rust' } })).toEqual([]);
+            expect(await titles({ tags: { hasSome: ['go', 'node'] } })).toEqual([
+                'a',
+                'b',
+            ]);
+            expect(await titles({ tags: { hasSome: [] } })).toEqual([]);
+            expect(await titles({ NOT: { tags: { has: 'ts' } } })).toEqual(['b', 'c']);
+            expect(await titles({ tags: { has: 'node', hasSome: ['go', 'ts'] } })).toEqual(['a']);
+        });
+        it('filters a list with hasEvery and isEmpty', async () => {
+            for (const [title, tags, scores, sizes] of [
+                ['a', ['ts', 'node', 'ts'], [1, 2], ['S', 'L']],
+                ['b', ['ts'], [2], []],
+                ['c', [], [], ['L']],
+            ]) {
+                await Article.create({ data: { title, tags, scores, sizes } }, M);
+            }
+            expect(await titles({ tags: { hasEvery: ['node', 'ts'] } })).toEqual([
+                'a',
+            ]);
+            expect(await titles({ tags: { hasEvery: ['ts', 'ts'] } })).toEqual([
+                'a',
+                'b',
+            ]);
+            expect(await titles({ tags: { hasEvery: [] } })).toEqual(['a', 'b', 'c']);
+            expect(await titles({ scores: { hasEvery: [2] } })).toEqual(['a', 'b']);
+            expect(await titles({ sizes: { hasEvery: ['L', 'S'] } })).toEqual(['a']);
+            expect(await titles({ tags: { isEmpty: true } })).toEqual(['c']);
+            expect(await titles({ sizes: { isEmpty: false } })).toEqual(['a', 'c']);
+            expect(await titles({ NOT: { scores: { isEmpty: true } } })).toEqual([
+                'a',
+                'b',
+            ]);
+            expect(await titles({
+                tags: { hasEvery: ['ts'], isEmpty: false, has: 'node' },
+            })).toEqual(['a']);
+        });
+        it('updates a list with set, push, pushUnique and remove', async () => {
+            const { id } = await Article.create({ data: { title: 'a', tags: ['a', 'a'], scores: [1, 2, 1] } }, M);
+            const updated = (data) => Article.update({ where: { id }, data }, M);
+            const tags = async (data) => (await updated({ tags: data })).tags;
+            expect(await tags({ pushUnique: 'b' })).toEqual(['a', 'a', 'b']);
+            expect(await tags({ pushUnique: ['a', 'c', 'c', 'd'] })).toEqual([
+                'a',
+                'a',
+                'b',
+                'c',
+                'd',
+            ]);
+            expect(await tags({ push: ['b', 'b'] })).toEqual([
+                'a',
+                'a',
+                'b',
+                'c',
+                'd',
+                'b',
+                'b',
+            ]);
+            expect(await tags({ remove: ['a', 'z'] })).toEqual([
+                'b',
+                'c',
+                'd',
+                'b',
+                'b',
+            ]);
+            expect(await tags({ remove: 'b' })).toEqual(['c', 'd']);
+            expect(await tags({ push: ['"', 'NULL', '{}'] })).toEqual([
+                'c',
+                'd',
+                '"',
+                'NULL',
+                '{}',
+            ]);
+            expect(await tags({ remove: ['NULL', 'c'] })).toEqual(['d', '"', '{}']);
+            expect(await tags({ push: [] })).toEqual(['d', '"', '{}']);
+            expect(await tags({ push: undefined })).toEqual(['d', '"', '{}']);
+            expect(await tags({ set: 'x' })).toEqual(['x']);
+            expect(await updated({
+                scores: { remove: 1 },
+                sizes: { pushUnique: ['L', 'M', 'L'] },
+                labels: { set: [] },
+            })).toMatchObject({ scores: [2], sizes: ['M', 'L'], labels: [] });
+            const upserted = await Article.upsert({
+                where: { id },
+                create: { title: 'b' },
+                update: { tags: { pushUnique: ['x', 'y'] } },
+            }, M);
+            expect(upserted.tags).toEqual(['x', 'y']);
+        });
+        it('updates the lists of many rows, with or without their hooks', async () => {
+            for (const [title, tags] of [
+                ['a', ['x', 'y', 'x']],
+                ['b', []],
+            ]) {
+                await Article.create({ data: { title, tags } }, M);
+                await Shelf.create({ data: { tags } }, M);
+            }
+            for (const model of [Article, Shelf]) {
+                expect(await model.updateMany({ data: { tags: { remove: 'x' } } }, M)).toEqual({ count: 2 });
+                expect(await model.updateMany({ data: { tags: { pushUnique: 'z' } } }, M)).toEqual({ count: 2 });
+            }
+            expect((await Article.findMany({}, M)).map((row) => row.tags)).toEqual([
+                ['y', 'z'],
+                ['z'],
+            ]);
+            expect((await Shelf.findMany({}, M)).map((row) => row.tags)).toEqual([
+                ['y', 'z'],
+                ['z'],
+            ]);
+        });
+        it('refuses a list operation that is not one, or a bad element', async () => {
+            const { id } = await Article.create({ data: { title: 'a', tags: ['a'] } }, M);
+            const takes = 'data.tags takes a list or one of set, push, pushUnique, remove.';
+            const refusals = [
+                [{}, 'INVALID_QUERY', takes],
+                [{ push: 'b', remove: 'a' }, 'INVALID_QUERY', takes],
+                [{ append: 'b' }, 'INVALID_QUERY', takes],
+                [{ push: '' }, 'VALIDATION_FAILED', 'Invalid data.'],
+                [{ pushUnique: ['b', '\0'] }, 'VALIDATION_FAILED', 'Invalid data.'],
+            ];
+            for (const [tags, code, message] of refusals) {
+                await expect(
+                // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- the test sends what the types refuse.
+                Article.update({ where: { id }, data: { tags } }, M)).rejects.toMatchObject({ code, message });
+            }
+            await expect(Article.update({ where: { id }, data: { tags: { push: '' } } }, M)).rejects.toMatchObject({
+                details: {
+                    issues: [
+                        {
+                            path: ['tags'],
+                            message: 'Expected a list of non-empty strings without a NUL or a lone surrogate.',
+                        },
+                    ],
+                },
+            });
+            const pushed = { push: 'a' };
+            const data = { title: 'b', tags: pushed };
+            await expect(Article.create({ data }, M)).rejects.toMatchObject({
+                code: 'VALIDATION_FAILED',
+            });
+            expect(await Article.findUnique({ where: { id } }, M)).toMatchObject({
+                tags: ['a'],
+            });
+        });
+        it('stores and filters numbers and enum values', async () => {
+            const a = await Article.create({ data: { title: 'a', scores: [1.5, -2, 0, 1.5], sizes: ['S', 'L'] } }, M);
+            expect(a).toMatchObject({ scores: [1.5, -2, 0, 1.5], sizes: ['S', 'L'] });
+            expect(await Article.create({ data: { title: 'b', scores: [1e300] } }, M)).toMatchObject({ scores: [1e300], sizes: ['M'] });
+            await Article.create({ data: { title: 'c', sizes: [] } }, M);
+            expect(await titles({ scores: { has: -2 } })).toEqual(['a']);
+            expect(await titles({ scores: { has: 2 } })).toEqual([]);
+            expect(await titles({ scores: { hasSome: [0, 1e300] } })).toEqual([
+                'a',
+                'b',
+            ]);
+            expect(await titles({ sizes: { has: 'M' } })).toEqual(['b']);
+            expect(await titles({ sizes: { hasSome: ['S', 'M'] } })).toEqual([
+                'a',
+                'b',
+            ]);
+            expect(await titles({ NOT: { sizes: { has: 'S' } } })).toEqual(['b', 'c']);
+            await Article.update({ where: { id: a.id }, data: { scores: [], sizes: ['L', 'L'] } }, M);
+            expect(await Article.findUnique({ where: { title: 'a' } }, M)).toMatchObject({ scores: [], sizes: ['L', 'L'] });
+        });
+        it('stores any well-formed text as an element', async () => {
+            const tags = ['"', '\\', 'a,b', '{}', ' ', 'NULL', 'é😀'];
+            await Article.create({ data: { title: 'odd', tags } }, M);
+            expect(await Article.findUnique({ where: { title: 'odd' } }, M)).toMatchObject({ tags });
+            for (const tag of tags) {
+                expect(await titles({ tags: { has: tag } })).toEqual(['odd']);
+            }
+            expect(await titles({ tags: { hasSome: ['null'] } })).toEqual([]);
+        });
+        it('refuses an empty element, a NUL or a lone surrogate', async () => {
+            for (const tags of [[''], ['a\0'], ['\uD800']]) {
+                await expect(Article.create({ data: { title: 'bad', tags } }, M)).rejects.toMatchObject({ code: 'VALIDATION_FAILED' });
+            }
+            for (const where of [
+                { tags: { has: '' } },
+                { tags: { hasSome: ['\0'] } },
+                { tags: { hasEvery: [''] } },
+            ]) {
+                await expect(Article.findMany({ where }, M)).rejects.toMatchObject({
+                    code: 'INVALID_QUERY',
+                });
+            }
+            expect(await Article.count({}, M)).toBe(0);
+        });
+    });
+}

package/dist/nested.d.ts

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

package/dist/nested.d.ts.map

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