An application's files

import { graphql } from '@ultimabase/graphql'
import { PublicError, allow, defineModel, master } from 'ultimabase'

export const Product = defineModel({
	name: 'Product',
	use: [graphql()],
	fields: (f) => ({
		name: f.string(),
		stock: f.number({ integer: true, default: 0 }),
		orders: f.many(() => Order),
	}),
}).with({
	// Clients read the products; only the server changes them.
	access: allow.readOnly,
	hooks: {
		// Sees the stock as the update leaves it, on the locked row.
		beforeUpdate: ({ record, data }) => {
			if (data.stock !== undefined && data.stock < 0) {
				throw new PublicError('OUT_OF_STOCK', `${record.name} is out of stock.`)
			}
		},
	},
})

export const Order = defineModel({
	name: 'Order',
	use: [graphql()],
	fields: (f) => ({
		product: f.one(() => Product),
		quantity: f.number({ integer: true }),
	}),
}).with({
	// Clients read the orders, and place them through `placeOrder`.
	access: allow.readOnly,
	hooks: {
		// Runs inside the order's transaction: throwing undoes the order.
		afterCreate: async ({ record }) => {
			await Product.update(
				{
					where: { id: record.product.id },
					data: { stock: { decrement: record.quantity } },
				},
				{ as: master },
			)
		},
	},
})

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

// Named, so GraphQL calls its input type `LineInput`.
const Line = z
	.object({ product: z.string(), quantity: z.int().min(1) })
	.meta({ id: 'Line' })

export const placeOrder = defineFunction({
	name: 'placeOrder',
	input: z.object({ lines: z.array(Line).min(1) }),
	output: [Order],
	// One transaction: every line is ordered, or none is.
	run: ({ input }) =>
		transaction(async () => {
			const orders = []
			for (const { product, quantity } of input.lines) {
				const data = { product: { connect: { id: product } }, quantity }
				// One after the other: each line takes from the stock the last left.
				orders.push(await Order.create({ data }, { as: master }))
			}
			return orders
		}),
}).with({ access: allow.public })

import { graphqlPlugin } from '@ultimabase/graphql'
import { httpPlugin } from '@ultimabase/http'
import { defineApp, memory } from 'ultimabase'
import { placeOrder } from './functions.ts'
import { Order, Product } 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(), graphqlPlugin()],
	models: [Product, Order],
	functions: [placeOrder],
})

// What `ultimabase dev` and `ultimabase start` run: the application.
export { app as default } from './src/app.ts'