@ultimabase/graphql 0.0.0-stage → 0.1.0

package/src/mutations.ts

@@ -0,0 +1,317 @@
+// The writes (D-107): `createPost(data)`, `updatePost(where, data)`,
+// `upsertPost(where, create, update)` (D-142) and `deletePost(where)`, each
+// one kernel write run as its caller. A create, an update and an upsert
+// return the row as the query asks for it, a delete the row as it was,
+// without its relations.
+import { run } from '@ultimabase/http/internal'
+import type {
+	GraphQLFieldConfig,
+	GraphQLInputFieldConfigMap,
+	GraphQLNullableInputType,
+} from 'graphql'
+import {
+	GraphQLBoolean,
+	GraphQLID,
+	GraphQLInputObjectType,
+	GraphQLList,
+	GraphQLNonNull,
+} from 'graphql'
+import type { SchemaField } from 'ultimabase'
+import { objectOf, uniqueInput, uniqueWhere } from './inputs.ts'
+import { jsonInput, plainData } from './json-fields.ts'
+import { upper } from './names.ts'
+import { deletedType, isMaster, objectType } from './outputs.ts'
+import type { Args, Context, Entry, Registry } from './registry.ts'
+import { as, described, valueType } from './registry.ts'
+import { JSONScalar } from './scalars.ts'
+import { selectOf } from './select.ts'
+
+type Fields = { [field: string]: GraphQLFieldConfig<unknown, Context, Args> }
+
+/** `ConnectInput { id }`: what a relation write names a row by. */
+const connectInput = (registry: Registry): GraphQLInputObjectType =>
+	registry.input(
+		'ConnectInput',
+		() =>
+			new GraphQLInputObjectType({
+				name: 'ConnectInput',
+				fields: { id: { type: new GraphQLNonNull(GraphQLID) } },
+			}),
+	)
+
+type Relation = Exclude<SchemaField, { readonly kind: 'scalar' }>
+
+const facing = (field: Relation): string => `Without${upper(field.inverse)}`
+
+/** `CommentCreateOrConnectWithoutPostInput { where, create }` (D-138). */
+const orCreateInput = (
+	registry: Registry,
+	field: Relation,
+): GraphQLInputObjectType => {
+	const name = `${field.target}CreateOrConnect${facing(field)}Input`
+	return registry.input(
+		name,
+		() =>
+			new GraphQLInputObjectType({
+				name,
+				fields: () => ({
+					where: {
+						type: new GraphQLNonNull(uniqueInput(registry, field.target)),
+					},
+					create: {
+						type: new GraphQLNonNull(
+							dataInput(registry, field.target, true, field.inverse),
+						),
+					},
+				}),
+			}),
+	)
+}
+
+/** `CommentUpdateWithWhereUniqueWithoutPostInput { where, data }` (D-138). */
+const updateWhereInput = (
+	registry: Registry,
+	field: Relation,
+): GraphQLInputObjectType => {
+	const name = `${field.target}UpdateWithWhereUnique${facing(field)}Input`
+	return registry.input(
+		name,
+		() =>
+			new GraphQLInputObjectType({
+				name,
+				fields: () => ({
+					where: {
+						type: new GraphQLNonNull(uniqueInput(registry, field.target)),
+					},
+					data: {
+						type: new GraphQLNonNull(
+							dataInput(registry, field.target, false, field.inverse),
+						),
+					},
+				}),
+			}),
+	)
+}
+
+/**
+ * A relation's write, named as Prisma names it (D-20, D-128, D-138): a
+ * create connects or creates, an update also disconnects, unless the
+ * relation is a required `one`, and updates or deletes a linked row; a
+ * `many` is also `set`. `create` takes the target's data without the
+ * relation back: `PostCreateInput.comments` is
+ * `CommentCreateNestedManyWithoutPostInput { connect, connectOrCreate,
+ * create: [CommentCreateWithoutPostInput!] }`. A hidden model is not
+ * created, updated or deleted over GraphQL, through a relation either, as
+ * in Parse.
+ */
+function relationInput(
+	registry: Registry,
+	field: Relation,
+	creating: boolean,
+): GraphQLInputObjectType {
+	const many = field.kind === 'many'
+	const shape = many ? 'Many' : field.optional ? 'One' : 'OneRequired'
+	const name = creating
+		? `${field.target}CreateNested${many ? 'Many' : 'One'}${facing(field)}Input`
+		: `${field.target}Update${shape}${facing(field)}NestedInput`
+	return registry.input(name, () => {
+		const listed = <T extends GraphQLInputObjectType>(type: T) =>
+			many ? new GraphQLList(new GraphQLNonNull(type)) : type
+		const row = listed(connectInput(registry))
+		const visible = registry.entry(field.target).visible
+		const updating = !creating && visible
+		const fields: GraphQLInputFieldConfigMap = { connect: { type: row } }
+		if (visible) {
+			fields['connectOrCreate'] = {
+				type: listed(orCreateInput(registry, field)),
+			}
+			const created = dataInput(registry, field.target, true, field.inverse)
+			fields['create'] = { type: listed(created) }
+		}
+		if (updating && shape !== 'OneRequired') {
+			const unique = uniqueInput(registry, field.target)
+			fields['delete'] = { type: many ? listed(unique) : GraphQLBoolean }
+		}
+		if (!creating && shape !== 'OneRequired') {
+			fields['disconnect'] = { type: many ? row : GraphQLBoolean }
+		}
+		// A filtered relation takes no `set` (D-151).
+		if (!creating && many && field.filtered !== true) {
+			fields['set'] = { type: row }
+		}
+		if (updating) {
+			fields['update'] = {
+				type: many
+					? listed(updateWhereInput(registry, field))
+					: dataInput(registry, field.target, false, field.inverse),
+			}
+		}
+		// A `one` relation takes one of them.
+		return new GraphQLInputObjectType({ name, fields, isOneOf: !many })
+	})
+}
+
+/**
+ * The kernel's data from a mutation's: its json values plain, and each
+ * nested row's data and unique target too (D-128, D-138).
+ */
+function kernelData(registry: Registry, model: string, data: Args): Args {
+	const plained: { [field: string]: unknown } = plainData(registry, model, data)
+	for (const field of registry.entry(model).model.fields) {
+		const value = plained[field.name]
+		if (field.kind === 'scalar' || typeof value !== 'object' || value === null)
+			continue
+		const { target } = field
+		const row = (item: unknown) => kernelData(registry, target, objectOf(item))
+		const unique = (item: unknown) =>
+			uniqueWhere(registry, target, objectOf(item))
+		const write: { [key: string]: unknown } = { ...value }
+		const map = (key: string, read: (item: unknown) => unknown) => {
+			const operand = write[key]
+			if (operand === undefined || operand === null) return
+			write[key] = Array.isArray(operand) ? operand.map(read) : read(operand)
+		}
+		map('create', row)
+		map('connectOrCreate', (item) => {
+			const { where, create } = objectOf(item)
+			return { where: unique(where), create: row(create) }
+		})
+		if (field.kind === 'many') {
+			map('update', (item) => {
+				const { where, data: changes } = objectOf(item)
+				return { where: unique(where), data: row(changes) }
+			})
+			map('delete', unique)
+		} else map('update', row)
+		plained[field.name] = write
+	}
+	return plained
+}
+
+function fieldInput(
+	registry: Registry,
+	model: string,
+	field: SchemaField,
+	creating: boolean,
+): GraphQLNullableInputType {
+	if (field.kind === 'scalar' && field.type === 'json') {
+		return jsonInput(registry, model, field).type
+	}
+	// A plugin field's schema takes its JSON (D-122).
+	if (registry.entry(model).exposed.fieldTypes[field.name] !== undefined) {
+		return JSONScalar
+	}
+	if (field.kind === 'scalar') return valueType(registry, model, field)
+	return relationInput(registry, field, creating)
+}
+
+/**
+ * `PostCreateInput` and `PostUpdateInput`: every field, those only Master
+ * reads included. A create needs the fields its type needs, neither optional
+ * nor with a default (D-53); the others are optional. A row created or
+ * updated through a relation takes `CommentCreateWithoutPostInput` or
+ * `CommentUpdateWithoutPostInput`, without that relation (D-128, D-138).
+ */
+function dataInput(
+	registry: Registry,
+	model: string,
+	creating: boolean,
+	without?: string,
+): GraphQLInputObjectType {
+	const name = `${model}${creating ? 'Create' : 'Update'}${
+		without === undefined ? '' : `Without${upper(without)}`
+	}Input`
+	return registry.input(
+		name,
+		() =>
+			new GraphQLInputObjectType({
+				name,
+				fields: () => {
+					const { exposed } = registry.entry(model)
+					const required = new Set(creating ? exposed.required : [])
+					const fields: GraphQLInputFieldConfigMap = {}
+					for (const field of exposed.schema.fields) {
+						// A view is read-only (D-151).
+						const view = field.kind === 'many' && field.from !== undefined
+						if (field.name === without || view) continue
+						const type = fieldInput(registry, model, field, creating)
+						fields[field.name] = {
+							type: required.has(field.name) ? new GraphQLNonNull(type) : type,
+						}
+					}
+					return described(registry.entry(model), fields)
+				},
+			}),
+	)
+}
+
+/** A visible model's four mutations. */
+export function mutationFields(registry: Registry, entry: Entry): Fields {
+	const name = entry.model.name
+	const type = objectType(registry, name)
+	const { queries } = entry.exposed
+	const where = { type: new GraphQLNonNull(uniqueInput(registry, name)) }
+	const data = (creating: boolean) => ({
+		type: new GraphQLNonNull(dataInput(registry, name, creating)),
+	})
+	const written =
+		(
+			write: (args: Args, select: Args, context: Context) => Promise<unknown>,
+		): GraphQLFieldConfig<unknown, Context, Args>['resolve'] =>
+		async (_, args, context, info) => {
+			const select = selectOf(
+				registry,
+				info,
+				type,
+				info.fieldNodes,
+				isMaster(context),
+			)
+			return run(() => write(args, select, context))
+		}
+	const unique = (args: Args): Args =>
+		uniqueWhere(registry, name, objectOf(args['where']))
+	const dataOf = (args: Args): Args =>
+		kernelData(registry, name, objectOf(args['data']))
+	return {
+		[`create${name}`]: {
+			type: new GraphQLNonNull(type),
+			args: { data: data(true) },
+			resolve: written(async (args, select, context) =>
+				queries.create({ data: dataOf(args), select }, as(context)),
+			),
+		},
+		[`update${name}`]: {
+			type: new GraphQLNonNull(type),
+			args: { where, data: data(false) },
+			resolve: written(async (args, select, context) =>
+				queries.update(
+					{ where: unique(args), data: dataOf(args), select },
+					as(context),
+				),
+			),
+		},
+		// The row it created or updated, as either branch returns it (D-142).
+		[`upsert${name}`]: {
+			type: new GraphQLNonNull(type),
+			args: { where, create: data(true), update: data(false) },
+			resolve: written(async (args, select, context) => {
+				const { row } = await entry.exposed.upsert(
+					{
+						where: unique(args),
+						create: kernelData(registry, name, objectOf(args['create'])),
+						update: kernelData(registry, name, objectOf(args['update'])),
+						select,
+					},
+					as(context),
+				)
+				return row
+			}),
+		},
+		[`delete${name}`]: {
+			type: new GraphQLNonNull(deletedType(registry, name)),
+			args: { where },
+			resolve: async (_, args, context) =>
+				run(async () => queries.delete({ where: unique(args) }, as(context))),
+		},
+	}
+}

package/src/names.ts

@@ -0,0 +1,25 @@
+// The names the schema gives each model's types and root fields (D-107).
+
+import { plural } from '@ultimabase/http/internal'
+import { Refused } from 'ultimabase'
+
+export const upper = (name: string): string =>
+	name.charAt(0).toUpperCase() + name.slice(1)
+
+export const lower = (name: string): string =>
+	name.charAt(0).toLowerCase() + name.slice(1)
+
+/** A model's root fields: its one-row name and its list name. */
+export function rootNames(
+	model: string,
+	given: string | undefined,
+): { readonly single: string; readonly list: string } {
+	const single = lower(model)
+	const list = given ?? plural(single)
+	if (list === single) {
+		throw new Refused(
+			`${model}: its list field would be named ${single} too; set .with({ graphql: { plural } }).`,
+		)
+	}
+	return { single, list }
+}

package/src/outputs.ts

@@ -0,0 +1,267 @@
+// The output types (D-107): each model's object type, its edges and
+// connections, and the arguments of its lists.
+import { connection, readable, rowsOf } from '@ultimabase/http/internal'
+import type {
+	GraphQLFieldConfig,
+	GraphQLFieldConfigArgumentMap,
+	GraphQLFieldConfigMap,
+} from 'graphql'
+import {
+	GraphQLBoolean,
+	GraphQLID,
+	GraphQLInt,
+	GraphQLList,
+	GraphQLNonNull,
+	GraphQLObjectType,
+	GraphQLString,
+} from 'graphql'
+import type { SchemaField } from 'ultimabase'
+import { orderByInput, whereInput } from './inputs.ts'
+import { upper } from './names.ts'
+import { listRead } from './pages.ts'
+import { jsonOutput } from './json-fields.ts'
+import type { Args, Context, Registry } from './registry.ts'
+import { described, valueType } from './registry.ts'
+import { DateTime } from './scalars.ts'
+
+const required = <T extends GraphQLObjectType>(type: T) =>
+	new GraphQLNonNull(type)
+
+export const isMaster = (context: Context): boolean =>
+	context.caller.kind === 'master'
+
+/** `first`, `after`, `last`, `before`, or `take` and `skip`; then filters. */
+export function listArgs(
+	registry: Registry,
+	model: string,
+): GraphQLFieldConfigArgumentMap {
+	const pages: GraphQLFieldConfigArgumentMap =
+		registry.settings.pagination === 'list'
+			? { take: { type: GraphQLInt }, skip: { type: GraphQLInt } }
+			: {
+					first: { type: GraphQLInt },
+					after: { type: GraphQLString },
+					last: { type: GraphQLInt },
+					before: { type: GraphQLString },
+				}
+	return {
+		...pages,
+		where: { type: whereInput(registry, model) },
+		orderBy: {
+			type: new GraphQLList(new GraphQLNonNull(orderByInput(registry, model))),
+		},
+	}
+}
+
+const pageInfo = (registry: Registry): GraphQLObjectType =>
+	registry.object(
+		'PageInfo',
+		() =>
+			new GraphQLObjectType({
+				name: 'PageInfo',
+				fields: {
+					hasNextPage: { type: new GraphQLNonNull(GraphQLBoolean) },
+					hasPreviousPage: { type: new GraphQLNonNull(GraphQLBoolean) },
+					startCursor: { type: GraphQLString },
+					endCursor: { type: GraphQLString },
+				},
+			}),
+	)
+
+const edge = (registry: Registry, model: string): GraphQLObjectType =>
+	registry.object(
+		`${model}Edge`,
+		() =>
+			new GraphQLObjectType({
+				name: `${model}Edge`,
+				fields: () => ({
+					cursor: { type: new GraphQLNonNull(GraphQLString) },
+					node: { type: required(objectType(registry, model)) },
+				}),
+			}),
+	)
+
+/**
+ * `PostConnection` at the root, `UserPostsConnection` on a relation, each
+ * with `totalCount` (D-107, D-134).
+ */
+export function connectionType(
+	registry: Registry,
+	name: string,
+	model: string,
+): GraphQLObjectType {
+	return registry.object(
+		name,
+		() =>
+			new GraphQLObjectType({
+				name,
+				fields: () => ({
+					edges: {
+						type: new GraphQLNonNull(
+							new GraphQLList(required(edge(registry, model))),
+						),
+					},
+					pageInfo: { type: required(pageInfo(registry)) },
+					// A function the default resolver calls: counted when selected.
+					totalCount: { type: new GraphQLNonNull(GraphQLInt) },
+				}),
+			}),
+	)
+}
+
+/**
+ * A relation's value in its row: `null` when absent and its read rule may
+ * hide it. Absent otherwise, the resolver that returned the row did not read
+ * it, such as one `extend` added.
+ */
+function readOf(
+	source: unknown,
+	model: string,
+	field: string,
+	ruled: boolean,
+): unknown {
+	const value: unknown = Reflect.get(Object(source), field)
+	if (value !== undefined) return value
+	if (ruled) return null
+	throw new Error(
+		`${model}.${field} was not read; select it with context.select(info).`,
+	)
+}
+
+/** A `many` relation: a connection, or a list with `pagination: 'list'`. */
+function manyField(
+	registry: Registry,
+	model: string,
+	field: Extract<SchemaField, { readonly kind: 'many' }>,
+	ruled: boolean,
+): GraphQLFieldConfig<unknown, Context, Args> {
+	const target = objectType(registry, field.target)
+	const type =
+		registry.settings.pagination === 'list'
+			? new GraphQLList(required(target))
+			: connectionType(
+					registry,
+					`${model}${upper(field.name)}Connection`,
+					field.target,
+				)
+	return {
+		// Absent when the field's read rule hides it (D-44).
+		type: ruled ? type : new GraphQLNonNull(type),
+		args: listArgs(registry, field.target),
+		resolve: (source, args, context) => {
+			const value = readOf(source, model, field.name, ruled)
+			if (value === null) return null
+			const rows = rowsOf(value)
+			const { page } = listRead(
+				registry,
+				registry.entry(field.target),
+				args,
+				isMaster(context),
+			)
+			if (page === undefined) return rows
+			return {
+				...connection(rows, page, (row) => row),
+				// The row's `_count`, read when the connection selects it (D-134).
+				totalCount: () => {
+					const counts: unknown = Reflect.get(Object(source), '_count')
+					const count: unknown = Reflect.get(Object(counts), field.name)
+					if (typeof count === 'number') return count
+					throw new Error(
+						`${model}.${field.name} was not counted; select it with context.select(info).`,
+					)
+				},
+			}
+		},
+	}
+}
+
+/** `id`, the dates and each scalar field a caller other than Master reads. */
+function scalarFields(
+	registry: Registry,
+	model: string,
+): GraphQLFieldConfigMap<unknown, Context> {
+	const entry = registry.entry(model)
+	const fields: GraphQLFieldConfigMap<unknown, Context> = {
+		id: { type: new GraphQLNonNull(GraphQLID) },
+		createdAt: { type: new GraphQLNonNull(DateTime) },
+		updatedAt: { type: new GraphQLNonNull(DateTime) },
+	}
+	for (const field of readable(entry)) {
+		if (field.kind !== 'scalar') continue
+		const ruled = entry.exposed.readRules[field.name] === 'rule'
+		const fieldType = entry.exposed.fieldTypes[field.name]
+		if (fieldType !== undefined) {
+			// A plugin field reads as its toJSON gives (D-122), typed by its
+			// shape (D-152).
+			const { type, nullable } = jsonOutput(registry, model, field)
+			fields[field.name] = {
+				type:
+					field.optional || ruled || nullable ? type : new GraphQLNonNull(type),
+				resolve: (source) => {
+					const value = readOf(source, model, field.name, ruled)
+					return value === null ? null : fieldType.toJSON(value)
+				},
+			}
+			continue
+		}
+		const { type, nullable } =
+			field.type === 'json'
+				? jsonOutput(registry, model, field)
+				: { type: valueType(registry, model, field), nullable: false }
+		fields[field.name] = {
+			type:
+				field.optional || ruled || nullable ? type : new GraphQLNonNull(type),
+		}
+	}
+	return fields
+}
+
+/** `Post`: a field only Master reads is absent, a ruled one nullable. */
+export function objectType(
+	registry: Registry,
+	model: string,
+): GraphQLObjectType {
+	return registry.object(
+		model,
+		() =>
+			new GraphQLObjectType<unknown, Context>({
+				name: model,
+				description: registry.entry(model).exposed.description,
+				fields: () => {
+					const entry = registry.entry(model)
+					const fields = scalarFields(registry, model)
+					for (const field of readable(entry)) {
+						const ruled = entry.exposed.readRules[field.name] === 'rule'
+						if (field.kind === 'one') {
+							// Its target's read rule may hide the row (D-86).
+							fields[field.name] = {
+								type: objectType(registry, field.target),
+								resolve: (source) => readOf(source, model, field.name, ruled),
+							}
+						} else if (field.kind === 'many') {
+							fields[field.name] = manyField(registry, model, field, ruled)
+						}
+					}
+					Object.assign(fields, registry.virtualFields(model))
+					return described(entry, fields)
+				},
+			}),
+	)
+}
+
+/** `DeletedPost`: a deleted row as it was, without its relations (D-102). */
+export function deletedType(
+	registry: Registry,
+	model: string,
+): GraphQLObjectType {
+	const name = `Deleted${model}`
+	return registry.object(
+		name,
+		() =>
+			new GraphQLObjectType<unknown, Context>({
+				name,
+				fields: () =>
+					described(registry.entry(model), scalarFields(registry, model)),
+			}),
+	)
+}

package/src/overlap.ts

@@ -0,0 +1,97 @@
+// The bound on graphql-js's overlapping-fields rule (D-107): the rule
+// compares every two fields that merge under one response key, so a
+// document whose merged fields make more than `maxPairs` such pairs is
+// refused before it is validated.
+import type {
+	DocumentNode,
+	FieldNode,
+	FragmentDefinitionNode,
+	SelectionSetNode,
+} from 'graphql'
+import { GraphQLError, Kind } from 'graphql'
+
+/** At about 28 µs a pair, the rule's slowest, about 30 ms of validation. */
+const maxPairs = 1000
+
+/** Fields of one key, and how many came from each place (see `merged`). */
+interface Merged {
+	readonly fields: FieldNode[]
+	readonly from: Map<string, number>
+}
+
+const pairsOf = (fields: number) => (fields * (fields - 1)) / 2
+
+/** The refusal of a document whose fields of one key make too many pairs. */
+export function overlapRefusal(
+	document: DocumentNode,
+): GraphQLError | undefined {
+	const fragments = new Map<string, FragmentDefinitionNode>()
+	for (const definition of document.definitions) {
+		if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+			fragments.set(definition.name.value, definition)
+		}
+	}
+	// A selection set merged with no other is counted once, wherever it is
+	// reached, as the rule compares its fields once.
+	const counted = new Set<SelectionSetNode>()
+	let pairs = 0
+	/**
+	 * The fields of `sets` by response key, fragments spread once, each with
+	 * how many came from each fragment spread in `sets`, or from `sets`.
+	 */
+	const merged = (sets: readonly SelectionSetNode[]) => {
+		const byKey = new Map<string, Merged>()
+		const spread = new Set<string>()
+		const collect = (set: SelectionSetNode, from: string): void => {
+			for (const selection of set.selections) {
+				if (selection.kind === Kind.FIELD) {
+					const key = selection.alias?.value ?? selection.name.value
+					const same: Merged = byKey.get(key) ?? { fields: [], from: new Map() }
+					byKey.set(key, same)
+					same.fields.push(selection)
+					same.from.set(from, (same.from.get(from) ?? 0) + 1)
+				} else if (selection.kind === Kind.INLINE_FRAGMENT) {
+					collect(selection.selectionSet, from)
+				} else {
+					const name = selection.name.value
+					const fragment = fragments.get(name)
+					if (fragment === undefined || spread.has(name)) continue
+					spread.add(name)
+					collect(fragment.selectionSet, from === '' ? name : from)
+				}
+			}
+		}
+		for (const set of sets) collect(set, '')
+		return byKey.values()
+	}
+	const walk = (sets: readonly SelectionSetNode[]): void => {
+		const [only] = sets
+		if (sets.length === 1 && only !== undefined) {
+			if (counted.has(only)) return
+			counted.add(only)
+		}
+		for (const { fields, from } of merged(sets)) {
+			if (pairs > maxPairs) return
+			pairs += pairsOf(fields.length)
+			// The pairs within a fragment are counted where it is defined.
+			for (const [fragment, count] of from) {
+				if (fragment !== '') pairs -= pairsOf(count)
+			}
+			if (from.size === 1 && !from.has('')) continue
+			const below = fields.flatMap((field) => field.selectionSet ?? [])
+			if (below.length > 0) walk(below)
+		}
+	}
+	for (const definition of document.definitions) {
+		if (
+			definition.kind === Kind.OPERATION_DEFINITION ||
+			definition.kind === Kind.FRAGMENT_DEFINITION
+		) {
+			walk([definition.selectionSet])
+		}
+	}
+	if (pairs <= maxPairs) return undefined
+	return new GraphQLError(
+		'The document repeats fields under one name too often. Ask for each field once.',
+	)
+}