@next-buildr/payload 0.0.0-stage → 2.0.0

package/dist/data/payload-data-source.js

@@ -0,0 +1,179 @@
+import { createMemoryDataSource, MAX_QUERY_LIMIT, } from '@next-buildr/core';
+import { normalizeDoc, normalizeMedia } from './normalize.js';
+import { isExposedCollection } from './schema-from-fields.js';
+import { compileWhere, QueryFieldError, queryFieldOf, } from './where.js';
+const DEFAULT_SCAN_LIMIT = 1000;
+/** A query that cannot be answered: not allowlisted, malformed, or too broad. */
+export class DataQueryError extends Error {
+}
+/** The Payload collections as the mapping sees them. */
+const collectionsOf = (payload) => payload.config.collections;
+/**
+ * The server `DataSource` (ADR-018): queries and media served from Payload's Local API, held to
+ * the same contract suite as `MemoryDataSource`. Every call runs with the access of the request's
+ * user (`overrideAccess: false`); production reads published documents only.
+ *
+ * Conditions Payload evaluates like the contract (typed scalars, missing values) go to the
+ * database, so paging and totals are the database's. What it cannot (a case-sensitive `contains`,
+ * lists, an optional sort key: missing values must sort last in both directions) is decided by the
+ * memory source over at most `scanLimit` candidates the database already narrowed.
+ */
+export function createPayloadDataSource(options) {
+    const { payload } = options;
+    const collections = collectionsOf(payload);
+    const scanLimit = options.scanLimit ?? DEFAULT_SCAN_LIMIT;
+    const scope = (ctx) => ({
+        ...(options.req === undefined ? {} : { req: options.req }),
+        overrideAccess: false,
+        ...(payload.config.localization && ctx.locale !== ''
+            ? {
+                locale: ctx.locale,
+                ...(payload.config.localization.fallback === false
+                    ? { fallbackLocale: false }
+                    : {}),
+            }
+            : {}),
+    });
+    const idKind = (slug) => {
+        const custom = payload.collections[slug]?.customIDType;
+        return { kind: (custom ?? payload.db.defaultIDType) === 'number' ? 'number' : 'text' };
+    };
+    async function query(spec, ctx) {
+        const queryable = Object.hasOwn(options.queryable, spec.source)
+            ? options.queryable[spec.source]
+            : undefined;
+        const collection = payload.collections[spec.source];
+        const own = collections.find((candidate) => candidate.slug === spec.source);
+        if (queryable === undefined ||
+            collection === undefined ||
+            own === undefined ||
+            !isExposedCollection(own)) {
+            throw new DataQueryError(`The collection "${spec.source}" cannot be queried.`);
+        }
+        if (!Number.isInteger(spec.limit) || spec.limit < 1 || spec.limit > MAX_QUERY_LIMIT) {
+            throw new DataQueryError(`The limit must be between 1 and ${MAX_QUERY_LIMIT}.`);
+        }
+        if (!Number.isInteger(spec.page) || spec.page < 1) {
+            throw new DataQueryError('The page must be 1 or more.');
+        }
+        const id = idKind(spec.source);
+        const context = {
+            collections,
+            source: spec.source,
+            allowed: queryable.fields,
+            id,
+        };
+        let compiled = { c: 'true', post: false };
+        let sortNeedsScan = false;
+        const sortKeys = [];
+        try {
+            if (spec.where !== undefined)
+                compiled = compileWhere(spec.where, context);
+            for (const { field, dir } of spec.sort ?? []) {
+                if (!queryable.sort.includes(field)) {
+                    throw new QueryFieldError(`The field "${field}" of "${spec.source}" cannot be sorted by.`);
+                }
+                const resolved = queryFieldOf({ ...context, allowed: [field] }, field);
+                sortNeedsScan ||= resolved.nullable || resolved.kind === 'unsafe';
+                sortKeys.push(`${dir === 'desc' ? '-' : ''}${resolved.payloadPath}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof QueryFieldError)
+                throw new DataQueryError(error.message);
+            throw error;
+        }
+        if (compiled.c === 'false') {
+            return { items: [], total: 0, page: spec.page, totalPages: 0 };
+        }
+        const conditions = compiled.c === 'where' ? [compiled.where] : [];
+        if (spec.excludeId !== undefined) {
+            const excluded = String(spec.excludeId);
+            if (id.kind === 'text' || /^\d+$/.test(excluded)) {
+                conditions.push({
+                    id: { not_equals: id.kind === 'number' ? Number(excluded) : excluded },
+                });
+            }
+        }
+        const preview = ctx.mode !== 'production';
+        const hasDrafts = Boolean(collection.config.versions && collection.config.versions.drafts);
+        if (hasDrafts && !preview)
+            conditions.push({ _status: { equals: 'published' } });
+        const where = conditions.length === 0
+            ? undefined
+            : conditions.length === 1
+                ? conditions[0]
+                : { and: conditions };
+        const depth = Math.max(1, options.depth ?? 1);
+        const normalize = (doc) => {
+            const record = doc;
+            const item = normalizeDoc({ collections }, own.fields, record, options.contextNames ?? {});
+            const path = options.itemPath?.(spec.source, record, ctx.locale);
+            return (path === undefined ? item : { ...item, path });
+        };
+        const common = {
+            collection: spec.source,
+            depth,
+            draft: preview,
+            ...(where === undefined ? {} : { where }),
+            ...scope(ctx),
+        };
+        if (!compiled.post && !sortNeedsScan) {
+            const sort = [
+                ...sortKeys,
+                ...(sortKeys.some((key) => key.replace('-', '') === 'id') ? [] : ['id']),
+            ];
+            const found = await payload.find({
+                ...common,
+                sort,
+                page: spec.page,
+                limit: spec.limit,
+                pagination: true,
+            });
+            return {
+                items: found.docs.map(normalize),
+                total: found.totalDocs,
+                page: spec.page,
+                totalPages: Math.ceil(found.totalDocs / spec.limit),
+            };
+        }
+        const candidates = await payload.find({
+            ...common,
+            sort: 'id',
+            page: 1,
+            limit: scanLimit + 1,
+            pagination: true,
+        });
+        if (candidates.totalDocs > scanLimit) {
+            throw new DataQueryError(`The query needs to look at more than ${scanLimit} documents; narrow the filter.`);
+        }
+        return createMemoryDataSource({
+            collections: { [spec.source]: candidates.docs.map(normalize) },
+        }).query(spec, ctx);
+    }
+    async function getMedia(ids, ctx) {
+        const slug = options.mediaCollection;
+        if (slug === undefined)
+            throw new DataQueryError('No media collection is configured.');
+        const kind = idKind(slug).kind;
+        const valid = [...new Set(ids)].filter((value) => kind === 'number' ? /^\d+$/.test(value) : value !== '');
+        const found = {};
+        if (valid.length === 0)
+            return found;
+        const result = await payload.find({
+            collection: slug,
+            where: { id: { in: kind === 'number' ? valid.map(Number) : valid } },
+            limit: valid.length,
+            pagination: false,
+            depth: 0,
+            ...scope(ctx),
+        });
+        for (const doc of result.docs) {
+            const asset = normalizeMedia(doc);
+            if (asset !== null)
+                found[asset.id] = asset;
+        }
+        return found;
+    }
+    return { query, getMedia };
+}

package/dist/data/payload-data-source.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=payload-data-source.test.d.ts.map

package/dist/data/payload-data-source.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload-data-source.test.d.ts","sourceRoot":"","sources":["../../src/data/payload-data-source.test.ts"],"names":[],"mappings":""}

package/dist/data/payload-data-source.test.js

@@ -0,0 +1,160 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { DATA_SOURCE_FIXTURE, runDataSourceContract, } from '@next-buildr/test-utils/contracts/data-source';
+import { sqliteAdapter } from '@payloadcms/db-sqlite';
+import { buildConfig, getPayload } from 'payload';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { createPayloadDataSource, DataQueryError } from './payload-data-source.js';
+const open = { read: () => true };
+const dir = mkdtempSync(join(tmpdir(), 'buildr-datasource-'));
+let payload;
+const queryable = {
+    posts: {
+        fields: ['title', 'views', 'tags', 'author.name', 'live'],
+        sort: ['title', 'views', 'author.name'],
+    },
+    notes: { fields: ['title'], sort: ['title'] },
+};
+const source = (extra = {}) => createPayloadDataSource({ payload, queryable, mediaCollection: 'media', ...extra });
+let seeded;
+async function seed(fixture) {
+    for (const item of fixture.collections['posts'] ?? []) {
+        const { id: _id, ...data } = item;
+        await payload.create({ collection: 'posts', data: data });
+    }
+    for (const asset of Object.values(fixture.media)) {
+        await payload.create({ collection: 'media', data: asset });
+    }
+}
+beforeAll(async () => {
+    const config = buildConfig({
+        secret: 'test-secret',
+        collections: [
+            {
+                slug: 'posts',
+                access: open,
+                fields: [
+                    { name: 'title', type: 'text', required: true },
+                    { name: 'views', type: 'number', required: true },
+                    { name: 'tags', type: 'text', hasMany: true },
+                    { name: 'author', type: 'group', fields: [{ name: 'name', type: 'text' }] },
+                    { name: 'live', type: 'checkbox', required: true },
+                ],
+            },
+            {
+                slug: 'media',
+                access: open,
+                fields: [
+                    { name: 'id', type: 'text' },
+                    { name: 'url', type: 'text' },
+                    { name: 'alt', type: 'text' },
+                    { name: 'width', type: 'number' },
+                    { name: 'height', type: 'number' },
+                    { name: 'mimeType', type: 'text' },
+                ],
+            },
+            {
+                slug: 'notes',
+                access: open,
+                fields: [{ name: 'title', type: 'text', required: true }],
+                versions: { drafts: true },
+            },
+            { slug: 'guarded', fields: [{ name: 'title', type: 'text' }] },
+        ],
+        db: sqliteAdapter({ client: { url: `file:${join(dir, 'db.sqlite')}` } }),
+        typescript: { autoGenerate: false },
+    });
+    payload = await getPayload({ config, key: 'datasource' });
+    seeded = seed(DATA_SOURCE_FIXTURE);
+    await seeded;
+});
+afterAll(() => {
+    try {
+        rmSync(dir, { recursive: true, force: true });
+    }
+    catch {
+        // Windows keeps the database file open a moment longer.
+    }
+});
+// The same contract MemoryDataSource is held to (posts and media are seeded once, above).
+runDataSourceContract('PayloadDataSource', async () => {
+    await seeded;
+    return source();
+});
+const CTX = { locale: 'en', mode: 'production' };
+const spec = (query = {}) => ({
+    source: 'posts',
+    limit: 50,
+    page: 1,
+    ...query,
+});
+const run = (query, data = source()) => data.query(spec(query), CTX);
+describe('the allowlist', () => {
+    it('rejects a field, a sort key or a collection that was not allowed', async () => {
+        await expect(run({ where: { field: 'id', op: 'eq', value: '1' } })).rejects.toThrow(DataQueryError);
+        await expect(run({ where: { field: 'author', op: 'exists', value: true } })).rejects.toThrow(DataQueryError);
+        await expect(run({ sort: [{ field: 'live', dir: 'asc' }] })).rejects.toThrow(DataQueryError);
+        await expect(run({ source: 'guarded' })).rejects.toThrow(DataQueryError);
+        await expect(run({ source: 'users' })).rejects.toThrow(DataQueryError);
+    });
+    it('never queries a credential-like field even when it is allowed', async () => {
+        const data = source({ queryable: { posts: { fields: ['password'], sort: [] } } });
+        await expect(run({ where: { field: 'password', op: 'eq', value: 'x' } }, data)).rejects.toThrow(DataQueryError);
+    });
+    it('rejects a limit or a page out of range', async () => {
+        await expect(run({ limit: 0 })).rejects.toThrow(DataQueryError);
+        await expect(run({ limit: 51 })).rejects.toThrow(DataQueryError);
+        await expect(run({ page: 0 })).rejects.toThrow(DataQueryError);
+    });
+});
+describe('item paths', () => {
+    it('gives every item the address the application computes, and none without one', async () => {
+        const withPath = source({
+            itemPath: (collection, doc, locale) => `/${locale}/${collection}/${String(doc['title'])}`,
+        });
+        const items = (await run({ limit: 1 }, withPath)).items;
+        expect(items[0]?.path).toBe(`/en/posts/${items[0]?.title}`);
+        const plain = (await run({ limit: 1 })).items;
+        expect(plain[0]).not.toHaveProperty('path');
+    });
+});
+describe('access, drafts and the in-memory pass', () => {
+    it('reads with the access of the request: a collection closed to visitors fails', async () => {
+        await payload.create({ collection: 'guarded', data: { title: 'x' } });
+        const data = source({ queryable: { guarded: { fields: ['title'], sort: [] } } });
+        await expect(run({ source: 'guarded' }, data)).rejects.toThrow();
+    });
+    it('serves published documents in production and drafts in preview and canvas', async () => {
+        await payload.create({
+            collection: 'notes',
+            data: { title: 'Live', _status: 'published' },
+        });
+        await payload.create({
+            collection: 'notes',
+            data: { title: 'Wip', _status: 'draft' },
+            draft: true,
+        });
+        const titles = async (mode) => {
+            const result = await source().query(spec({ source: 'notes' }), { locale: 'en', mode });
+            return result.items.map((item) => item.title).sort();
+        };
+        expect(await titles('production')).toEqual(['Live']);
+        expect(await titles('preview')).toEqual(['Live', 'Wip']);
+        expect(await titles('canvas')).toEqual(['Live', 'Wip']);
+    });
+    it('refuses to scan more than scanLimit documents', async () => {
+        const data = source({ scanLimit: 3 });
+        await expect(run({ where: { field: 'title', op: 'contains', value: 'a' } }, data)).rejects.toThrow(DataQueryError);
+        // Narrowed by the database first, the same query fits.
+        const narrowed = await run({
+            where: {
+                and: [
+                    { field: 'views', op: 'gte', value: 20 },
+                    { field: 'title', op: 'contains', value: 'a' },
+                ],
+            },
+        }, data);
+        expect(narrowed.items.length).toBeGreaterThan(0);
+    });
+});

package/dist/data/resolve-layout.d.ts

@@ -0,0 +1,45 @@
+import type { Payload, PayloadRequest } from 'payload';
+/** The collection of reusable layouts (added by the plugin). */
+export declare const TEMPLATES_COLLECTION = "buildr-templates";
+/** Where the layout of a document came from, in the order `resolveLayout` tries them. */
+export type LayoutSource = 'document' | 'template' | 'default-template' | 'builtin';
+export interface ResolvedLayout {
+    /** The stored layout as it is (not migrated or validated), or the built-in one. */
+    readonly layout: unknown;
+    readonly source: LayoutSource;
+    /**
+     * The document the layout came from as `{collection}:{id}` (the `layoutRef` forms and cache tags
+     * use); `null` for the built-in layout, which belongs to no document.
+     */
+    readonly layoutRef: string | null;
+}
+export interface ResolveLayoutInput {
+    readonly payload: Payload;
+    /** The request whose access applies; without one the read is the visitor's (anonymous). */
+    readonly req?: PayloadRequest | undefined;
+    readonly collection: string;
+    /** The document: at least `id`, `layout` and `template` (an id or a populated template). */
+    readonly doc: Readonly<Record<string, unknown>>;
+    /** The name the document is bound under (`post`, `page`): the built-in layout binds to it. */
+    readonly contextName: string;
+    /** Read the latest draft of the templates (the editor, a preview) instead of the published ones. */
+    readonly draft?: boolean | undefined;
+    /** `true` skips collection access: for a trusted server-side render. Default `false`. */
+    readonly overrideAccess?: boolean | undefined;
+}
+/** A layout has content when its root has at least one child; a bare root is what "no layout" looks like. */
+export declare function hasContent(layout: unknown): boolean;
+/**
+ * The built-in minimal layout (title and body) a document falls back to when neither it nor a
+ * template has one: a level-1 heading bound to `{context}.title` and a rich text bound to
+ * `{context}.content`.
+ */
+export declare function builtinLayout(contextName: string): unknown;
+/**
+ * The layout a document is shown with (docs/payload.md): its own (`layout`, when it has content),
+ * else the template it points at, else the collection's default template (`isDefault`), else the
+ * built-in minimal one. A template of another collection is never used. Unless `draft`, only
+ * published templates count.
+ */
+export declare function resolveLayout(input: ResolveLayoutInput): Promise<ResolvedLayout>;
+//# sourceMappingURL=resolve-layout.d.ts.map

package/dist/data/resolve-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-layout.d.ts","sourceRoot":"","sources":["../../src/data/resolve-layout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAS,MAAM,SAAS,CAAC;AAE9D,gEAAgE;AAChE,eAAO,MAAM,oBAAoB,qBAAqB,CAAC;AAEvD,yFAAyF;AACzF,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,UAAU,GAAG,kBAAkB,GAAG,SAAS,CAAC;AAEpF,MAAM,WAAW,cAAc;IAC7B,mFAAmF;IACnF,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,2FAA2F;IAC3F,QAAQ,CAAC,GAAG,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IAC1C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,4FAA4F;IAC5F,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAChD,8FAA8F;IAC9F,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,oGAAoG;IACpG,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACrC,yFAAyF;IACzF,QAAQ,CAAC,cAAc,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC/C;AAKD,6GAA6G;AAC7G,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAOnD;AAOD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAwB1D;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC,CA+DtF"}

package/dist/data/resolve-layout.js

@@ -0,0 +1,111 @@
+/** The collection of reusable layouts (added by the plugin). */
+export const TEMPLATES_COLLECTION = 'buildr-templates';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+/** A layout has content when its root has at least one child; a bare root is what "no layout" looks like. */
+export function hasContent(layout) {
+    if (!isRecord(layout) || !isRecord(layout['nodes']))
+        return false;
+    const root = layout['nodes']['root'];
+    if (!isRecord(root) || !isRecord(root['slots']))
+        return false;
+    return Object.values(root['slots']).some((children) => Array.isArray(children) && children.length > 0);
+}
+const idOf = (value) => {
+    const id = isRecord(value) ? value['id'] : value;
+    return typeof id === 'string' || typeof id === 'number' ? id : undefined;
+};
+/**
+ * The built-in minimal layout (title and body) a document falls back to when neither it nor a
+ * template has one: a level-1 heading bound to `{context}.title` and a rich text bound to
+ * `{context}.content`.
+ */
+export function builtinLayout(contextName) {
+    return {
+        schemaVersion: 1,
+        root: 'root',
+        nodes: {
+            root: { id: 'root', type: 'buildr/page', slots: { default: ['bTitle0001', 'bBody00001'] } },
+            bTitle0001: {
+                id: 'bTitle0001',
+                type: 'buildr/heading',
+                name: 'Title',
+                props: {
+                    text: { kind: 'binding', path: `${contextName}.title` },
+                    level: { kind: 'static', value: 1 },
+                },
+            },
+            bBody00001: {
+                id: 'bBody00001',
+                type: 'buildr/rich-text',
+                name: 'Body',
+                props: { content: { kind: 'binding', path: `${contextName}.content` } },
+            },
+        },
+        components: { 'buildr/page': 1, 'buildr/heading': 1, 'buildr/rich-text': 1 },
+    };
+}
+/**
+ * The layout a document is shown with (docs/payload.md): its own (`layout`, when it has content),
+ * else the template it points at, else the collection's default template (`isDefault`), else the
+ * built-in minimal one. A template of another collection is never used. Unless `draft`, only
+ * published templates count.
+ */
+export async function resolveLayout(input) {
+    const { payload, collection, doc } = input;
+    const ownId = idOf(doc['id']);
+    if (hasContent(doc['layout'])) {
+        return {
+            layout: doc['layout'],
+            source: 'document',
+            layoutRef: ownId === undefined ? null : `${collection}:${String(ownId)}`,
+        };
+    }
+    if (payload.collections[TEMPLATES_COLLECTION] === undefined) {
+        return { layout: builtinLayout(input.contextName), source: 'builtin', layoutRef: null };
+    }
+    const access = {
+        draft: input.draft === true,
+        overrideAccess: input.overrideAccess === true,
+        depth: 0,
+        ...(input.req === undefined ? {} : { req: input.req }),
+    };
+    const asResolved = (template, source) => {
+        if (template === undefined || template['targetCollection'] !== collection)
+            return undefined;
+        if (input.draft !== true && template['_status'] !== 'published')
+            return undefined;
+        if (!hasContent(template['layout']))
+            return undefined;
+        return {
+            layout: template['layout'],
+            source,
+            layoutRef: `${TEMPLATES_COLLECTION}:${String(template['id'])}`,
+        };
+    };
+    const templateId = idOf(doc['template']);
+    if (templateId !== undefined) {
+        const found = await payload
+            .findByID({ collection: TEMPLATES_COLLECTION, id: templateId, ...access })
+            .catch(() => undefined);
+        const own = asResolved(found, 'template');
+        if (own !== undefined)
+            return own;
+    }
+    const defaults = await payload.find({
+        collection: TEMPLATES_COLLECTION,
+        where: {
+            and: [
+                { targetCollection: { equals: collection } },
+                { isDefault: { equals: true } },
+                ...(input.draft === true ? [] : [{ _status: { equals: 'published' } }]),
+            ],
+        },
+        limit: 1,
+        pagination: false,
+        ...access,
+    });
+    const fallback = asResolved(defaults.docs[0], 'default-template');
+    if (fallback !== undefined)
+        return fallback;
+    return { layout: builtinLayout(input.contextName), source: 'builtin', layoutRef: null };
+}

package/dist/data/schema-from-fields.d.ts

@@ -0,0 +1,63 @@
+import type { DataSchema } from '@next-buildr/core';
+/**
+ * The part of a (sanitized) Payload field this module reads. Payload's own `Field` union is large
+ * and changes between minor versions; reading through this shape keeps the mapping in one place
+ * and the dedicated tests pin the behaviour.
+ */
+export interface FieldLike {
+    readonly type: string;
+    readonly name?: string;
+    readonly hidden?: boolean;
+    readonly label?: unknown;
+    readonly access?: {
+        readonly read?: unknown;
+    };
+    readonly fields?: readonly FieldLike[];
+    readonly tabs?: readonly {
+        readonly name?: string;
+        readonly fields: readonly FieldLike[];
+    }[];
+    readonly options?: readonly unknown[];
+    readonly hasMany?: boolean;
+    readonly relationTo?: unknown;
+    readonly required?: boolean;
+    readonly defaultValue?: unknown;
+}
+/** A collection as the mapping sees it. */
+export interface CollectionLike {
+    readonly slug: string;
+    readonly auth?: unknown;
+    readonly fields: readonly FieldLike[];
+}
+export interface SchemaSource {
+    readonly collections: readonly CollectionLike[];
+    readonly globals?: readonly {
+        readonly slug: string;
+        readonly fields: readonly FieldLike[];
+    }[];
+}
+export interface SchemaOptions {
+    /** The name each configured collection is bound under (`page`, `post`, ...); others keep their slug. */
+    readonly contextNames: Readonly<Record<string, string>>;
+    /** The global that becomes the `site` scope. */
+    readonly siteGlobal?: string;
+}
+/** Whether a collection may take part in the schema and in contexts at all: never the auth ones. */
+export declare const isExposedCollection: (collection: CollectionLike) => boolean;
+/**
+ * The named fields of `fields` a binding may reach, layout containers (`row`, `collapsible`, tabs)
+ * flattened; a named tab is a `group`. This is the allow-list both the schema and the context use.
+ */
+export declare function exposedFields(fields: readonly FieldLike[]): readonly (FieldLike & {
+    readonly name: string;
+})[];
+/** The slug a relation points at when it can be followed (a single, exposed target). */
+export declare function relationTarget(field: FieldLike, source: SchemaSource): string | undefined;
+/**
+ * The `DataSchema` of a collection's documents: the scopes `site` (when the site global exists),
+ * the collection's own context name, and `route`; plus one entity per relation target that can be
+ * reached (transitively). Auth collections (`users`), hidden fields and anything that looks like a
+ * credential are never included; a relation to them is dropped.
+ */
+export declare function schemaFromCollection(source: SchemaSource, collection: string, options: SchemaOptions): DataSchema | undefined;
+//# sourceMappingURL=schema-from-fields.d.ts.map

package/dist/data/schema-from-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-from-fields.d.ts","sourceRoot":"","sources":["../../src/data/schema-from-fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,UAAU,EAAY,MAAM,mBAAmB,CAAC;AAEzE;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAC9C,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,SAAS,EAAE,CAAC;IACvC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS;QAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAA;KAAE,EAAE,CAAC;IAC7F,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;CACjC;AAED,2CAA2C;AAC3C,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAC;CACvC;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,WAAW,EAAE,SAAS,cAAc,EAAE,CAAC;IAChD,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,SAAS,EAAE,CAAA;KAAE,EAAE,CAAC;CAChG;AAED,MAAM,WAAW,aAAa;IAC5B,wGAAwG;IACxG,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACxD,gDAAgD;IAChD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAWD,oGAAoG;AACpG,eAAO,MAAM,mBAAmB,eAAgB,cAAc,KAAG,OACL,CAAC;AAe7D;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,SAAS,EAAE,GAC3B,SAAS,CAAC,SAAS,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,CAoBpD;AAiBD,wFAAwF;AACxF,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS,CAIzF;AAyFD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,aAAa,GACrB,UAAU,GAAG,SAAS,CAgCxB"}