@ultimabase/rest 0.0.0-stage → 0.1.1

package/dist/models.js

@@ -0,0 +1,136 @@
+import { validate } from '@ultimabase/http';
+import { badInput, connection, pageArgs, run } from '@ultimabase/http/internal';
+import { InvalidQuery, PublicError } from 'ultimabase';
+import { defaultShape, filterOf, readerOf, shaped } from './fields.js';
+import { bounded } from './limits.js';
+import { liveList, liveRow, wantsEvents } from './live.js';
+import { paramsOf } from './params.js';
+import { dataOf, isArgs, whereOf } from './values.js';
+/** Any JSON body: the kernel checks the data (D-129). */
+export const anyBody = {
+    '~standard': { validate: (value) => ({ value }) },
+};
+const fieldParams = { json: ['select', 'include'], text: [] };
+/** The kernel read of one row's `select` or `include`. */
+function oneRead(api, entry, caller, url) {
+    const params = paramsOf(url, fieldParams);
+    const read = readerOf(api, caller.kind === 'master').fields(entry, params, '');
+    bounded(api, caller, read.shape, 1);
+    return read;
+}
+/** `GET /api/posts`: a connection, or a list with `pagination: 'list'`. */
+async function list(api, entry, caller, url) {
+    const counts = api.pagination === 'connection';
+    const params = paramsOf(url, {
+        json: [
+            'where',
+            'orderBy',
+            'select',
+            'include',
+            ...pageArgs(api.pagination).filter((arg) => arg !== 'after' && arg !== 'before'),
+            ...(counts ? ['totalCount'] : []),
+        ],
+        text: counts ? ['after', 'before'] : [],
+    });
+    const { totalCount, ...args } = params;
+    if (totalCount !== undefined && typeof totalCount !== 'boolean') {
+        throw badInput('totalCount must be true or false.');
+    }
+    const read = readerOf(api, caller.kind === 'master').list(entry, args, '');
+    // A count reads the rows it counts, however few the page returns.
+    const size = totalCount === true ? Math.max(read.size, entry.take) : read.size;
+    bounded(api, caller, read.shape, size);
+    const { queries } = entry.exposed;
+    const rows = await queries.findMany(read.read, { as: caller });
+    const node = (row) => shaped(row, read.shape);
+    if (read.relay === undefined)
+        return rows.map(node);
+    const page = connection(rows, read.relay, node);
+    if (totalCount !== true)
+        return page;
+    const where = filterOf(api, entry, args['where'], 'where');
+    return { ...page, totalCount: await queries.count(where, { as: caller }) };
+}
+const notFound = (entry) => new PublicError('NOT_FOUND', `No ${entry.model.name} matches.`);
+const written = (api, entry, body) => isArgs(body) ? dataOf(api, entry.model.name, body, 'data') : body;
+const upsertKeys = new Set(['where', 'create', 'update']);
+/** An upsert's body, its dates read; the kernel checks the rest (D-142). */
+function upserting(api, entry, body) {
+    const { name } = entry.model;
+    if (!isArgs(body))
+        throw new InvalidQuery('body', 'The body must be an object.');
+    const read = {};
+    for (const [key, value] of Object.entries(body)) {
+        if (!upsertKeys.has(key)) {
+            throw new InvalidQuery(key, `Unknown key '${key}' on ${name}.`);
+        }
+        if (!isArgs(value))
+            read[key] = value;
+        else if (key === 'where')
+            read[key] = whereOf(api, name, value, key);
+        else
+            read[key] = dataOf(api, name, value, key);
+    }
+    return read;
+}
+/** Each route of a visible model, under `base`; its reads live with `live`. */
+export function modelRoutes(app, api, entry, base, live) {
+    const path = `${base}/${entry.plural}`;
+    const { queries } = entry.exposed;
+    app.get(path, async (c) => {
+        const { caller } = c.var;
+        if (wantsEvents(c.req.raw)) {
+            return liveList(api, live, entry, caller, c.req.raw);
+        }
+        return c.json(await run(() => list(api, entry, caller, c.req.url)));
+    });
+    /** The row `query` returns, shaped as `url` asks. */
+    const one = async (caller, url, query) => {
+        const { row, shape } = await run(async () => {
+            const fields = oneRead(api, entry, caller, url);
+            return { row: await query(fields.read, { as: caller }), ...fields };
+        });
+        if (row === null)
+            throw notFound(entry);
+        return shaped(row, shape);
+    };
+    app.get(`${path}/:id`, async (c) => {
+        const { caller } = c.var;
+        const id = c.req.param('id');
+        if (wantsEvents(c.req.raw)) {
+            return liveRow(api, live, entry, caller, c.req.raw, id);
+        }
+        return c.json(await one(caller, c.req.url, async (read, as) => queries.findUnique({ ...read, where: { id } }, as)));
+    });
+    app.post(path, validate('json', anyBody), async (c) => {
+        const body = c.req.valid('json');
+        const row = await one(c.var.caller, c.req.url, async (read, as) => queries.create({ ...read, data: written(api, entry, body) }, as));
+        return c.json(row, 201);
+    });
+    // 201 when it created the row, 200 when it updated it (D-142).
+    app.put(path, validate('json', anyBody), async (c) => {
+        const body = c.req.valid('json');
+        const { caller } = c.var;
+        const { row, created, shape } = await run(async () => {
+            const fields = oneRead(api, entry, caller, c.req.url);
+            const args = { ...fields.read, ...upserting(api, entry, body) };
+            const upserted = await entry.exposed.upsert(args, { as: caller });
+            return { ...upserted, shape: fields.shape };
+        });
+        return c.json(shaped(row, shape), created ? 201 : 200);
+    });
+    app.patch(`${path}/:id`, validate('json', anyBody), async (c) => {
+        const body = c.req.valid('json');
+        const where = { id: c.req.param('id') };
+        return c.json(await one(c.var.caller, c.req.url, async (read, as) => queries.update({ ...read, where, data: written(api, entry, body) }, as)));
+    });
+    app.delete(`${path}/:id`, async (c) => {
+        const { caller } = c.var;
+        const row = await run(async () => {
+            paramsOf(c.req.url, { json: [], text: [] });
+            return queries.delete({ where: { id: c.req.param('id') } }, { as: caller });
+        });
+        // As it was, without its relations (D-102).
+        return c.json(shaped(row, defaultShape(entry)));
+    });
+}

package/dist/openapi-functions.d.ts

@@ -0,0 +1,11 @@
+import type { ExposedOutput } from 'ultimabase';
+import type { Routed } from './functions.ts';
+import type { Doc } from './openapi-inputs.ts';
+import type { Schema } from './openapi.ts';
+/** A model, a `defineType` or a schema, held as `form` says (D-109). */
+export declare function outputOf(doc: Doc, output: ExposedOutput, owner: string, root: string): Schema;
+/** `/functions/{name}`, a query over GET, a mutation over POST (D-109). */
+export declare function functionPaths(doc: Doc, functions: readonly Routed[]): {
+    [path: string]: Schema;
+};
+//# sourceMappingURL=openapi-functions.d.ts.map

package/dist/openapi-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-functions.d.ts","sourceRoot":"","sources":["../src/openapi-functions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,YAAY,CAAA;AAC5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAE5C,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAA;AAE9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAyC1C,wEAAwE;AACxE,wBAAgB,QAAQ,CACvB,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,GACV,MAAM,CAWR;AAsBD,2EAA2E;AAC3E,wBAAgB,aAAa,CAC5B,GAAG,EAAE,GAAG,EACR,SAAS,EAAE,SAAS,MAAM,EAAE,GAC1B;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAiC5B"}

package/dist/openapi-functions.js

@@ -0,0 +1,85 @@
+import { isNode, jsonSchemaOf } from '@ultimabase/http/internal';
+import { getParams } from './functions.js';
+import { rowOf } from './openapi-models.js';
+import { arrayOf, describe, failed, hoisted, json, objectOf, orNull, } from './openapi.js';
+const upper = (name) => name.charAt(0).toUpperCase() + name.slice(1);
+const prefix = '#/components/schemas/';
+/** A schema, or the component it refers to. */
+function resolve(doc, schema) {
+    const ref = schema['$ref'];
+    if (typeof ref !== 'string' || !ref.startsWith(prefix))
+        return schema;
+    return doc.components.schemas[ref.slice(prefix.length)] ?? {};
+}
+/** A `defineType`, each of its fields always given (D-109). */
+function typeOf(doc, type, owner) {
+    return doc.components.ref(type.name, () => describe(objectOf(Object.fromEntries([...type.fields].map(([name, field]) => [
+        name,
+        outputOf(doc, field, owner, `${type.name}${upper(name)}`),
+    ])), [...type.fields.keys()]), type.description));
+}
+/** A model, a `defineType` or a schema, held as `form` says (D-109). */
+export function outputOf(doc, output, owner, root) {
+    if (output.kind === 'schema') {
+        const node = jsonSchemaOf(output.schema, 'output', `${owner}: output`);
+        return hoisted(doc.components, node, 'output', owner, root);
+    }
+    const one = output.kind === 'model'
+        ? rowOf(doc, output.name)
+        : typeOf(doc, output.type, owner);
+    if (output.form === 'list')
+        return arrayOf(one);
+    return output.form === 'nullable' ? orNull(one) : one;
+}
+/** A GET's parameters, as `getParams` reads them. */
+function paramsOf(doc, input, schema) {
+    const { accepted, flat } = getParams(input);
+    if (!flat) {
+        const as = accepted.text.length > 0 ? { schema } : { content: json(schema) };
+        return [{ name: 'input', in: 'query', required: true, ...as }];
+    }
+    const object = resolve(doc, schema);
+    const properties = isNode(object['properties']) ? object['properties'] : {};
+    const required = Array.isArray(object['required']) ? object['required'] : [];
+    return Object.entries(properties).map(([name, property]) => ({
+        name,
+        in: 'query',
+        ...(required.includes(name) && { required: true }),
+        ...(accepted.text.includes(name)
+            ? { schema: property }
+            : { content: json(isNode(property) ? property : {}) }),
+    }));
+}
+/** `/functions/{name}`, a query over GET, a mutation over POST (D-109). */
+export function functionPaths(doc, functions) {
+    const paths = {};
+    for (const { fn, owner, name, input } of functions) {
+        const base = upper(name);
+        const given = input === undefined
+            ? undefined
+            : hoisted(doc.components, input, 'input', owner, `${base}Input`);
+        const output = fn.output === undefined
+            ? { const: true }
+            : outputOf(doc, fn.output, owner, `${base}Output`);
+        const operation = {
+            operationId: doc.components.operation(name, owner, 'name'),
+            tags: ['functions'],
+            ...(fn.description !== undefined && { description: fn.description }),
+            ...(fn.query && given !== undefined && input !== undefined
+                ? { parameters: paramsOf(doc, input, given) }
+                : {}),
+            ...(!fn.query &&
+                given !== undefined && {
+                requestBody: { required: true, content: json(given) },
+            }),
+            responses: {
+                200: { description: `What ${name} returns.`, content: json(output) },
+                ...failed,
+            },
+        };
+        paths[`/functions/${name}`] = fn.query
+            ? { get: operation }
+            : { post: operation };
+    }
+    return paths;
+}

package/dist/openapi-inputs.d.ts

@@ -0,0 +1,30 @@
+import type { SchemaField } from 'ultimabase';
+import type { Api, Entry } from './entries.ts';
+import type { Components, Schema } from './openapi.ts';
+type Scalar = Extract<SchemaField, {
+    readonly kind: 'scalar';
+}>;
+/** What the document is built from: its components and REST's models. */
+export type Doc = {
+    readonly components: Components;
+    readonly api: Api;
+};
+/** A field's value, a plugin field's as its shape says (D-122, D-152). */
+export declare function valueOf(doc: Doc, entry: Entry, field: Scalar, side: 'input' | 'output'): Schema;
+/** `PostWhereInput`, its relation filters included. */
+export declare function whereOf(doc: Doc, model: string): Schema;
+/** `PostOrderByInput`, an object or a list of them (D-94, D-134). */
+export declare function orderByOf(doc: Doc, model: string): Schema;
+/**
+ * `PostWhereUniqueInput`, as REST takes it: the fields of one unique set,
+ * `{ id }` or `{ author, slug }`, a relation by its target's id.
+ */
+export declare function uniqueOf(doc: Doc, model: string): Schema;
+/**
+ * `PostCreateInput` and `PostUpdateInput`: every field, those only Master
+ * reads included; a create needs the fields `create` needs (D-53). Through
+ * a relation, `CommentCreateWithoutPostInput`, without it (D-138).
+ */
+export declare function dataOf(doc: Doc, model: string, creating: boolean, without?: string): Schema;
+export {};
+//# sourceMappingURL=openapi-inputs.d.ts.map

package/dist/openapi-inputs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-inputs.d.ts","sourceRoot":"","sources":["../src/openapi-inputs.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAG7C,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAWtD,KAAK,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAAA;AAG/D,yEAAyE;AACzE,MAAM,MAAM,GAAG,GAAG;IAAE,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;CAAE,CAAA;AAqFxE,0EAA0E;AAC1E,wBAAgB,OAAO,CACtB,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,OAAO,GAAG,QAAQ,GACtB,MAAM,CAOR;AAqFD,uDAAuD;AACvD,wBAAgB,OAAO,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAwBvD;AAYD,qEAAqE;AACrE,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CA+BzD;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAqBxD;AA4DD;;;;GAIG;AACH,wBAAgB,MAAM,CACrB,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,OAAO,EACjB,OAAO,CAAC,EAAE,MAAM,GACd,MAAM,CAyBR"}

package/dist/openapi-inputs.js

@@ -0,0 +1,316 @@
+// The inputs of the document (D-144), named and typed as GraphQL's (D-129):
+// each field's value, the filters, `where`, `orderBy`, the unique target
+// in REST's flat form, and the data a write takes.
+import { jsonSchemaOf, readable } from '@ultimabase/http/internal';
+import { Refused } from 'ultimabase';
+import { decimalPattern } from 'ultimabase/internal';
+import { entryOf } from './entries.js';
+import { arrayOf, describe, described, hoisted, objectOf, orNull, refTo, } from './openapi.js';
+const upper = (name) => name.charAt(0).toUpperCase() + name.slice(1);
+/** Whether a model has fields its `_search` matches (D-148). */
+const searched = (fields) => fields.some((field) => field.kind === 'scalar' && field.search === true);
+const id = { type: 'string' };
+const dateTime = { type: 'string', format: 'date-time' };
+/** One value of `field`, a list's item, by GraphQL's type name. */
+function item(doc, model, field, side) {
+    const named = `${model}${upper(field.name)}`;
+    switch (field.type) {
+        case 'string':
+            return { name: 'String', schema: { type: 'string' } };
+        case 'number':
+            return field.integer === true
+                ? { name: 'Int', schema: { type: 'integer', format: 'int32' } }
+                : { name: 'Float', schema: { type: 'number' } };
+        case 'decimal':
+            return {
+                name: 'Decimal',
+                schema: { type: 'string', pattern: decimalPattern },
+            };
+        case 'boolean':
+            return { name: 'Boolean', schema: { type: 'boolean' } };
+        case 'dateTime':
+            return { name: 'DateTime', schema: dateTime };
+        case 'date':
+            return { name: 'Date', schema: { type: 'string', format: 'date' } };
+        case 'enum': {
+            const values = field.values ?? [];
+            const shared = entryOf(doc.api, model).exposed.enums[field.name];
+            if (shared !== undefined) {
+                const { name, description } = shared;
+                const schema = describe({ type: 'string', enum: values }, description);
+                const owner = `${model}.${field.name}`;
+                return { name, schema: doc.components.shared(name, schema, owner) };
+            }
+            const schema = doc.components.ref(named, () => ({
+                type: 'string',
+                enum: values,
+            }));
+            return { name: named, schema };
+        }
+        case 'json':
+            break;
+    }
+    return { name: 'JSON', schema: jsonOf(doc, model, field, side) };
+}
+/**
+ * A json field's value: its validator's JSON Schema, any JSON without
+ * (D-125); a plugin field's read value, its shape's (D-152).
+ */
+function jsonOf(doc, model, field, side) {
+    const { validators, fieldTypes } = entryOf(doc.api, model).exposed;
+    const validator = validators[field.name] ?? fieldTypes[field.name]?.shape;
+    if (validator === undefined)
+        return {};
+    const owner = `${model}.${field.name}`;
+    let node;
+    try {
+        node = jsonSchemaOf(validator, side, owner);
+    }
+    catch (error) {
+        // As GraphQL types it: `JSON` without an export.
+        if (error instanceof Refused)
+            return {};
+        throw error;
+    }
+    const root = `${model}${upper(field.name)}${side === 'input' ? 'Input' : ''}`;
+    return hoisted(doc.components, node, side, owner, root);
+}
+/** A field's value, a plugin field's as its shape says (D-122, D-152). */
+export function valueOf(doc, entry, field, side) {
+    if (entry.exposed.fieldTypes[field.name] !== undefined) {
+        // What it takes is the field type's own.
+        return side === 'input' ? {} : jsonOf(doc, entry.model.name, field, side);
+    }
+    const { schema } = item(doc, entry.model.name, field, side);
+    return field.list ? arrayOf(schema) : schema;
+}
+const base = ['equals', 'not', 'in', 'notIn'];
+const ordered = [...base, 'lt', 'lte', 'gt', 'gte'];
+const text = [...base, 'contains', 'startsWith', 'endsWith', 'mode'];
+const operators = {
+    string: text,
+    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,
+};
+/** `StringFilter`, `PostStatusFilter`: `equals` and `not` take `null` too. */
+function filter(doc, name, value, list) {
+    return doc.components.ref(`${name}Filter`, () => objectOf(Object.fromEntries(list.map((operator) => {
+        if (operator === 'mode') {
+            const mode = doc.components.ref('QueryMode', () => ({
+                type: 'string',
+                enum: ['insensitive'],
+            }));
+            return [operator, mode];
+        }
+        if (operator === 'in' || operator === 'notIn') {
+            return [operator, arrayOf(value)];
+        }
+        if (operator === 'path')
+            return [operator, arrayOf({ type: 'string' })];
+        if (operator.startsWith('string')) {
+            return [operator, { type: 'string' }];
+        }
+        const nullable = operator === 'equals' || operator === 'not';
+        return [operator, nullable ? orNull(value) : value];
+    }))));
+}
+function scalarFilter(doc, model, field) {
+    // A typed json field's operands are any JSON at a path (D-149).
+    if (field.type === 'json' && !field.list) {
+        return filter(doc, 'JSON', {}, operators.json);
+    }
+    const { name, schema } = item(doc, model, field, 'input');
+    if (field.list) {
+        return doc.components.ref(`${name}ListFilter`, () => objectOf({
+            has: schema,
+            hasSome: arrayOf(schema),
+            hasEvery: arrayOf(schema),
+            isEmpty: { type: 'boolean' },
+        }));
+    }
+    return filter(doc, name, schema, operators[field.type]);
+}
+/** One value or a list: GraphQL takes either for a list argument. */
+const oneOrMore = (schema) => ({
+    anyOf: [schema, arrayOf(schema)],
+});
+/** `PostWhereInput`, its relation filters included. */
+export function whereOf(doc, model) {
+    return doc.components.ref(`${model}WhereInput`, () => {
+        const self = refTo(`${model}WhereInput`);
+        const entry = entryOf(doc.api, model);
+        const dates = filter(doc, 'DateTime', dateTime, ordered);
+        const fields = {
+            AND: oneOrMore(self),
+            OR: oneOrMore(self),
+            NOT: oneOrMore(self),
+            id: filter(doc, 'ID', id, base),
+            createdAt: dates,
+            updatedAt: dates,
+        };
+        if (searched(readable(entry)))
+            fields['_search'] = { type: 'string' };
+        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] =
+                field.kind === 'scalar'
+                    ? scalarFilter(doc, model, field)
+                    : relationFilter(doc, field);
+        }
+        return objectOf(fields);
+    });
+}
+function relationFilter(doc, field) {
+    const one = field.kind === 'one';
+    const name = `${field.target}${one ? 'Relation' : 'ListRelation'}Filter`;
+    return doc.components.ref(name, () => {
+        const where = whereOf(doc, field.target);
+        const keys = one ? ['is', 'isNot'] : ['some', 'every', 'none'];
+        return objectOf(Object.fromEntries(keys.map((key) => [key, where])));
+    });
+}
+/** `PostOrderByInput`, an object or a list of them (D-94, D-134). */
+export function orderByOf(doc, model) {
+    return doc.components.ref(`${model}OrderByInput`, () => {
+        const order = doc.components.ref('SortOrder', () => ({
+            type: 'string',
+            enum: ['asc', 'desc'],
+        }));
+        const entry = entryOf(doc.api, model);
+        const fields = {
+            id: order,
+            createdAt: order,
+            updatedAt: order,
+        };
+        // The kernel refuses it in a relation's: a read ranks by its own search.
+        if (searched(readable(entry)))
+            fields['_relevance'] = order;
+        for (const field of readable(entry)) {
+            if (field.kind === 'one')
+                fields[field.name] = orderByOf(doc, field.target);
+            else if (field.kind === 'many') {
+                fields[field.name] = doc.components.ref('CountOrderByInput', () => objectOf({ _count: order }));
+            }
+            else if (field.type !== 'json' &&
+                !field.list &&
+                entry.exposed.fieldTypes[field.name] === undefined) {
+                fields[field.name] = order;
+            }
+        }
+        return objectOf(fields);
+    });
+}
+/**
+ * `PostWhereUniqueInput`, as REST takes it: the fields of one unique set,
+ * `{ id }` or `{ author, slug }`, a relation by its target's id.
+ */
+export function uniqueOf(doc, model) {
+    return doc.components.ref(`${model}WhereUniqueInput`, () => {
+        const entry = entryOf(doc.api, model);
+        const { readRules, uniques } = entry.exposed;
+        // A field only Master reads is absent, as from the filters (D-44).
+        const sets = uniques.filter((unique) => unique.every((name) => readRules[name] !== 'private'));
+        const typeOf = (name) => {
+            const field = entry.model.fields.find((each) => each.name === name);
+            return field?.kind === 'scalar' ? valueOf(doc, entry, field, 'input') : id;
+        };
+        return {
+            anyOf: sets.map((unique) => objectOf(Object.fromEntries(unique.map((name) => [name, typeOf(name)])), unique)),
+        };
+    });
+}
+/** Exactly one of an object's keys, as a GraphQL `@oneOf` input. */
+const oneKey = (schema) => ({
+    ...schema,
+    minProperties: 1,
+    maxProperties: 1,
+});
+/**
+ * A relation's write, as GraphQL names it (D-128, D-138): a hidden target is
+ * connected, disconnected or set, never created, updated or deleted.
+ */
+function relationInput(doc, field, creating) {
+    const many = field.kind === 'many';
+    const shape = many ? 'Many' : field.optional ? 'One' : 'OneRequired';
+    const facing = `Without${upper(field.inverse)}`;
+    const name = creating
+        ? `${field.target}CreateNested${many ? 'Many' : 'One'}${facing}Input`
+        : `${field.target}Update${shape}${facing}NestedInput`;
+    return doc.components.ref(name, () => {
+        const listed = (schema) => (many ? arrayOf(schema) : schema);
+        const unique = uniqueOf(doc, field.target);
+        const { visible } = entryOf(doc.api, field.target);
+        const updating = !creating && visible;
+        const fields = { connect: listed(unique) };
+        if (visible) {
+            const created = dataOf(doc, field.target, true, field.inverse);
+            const orCreate = doc.components.ref(`${field.target}CreateOrConnect${facing}Input`, () => objectOf({ where: unique, create: created }, ['where', 'create']));
+            fields['connectOrCreate'] = listed(orCreate);
+            fields['create'] = listed(created);
+        }
+        if (updating && shape !== 'OneRequired') {
+            fields['delete'] = many ? listed(unique) : { type: 'boolean' };
+        }
+        if (!creating && shape !== 'OneRequired') {
+            fields['disconnect'] = many ? listed(unique) : { type: 'boolean' };
+        }
+        // A filtered relation takes no `set` (D-151).
+        if (!creating && many && field.filtered !== true) {
+            fields['set'] = listed(unique);
+        }
+        if (updating) {
+            const data = dataOf(doc, field.target, false, field.inverse);
+            fields['update'] = many
+                ? listed(doc.components.ref(`${field.target}UpdateWithWhereUnique${facing}Input`, () => objectOf({ where: unique, data }, ['where', 'data'])))
+                : data;
+        }
+        return many ? objectOf(fields) : oneKey(objectOf(fields));
+    });
+}
+/**
+ * `PostCreateInput` and `PostUpdateInput`: every field, those only Master
+ * reads included; a create needs the fields `create` needs (D-53). Through
+ * a relation, `CommentCreateWithoutPostInput`, without it (D-138).
+ */
+export function dataOf(doc, model, creating, without) {
+    const facing = without === undefined ? '' : `Without${upper(without)}`;
+    const name = `${model}${creating ? 'Create' : 'Update'}${facing}Input`;
+    return doc.components.ref(name, () => {
+        const entry = entryOf(doc.api, model);
+        const fields = {};
+        for (const field of entry.model.fields) {
+            // A view is read-only (D-151).
+            if (field.name === without ||
+                (field.kind === 'many' && field.from !== undefined))
+                continue;
+            if (field.kind !== 'scalar') {
+                fields[field.name] = relationInput(doc, field, creating);
+                continue;
+            }
+            const value = valueOf(doc, entry, field, 'input');
+            fields[field.name] = field.optional && !field.list ? orNull(value) : value;
+        }
+        const required = creating
+            ? entry.exposed.required.filter((each) => each !== without)
+            : [];
+        return objectOf(described(fields, entry.exposed.descriptions), required);
+    });
+}

package/dist/openapi-models.d.ts

@@ -0,0 +1,14 @@
+import type { Entry } from './entries.ts';
+import type { Doc } from './openapi-inputs.ts';
+import type { Schema } from './openapi.ts';
+/**
+ * `Post`: its default fields, which a row always holds without `select`,
+ * and its relations, which `include` adds. A field with a read rule may be
+ * `null`, a `one` relation always may (D-44).
+ */
+export declare function rowOf(doc: Doc, model: string): Schema;
+/** `/posts` and `/posts/{id}`, as REST serves them (D-129, D-142). */
+export declare function modelPaths(doc: Doc, entry: Entry): {
+    [path: string]: Schema;
+};
+//# sourceMappingURL=openapi-models.d.ts.map

package/dist/openapi-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-models.d.ts","sourceRoot":"","sources":["../src/openapi-models.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAA;AAS9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AA+C1C;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAoDrD;AAyJD,sEAAsE;AACtE,wBAAgB,UAAU,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,CAwF7E"}