@next-buildr/payload 0.0.0-stage → 2.0.1

package/dist/plugin/endpoints/media.js

@@ -0,0 +1,115 @@
+import { mediaListQuerySchema, mediaListResponseSchema } from '../../contract.js';
+import { normalizeMedia } from '../../data/index.js';
+import { chooseLocale } from '../locales.js';
+import { allowed } from './context.js';
+import { mutationGuard } from './guards.js';
+import { fail, json, unauthorized } from './respond.js';
+const PAGE_SIZE = 24;
+/** Uploads are buffered by the server; a serverless host may impose a lower limit of its own. */
+const MAX_UPLOAD_BYTES = 10 * 1024 * 1024;
+const TYPE_PREFIX = { image: 'image/', video: 'video/', audio: 'audio/' };
+/** The media collection, or the response to send when the builder has none or the caller may not edit. */
+async function mediaOf(env, req) {
+    if (req.user === null || req.user === undefined)
+        return { ok: false, response: unauthorized() };
+    const slug = env.options.media?.collection;
+    if (slug === undefined || req.payload.collections[slug] === undefined) {
+        return { ok: false, response: fail(404, 'No media collection is configured.') };
+    }
+    if (!(await allowed(env, 'edit', req))) {
+        return { ok: false, response: fail(403, 'You may not edit with the builder.') };
+    }
+    return { ok: true, slug };
+}
+/** `GET /api/buildr/media?search&type&page`: the picker's listing, newest first. */
+export const mediaListEndpoint = (env) => ({
+    path: '/buildr/media',
+    method: 'get',
+    handler: async (req) => {
+        const media = await mediaOf(env, req);
+        if (!media.ok)
+            return media.response;
+        const parsed = mediaListQuerySchema.safeParse({
+            search: req.searchParams?.get('search') ?? undefined,
+            type: req.searchParams?.get('type') ?? undefined,
+            page: req.searchParams?.get('page') ?? undefined,
+            locale: req.searchParams?.get('locale') ?? undefined,
+        });
+        if (!parsed.success)
+            return fail(400, 'The query does not match the contract.');
+        const { search, type, page } = parsed.data;
+        const locale = chooseLocale(req, parsed.data.locale);
+        if (!locale.ok)
+            return locale.response;
+        const conditions = [
+            ...(search === undefined || search === ''
+                ? []
+                : [{ or: [{ alt: { like: search } }, { filename: { like: search } }] }]),
+            ...(type === undefined ? [] : [{ mimeType: { like: TYPE_PREFIX[type] } }]),
+        ];
+        const result = await req.payload.find({
+            collection: media.slug,
+            ...(conditions.length === 0 ? {} : { where: { and: conditions } }),
+            sort: '-createdAt',
+            page,
+            limit: PAGE_SIZE,
+            depth: 0,
+            ...locale.args,
+            req,
+            overrideAccess: false,
+        });
+        return json(mediaListResponseSchema.parse({
+            items: result.docs.flatMap((doc) => {
+                const asset = normalizeMedia(doc);
+                return asset === null ? [] : [asset];
+            }),
+            page: result.page ?? page,
+            totalPages: result.totalPages,
+        }));
+    },
+});
+/** `POST /api/buildr/media` (multipart `file`, `alt`): uploads through the Local API; `alt` is required. */
+export const mediaUploadEndpoint = (env) => ({
+    path: '/buildr/media',
+    method: 'post',
+    handler: async (req) => {
+        const media = await mediaOf(env, req);
+        if (!media.ok)
+            return media.response;
+        const rejected = mutationGuard(req, 'multipart');
+        if (rejected !== undefined)
+            return rejected;
+        let form;
+        try {
+            form = await req.formData();
+        }
+        catch {
+            return fail(400, 'The request body must be multipart form data.');
+        }
+        const file = form.get('file');
+        const alt = form.get('alt');
+        if (!(file instanceof File) || file.size === 0)
+            return fail(400, 'A file is required.');
+        if (file.size > MAX_UPLOAD_BYTES)
+            return fail(413, 'The file is too large.');
+        if (typeof alt !== 'string' || alt.trim() === '') {
+            return fail(422, 'The alternative text (alt) is required.');
+        }
+        const doc = await req.payload.create({
+            collection: media.slug,
+            data: { alt: alt.trim() },
+            file: {
+                data: Buffer.from(await file.arrayBuffer()),
+                mimetype: file.type,
+                name: file.name,
+                size: file.size,
+            },
+            req,
+            overrideAccess: false,
+        });
+        const asset = normalizeMedia(doc);
+        if (asset === null)
+            return fail(500, 'The uploaded file has no URL.');
+        return json(asset, 201);
+    },
+});

package/dist/plugin/endpoints/media.test.d.ts

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

package/dist/plugin/endpoints/media.test.d.ts.map

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

package/dist/plugin/endpoints/media.test.js

@@ -0,0 +1,95 @@
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { mediaListResponseSchema } from '../../contract.js';
+import { boot } from './endpoints.test-kit.js';
+let h;
+beforeAll(async () => {
+    h = await boot('media', { media: { collection: 'media' } }, {
+        collections: [
+            {
+                slug: 'media',
+                upload: { staticDir: mkdtempSync(join(tmpdir(), 'buildr-media-files-')) },
+                fields: [{ name: 'alt', type: 'text', required: true }],
+            },
+        ],
+    });
+});
+afterAll(() => h.close());
+const PNG = Uint8Array.from(atob('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4nGP4z8DwHwAFAAH/iZk9HQAAAABJRU5ErkJggg=='), (char) => char.charCodeAt(0));
+const upload = async (fields, token) => {
+    const form = new FormData();
+    if (fields.file !== undefined)
+        form.set('file', fields.file);
+    if (fields.alt !== undefined)
+        form.set('alt', fields.alt);
+    const { handleEndpoints } = await import('payload');
+    const auth = token === undefined ? h.token : token;
+    const response = await handleEndpoints({
+        config: h.payload.config,
+        request: new Request('http://localhost/api/buildr/media', {
+            method: 'POST',
+            headers: auth === null ? {} : { authorization: `JWT ${auth}` },
+            body: form,
+        }),
+    });
+    const text = await response.text();
+    return { status: response.status, body: text === '' ? undefined : JSON.parse(text) };
+};
+describe('POST /buildr/media', () => {
+    it('uploads a file with its alt and answers a MediaAsset', async () => {
+        const { status, body } = await upload({
+            file: new File([PNG], 'pixel.png', { type: 'image/png' }),
+            alt: '  A pixel ',
+        });
+        expect(status).toBe(201);
+        expect(body).toMatchObject({ alt: 'A pixel', mimeType: 'image/png' });
+        expect(typeof body.url).toBe('string');
+    });
+    it('refuses an upload with no alt (422), no file (400) or no login (401)', async () => {
+        const file = new File([PNG], 'x.png', { type: 'image/png' });
+        expect((await upload({ file })).status).toBe(422);
+        expect((await upload({ file, alt: '  ' })).status).toBe(422);
+        expect((await upload({ alt: 'x' })).status).toBe(400);
+        expect((await upload({ file, alt: 'x' }, null)).status).toBe(401);
+    });
+    it('refuses a foreign origin and a JSON body', async () => {
+        const foreign = await h.call('POST', '/buildr/media', {
+            body: {},
+            headers: { origin: 'https://evil.test' },
+        });
+        expect(foreign.status).toBe(415);
+        const { handleEndpoints } = await import('payload');
+        const form = new FormData();
+        form.set('alt', 'x');
+        const response = await handleEndpoints({
+            config: h.payload.config,
+            request: new Request('http://localhost/api/buildr/media', {
+                method: 'POST',
+                headers: { authorization: `JWT ${h.token}`, origin: 'https://evil.test' },
+                body: form,
+            }),
+        });
+        expect(response.status).toBe(403);
+    });
+});
+describe('GET /buildr/media', () => {
+    it('lists, searches and filters by type', async () => {
+        await upload({ file: new File([PNG], 'cat.png', { type: 'image/png' }), alt: 'A cat' });
+        await upload({ file: new File(['%PDF'], 'doc.pdf', { type: 'application/pdf' }), alt: 'Doc' });
+        const all = mediaListResponseSchema.parse((await h.call('GET', '/buildr/media')).body);
+        expect(all.items.length).toBeGreaterThanOrEqual(3);
+        expect(all.page).toBe(1);
+        const images = mediaListResponseSchema.parse((await h.call('GET', '/buildr/media?type=image')).body);
+        expect(images.items.every((item) => item.mimeType.startsWith('image/'))).toBe(true);
+        expect(images.items.length).toBe(all.items.length - 1);
+        const found = mediaListResponseSchema.parse((await h.call('GET', '/buildr/media?search=cat')).body);
+        expect(found.items.map((item) => item.alt)).toEqual(['A cat']);
+    });
+    it('validates the query and the caller: 400, 401', async () => {
+        expect((await h.call('GET', '/buildr/media?type=exe')).status).toBe(400);
+        expect((await h.call('GET', '/buildr/media?page=0')).status).toBe(400);
+        expect((await h.call('GET', '/buildr/media', { token: null })).status).toBe(401);
+    });
+});

package/dist/plugin/endpoints/publish-a11y.test.d.ts

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

package/dist/plugin/endpoints/publish-a11y.test.d.ts.map

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

package/dist/plugin/endpoints/publish-a11y.test.js

@@ -0,0 +1,27 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { boot, title, withChild } from './endpoints.test-kit.js';
+let h;
+beforeAll(async () => {
+    h = await boot('publish-a11y', { a11y: { publish: 'block' } });
+});
+afterAll(() => h.close());
+describe('publishing with the a11y policy "block"', () => {
+    it('refuses a layout with accessibility errors, and publishes a fixed one', async () => {
+        const doc = await h.payload.create({
+            collection: 'pages',
+            data: { title: 'Home', slug: 'home' },
+            draft: true,
+        });
+        const path = `/buildr/documents/pages/${doc.id}`;
+        const put = (document, baseRevision) => h.call('PUT', path, { body: { document, baseRevision, autosave: false } });
+        const broken = withChild({ alt: { kind: 'static', value: '' } }, { type: 'buildr/image' });
+        expect((await put(broken, 0)).status).toBe(200);
+        const refused = await h.call('POST', `${path}/publish`, { body: { baseRevision: 1 } });
+        expect(refused.status).toBe(422);
+        expect(refused.body.diagnostics.map((d) => d.code)).toContain('a11y.image-alt');
+        const fixed = withChild({ alt: title('A cat').title }, { type: 'buildr/image' });
+        expect((await put(fixed, 1)).status).toBe(200);
+        const published = await h.call('POST', `${path}/publish`, { body: { baseRevision: 2 } });
+        expect(published.status).toBe(200);
+    });
+});

package/dist/plugin/endpoints/publish.d.ts

@@ -0,0 +1,9 @@
+import type { Endpoint } from 'payload';
+import { type EndpointEnv } from './context.ts';
+/**
+ * `POST /api/buildr/documents/:collection/:id/publish`: publishes the latest draft, all of it
+ * (fields edited in the admin included). The revision must be the stored one (`409`); the layout is
+ * validated again and, with `a11y.publish: 'block'`, accessibility errors refuse the publish (`422`).
+ */
+export declare const publishEndpoint: (env: EndpointEnv) => Endpoint;
+//# sourceMappingURL=publish.d.ts.map

package/dist/plugin/endpoints/publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish.d.ts","sourceRoot":"","sources":["../../../src/plugin/endpoints/publish.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAIxC,OAAO,EAGL,KAAK,WAAW,EAOjB,MAAM,cAAc,CAAC;AAItB;;;;GAIG;AACH,eAAO,MAAM,eAAe,QAAS,WAAW,KAAG,QAiEjD,CAAC"}

package/dist/plugin/endpoints/publish.js

@@ -0,0 +1,81 @@
+import { runA11y } from '@next-buildr/core';
+import { publishRequestSchema, publishResponseSchema } from '../../contract.js';
+import { processLayout } from '../hooks/process-layout.js';
+import { configuredLocales } from '../locales.js';
+import { allowed, bodyOf, latestOf, revisionOf, targetOf, updatedBy, writeContext, writeLimit, } from './context.js';
+import { mutationGuard } from './guards.js';
+import { conflict, fail, invalid, json } from './respond.js';
+/**
+ * `POST /api/buildr/documents/:collection/:id/publish`: publishes the latest draft, all of it
+ * (fields edited in the admin included). The revision must be the stored one (`409`); the layout is
+ * validated again and, with `a11y.publish: 'block'`, accessibility errors refuse the publish (`422`).
+ */
+export const publishEndpoint = (env) => ({
+    path: '/buildr/documents/:collection/:id/publish',
+    method: 'post',
+    handler: async (req) => {
+        const target = targetOf(env, req);
+        if (!target.ok)
+            return target.response;
+        const rejected = mutationGuard(req);
+        if (rejected !== undefined)
+            return rejected;
+        if (!(await allowed(env, 'publish', req))) {
+            return fail(403, 'You may not publish with the builder.');
+        }
+        const limited = await writeLimit(env, req);
+        if (limited !== undefined)
+            return limited;
+        const body = await bodyOf(req);
+        if (!body.ok)
+            return body.response;
+        const parsed = publishRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return fail(400, 'The request does not match the contract.');
+        const found = await latestOf(req, target.value);
+        if (!found.ok)
+            return found.response;
+        const current = revisionOf(found.value);
+        if (parsed.data.baseRevision !== current)
+            return conflict(current);
+        const layout = processLayout(found.value['layout'], {
+            ...env.options,
+            locales: configuredLocales(req.payload.config),
+        });
+        if (!layout.ok)
+            return invalid(layout.diagnostics);
+        const registry = env.options.registry;
+        if (registry !== undefined && env.options.a11y.publish === 'block') {
+            const own = env.options.collections[target.value.collection];
+            const errors = runA11y(layout.doc, registry.meta, {
+                config: { expectH1: own?.expectH1 === true ? 'document' : 'layout' },
+            })
+                .filter((issue) => issue.severity === 'error')
+                .map((issue) => ({
+                code: `a11y.${issue.ruleId}`,
+                message: issue.message,
+                severity: 'error',
+                path: ['nodes', issue.nodeId],
+            }));
+            if (errors.length > 0)
+                return invalid(errors);
+        }
+        const published = await req.payload.update({
+            collection: target.value.collection,
+            id: target.value.id,
+            data: { _status: 'published', ...updatedBy(env, req) },
+            draft: false,
+            depth: 0,
+            req,
+            overrideAccess: false,
+            context: writeContext(req),
+        });
+        const updatedAt = String(published['updatedAt']);
+        return json(publishResponseSchema.parse({
+            status: 'published',
+            publishedAt: updatedAt,
+            revision: current,
+            updatedAt,
+        }));
+    },
+});

package/dist/plugin/endpoints/rename.d.ts

@@ -0,0 +1,9 @@
+import type { Endpoint } from 'payload';
+import { type EndpointEnv } from './context.ts';
+/**
+ * `PATCH /api/buildr/documents/:collection/:id`: renames a document. The name is the field the
+ * collection shows as its title (`admin.useAsTitle`, else `title`); the layout and its revision are
+ * left alone, so a rename never conflicts with the editor's own saves.
+ */
+export declare const renameEndpoint: (env: EndpointEnv) => Endpoint;
+//# sourceMappingURL=rename.d.ts.map

package/dist/plugin/endpoints/rename.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rename.d.ts","sourceRoot":"","sources":["../../../src/plugin/endpoints/rename.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,OAAO,EAGL,KAAK,WAAW,EAMjB,MAAM,cAAc,CAAC;AAItB;;;;GAIG;AACH,eAAO,MAAM,cAAc,QAAS,WAAW,KAAG,QAiChD,CAAC"}

package/dist/plugin/endpoints/rename.js

@@ -0,0 +1,47 @@
+import { renameRequestSchema, renameResponseSchema } from '../../contract.js';
+import { allowed, bodyOf, latestOf, targetOf, updatedBy, writeContext, writeLimit, } from './context.js';
+import { mutationGuard } from './guards.js';
+import { fail, json } from './respond.js';
+/**
+ * `PATCH /api/buildr/documents/:collection/:id`: renames a document. The name is the field the
+ * collection shows as its title (`admin.useAsTitle`, else `title`); the layout and its revision are
+ * left alone, so a rename never conflicts with the editor's own saves.
+ */
+export const renameEndpoint = (env) => ({
+    path: '/buildr/documents/:collection/:id',
+    method: 'patch',
+    handler: async (req) => {
+        const target = targetOf(env, req);
+        if (!target.ok)
+            return target.response;
+        const rejected = mutationGuard(req);
+        if (rejected !== undefined)
+            return rejected;
+        if (!(await allowed(env, 'edit', req)))
+            return fail(403, 'You may not edit with the builder.');
+        const limited = await writeLimit(env, req);
+        if (limited !== undefined)
+            return limited;
+        const body = await bodyOf(req);
+        if (!body.ok)
+            return body.response;
+        const parsed = renameRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return fail(400, 'The request does not match the contract.');
+        const found = await latestOf(req, target.value);
+        if (!found.ok)
+            return found.response;
+        const titleField = req.payload.collections[target.value.collection]?.config.admin?.useAsTitle ?? 'title';
+        await req.payload.update({
+            collection: target.value.collection,
+            id: target.value.id,
+            data: { [titleField]: parsed.data.title, ...updatedBy(env, req) },
+            draft: true,
+            depth: 0,
+            req,
+            overrideAccess: false,
+            context: writeContext(req),
+        });
+        return json(renameResponseSchema.parse({ title: parsed.data.title }));
+    },
+});

package/dist/plugin/endpoints/respond.d.ts

@@ -0,0 +1,9 @@
+import type { Diagnostic } from '@next-buildr/core';
+export declare const json: (body: unknown, status?: number) => Response;
+export declare const fail: (status: number, error: string) => Response;
+export declare const unauthorized: () => Response;
+export declare const notFound: (what: string) => Response;
+export declare const conflict: (currentRevision: number) => Response;
+/** The contract carries plain JSON; a diagnostic detail that is not JSON never gets here. */
+export declare const invalid: (diagnostics: readonly Diagnostic[]) => Response;
+//# sourceMappingURL=respond.d.ts.map

package/dist/plugin/endpoints/respond.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"respond.d.ts","sourceRoot":"","sources":["../../../src/plugin/endpoints/respond.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAGpD,eAAO,MAAM,IAAI,SAAU,OAAO,sBAAiB,QAI/C,CAAC;AAEL,eAAO,MAAM,IAAI,WAAY,MAAM,SAAS,MAAM,KAAG,QACJ,CAAC;AAElD,eAAO,MAAM,YAAY,QAAO,QAAoD,CAAC;AACrF,eAAO,MAAM,QAAQ,SAAU,MAAM,KAAG,QAA+C,CAAC;AACxF,eAAO,MAAM,QAAQ,oBAAqB,MAAM,KAAG,QAA0C,CAAC;AAE9F,6FAA6F;AAC7F,eAAO,MAAM,OAAO,gBAAiB,SAAS,UAAU,EAAE,KAAG,QACd,CAAC"}

package/dist/plugin/endpoints/respond.js

@@ -0,0 +1,10 @@
+export const json = (body, status = 200) => new Response(JSON.stringify(body), {
+    status,
+    headers: { 'content-type': 'application/json' },
+});
+export const fail = (status, error) => json({ error }, status);
+export const unauthorized = () => fail(401, 'Authentication is required.');
+export const notFound = (what) => fail(404, `${what} was not found.`);
+export const conflict = (currentRevision) => json({ currentRevision }, 409);
+/** The contract carries plain JSON; a diagnostic detail that is not JSON never gets here. */
+export const invalid = (diagnostics) => json({ diagnostics }, 422);

package/dist/plugin/endpoints/samples.d.ts

@@ -0,0 +1,5 @@
+import type { Endpoint } from 'payload';
+import { type EndpointEnv } from './context.ts';
+/** `GET /api/buildr/samples/:collection?search`: documents to preview a template with. */
+export declare const samplesEndpoint: (env: EndpointEnv) => Endpoint;
+//# sourceMappingURL=samples.d.ts.map

package/dist/plugin/endpoints/samples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"samples.d.ts","sourceRoot":"","sources":["../../../src/plugin/endpoints/samples.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGxC,OAAO,EAAyB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAKvE,0FAA0F;AAC1F,eAAO,MAAM,eAAe,QAAS,WAAW,KAAG,QAmCjD,CAAC"}

package/dist/plugin/endpoints/samples.js

@@ -0,0 +1,42 @@
+import { samplesResponseSchema } from '../../contract.js';
+import { chooseLocale } from '../locales.js';
+import { allowed, collectionOf } from './context.js';
+import { fail, json } from './respond.js';
+const SAMPLE_LIMIT = 20;
+/** `GET /api/buildr/samples/:collection?search`: documents to preview a template with. */
+export const samplesEndpoint = (env) => ({
+    path: '/buildr/samples/:collection',
+    method: 'get',
+    handler: async (req) => {
+        const collection = collectionOf(env, req);
+        if (!collection.ok)
+            return collection.response;
+        if (!(await allowed(env, 'edit', req)))
+            return fail(403, 'You may not edit with the builder.');
+        const titleField = req.payload.collections[collection.value]?.config.admin?.useAsTitle ?? 'title';
+        const locale = chooseLocale(req, req.searchParams?.get('locale'));
+        if (!locale.ok)
+            return locale.response;
+        const search = req.searchParams?.get('search')?.trim() ?? '';
+        const result = await req.payload.find({
+            collection: collection.value,
+            ...(search === '' ? {} : { where: { [titleField]: { like: search } } }),
+            limit: SAMPLE_LIMIT,
+            depth: 0,
+            draft: true,
+            ...locale.args,
+            req,
+            overrideAccess: false,
+        });
+        return json(samplesResponseSchema.parse({
+            items: result.docs.map((doc) => {
+                const record = doc;
+                const title = record[titleField];
+                return {
+                    id: String(record['id']),
+                    title: typeof title === 'string' && title !== '' ? title : String(record['id']),
+                };
+            }),
+        }));
+    },
+});

package/dist/plugin/endpoints/save.d.ts

@@ -0,0 +1,9 @@
+import type { Endpoint } from 'payload';
+import { type EndpointEnv } from './context.ts';
+/**
+ * `PUT /api/buildr/documents/:collection/:id`: a save. The revision the editor built on must still
+ * be the stored one (`409` otherwise); the document is migrated and validated (`422` with the
+ * diagnostics); an autosave updates the current autosave version in place, a save creates a draft.
+ */
+export declare const saveEndpoint: (env: EndpointEnv) => Endpoint;
+//# sourceMappingURL=save.d.ts.map

package/dist/plugin/endpoints/save.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"save.d.ts","sourceRoot":"","sources":["../../../src/plugin/endpoints/save.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAIxC,OAAO,EAGL,KAAK,WAAW,EAOjB,MAAM,cAAc,CAAC;AAItB;;;;GAIG;AACH,eAAO,MAAM,YAAY,QAAS,WAAW,KAAG,QA0C9C,CAAC"}

package/dist/plugin/endpoints/save.js

@@ -0,0 +1,58 @@
+import { saveRequestSchema, saveResponseSchema } from '../../contract.js';
+import { processLayout } from '../hooks/process-layout.js';
+import { configuredLocales } from '../locales.js';
+import { allowed, bodyOf, latestOf, revisionOf, targetOf, updatedBy, writeContext, writeLimit, } from './context.js';
+import { mutationGuard } from './guards.js';
+import { conflict, fail, invalid, json } from './respond.js';
+/**
+ * `PUT /api/buildr/documents/:collection/:id`: a save. The revision the editor built on must still
+ * be the stored one (`409` otherwise); the document is migrated and validated (`422` with the
+ * diagnostics); an autosave updates the current autosave version in place, a save creates a draft.
+ */
+export const saveEndpoint = (env) => ({
+    path: '/buildr/documents/:collection/:id',
+    method: 'put',
+    handler: async (req) => {
+        const target = targetOf(env, req);
+        if (!target.ok)
+            return target.response;
+        const rejected = mutationGuard(req);
+        if (rejected !== undefined)
+            return rejected;
+        if (!(await allowed(env, 'edit', req)))
+            return fail(403, 'You may not edit with the builder.');
+        const limited = await writeLimit(env, req);
+        if (limited !== undefined)
+            return limited;
+        const body = await bodyOf(req);
+        if (!body.ok)
+            return body.response;
+        const parsed = saveRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return fail(400, 'The request does not match the contract.');
+        const found = await latestOf(req, target.value);
+        if (!found.ok)
+            return found.response;
+        const current = revisionOf(found.value);
+        if (parsed.data.baseRevision !== current)
+            return conflict(current);
+        const layout = processLayout(parsed.data.document, {
+            ...env.options,
+            locales: configuredLocales(req.payload.config),
+        });
+        if (!layout.ok)
+            return invalid(layout.diagnostics);
+        const updated = await req.payload.update({
+            collection: target.value.collection,
+            id: target.value.id,
+            data: { layout: layout.doc, buildrRevision: current + 1, ...updatedBy(env, req) },
+            draft: true,
+            autosave: parsed.data.autosave,
+            depth: 0,
+            req,
+            overrideAccess: false,
+            context: writeContext(req),
+        });
+        return json(saveResponseSchema.parse({ revision: current + 1, updatedAt: String(updated['updatedAt']) }));
+    },
+});

package/dist/plugin/endpoints/session.d.ts

@@ -0,0 +1,5 @@
+import type { Endpoint } from 'payload';
+import type { EndpointEnv } from './context.ts';
+/** `GET /api/buildr/session`: who is asking, what they may do, and the limits their documents live under. */
+export declare const sessionEndpoint: (env: EndpointEnv) => Endpoint;
+//# sourceMappingURL=session.d.ts.map

package/dist/plugin/endpoints/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../src/plugin/endpoints/session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAIxC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,6GAA6G;AAC7G,eAAO,MAAM,eAAe,QAAS,WAAW,KAAG,QAuBjD,CAAC"}

package/dist/plugin/endpoints/session.js

@@ -0,0 +1,30 @@
+import { sessionResponseSchema } from '../../contract.js';
+import { permissionsOf } from '../access.js';
+import { configuredLocales } from '../locales.js';
+import { json, unauthorized } from './respond.js';
+/** `GET /api/buildr/session`: who is asking, what they may do, and the limits their documents live under. */
+export const sessionEndpoint = (env) => ({
+    path: '/buildr/session',
+    method: 'get',
+    handler: async (req) => {
+        const user = req.user;
+        if (user === null || user === undefined || user.id === undefined)
+            return unauthorized();
+        const body = {
+            user: { id: user.id, ...(user.email === undefined ? {} : { email: user.email }) },
+            permissions: await permissionsOf(env.options, req),
+            limits: { ...env.options.limits },
+            publishPolicy: env.options.a11y.publish,
+        };
+        const locales = configuredLocales(req.payload.config);
+        if (locales !== undefined) {
+            body.locales = {
+                locales: [...locales.locales],
+                default: locales.default,
+                fallback: locales.fallback,
+                intl: { ...locales.intl },
+            };
+        }
+        return json(sessionResponseSchema.parse(body));
+    },
+});

package/dist/plugin/endpoints/templates.test.d.ts

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

package/dist/plugin/endpoints/templates.test.d.ts.map

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