ultimabase 0.0.0-stage → 0.1.0

package/src/fields.ts

@@ -0,0 +1,383 @@
+// Field builders (D-09, D-12); a field's `.with` takes the rules of
+// field-rules.ts (D-44).
+import type { Declared, FieldWith } from './field-rules.ts'
+import type { Caller } from './rules.ts'
+import type { calendarDay, fieldType } from './symbols.ts'
+import type { NoOptions, Virtual, VirtualOptions } from './virtual.ts'
+
+export type JsonValue =
+	| string
+	| number
+	| boolean
+	| null
+	| readonly JsonValue[]
+	| { readonly [key: string]: JsonValue }
+
+/**
+ * Standard Schema (standardschema.dev), the part the kernel reads. Its
+ * specification asks for the interface to be copied, not imported.
+ */
+export interface StandardSchema<I = unknown, O = I> {
+	readonly '~standard': {
+		readonly version: 1
+		readonly vendor: string
+		readonly validate: (
+			value: unknown,
+		) => SchemaResult<O> | Promise<SchemaResult<O>>
+		readonly types?: { readonly input: I; readonly output: O } | undefined
+	}
+}
+type SchemaResult<O> =
+	| { readonly value: O; readonly issues?: undefined }
+	| { readonly issues: readonly { readonly message: string }[] }
+
+/**
+ * A field's `validate` (D-23): a Standard Schema, or a function that returns
+ * the value to store and throws to refuse it.
+ */
+export type Validate<V> = StandardSchema<V, V> | ((value: V) => V | Promise<V>)
+
+/** A default's function form: `undefined` gives no value (D-53). */
+export type DefaultFunction<V> = (facts: {
+	readonly caller: Caller
+}) => V | undefined
+
+/** What a field means, which the transports show and nothing reads (D-150). */
+export type Described = { readonly description?: string }
+
+/** What shapes a scalar field (D-08, D-23, D-52, D-53). */
+export type ScalarOptions<V> = Described & {
+	readonly optional?: boolean
+	readonly unique?: boolean
+	readonly default?: V | DefaultFunction<V>
+	readonly validate?: Validate<V>
+	/** The stored column's name, when the adapter's convention will not do (D-63). */
+	readonly dbName?: string
+}
+
+/** What a calendar day's options carry in its type, filtered in order (D-150). */
+export type Day = { readonly [calendarDay]: true }
+
+/** A decimal's options: its digits are required (D-145). */
+export type DecimalOptions = ScalarOptions<string> & {
+	readonly precision: number
+	readonly scale: number
+}
+
+/** A shared enum, which `defineEnum` returns frozen (D-150). */
+export type Enum<E extends string = string> = {
+	/** Its GraphQL enum's and its OpenAPI schema's name. */
+	readonly name: string
+	readonly values: readonly E[]
+	readonly description: string | undefined
+}
+
+/** A field's options without `list` (D-120, D-127). */
+export type SingleOptions<V> = ScalarOptions<V> & { readonly list?: false }
+
+/** A string's options: `search` adds it to its model's document (D-148). */
+export type StringOptions = SingleOptions<string> & {
+	readonly search?: boolean
+}
+
+/** What shapes a list of strings, numbers or enum values (D-120, D-127). */
+export type ListOptions<V> = Described & {
+	readonly list: true
+	readonly default?: readonly V[] | DefaultFunction<readonly V[]>
+	readonly validate?: Validate<readonly V[]>
+	readonly dbName?: string
+}
+// A list is `[]` when empty and may hold a value twice. The messages are
+// objects, as OneCheck's.
+type ListCheck<O> = (O extends { readonly optional: unknown }
+	? {
+			readonly optional: {
+				readonly error: 'a list is [] when empty: it is never optional'
+			}
+		}
+	: unknown) &
+	(O extends { readonly unique: unknown }
+		? { readonly unique: { readonly error: 'a list cannot be unique' } }
+		: unknown) &
+	(O extends { readonly search: unknown }
+		? { readonly search: { readonly error: 'a list is not searched' } }
+		: unknown)
+type ListableCheck<O, V> = O extends { readonly list: true }
+	? ListCheck<O> & ValidateCheck<O, readonly V[]>
+	: ValidateCheck<O, V>
+type Listable<V, O, T> = O extends { readonly list: true }
+	? Field<readonly V[], O, never, T>
+	: Field<V, O, never, T>
+
+/** The types a Standard Schema declares, `never` without them. */
+export type SchemaTypes<S> = S extends {
+	readonly '~standard': { readonly types?: infer T }
+}
+	? NonNullable<T>
+	: never
+type IsAny<X> = 0 extends 1 & X ? true : false
+/** Refuses a schema typed `any` or without types, under `validate`. */
+export type AnyCheck<S> =
+	SchemaTypes<S> extends { readonly input: infer I; readonly output: infer O }
+		? IsAny<I> extends true
+			? { readonly validate: 'the schema types its input as any' }
+			: IsAny<O> extends true
+				? { readonly validate: 'the schema types its output as any' }
+				: unknown
+		: { readonly validate: 'the schema declares no types' }
+// A schema is checked on its line: its input must take every value of the
+// field, which the covariant `types` alone would not refuse.
+type ValidateCheck<O, V> = O extends {
+	readonly validate: infer S extends StandardSchema
+}
+	? unknown extends AnyCheck<S>
+		? SchemaTypes<S> extends { readonly input: infer I }
+			? [V] extends [I]
+				? unknown
+				: {
+						readonly validate: 'the schema must accept every value of the field'
+					}
+			: unknown
+		: AnyCheck<S>
+	: unknown
+
+/** What shapes a `json` field (D-53): its schema gives its types. */
+export type JsonOptions = Described & {
+	readonly optional?: boolean
+	// Any value; the function member types `caller`. JsonCheck checks it.
+	readonly default?: DefaultFunction<unknown> | {} | null
+	readonly validate?: StandardSchema | ((value: JsonValue) => unknown)
+	readonly dbName?: string
+}
+/** What a `json` field stores and returns: the schema's output. */
+type JsonOutput<O> = O extends { readonly validate: infer S }
+	? S extends StandardSchema
+		? SchemaTypes<S>['output']
+		: S extends (value: JsonValue) => infer R
+			? Awaited<R>
+			: unknown
+	: unknown
+/** What a `json` field is written: the schema's input. */
+type JsonInput<O> = O extends { readonly validate: infer S }
+	? S extends StandardSchema
+		? SchemaTypes<S>['input']
+		: JsonValue
+	: JsonValue
+// Defaults are validated (D-67), so a default is the schema's input.
+type JsonCheck<O> = (O extends {
+	readonly validate: infer S extends StandardSchema
+}
+	? AnyCheck<S>
+	: unknown) &
+	(O extends { readonly default: infer D }
+		? [D] extends [JsonInput<O> | DefaultFunction<JsonInput<O>>]
+			? unknown
+			: { readonly default: JsonInput<O> | DefaultFunction<JsonInput<O>> }
+		: unknown)
+
+/** What shapes a `one` relation (D-37, D-54). */
+export type OneOptions = Described & {
+	readonly optional?: boolean
+	/** The target's id (D-53). */
+	readonly default?:
+		{ readonly id: string } | DefaultFunction<{ readonly id: string }>
+	readonly onDelete?: 'cascade' | 'restrict' | 'setNull'
+	readonly inverse?: string
+	readonly dbName?: string
+}
+// `setNull` empties the relation, which only an optional one may be (D-54).
+// The message is an object: a literal would empty the whole options type.
+type OneCheck<O> = O extends { readonly optional: true }
+	? unknown
+	: O extends { readonly onDelete: 'setNull' }
+		? {
+				readonly onDelete: {
+					readonly error: 'setNull needs an optional relation'
+				}
+			}
+		: unknown
+
+export type ManyOptions = Described &
+	(
+		| { readonly inverse?: string; readonly from?: undefined }
+		| {
+				/**
+				 * A view: read-only, on the link of this other `many` of the
+				 * model, its rows those its filter keeps (D-151).
+				 */
+				readonly from: string
+				readonly inverse?: undefined
+		  }
+	)
+
+/** An optional field may be written `null`. */
+type Written<V, O> = O extends { readonly optional: true } ? V | null : V
+
+/**
+ * `V` is the stored value and `I` the written one, which differ when a
+ * schema transforms (D-23). `P` names the plugin that provides the field
+ * type (D-32); `T` is the types of the plugins the model uses, whose field
+ * rules `.with` takes. Rules judge what the caller sent (D-67): they see `I`.
+ * `J` marks a `json` field, which cannot be sorted (D-94); `S` is a plugin
+ * field type's stored field, which a `beforeFind` filters (D-122).
+ */
+export interface Field<
+	V,
+	O,
+	P extends string = never,
+	T = never,
+	I = V,
+	J extends boolean = false,
+	S = never,
+> {
+	readonly [fieldType]: {
+		readonly kind: 'scalar'
+		readonly value: V
+		readonly input: I
+		readonly options: O
+		readonly plugin?: P
+		readonly json: J
+		readonly stored: S
+	}
+	/**
+	 * `.with({ ... })` types `value` and `record.id`;
+	 * `.with<{ status: 'draft' | 'published' }>` also types the record fields it
+	 * declares, each with the model's exact type (D-44).
+	 */
+	// With a declared record, `.with<{ ... }>`; refused without one, so the
+	// next signature applies.
+	with<R extends object>(
+		rules: [keyof R] extends [never]
+			? never
+			: FieldWith<NoInfer<R>, Written<I, O>, T>,
+	): Field<V, O, P, never, I, J, S> & Declared<R>
+	with(
+		rules: FieldWith<never, Written<I, O>, T>,
+	): Field<V, O, P, never, I, J, S>
+}
+
+export type RelationValue = { readonly id: string }
+
+/** What a `many` relation's write rule sees: the caller's lists (D-86). */
+export type ManyValue = {
+	readonly connect: readonly RelationValue[]
+	readonly disconnect: readonly RelationValue[]
+	/** The linked rows it deletes (D-138). */
+	readonly delete: readonly RelationValue[]
+	/** The rows it creates, by the ids the kernel gives them (D-128). */
+	readonly create: readonly RelationValue[]
+}
+
+// `T` is the target's thunk, constrained to `object` only: its return type
+// is read lazily, in queries and at registration, never while declaring.
+export interface One<T, O, U = never> {
+	readonly [fieldType]: {
+		readonly kind: 'one'
+		readonly target: T
+		readonly options: O
+	}
+	with<R extends object = never>(
+		rules: FieldWith<NoInfer<R>, RelationValue | null, U>,
+	): One<T, O> & Declared<R>
+}
+
+export interface Many<T, O, U = never> {
+	readonly [fieldType]: {
+		readonly kind: 'many'
+		readonly target: T
+		readonly options: O
+	}
+	with<R extends object = never>(
+		rules: FieldWith<NoInfer<R>, ManyValue, U>,
+	): Many<T, O> & Declared<R>
+}
+
+/**
+ * The field builders, which only `defineModel`'s `fields` callback receives:
+ * typed by the model's `use`, a field's `.with` takes those plugins' rules
+ * (D-12, D-57).
+ */
+export interface FieldBuilders<T> {
+	/**
+	 * With `list: true`, a list of strings, `[]` when empty (D-120); with
+	 * `search: true`, matched by its model's `_search` (D-148).
+	 */
+	readonly string: <
+		const O extends StringOptions | ListOptions<string> = StringOptions,
+	>(
+		options?: O & NoInfer<ListableCheck<O, string>>,
+	) => Listable<string, O, T>
+	/**
+	 * With `list: true`, a list of numbers, `[]` when empty (D-127); with
+	 * `integer: true`, whole numbers from -2,147,483,648 to 2,147,483,647
+	 * (D-132).
+	 */
+	readonly number: <
+		const O extends (SingleOptions<number> | ListOptions<number>) & {
+			readonly integer?: boolean
+		} = SingleOptions<number>,
+	>(
+		options?: O & NoInfer<ListableCheck<O, number>>,
+	) => Listable<number, O, T>
+	/**
+	 * Exact numbers of `precision` digits, `scale` of them after the point,
+	 * read and written as strings at that scale: `'12.50'` (D-145).
+	 */
+	readonly decimal: <const O extends DecimalOptions>(
+		options: O & NoInfer<ValidateCheck<O, string>>,
+	) => Field<string, O, never, T>
+	readonly boolean: <
+		const O extends ScalarOptions<boolean> = ScalarOptions<boolean>,
+	>(
+		options?: O & NoInfer<ValidateCheck<O, boolean>>,
+	) => Field<boolean, O, never, T>
+	readonly dateTime: <
+		const O extends ScalarOptions<Date> = ScalarOptions<Date>,
+	>(
+		options?: O & NoInfer<ValidateCheck<O, Date>>,
+	) => Field<Date, O, never, T>
+	/** A calendar day, the string `'2026-07-31'`, without a time zone (D-150). */
+	readonly date: <
+		const O extends ScalarOptions<string> = ScalarOptions<string>,
+	>(
+		options?: O & NoInfer<ValidateCheck<O, string>>,
+	) => Field<string, O & Day, never, T>
+	/**
+	 * Without a schema, a `json` value is `unknown` and written as JSON; with
+	 * one, it reads the schema's output and is written its input (D-53).
+	 */
+	readonly json: <const O extends JsonOptions = JsonOptions>(
+		options?: O & NoInfer<JsonCheck<O>>,
+	) => Field<JsonOutput<O>, O, never, T, JsonInput<O>, true>
+	/**
+	 * With `list: true`, a list of its values, `[]` when empty (D-127); a
+	 * `defineEnum` in place of its values is one type for each field (D-150),
+	 * and `Object.values(Status)` of a TypeScript string enum types it `Status`.
+	 */
+	readonly enumOf: <
+		const E extends string,
+		const O extends SingleOptions<E> | ListOptions<E> = SingleOptions<E>,
+	>(
+		values: readonly E[] | Enum<E>,
+		options?: O & NoInfer<ListableCheck<O, E>>,
+	) => Listable<E, O, T>
+	readonly one: <M extends object, const O extends OneOptions = OneOptions>(
+		target: M,
+		options?: O & NoInfer<OneCheck<O>>,
+	) => One<M, O, T>
+	readonly many: <M extends object, const O extends ManyOptions = ManyOptions>(
+		target: M,
+		options?: O,
+	) => Many<M, O, T>
+	/**
+	 * Computed on read by the model's `.with({ virtuals })` (D-151): a
+	 * Standard Schema, or a model or a type behind an arrow, `() => [Image]`.
+	 */
+	readonly virtual: <
+		const O extends object,
+		const X extends VirtualOptions = NoOptions,
+	>(
+		output: O,
+		options?: X,
+	) => Virtual<O, X>
+}

package/src/function.ts

@@ -0,0 +1,143 @@
+// Functions (D-27, D-45, D-109): a server operation with a Standard Schema
+// input and a typed output, which `defineApp({ functions })` adds to the
+// application, and the named objects its output may hold.
+import type { AnyCheck, SchemaTypes, StandardSchema } from './fields.ts'
+import type { ModelShape } from './model.ts'
+import type { ModelUse, PluginTypes } from './plugin.ts'
+import type { QueryOptions } from './query.ts'
+import type { RecordOf } from './record.ts'
+import type { Caller } from './rules.ts'
+import type { modelFields, nullableOf, typeFields } from './symbols.ts'
+
+/** `X.nullable()`: a model or a type, or `null` (D-109). */
+export type Nullable<X> = { readonly [nullableOf]: X }
+
+/** A `defineType`: a named object, which may hold a model (D-109). */
+export interface ObjectType<N extends string, F> {
+	readonly name: N
+	readonly [typeFields]: F
+	nullable(): Nullable<this>
+}
+
+type Named =
+	ModelShape | { readonly name: string; readonly [typeFields]: object }
+
+/**
+ * What a function returns (D-109): a model or a type, one or `null`, a list
+ * of one, or any Standard Schema.
+ */
+export type OutputSpec =
+	Named | Nullable<Named> | readonly [Named] | StandardSchema
+
+/** A `defineType`'s fields: any output but nothing. */
+export type TypeFields = { readonly [field: string]: OutputSpec }
+
+/** The value of an output: typed, never validated (D-45). */
+export type OutputValue<O> = O extends { readonly [modelFields]: infer F }
+	? RecordOf<F>
+	: O extends { readonly [typeFields]: infer F }
+		? { readonly [K in keyof F]: OutputValue<F[K]> }
+		: O extends { readonly [nullableOf]: infer X }
+			? OutputValue<X> | null
+			: O extends StandardSchema
+				? SchemaTypes<O>['output']
+				: O extends readonly [infer X]
+					? readonly OutputValue<X>[]
+					: never
+
+/** What `run` returns: nothing without an output. */
+export type ResultOf<O> = [O] extends [undefined] ? void : OutputValue<O>
+
+/**
+ * A function's access rule reads the caller only: it runs before the input
+ * is validated, so a closed function says nothing of its input (D-04).
+ */
+export type FunctionAccess = (facts: { readonly caller: Caller }) => boolean
+
+export type FunctionWith<W> = { readonly access?: FunctionAccess } & W
+
+/** What a caller passes to `run`: the input before validation (D-75). */
+export type RunArgs<I> = [I] extends [StandardSchema]
+	? readonly [input: SchemaTypes<I>['input'], options?: QueryOptions]
+	: readonly [options?: QueryOptions]
+
+export interface ServerFunction<N extends string, I, O, P, W> {
+	readonly name: N
+	/** The schemas the transports read (D-45). */
+	readonly input: I
+	readonly output: O
+	/** The plugins it uses, checked against the application's (D-24). */
+	readonly plugins?: P
+	with(rules: FunctionWith<W>): this
+	/** Checks access, validates the input, then runs it (D-75). */
+	run(...args: RunArgs<I>): Promise<ResultOf<O>>
+}
+
+export type FunctionShape = {
+	readonly name: string
+	readonly output: OutputSpec | undefined
+}
+
+/** A plugin that exposes functions: it keys their `.with` (D-27). */
+export type FunctionPlugin = PluginTypes & {
+	readonly functionWith: object | false
+}
+
+/** Each used plugin's key of a function's `.with`. */
+export type FunctionWithKeys<U> = {
+	readonly [
+		V in U as V extends ModelUse<infer P, FunctionPlugin> ? P : never
+	]?: V extends ModelUse<string, infer T extends FunctionPlugin>
+		? T['functionWith']
+		: never
+}
+
+/** A cookie's attributes (D-113). */
+export interface CookieOptions {
+	/** In seconds. */
+	readonly maxAge?: number
+	readonly path?: string
+	readonly domain?: string
+	readonly httpOnly?: boolean
+	readonly secure?: boolean
+	readonly sameSite?: 'Strict' | 'Lax' | 'None'
+}
+
+/** Who calls a function through a transport (D-113). */
+export interface Client {
+	/** The connection's address, `''` when the transport has none. */
+	readonly address: string
+	/** Read from the request, written on the transport's HTTP response. */
+	readonly cookies: {
+		/** The request's cookie `name`, `undefined` when it sent none. */
+		get(name: string): string | undefined
+		set(name: string, value: string, options?: CookieOptions): void
+		/** Its `path` and `domain` must be those it was set with. */
+		clear(name: string, options?: CookieOptions): void
+	}
+}
+
+/**
+ * What `run` receives: the caller, its client when a transport calls it,
+ * and the validated input if any (D-113).
+ */
+export type RunFacts<I> = {
+	readonly caller: Caller
+	readonly client: Client | undefined
+} & ([I] extends [StandardSchema]
+	? { readonly input: SchemaTypes<I>['output'] }
+	: unknown)
+
+/** Requires `query: true` when a plugin of `use` takes queries only (D-154). */
+export type QueryCheck<U> = [
+	Extract<U, ModelUse<string, { readonly queryOnly: true }>>,
+] extends [never]
+	? unknown
+	: { readonly query: true }
+
+/** Refuses an input typed `any` or without types (D-27). */
+export type InputCheck<I> = [I] extends [StandardSchema]
+	? AnyCheck<I> extends { readonly validate: infer M }
+		? { readonly input: M }
+		: unknown
+	: unknown

package/src/functions.ts

@@ -0,0 +1,154 @@
+// The application's and the plugins' functions at `start` (D-27, D-109,
+// D-113): each named once, its plugins installed, the models it returns in
+// `models`, and each type named once, apart from the models.
+import type {
+	FunctionDefinition,
+	Output,
+	PluginCode,
+	TypeDefinition,
+} from './definition.ts'
+import { called } from './define-function.ts'
+import type { Client } from './function.ts'
+import { functionDefinitions } from './definition.ts'
+import type { ExposedFunction } from './plugin.ts'
+import { isObject } from './query-where.ts'
+import type { Resolved } from './schema.ts'
+import { checkInstalled } from './plugin-use.ts'
+import { Refused } from './errors.ts'
+
+/** Checks the models and types an output reaches, each type once. */
+function checkOutput(
+	name: string,
+	output: Output,
+	resolved: Resolved,
+	types: Map<string, TypeDefinition>,
+): void {
+	if (output.kind === 'schema') return
+	if (output.kind === 'model') {
+		const info = resolved.byValue.get(output.value)
+		if (info === undefined) {
+			throw new Refused(
+				`${name} returns ${output.name}, which is not in models.`,
+			)
+		}
+		if (info.owner === undefined) return
+		throw new Refused(
+			`${name} returns ${output.name}, a model of ${info.owner}.`,
+		)
+	}
+	const { type } = output
+	const known = types.get(type.name)
+	if (known === type) return
+	if (known !== undefined) {
+		throw new Refused(`Two types are named ${type.name}; name each once.`)
+	}
+	if (resolved.models.has(type.name)) {
+		throw new Refused(`The type ${type.name} is named like a model.`)
+	}
+	types.set(type.name, type)
+	for (const field of type.fields.values()) {
+		checkOutput(name, field, resolved, types)
+	}
+}
+
+/** Functions listed by the application, or given by a plugin (D-113). */
+export type FunctionSource = {
+	readonly plugin: string | undefined
+	readonly values: readonly unknown[]
+}
+
+/** The application's and the plugins' functions, by value, and who gives each. */
+export type Functions = {
+	readonly definitions: ReadonlyMap<object, FunctionDefinition>
+	readonly plugins: ReadonlyMap<object, string>
+}
+
+const ownerOf = (plugin: string | undefined, name: string): string =>
+	plugin === undefined
+		? `the application's function ${name}`
+		: `${plugin}'s function ${name}`
+
+/** The functions, each named once, or startup stops with a message. */
+export function resolveFunctions(
+	sources: readonly FunctionSource[],
+	resolved: Resolved,
+	plugins: readonly PluginCode[],
+): Functions {
+	const definitions = new Map<object, FunctionDefinition>()
+	const owners = new Map<object, string>()
+	const names = new Map<string, string>()
+	const types = new Map<string, TypeDefinition>()
+	for (const { plugin, values } of sources) {
+		const where = plugin === undefined ? 'functions' : `${plugin}.functions`
+		for (const value of values) {
+			const definition = isObject(value)
+				? functionDefinitions.get(value)
+				: undefined
+			if (definition === undefined || !isObject(value)) {
+				throw new Refused(
+					`${where} lists a value that defineFunction did not return.`,
+				)
+			}
+			const { name } = definition
+			const owner = ownerOf(plugin, name)
+			const other = names.get(name)
+			if (other !== undefined) {
+				throw new Refused(
+					other === owner
+						? `${where} lists two functions named ${name}.`
+						: `${owner} and ${other} are both named ${name}.`,
+				)
+			}
+			names.set(name, owner)
+			for (const use of definition.uses) {
+				checkInstalled(name, use.code, plugins)
+			}
+			if (definition.output !== undefined) {
+				checkOutput(name, definition.output, resolved, types)
+			}
+			definitions.set(value, definition)
+			if (plugin !== undefined) owners.set(value, plugin)
+		}
+	}
+	// A virtual's type is named once with the functions' (D-151).
+	for (const info of resolved.byValue.values()) {
+		for (const { name, output } of info.virtuals.values()) {
+			if (output.kind !== 'type') continue
+			checkOutput(`${info.name}.${name}`, output, resolved, types)
+		}
+	}
+	return { definitions, plugins: owners }
+}
+
+/** The functions as the plugin `name` reads them, with its `.with` key. */
+export function exposedFunctions(
+	name: string,
+	functions: Functions,
+): readonly ExposedFunction[] {
+	return [...functions.definitions].map(([value, record]) => {
+		const { rules, input } = record
+		const key: unknown =
+			rules === undefined ? undefined : Reflect.get(rules, name)
+		return Object.freeze({
+			name: record.name,
+			description: record.description,
+			plugin: functions.plugins.get(value),
+			query: record.query,
+			used: record.uses.some((use) => use.code.name === name),
+			input,
+			output: record.output,
+			with: key,
+			run: async (
+				given: unknown,
+				options: unknown,
+				client?: Client,
+			): Promise<unknown> =>
+				called(
+					value,
+					record,
+					input === undefined ? [options] : [given, options],
+					client,
+				),
+		})
+	})
+}