@ultimabase/testing 0.0.0-stage → 0.1.1

package/src/lists.ts

@@ -0,0 +1,304 @@
+// The lists of the contract (D-120, D-127, D-149): of strings, numbers or
+// enum values, `[]` when unwritten, replaced whole or updated with `push`,
+// `pushUnique` or `remove`, filtered with `has`, `hasSome`, `hasEvery` and
+// `isEmpty`, indexed by GIN in PostgreSQL.
+import type { Adapter, UpdateDataOf, WhereOf } from 'ultimabase'
+import { defineModel, master } from 'ultimabase'
+import { describe, expect, it } from 'vitest'
+import { started } from './suite.ts'
+
+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: WhereOf<typeof Article>): Promise<string[]> =>
+	(await Article.findMany({ where }, M)).map((article) => article.title)
+
+export function lists(create: () => Adapter): void {
+	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', []],
+			] as const) {
+				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']],
+			] as const) {
+				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: UpdateDataOf<typeof Article>) =>
+				Article.update({ where: { id }, data }, M)
+			const tags = async (data: UpdateDataOf<typeof Article>['tags']) =>
+				(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', []],
+			] as const) {
+				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: [unknown, string, string][] = [
+				[{}, '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 } as { 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: unknown = { push: 'a' }
+			const data = { title: 'b', tags: pushed } as { title: string }
+			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/src/nested.ts

@@ -0,0 +1,187 @@
+// Nested creation in the contract (D-128): `create` in a relation write makes
+// the rows with the one it writes, at any depth, or none of them.
+import type { Adapter } from 'ultimabase'
+import { defineModel, master } from 'ultimabase'
+import { describe, expect, it } from 'vitest'
+import { started } from './suite.ts'
+
+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: () => Adapter): void {
+	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/src/numbers.ts

@@ -0,0 +1,125 @@
+// The numbers of the contract (D-132): integer fields in 32 bits, and number
+// updates computed by the write on the row as it finds it, `null` as 0.
+import type { Adapter, UpdateDataOf } from 'ultimabase'
+import { defineModel, master } from 'ultimabase'
+import { describe, expect, it } from 'vitest'
+import { started } from './suite.ts'
+
+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: UpdateDataOf<typeof Tally>,
+	from: { count?: number | null; ratio?: number | null },
+) => {
+	const { id } = await Tally.create({ data: from }, M)
+	return Tally.update({ where: { id }, data }, M)
+}
+
+export function numbers(create: () => Adapter): void {
+	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.',
+				],
+			] as const) {
+				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/src/projection.ts

@@ -0,0 +1,65 @@
+// A read's `fields` (D-136): the rows hold `id` and those fields only, in a
+// relation too; without them, the whole row and each `one` key.
+import type { Adapter } from 'ultimabase'
+import { defineModel, master } from 'ultimabase'
+import { beforeEach, describe, expect, it } from 'vitest'
+import { started } from './suite.ts'
+
+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: () => Adapter): void {
+	describe('projection', () => {
+		const database = started(create, [Writer, Note])
+
+		let ada: string
+		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',
+			])
+		})
+	})
+}