@ultimabase/graphql 0.0.0-stage → 0.1.0

package/dist/inputs.js

@@ -0,0 +1,236 @@
+// The read inputs (D-107), as the query API spells them (D-20): filters,
+// `where`, `orderBy` and the `@oneOf` unique target.
+import { readable } from '@ultimabase/http/internal';
+import { GraphQLBoolean, GraphQLEnumType, GraphQLID, GraphQLInputObjectType, GraphQLList, GraphQLNonNull, GraphQLString, } from 'graphql';
+import { upper } from './names.js';
+import { scalarType } from './registry.js';
+import { DateTime } from './scalars.js';
+/** An input object's value, as the kernel's arguments. */
+export const objectOf = (value) => typeof value === 'object' && value !== null ? { ...value } : {};
+/** Whether a model has fields its `_search` matches (D-148). */
+const searched = (fields) => fields.some((field) => field.kind === 'scalar' && field.search === true);
+const list = (type) => new GraphQLList(new GraphQLNonNull(type));
+const base = ['equals', 'not', 'in', 'notIn'];
+const ordered = [...base, 'lt', 'lte', 'gt', 'gte'];
+const text = [...base, 'contains', 'startsWith', 'endsWith'];
+/** `QueryMode`: a string filter's operators ignore case (D-140). */
+const queryMode = (registry) => registry.enum('QueryMode', () => new GraphQLEnumType({
+    name: 'QueryMode',
+    values: { insensitive: { value: 'insensitive' } },
+}));
+/** The input type of a filter's operator. */
+function operand(registry, type, operator) {
+    if (operator === 'mode')
+        return queryMode(registry);
+    if (operator === 'path')
+        return list(GraphQLString);
+    if (operator.startsWith('string'))
+        return GraphQLString;
+    return operator === 'in' || operator === 'notIn' ? list(type) : type;
+}
+/** `StringFilter`, `FloatFilter`, `PostStatusFilter`: the kernel's operators. */
+function filter(registry, type, operators) {
+    const name = `${type.name}Filter`;
+    return registry.input(name, () => new GraphQLInputObjectType({
+        name,
+        fields: Object.fromEntries(operators.map((operator) => [
+            operator,
+            { type: operand(registry, type, operator) },
+        ])),
+    }));
+}
+/** Each scalar type's operators: no order on strings, as the kernel. */
+const operators = {
+    string: [...text, 'mode'],
+    number: ordered,
+    decimal: ordered,
+    dateTime: ordered,
+    date: ordered,
+    boolean: base,
+    // Any JSON, a path into it or not, typed field or not (D-149).
+    json: [
+        'path',
+        ...ordered,
+        'stringContains',
+        'stringStartsWith',
+        'stringEndsWith',
+        'mode',
+        'arrayContains',
+        'arrayStartsWith',
+        'arrayEndsWith',
+    ],
+    enum: base,
+};
+/**
+ * `StringListFilter`, `FloatListFilter`, `ProductSizesListFilter`: no
+ * shorthand, `NOT` gives the opposite (D-120, D-127, D-149).
+ */
+const listFilter = (registry, item) => {
+    const name = `${item.name}ListFilter`;
+    return registry.input(name, () => new GraphQLInputObjectType({
+        name,
+        fields: {
+            has: { type: item },
+            hasSome: { type: list(item) },
+            hasEvery: { type: list(item) },
+            isEmpty: { type: GraphQLBoolean },
+        },
+    }));
+};
+const scalarFilter = (registry, model, field) => {
+    const item = scalarType(registry, model, field);
+    if (field.list)
+        return listFilter(registry, item);
+    return filter(registry, item, operators[field.type]);
+};
+const relationFilter = (registry, field) => {
+    const one = field.kind === 'one';
+    const name = `${field.target}${one ? 'Relation' : 'ListRelation'}Filter`;
+    return registry.input(name, () => new GraphQLInputObjectType({
+        name,
+        fields: () => {
+            const type = whereInput(registry, field.target);
+            return Object.fromEntries((one ? ['is', 'isNot'] : ['some', 'every', 'none']).map((key) => [
+                key,
+                { type },
+            ]));
+        },
+    }));
+};
+/** `PostWhereInput`. */
+export function whereInput(registry, model) {
+    const name = `${model}WhereInput`;
+    return registry.input(name, () => new GraphQLInputObjectType({
+        name,
+        fields: () => {
+            const self = whereInput(registry, model);
+            const fields = {
+                AND: { type: list(self) },
+                OR: { type: list(self) },
+                NOT: { type: list(self) },
+                id: { type: filter(registry, GraphQLID, base) },
+                createdAt: { type: filter(registry, DateTime, ordered) },
+                updatedAt: { type: filter(registry, DateTime, ordered) },
+            };
+            const entry = registry.entry(model);
+            if (searched(readable(entry))) {
+                fields['_search'] = { type: GraphQLString };
+            }
+            for (const field of readable(entry)) {
+                // Only a beforeFind filters a plugin field (D-122).
+                if (entry.exposed.fieldTypes[field.name] !== undefined)
+                    continue;
+                fields[field.name] = {
+                    type: field.kind === 'scalar'
+                        ? scalarFilter(registry, model, field)
+                        : relationFilter(registry, field),
+                };
+            }
+            return fields;
+        },
+    }));
+}
+const sortOrder = (registry) => registry.enum('SortOrder', () => new GraphQLEnumType({
+    name: 'SortOrder',
+    values: { asc: { value: 'asc' }, desc: { value: 'desc' } },
+}));
+/** `CountOrderByInput`: a `many` relation sorted by its rows (D-134). */
+const countOrderBy = (registry) => registry.input('CountOrderByInput', () => new GraphQLInputObjectType({
+    name: 'CountOrderByInput',
+    fields: { _count: { type: sortOrder(registry) } },
+}));
+/**
+ * `PostOrderByInput`: scalar fields but json, lists and plugin fields, as
+ * the kernel sorts (D-94, D-120, D-122); a `one` relation as its target's,
+ * a `many` one by its count (D-134).
+ */
+export function orderByInput(registry, model) {
+    const name = `${model}OrderByInput`;
+    return registry.input(name, () => new GraphQLInputObjectType({
+        name,
+        fields: () => {
+            const type = sortOrder(registry);
+            const fields = {
+                id: { type },
+                createdAt: { type },
+                updatedAt: { type },
+            };
+            const entry = registry.entry(model);
+            // The kernel refuses it in a relation's: a read ranks by its own search.
+            if (searched(readable(entry)))
+                fields['_relevance'] = { type };
+            for (const field of readable(entry)) {
+                if (field.kind === 'one') {
+                    fields[field.name] = {
+                        type: orderByInput(registry, field.target),
+                    };
+                }
+                else if (field.kind === 'many') {
+                    fields[field.name] = { type: countOrderBy(registry) };
+                }
+                else if (field.type !== 'json' &&
+                    !field.list &&
+                    entry.exposed.fieldTypes[field.name] === undefined) {
+                    fields[field.name] = { type };
+                }
+            }
+            return fields;
+        },
+    }));
+}
+/** A unique field's type: a `one` relation's is its target's `ID`. */
+function uniqueType(registry, model, name) {
+    const field = registry.entry(model).model.fields.find((f) => f.name === name);
+    return field?.kind === 'scalar'
+        ? scalarType(registry, model, field)
+        : GraphQLID;
+}
+const compositeName = (fields) => fields.join('_');
+/**
+ * `PostWhereUniqueInput @oneOf`: `id`, each unique field, and each unique
+ * index as `author_slug: { author, slug }`.
+ */
+export function uniqueInput(registry, model) {
+    const name = `${model}WhereUniqueInput`;
+    return registry.input(name, () => {
+        const fields = {};
+        const { exposed } = registry.entry(model);
+        // A field only Master reads is absent, as from the filters (D-44).
+        const uniques = exposed.uniques.filter((unique) => unique.every((field) => exposed.readRules[field] !== 'private'));
+        for (const unique of uniques) {
+            const [only] = unique;
+            if (unique.length === 1 && only !== undefined) {
+                fields[only] = { type: uniqueType(registry, model, only) };
+                continue;
+            }
+            const key = compositeName(unique);
+            const composite = `${model}${unique.map(upper).join('')}UniqueInput`;
+            fields[key] = {
+                type: new GraphQLInputObjectType({
+                    name: composite,
+                    fields: Object.fromEntries(unique.map((field) => [
+                        field,
+                        { type: new GraphQLNonNull(uniqueType(registry, model, field)) },
+                    ])),
+                }),
+            };
+        }
+        return new GraphQLInputObjectType({ name, fields, isOneOf: true });
+    });
+}
+/** A `@oneOf` unique target as the kernel's flat `where`. */
+export function uniqueWhere(registry, model, where) {
+    const composites = new Set(registry
+        .entry(model)
+        .exposed.uniques.filter((unique) => unique.length > 1)
+        .map(compositeName));
+    const flat = {};
+    for (const [key, value] of Object.entries(where)) {
+        if (composites.has(key) && typeof value === 'object') {
+            Object.assign(flat, value);
+        }
+        else
+            flat[key] = value;
+    }
+    return flat;
+}

package/dist/json-fields.d.ts

@@ -0,0 +1,12 @@
+import type { GraphQLNullableInputType, GraphQLNullableOutputType } from 'graphql';
+import type { Typed } from './data.ts';
+import type { Args, Registry, Scalar } from './registry.ts';
+/** `UserPrefs` or `PostCover`, and whether the schema reads `null`. */
+export declare function jsonOutput(registry: Registry, model: string, field: Scalar): Typed<GraphQLNullableOutputType>;
+/** `UserPrefsInput`, and whether the schema takes `null`. */
+export declare function jsonInput(registry: Registry, model: string, field: Scalar): Typed<GraphQLNullableInputType>;
+/** A written row's json and plugin values, their dates back to text. */
+export declare function plainData(registry: Registry, model: string, data: Args): Args;
+/** A filter's json operands, their dates back to text, through relations. */
+export declare function plainWhere(registry: Registry, model: string, where: Args): Args;
+//# sourceMappingURL=json-fields.d.ts.map

package/dist/json-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-fields.d.ts","sourceRoot":"","sources":["../src/json-fields.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACX,wBAAwB,EACxB,yBAAyB,EACzB,MAAM,SAAS,CAAA;AAChB,OAAO,KAAK,EAAQ,KAAK,EAAE,MAAM,WAAW,CAAA;AAG5C,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAY3D,uEAAuE;AACvE,wBAAgB,UAAU,CACzB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACX,KAAK,CAAC,yBAAyB,CAAC,CAKlC;AAED,6DAA6D;AAC7D,wBAAgB,SAAS,CACxB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACX,KAAK,CAAC,wBAAwB,CAAC,CAIjC;AAED,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,CAW7E;AASD,6EAA6E;AAC7E,wBAAgB,UAAU,CACzB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,IAAI,GACT,IAAI,CAsBN"}

package/dist/json-fields.js

@@ -0,0 +1,66 @@
+import { fieldInput, fieldOutput } from './data.js';
+import { upper } from './names.js';
+import { JSONScalar, plain } from './scalars.js';
+const pathOf = (model, field, suffix) => ({
+    owner: `${model}.${field.name}`,
+    name: `${model}${upper(field.name)}`,
+    suffix,
+    at: field.name,
+});
+const untyped = { type: JSONScalar, nullable: false };
+/** `UserPrefs` or `PostCover`, and whether the schema reads `null`. */
+export function jsonOutput(registry, model, field) {
+    const { validators, fieldTypes } = registry.entry(model).exposed;
+    const schema = validators[field.name] ?? fieldTypes[field.name]?.shape;
+    const path = pathOf(model, field, '');
+    return (schema && fieldOutput(schema, path, registry.data)) ?? untyped;
+}
+/** `UserPrefsInput`, and whether the schema takes `null`. */
+export function jsonInput(registry, model, field) {
+    const schema = registry.entry(model).exposed.validators[field.name];
+    const path = pathOf(model, field, 'Input');
+    return (schema && fieldInput(schema, path, registry.data)) ?? untyped;
+}
+/** A written row's json and plugin values, their dates back to text. */
+export function plainData(registry, model, data) {
+    const plained = { ...data };
+    const { exposed, model: schema } = registry.entry(model);
+    for (const field of schema.fields) {
+        const value = plained[field.name];
+        if (value === undefined || field.kind !== 'scalar')
+            continue;
+        if (field.type === 'json' || exposed.fieldTypes[field.name] !== undefined) {
+            plained[field.name] = plain(value);
+        }
+    }
+    return plained;
+}
+const each = (value, map) => Array.isArray(value)
+    ? value.map((item) => each(item, map))
+    : typeof value === 'object' && value !== null
+        ? map({ ...value })
+        : value;
+/** A filter's json operands, their dates back to text, through relations. */
+export function plainWhere(registry, model, where) {
+    const fields = registry.entry(model).model.fields;
+    const plained = {};
+    for (const [key, value] of Object.entries(where)) {
+        const field = fields.find((candidate) => candidate.name === key);
+        if (key === 'AND' || key === 'OR' || key === 'NOT') {
+            plained[key] = each(value, (inner) => plainWhere(registry, model, inner));
+        }
+        else if (field?.kind === 'scalar') {
+            plained[key] = field.type === 'json' ? plain(value) : value;
+        }
+        else if (field !== undefined) {
+            // `is`, `some` and the others each take the target's filter.
+            plained[key] = each(value, (operators) => Object.fromEntries(Object.entries(operators).map(([operator, inner]) => [
+                operator,
+                each(inner, (target) => plainWhere(registry, field.target, target)),
+            ])));
+        }
+        else
+            plained[key] = value;
+    }
+    return plained;
+}

package/dist/json-schema.d.ts

@@ -0,0 +1,7 @@
+import type { Node } from '@ultimabase/http/internal';
+export type Side = 'input' | 'output';
+/** A json field's JSON Schema, `undefined` without one (D-125). */
+export declare function exportOf(schema: object, side: Side): Node | undefined;
+/** The JSON Schema's shared nodes, by id. */
+export declare const defsOf: (root: Node) => Node;
+//# sourceMappingURL=json-schema.d.ts.map

package/dist/json-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../src/json-schema.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAA;AAIrD,MAAM,MAAM,IAAI,GAAG,OAAO,GAAG,QAAQ,CAAA;AAErC,mEAAmE;AACnE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAOrE;AAED,6CAA6C;AAC7C,eAAO,MAAM,MAAM,SAAU,IAAI,KAAG,IACO,CAAA"}

package/dist/json-schema.js

@@ -0,0 +1,16 @@
+// A schema's standard JSON Schema export, which `data.ts` types (D-45).
+import { isNode, jsonSchemaOf } from '@ultimabase/http/internal';
+import { Refused } from 'ultimabase';
+/** A json field's JSON Schema, `undefined` without one (D-125). */
+export function exportOf(schema, side) {
+    try {
+        return jsonSchemaOf(schema, side, '');
+    }
+    catch (error) {
+        if (error instanceof Refused)
+            return undefined;
+        throw error;
+    }
+}
+/** The JSON Schema's shared nodes, by id. */
+export const defsOf = (root) => isNode(root['$defs']) ? root['$defs'] : {};

package/dist/live-stream.d.ts

@@ -0,0 +1,59 @@
+import type { ExecutionResult } from 'graphql';
+import type { LiveHandle, LiveMessage, Viewer } from '@ultimabase/realtime';
+/** A message to run against the selection, and how its result is sent. */
+export declare class LiveEvent {
+    readonly root: unknown;
+    readonly finish: (result: ExecutionResult) => ExecutionResult;
+    constructor(root: unknown, finish: (result: ExecutionResult) => ExecutionResult);
+}
+/** The socket a connection's subscriptions write to. */
+export type Channel = {
+    readonly viewer: Viewer;
+    /** Whether the client's buffer holds more than it may. */
+    readonly full: () => boolean;
+    /** Runs `then` once everything sent is written. */
+    readonly drained: (then: () => void) => void;
+    /** Closes the socket: its caller is no longer the same user. */
+    readonly forbid: () => void;
+    /** The completed live lists a resume may take back, by token. */
+    readonly kept: Map<string, Kept>;
+};
+/**
+ * A subscription's channel, whether it gets the whole window each time, and
+ * the token of the completed list it resumes.
+ */
+export type Live = {
+    readonly channel: Channel;
+    readonly page: boolean;
+    readonly resume?: string;
+};
+/** A live list's token, what read it is, and the rows it shows. */
+export type Keep = {
+    readonly token: string;
+    readonly signature: string;
+    first: number;
+};
+/** A completed live list, until a resume takes it or its time is up. */
+export type Kept = {
+    readonly keep: Keep;
+    readonly stream: AsyncIterableIterator<LiveEvent>;
+    readonly handle: LiveHandle;
+    readonly timer: NodeJS.Timeout;
+    readonly end: () => void;
+};
+/** Each WebSocket operation's, by its context. */
+export declare const lives: WeakMap<object, Live>;
+/**
+ * The list `token` keeps, taken back when it is the same read and grown to
+ * `first` rows; a resume that grows past a limit ends it.
+ */
+export declare function resumed(channel: Channel, token: string, signature: string, first: number): Promise<AsyncIterableIterator<LiveEvent> | undefined>;
+/**
+ * Follows the read `open` starts; `event` turns each message the client
+ * gets into what it runs, and `closed`, given a live function's error, into
+ * the last one, unless the viewer ended, which closes the socket. A list given `keep` is kept once completed.
+ */
+export declare function liveStream(channel: Channel, open: (send: (message: LiveMessage) => void) => Promise<LiveHandle>, event: (message: Exclude<LiveMessage, {
+    kind: 'closed';
+}>) => LiveEvent, closed: (error?: unknown) => LiveEvent, keep?: Keep): Promise<AsyncIterableIterator<LiveEvent>>;
+//# sourceMappingURL=live-stream.d.ts.map

package/dist/live-stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-stream.d.ts","sourceRoot":"","sources":["../src/live-stream.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAE3E,0EAA0E;AAC1E,qBAAa,SAAS;IACrB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,eAAe,CAAA;IAE7D,YACC,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,eAAe,EAIpD;CACD;AAED,wDAAwD;AACxD,MAAM,MAAM,OAAO,GAAG;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,0DAA0D;IAC1D,QAAQ,CAAC,IAAI,EAAE,MAAM,OAAO,CAAA;IAC5B,mDAAmD;IACnD,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;IAC5C,gEAAgE;IAChE,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAA;IAC3B,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;CAChC,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG;IAClB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;IACtB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,mEAAmE;AACnE,MAAM,MAAM,IAAI,GAAG;IAClB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,KAAK,EAAE,MAAM,CAAA;CACb,CAAA;AAED,wEAAwE;AACxE,MAAM,MAAM,IAAI,GAAG;IAClB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC,SAAS,CAAC,CAAA;IACjD,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,OAAO,CAAA;IAC9B,QAAQ,CAAC,GAAG,EAAE,MAAM,IAAI,CAAA;CACxB,CAAA;AAKD,kDAAkD;AAClD,eAAO,MAAM,KAAK,EAAE,OAAO,CAAC,MAAM,EAAE,IAAI,CAAiB,CAAA;AAOzD;;;GAGG;AACH,wBAAsB,OAAO,CAC5B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,GACX,OAAO,CAAC,qBAAqB,CAAC,SAAS,CAAC,GAAG,SAAS,CAAC,CAevD;AAED;;;;GAIG;AACH,wBAAsB,UAAU,CAC/B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,KAAK,OAAO,CAAC,UAAU,CAAC,EACnE,KAAK,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,WAAW,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,KAAK,SAAS,EACvE,MAAM,EAAE,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,SAAS,EACtC,IAAI,CAAC,EAAE,IAAI,GACT,OAAO,CAAC,qBAAqB,CAAC,SAAS,CAAC,CAAC,CAmF3C"}

package/dist/live-stream.js

@@ -0,0 +1,136 @@
+/** A message to run against the selection, and how its result is sent. */
+export class LiveEvent {
+    root;
+    finish;
+    constructor(root, finish) {
+        this.root = root;
+        this.finish = finish;
+    }
+}
+/** How long a completed live list waits for a resume. */
+const keptFor = 10_000;
+/** Each WebSocket operation's, by its context. */
+export const lives = new WeakMap();
+const finished = () => ({
+    done: true,
+    value: undefined,
+});
+/**
+ * The list `token` keeps, taken back when it is the same read and grown to
+ * `first` rows; a resume that grows past a limit ends it.
+ */
+export async function resumed(channel, token, signature, first) {
+    const kept = channel.kept.get(token);
+    if (kept?.keep.signature !== signature || first < kept.keep.first) {
+        return undefined;
+    }
+    channel.kept.delete(token);
+    clearTimeout(kept.timer);
+    try {
+        if (first > kept.keep.first)
+            await kept.handle.grow(first - kept.keep.first);
+    }
+    catch (error) {
+        kept.end();
+        throw error;
+    }
+    kept.keep.first = first;
+    return kept.stream;
+}
+/**
+ * Follows the read `open` starts; `event` turns each message the client
+ * gets into what it runs, and `closed`, given a live function's error, into
+ * the last one, unless the viewer ended, which closes the socket. A list given `keep` is kept once completed.
+ */
+export async function liveStream(channel, open, event, closed, keep) {
+    const queue = [];
+    let waiting;
+    let ending = false;
+    let done = false;
+    // Changes are dropped from a full buffer until the window comes whole.
+    let dropping = false;
+    let owed = false;
+    let handle;
+    const push = (value) => {
+        const taker = waiting;
+        waiting = undefined;
+        if (taker === undefined)
+            queue.push(value);
+        else
+            taker({ done: false, value });
+    };
+    const end = () => {
+        done = true;
+        queue.length = 0;
+        handle?.close();
+        const taker = waiting;
+        waiting = undefined;
+        taker?.(finished());
+    };
+    const send = (message) => {
+        if (done || ending)
+            return;
+        if (message.kind === 'closed') {
+            if (channel.viewer.closed) {
+                end();
+                return channel.forbid();
+            }
+            ending = true;
+            return push(closed(message.error));
+        }
+        if (dropping && message.kind === 'changes')
+            return;
+        if (!dropping && channel.full()) {
+            queue.length = 0;
+            dropping = true;
+            channel.drained(() => {
+                if (handle === undefined)
+                    owed = true;
+                else
+                    void handle.resend();
+            });
+            return;
+        }
+        dropping = false;
+        push(event(message));
+    };
+    const opened = await open(send);
+    handle = opened;
+    if (owed)
+        void opened.resend();
+    const stream = {
+        next: async () => {
+            const value = queue.shift();
+            if (value !== undefined)
+                return { done: false, value };
+            if (done || ending) {
+                end();
+                return finished();
+            }
+            return new Promise((taker) => {
+                waiting = taker;
+            });
+        },
+        return: async () => {
+            if (channel.kept.get(keep?.token ?? '')?.stream === stream) {
+                return finished();
+            }
+            if (keep === undefined || done || ending || channel.viewer.closed) {
+                end();
+                return finished();
+            }
+            const taker = waiting;
+            waiting = undefined;
+            taker?.(finished());
+            const timer = setTimeout(() => {
+                channel.kept.delete(keep.token);
+                end();
+            }, keptFor);
+            timer.unref();
+            channel.kept.set(keep.token, { keep, stream, handle: opened, timer, end });
+            return finished();
+        },
+        [Symbol.asyncIterator]: () => stream,
+    };
+    return stream;
+}

package/dist/mutations.d.ts

@@ -0,0 +1,9 @@
+import type { GraphQLFieldConfig } from 'graphql';
+import type { Args, Context, Entry, Registry } from './registry.ts';
+type Fields = {
+    [field: string]: GraphQLFieldConfig<unknown, Context, Args>;
+};
+/** A visible model's four mutations. */
+export declare function mutationFields(registry: Registry, entry: Entry): Fields;
+export {};
+//# sourceMappingURL=mutations.d.ts.map

package/dist/mutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutations.d.ts","sourceRoot":"","sources":["../src/mutations.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACX,kBAAkB,EAGlB,MAAM,SAAS,CAAA;AAahB,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAKnE,KAAK,MAAM,GAAG;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,CAAA;CAAE,CAAA;AA2N7E,wCAAwC;AACxC,wBAAgB,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,MAAM,CAoEvE"}