@ultimabase/graphql 0.0.0-stage → 0.1.1

package/dist/mutations.js

@@ -0,0 +1,228 @@
+// 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 { GraphQLBoolean, GraphQLID, GraphQLInputObjectType, GraphQLList, GraphQLNonNull, } from 'graphql';
+import { objectOf, uniqueInput, uniqueWhere } from './inputs.js';
+import { jsonInput, plainData } from './json-fields.js';
+import { upper } from './names.js';
+import { deletedType, isMaster, objectType } from './outputs.js';
+import { as, described, valueType } from './registry.js';
+import { JSONScalar } from './scalars.js';
+import { selectOf } from './select.js';
+/** `ConnectInput { id }`: what a relation write names a row by. */
+const connectInput = (registry) => registry.input('ConnectInput', () => new GraphQLInputObjectType({
+    name: 'ConnectInput',
+    fields: { id: { type: new GraphQLNonNull(GraphQLID) } },
+}));
+const facing = (field) => `Without${upper(field.inverse)}`;
+/** `CommentCreateOrConnectWithoutPostInput { where, create }` (D-138). */
+const orCreateInput = (registry, field) => {
+    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, field) => {
+    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, field, creating) {
+    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 = (type) => 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 = { 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, model, data) {
+    const plained = 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) => kernelData(registry, target, objectOf(item));
+        const unique = (item) => uniqueWhere(registry, target, objectOf(item));
+        const write = { ...value };
+        const map = (key, read) => {
+            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, model, field, creating) {
+    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, model, creating, without) {
+    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 = {};
+            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, entry) {
+    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) => ({
+        type: new GraphQLNonNull(dataInput(registry, name, creating)),
+    });
+    const written = (write) => async (_, args, context, info) => {
+        const select = selectOf(registry, info, type, info.fieldNodes, isMaster(context));
+        return run(() => write(args, select, context));
+    };
+    const unique = (args) => uniqueWhere(registry, name, objectOf(args['where']));
+    const dataOf = (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/dist/names.d.ts

@@ -0,0 +1,8 @@
+export declare const upper: (name: string) => string;
+export declare const lower: (name: string) => string;
+/** A model's root fields: its one-row name and its list name. */
+export declare function rootNames(model: string, given: string | undefined): {
+    readonly single: string;
+    readonly list: string;
+};
+//# sourceMappingURL=names.d.ts.map

package/dist/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../src/names.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,KAAK,SAAU,MAAM,KAAG,MACQ,CAAA;AAE7C,eAAO,MAAM,KAAK,SAAU,MAAM,KAAG,MACQ,CAAA;AAE7C,iEAAiE;AACjE,wBAAgB,SAAS,CACxB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GAAG,SAAS,GACvB;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CASpD"}

package/dist/names.js

@@ -0,0 +1,14 @@
+// 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) => name.charAt(0).toUpperCase() + name.slice(1);
+export const lower = (name) => name.charAt(0).toLowerCase() + name.slice(1);
+/** A model's root fields: its one-row name and its list name. */
+export function rootNames(model, given) {
+    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/dist/outputs.d.ts

@@ -0,0 +1,16 @@
+import type { GraphQLFieldConfigArgumentMap } from 'graphql';
+import { GraphQLObjectType } from 'graphql';
+import type { Context, Registry } from './registry.ts';
+export declare const isMaster: (context: Context) => boolean;
+/** `first`, `after`, `last`, `before`, or `take` and `skip`; then filters. */
+export declare function listArgs(registry: Registry, model: string): GraphQLFieldConfigArgumentMap;
+/**
+ * `PostConnection` at the root, `UserPostsConnection` on a relation, each
+ * with `totalCount` (D-107, D-134).
+ */
+export declare function connectionType(registry: Registry, name: string, model: string): GraphQLObjectType;
+/** `Post`: a field only Master reads is absent, a ruled one nullable. */
+export declare function objectType(registry: Registry, model: string): GraphQLObjectType;
+/** `DeletedPost`: a deleted row as it was, without its relations (D-102). */
+export declare function deletedType(registry: Registry, model: string): GraphQLObjectType;
+//# sourceMappingURL=outputs.d.ts.map

package/dist/outputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputs.d.ts","sourceRoot":"","sources":["../src/outputs.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAEX,6BAA6B,EAE7B,MAAM,SAAS,CAAA;AAChB,OAAO,EAMN,iBAAiB,EAEjB,MAAM,SAAS,CAAA;AAMhB,OAAO,KAAK,EAAQ,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAO5D,eAAO,MAAM,QAAQ,YAAa,OAAO,KAAG,OACX,CAAA;AAEjC,8EAA8E;AAC9E,wBAAgB,QAAQ,CACvB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,GACX,6BAA6B,CAiB/B;AA8BD;;;GAGG;AACH,wBAAgB,cAAc,CAC7B,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACX,iBAAiB,CAkBnB;AA6GD,yEAAyE;AACzE,wBAAgB,UAAU,CACzB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,GACX,iBAAiB,CA2BnB;AAED,6EAA6E;AAC7E,wBAAgB,WAAW,CAC1B,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,GACX,iBAAiB,CAWnB"}

package/dist/outputs.js

@@ -0,0 +1,177 @@
+// 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 { GraphQLBoolean, GraphQLID, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLString, } from 'graphql';
+import { orderByInput, whereInput } from './inputs.js';
+import { upper } from './names.js';
+import { listRead } from './pages.js';
+import { jsonOutput } from './json-fields.js';
+import { described, valueType } from './registry.js';
+import { DateTime } from './scalars.js';
+const required = (type) => new GraphQLNonNull(type);
+export const isMaster = (context) => context.caller.kind === 'master';
+/** `first`, `after`, `last`, `before`, or `take` and `skip`; then filters. */
+export function listArgs(registry, model) {
+    const pages = 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.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, model) => 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, name, model) {
+    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, model, field, ruled) {
+    const value = 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, model, field, ruled) {
+    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 = Reflect.get(Object(source), '_count');
+                    const count = 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, model) {
+    const entry = registry.entry(model);
+    const fields = {
+        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, model) {
+    return registry.object(model, () => new GraphQLObjectType({
+        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, model) {
+    const name = `Deleted${model}`;
+    return registry.object(name, () => new GraphQLObjectType({
+        name,
+        fields: () => described(registry.entry(model), scalarFields(registry, model)),
+    }));
+}

package/dist/overlap.d.ts

@@ -0,0 +1,5 @@
+import type { DocumentNode } from 'graphql';
+import { GraphQLError } from 'graphql';
+/** The refusal of a document whose fields of one key make too many pairs. */
+export declare function overlapRefusal(document: DocumentNode): GraphQLError | undefined;
+//# sourceMappingURL=overlap.d.ts.map

package/dist/overlap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlap.d.ts","sourceRoot":"","sources":["../src/overlap.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACX,YAAY,EAIZ,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,YAAY,EAAQ,MAAM,SAAS,CAAA;AAa5C,6EAA6E;AAC7E,wBAAgB,cAAc,CAC7B,QAAQ,EAAE,YAAY,GACpB,YAAY,GAAG,SAAS,CAsE1B"}

package/dist/overlap.js

@@ -0,0 +1,82 @@
+import { GraphQLError, Kind } from 'graphql';
+/** At about 28 µs a pair, the rule's slowest, about 30 ms of validation. */
+const maxPairs = 1000;
+const pairsOf = (fields) => (fields * (fields - 1)) / 2;
+/** The refusal of a document whose fields of one key make too many pairs. */
+export function overlapRefusal(document) {
+    const fragments = new Map();
+    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();
+    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) => {
+        const byKey = new Map();
+        const spread = new Set();
+        const collect = (set, from) => {
+            for (const selection of set.selections) {
+                if (selection.kind === Kind.FIELD) {
+                    const key = selection.alias?.value ?? selection.name.value;
+                    const same = 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) => {
+        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.');
+}

package/dist/pages.d.ts

@@ -0,0 +1,11 @@
+import type { Page } from '@ultimabase/http/internal';
+import type { Args, Registry } from './registry.ts';
+import type { Entry } from './registry.ts';
+/** The kernel's `where` of a list or count's arguments. */
+export declare function whereOf(registry: Registry, model: string, args: Args): Args;
+/** A list's kernel read, and its Relay page unless `pagination: 'list'`. */
+export declare function listRead(registry: Registry, entry: Entry, args: Args, master: boolean): {
+    readonly read: Args;
+    readonly page: Page['relay'];
+};
+//# sourceMappingURL=pages.d.ts.map

package/dist/pages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pages.d.ts","sourceRoot":"","sources":["../src/pages.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAA;AAGrD,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAA;AAE1C,2DAA2D;AAC3D,wBAAgB,OAAO,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,CAK3E;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CACvB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,KAAK,EACZ,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,OAAO,GACb;IAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,CAAA;CAAE,CAgBvD"}

package/dist/pages.js

@@ -0,0 +1,22 @@
+import { pageOf } from '@ultimabase/http/internal';
+import { plainWhere } from './json-fields.js';
+/** The kernel's `where` of a list or count's arguments. */
+export function whereOf(registry, model, args) {
+    const { where } = args;
+    return typeof where === 'object' && where !== null
+        ? { where: plainWhere(registry, model, { ...where }) }
+        : {};
+}
+/** A list's kernel read, and its Relay page unless `pagination: 'list'`. */
+export function listRead(registry, entry, args, master) {
+    const { orderBy } = args;
+    const { read, relay } = pageOf(registry.settings.pagination, entry, args, master);
+    return {
+        read: {
+            ...whereOf(registry, entry.model.name, args),
+            ...(orderBy === undefined || orderBy === null ? {} : { orderBy }),
+            ...read,
+        },
+        page: relay,
+    };
+}

package/dist/registry.d.ts

@@ -0,0 +1,80 @@
+import type { GraphQLFieldConfigMap, GraphQLInputObjectType, GraphQLObjectType, GraphQLResolveInfo, GraphQLScalarType } from 'graphql';
+import { GraphQLEnumType, GraphQLList, GraphQLNonNull } from 'graphql';
+import type { Caller, Client, ExposedModel, SchemaField, SchemaModel } from 'ultimabase';
+import { DataTypes } from './data-types.ts';
+/** A model's key of `.with` (D-107). */
+export type GraphqlWith = {
+    readonly plural?: string;
+    readonly maxTake?: number;
+} | false;
+/** What every resolver receives, the generated ones and those `extend` adds. */
+export type Context = {
+    readonly caller: Caller;
+    /** The request's client, which a function's `run` receives (D-113). */
+    readonly client: Client;
+    /**
+     * The kernel's `select` for what the client asks of the rows a field
+     * returns, relations and their pages included; spread it to add a field.
+     * Its type names `id` only: the rest depends on the document.
+     */
+    readonly select: (info: GraphQLResolveInfo) => {
+        readonly id: true;
+    };
+};
+/** A kernel query's options: run as the request's caller (D-106). */
+export declare const as: (context: Context) => {
+    readonly as: Caller;
+};
+export type Args = {
+    readonly [arg: string]: unknown;
+};
+export type Scalar = Extract<SchemaField, {
+    readonly kind: 'scalar';
+}>;
+export type Entry = {
+    readonly exposed: ExposedModel<GraphqlWith>;
+    readonly model: SchemaModel;
+    /** In the root fields; a hidden model is reached by relations only. */
+    readonly visible: boolean;
+    readonly single: string;
+    readonly list: string;
+    /** The rows a list returns without `first`, `last` or `take`. */
+    readonly take: number;
+    readonly maxTake: number;
+};
+export type Settings = {
+    readonly pagination: 'connection' | 'list';
+};
+export declare class Registry {
+    #private;
+    readonly entries: ReadonlyMap<string, Entry>;
+    readonly settings: Settings;
+    /** The types functions and json fields give, shared by both (D-125). */
+    readonly data: DataTypes;
+    /** A model's virtual fields, which the functions' outputs build (D-151). */
+    virtualFields: (model: string) => GraphQLFieldConfigMap<unknown, Context>;
+    constructor(entries: ReadonlyMap<string, Entry>, settings: Settings);
+    entry(model: string): Entry;
+    object(name: string, build: () => GraphQLObjectType): GraphQLObjectType;
+    input(name: string, build: () => GraphQLInputObjectType): GraphQLInputObjectType;
+    enum(name: string, build: () => GraphQLEnumType): GraphQLEnumType;
+}
+/** Each field's `description` (D-150), on the fields of a type or an input. */
+export declare function described<C extends {
+    readonly description?: string | null | undefined;
+}>(entry: Entry, fields: {
+    [field: string]: C;
+}): {
+    [field: string]: C;
+};
+export declare const scalarTypes: {
+    readonly [T in Exclude<Scalar['type'], 'enum'>]: GraphQLScalarType;
+};
+/**
+ * A scalar field's type; an enum's is `PostStatus`, built once, and a
+ * `defineEnum`'s its own name, one type for every field (D-150).
+ */
+export declare function scalarType(registry: Registry, model: string, field: Scalar): GraphQLScalarType | GraphQLEnumType;
+/** A scalar field's value, read or written: a list's is `[Float!]` (D-127). */
+export declare const valueType: (registry: Registry, model: string, field: Scalar) => GraphQLScalarType | GraphQLEnumType | GraphQLList<GraphQLNonNull<GraphQLScalarType | GraphQLEnumType>>;
+//# sourceMappingURL=registry.d.ts.map