@ultimabase/graphql 0.0.0-stage → 0.1.1

package/dist/select.js

@@ -0,0 +1,152 @@
+// A query's selection as one kernel read (D-107): the fields asked for, and
+// each `many` relation's own page and count, read with its parent's rows.
+import { badInput, readable } from '@ultimabase/http/internal';
+import { getArgumentValues, getDirectiveValues, getNamedType, GraphQLIncludeDirective, GraphQLSkipDirective, isObjectType, Kind, } from 'graphql';
+import { objectType } from './outputs.js';
+import { plain } from './scalars.js';
+import { listRead } from './pages.js';
+function included(info, node) {
+    const skip = getDirectiveValues(GraphQLSkipDirective, node, info.variableValues);
+    if (skip?.['if'] === true)
+        return false;
+    const include = getDirectiveValues(GraphQLIncludeDirective, node, info.variableValues);
+    return include?.['if'] !== false;
+}
+// A fragment spread again adds nothing the first spread did not, so each is
+// collected once: spreading each fragment twice into the next would otherwise
+// cost 2^n visits.
+function collect(info, set, into, key, spread) {
+    for (const selection of set?.selections ?? []) {
+        if (!included(info, selection))
+            continue;
+        if (selection.kind === Kind.FIELD) {
+            const found = into.get(key(selection));
+            if (found === undefined)
+                into.set(key(selection), [selection]);
+            else
+                found.push(selection);
+        }
+        else if (selection.kind === Kind.INLINE_FRAGMENT) {
+            collect(info, selection.selectionSet, into, key, spread);
+        }
+        else if (!spread.has(selection.name.value)) {
+            spread.add(selection.name.value);
+            const fragment = info.fragments[selection.name.value];
+            collect(info, fragment?.selectionSet, into, key, spread);
+        }
+    }
+}
+const byName = (node) => node.name.value;
+/** The fields under some nodes, by name, through fragments and directives. */
+export function grouped(info, nodes, key = byName) {
+    const into = new Map();
+    const spread = new Set();
+    for (const node of nodes)
+        collect(info, node.selectionSet, into, key, spread);
+    return into;
+}
+/** One relation's arguments, the same under every alias. */
+function argsOf(type, name, nodes, info) {
+    const field = type.getFields()[name];
+    const [first, ...others] = nodes.map((node) => field === undefined
+        ? {}
+        : getArgumentValues(field, node, info.variableValues));
+    const key = JSON.stringify(first);
+    if (others.some((args) => JSON.stringify(args) !== key)) {
+        throw badInput(`${name} is selected twice with different arguments; read it once.`);
+    }
+    return first ?? {};
+}
+/** Under a connection, the nodes its edges select. */
+export function nodesOf(info, nodes) {
+    const edges = grouped(info, nodes).get('edges') ?? [];
+    return [...(grouped(info, edges).get('node') ?? [])];
+}
+/** What a root list selects of its rows: under `edges { node }`. */
+export function rowNodes(registry, info) {
+    return registry.settings.pagination === 'list'
+        ? info.fieldNodes
+        : nodesOf(info, info.fieldNodes);
+}
+const system = new Set(['id', 'createdAt', 'updatedAt']);
+/** A virtual's read: `true`, its arguments, and a model's `select` (D-151). */
+function virtualRead(registry, info, type, virtual, nodes, master) {
+    const { output } = virtual;
+    const args = plain(argsOf(type, virtual.name, nodes, info));
+    const input = typeof args === 'object' && args !== null ? args : {};
+    if (output.kind !== 'model')
+        return virtual.input === undefined || input;
+    const target = objectType(registry, output.name);
+    return { ...input, select: selectOf(registry, info, target, nodes, master) };
+}
+/** The kernel's `select` for what a query asks of a model's rows. */
+export function selectOf(registry, info, type, nodes, master) {
+    const entry = registry.entry(type.name);
+    const select = { id: true };
+    // The connections' `totalCount`, each the count of its `where` (D-134).
+    const counts = {};
+    for (const [name, fieldNodes] of grouped(info, nodes)) {
+        if (name === '__typename')
+            continue;
+        if (system.has(name)) {
+            select[name] = true;
+            continue;
+        }
+        const virtual = entry.exposed.virtuals.find((v) => v.name === name);
+        if (virtual !== undefined) {
+            select[name] = virtualRead(registry, info, type, virtual, fieldNodes, master);
+            continue;
+        }
+        const field = entry.model.fields.find((f) => f.name === name);
+        if (field === undefined) {
+            // A field `extend` added: its resolver gets the row's scalars.
+            for (const scalar of readable(entry)) {
+                if (scalar.kind === 'scalar')
+                    select[scalar.name] = true;
+            }
+            for (const key of system)
+                select[key] = true;
+            continue;
+        }
+        if (field.kind === 'scalar') {
+            select[name] = true;
+            continue;
+        }
+        const target = registry.entry(field.target);
+        const targetObject = objectType(registry, field.target);
+        if (field.kind === 'one') {
+            select[name] = {
+                select: selectOf(registry, info, targetObject, fieldNodes, master),
+            };
+            continue;
+        }
+        const args = argsOf(type, name, fieldNodes, info);
+        const { read } = listRead(registry, target, args, master);
+        const list = registry.settings.pagination === 'list';
+        const below = list ? fieldNodes : nodesOf(info, fieldNodes);
+        select[name] = {
+            ...read,
+            select: selectOf(registry, info, targetObject, below, master),
+        };
+        if (!list && grouped(info, fieldNodes).has('totalCount')) {
+            counts[name] =
+                read['where'] === undefined ? true : { where: read['where'] };
+        }
+    }
+    if (Object.keys(counts).length > 0)
+        select['_count'] = { select: counts };
+    return select;
+}
+/** `context.select(info)`, for a field that returns a model or a list of one. */
+export function selectFor(registry, master) {
+    return (info) => {
+        const type = getNamedType(info.returnType);
+        if (!isObjectType(type) || !registry.entries.has(type.name)) {
+            throw new Error(`context.select(info) reads a model's rows; ${info.parentType.name}.${info.fieldName} returns ${type.name}.`);
+        }
+        return {
+            ...selectOf(registry, info, type, info.fieldNodes, master),
+            id: true,
+        };
+    };
+}

package/dist/sockets.d.ts

@@ -0,0 +1,25 @@
+import type { HttpApi } from '@ultimabase/http';
+import type { RealtimeApi } from '@ultimabase/realtime';
+import type { DocumentNode, ExecutionArgs, ExecutionResult, GraphQLSchema, Source, ValidationRule } from 'graphql';
+import { GraphQLError } from 'graphql';
+import type { Caller, Client, Logger } from 'ultimabase';
+import type { formatter } from './errors.ts';
+import type { Context } from './registry.ts';
+/** How the GraphQL plugin runs a document, over HTTP as over WebSocket. */
+export type Operations = {
+    readonly schema: GraphQLSchema;
+    readonly parse: (source: string | Source) => DocumentNode;
+    readonly rules: (master: boolean) => readonly ValidationRule[];
+    readonly validate: (document: DocumentNode, rules?: readonly ValidationRule[]) => readonly GraphQLError[];
+    readonly execute: (args: ExecutionArgs) => Promise<ExecutionResult>;
+    readonly context: (caller: Caller, client: Client) => Context;
+    readonly hideSuggestions: boolean;
+    readonly format: ReturnType<typeof formatter>;
+    readonly logger: Logger;
+};
+/**
+ * Serves `path`'s WebSocket upgrades with `operations`, each connection read
+ * by `realtime`; returns what closes them.
+ */
+export declare function serveSockets(http: HttpApi, path: string, realtime: RealtimeApi, operations: Operations): () => Promise<void>;
+//# sourceMappingURL=sockets.d.ts.map

package/dist/sockets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sockets.d.ts","sourceRoot":"","sources":["../src/sockets.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAW,MAAM,kBAAkB,CAAA;AACxD,OAAO,KAAK,EAAE,WAAW,EAAU,MAAM,sBAAsB,CAAA;AAC/D,OAAO,KAAK,EACX,YAAY,EACZ,aAAa,EACb,eAAe,EACf,aAAa,EACb,MAAM,EACN,cAAc,EACd,MAAM,SAAS,CAAA;AAChB,OAAO,EAGN,YAAY,EAGZ,MAAM,SAAS,CAAA;AAIhB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAExD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAG5C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAE5C,2EAA2E;AAC3E,MAAM,MAAM,UAAU,GAAG;IACxB,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAA;IAC9B,QAAQ,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,KAAK,YAAY,CAAA;IACzD,QAAQ,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,SAAS,cAAc,EAAE,CAAA;IAC9D,QAAQ,CAAC,QAAQ,EAAE,CAClB,QAAQ,EAAE,YAAY,EACtB,KAAK,CAAC,EAAE,SAAS,cAAc,EAAE,KAC7B,SAAS,YAAY,EAAE,CAAA;IAC5B,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC,eAAe,CAAC,CAAA;IACnE,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAA;IAC7D,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAA;IACjC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,SAAS,CAAC,CAAA;IAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACvB,CAAA;AAqFD;;;GAGG;AACH,wBAAgB,YAAY,CAC3B,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,WAAW,EACrB,UAAU,EAAE,UAAU,GACpB,MAAM,OAAO,CAAC,IAAI,CAAC,CAwJrB"}

package/dist/sockets.js

@@ -0,0 +1,234 @@
+import { createSourceEventStream, executeSubscriptionEvent, GraphQLError, mapSourceToResponseEvent, validateSubscriptionArgs, } from 'graphql';
+import { CloseCode, handleProtocols, makeServer } from 'graphql-ws';
+import { WebSocketServer } from 'ws';
+import { PublicError } from 'ultimabase';
+import { LiveEvent, lives } from './live-stream.js';
+/** A client's buffer past which its changes are dropped, and the most it sends us. */
+const maxBuffer = 1024 * 1024;
+/** Between pings; a socket that has not answered the last one is cut. */
+const keepAlive = 12_000;
+const unset = () => {
+    throw new Error('A cookie is set over HTTP: a WebSocket cannot set one.');
+};
+/** The upgrade request's cookies, which a WebSocket cannot set. */
+function cookiesOf(request) {
+    const cookies = new Map();
+    for (const part of (request.headers.get('cookie') ?? '').split(';')) {
+        const at = part.indexOf('=');
+        if (at <= 0)
+            continue;
+        const name = part.slice(0, at).trim();
+        if (cookies.has(name))
+            continue;
+        try {
+            cookies.set(name, decodeURIComponent(part.slice(at + 1).trim()));
+        }
+        catch {
+            // A value that is no URI component is no cookie this API wrote.
+        }
+    }
+    return { get: (name) => cookies.get(name), set: unset, clear: unset };
+}
+// How each socket sends, counted by its channel once it has one.
+const sends = new WeakMap();
+/** The socket's channel: what it holds unsent, and when that is written. */
+function channelOf(viewer, socket) {
+    let pending = 0;
+    const waiters = [];
+    const written = () => {
+        pending -= 1;
+        if (pending > 0)
+            return;
+        for (const then of waiters.splice(0))
+            then();
+    };
+    sends.set(socket, (data) => {
+        pending += 1;
+        socket.send(data, written);
+    });
+    return {
+        viewer,
+        full: () => socket.bufferedAmount > maxBuffer,
+        drained: (then) => {
+            if (pending === 0)
+                then();
+            else
+                waiters.push(then);
+        },
+        forbid: () => socket.close(CloseCode.Forbidden, 'Forbidden'),
+        kept: new Map(),
+    };
+}
+const text = (data) => Buffer.concat([data].flat().map((part) => new Uint8Array(part))).toString();
+const isLive = (value) => typeof value === 'object' && value !== null;
+/** The authorization `connection_init` gives, over the upgrade's own. */
+function requestOf(upgrade, params) {
+    const headers = new Headers(upgrade.request.headers);
+    const authorization = typeof params === 'object' && params !== null
+        ? Reflect.get(params, 'authorization')
+        : undefined;
+    if (typeof authorization === 'string') {
+        headers.set('authorization', authorization);
+    }
+    return new Request(upgrade.request.url, { headers });
+}
+/**
+ * Serves `path`'s WebSocket upgrades with `operations`, each connection read
+ * by `realtime`; returns what closes them.
+ */
+export function serveSockets(http, path, realtime, operations) {
+    const { schema, logger, format, hideSuggestions } = operations;
+    const formatted = (errors) => errors.map((error) => {
+        const shown = format(error);
+        return shown instanceof GraphQLError
+            ? shown.toJSON()
+            : { message: shown.message };
+    });
+    const server = makeServer({
+        schema,
+        onConnect: async (ctx) => {
+            const { upgrade, socket } = ctx.extra;
+            try {
+                const request = requestOf(upgrade, ctx.connectionParams);
+                const viewer = await realtime.connect(request);
+                if (socket.readyState !== socket.OPEN) {
+                    viewer.close();
+                    return false;
+                }
+                ctx.extra.viewer = viewer;
+                ctx.extra.channel = channelOf(viewer, socket);
+                return true;
+            }
+            catch (error) {
+                if (!(error instanceof PublicError)) {
+                    logger.error({ err: error }, 'A WebSocket caller was not read.');
+                }
+                return false;
+            }
+        },
+        onSubscribe: (ctx, _, payload) => {
+            const { viewer, channel, upgrade, socket } = ctx.extra;
+            if (viewer === undefined || channel === undefined || viewer.closed) {
+                socket.close(CloseCode.Forbidden, 'Forbidden');
+                return [new GraphQLError('Forbidden')];
+            }
+            let document;
+            try {
+                document = operations.parse(payload.query);
+            }
+            catch (error) {
+                if (error instanceof GraphQLError)
+                    return [error];
+                throw error;
+            }
+            const { caller } = viewer;
+            const master = caller.kind === 'master';
+            const refused = operations.validate(document, operations.rules(master));
+            if (refused.length > 0)
+                return refused;
+            const client = {
+                address: upgrade.address,
+                cookies: cookiesOf(upgrade.request),
+            };
+            const contextValue = operations.context(caller, client);
+            const live = payload.extensions?.['live'];
+            const page = isLive(live) && live.mode === 'page';
+            const resume = isLive(live) ? live.resume : undefined;
+            lives.set(contextValue, {
+                channel,
+                page,
+                ...(typeof resume === 'string' && { resume }),
+            });
+            return {
+                schema,
+                document,
+                operationName: payload.operationName,
+                variableValues: payload.variables,
+                contextValue,
+            };
+        },
+        execute: async (args) => operations.execute(args),
+        subscribe: async (args) => {
+            const validated = validateSubscriptionArgs({ ...args, hideSuggestions });
+            if (!('schema' in validated))
+                return { errors: validated };
+            const source = await createSourceEventStream(validated);
+            if (!(Symbol.asyncIterator in source))
+                return source;
+            return mapSourceToResponseEvent(validated, source, async (event) => {
+                const result = await executeSubscriptionEvent(event);
+                const { rootValue } = event;
+                return rootValue instanceof LiveEvent
+                    ? rootValue.finish(result)
+                    : result;
+            });
+        },
+        onNext: (_ctx, _id, _payload, _args, { data, errors, extensions }) => ({
+            ...(data === undefined ? {} : { data }),
+            ...(errors === undefined ? {} : { errors: formatted(errors) }),
+            ...(extensions === undefined ? {} : { extensions }),
+        }),
+        onError: (_ctx, _id, _payload, errors) => formatted(errors),
+    });
+    const sockets = new WebSocketServer({
+        noServer: true,
+        maxPayload: maxBuffer,
+        perMessageDeflate: { threshold: 1024 },
+        handleProtocols,
+    });
+    const beats = new WeakMap();
+    const opened = (socket, upgrade) => {
+        const extra = { upgrade, socket };
+        let alive = true;
+        socket.on('pong', () => {
+            alive = true;
+        });
+        beats.set(socket, () => {
+            if (!alive)
+                return socket.terminate();
+            alive = false;
+            socket.ping();
+        });
+        const closed = server.opened({
+            protocol: socket.protocol,
+            send: async (data) => {
+                if (socket.readyState !== socket.OPEN)
+                    return;
+                const send = sends.get(socket);
+                if (send === undefined)
+                    socket.send(data);
+                else
+                    send(data);
+            },
+            close: (code, reason) => socket.close(code, reason),
+            onMessage: (received) => {
+                socket.on('message', (data) => {
+                    received(text(data)).catch((error) => {
+                        logger.error({ err: error }, 'A WebSocket message failed.');
+                        socket.close(CloseCode.InternalServerError, 'Internal error');
+                    });
+                });
+            },
+        }, extra);
+        socket.once('close', (code, reason) => {
+            void closed(code, String(reason));
+            extra.viewer?.close();
+        });
+    };
+    const beating = setInterval(() => {
+        for (const socket of sockets.clients)
+            beats.get(socket)?.();
+    }, keepAlive);
+    beating.unref();
+    http.upgrade(path, (upgrade) => {
+        sockets.handleUpgrade(upgrade.incoming, upgrade.socket, upgrade.head, (socket) => opened(socket, upgrade));
+    });
+    return async () => {
+        clearInterval(beating);
+        for (const socket of sockets.clients)
+            socket.close(1001, 'Going away');
+        await new Promise((done) => {
+            sockets.close(() => done());
+        });
+    };
+}

package/dist/subscriptions.d.ts

@@ -0,0 +1,14 @@
+import type { GraphQLFieldConfig, GraphQLResolveInfo } from 'graphql';
+import type { Args, Context, Registry } from './registry.ts';
+type Fields = {
+    [field: string]: GraphQLFieldConfig<unknown, Context, Args>;
+};
+/**
+ * A live function's subscription (D-154), as its query field: `value` runs
+ * it as the subscriber each time it may have changed.
+ */
+export declare function followed(owner: string, field: Omit<GraphQLFieldConfig<unknown, Context, Args>, 'resolve'>, value: (args: Args, context: Context, info: GraphQLResolveInfo) => Promise<unknown>): GraphQLFieldConfig<unknown, Context, Args>;
+/** The live models' subscriptions, by root name. */
+export declare function subscriptionFields(registry: Registry, live: (model: string) => boolean): Fields;
+export {};
+//# sourceMappingURL=subscriptions.d.ts.map

package/dist/subscriptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions.d.ts","sourceRoot":"","sources":["../src/subscriptions.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAEX,kBAAkB,EAClB,kBAAkB,EAClB,MAAM,SAAS,CAAA;AAQhB,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAS,QAAQ,EAAE,MAAM,eAAe,CAAA;AAInE,KAAK,MAAM,GAAG;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,CAAA;CAAE,CAAA;AAmQ7E;;;GAGG;AACH,wBAAgB,QAAQ,CACvB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS,CAAC,EAClE,KAAK,EAAE,CACN,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,kBAAkB,KACpB,OAAO,CAAC,OAAO,CAAC,GACnB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,CAkB5C;AAED,oDAAoD;AACpD,wBAAgB,kBAAkB,CACjC,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,GAC9B,MAAM,CAQR"}

package/dist/subscriptions.js

@@ -0,0 +1,242 @@
+// The subscriptions (D-154): each live model's row and list, with its query's
+// name, arguments and type, followed by the realtime engine. The first result
+// is `{ data }`; a list then sends only what changed, under `extensions.live`,
+// or its whole window in page mode. A list's first result carries the token
+// that resumes it once completed, grown.
+import { randomUUID } from 'node:crypto';
+import { applied, badInput, connection, pageOf, run, } from '@ultimabase/http/internal';
+import { GraphQLError, GraphQLList, GraphQLNonNull } from 'graphql';
+import { objectOf, uniqueInput, uniqueWhere } from './inputs.js';
+import { LiveEvent, liveStream, lives, resumed } from './live-stream.js';
+import { connectionType, isMaster, listArgs, objectType } from './outputs.js';
+import { whereOf } from './pages.js';
+import { grouped, rowNodes, selectOf } from './select.js';
+const responseKey = (node) => node.alias?.value ?? node.name.value;
+/** The response key of the first field named `name` the info's field selects. */
+function keyOf(info, name) {
+    for (const [key, [first]] of grouped(info, info.fieldNodes, responseKey)) {
+        if (first.name.value === name)
+            return key;
+    }
+    return undefined;
+}
+const valueAt = (value, key) => key === undefined || typeof value !== 'object' || value === null
+    ? undefined
+    : Reflect.get(value, key);
+const fromTop = { size: undefined, backward: false };
+/** A window from the top of its order, as a connection. */
+function connectionOf(rows, hasMore, totalCount) {
+    const { edges, pageInfo } = connection(rows, fromTop, (row) => row);
+    return { edges, pageInfo: { ...pageInfo, hasNextPage: hasMore }, totalCount };
+}
+const revised = (result, revision, resume) => ({
+    ...result,
+    extensions: {
+        ...result.extensions,
+        live: { revision, ...(resume !== undefined && { resume }) },
+    },
+});
+/** Where a list's root, its edges, page info and count are in the result. */
+const keysOf = (info, connected) => [
+    String(info.path.key),
+    ...(connected
+        ? [
+            keyOf(info, 'edges'),
+            keyOf(info, 'pageInfo'),
+            keyOf(info, 'totalCount'),
+        ]
+        : [undefined, undefined, undefined]),
+];
+/**
+ * What a live read's messages run, with what it sent so far; a list's
+ * first result carries `resume`.
+ */
+function follower(info, connected, page, resume) {
+    const [key, edgesKey, pageInfoKey, totalCountKey] = keysOf(info, connected);
+    let token = resume;
+    let window = [];
+    let hasMore = false;
+    let count;
+    let pageInfo = '';
+    const rootOf = (rows) => connected ? connectionOf(rows, hasMore, count) : rows;
+    const sent = (result) => {
+        const at = valueAt(result.data, key);
+        pageInfo = JSON.stringify(valueAt(at, pageInfoKey)) ?? '';
+        return result;
+    };
+    return (message) => {
+        if (message.kind === 'row' || message.kind === 'value') {
+            const { revision } = message;
+            const root = message.kind === 'row' ? message.row : message.value;
+            return new LiveEvent(root, (result) => revised(result, revision));
+        }
+        const { revision } = message;
+        hasMore = message.hasMore ?? hasMore;
+        count = message.totalCount ?? count;
+        if (message.kind === 'reset' || page) {
+            window =
+                message.kind === 'reset'
+                    ? message.rows
+                    : applied(window, message.changes, (row) => row);
+            const shown = token;
+            token = undefined;
+            return new LiveEvent(rootOf(window), (result) => revised(sent(result), revision, shown));
+        }
+        const { changes } = message;
+        window = applied(window, changes, ({ id }) => ({ id }));
+        const upserts = changes.flatMap((change) => 'upsert' in change ? [change.upsert] : []);
+        const root = connected
+            ? {
+                ...connectionOf(window, hasMore, count),
+                edges: connectionOf(upserts, false, undefined).edges,
+            }
+            : upserts;
+        return new LiveEvent(root, (result) => {
+            const at = valueAt(result.data, key);
+            const upserted = connected ? valueAt(at, edgesKey) : at;
+            const shown = Array.isArray(upserted) ? upserted : [];
+            let next = 0;
+            const live = { revision };
+            if (!connected || edgesKey !== undefined) {
+                live['changes'] = changes.map((change) => {
+                    if ('remove' in change)
+                        return change;
+                    next += 1;
+                    return { upsert: shown[next - 1], after: change.after };
+                });
+            }
+            if (message.totalCount !== undefined && totalCountKey !== undefined) {
+                live['totalCount'] = valueAt(at, totalCountKey);
+            }
+            const before = pageInfo;
+            sent(result);
+            if (pageInfoKey !== undefined && pageInfo !== before) {
+                live['pageInfo'] = valueAt(at, pageInfoKey);
+            }
+            return {
+                ...(result.errors && { errors: result.errors }),
+                extensions: { ...result.extensions, live },
+            };
+        });
+    };
+}
+/**
+ * The last result of a live read the engine closed, or of a live function
+ * that failed with `error`, which the error formatter shows or masks.
+ */
+const closedEvent = (error) => new LiveEvent(null, () => ({
+    errors: [
+        error === undefined
+            ? new GraphQLError('The live read closed.', {
+                extensions: { code: 'INTERNAL' },
+            })
+            : new GraphQLError('A live function failed.', {
+                originalError: error instanceof Error
+                    ? error
+                    : new Error('A live function threw.', { cause: error }),
+            }),
+    ],
+}));
+/** What a subscription's event holds; its stream only yields `LiveEvent`s. */
+const rootOf = (event) => Reflect.get(Object(event), 'root');
+/** The WebSocket operation `context` runs in. */
+function liveOf(context) {
+    const live = lives.get(context);
+    if (live === undefined)
+        throw badInput('A subscription runs over WebSocket.');
+    return live;
+}
+/** `post(where)` and `posts(where, orderBy, first)` of a live model. */
+function liveFields(registry, entry) {
+    const name = entry.model.name;
+    const type = objectType(registry, name);
+    const { pagination } = registry.settings;
+    const connected = pagination === 'connection';
+    const list = connected
+        ? new GraphQLNonNull(connectionType(registry, `${name}Connection`, name))
+        : new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(type)));
+    // A window starts at the top of its order (D-154).
+    const windowArgs = Object.fromEntries(Object.entries(listArgs(registry, name)).filter(([arg]) => !['after', 'last', 'before', 'skip'].includes(arg)));
+    return {
+        [entry.single]: {
+            type,
+            args: {
+                where: { type: new GraphQLNonNull(uniqueInput(registry, name)) },
+            },
+            subscribe: async (_, args, context, info) => {
+                const { channel, page } = liveOf(context);
+                const where = uniqueWhere(registry, name, objectOf(args['where']));
+                const master = isMaster(context);
+                const select = selectOf(registry, info, type, info.fieldNodes, master);
+                return run(async () => liveStream(channel, async (send) => channel.viewer.row(name, { where, select }, send), follower(info, false, page), closedEvent));
+            },
+            resolve: rootOf,
+        },
+        [entry.list]: {
+            type: list,
+            args: windowArgs,
+            subscribe: async (_, args, context, info) => {
+                const { channel, page } = liveOf(context);
+                const master = isMaster(context);
+                const { read: paged, relay } = pageOf(pagination, entry, args, master);
+                const asked = relay === undefined ? paged['take'] : relay.size;
+                const rows = typeof asked === 'number' ? asked : entry.take;
+                const arg = connected ? 'first' : 'take';
+                if (page && rows > entry.maxTake) {
+                    throw badInput(`${arg} is at most ${entry.maxTake} on ${name} in page mode.`);
+                }
+                const nodes = rowNodes(registry, info);
+                const select = selectOf(registry, info, type, nodes, master);
+                const { orderBy: order } = args;
+                const read = {
+                    ...whereOf(registry, name, args),
+                    ...(order === undefined || order === null ? {} : { orderBy: order }),
+                    select,
+                    totalCount: connected && grouped(info, info.fieldNodes).has('totalCount'),
+                };
+                const signature = JSON.stringify([
+                    name,
+                    page,
+                    keysOf(info, connected),
+                    read,
+                ]);
+                const { resume } = liveOf(context);
+                return run(async () => {
+                    const taken = resume === undefined
+                        ? undefined
+                        : await resumed(channel, resume, signature, rows);
+                    if (taken !== undefined)
+                        return taken;
+                    const keep = { token: randomUUID(), signature, first: rows };
+                    return liveStream(channel, async (send) => channel.viewer.list(name, { ...read, first: rows }, send), follower(info, connected, page, keep.token), closedEvent, keep);
+                });
+            },
+            resolve: rootOf,
+        },
+    };
+}
+/**
+ * A live function's subscription (D-154), as its query field: `value` runs
+ * it as the subscriber each time it may have changed.
+ */
+export function followed(owner, field, value) {
+    return {
+        ...field,
+        subscribe: async (_, args, context, info) => {
+            const { channel } = liveOf(context);
+            const compute = async (caller) => value(args, { ...context, caller }, info);
+            return run(async () => liveStream(channel, async (send) => channel.viewer.value(owner, compute, send), follower(info, false, false), closedEvent));
+        },
+        resolve: rootOf,
+    };
+}
+/** The live models' subscriptions, by root name. */
+export function subscriptionFields(registry, live) {
+    const fields = {};
+    for (const entry of registry.entries.values()) {
+        if (entry.visible && live(entry.model.name)) {
+            Object.assign(fields, liveFields(registry, entry));
+        }
+    }
+    return fields;
+}