Functions

import { graphql } from '@ultimabase/graphql'
import {
	PublicError,
	allow,
	defineFunction,
	defineType,
	master,
} from 'ultimabase'
import type { Caller } from 'ultimabase'
import { z } from 'zod'
import { Book } from './models.ts'

// A named object: a model and data together.
export const Loan = defineType({
	name: 'Loan',
	fields: { book: Book, dueOn: z.iso.date() },
})

export const borrowBook = defineFunction({
	name: 'borrowBook',
	input: z.object({ book: z.string(), days: z.int().min(1).max(30) }),
	output: Loan,
	run: async ({ input, caller }) => {
		const book = await Book.findUniqueOrThrow(
			{ where: { id: input.book } },
			{ as: caller },
		)
		if (book.borrowedBy !== null) {
			throw new PublicError('BOOK_BORROWED', `${book.title} is out.`)
		}
		// Book is read-only for clients: the function writes as the server.
		const lent = await Book.update(
			{ where: { id: book.id }, data: { borrowedBy: userOf(caller) } },
			{ as: master },
		)
		const due = new Date(Date.now() + input.days * 86_400_000)
		return { book: lent, dueOn: due.toISOString().slice(0, 10) }
	},
}).with({ access: ({ caller }) => caller.kind === 'user' })

import { graphqlPlugin } from '@ultimabase/graphql'
import { httpPlugin } from '@ultimabase/http'
import { restPlugin } from '@ultimabase/rest'
import { defineApp, memory } from 'ultimabase'
import { borrowBook, returnBooks, searchBooks } from './functions.ts'
import { Book } from './models.ts'

export const app = defineApp({
	// Kept in memory, so the example needs no database.
	database: memory(),
	// Listens on PORT, or 3000.
	plugins: [httpPlugin(), restPlugin(), graphqlPlugin()],
	models: [Book],
	functions: [borrowBook, searchBooks, returnBooks],
})

const loan = await borrowBook.run({ book: dune, days: 14 }, ada)
expect(loan.book.borrowedBy).toBe('ada')
expect(loan.dueOn).toMatch(/^\d{4}-\d{2}-\d{2}$/)

// A PublicError thrown by `run` reaches the caller.
await expect(
	borrowBook.run({ book: dune, days: 7 }, grace),
).rejects.toMatchObject({ code: 'BOOK_BORROWED', message: 'Dune is out.' })

await returnBooks.run(ada)
const available = await searchBooks.run({ text: 'dune', available: true }, ada)
expect(available.map((book) => book.title)).toEqual(['Dune'])

// Without `as`, the caller is anonymous.
await expect(borrowBook.run({ book: dune, days: 14 })).rejects.toMatchObject({
	code: 'ACCESS_DENIED',
	message: 'borrowBook refused.',
	details: { function: 'borrowBook' },
})
await expect(
	borrowBook.run({ book: dune, days: 90 }, ada),
).rejects.toMatchObject({
	code: 'VALIDATION_FAILED',
	message: 'Invalid input.',
	details: { issues: [{ path: ['days'] }] },
})

// A query: served over GraphQL's Query and REST's GET.
export const searchBooks = defineFunction({
	name: 'searchBooks',
	query: true,
	input: z.object({ text: z.string().min(1), available: z.boolean() }),
	output: [Book],
	run: ({ input, caller }) =>
		Book.findMany(
			{
				where: {
					_search: input.text,
					...(input.available ? { borrowedBy: null } : {}),
				},
			},
			{ as: caller },
		),
}).with({ access: allow.public })

// No input and no output: GraphQL answers `true`.
export const returnBooks = defineFunction({
	name: 'returnBooks',
	// The transports whose key `.with` sets.
	use: [graphql()],
	run: async ({ caller }) => {
		const borrowedBy = userOf(caller)
		await Book.updateMany(
			{ where: { borrowedBy }, data: { borrowedBy: null } },
			{ as: master },
		)
	},
}).with({
	access: ({ caller }) => caller.kind === 'user',
	// Named `giveBack` in GraphQL; REST keeps `returnBooks`.
	graphql: { name: 'giveBack' },
})

// Sends a GraphQL document, as a client without a session does.
async function request(query: string): Promise<unknown> {
	const response = await fetch(`${running.url}/graphql`, {
		method: 'POST',
		headers: { 'content-type': 'application/json' },
		body: JSON.stringify({ query }),
	})
	return response.json()
}

// An object input gives one argument per property.
expect(
	await request('{ searchBooks(text: "dune", available: true) { title } }'),
).toEqual({ data: { searchBooks: [{ title: 'Dune' }] } })
// Renamed by `.with({ graphql: { name } })`.
expect(await request('mutation { giveBack }')).toMatchObject({
	errors: [
		{
			message: 'returnBooks refused.',
			extensions: { code: 'ACCESS_DENIED' },
		},
	],
})

// A query is a GET, its input in the query string.
const found = await fetch(
	`${running.url}/api/functions/searchBooks?text=dune&available=true`,
)
expect(await found.json()).toMatchObject([{ title: 'Dune' }])

// A mutation is a POST, its input in the body.
const borrowed = await fetch(`${running.url}/api/functions/borrowBook`, {
	method: 'POST',
	headers: { 'content-type': 'application/json' },
	body: JSON.stringify({ book: dune, days: 14 }),
})
expect(borrowed.status).toBe(403)
expect(await borrowed.json()).toMatchObject({
	code: 'ACCESS_DENIED',
	message: 'borrowBook refused.',
})