@ultimabase/testing 0.0.0-stage → 0.1.1

package/dist/nested.js

@@ -0,0 +1,152 @@
+import { defineModel, master } from 'ultimabase';
+import { describe, expect, it } from 'vitest';
+import { started } from './suite.js';
+const M = { as: master };
+const Blogger = defineModel({
+    name: 'Blogger',
+    fields: (f) => ({
+        name: f.string(),
+        posts: f.many(() => Post),
+        card: f.one(() => Card, { optional: true }),
+    }),
+});
+/** Holds the key of its one-to-one with a blogger (D-37). */
+const Card = defineModel({
+    name: 'Card',
+    fields: (f) => ({
+        bio: f.string(),
+        blogger: f.one(() => Blogger, { onDelete: 'cascade' }),
+    }),
+});
+const Post = defineModel({
+    name: 'Post',
+    fields: (f) => ({
+        title: f.string({ unique: true }),
+        blogger: f.one(() => Blogger, { onDelete: 'cascade' }),
+        comments: f.many(() => Comment),
+        topics: f.many(() => Topic),
+    }),
+});
+const Comment = defineModel({
+    name: 'Comment',
+    fields: (f) => ({
+        body: f.string(),
+        post: f.one(() => Post, { onDelete: 'cascade' }),
+    }),
+});
+const Topic = defineModel({
+    name: 'Topic',
+    fields: (f) => ({ label: f.string(), posts: f.many(() => Post) }),
+});
+export function nested(create) {
+    describe('nested creation', () => {
+        started(create, [Blogger, Card, Post, Comment, Topic]);
+        it('creates rows three levels deep with the one it writes', async () => {
+            const topic = await Topic.create({ data: { label: 'ts' } }, M);
+            const blogger = await Blogger.create({
+                data: {
+                    name: 'Ada',
+                    card: { create: { bio: 'engines' } },
+                    posts: {
+                        create: [
+                            {
+                                title: 'First',
+                                comments: { create: [{ body: 'a' }, { body: 'b' }] },
+                                topics: {
+                                    connect: [{ id: topic.id }],
+                                    create: [{ label: 'go' }],
+                                },
+                            },
+                            { title: 'Second' },
+                        ],
+                    },
+                },
+                include: {
+                    card: true,
+                    posts: { include: { comments: true, topics: true } },
+                },
+            }, M);
+            expect(blogger).toMatchObject({
+                name: 'Ada',
+                card: { bio: 'engines' },
+                posts: [
+                    {
+                        title: 'First',
+                        comments: [{ body: 'a' }, { body: 'b' }],
+                        topics: [{ label: 'ts' }, { label: 'go' }],
+                    },
+                    { title: 'Second', comments: [], topics: [] },
+                ],
+            });
+            expect(await Comment.count({}, M)).toBe(2);
+            expect(await Topic.count({}, M)).toBe(2);
+        });
+        it('creates the row a stored one links to', async () => {
+            const comment = await Comment.create({
+                data: {
+                    body: 'hello',
+                    post: {
+                        create: { title: 'Root', blogger: { create: { name: 'Bo' } } },
+                    },
+                },
+                include: { post: { include: { blogger: true } } },
+            }, M);
+            expect(comment).toMatchObject({
+                post: { title: 'Root', blogger: { name: 'Bo' } },
+            });
+        });
+        it('creates rows in an update, beside connect and disconnect', async () => {
+            const blogger = await Blogger.create({ data: { name: 'Ada' } }, M);
+            const old = await Topic.create({ data: { label: 'old' } }, M);
+            const post = await Post.create({
+                data: {
+                    title: 'Kept',
+                    blogger: { connect: { id: blogger.id } },
+                    topics: { connect: [{ id: old.id }] },
+                },
+            }, M);
+            const updated = await Post.update({
+                where: { id: post.id },
+                data: {
+                    comments: { create: [{ body: 'late' }] },
+                    topics: {
+                        disconnect: [{ id: old.id }],
+                        create: [{ label: 'new' }],
+                    },
+                },
+                include: { comments: true, topics: true },
+            }, M);
+            expect(updated).toMatchObject({
+                comments: [{ body: 'late' }],
+                topics: [{ label: 'new' }],
+            });
+            const card = await Blogger.update({
+                where: { id: blogger.id },
+                data: { card: { create: { bio: 'later' } } },
+                include: { card: true },
+            }, M);
+            expect(card).toMatchObject({ card: { bio: 'later' } });
+        });
+        it('writes nothing when a row deep down fails', async () => {
+            const blogger = await Blogger.create({ data: { name: 'Ada' } }, M);
+            await Post.create({
+                data: { title: 'Taken', blogger: { connect: { id: blogger.id } } },
+            }, M);
+            const failed = Blogger.create({
+                data: {
+                    name: 'Bo',
+                    posts: {
+                        create: [
+                            { title: 'Fresh', comments: { create: [{ body: 'x' }] } },
+                            { title: 'Taken' },
+                        ],
+                    },
+                },
+            }, M);
+            await expect(failed).rejects.toMatchObject({ code: 'UNIQUE_VIOLATION' });
+            expect(await Blogger.count({}, M)).toBe(1);
+            expect(await Post.count({}, M)).toBe(1);
+            expect(await Comment.count({}, M)).toBe(0);
+        });
+    });
+}

package/dist/numbers.d.ts

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

package/dist/numbers.d.ts.map

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

package/dist/numbers.js

@@ -0,0 +1,92 @@
+import { defineModel, master } from 'ultimabase';
+import { describe, expect, it } from 'vitest';
+import { started } from './suite.js';
+const M = { as: master };
+const Tally = defineModel({
+    name: 'Tally',
+    fields: (f) => ({
+        count: f.number({ integer: true, optional: true }),
+        ratio: f.number({ optional: true }),
+        points: f.number({ integer: true, list: true }),
+    }),
+});
+/** An update hook: `updateMany` locks the rows and groups their writes. */
+const Stock = defineModel({
+    name: 'Stock',
+    fields: (f) => ({ level: f.number({ integer: true }) }),
+}).with({ hooks: { beforeUpdate: () => { } } });
+const whole = 'Expected a whole number from -2,147,483,648 to 2,147,483,647.';
+const update = async (data, from) => {
+    const { id } = await Tally.create({ data: from }, M);
+    return Tally.update({ where: { id }, data }, M);
+};
+export function numbers(create) {
+    describe('numbers', () => {
+        started(create, [Tally, Stock]);
+        it('stores and filters whole numbers in 32 bits', async () => {
+            const points = [-2_147_483_648, 0, 2_147_483_647];
+            await Tally.create({ data: { count: 2_147_483_647, points } }, M);
+            await Tally.create({ data: { count: -3, points: [1] } }, M);
+            const found = await Tally.findMany({ where: { count: { gt: 0 }, points: { has: 0 } } }, M);
+            expect(found).toMatchObject([{ count: 2_147_483_647, points }]);
+            expect(await Tally.count({ where: { points: { hasSome: [1, 5] } } }, M)).toBe(1);
+        });
+        it('computes each operation on the stored number', async () => {
+            expect(await update({ count: { increment: 3 } }, { count: 4 })).toMatchObject({ count: 7 });
+            expect(await update({ count: { decrement: 2 } }, { count: null })).toMatchObject({ count: -2 });
+            expect(await update({ count: { divide: 2 } }, { count: -7 })).toMatchObject({ count: -3 });
+            expect(await update({ ratio: { multiply: 1.5 } }, { ratio: 3 })).toMatchObject({ ratio: 4.5 });
+            expect(await update({ ratio: { divide: 4 } }, { ratio: 3 })).toMatchObject({ ratio: 0.75 });
+        });
+        it('computes updateMany on each row, with or without its hooks', async () => {
+            for (const count of [1, null, 5]) {
+                await Tally.create({ data: { count } }, M);
+            }
+            const data = { count: { increment: 2 } };
+            expect(await Tally.updateMany({ data }, M)).toEqual({ count: 3 });
+            const counts = async () => (await Tally.findMany({}, M)).map((row) => row.count);
+            expect(await counts()).toEqual([3, 2, 7]);
+            await Tally.create({ data: { count: 2_147_483_647 } }, M);
+            await expect(Tally.updateMany({ data }, M)).rejects.toMatchObject({
+                code: 'VALIDATION_FAILED',
+                details: { issues: [{ path: ['count'], message: whole }] },
+            });
+            expect(await counts()).toEqual([3, 2, 7, 2_147_483_647]);
+            for (const level of [1, 2])
+                await Stock.create({ data: { level } }, M);
+            const doubled = { level: { multiply: 2 } };
+            expect(await Stock.updateMany({ data: doubled }, M)).toEqual({
+                count: 2,
+            });
+            const levels = await Stock.findMany({}, M);
+            expect(levels.map((row) => row.level)).toEqual([2, 4]);
+        });
+        it('refuses a result out of bounds, and keeps the row', async () => {
+            for (const [data, from, path, message] of [
+                [{ count: { increment: 1 } }, { count: 2_147_483_647 }, 'count', whole],
+                [
+                    { count: { multiply: -2 } },
+                    { count: -1_073_741_825 },
+                    'count',
+                    whole,
+                ],
+                [
+                    { ratio: { multiply: 10 } },
+                    { ratio: 1e308 },
+                    'ratio',
+                    'Expected a finite number.',
+                ],
+            ]) {
+                await expect(update(data, from)).rejects.toMatchObject({
+                    code: 'VALIDATION_FAILED',
+                    details: { issues: [{ path: [path], message }] },
+                });
+            }
+            expect((await Tally.findMany({}, M)).map(({ count, ratio }) => [count, ratio])).toEqual([
+                [2_147_483_647, null],
+                [-1_073_741_825, null],
+                [null, 1e308],
+            ]);
+        });
+    });
+}

package/dist/projection.d.ts

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

package/dist/projection.d.ts.map

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

package/dist/projection.js

@@ -0,0 +1,53 @@
+import { defineModel, master } from 'ultimabase';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { started } from './suite.js';
+const M = { as: master };
+const Writer = defineModel({
+    name: 'Writer',
+    fields: (f) => ({ name: f.string(), notes: f.many(() => Note) }),
+});
+const Note = defineModel({
+    name: 'Note',
+    fields: (f) => ({
+        title: f.string(),
+        body: f.string(),
+        writer: f.one(() => Writer),
+    }),
+});
+export function projection(create) {
+    describe('projection', () => {
+        const database = started(create, [Writer, Note]);
+        let ada;
+        beforeEach(async () => {
+            ada = (await Writer.create({ data: { name: 'Ada' } }, M)).id;
+            await Note.create({
+                data: {
+                    title: 'one',
+                    body: 'long',
+                    writer: { connect: { id: ada } },
+                },
+            }, M);
+        });
+        it('reads the fields a read names, in a relation too', async () => {
+            const [note] = await database().find({
+                model: 'Note',
+                fields: ['title'],
+                include: { writer: { fields: ['name'] } },
+            });
+            expect(note).toEqual({
+                id: note?.id,
+                title: 'one',
+                writer: { id: ada, name: 'Ada' },
+            });
+            const [whole] = await database().find({ model: 'Note' });
+            expect(Object.keys(whole ?? {}).toSorted()).toEqual([
+                'body',
+                'createdAt',
+                'id',
+                'title',
+                'updatedAt',
+                'writer',
+            ]);
+        });
+    });
+}

package/dist/reads.d.ts

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

package/dist/reads.d.ts.map

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

package/dist/reads.js

@@ -0,0 +1,312 @@
+import { defineModel, master } from 'ultimabase';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { started } from './suite.js';
+const M = { as: master };
+const Author = defineModel({
+    name: 'Author',
+    fields: (f) => ({
+        name: f.string({ unique: true }),
+        level: f.enumOf(['junior', 'senior'], { default: 'junior' }),
+        books: f.many(() => Book),
+        profile: f.one(() => Profile, { optional: true }),
+    }),
+});
+const Profile = defineModel({
+    name: 'Profile',
+    fields: (f) => ({ bio: f.string(), author: f.one(() => Author) }),
+});
+const Book = defineModel({
+    name: 'Book',
+    fields: (f) => ({
+        title: f.string(),
+        pages: f.number({ optional: true }),
+        published: f.boolean({ default: false }),
+        meta: f.json({ optional: true }),
+        releasedAt: f.dateTime({ optional: true }),
+        author: f.one(() => Author),
+        tags: f.many(() => Tag),
+    }),
+    indexes: [{ fields: ['title', 'author'], unique: true }],
+});
+const Tag = defineModel({
+    name: 'Tag',
+    fields: (f) => ({
+        label: f.string({ unique: true }),
+        books: f.many(() => Book),
+    }),
+});
+// Asymmetric matchers are typed `any`.
+const aDate = expect.any(Date);
+const day = (date) => new Date(Date.UTC(2020, 0, date));
+/** Ada wrote Analysis and Engines and has a profile; Grace wrote Compilers. */
+async function seed() {
+    const ada = await Author.create({ data: { name: 'Ada' } }, M);
+    const grace = await Author.create({ data: { name: 'Grace', level: 'senior' } }, M);
+    await Profile.create({ data: { bio: 'Poet', author: { connect: { id: ada.id } } } }, M);
+    const math = await Tag.create({ data: { label: 'math' } }, M);
+    const art = await Tag.create({ data: { label: 'art' } }, M);
+    const books = [
+        {
+            title: 'Analysis',
+            pages: 300,
+            published: true,
+            author: ada,
+            tags: [math],
+        },
+        { title: 'Engines', pages: 120, author: ada, tags: [] },
+        { title: 'Compilers', pages: null, author: grace, tags: [math, art] },
+    ];
+    for (const [index, { author, tags, ...data }] of books.entries()) {
+        await Book.create({
+            data: {
+                ...data,
+                meta: { rank: index, kind: 'book' },
+                releasedAt: day(index + 1),
+                author: { connect: { id: author.id } },
+                tags: { connect: tags.map(({ id }) => ({ id })) },
+            },
+        }, M);
+    }
+    return { ada: ada.id, grace: grace.id };
+}
+const titles = async (where) => (await Book.findMany({ where }, M)).map((book) => book.title);
+const names = async (where) => (await Author.findMany({ where }, M)).map((author) => author.name);
+const ordered = async (orderBy) => (await Book.findMany({ orderBy }, M)).map((book) => book.title);
+const page = async (args) => (await Book.findMany({ orderBy: { title: 'asc' }, ...args }, M)).map((book) => book.title);
+export function reads(create) {
+    describe('reads', () => {
+        started(create, [Author, Profile, Book, Tag]);
+        let authors;
+        beforeEach(async () => {
+            authors = await seed();
+        });
+        it('compares strings with every operator, case included', async () => {
+            expect(await titles({ title: 'Engines' })).toEqual(['Engines']);
+            expect(await titles({ title: { not: 'Engines' } })).toEqual([
+                'Analysis',
+                'Compilers',
+            ]);
+            expect(await titles({ title: { in: ['Compilers', 'Nope'] } })).toEqual([
+                'Compilers',
+            ]);
+            expect(await titles({ title: { notIn: ['Analysis'] } })).toEqual([
+                'Engines',
+                'Compilers',
+            ]);
+            expect(await titles({ title: { notIn: [] } })).toHaveLength(3);
+            expect(await titles({ title: { in: [] } })).toEqual([]);
+            expect(await titles({ title: { contains: 'gin' } })).toEqual(['Engines']);
+            expect(await titles({ title: { contains: 'GIN' } })).toEqual([]);
+            expect(await titles({ title: { startsWith: 'C' } })).toEqual([
+                'Compilers',
+            ]);
+            expect(await titles({ title: { endsWith: 'sis' } })).toEqual(['Analysis']);
+            // `%` and `_` are characters, not patterns.
+            expect(await titles({ title: { contains: '%' } })).toEqual([]);
+            expect(await titles({ title: { startsWith: '_' } })).toEqual([]);
+        });
+        it('matches part of an id as a string', async () => {
+            // An id begins with its time, shared by rows created together.
+            const id = authors.ada;
+            expect(await names({ id: { startsWith: id.slice(0, 30) } })).toEqual([
+                'Ada',
+            ]);
+            expect(await names({ id: { contains: id.slice(24, 32) } })).toEqual([
+                'Ada',
+            ]);
+            expect(await names({ id: { endsWith: id.slice(24) } })).toEqual(['Ada']);
+            expect(await names({ id: { contains: 'Z' } })).toEqual([]);
+        });
+        it('compares numbers, dates, booleans, enums and json', async () => {
+            expect(await titles({ pages: { lt: 300 } })).toEqual(['Engines']);
+            expect(await titles({ pages: { lte: 300 } })).toEqual([
+                'Analysis',
+                'Engines',
+            ]);
+            expect(await titles({ pages: { gt: 120 } })).toEqual(['Analysis']);
+            expect(await titles({ pages: { gte: 120 } })).toEqual([
+                'Analysis',
+                'Engines',
+            ]);
+            expect(await titles({ releasedAt: { gt: day(1) } })).toEqual([
+                'Engines',
+                'Compilers',
+            ]);
+            expect(await titles({ releasedAt: day(2) })).toEqual(['Engines']);
+            expect(await titles({ published: true })).toEqual(['Analysis']);
+            expect(await titles({ author: { is: { level: { in: ['senior'] } } } })).toEqual(['Compilers']);
+            // A json value equals another of the same content, keys in any order.
+            expect(await titles({ meta: { equals: { kind: 'book', rank: 1 } } })).toEqual(['Engines']);
+        });
+        it('takes -0 for 0 and gives it back as 0, in a number and in json, as PostgreSQL does', async () => {
+            const { id } = await Book.create({
+                data: {
+                    title: 'Zero',
+                    pages: -0,
+                    meta: { rank: -0, list: [-0, 1] },
+                    author: { connect: { id: authors.grace } },
+                },
+            }, M);
+            expect(await titles({ pages: 0 })).toEqual(['Zero']);
+            expect(await titles({ pages: { in: [0] } })).toEqual(['Zero']);
+            expect(await titles({ pages: { not: -0 } })).toEqual([
+                'Analysis',
+                'Engines',
+            ]);
+            expect(await titles({ meta: { equals: { list: [0, 1], rank: 0 } } })).toEqual(['Zero']);
+            // A json array keeps its order and its length.
+            expect(await titles({ meta: { equals: { rank: 0, list: [1, 0] } } })).toEqual([]);
+            expect(await titles({ meta: { equals: { rank: 0, list: [0] } } })).toEqual([]);
+            expect(await titles({ meta: { equals: { kind: 'book', rank: -0 } } })).toEqual(['Analysis']);
+            // It comes back as 0, in json as in a number.
+            const read = { where: { id }, select: { pages: true, meta: true } };
+            expect(await Book.findUnique(read, M)).toStrictEqual({
+                pages: 0,
+                meta: { rank: 0, list: [0, 1] },
+            });
+            await Book.update({ where: { id }, data: { meta: -0 } }, M);
+            expect(await Book.findUnique(read, M)).toStrictEqual({
+                pages: 0,
+                meta: 0,
+            });
+        });
+        it('treats null as a value, and as unknown in a comparison', async () => {
+            expect(await titles({ pages: null })).toEqual(['Compilers']);
+            expect(await titles({ pages: { not: null } })).toEqual([
+                'Analysis',
+                'Engines',
+            ]);
+            // `null` is not below 200, nor not below it, as in SQL.
+            expect(await titles({ NOT: { pages: { lt: 200 } } })).toEqual([
+                'Analysis',
+            ]);
+            expect(await titles({ pages: { not: 300 } })).toEqual(['Engines']);
+        });
+        it('combines AND, OR and NOT', async () => {
+            expect(await titles({
+                OR: [{ pages: { lt: 200 } }, { title: 'Analysis' }],
+                NOT: [{ title: 'Engines' }],
+            })).toEqual(['Analysis']);
+            expect(await titles({ AND: [{ pages: { gt: 100 } }, { published: false }] })).toEqual(['Engines']);
+            expect(await titles({ OR: [] })).toEqual([]);
+        });
+        it('filters through a one relation', async () => {
+            expect(await titles({ author: { is: { name: 'Grace' } } })).toEqual([
+                'Compilers',
+            ]);
+            expect(await titles({ author: { isNot: { name: 'Grace' } } })).toEqual([
+                'Analysis',
+                'Engines',
+            ]);
+            expect(await names({ profile: { is: null } })).toEqual(['Grace']);
+            expect(await names({ profile: { isNot: null } })).toEqual(['Ada']);
+            expect(await names({ profile: { is: { bio: 'Poet' } } })).toEqual(['Ada']);
+        });
+        it('filters through a many relation', async () => {
+            expect(await titles({ tags: { some: { label: 'art' } } })).toEqual([
+                'Compilers',
+            ]);
+            expect(await titles({ tags: { none: { label: 'math' } } })).toEqual([
+                'Engines',
+            ]);
+            // Every tag of a book without tags is art.
+            expect(await titles({ tags: { every: { label: 'art' } } })).toEqual([
+                'Engines',
+            ]);
+            // Grace's book has no pages: unknown is not false, as in SQL.
+            expect(await names({ books: { every: { pages: { gt: 200 } } } })).toEqual(['Grace']);
+        });
+        it('orders by several fields, nulls last ascending', async () => {
+            expect(await ordered({ pages: 'asc' })).toEqual([
+                'Engines',
+                'Analysis',
+                'Compilers',
+            ]);
+            expect(await ordered({ pages: 'desc' })).toEqual([
+                'Compilers',
+                'Analysis',
+                'Engines',
+            ]);
+            expect(await ordered([{ published: 'asc' }, { title: 'desc' }])).toEqual([
+                'Engines',
+                'Compilers',
+                'Analysis',
+            ]);
+            // Without an order, rows come in the order they were created.
+            expect(await ordered([])).toEqual(['Analysis', 'Engines', 'Compilers']);
+        });
+        it('orders strings by code point, as the bytes of their UTF-8', async () => {
+            // UTF-16 puts U+FF5A above U+1F600, which is above it as a code point.
+            await Tag.create({ data: { label: '😀' } }, M);
+            await Tag.create({ data: { label: 'ｚ' } }, M);
+            const tags = await Tag.findMany({ orderBy: { label: 'asc' } }, M);
+            expect(tags.map(({ label }) => label)).toEqual([
+                'art',
+                'math',
+                'ｚ',
+                '😀',
+            ]);
+        });
+        it('skips, takes and starts at a cursor, forwards and backwards', async () => {
+            expect(await page({ skip: 1, take: 1 })).toEqual(['Compilers']);
+            expect(await page({ take: -2 })).toEqual(['Compilers', 'Engines']);
+            // A cursor is any unique key, here the index on title and author.
+            const cursor = { title: 'Compilers', author: authors.grace };
+            expect(await page({ cursor, take: 2 })).toEqual(['Compilers', 'Engines']);
+            expect(await page({ cursor, skip: 1 })).toEqual(['Engines']);
+            expect(await page({ cursor, take: -2 })).toEqual([
+                'Analysis',
+                'Compilers',
+            ]);
+        });
+        it('includes relations, filtered, ordered and paged, at any depth', async () => {
+            const ada = await Author.findUnique({
+                where: { name: 'Ada' },
+                include: {
+                    profile: true,
+                    books: {
+                        where: { pages: { gt: 100 } },
+                        orderBy: { pages: 'asc' },
+                        take: 1,
+                        include: { tags: { orderBy: { label: 'asc' } } },
+                    },
+                },
+            }, M);
+            expect(ada).toMatchObject({
+                profile: { bio: 'Poet' },
+                // An array matches only an array of the same length.
+                books: [{ title: 'Engines', tags: [] }],
+            });
+            const compilers = await Book.findFirst({
+                where: { title: 'Compilers' },
+                select: {
+                    title: true,
+                    author: { select: { name: true, profile: true } },
+                    tags: { select: { label: true }, orderBy: { label: 'asc' } },
+                },
+            }, M);
+            expect(compilers).toEqual({
+                title: 'Compilers',
+                author: { name: 'Grace', profile: null },
+                tags: [{ label: 'art' }, { label: 'math' }],
+            });
+        });
+        it('finds a row by a unique index', async () => {
+            const engines = await Book.findUnique({ where: { title: 'Engines', author: authors.ada } }, M);
+            expect(engines).toMatchObject({ title: 'Engines', pages: 120 });
+            expect(await Book.findUnique({ where: { id: 'missing' } }, M)).toBeNull();
+        });
+        it('returns each type as written, and counts', async () => {
+            const analysis = await Book.findFirst({ where: { title: 'Analysis' } }, M);
+            expect(analysis).toMatchObject({
+                pages: 300,
+                published: true,
+                meta: { rank: 0, kind: 'book' },
+                releasedAt: day(1),
+                createdAt: aDate,
+            });
+            expect(await Book.count({}, M)).toBe(3);
+            expect(await Book.count({ where: { tags: { some: {} } } }, M)).toBe(2);
+        });
+    });
+}

package/dist/relation-filters.d.ts

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

package/dist/relation-filters.d.ts.map

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