@ultimabase/testing 0.0.0-stage → 0.1.1

package/src/cases.ts

@@ -0,0 +1,76 @@
+// Case-insensitive filters in the contract (D-140): `mode: 'insensitive'`
+// on every string operator, beyond ASCII, a pattern character kept.
+import type { Adapter, Identity, WhereOf } from 'ultimabase'
+import { defineModel, master } from 'ultimabase'
+import { beforeEach, describe, expect, it } from 'vitest'
+import { started } from './suite.ts'
+
+const M: { readonly as: Identity } = { as: master }
+
+const Title = defineModel({
+	name: 'Title',
+	fields: (f) => ({ text: f.string({ optional: true }) }),
+})
+
+const texts = async (where: WhereOf<typeof Title>): Promise<unknown[]> =>
+	(await Title.findMany({ where, orderBy: { text: 'asc' } }, M)).map(
+		(title) => title.text,
+	)
+
+export function cases(create: () => Adapter): void {
+	describe('case-insensitive filters', () => {
+		started(create, [Title])
+
+		beforeEach(async () => {
+			for (const text of ['Analysis', 'Compilers', 'Engines', 'Émile', null]) {
+				await Title.create({ data: { text } }, M)
+			}
+		})
+
+		it('ignores case with every string operator', async () => {
+			const mode = 'insensitive'
+			expect(await texts({ text: { equals: 'analysis', mode } })).toEqual([
+				'Analysis',
+			])
+			expect(await texts({ text: { not: 'ANALYSIS', mode } })).toEqual([
+				'Compilers',
+				'Engines',
+				'Émile',
+			])
+			expect(await texts({ text: { in: ['ENGINES', 'nope'], mode } })).toEqual([
+				'Engines',
+			])
+			expect(
+				await texts({ text: { notIn: ['engines', 'émile'], mode } }),
+			).toEqual(['Analysis', 'Compilers'])
+			expect(await texts({ text: { contains: 'GIN', mode } })).toEqual([
+				'Engines',
+			])
+			expect(await texts({ text: { startsWith: 'c', mode } })).toEqual([
+				'Compilers',
+			])
+			expect(await texts({ text: { endsWith: 'SIS', mode } })).toEqual([
+				'Analysis',
+			])
+		})
+
+		it('folds letters beyond ASCII', async () => {
+			const mode = 'insensitive'
+			expect(await texts({ text: { startsWith: 'é', mode } })).toEqual([
+				'Émile',
+			])
+			expect(await texts({ text: { equals: 'ÉMILE', mode } })).toEqual([
+				'Émile',
+			])
+		})
+
+		it('keeps pattern characters as they are', async () => {
+			const mode = 'insensitive'
+			expect(await texts({ text: { equals: 'analysi_', mode } })).toEqual([])
+			expect(await texts({ text: { contains: '%', mode } })).toEqual([])
+			expect(await texts({ text: { in: [], mode } })).toEqual([])
+			// `mode` alone filters nothing, as in Prisma.
+			expect(await texts({ text: { mode } })).toHaveLength(5)
+		})
+	})
+}

package/src/counts.ts

@@ -0,0 +1,223 @@
+// Counts and sorts through relations in the contract (D-134): `_count` at
+// any depth and filtered, a sort through `one` relations or by a count, on
+// the rows the caller reads, a cursor kept exact.
+import type { Adapter, Identity } from 'ultimabase'
+import { defineModel, master } from 'ultimabase'
+import { beforeEach, describe, expect, it } from 'vitest'
+import { suiteUser } from './as-user.ts'
+import { started } from './suite.ts'
+
+const M: { readonly as: Identity } = { 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: readonly { readonly title: string }[]): string[] =>
+	rows.map((row) => row.title)
+
+const connect = (id: string) => ({ connect: { id } })
+
+/** The articles' titles, by their author's firm name, then their title. */
+const byFirm = async (direction: 'asc' | 'desc', as = M) =>
+	titles(
+		await Article.findMany(
+			{
+				orderBy: [{ author: { firm: { name: direction } } }, { title: 'asc' }],
+			},
+			as,
+		),
+	)
+
+export function counts(create: () => Adapter): void {
+	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: string,
+				author: string | undefined,
+				remarks: readonly { body: string; hidden?: boolean }[],
+				labels: readonly string[],
+			) =>
+				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 } } },
+					},
+				},
+			} as const
+			const counted = async (as: typeof M) =>
+				(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: typeof M) =>
+				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' } },
+			] as const
+			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/src/days.ts

@@ -0,0 +1,107 @@
+// Calendar days in the contract (D-150): the string '2026-07-31' as written,
+// filtered, sorted, grouped and aggregated in the calendar's order.
+import type { Adapter, Identity } from 'ultimabase'
+import { defineModel, master } from 'ultimabase'
+import { describe, expect, it } from 'vitest'
+import { started } from './suite.ts'
+
+const M: { readonly as: Identity } = { 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: readonly { readonly on: string }[]) =>
+	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: () => Adapter): void {
+	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/src/decimals.ts

@@ -0,0 +1,102 @@
+// Decimals in the contract (D-145): exact strings at their field's scale,
+// filtered, sorted and aggregated by value, beyond a double's digits.
+import type { Adapter, Identity } from 'ultimabase'
+import { defineModel, master } from 'ultimabase'
+import { describe, expect, it } from 'vitest'
+import { started } from './suite.ts'
+
+const M: { readonly as: Identity } = { 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: readonly { readonly amount: string }[]) =>
+	rows.map((row) => row.amount)
+
+export function decimals(create: () => Adapter): void {
+	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/src/distincts.ts

@@ -0,0 +1,107 @@
+// `distinct` in the contract (D-147): of the rows with the same keys, the
+// first in `orderBy`'s order, then `skip` and `take`; rows with no value
+// share a key, and a relation the caller cannot read is no relation.
+import type { Adapter, Identity } from 'ultimabase'
+import { defineModel, master } from 'ultimabase'
+import { beforeEach, describe, expect, it } from 'vitest'
+import { suiteUser } from './as-user.ts'
+import { started } from './suite.ts'
+
+const M: { readonly as: Identity } = { 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 } as const
+const scores = (rows: readonly { readonly score: number }[]): number[] =>
+	rows.map((row) => row.score)
+
+export function distincts(create: () => Adapter): void {
+	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,
+			} as const
+			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,
+			} as const
+			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])
+		})
+	})
+}