@next-buildr/payload 0.0.0-stage → 2.0.0

package/dist/data/build-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-context.d.ts","sourceRoot":"","sources":["../../src/data/build-context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAE3E,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IACpD,QAAQ,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5F;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAmB9E"}

package/dist/data/build-context.js

@@ -0,0 +1,25 @@
+import { normalizeDoc } from './normalize.js';
+/**
+ * The data scopes of a document: `{ site, [context]: doc, route }`, shaped exactly like the schema
+ * `schemaFromCollection` derives (same allow-list), ready to be served to the canvas as `scopes`.
+ */
+export function buildContext(input) {
+    const { source, options, collection } = input;
+    const own = source.collections.find((candidate) => candidate.slug === collection);
+    const scopes = {};
+    const siteGlobal = source.globals?.find((global) => global.slug === options.siteGlobal);
+    if (siteGlobal !== undefined) {
+        scopes['site'] =
+            input.site === undefined
+                ? null
+                : normalizeDoc(source, siteGlobal.fields, input.site, options.contextNames);
+    }
+    scopes[options.contextNames[collection] ?? collection] =
+        own === undefined ? null : normalizeDoc(source, own.fields, input.doc, options.contextNames);
+    scopes['route'] = {
+        path: input.route.path,
+        locale: input.route.locale,
+        params: { page: input.route.page ?? null },
+    };
+    return scopes;
+}

package/dist/data/data.test.d.ts

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

package/dist/data/data.test.d.ts.map

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

package/dist/data/data.test.js

@@ -0,0 +1,261 @@
+import { schemaAtPath } from '@next-buildr/core';
+import { describe, expect, it } from 'vitest';
+import { buildContext } from './build-context.js';
+import { normalizeDoc, normalizeMedia } from './normalize.js';
+import { schemaFromCollection, } from './schema-from-fields.js';
+const text = (name, extra = {}) => ({
+    type: 'text',
+    name,
+    ...extra,
+});
+const posts = {
+    slug: 'posts',
+    fields: [
+        text('title', { label: 'Title' }),
+        { type: 'textarea', name: 'excerpt' },
+        { type: 'number', name: 'readingTime' },
+        { type: 'checkbox', name: 'featured' },
+        { type: 'date', name: 'publishedAt' },
+        { type: 'select', name: 'kind', options: ['news', { label: 'Guide', value: 'guide' }] },
+        { type: 'select', name: 'flags', hasMany: true, options: ['a', 'b'] },
+        { type: 'richText', name: 'content' },
+        { type: 'upload', name: 'cover', relationTo: 'media' },
+        { type: 'upload', name: 'gallery', relationTo: 'media', hasMany: true },
+        { type: 'relationship', name: 'author', relationTo: 'authors' },
+        { type: 'relationship', name: 'tags', relationTo: 'tags', hasMany: true },
+        { type: 'relationship', name: 'owner', relationTo: 'users' },
+        { type: 'relationship', name: 'either', relationTo: ['authors', 'tags'] },
+        {
+            type: 'group',
+            name: 'seo',
+            fields: [text('title'), text('internalNote', { hidden: true })],
+        },
+        { type: 'array', name: 'facts', fields: [text('label'), { type: 'number', name: 'value' }] },
+        { type: 'row', fields: [text('subtitle')] },
+        { type: 'tabs', tabs: [{ fields: [text('lead')] }, { name: 'extra', fields: [text('note')] }] },
+        // Never data for a binding:
+        { type: 'blocks', name: 'sections' },
+        { type: 'json', name: 'layout' },
+        { type: 'json', name: 'raw' },
+        { type: 'point', name: 'where' },
+        text('password'),
+        text('resetPasswordToken'),
+        text('apiKey'),
+        text('secretNotes'),
+        text('draftOnly', { hidden: true }),
+        text('restricted', { access: { read: () => false } }),
+        { type: 'number', name: 'buildrRevision' },
+        { type: 'text', name: '_status' },
+        { type: 'ui', name: 'preview' },
+    ],
+};
+const authors = {
+    slug: 'authors',
+    fields: [
+        text('name'),
+        { type: 'upload', name: 'avatar', relationTo: 'media' },
+        { type: 'relationship', name: 'user', relationTo: 'users' },
+        { type: 'relationship', name: 'posts', relationTo: 'posts', hasMany: true },
+        text('salt'),
+    ],
+};
+const users = {
+    slug: 'users',
+    auth: true,
+    fields: [text('email'), text('name'), text('role'), text('password')],
+};
+const tags = { slug: 'tags', fields: [text('title')] };
+const media = { slug: 'media', fields: [text('alt')] };
+const internal = { slug: 'payload-preferences', fields: [text('key')] };
+const settings = {
+    slug: 'site-settings',
+    fields: [text('siteName'), { type: 'upload', name: 'logo', relationTo: 'media' }, text('token')],
+};
+const source = {
+    collections: [posts, authors, users, tags, media, internal],
+    globals: [settings],
+};
+const options = { contextNames: { posts: 'post' }, siteGlobal: 'site-settings' };
+const schema = () => {
+    const built = schemaFromCollection(source, 'posts', options);
+    if (built === undefined)
+        throw new Error('expected a schema');
+    return built;
+};
+describe('schemaFromCollection', () => {
+    it('maps the field types of a post', () => {
+        expect(schema()).toMatchSnapshot();
+    });
+    it('resolves paths through relations with the core schema helpers', () => {
+        const built = schema();
+        expect(schemaAtPath(built, 'post.title')?.type).toEqual({ t: 'string' });
+        expect(schemaAtPath(built, 'post.author.name')?.type).toEqual({ t: 'string' });
+        expect(schemaAtPath(built, 'post.author.avatar')?.type).toEqual({ t: 'media' });
+        expect(schemaAtPath(built, 'post.seo.title')?.type).toEqual({ t: 'string' });
+        expect(schemaAtPath(built, 'post.extra.note')?.type).toEqual({ t: 'string' });
+        expect(schemaAtPath(built, 'site.logo')?.type).toEqual({ t: 'media' });
+        expect(schemaAtPath(built, 'route.path')?.type).toEqual({ t: 'string' });
+    });
+    it('never exposes users, credentials, hidden or builder-owned fields', () => {
+        const built = schema();
+        const json = JSON.stringify(built);
+        for (const forbidden of [
+            'users',
+            'email',
+            'role',
+            'password',
+            'resetPasswordToken',
+            'apiKey',
+            'secretNotes',
+            'salt',
+            'token',
+            'internalNote',
+            'draftOnly',
+            'restricted',
+            'buildrRevision',
+            '_status',
+            'layout',
+            'sections',
+            'raw',
+            'where',
+            'either',
+            'owner',
+            'payload-preferences',
+        ]) {
+            expect(json, forbidden).not.toContain(`"${forbidden}"`);
+        }
+        expect(built.entities['users']).toBeUndefined();
+        expect(Object.keys(built.entities).sort()).toEqual(['authors', 'post', 'tags']);
+    });
+    it('refuses a collection that is an auth collection or internal', () => {
+        expect(schemaFromCollection(source, 'users', options)).toBeUndefined();
+        expect(schemaFromCollection(source, 'payload-preferences', options)).toBeUndefined();
+        expect(schemaFromCollection(source, 'nope', options)).toBeUndefined();
+    });
+    it('survives relations that point back (authors <-> posts)', () => {
+        const built = schema();
+        expect(schemaAtPath(built, 'post.author.posts')?.type.t).toBe('list');
+    });
+});
+const doc = {
+    id: 7,
+    createdAt: '2026-01-02T03:04:05.000Z',
+    updatedAt: new Date('2026-02-03T00:00:00Z'),
+    title: 'Hello',
+    publishedAt: '2026-03-04T05:06:07Z',
+    kind: 'news',
+    flags: ['a'],
+    cover: {
+        id: 3,
+        url: '/media/cover.jpg',
+        alt: 'A cover',
+        width: 800,
+        height: 600,
+        mimeType: 'image/jpeg',
+        focalX: 40,
+        focalY: 60,
+        filename: 'cover.jpg',
+        sizes: {
+            card: { url: '/media/cover-800.jpg', width: 800, height: 500 },
+            og: { url: null, width: null, height: null },
+        },
+    },
+    gallery: [5, { id: 6, url: '/media/g.jpg', mimeType: 'image/png' }],
+    author: {
+        id: 2,
+        name: 'Ada',
+        salt: 'NaCl',
+        user: { id: 1, email: 'ada@example.com', password: 'hash' },
+        posts: [{ id: 7, title: 'cycle' }],
+    },
+    tags: [{ id: 1, title: 'one' }, 9],
+    owner: { id: 1, email: 'ada@example.com', hash: 'x' },
+    seo: { title: 'SEO', internalNote: 'private' },
+    facts: [{ label: 'a', value: 1, id: 'row1' }],
+    lead: 'Lead',
+    extra: { note: 'Note', secret: 'no' },
+    sections: [{ blockType: 'x' }],
+    password: 'p',
+    resetPasswordToken: 't',
+    apiKey: 'k',
+    layout: { root: 'r' },
+    buildrRevision: 4,
+    _status: 'draft',
+    unknown: 'field',
+};
+describe('normalizeDoc', () => {
+    it('turns a populated document into plain, allow-listed data', () => {
+        expect(normalizeDoc(source, posts.fields, doc, options.contextNames)).toMatchSnapshot();
+    });
+    it('never lets a credential or an unlisted field through, at any depth', () => {
+        const json = JSON.stringify(normalizeDoc(source, posts.fields, doc, options.contextNames));
+        for (const leaked of [
+            'ada@example.com',
+            'NaCl',
+            'hash',
+            'private',
+            '"k"',
+            'blockType',
+            'root',
+            'field',
+            'no',
+        ]) {
+            expect(json).not.toContain(`"${leaked}"`);
+        }
+        expect(json).not.toContain('ada@example.com');
+        expect(json).not.toContain('resetPasswordToken');
+    });
+    it('keeps an unpopulated relation as { id } and an unpopulated upload as null', () => {
+        const value = normalizeDoc(source, posts.fields, { id: 1, author: 4, cover: 3, gallery: [1, 2] }, options.contextNames);
+        expect(value['author']).toEqual({ id: '4' });
+        expect(value['cover']).toBeNull();
+        expect(value['gallery']).toEqual([null, null]);
+    });
+});
+describe('normalizeMedia', () => {
+    it('drops sizes without a URL and fills what Payload stores', () => {
+        expect(normalizeMedia(doc.cover)).toEqual({
+            id: '3',
+            url: '/media/cover.jpg',
+            alt: 'A cover',
+            width: 800,
+            height: 600,
+            mimeType: 'image/jpeg',
+            focalPoint: { x: 40, y: 60 },
+            sizes: { card: { url: '/media/cover-800.jpg', width: 800, height: 500 } },
+        });
+        expect(normalizeMedia(5)).toBeNull();
+        expect(normalizeMedia({ id: 1 })).toBeNull();
+    });
+});
+describe('buildContext', () => {
+    it('builds site, the document under its context name, and route', () => {
+        const scopes = buildContext({
+            source,
+            options,
+            collection: 'posts',
+            doc,
+            site: { siteName: 'Buildr', token: 'x', logo: doc.cover },
+            route: { path: '/posts/hello', locale: 'pl' },
+        });
+        expect(Object.keys(scopes).sort()).toEqual(['post', 'route', 'site']);
+        expect(scopes['site']).toMatchObject({ siteName: 'Buildr', logo: { id: '3' } });
+        expect(JSON.stringify(scopes['site'])).not.toContain('token');
+        expect(scopes['route']).toEqual({ path: '/posts/hello', locale: 'pl', params: { page: null } });
+        expect(scopes['post'].author.name).toBe('Ada');
+    });
+    it('has the shape of the schema', () => {
+        const scopes = buildContext({
+            source,
+            options,
+            collection: 'posts',
+            doc,
+            route: { path: '/', locale: 'pl' },
+        });
+        const built = schema();
+        const context = scopes['post'];
+        const declared = Object.keys(built.scopes['post'].type.fields);
+        expect(Object.keys(context).sort()).toEqual(declared.sort());
+        expect(scopes['site']).toBeNull(); // no readable site document was given
+    });
+});

package/dist/data/index.d.ts

@@ -0,0 +1,10 @@
+export type { BuildContextInput } from './build-context.ts';
+export { buildContext } from './build-context.ts';
+export { normalizeDoc, normalizeMedia } from './normalize.ts';
+export type { PayloadDataSourceOptions, QueryableCollection } from './payload-data-source.ts';
+export { createPayloadDataSource, DataQueryError } from './payload-data-source.ts';
+export type { LayoutSource, ResolvedLayout, ResolveLayoutInput, } from './resolve-layout.ts';
+export { builtinLayout, hasContent, resolveLayout } from './resolve-layout.ts';
+export type { CollectionLike, FieldLike, SchemaOptions, SchemaSource, } from './schema-from-fields.ts';
+export { exposedFields, isExposedCollection, schemaFromCollection } from './schema-from-fields.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/data/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/data/index.ts"],"names":[],"mappings":"AAEA,YAAY,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC9D,YAAY,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC9F,OAAO,EAAE,uBAAuB,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AACnF,YAAY,EACV,YAAY,EACZ,cAAc,EACd,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC/E,YAAY,EACV,cAAc,EACd,SAAS,EACT,aAAa,EACb,YAAY,GACb,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/data/index.js

@@ -0,0 +1,5 @@
+export { buildContext } from './build-context.js';
+export { normalizeDoc, normalizeMedia } from './normalize.js';
+export { createPayloadDataSource, DataQueryError } from './payload-data-source.js';
+export { builtinLayout, hasContent, resolveLayout } from './resolve-layout.js';
+export { exposedFields, isExposedCollection, schemaFromCollection } from './schema-from-fields.js';

package/dist/data/normalize.d.ts

@@ -0,0 +1,14 @@
+import type { MediaAsset } from '@next-buildr/core';
+import { type FieldLike, type SchemaSource } from './schema-from-fields.ts';
+/**
+ * A populated Payload upload document as a `MediaAsset`; an id that was not populated (or a
+ * document without a URL) is `null`: the context never carries half a media asset.
+ */
+export declare function normalizeMedia(value: unknown): MediaAsset | null;
+/**
+ * A document as plain, JSON-safe data for bindings: only the fields the schema exposes (an
+ * allow-list, so nothing else ever leaks), dates as ISO strings, uploads as `MediaAsset`s,
+ * relations as plain objects (`{ id }` when they were not populated).
+ */
+export declare function normalizeDoc(source: SchemaSource, fields: readonly FieldLike[], doc: Record<string, unknown>, contextNames?: Readonly<Record<string, string>>): Record<string, unknown>;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/data/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../src/data/normalize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAEL,KAAK,SAAS,EAEd,KAAK,YAAY,EAClB,MAAM,yBAAyB,CAAC;AAcjC;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,IAAI,CA+BhE;AAkFD;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,SAAS,SAAS,EAAE,EAC5B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,YAAY,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM,GAClD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAOzB"}

package/dist/data/normalize.js

@@ -0,0 +1,128 @@
+import { exposedFields, relationTarget, } from './schema-from-fields.js';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isoDate = (value) => {
+    if (value === null || value === undefined)
+        return null;
+    const date = value instanceof Date ? value : new Date(String(value));
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+};
+const num = (value) => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+/**
+ * A populated Payload upload document as a `MediaAsset`; an id that was not populated (or a
+ * document without a URL) is `null`: the context never carries half a media asset.
+ */
+export function normalizeMedia(value) {
+    if (!isRecord(value) || typeof value['url'] !== 'string' || value['id'] === undefined)
+        return null;
+    const sizes = {};
+    if (isRecord(value['sizes'])) {
+        for (const [name, size] of Object.entries(value['sizes'])) {
+            if (isRecord(size) && typeof size['url'] === 'string') {
+                const width = num(size['width']);
+                const height = num(size['height']);
+                if (width !== undefined && height !== undefined) {
+                    sizes[name] = { url: size['url'], width, height };
+                }
+            }
+        }
+    }
+    const focalX = num(value['focalX']);
+    const focalY = num(value['focalY']);
+    const width = num(value['width']);
+    const height = num(value['height']);
+    return {
+        id: String(value['id']),
+        url: value['url'],
+        mimeType: typeof value['mimeType'] === 'string' ? value['mimeType'] : '',
+        ...(typeof value['alt'] === 'string' ? { alt: value['alt'] } : {}),
+        ...(width === undefined ? {} : { width }),
+        ...(height === undefined ? {} : { height }),
+        ...(focalX !== undefined && focalY !== undefined
+            ? { focalPoint: { x: focalX, y: focalY } }
+            : {}),
+        ...(Object.keys(sizes).length === 0 ? {} : { sizes }),
+    };
+}
+function normalizeValue(field, value, walk) {
+    if (value === null || value === undefined)
+        return null;
+    if (field.hasMany === true && Array.isArray(value) && field.type !== 'array') {
+        return value.map((item) => normalizeValue({ ...field, hasMany: false }, item, walk));
+    }
+    switch (field.type) {
+        case 'date':
+            return isoDate(value);
+        case 'upload':
+            return normalizeMedia(value);
+        case 'relationship': {
+            const slug = relationTarget(field, walk.source);
+            if (slug === undefined)
+                return null;
+            if (!isRecord(value))
+                return { id: String(value) };
+            const id = String(value['id']);
+            const target = walk.source.collections.find((candidate) => candidate.slug === slug);
+            // Not populated (or a cycle): the id is all there is; never the raw document.
+            if (target === undefined || walk.trail.includes(`${slug}:${id}`))
+                return { id };
+            return {
+                id,
+                ...normalizeFields(target.fields, value, {
+                    ...walk,
+                    trail: [...walk.trail, `${slug}:${id}`],
+                }),
+            };
+        }
+        case 'group':
+            return isRecord(value) ? normalizeFields(field.fields ?? [], value, walk) : null;
+        case 'array':
+            return Array.isArray(value)
+                ? value.map((row) => isRecord(row) ? normalizeFields(field.fields ?? [], row, walk) : null)
+                : null;
+        case 'richText':
+            return value;
+        default:
+            return value;
+    }
+}
+function normalizeFields(fields, doc, walk) {
+    const result = {};
+    for (const field of exposedFields(fields)) {
+        // Types the schema does not expose (blocks, json, ...) have no `case` above that keeps them.
+        if (!EXPOSED_TYPES.has(field.type))
+            continue;
+        // A relation the schema drops (to users, or polymorphic) is dropped here too.
+        if (field.type === 'relationship' && relationTarget(field, walk.source) === undefined)
+            continue;
+        result[field.name] = normalizeValue(field, doc[field.name], walk);
+    }
+    return result;
+}
+const EXPOSED_TYPES = new Set([
+    'text',
+    'textarea',
+    'email',
+    'number',
+    'checkbox',
+    'date',
+    'select',
+    'radio',
+    'richText',
+    'upload',
+    'relationship',
+    'group',
+    'array',
+]);
+/**
+ * A document as plain, JSON-safe data for bindings: only the fields the schema exposes (an
+ * allow-list, so nothing else ever leaks), dates as ISO strings, uploads as `MediaAsset`s,
+ * relations as plain objects (`{ id }` when they were not populated).
+ */
+export function normalizeDoc(source, fields, doc, contextNames = {}) {
+    return {
+        id: doc['id'] === undefined ? null : String(doc['id']),
+        createdAt: isoDate(doc['createdAt']),
+        updatedAt: isoDate(doc['updatedAt']),
+        ...normalizeFields(fields, doc, { source, names: contextNames, trail: [] }),
+    };
+}

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

@@ -0,0 +1,42 @@
+import { type DataSource } from '@next-buildr/core';
+import type { Payload, PayloadRequest } from 'payload';
+/** What a collection may be queried by: the fields (as query paths) and the sort keys. */
+export interface QueryableCollection {
+    readonly fields: readonly string[];
+    readonly sort: readonly string[];
+}
+export interface PayloadDataSourceOptions {
+    readonly payload: Payload;
+    /** The request whose user's access applies; without one the source reads as an anonymous visitor. */
+    readonly req?: PayloadRequest | undefined;
+    /** The allowlist: only these collections, with only these fields and sort keys. */
+    readonly queryable: Readonly<Record<string, QueryableCollection>>;
+    /** The collection `getMedia` reads. */
+    readonly mediaCollection?: string | undefined;
+    /** The name each collection is bound under (`post`, ...), as in the data schema. */
+    readonly contextNames?: Readonly<Record<string, string>> | undefined;
+    /** How deep relations are populated in the items (default 1: `author.name` works). */
+    readonly depth?: number | undefined;
+    /**
+     * The address of a queried document, exposed to bindings as `item.path` (a card that links to its
+     * post). The application knows its routes and how a locale enters them; without it items have no `path`.
+     */
+    readonly itemPath?: ((collection: string, doc: Record<string, unknown>, locale: string) => string | undefined) | undefined;
+    /** How many documents the in-memory pass may look at (default 1000). */
+    readonly scanLimit?: number | undefined;
+}
+/** A query that cannot be answered: not allowlisted, malformed, or too broad. */
+export declare class DataQueryError extends Error {
+}
+/**
+ * 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 declare function createPayloadDataSource(options: PayloadDataSourceOptions): DataSource;
+//# sourceMappingURL=payload-data-source.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"payload-data-source.d.ts","sourceRoot":"","sources":["../../src/data/payload-data-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EAOhB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAS,MAAM,SAAS,CAAC;AAY9D,0FAA0F;AAC1F,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,qGAAqG;IACrG,QAAQ,CAAC,GAAG,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IAC1C,mFAAmF;IACnF,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAClE,uCAAuC;IACvC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9C,oFAAoF;IACpF,QAAQ,CAAC,YAAY,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC;IACrE,sFAAsF;IACtF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EACd,CAAC,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC,GAC1F,SAAS,CAAC;IACd,wEAAwE;IACxE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC;AAID,iFAAiF;AACjF,qBAAa,cAAe,SAAQ,KAAK;CAAG;AAM5C;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,wBAAwB,GAAG,UAAU,CA6KrF"}