@ultimabase/testing 0.0.0-stage → 0.1.1

package/dist/test-adapter.js

@@ -0,0 +1,55 @@
+import { describe } from 'vitest';
+import { aggregates } from './aggregates.js';
+import { bulkReturns } from './bulk-returns.js';
+import { calendarDays } from './days.js';
+import { cases } from './cases.js';
+import { cascades } from './cascades.js';
+import { counts } from './counts.js';
+import { decimals } from './decimals.js';
+import { distincts } from './distincts.js';
+import { feeds } from './feeds.js';
+import { groups } from './groups.js';
+import { jsonPaths } from './json-paths.js';
+import { lists } from './lists.js';
+import { nested } from './nested.js';
+import { numbers } from './numbers.js';
+import { projection } from './projection.js';
+import { reads } from './reads.js';
+import { relationFilters } from './relation-filters.js';
+import { roundTrips } from './round-trips.js';
+import { searches } from './searches.js';
+import { sorts } from './sorts.js';
+import { transactions } from './transactions.js';
+import { virtuals } from './virtuals.js';
+import { writes } from './writes.js';
+/**
+ * Runs the contract against the adapters `create` returns, one per test, each
+ * on an empty database.
+ */
+export function testAdapter(name, create, options) {
+    describe(`the ${name} adapter`, () => {
+        reads(create);
+        cases(create);
+        writes(create);
+        cascades(create);
+        lists(create);
+        jsonPaths(create);
+        nested(create);
+        numbers(create);
+        bulkReturns(create);
+        decimals(create);
+        calendarDays(create);
+        counts(create);
+        relationFilters(create);
+        virtuals(create);
+        aggregates(create);
+        groups(create);
+        distincts(create);
+        sorts(create);
+        searches(create);
+        projection(create);
+        transactions(create);
+        feeds(create);
+        roundTrips(create, options.roundTrips);
+    });
+}

package/dist/test-application.d.ts

@@ -0,0 +1,17 @@
+export type TestApplication = {
+    /** The HTTP server's address during a test, such as `http://localhost:54321`. */
+    readonly url: string;
+};
+export type TestOptions = {
+    /**
+     * `'declared'` runs the tests on the application's own database, in
+     * tables of the file's own, instead of a new `memory()`.
+     */
+    readonly database?: 'declared';
+};
+/**
+ * Runs `app`, the value `defineApp` returned, around each test of the file
+ * that calls it.
+ */
+export declare function testApplication(app: object, options?: TestOptions): TestApplication;
+//# sourceMappingURL=test-application.d.ts.map

package/dist/test-application.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-application.d.ts","sourceRoot":"","sources":["../src/test-application.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,eAAe,GAAG;IAC7B,iFAAiF;IACjF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACpB,CAAA;AAwBD,MAAM,MAAM,WAAW,GAAG;IACzB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,UAAU,CAAA;CAC9B,CAAA;AAgBD;;;GAGG;AACH,wBAAgB,eAAe,CAC9B,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,WAAgB,GACvB,eAAe,CA2BjB"}

package/dist/test-application.js

@@ -0,0 +1,68 @@
+import { memory } from 'ultimabase';
+import { quietRuns, runningApi, scratchOf } from 'ultimabase/internal';
+import { afterEach, beforeAll, beforeEach } from 'vitest';
+/** Starts `run` with `PORT` set to `0`, then puts `PORT` back. */
+async function onFreePort(run) {
+    const port = process.env['PORT'];
+    process.env['PORT'] = '0';
+    try {
+        await run.start();
+    }
+    finally {
+        if (port === undefined)
+            delete process.env['PORT'];
+        else
+            process.env['PORT'] = port;
+    }
+}
+function urlOf(api) {
+    if (typeof api !== 'object' || api === null || !('url' in api)) {
+        return undefined;
+    }
+    const { url } = api;
+    if (typeof url !== 'function')
+        return undefined;
+    const value = Reflect.apply(url, api, []);
+    return typeof value === 'string' ? value : undefined;
+}
+/** The declared database, which gives each test file empty tables. */
+function declared(database) {
+    // A database that starts empty every time, as memory(), needs nothing.
+    if (database.migrations === undefined)
+        return () => database;
+    const scratch = scratchOf(database);
+    if (scratch === undefined) {
+        throw new TypeError("testApplication runs on the declared database when it gives a test file tables of its own, as postgres() does; this one does not: remove { database: 'declared' }.");
+    }
+    beforeAll(() => scratch().drop);
+    return () => database;
+}
+/**
+ * Runs `app`, the value `defineApp` returned, around each test of the file
+ * that calls it.
+ */
+export function testApplication(app, options = {}) {
+    const runs = quietRuns(app);
+    if (runs === undefined) {
+        throw new TypeError('testApplication takes the value defineApp returned.');
+    }
+    const database = options.database === 'declared' ? declared(runs.declared) : memory;
+    let run;
+    beforeEach(async () => {
+        run = runs.on(database());
+        await onFreePort(run);
+    });
+    afterEach(async () => {
+        await run?.stop();
+        run = undefined;
+    });
+    return {
+        get url() {
+            const url = run === undefined ? undefined : urlOf(runningApi('http'));
+            if (url === undefined) {
+                throw new Error('url is the address of httpPlugin(), read during a test: add httpPlugin() to the application.');
+            }
+            return url;
+        },
+    };
+}

package/dist/transactions.d.ts

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

package/dist/transactions.d.ts.map

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

package/dist/transactions.js

@@ -0,0 +1,61 @@
+import { defineModel, master, transaction } from 'ultimabase';
+import { describe, expect, it } from 'vitest';
+import { started } from './suite.js';
+const M = { as: master };
+const Account = defineModel({
+    name: 'Account',
+    fields: (f) => ({ name: f.string({ unique: true }) }),
+});
+const open = async (name) => Account.create({ data: { name } }, M);
+const names = async () => (await Account.findMany({ orderBy: { name: 'asc' } }, M)).map((account) => account.name);
+export function transactions(create) {
+    describe('transactions', () => {
+        started(create, [Account]);
+        it('commits every write together', async () => {
+            await transaction(async () => {
+                await open('bob');
+                await open('cy');
+            });
+            expect(await names()).toEqual(['bob', 'cy']);
+        });
+        it('reads its own writes', async () => {
+            const seen = await transaction(async () => {
+                await open('bob');
+                return names();
+            });
+            expect(seen).toEqual(['bob']);
+        });
+        it('rolls every write back when the callback throws', async () => {
+            await open('ann');
+            const failed = transaction(async () => {
+                await open('bob');
+                throw new Error('Stop.');
+            });
+            await expect(failed).rejects.toThrow('Stop.');
+            expect(await names()).toEqual(['ann']);
+        });
+        it('rolls back after a failed write, even one the callback catches', async () => {
+            const failed = transaction(async () => {
+                await open('bob');
+                await open('bob').catch(() => undefined);
+            });
+            await expect(failed).rejects.toMatchObject({ code: 'UNIQUE_VIOLATION' });
+            expect(await names()).toEqual([]);
+        });
+        it('shows its writes to no one else before the commit', async () => {
+            const written = Promise.withResolvers();
+            const resumed = Promise.withResolvers();
+            const running = transaction(async () => {
+                await open('bob');
+                written.resolve();
+                await resumed.promise;
+            });
+            await written.promise;
+            // This read runs outside the transaction.
+            expect(await names()).toEqual([]);
+            resumed.resolve();
+            await running;
+            expect(await names()).toEqual(['bob']);
+        });
+    });
+}

package/dist/virtuals.d.ts

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

package/dist/virtuals.d.ts.map

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

package/dist/virtuals.js

@@ -0,0 +1,135 @@
+import { allow, defineModel, master } from 'ultimabase';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { started } from './suite.js';
+const M = { as: master };
+/** A Standard Schema of what `check` accepts, as zod would type it. */
+function schema(check) {
+    const validate = (value) => check(value) ? { value } : { issues: [{ message: 'Invalid.' }] };
+    return { '~standard': { version: 1, vendor: 'testing', validate } };
+}
+const text = schema((value) => typeof value === 'string');
+const width = schema((value) => Number.isInteger(Reflect.get(Object(value), 'width')));
+const first = schema((value) => Number.isInteger(Reflect.get(Object(value), 'first')));
+const Shelf = defineModel({
+    name: 'Shelf',
+    fields: (f) => ({
+        name: f.string(),
+        books: f.many(() => Book),
+        label: f.virtual(text, { needs: ['name'] }),
+        padded: f.virtual(text, { input: width, needs: ['name'] }),
+        latest: f.virtual(() => [Book], { input: first }),
+    }),
+}).with({
+    access: allow.public,
+    virtuals: {
+        label: { run: ({ record }) => record.name.toUpperCase() },
+        padded: {
+            run: ({ input, record }) => record.name.padEnd(input.width, '.'),
+        },
+        latest: {
+            runMany: async ({ input, records }) => {
+                const ids = records.map((record) => record.id);
+                const books = await Book.findMany({
+                    where: { shelf: { is: { id: { in: ids } } } },
+                    orderBy: { title: 'desc' },
+                    include: { shelf: { select: { id: true } } },
+                }, M);
+                return records.map((record) => books
+                    .filter((book) => book.shelf?.id === record.id)
+                    .slice(0, input.first));
+            },
+        },
+    },
+});
+const Book = defineModel({
+    name: 'Book',
+    fields: (f) => ({
+        title: f.string(),
+        shelf: f.one(() => Shelf, { optional: true }),
+        tags: f.many(() => Tag),
+    }),
+}).with({ access: allow.public });
+const Tag = defineModel({
+    name: 'Tag',
+    fields: (f) => ({ name: f.string(), books: f.many(() => Book) }),
+}).with({ access: allow.public });
+export function virtuals(create) {
+    describe('virtual fields', () => {
+        started(create, [Shelf, Book, Tag]);
+        beforeEach(async () => {
+            await Shelf.create({
+                data: {
+                    name: 'oak',
+                    books: {
+                        create: [
+                            { title: 'A', tags: { create: [{ name: 'old' }] } },
+                            { title: 'B' },
+                            { title: 'C', tags: { create: [{ name: 'new' }] } },
+                        ],
+                    },
+                },
+            }, M);
+            await Shelf.create({ data: { name: 'elm' } }, M);
+        });
+        it('reads the fields it needs, which the row leaves out', async () => {
+            const rows = await Shelf.findMany({
+                orderBy: { name: 'asc' },
+                select: { label: true, padded: { width: 5 } },
+            }, M);
+            expect(rows).toStrictEqual([
+                { label: 'ELM', padded: 'elm..' },
+                { label: 'OAK', padded: 'oak..' },
+            ]);
+        });
+        it('is in the default row without an input', async () => {
+            const row = await Shelf.findFirst({ where: { name: 'oak' } }, M);
+            expect(row?.label).toBe('OAK');
+            expect(row && 'padded' in row).toBe(false);
+        });
+        it('reads the rows it returns with their relations', async () => {
+            const rows = await Shelf.findMany({
+                orderBy: { name: 'asc' },
+                select: {
+                    name: true,
+                    latest: {
+                        first: 2,
+                        select: {
+                            title: true,
+                            shelf: { select: { label: true } },
+                            tags: { select: { name: true } },
+                            _count: { select: { tags: true } },
+                        },
+                    },
+                },
+            }, M);
+            expect(rows).toStrictEqual([
+                { name: 'elm', latest: [] },
+                {
+                    name: 'oak',
+                    latest: [
+                        {
+                            title: 'C',
+                            shelf: { label: 'OAK' },
+                            tags: [{ name: 'new' }],
+                            _count: { tags: 1 },
+                        },
+                        {
+                            title: 'B',
+                            shelf: { label: 'OAK' },
+                            tags: [],
+                            _count: { tags: 0 },
+                        },
+                    ],
+                },
+            ]);
+        });
+        it('is read under an included relation', async () => {
+            const book = await Book.findFirst({
+                where: { title: 'A' },
+                include: { shelf: { include: { padded: { width: 4 } } } },
+            }, M);
+            expect(book?.shelf?.label).toBe('OAK');
+            expect(book?.shelf?.padded).toBe('oak.');
+        });
+    });
+}

package/dist/writes.d.ts

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

package/dist/writes.d.ts.map

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

package/dist/writes.js

@@ -0,0 +1,219 @@
+import { defineModel, master } from 'ultimabase';
+import { describe, expect, it } from 'vitest';
+import { started } from './suite.js';
+const M = { as: master };
+const Team = defineModel({
+    name: 'Team',
+    fields: (f) => ({
+        name: f.string({ unique: true }),
+        players: f.many(() => Player),
+    }),
+});
+const Player = defineModel({
+    name: 'Player',
+    fields: (f) => ({
+        name: f.string(),
+        score: f.number({ default: 0 }),
+        active: f.boolean({ default: true }),
+        bio: f.string({ optional: true }),
+        stats: f.json({ optional: true }),
+        bornAt: f.dateTime({ optional: true }),
+        team: f.one(() => Team, { optional: true }),
+        badge: f.one(() => Badge, { optional: true }),
+        skills: f.many(() => Skill),
+    }),
+    indexes: [{ fields: ['name', 'team'], unique: true }],
+});
+const Badge = defineModel({
+    name: 'Badge',
+    fields: (f) => ({ code: f.string(), player: f.one(() => Player) }),
+});
+const Skill = defineModel({
+    name: 'Skill',
+    fields: (f) => ({
+        label: f.string({ unique: true }),
+        players: f.many(() => Player),
+    }),
+});
+const skillsOf = async (id) => (await Skill.findMany({ where: { players: { some: { id } } }, orderBy: { label: 'asc' } }, M)).map((skill) => skill.label);
+const skill = async (label) => Skill.create({ data: { label } }, M);
+export function writes(create) {
+    describe('writes', () => {
+        const database = started(create, [Team, Player, Badge, Skill]);
+        it('creates a row and returns it as stored', async () => {
+            const bornAt = new Date(Date.UTC(1990, 4, 17, 8, 30, 15, 250));
+            const created = await Player.create({ data: { name: 'Ada', stats: { goals: [1, 2], ok: true }, bornAt } }, M);
+            expect(created).toMatchObject({
+                name: 'Ada',
+                score: 0,
+                active: true,
+                bio: null,
+                stats: { goals: [1, 2], ok: true },
+                bornAt,
+            });
+            expect(created.createdAt).toBeInstanceOf(Date);
+            expect(await Player.findUnique({ where: { id: created.id } }, M)).toEqual(created);
+        });
+        it('updates values, to null too, and moves updatedAt', async () => {
+            const ada = await Player.create({ data: { name: 'Ada', bio: 'Poet', score: 1.5 } }, M);
+            const updated = await Player.update({
+                where: { id: ada.id },
+                data: { bio: null, score: -2, active: false },
+            }, M);
+            expect(updated).toMatchObject({ bio: null, score: -2, active: false });
+            expect(updated.createdAt).toEqual(ada.createdAt);
+            expect(updated.updatedAt.getTime()).toBeGreaterThanOrEqual(ada.updatedAt.getTime());
+            expect(await Player.findUnique({ where: { id: ada.id } }, M)).toEqual(updated);
+        });
+        it('deletes a row and returns it', async () => {
+            const ada = await Player.create({ data: { name: 'Ada' } }, M);
+            expect(await Player.delete({ where: { id: ada.id } }, M)).toEqual(ada);
+            expect(await Player.count({}, M)).toBe(0);
+            await expect(Player.delete({ where: { id: ada.id } }, M)).rejects.toMatchObject({ code: 'NOT_FOUND' });
+        });
+        it('reads, with before, the rows its delete removed, as they were', async () => {
+            const ada = await Player.create({ data: { name: 'Ada' } }, M);
+            await Player.create({ data: { name: 'Bob' } }, M);
+            const read = { model: 'Player', where: {} };
+            const where = { name: { equals: 'Ada' } };
+            const removed = await database().write({
+                changes: [{ kind: 'delete', model: 'Player', where }],
+                read,
+                before: true,
+            });
+            expect(removed).toMatchObject([{ id: ada.id, name: 'Ada' }]);
+            // Nothing left to remove, or no delete at all: no row (D-104).
+            const again = await database().write({
+                changes: [{ kind: 'delete', model: 'Player', where }],
+                read,
+                before: true,
+            });
+            expect(again).toEqual([]);
+            expect(await database().write({ changes: [], read, before: true })).toEqual([]);
+            expect(await Player.count({}, M)).toBe(1);
+        });
+        it('reads, with before and no delete, the rows its update changed', async () => {
+            const ada = await Player.create({ data: { name: 'Ada' } }, M);
+            await Player.create({ data: { name: 'Bob' } }, M);
+            const changed = await database().write({
+                changes: [
+                    {
+                        kind: 'update',
+                        model: 'Player',
+                        where: { name: { equals: 'Ada' } },
+                        set: { name: 'Eve' },
+                    },
+                ],
+                read: { model: 'Player', where: {} },
+                before: true,
+            });
+            // As the update left them (D-133).
+            expect(changed).toMatchObject([{ id: ada.id, name: 'Eve' }]);
+        });
+        it('connects and disconnects a one-to-many', async () => {
+            const team = await Team.create({ data: { name: 'Reds' } }, M);
+            const ada = await Player.create({ data: { name: 'Ada', team: { connect: { id: team.id } } } }, M);
+            const reds = await Team.findUnique({ where: { id: team.id }, include: { players: true } }, M);
+            expect(reds).toMatchObject({ players: [{ id: ada.id }] });
+            await Player.update({ where: { id: ada.id }, data: { team: { disconnect: true } } }, M);
+            expect(await Player.count({ where: { team: { is: null } } }, M)).toBe(1);
+        });
+        it('connects a one-to-one from either side', async () => {
+            const ada = await Player.create({ data: { name: 'Ada' } }, M);
+            const badge = await Badge.create({ data: { code: 'A1', player: { connect: { id: ada.id } } } }, M);
+            const found = await Player.findUnique({ where: { id: ada.id }, include: { badge: true } }, M);
+            expect(found).toMatchObject({ badge: { id: badge.id } });
+            const grace = await Player.create({ data: { name: 'Grace', badge: { connect: { id: badge.id } } } }, M);
+            const moved = await Badge.findUnique({ where: { id: badge.id }, include: { player: true } }, M);
+            expect(moved).toMatchObject({ player: { id: grace.id } });
+        });
+        it('links and unlinks a many-to-many, and unlinks a deleted row', async () => {
+            const math = await skill('math');
+            const art = await skill('art');
+            const chess = await skill('chess');
+            const ada = await Player.create({
+                data: {
+                    name: 'Ada',
+                    skills: {
+                        connect: [{ id: math.id }, { id: art.id }],
+                    },
+                },
+            }, M);
+            expect(await skillsOf(ada.id)).toEqual(['art', 'math']);
+            await Player.update({
+                where: { id: ada.id },
+                data: {
+                    skills: {
+                        connect: [{ id: chess.id }],
+                        disconnect: [{ id: math.id }],
+                    },
+                },
+            }, M);
+            expect(await skillsOf(ada.id)).toEqual(['art', 'chess']);
+            await Skill.delete({ where: { id: art.id } }, M);
+            expect(await skillsOf(ada.id)).toEqual(['chess']);
+            await Player.delete({ where: { id: ada.id } }, M);
+            expect(await Skill.count({ where: { players: { some: {} } } }, M)).toBe(0);
+        });
+        it('refuses a second row with a unique field or index, and keeps the first', async () => {
+            const team = await Team.create({ data: { name: 'Reds' } }, M);
+            await expect(Team.create({ data: { name: 'Reds' } }, M)).rejects.toMatchObject({
+                code: 'UNIQUE_VIOLATION',
+                details: { model: 'Team', fields: ['name'] },
+            });
+            const data = { name: 'Ada', team: { connect: { id: team.id } } };
+            await Player.create({ data }, M);
+            await expect(Player.create({ data }, M)).rejects.toMatchObject({
+                code: 'UNIQUE_VIOLATION',
+                details: { model: 'Player', fields: ['name', 'team'] },
+            });
+            const grace = await Player.create({ data: { name: 'Grace' } }, M);
+            await expect(Player.update({ where: { id: grace.id }, data: { name: 'Ada', team: data.team } }, M)).rejects.toMatchObject({ code: 'UNIQUE_VIOLATION' });
+            expect(await Team.count({}, M)).toBe(1);
+            expect(await Player.count({ where: { name: 'Grace', team: { is: null } } }, M)).toBe(1);
+        });
+        it('stores any well-formed text and the dates of years 1 to 9999', async () => {
+            const first = new Date('0001-01-01T00:00:00.000Z');
+            const last = new Date('9999-12-31T23:59:59.999Z');
+            const ada = await Player.create({ data: { name: '😀 Ada', stats: { 'é😀': ['ｚ'] }, bornAt: first } }, M);
+            await Player.create({ data: { name: 'Grace', bornAt: last } }, M);
+            expect(await Player.findMany({ orderBy: { bornAt: 'asc' } }, M)).toMatchObject([
+                { name: '😀 Ada', stats: { 'é😀': ['ｚ'] }, bornAt: first },
+                { name: 'Grace', bornAt: last },
+            ]);
+            expect(await Player.count({ where: { id: ada.id, bornAt: first } }, M)).toBe(1);
+        });
+        it('refuses a NUL, a lone surrogate or a year outside 1 to 9999', async () => {
+            const invalid = { code: 'VALIDATION_FAILED' };
+            for (const data of [
+                { name: 'A\0da' },
+                { name: '\uD800' },
+                { name: 'Ada', stats: { 'k\0': 1 } },
+                { name: 'Ada', stats: ['\uDC00'] },
+                { name: 'Ada', bornAt: new Date('0000-12-31T23:59:59.999Z') },
+                { name: 'Ada', bornAt: new Date('+010000-01-01T00:00:00.000Z') },
+            ]) {
+                await expect(Player.create({ data }, M)).rejects.toMatchObject(invalid);
+            }
+            const query = { code: 'INVALID_QUERY' };
+            const late = new Date('+010000-01-01T00:00:00.000Z');
+            for (const where of [
+                { name: 'A\0' },
+                { name: { contains: '\uD800' } },
+                { id: { in: ['\0'] } },
+                { bornAt: { lt: late } },
+                { stats: { equals: { a: '\0' } } },
+            ]) {
+                await expect(Player.findMany({ where }, M)).rejects.toMatchObject(query);
+            }
+            const team = { connect: { id: '\0' } };
+            await expect(Player.create({ data: { name: 'Ada', team } }, M)).rejects.toMatchObject(query);
+            expect(await Player.count({}, M)).toBe(0);
+        });
+        it('refuses to connect a missing row, and writes nothing', async () => {
+            const created = Player.create({ data: { name: 'Ada', team: { connect: { id: 'missing' } } } }, M);
+            await expect(created).rejects.toMatchObject({ code: 'NOT_FOUND' });
+            expect(await Player.count({}, M)).toBe(0);
+        });
+    });
+}

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@ultimabase/testing",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Test helpers for UltimaBase applications, plugins and adapters.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "homepage": "https://ultimabase.dev/docs/testing",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MrEkinox/ultimabase.git",
+    "directory": "packages/testing"
+  },
+  "engines": {
+    "node": ">=24.7.0"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/test"
+  ],
+  "scripts": {
+    "prepack": "rm -rf dist && yarn run -T tsc --project tsconfig.build.json"
+  },
+  "publishConfig": {
+    "exports": {
+      ".": "./dist/index.js"
+    }
+  },
+  "peerDependencies": {
+    "ultimabase": "^0.1.1",
+    "vitest": "^5.0.5"
+  },
+  "devDependencies": {
+    "@ultimabase/http": "0.1.1",
+    "ultimabase": "0.1.1",
+    "vite": "8.3.4",
+    "vitest": "5.0.5"
+  }
 }