Errors

import { PublicError, allow, defineFunction, master } from 'ultimabase'
import { z } from 'zod'
import { Product } from './models.ts'

export const order = defineFunction({
	name: 'order',
	input: z.object({ sku: z.string(), quantity: z.int().min(1) }),
	run: async ({ input }) => {
		const product = await Product.findUniqueOrThrow(
			{ where: { sku: input.sku } },
			{ as: master },
		)
		if (product.stock < input.quantity) {
			// The code, the message and the details reach the client.
			throw new PublicError('OUT_OF_STOCK', `Only ${product.stock} left.`, {
				details: { sku: product.sku, left: product.stock },
			})
		}
		await Product.update(
			{
				where: { id: product.id },
				data: { stock: { decrement: input.quantity } },
			},
			{ as: master },
		)
	},
}).with({ access: allow.public })

// A caller branches on the code, and lets any other error go on.
const outcome = await order.run({ sku: 'MUG-1', quantity: 5 }).then(
	() => 'Ordered.',
	(error: unknown) => {
		if (error instanceof PublicError && error.code === 'OUT_OF_STOCK') {
			return `Sorry: ${error.message}`
		}
		throw error
	},
)
expect(outcome).toBe('Sorry: Only 2 left.')
await expect(order.run({ sku: 'MUG-1', quantity: 5 })).rejects.toMatchObject({
	code: 'OUT_OF_STOCK',
	details: { sku: 'MUG-1', left: 2 },
})

// The kernel's own errors are PublicErrors too.
await expect(
	Product.create({ data: { sku: 'MUG-1', name: 'Other mug' } }, { as: master }),
).rejects.toMatchObject({
	code: 'UNIQUE_VIOLATION',
	details: { model: 'Product', fields: ['sku'] },
})

const response = await post('/api/functions/order', {
	sku: 'MUG-1',
	quantity: 5,
})
// An application's own code is a 400.
expect(response.status).toBe(400)
expect(await response.json()).toEqual({
	code: 'OUT_OF_STOCK',
	message: 'Only 2 left.',
	details: { sku: 'MUG-1', left: 2 },
})

const answer = await post('/graphql', {
	query: 'mutation { order(sku: "MUG-1", quantity: 5) }',
})
expect(await answer.json()).toMatchObject({
	data: null,
	errors: [
		{
			message: 'Only 2 left.',
			path: ['order'],
			extensions: {
				code: 'OUT_OF_STOCK',
				details: { sku: 'MUG-1', left: 2 },
			},
		},
	],
})

export const subscribe = defineFunction({
	name: 'subscribe',
	input: z.object({ email: z.email() }),
	run: async ({ input }) => {
		const url = process.env['NEWSLETTER_URL']
		// Any other error is masked: the client sees `INTERNAL`.
		if (url === undefined) throw new Error('NEWSLETTER_URL is not set.')
		await fetch(url, { method: 'POST', body: JSON.stringify(input) })
	},
}).with({ access: allow.public })

const logged = vi.spyOn(console, 'error').mockImplementation(() => {})
const response = await post('/api/functions/subscribe', {
	email: 'ada@example.com',
})
expect(response.status).toBe(500)
// The message stays on the server.
const { correlationId } = z
	.object({
		code: z.literal('INTERNAL'),
		message: z.literal('Internal error.'),
		correlationId: z.uuid(),
	})
	.strict()
	.parse(await response.json())
// The log line holds the same id, and the error with its stack.
const line = String(logged.mock.calls[0]?.[0])
expect(line).toContain(correlationId)
expect(line).toContain('NEWSLETTER_URL is not set.')