alinea 2.0.0-preview.0 → 2.0.0-preview.2

package/dist/adapter/next/with-alinea.js

@@ -10,12 +10,13 @@ function createCMS() {
   );
 }
 function withAlinea(config = {}) {
-  const adminPath = resolveAdminPath();
-  if (!adminPath) {
+  const settings = resolveSettings(config);
+  if (!settings) {
     console.warn(
-      "Alinea dashboard settings could not be loaded; dashboard routing is disabled. Run Next.js through the Alinea CLI and deploy @alinea/generated."
+      "Alinea dashboard settings were not provided; dashboard routing is disabled. Run Next.js through the Alinea CLI."
     );
   }
+  const adminPath = settings?.adminPath;
   let nextVersion = 15;
   try {
     const require2 = createRequire(resolve("./index.js"));
@@ -39,6 +40,10 @@ function withAlinea(config = {}) {
   };
   const redirects = adminPath ? createRedirects(config, adminPath) : config.redirects;
   const rewrites = adminPath ? createRewrites(config, adminPath) : config.rewrites;
+  const env = settings ? {
+    ...config.env,
+    ALINEA_ADMIN_PATH: settings.adminPath
+  } : config.env;
   if (nextVersion < 15)
     return {
       ...config,
@@ -51,7 +56,8 @@ function withAlinea(config = {}) {
       },
       images,
       redirects,
-      rewrites
+      rewrites,
+      env
     };
   return {
     ...config,
@@ -61,7 +67,8 @@ function withAlinea(config = {}) {
     ],
     images,
     redirects,
-    rewrites
+    rewrites,
+    env
   };
 }
 function createRedirects(config, adminPath) {
@@ -124,17 +131,12 @@ function createRewrites(config, adminPath) {
     };
   };
 }
-function resolveAdminPath() {
-  try {
-    const require2 = createRequire(resolve("./index.js"));
-    const location = require2.resolve("@alinea/generated/settings.json");
-    const settings = JSON.parse(
-      readFileSync(location, "utf-8")
-    );
-    if (typeof settings.adminPath === "string" && settings.adminPath)
-      return normalizeBasePath(settings.adminPath);
-  } catch {
-  }
+function resolveSettings(config) {
+  const adminPath = config.env?.ALINEA_ADMIN_PATH ?? process.env.ALINEA_ADMIN_PATH;
+  if (!adminPath) return;
+  return {
+    adminPath: normalizeBasePath(adminPath)
+  };
 }
 function normalizeBasePath(value) {
   return value.startsWith("/") ? value : `/${value}`;

package/dist/backend/Handler.d.ts

@@ -1,24 +1,25 @@
-import type { Entry } from 'alinea/core';
 import type { CMS } from 'alinea/core/CMS';
-import type { RemoteConnection, RequestContext } from 'alinea/core/Connection';
-import type { LocalDB } from 'alinea/core/db/LocalDB';
+import type { AuthedContext, RemoteConnection, RequestContext } from 'alinea/core/Connection';
+import { LocalDB } from 'alinea/core/db/LocalDB';
+import type { Mutation } from 'alinea/core/db/Mutation';
 export interface Handler {
     (request: Request, context: RequestContext): Promise<Response>;
 }
-export type HookResponse<T = void> = void | T | Promise<T> | Promise<void>;
+export type HookResponse<T = void> = void | T | Promise<void | T>;
+export interface BeforeCommitContext {
+    mutations: ReadonlyArray<Mutation>;
+}
+export interface AfterCommitContext extends BeforeCommitContext {
+    sha: string;
+}
 export interface HandlerHooks {
-    beforeCreate?(entry: Entry): HookResponse<Entry>;
-    afterCreate?(entry: Entry): HookResponse;
-    beforeUpdate?(entry: Entry): HookResponse<Entry>;
-    afterUpdate?(entry: Entry): HookResponse;
-    beforeArchive?(entryId: string): HookResponse;
-    afterArchive?(entryId: string): HookResponse;
-    beforeRemove?(entryId: string): HookResponse;
-    afterRemove?(entryId: string): HookResponse;
+    beforeCommit?(context: BeforeCommitContext): HookResponse<ReadonlyArray<Mutation>>;
+    afterCommit?(context: AfterCommitContext): HookResponse;
 }
 export interface HandlerOptions extends HandlerHooks {
     cms: CMS;
     db: LocalDB | Promise<LocalDB>;
     remote?: (context: RequestContext) => RemoteConnection;
+    forwardMutations?(request: Request, context: AuthedContext): Promise<Response | undefined>;
 }
-export declare function createHandler({ cms, remote, db, ...hooks }: HandlerOptions): Handler;
+export declare function createHandler({ cms, remote, db, forwardMutations, ...hooks }: HandlerOptions): Handler;

package/dist/backend/Handler.js

@@ -13,6 +13,11 @@ import "../chunks/chunk-CQ52GEHY.js";
 // src/backend/Handler.ts
 import { JWTPreviews } from "alinea/backend/util/JWTPreviews";
 import { CloudRemote } from "alinea/cloud/CloudRemote";
+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";
@@ -22,7 +27,8 @@ 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({
   filename: string,
@@ -32,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;
@@ -88,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
             });
@@ -159,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();
@@ -210,7 +246,7 @@ function createHandler({
         const sha = string(url.searchParams.get("sha"));
         await local.syncWith(cnx);
         const tree = await local.getTreeIfDifferent(sha);
-        return Response.json(tree ?? null);
+        return compressResponse(request, Response.json(tree ?? null));
       }
       if (action === HandleAction.Blob && request.method === "POST") {
         const { shas } = object({ shas: array(string) })(await body);
@@ -222,20 +258,18 @@ function createHandler({
           if (tree.hasSha(sha)) fromLocal.push(sha);
           else fromRemote.push(sha);
         }
-        const formData = new FormData();
-        if (fromLocal.length > 0) {
-          const blobs = local.source.getBlobs(fromLocal);
-          for await (const [sha, blob] of blobs) {
-            formData.append(sha, new Blob([blob]));
-          }
+        async function* blobs() {
+          const options = { signal: request.signal };
+          if (fromLocal.length > 0)
+            yield* local.source.getBlobs(fromLocal, options);
+          if (fromRemote.length > 0) yield* cnx.getBlobs(fromRemote, options);
         }
-        if (fromRemote.length > 0) {
-          const blobs = cnx.getBlobs(fromRemote);
-          for await (const [sha, blob] of blobs) {
-            formData.append(sha, new Blob([blob]));
-          }
-        }
-        return new Response(formData);
+        return compressResponse(
+          request,
+          new Response(encodeBlobSequence(blobs()), {
+            headers: { "content-type": BLOB_SEQUENCE_CONTENT_TYPE }
+          })
+        );
       }
       if (action === HandleAction.Upload) {
         const user = 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
 };

package/dist/backend/router/Router.d.ts

@@ -144,4 +144,5 @@ export declare namespace router {
     function cookie(...cookies: Array<Cookie>): string;
     function compress(...routes: Array<Next<Request, Response | undefined>>): Route<Request, Response | undefined>;
 }
+export declare function compressResponse(request: Request, response: Response): Response;
 export {};

package/dist/backend/router/Router.js

@@ -186,27 +186,33 @@ function callHandler(handler, input) {
       async (request) => {
         const response = await route.handle(request);
         if (response === void 0) return void 0;
-        const body = response.body;
-        if (!body) return response;
-        const isCompressed = response.headers.get("content-encoding");
-        if (isCompressed) return response;
-        const accept = request.headers.get("accept-encoding");
-        const method = accept?.includes("gzip") ? "gzip" : accept?.includes("deflate") ? "deflate" : void 0;
-        if (method === void 0) return response;
-        const stream = body.pipeThrough(new CompressionStream(method));
-        const headers = new Headers(response.headers);
-        headers.set("content-encoding", method);
-        headers.delete("content-length");
-        return new Response(stream, {
-          headers,
-          status: response.status
-        });
+        return compressResponse(request, response);
       }
     );
   }
   router2.compress = compress;
 })(router || (router = {}));
+function compressResponse(request, response) {
+  const body = response.body;
+  if (!body) return response;
+  const isCompressed = response.headers.get("content-encoding");
+  if (isCompressed) return response;
+  const accept = request.headers.get("accept-encoding");
+  const method = accept?.includes("gzip") ? "gzip" : accept?.includes("deflate") ? "deflate" : void 0;
+  if (method === void 0) return response;
+  const stream = body.pipeThrough(new CompressionStream(method));
+  const headers = new Headers(response.headers);
+  headers.set("content-encoding", method);
+  headers.set("vary", "accept-encoding");
+  headers.delete("content-length");
+  return new Response(stream, {
+    headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+}
 export {
   Route,
+  compressResponse,
   router
 };