alinea 2.0.0-preview.1 → 2.0.0-preview.3

package/dist/backend/Handler.js

@@ -17,6 +17,7 @@ import {
   BLOB_SEQUENCE_CONTENT_TYPE,
   encodeBlobSequence
 } from "alinea/core/BlobTransport";
+import { developmentKeyHeader } from "alinea/core/Connection";
 import { ErrorCode, HttpError } from "alinea/core/HttpError";
 import { assertUploadSize } from "alinea/core/media/UploadLimits";
 import { Permission, Policy } from "alinea/core/Role";
@@ -26,7 +27,7 @@ import { base64 } from "alinea/core/util/Encoding";
 import { isRecord } from "alinea/core/util/Objects";
 import { InvalidCredentialsError, MissingCredentialsError } from "./Auth.js";
 import { HandleAction } from "./HandleAction.js";
-import { createPreviewParser } from "./resolver/ParsePreview.js";
+import { applyPreview, decodePreviewRequest } from "./resolver/ParsePreview.js";
 import { compressResponse } from "./router/Router.js";
 import { createThrottledSync } from "./util/Syncable.js";
 var PrepareBody = object({
@@ -37,13 +38,10 @@ function createHandler({
   cms,
   remote = (context) => new CloudRemote(context, cms.config),
   db,
+  forwardMutations,
   ...hooks
 }) {
   const throttle = createThrottledSync();
-  const previewParser = PLazy.from(async () => {
-    const local = await db;
-    return createPreviewParser(local);
-  });
   return async function handle(request, context) {
     const dev = process.env.ALINEA_DEV_SERVER;
     const local = await db;
@@ -93,11 +91,10 @@ function createHandler({
         };
       } catch (cause) {
         if (cause instanceof MissingCredentialsError) {
-          const authorization = request.headers.get("authorization");
-          const bearer = authorization?.slice("Bearer ".length);
+          const credential = context.isDev ? request.headers.get(developmentKeyHeader) : request.headers.get("authorization")?.slice("Bearer ".length);
           if (!context.apiKey)
             throw new MissingCredentialsError("Missing API key", { cause });
-          if (bearer !== context.apiKey)
+          if (credential !== context.apiKey)
             throw new InvalidCredentialsError("Expected matching api key", {
               cause
             });
@@ -164,43 +161,77 @@ function createHandler({
         const scope = getScope(cms.config);
         const query = scope.parse(raw);
         if (!query.preview) {
-          await periodicSync(cnx, query.syncInterval);
+          await periodicSync(
+            cnx,
+            query.disableSync ? Number.POSITIVE_INFINITY : query.syncInterval ?? cms.config.syncInterval
+          );
         } else {
-          const { parse } = await previewParser;
-          const preview = await parse(query.preview, () => local.syncWith(cnx));
-          query.preview = preview;
+          const preview = await decodePreviewRequest(query.preview);
+          if ("contentHash" in preview && local.sha !== preview.contentHash)
+            await local.syncWith(cnx);
+          query.preview = await applyPreview(local, preview);
         }
         return Response.json(await local.resolve(query) ?? null);
       }
       if (action === HandleAction.Mutate && request.method === "POST") {
+        if (forwardMutations && userCtx) {
+          const forwarded = await forwardMutations(request.clone(), userCtx);
+          if (forwarded) return forwarded;
+        }
         const user = expectUser();
         expectJson();
         const policy = await user.policy;
-        const mutations = await body;
+        let mutations = await body;
+        await local.syncWith(cnx);
+        const adjusted = await hooks.beforeCommit?.({ mutations });
+        if (adjusted) mutations = adjusted;
         const attempt = async (retry = 0) => {
-          await local.syncWith(cnx);
+          if (retry > 0) await local.syncWith(cnx);
           const request2 = {
             ...await local.request(mutations, policy),
             user: user.claims
           };
           try {
-            let { sha } = await cnx.write(request2);
-            if (sha === request2.intoSha) {
+            let { sha: sha2 } = await cnx.write(request2);
+            if (sha2 === request2.intoSha) {
               await local.write(request2);
             } else {
-              sha = await local.syncWith(cnx);
+              sha2 = await local.syncWith(cnx);
             }
-            return sha;
+            return sha2;
           } catch (error) {
-            if (error instanceof ShaMismatchError && retry < 3)
-              return attempt(retry + 1);
+            const isConflict = error instanceof ShaMismatchError || error instanceof HttpError && error.code === 409 || error instanceof Response && error.status === 409;
+            if (isConflict && retry < 3) return attempt(retry + 1);
             throw error;
           }
         };
-        return Response.json({ sha: await attempt() });
+        const sha = await attempt();
+        try {
+          await hooks.afterCommit?.({
+            mutations,
+            sha
+          });
+        } catch (error) {
+          console.error("Alinea afterCommit hook failed", error);
+        }
+        return Response.json({ sha });
       }
       if (action === HandleAction.Commit && request.method === "POST") {
-        throw new Error("Mutations expected");
+        if (!context.isDev)
+          throw new HttpError(400, "Commits are only accepted in development");
+        const developmentKey = request.headers.get(developmentKeyHeader);
+        if (!context.apiKey || developmentKey !== context.apiKey)
+          throw new HttpError(401, "Invalid development commit credentials");
+        const user = expectUser();
+        expectJson();
+        const commit = {
+          ...await body,
+          user: user.claims
+        };
+        let { sha } = await cnx.write(commit);
+        if (sha === commit.intoSha) await local.write(commit);
+        else sha = await local.syncWith(cnx);
+        return Response.json({ sha });
       }
       if (action === HandleAction.History && request.method === "GET") {
         expectUser();

package/dist/backend/resolver/ParsePreview.d.ts

@@ -1,5 +1,9 @@
 import type { LocalDB } from 'alinea/core/db/LocalDB';
-import type { PreviewRequest } from 'alinea/core/Preview';
-export declare function createPreviewParser(local: LocalDB): {
-    parse(preview: PreviewRequest, sync: () => Promise<unknown>): Promise<PreviewRequest | undefined>;
-};
+import { Entry } from 'alinea/core/Entry';
+import type { PreviewRequest, PreviewUpdate } from 'alinea/core/Preview';
+export interface DecodedEntryPreview {
+    entry: Entry;
+}
+export type DecodedPreviewRequest = PreviewUpdate | DecodedEntryPreview;
+export declare function decodePreviewRequest(preview: PreviewRequest): Promise<DecodedPreviewRequest>;
+export declare function applyPreview(local: LocalDB, preview: DecodedPreviewRequest): Promise<PreviewRequest | undefined>;

package/dist/backend/resolver/ParsePreview.js

@@ -5,53 +5,50 @@ import { JsonLoader } from "alinea/backend/loader/JsonLoader";
 import { Entry } from "alinea/core/Entry";
 import { createRecord, parseRecord } from "alinea/core/EntryRecord";
 import { applyFilePatch } from "alinea/core/source/FilePatch";
+import { trace } from "alinea/core/Trace";
 import { createEntryRow } from "alinea/core/util/EntryRows";
 import { decodePreviewPayload } from "alinea/preview/PreviewPayload";
 var decoder = new TextDecoder();
-function createPreviewParser(local) {
-  return {
-    async parse(preview, sync) {
-      if (!(preview && "payload" in preview)) return preview;
-      const payload = await decodePreviewPayload(preview.payload);
-      if (local.sha !== payload.contentHash) {
-        await sync();
-        if (local.sha !== payload.contentHash) return;
-      }
-      const entry = await local.first({
-        select: Entry,
-        id: payload.entryId,
-        locale: payload.locale,
-        status: "preferDraft"
-      });
-      if (!entry) return;
-      const baseText = decoder.decode(
-        JsonLoader.format(
-          local.config.schema,
-          createRecord(entry, entry.status)
-        )
-      );
-      let updatedText;
-      try {
-        updatedText = await applyFilePatch(baseText, payload.patch);
-      } catch {
-        return;
-      }
-      const { data } = parseRecord(JSON.parse(updatedText));
-      const { rowHash: _rowHash, fileHash: _fileHash, ...withoutHashes } = entry;
-      const patched = await createEntryRow(
-        local.config,
-        {
-          ...withoutHashes,
-          title: data.title,
-          data,
-          path: entry.path
-        },
-        entry.status
-      );
-      return { entry: patched };
+async function decodePreviewRequest(preview) {
+  if ("entry" in preview) return preview;
+  return decodePreviewPayload(preview.payload);
+}
+async function applyPreview(local, preview) {
+  if ("entry" in preview) return preview;
+  const span = trace(local.config, "alinea.preview.apply");
+  return span(async () => {
+    const entry = await local.first({
+      select: Entry,
+      id: preview.entryId,
+      locale: preview.locale,
+      status: "preferDraft"
+    });
+    if (!entry) return;
+    const baseText = decoder.decode(
+      JsonLoader.format(local.config.schema, createRecord(entry, entry.status))
+    );
+    let updatedText;
+    try {
+      updatedText = await applyFilePatch(baseText, preview.patch);
+    } catch {
+      return;
     }
-  };
+    const { data } = parseRecord(JSON.parse(updatedText));
+    const { rowHash: _rowHash, fileHash: _fileHash, ...withoutHashes } = entry;
+    const patched = await createEntryRow(
+      local.config,
+      {
+        ...withoutHashes,
+        title: data.title,
+        data,
+        path: entry.path
+      },
+      entry.status
+    );
+    return { entry: patched };
+  });
 }
 export {
-  createPreviewParser
+  applyPreview,
+  decodePreviewRequest
 };