ultimabase 0.0.0-stage → 0.1.0

package/src/manifest.ts

@@ -0,0 +1,71 @@
+// A plugin's manifest (D-57, D-95): checked by `definePlugin`, its ranges
+// matched at `start` against the running kernel and the installed plugins.
+import { satisfies, valid, validRange } from 'semver'
+import kernel from '../package.json' with { type: 'json' }
+import type { Logger } from './app-options.ts'
+import type { PluginRecord } from './definition.ts'
+import type { Manifest } from './plugin.ts'
+import { isObject } from './query-where.ts'
+import { Refused } from './errors.ts'
+
+/** Checks a plugin's `manifest`: a name, a version and valid ranges. */
+export function manifestOf(value: unknown, plugin: string): Manifest {
+	const path = `${plugin}.manifest`
+	if (!isObject(value)) throw new TypeError(`${path} is an object.`)
+	const { name, version, peerDependencies } = value
+	if (typeof name !== 'string' || name === '') {
+		throw new TypeError(`${path}.name is a package name.`)
+	}
+	if (typeof version !== 'string' || valid(version) === null) {
+		throw new TypeError(`${path}.version is a version, not ${String(version)}.`)
+	}
+	if (peerDependencies === undefined) return Object.freeze({ name, version })
+	if (!isObject(peerDependencies)) {
+		throw new TypeError(`${path}.peerDependencies is an object.`)
+	}
+	const ranges: { [name: string]: string } = {}
+	for (const [peer, range] of Object.entries(peerDependencies)) {
+		if (typeof range !== 'string' || validRange(range) === null) {
+			throw new TypeError(
+				`${path}.peerDependencies.${peer} is a version range, not ${String(range)}.`,
+			)
+		}
+		ranges[peer] = range
+	}
+	return Object.freeze({
+		name,
+		version,
+		peerDependencies: Object.freeze(ranges),
+	})
+}
+
+// A prerelease of the kernel runs the plugins written for its version range.
+const accepts = (version: string, range: string): boolean =>
+	satisfies(version, range, { includePrerelease: true })
+
+/**
+ * Refuses a plugin whose ranges exclude the running kernel or an installed
+ * plugin, naming both versions; warns of one that gives the kernel no range.
+ */
+export function checkVersions(
+	plugins: readonly PluginRecord[],
+	logger: Logger,
+): void {
+	const installed = new Map<string, string>([[kernel.name, kernel.version]])
+	for (const { code } of plugins) {
+		installed.set(code.manifest.name, code.manifest.version)
+	}
+	for (const { code } of plugins) {
+		const { name, version, peerDependencies = {} } = code.manifest
+		if (peerDependencies[kernel.name] === undefined) {
+			logger.warn(`${name} declares no ${kernel.name} range.`)
+		}
+		for (const [peer, range] of Object.entries(peerDependencies)) {
+			const found = installed.get(peer)
+			if (found === undefined || accepts(found, range)) continue
+			throw new Refused(
+				`${name} ${version} needs ${peer} ${range}; this is ${peer} ${found}.`,
+			)
+		}
+	}
+}

package/src/memory-aggregate.ts

@@ -0,0 +1,162 @@
+// How `memory()` aggregates (D-143), as PostgreSQL: a `null` is skipped, and
+// a sum, an average, a minimum or a maximum of no value is `null`.
+// A decimal's sum is exact, at its field's scale, its average that sum's
+// number divided (D-145). Groups are kept by `having` as rows by a `where`
+// (D-149), and sorted as a read's rows (D-146).
+import type {
+	Aggregate,
+	AggregateRead,
+	Filter,
+	GroupKey,
+	Read,
+	SchemaField,
+} from './adapter.ts'
+import { sumDecimals } from './decimal.ts'
+import type { Truth } from './memory-conditions.ts'
+import { and, isFilters, not, or, scalar } from './memory-conditions.ts'
+import type { Reader, StoredRow } from './memory-read.ts'
+import { compareKeys, compareValues, copy, sortable } from './memory-values.ts'
+
+function of(
+	values: readonly unknown[],
+	operation: Aggregate['operation'],
+	field: SchemaField | undefined,
+): unknown {
+	if (operation === 'count') return values.length
+	const [head, ...rest] = values
+	if (head === undefined) return null
+	if (operation === 'min' || operation === 'max') {
+		const sign = operation === 'min' ? 1 : -1
+		const order = (a: unknown, b: unknown) =>
+			compareValues(sortable(a, field), sortable(b, field))
+		const found = rest.reduce(
+			(best, item) => (sign * order(item, best) < 0 ? item : best),
+			head,
+		)
+		return copy(found)
+	}
+	const sum =
+		field?.kind === 'scalar' && field.type === 'decimal'
+			? sumDecimals(values.map(String), field.scale ?? 0)
+			: values.reduce((total: number, item) => total + Number(item), 0)
+	return operation === 'sum' ? sum : Number(sum) / values.length
+}
+
+/** One value per aggregate of `rows`, in order. */
+function aggregated(
+	rows: readonly StoredRow[],
+	aggregates: readonly Aggregate[],
+	fieldOf: (name: string) => SchemaField | undefined,
+): unknown[] {
+	return aggregates.map(({ operation, field }) => {
+		if (field === undefined) return rows.length
+		const values = rows.map((row) => row[field] ?? null)
+		return of(
+			values.filter((item) => item !== null),
+			operation,
+			fieldOf(field),
+		)
+	})
+}
+
+/** The values of a row's keys, a key through a relation its target's. */
+function keysOf(
+	reader: Reader,
+	model: string,
+	row: StoredRow,
+	by: readonly GroupKey[],
+): unknown[] {
+	return by.map(({ field, through }) => {
+		const reached = reader.reach(model, row, through)
+		return copy(reached?.row[field] ?? null)
+	})
+}
+
+/** Of the rows with the same keys, the first in `read`'s order (D-147). */
+export function distinct(
+	reader: Reader,
+	read: Read,
+	rows: StoredRow[],
+): StoredRow[] {
+	const { where, orderBy } = read
+	const sorted = reader.select(read.model, rows, {
+		...(where && { where }),
+		...(orderBy && { orderBy }),
+	})
+	const seen = new Set<string>()
+	return sorted.filter((row) => {
+		const id = JSON.stringify(
+			keysOf(reader, read.model, row, read.distinct ?? []),
+		)
+		if (seen.has(id)) return false
+		seen.add(id)
+		return true
+	})
+}
+
+/** Whether a group's values pass `having`, whose keys are positions (D-149). */
+function held(
+	filter: Filter,
+	values: readonly unknown[],
+	fields: readonly (SchemaField | undefined)[],
+): Truth {
+	const truths: Truth[] = []
+	for (const [key, part] of Object.entries(filter)) {
+		if (part === undefined) continue
+		if (!isFilters(part)) {
+			const at = Number(key)
+			const sorted = (value: unknown) => sortable(value, fields[at])
+			truths.push(scalar(values[at] ?? null, part, sorted))
+			continue
+		}
+		const inner = part.map((each) => held(each, values, fields))
+		if (key === 'AND') truths.push(and(inner))
+		else if (key === 'OR') truths.push(or(inner))
+		else truths.push(and(inner.map((truth) => not(truth))))
+	}
+	return and(truths)
+}
+
+/** Each group of `rows`: its keys' values, then its aggregates', in order. */
+export function grouped(
+	reader: Reader,
+	read: AggregateRead,
+	rows: readonly StoredRow[],
+): unknown[][] {
+	const by = read.by ?? []
+	const fieldOf = (name: string) => reader.field(read.model, name)
+	const groups = new Map<string, { keys: unknown[]; rows: StoredRow[] }>()
+	if (by.length === 0) groups.set('[]', { keys: [], rows: [] })
+	for (const row of rows) {
+		const keys = keysOf(reader, read.model, row, by)
+		const id = JSON.stringify(keys)
+		const group = groups.get(id) ?? { keys, rows: [] }
+		group.rows.push(row)
+		groups.set(id, group)
+	}
+	const lists = [...groups.values()].map((group) => [
+		...group.keys,
+		...aggregated(group.rows, read.aggregates, fieldOf),
+	])
+	// A key through a relation is an id; a decimal sorts by value (D-145).
+	const fields = [
+		...by.map(({ field, through }) => (through ? undefined : field)),
+		...read.aggregates.map(({ operation, field }) =>
+			operation === 'count' ? undefined : field,
+		),
+	].map((name) => (name === undefined ? undefined : fieldOf(name)))
+	const { having } = read
+	const kept =
+		having === undefined
+			? lists
+			: lists.filter((list) => held(having, list, fields) === true)
+	const order = read.orderBy ?? []
+	const sorted = (list: readonly unknown[]) =>
+		order.map(({ at }) => sortable(list[at], fields[at]))
+	kept.sort((a, b) => compareKeys(sorted(a), sorted(b), order))
+	const skip = read.skip ?? 0
+	return kept.slice(
+		skip,
+		read.take === undefined ? undefined : skip + read.take,
+	)
+}

package/src/memory-conditions.ts

@@ -0,0 +1,88 @@
+// How `memory()` tests a condition, with SQL's three-valued logic: `null` is
+// unknown, as PostgreSQL compares it (D-94).
+import type { Condition, Filter } from './adapter.ts'
+import { jsonPath } from './memory-json.ts'
+import { compareValues, lower, same, text } from './memory-values.ts'
+
+export type Truth = boolean | null
+
+export function and(truths: readonly Truth[]): Truth {
+	if (truths.includes(false)) return false
+	return truths.includes(null) ? null : true
+}
+
+export function or(truths: readonly Truth[]): Truth {
+	if (truths.includes(true)) return true
+	return truths.includes(null) ? null : false
+}
+
+export function not(truth: Truth): Truth {
+	return truth === null ? null : !truth
+}
+
+export function isFilters(
+	value: Condition | readonly Filter[],
+): value is readonly Filter[] {
+	return Array.isArray(value)
+}
+
+export function scalar(
+	stored: unknown,
+	condition: Condition,
+	sorted: (value: unknown) => unknown,
+): Truth {
+	if (condition.path !== undefined) return jsonPath(stored, condition)
+	const truths: Truth[] = []
+	const known = stored !== null
+	const fold =
+		condition.mode === 'insensitive' ? lower : (item: unknown) => item
+	const value = fold(stored)
+	for (const [operator, raw] of Object.entries(condition)) {
+		if (raw === undefined || operator === 'mode') continue
+		const operand: unknown = Array.isArray(raw)
+			? raw.map((item: unknown) => fold(item))
+			: fold(raw)
+		if (operator === 'equals' || operator === 'not') {
+			const equal =
+				operand === null ? !known : known ? same(value, operand) : null
+			truths.push(operator === 'equals' ? equal : not(equal))
+		} else if (operator === 'in' || operator === 'notIn') {
+			const list: readonly unknown[] = Array.isArray(operand) ? operand : []
+			const found =
+				list.length === 0
+					? false
+					: known
+						? list.some((item) => same(value, item))
+						: null
+			truths.push(operator === 'in' ? found : not(found))
+		} else if (!known) {
+			truths.push(null)
+		} else if (operator.startsWith('has') || operator === 'isEmpty') {
+			const items: readonly unknown[] = Array.isArray(value) ? value : []
+			const wanted: readonly unknown[] = Array.isArray(operand)
+				? operand
+				: [operand]
+			const holds = (item: unknown): boolean => items.includes(item)
+			truths.push(
+				operator === 'isEmpty'
+					? (items.length === 0) === operand
+					: operator === 'hasEvery'
+						? wanted.every(holds)
+						: wanted.some(holds),
+			)
+		} else if (operator === 'contains') {
+			truths.push(text(value, operand, (a, b) => a.includes(b)))
+		} else if (operator === 'startsWith') {
+			truths.push(text(value, operand, (a, b) => a.startsWith(b)))
+		} else if (operator === 'endsWith') {
+			truths.push(text(value, operand, (a, b) => a.endsWith(b)))
+		} else {
+			const order = compareValues(sorted(value), sorted(operand))
+			if (operator === 'lt') truths.push(order < 0)
+			else if (operator === 'lte') truths.push(order <= 0)
+			else if (operator === 'gt') truths.push(order > 0)
+			else truths.push(order >= 0)
+		}
+	}
+	return and(truths)
+}

package/src/memory-draft.ts

@@ -0,0 +1,319 @@
+// The draft a memory() write changes: a copy of the store, and what the
+// write changed for the feed (D-154).
+import type {
+	AggregateRead,
+	Arithmetic,
+	Change,
+	Changed,
+	CountRead,
+	ListUpdate,
+	Read,
+	Row,
+	ScalarType,
+	Schema,
+	SchemaField,
+	Write,
+} from './adapter.ts'
+import { CheckFailed, OutOfRange, UniqueViolation } from './adapter.ts'
+import type { Fields, Store, StoredRow } from './memory-read.ts'
+import { Reader } from './memory-read.ts'
+import { distinct, grouped } from './memory-aggregate.ts'
+import { copy } from './memory-values.ts'
+import { listed } from './list-update.ts'
+import { computed } from './number-update.ts'
+import { isInteger } from './query-where.ts'
+
+/**
+ * A value as PostgreSQL gives it back: `-0` is `0`, which `pg` sends for a
+ * number, and JSON text for json (D-94).
+ */
+function storedAs(type: ScalarType | undefined, value: unknown): unknown {
+	if (type === 'json') {
+		const parsed: unknown = JSON.parse(JSON.stringify(value))
+		return parsed
+	}
+	if (type === 'number' && value === 0) return 0
+	return copy(value)
+}
+
+function keyOf(values: readonly unknown[]): string {
+	return JSON.stringify(
+		values.map((value) =>
+			value instanceof Date ? `date:${value.getTime()}` : value,
+		),
+	)
+}
+
+export class Draft {
+	readonly reader: Reader
+	readonly schema: Schema
+	/** What the write changed, in order, for the feed (D-154). */
+	readonly changed: Changed[] = []
+
+	constructor(store: Store, fields: Fields, schema: Schema) {
+		this.reader = new Reader(store, fields)
+		this.schema = schema
+	}
+
+	find(read: Read): Row[] {
+		const stored = [...this.reader.table(read.model).values()]
+		const rows = read.distinct ? distinct(this.reader, read, stored) : stored
+		return this.reader
+			.select(read.model, rows, read)
+			.map((row) => this.reader.output(read.model, row, read))
+	}
+
+	count(read: CountRead): number {
+		return this.selected(read).length
+	}
+
+	aggregate(read: AggregateRead): unknown[][] {
+		return grouped(this.reader, read, this.selected(read))
+	}
+
+	private selected(read: CountRead): StoredRow[] {
+		const rows = [...this.reader.table(read.model).values()]
+		return rows.filter(
+			(row) => this.reader.matches(read.model, row, read.where) === true,
+		)
+	}
+
+	write(write: Write): Row[] {
+		for (const [index, check] of (write.checks ?? []).entries()) {
+			if (this.count(check) !== check.count) throw new CheckFailed(index)
+		}
+		const read = write.read
+		if (read !== undefined && write.before === true) {
+			const { model } = read
+			const deletes = write.changes.some(
+				(change) => change.kind === 'delete' && change.model === model,
+			)
+			const update = write.changes.find(
+				(change) => change.kind === 'update' && change.model === model,
+			)
+			if (!deletes) {
+				// The rows its update changed, as it left them (D-133).
+				const changed = update && this.matching(model, update)
+				const ids = new Set(changed?.map((row) => row.id))
+				this.change(write.changes)
+				return this.find(read).filter((row) => ids.has(row.id))
+			}
+			const rows = this.find(read)
+			this.change(write.changes)
+			// The rows the write's delete removed, as they were (D-104).
+			const table = this.reader.table(read.model)
+			return rows.filter((row) => !table.has(row.id))
+		}
+		this.change(write.changes)
+		return read === undefined ? [] : this.find(read)
+	}
+
+	private change(changes: readonly Change[]): void {
+		const touched = new Set<string>()
+		this.reader.removed.clear()
+		for (const [index, change] of changes.entries()) {
+			touched.add(change.model)
+			if (change.kind === 'delete') {
+				const removed = this.remove(change)
+				this.reader.removed.set(index, removed)
+				this.note({ kind: 'delete', model: change.model, ids: [...removed] })
+			} else this.apply(change)
+		}
+		for (const model of touched) this.checkUnique(model)
+	}
+
+	private note(change: Changed): void {
+		const rows = 'field' in change ? change.pairs : change.ids
+		if (rows?.length !== 0) this.changed.push(change)
+	}
+
+	private matching(model: string, change: Change): StoredRow[] {
+		if (change.kind !== 'update' && change.kind !== 'delete') return []
+		return [...this.reader.table(model).values()].filter(
+			(row) => this.reader.matches(model, row, change.where) === true,
+		)
+	}
+
+	private stored(
+		model: string,
+		value: { readonly [field: string]: unknown },
+	): { [field: string]: unknown } {
+		return Object.fromEntries(
+			Object.entries(value).map(([key, item]) => {
+				const field = this.reader.field(model, key)
+				const type = field?.kind === 'scalar' ? field.type : undefined
+				return [key, storedAs(type, item)]
+			}),
+		)
+	}
+
+	/** The numbers and lists a change computes on `row` (D-132, D-149). */
+	private computed(
+		model: string,
+		row: StoredRow,
+		compute: { readonly [field: string]: Arithmetic | ListUpdate } = {},
+	): { [field: string]: unknown } {
+		return Object.fromEntries(
+			Object.entries(compute).map(([key, operation]): [string, unknown] => {
+				if ('elements' in operation) return [key, listed(row[key], operation)]
+				const field = this.reader.field(model, key)
+				const integer = field?.kind === 'scalar' && field.integer === true
+				const result = computed(row[key], operation, integer)
+				if (integer ? !isInteger(result) : !Number.isFinite(result)) {
+					throw new OutOfRange(model, key)
+				}
+				return [key, result]
+			}),
+		)
+	}
+
+	/** Applies `delete`; returns the ids it removed. */
+	private remove(change: Extract<Change, { kind: 'delete' }>): Set<string> {
+		const table = this.reader.table(change.model)
+		const removed = new Set<string>()
+		for (const row of this.matching(change.model, change)) {
+			removed.add(row.id)
+			table.delete(row.id)
+			for (const field of this.joinFields(change.model)) {
+				this.unlink(change.model, field, row.id, [
+					...(this.side(change.model, field.name).get(row.id) ?? []),
+				])
+			}
+		}
+		return removed
+	}
+
+	private apply(change: Exclude<Change, { kind: 'delete' }>): void {
+		const table = this.reader.table(change.model)
+		switch (change.kind) {
+			case 'insert': {
+				if (table.has(change.row.id)) {
+					throw new UniqueViolation(change.model, ['id'])
+				}
+				table.set(change.row.id, {
+					...this.stored(change.model, change.row),
+					id: change.row.id,
+				})
+				this.note({ kind: 'insert', model: change.model, ids: [change.row.id] })
+				return
+			}
+			case 'update': {
+				const rows = this.matching(change.model, change)
+				for (const row of rows) {
+					const set = {
+						...change.set,
+						...this.computed(change.model, row, change.compute),
+					}
+					table.set(row.id, {
+						...row,
+						...this.stored(change.model, set),
+						id: row.id,
+					})
+				}
+				const fields = [
+					...Object.keys(change.set),
+					...Object.keys(change.compute ?? {}),
+				]
+				const ids = rows.map((row) => row.id)
+				this.note({ kind: 'update', model: change.model, ids, fields })
+				return
+			}
+			case 'link':
+			case 'unlink': {
+				const field = this.reader.field(change.model, change.field)
+				if (field?.kind !== 'many' || !field.join) {
+					throw new Error(`${change.model}.${change.field} has no join.`)
+				}
+				const { model, id } = change
+				const targets =
+					change.kind === 'unlink'
+						? this.unlink(model, field, id, change.targets)
+						: change.targets.filter((target) =>
+								this.link(model, field, id, target),
+							)
+				const pairs = targets.map((target): [string, string] => [id, target])
+				this.note({ kind: change.kind, model, field: field.name, pairs })
+				return
+			}
+		}
+	}
+
+	private joinFields(model: string): SchemaField[] {
+		return [...(this.reader.fields.get(model)?.values() ?? [])].filter(
+			(field) =>
+				field.kind === 'many' && field.join && field.from === undefined,
+		)
+	}
+
+	private side(model: string, field: string): Map<string, Set<string>> {
+		const name = `${model}.${field}`
+		let side = this.reader.store.joins.get(name)
+		if (side === undefined) {
+			side = new Map()
+			this.reader.store.joins.set(name, side)
+		}
+		return side
+	}
+
+	private ids(model: string, field: string, id: string): Set<string> {
+		const side = this.side(model, field)
+		let ids = side.get(id)
+		if (ids === undefined) {
+			ids = new Set()
+			side.set(id, ids)
+		}
+		return ids
+	}
+
+	/** Links `id` to `target` unless they were; tells whether it did. */
+	private link(
+		model: string,
+		field: Extract<SchemaField, { kind: 'many' }>,
+		id: string,
+		target: string,
+	): boolean {
+		const ids = this.ids(model, field.name, id)
+		if (ids.has(target)) return false
+		ids.add(target)
+		this.ids(field.target, field.inverse, target).add(id)
+		return true
+	}
+
+	/** Unlinks `id` from `targets`; returns the targets it was linked to. */
+	private unlink(
+		model: string,
+		field: SchemaField,
+		id: string,
+		targets: readonly string[],
+	): string[] {
+		if (field.kind !== 'many') return []
+		return targets.filter((target) => {
+			const removed = this.side(model, field.name).get(id)?.delete(target)
+			this.side(field.target, field.inverse).get(target)?.delete(id)
+			return removed === true
+		})
+	}
+
+	/** Unique fields, unique indexes and one-to-one keys; `null` never clashes. */
+	private checkUnique(model: string): void {
+		const definition = this.schema.models.find((each) => each.name === model)
+		if (definition === undefined) return
+		const sets: (readonly string[])[] = definition.indexes
+			.filter((index) => index.unique)
+			.map((index) => index.fields)
+		for (const field of definition.fields) {
+			if (field.kind !== 'many' && field.unique) sets.push([field.name])
+		}
+		const rows = [...this.reader.table(model).values()]
+		for (const fields of sets) {
+			const seen = new Set<string>()
+			for (const row of rows) {
+				const values = fields.map((field) => row[field] ?? null)
+				if (values.includes(null)) continue
+				const found = keyOf(values)
+				if (seen.has(found)) throw new UniqueViolation(model, fields)
+				seen.add(found)
+			}
+		}
+	}
+}