alinea 2.0.0-preview.9 → 2.0.0-rc2

package/dist/adapter/next/cms.d.ts

@@ -1,6 +1,6 @@
 import { CMS } from 'alinea/core/CMS';
 import { Config } from 'alinea/core/Config';
-import type { UploadResponse } from 'alinea/core/Connection';
+import { type UploadMetadata, type UploadResponse } from 'alinea/core/Connection';
 import type { LocalStore } from 'alinea/core/db/LocalStore';
 import type { Mutation } from 'alinea/core/db/Mutation';
 import type { GraphQuery } from 'alinea/core/Graph';
@@ -35,7 +35,7 @@ export declare class NextCMS<Definition extends Config = Config> extends CMS<Def
     mutate(mutations: Array<Mutation>): Promise<{
         sha: string;
     }>;
-    prepareUpload(file: string): Promise<UploadResponse>;
+    prepareUpload(file: string, metadata?: UploadMetadata): Promise<UploadResponse>;
     previews: ({ widget, stats: showStats, workspace, root }: PreviewProps) => Promise<import("react").JSX.Element | null>;
 }
 export declare function createCMS<Definition extends Config>(config: Definition): NextCMS<Definition>;

package/dist/adapter/next/cms.js

@@ -8,18 +8,25 @@ import {
   applyPreview as applyPreviewUpdate,
   decodePreviewRequest
 } from "alinea/backend/resolver/ParsePreview";
-import { createThrottledSync } from "alinea/backend/util/Syncable";
+import { dashboardUrl } from "./dashboardUrl.js";
+import { createThrottledSync, syncWait } from "alinea/backend/util/Syncable";
 import { Client } from "alinea/core/Client";
 import { CMS } from "alinea/core/CMS";
-import { Config } from "alinea/core/Config";
+import {
+  withDevelopmentKey
+} from "alinea/core/Connection";
+import { loggedSync, syncStats } from "alinea/core/db/SyncStats";
 import { outcome } from "alinea/core/Outcome";
+import { getScope } from "alinea/core/Scope";
 import { trace } from "alinea/core/Trace";
+import { within } from "alinea/core/util/Async";
 import { getPreviewPayloadFromCookies } from "alinea/preview/PreviewCookies";
 import { Headers } from "@alinea/iso";
 import { cache } from "react";
 import { requestContext } from "./context.js";
+import { cachedResolve, developmentRevision } from "./devCache.js";
 import { RenderStats, summarizeQuery, timed } from "./renderStats.js";
-import { syncIfStale } from "./syncCheck.js";
+import { contentShaWindow, syncIfStale, tagContentSha } from "./syncCheck.js";
 import { jsx } from "react/jsx-runtime";
 var preValidatedRemote = { validate: false };
 var NextCMS = class extends CMS {
@@ -61,9 +68,16 @@ var NextCMS = class extends CMS {
    * returns a fresh holder, so nothing is recorded there.
    */
   #render = cache(() => ({}));
+  /** Build renders join the content sha tag once, see `tagContentSha`. */
+  #tagContent = cache(
+    () => tagContentSha(contentShaWindow(this.config.syncInterval))
+  );
+  /** One content revision per render, see `developmentRevision`. */
+  #devRevision = cache(() => developmentRevision());
   #isDraft = cache(async () => {
-    const { draftMode } = await import("next/headers.js");
+    const { cookies, draftMode } = await import("next/headers.js");
     const [isDraft] = await outcome(async () => (await draftMode()).isEnabled);
+    if (isDraft) await outcome(cookies);
     return Boolean(isDraft);
   });
   /** Draft renders collect their queries and syncs for the preview widget. */
@@ -80,22 +94,27 @@ var NextCMS = class extends CMS {
     return { isBuild, useLocalDb: !isEdge && (!context.isDev || isBuild) };
   }
   /** Renders keep serving the current content when the handler is unreachable. */
-  async #syncDb(db, client, stats) {
-    if (stats)
-      return stats.track(
-        { kind: "sync", summary: "sync" },
-        (row) => timed(row, () => this.#syncDb(db, client, void 0))
-      );
-    try {
-      const sha = await db.syncWith(client, preValidatedRemote);
-      this.#syncedAt = Date.now();
-      return sha;
-    } catch (error) {
-      console.warn(
-        `Alinea could not sync with the handler, serving current content: ${error instanceof Error ? error.message : String(error)}`
-      );
-      return db.sha;
-    }
+  async #syncDb(db, client, reason, render) {
+    const stats = syncStats();
+    const sync = async () => {
+      try {
+        const options = { ...preValidatedRemote, stats };
+        const synced = process.env.NODE_ENV === "production" ? loggedSync(db, client, reason, options) : db.syncWith(client, options);
+        const sha = await within(synced, syncWait);
+        this.#syncedAt = Date.now();
+        return sha;
+      } catch (error) {
+        console.warn(
+          `Alinea could not sync with the handler, serving current content: ${error instanceof Error ? error.message : String(error)}`
+        );
+        return db.sha;
+      }
+    };
+    if (!render) return sync();
+    return render.track(
+      { kind: "sync", summary: `sync (${reason})`, sync: stats },
+      (row) => timed(row, sync)
+    );
   }
   #applyPreview = cache(async () => {
     const context = await requestContext(this.config);
@@ -137,6 +156,7 @@ var NextCMS = class extends CMS {
       await this.#syncDb(
         db,
         createClient(this.config, context),
+        `preview at ${decoded.contentHash.slice(0, 7)}`,
         this.#render().stats
       );
     return applyPreviewUpdate(db, decoded);
@@ -168,13 +188,18 @@ var NextCMS = class extends CMS {
   async #resolve(query, row) {
     let status = query.status;
     const { context, hasPreview, isDraft, isBuild, preview, useLocalDb } = await this.#applyPreview();
-    if (isDraft && !status) status = "preferDraft";
+    if (isDraft && !status) status = "preview";
     const request = { ...query, preview, status };
     const client = createClient(this.config, context);
     if (row) row.source = useLocalDb ? "database" : "handler";
     if (!useLocalDb) {
       const span = trace(this.config, "alinea.cms.resolve.client");
-      return timed(row, () => span(() => client.resolve(request)));
+      const answer2 = () => client.resolve(request);
+      const revision = context.isDev && !isDraft && this.#devRevision();
+      if (!revision) return timed(row, () => span(answer2));
+      const key = [context.handlerUrl.href, revision];
+      const body = getScope(this.config).stringify(request);
+      return span(() => cachedResolve(key, body, answer2));
     }
     const db = await this.bundledDb;
     const stats = this.#render().stats;
@@ -188,14 +213,24 @@ var NextCMS = class extends CMS {
     const answer = () => stats && row ? stats.executed(row, () => db.resolve(request)) : db.resolve(request);
     const syncInterval = request.disableSync ? Number.POSITIVE_INFINITY : request.syncInterval ?? this.config.syncInterval;
     if (hasPreview) return answer();
-    if (!isBuild) {
+    if (isBuild) {
+      await this.#tagContent();
+    } else {
       const tracked = {
         sha: db.sha,
-        syncWith: () => this.#syncDb(db, client, stats)
+        syncWith: () => this.#syncDb(db, client, "stale", stats)
       };
-      const settled = !isDraft && await syncIfStale(tracked, client, syncInterval);
+      const settled = !isDraft && await syncIfStale(
+        tracked,
+        client,
+        syncInterval,
+        contentShaWindow(this.config.syncInterval)
+      );
       if (!settled)
-        await this.throttle(() => this.#syncDb(db, client, stats), syncInterval);
+        await this.throttle(
+          () => this.#syncDb(db, client, "interval", stats),
+          syncInterval
+        );
     }
     return answer();
   }
@@ -235,9 +270,11 @@ var NextCMS = class extends CMS {
     const client = await this.#authenticatedClient();
     return client.mutate(mutations);
   }
-  async prepareUpload(file) {
+  async prepareUpload(file, metadata) {
+    const context = await requestContext(this.config);
     const client = await this.#authenticatedClient();
-    return client.prepareUpload(file);
+    const upload = await client.prepareUpload(file, metadata);
+    return context.isDev ? withDevelopmentKey(upload, context.apiKey) : upload;
   }
   previews = async ({
     widget,
@@ -249,16 +286,13 @@ var NextCMS = class extends CMS {
     if (!stats) return null;
     const { default: dynamic } = await import("next/dynamic.js");
     const { isDev, handlerUrl } = await requestContext(this.config);
-    let file = `${Config.adminPath(this.config)}.html`;
-    if (!file.startsWith("/")) file = `/${file}`;
-    const dashboardUrl = isDev ? new URL("/", handlerUrl) : new URL(file, handlerUrl);
     const NextPreviews = dynamic(() => import("./previews.js"), {
       ssr: false
     });
     return /* @__PURE__ */ jsx(
       NextPreviews,
       {
-        dashboardUrl: dashboardUrl.href,
+        dashboardUrl: dashboardUrl(this.config, isDev, handlerUrl),
         widget,
         stats: widget && showStats ? stats.settled() : void 0,
         workspace,

package/dist/adapter/next/context.js

@@ -5,7 +5,7 @@ import { generatedRelease } from "alinea/backend/store/GeneratedRelease";
 import { Config } from "alinea/core/Config";
 import { forwardDevelopmentCredentials } from "./ForwardCredentials.js";
 async function requestContext(config, request) {
-  const apiKey = process.env.ALINEA_API_KEY || (process.env.NODE_ENV === "development" ? "dev" : await generatedRelease);
+  const apiKey = process.env.ALINEA_API_KEY || (process.env.NODE_ENV === "development" ? "dev" : await generatedRelease());
   const dev = process.env.ALINEA_DEV_SERVER;
   if (dev) {
     return {
@@ -15,13 +15,12 @@ async function requestContext(config, request) {
       applyAuth: (init) => forwardDevelopmentCredentials(request, apiKey, init)
     };
   }
-  const nodeEnv = process.env.NODE_ENV;
-  const baseUrl = Config.baseUrl(config, nodeEnv);
-  if (!baseUrl) throw new Error(`Missing baseUrl in config for ${nodeEnv}`);
+  const localOrigin = process.env.__NEXT_PRIVATE_ORIGIN;
   return {
     isDev: false,
-    handlerUrl: new URL(Config.handlerUrl(config), baseUrl),
-    apiKey
+    handlerUrl: Config.serverHandlerUrl(config),
+    apiKey,
+    publicUrl: localOrigin ? new URL(localOrigin) : void 0
   };
 }
 export {

package/dist/adapter/next/dashboardUrl.d.ts

@@ -0,0 +1,6 @@
+import { Config } from 'alinea/core/Config';
+/**
+ * The dashboard as the site serves it: in development the site proxies the
+ * admin path to the dev server, in production it serves the generated file.
+ */
+export declare function dashboardUrl(config: Config, isDev: boolean, handlerUrl: URL | string): string;

package/dist/adapter/next/dashboardUrl.js

@@ -0,0 +1,13 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/adapter/next/dashboardUrl.ts
+import { Config } from "alinea/core/Config";
+function dashboardUrl(config, isDev, handlerUrl) {
+  if (!isDev)
+    return new URL(`/${Config.dashboardFile(config)}`, handlerUrl).href;
+  const adminPath = Config.adminPath(config);
+  return adminPath.startsWith("/") ? adminPath : `/${adminPath}`;
+}
+export {
+  dashboardUrl
+};

package/dist/adapter/next/devCache.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The revision of the database the Alinea dev server answers from: it
+ * commits every content change to this file, so its modification time and
+ * size change with the content. It is read synchronously, which keeps it out
+ * of the IO that Next.js tracks while it renders, and is undefined where the
+ * file cannot be read, such as in the Edge runtime.
+ */
+export declare function developmentRevision(file?: string | undefined): string | undefined;
+/**
+ * Answer a query of a development render through the Next.js data cache,
+ * under a key that includes the content revision, so the dev server is asked
+ * once per revision. With Cache Components enabled Next.js then treats the
+ * answer as cached data, as it does the bundled database in production,
+ * instead of as uncached IO that has to be wrapped in `<Suspense>`.
+ */
+export declare function cachedResolve<T>(keyParts: Array<string>, query: string, resolve: () => Promise<T>): Promise<T>;

package/dist/adapter/next/devCache.js

@@ -0,0 +1,32 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/adapter/next/devCache.ts
+function developmentRevision(file = process.env.ALINEA_GENERATED_DATABASE) {
+  if (!file) return void 0;
+  const fs = process.getBuiltinModule?.("node:fs");
+  if (!fs) return void 0;
+  try {
+    const { mtimeMs, size } = fs.statSync(file);
+    return `${mtimeMs}-${size}`;
+  } catch {
+    return void 0;
+  }
+}
+async function cachedResolve(keyParts, query, resolve) {
+  let called = false;
+  const run = (_query) => {
+    called = true;
+    return resolve();
+  };
+  try {
+    const { unstable_cache } = await import("next/cache.js");
+    return await unstable_cache(run, ["alinea-resolve", ...keyParts])(query);
+  } catch (error) {
+    if (called) throw error;
+    return resolve();
+  }
+}
+export {
+  cachedResolve,
+  developmentRevision
+};

package/dist/adapter/next/handler.js

@@ -10,6 +10,7 @@ import {
 import {
   createHandler as createCoreHandler
 } from "alinea/backend/Handler";
+import { committedEntries, removedEntries } from "alinea/backend/CommitEntries";
 import { HandleAction } from "alinea/backend/HandleAction";
 import { JWTPreviews } from "alinea/backend/util/JWTPreviews";
 import { CloudRemote } from "alinea/cloud/CloudRemote";
@@ -51,6 +52,7 @@ function createHandlerWithDatabase(input, openGeneratedDatabase) {
     ...options,
     remote,
     db,
+    logSyncs: process.env.NODE_ENV === "production",
     afterCommit
   });
   async function handleDevelopment(request, context) {
@@ -67,8 +69,6 @@ function createHandlerWithDatabase(input, openGeneratedDatabase) {
       return failure(400, "Expected JSON");
     }
     if (!Array.isArray(mutations)) return failure(400, "Expected mutations");
-    const adjusted = await options.beforeCommit?.({ mutations });
-    if (adjusted) mutations = [...adjusted];
     const devServer = new Client({
       config,
       url: context.handlerUrl.href,
@@ -80,15 +80,29 @@ function createHandlerWithDatabase(input, openGeneratedDatabase) {
       }
     });
     let sha;
+    let user;
+    let before = [];
     try {
-      ;
+      user = await devServer.user();
+      if (!user) return failure(401, "Unauthorized");
+      const adjusted = await options.beforeCommit?.({ mutations, user });
+      if (adjusted) mutations = [...adjusted];
+      if (options.afterCommit)
+        before = await committedEntries(devServer, mutations).catch(() => []);
       ({ sha } = await devServer.mutate(mutations));
     } catch (error) {
       if (error instanceof HttpError) return failure(error.code, error.message);
       throw error;
     }
     try {
-      await afterCommit({ mutations, sha });
+      const entries = options.afterCommit ? await committedEntries(devServer, mutations) : [];
+      await afterCommit({
+        mutations,
+        sha,
+        user,
+        entries,
+        removed: removedEntries(before, entries)
+      });
     } catch (error) {
       console.error("Alinea afterCommit hook failed", error);
     }

package/dist/adapter/next/syncCheck.d.ts

@@ -6,13 +6,26 @@ interface SyncableDB {
     syncWith(source: RemoteSource, options?: SyncOptions): Promise<string>;
 }
 export declare const CONTENT_SHA_TAG = "alinea-content-sha";
+/**
+ * How long renders share the latest content sha. Configured through the
+ * config's `syncInterval`, never a query's: all renders share one entry.
+ */
+export declare function contentShaWindow(syncInterval?: number): number;
+/**
+ * Tag a static render with the content sha without looking it up. Renders at
+ * build skip `syncIfStale`, so this is how their pages join the tag that
+ * commits revalidate, and get the same time-based safety net as pages
+ * rendered at runtime.
+ */
+export declare function tagContentSha(revalidate?: number): Promise<void>;
 export declare function revalidateContentSha(): Promise<void>;
 /**
  * Sync the isolate-local db only when it is behind the shared content sha.
  * Returns true when the freshness question is settled here (synced, forced,
  * or explicitly disabled) and the caller can skip its throttled sync.
  * Returns false when the sha could not be determined, so the caller falls
- * back to its existing throttle behavior.
+ * back to its existing throttle behavior. `shaWindow` is how long renders
+ * share the latest sha, see `contentShaWindow`.
  */
-export declare function syncIfStale(db: SyncableDB, client: Client, syncInterval?: number, options?: SyncOptions): Promise<boolean>;
+export declare function syncIfStale(db: SyncableDB, client: Client, syncInterval?: number, shaWindow?: number, options?: SyncOptions): Promise<boolean>;
 export {};

package/dist/adapter/next/syncCheck.js

@@ -2,22 +2,27 @@ import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/adapter/next/syncCheck.ts
 var CONTENT_SHA_TAG = "alinea-content-sha";
-var SHA_REVALIDATE_SECONDS = 60;
+var SHA_REVALIDATE_SECONDS = 300;
+function contentShaWindow(syncInterval) {
+  if (syncInterval !== void 0 && syncInterval > 0 && Number.isFinite(syncInterval))
+    return syncInterval;
+  return SHA_REVALIDATE_SECONDS;
+}
 var inflight;
-function latestSha(client) {
+function latestSha(client, revalidate) {
   if (inflight) return inflight;
-  inflight = loadLatestSha(client).finally(() => {
+  inflight = loadLatestSha(client, revalidate).finally(() => {
     inflight = void 0;
   });
   return inflight;
 }
-async function loadLatestSha(client) {
+async function loadLatestSha(client, revalidate) {
   try {
     const { unstable_cache } = await import("next/cache.js");
     const getSha = unstable_cache(
       () => client.getSha(),
       ["alinea-content-sha"],
-      { revalidate: SHA_REVALIDATE_SECONDS, tags: [CONTENT_SHA_TAG] }
+      { revalidate, tags: [CONTENT_SHA_TAG] }
     );
     return await getSha();
   } catch {
@@ -28,26 +33,38 @@ async function loadLatestSha(client) {
     }
   }
 }
+async function tagContentSha(revalidate = SHA_REVALIDATE_SECONDS) {
+  try {
+    const { unstable_cache } = await import("next/cache.js");
+    await unstable_cache(async () => true, ["alinea-content-sha-tag"], {
+      revalidate,
+      tags: [CONTENT_SHA_TAG]
+    })();
+  } catch {
+  }
+}
 async function revalidateContentSha() {
   try {
     const { revalidateTag } = await import("next/cache.js");
-    revalidateTag(CONTENT_SHA_TAG, { expire: 0 });
+    revalidateTag(CONTENT_SHA_TAG, "max");
   } catch {
   }
 }
-async function syncIfStale(db, client, syncInterval, options) {
+async function syncIfStale(db, client, syncInterval, shaWindow = SHA_REVALIDATE_SECONDS, options) {
   if (syncInterval === Number.POSITIVE_INFINITY) return true;
   if (syncInterval === 0) {
     await db.syncWith(client, options);
     return true;
   }
-  const expected = await latestSha(client);
+  const expected = await latestSha(client, shaWindow);
   if (!expected) return false;
   if (expected !== await db.sha) await db.syncWith(client, options);
   return true;
 }
 export {
   CONTENT_SHA_TAG,
+  contentShaWindow,
   revalidateContentSha,
-  syncIfStale
+  syncIfStale,
+  tagContentSha
 };

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

@@ -64,24 +64,18 @@ function withAlinea(config = {}) {
   };
 }
 function createImages(config, adminPath) {
-  const filePattern = `${adminPath}/file/**`;
+  const filePattern = { pathname: `${adminPath}/file/**` };
   const localPatterns = config.images?.localPatterns;
   if (!localPatterns)
     return {
       ...config.images,
-      localPatterns: [{ pathname: filePattern }, { pathname: "/**" }]
+      localPatterns: [filePattern, { pathname: "**", search: "" }]
     };
-  if (localPatterns.some((pattern) => pattern.pathname === filePattern))
+  if (localPatterns.some(
+    (pattern) => pattern.pathname === filePattern.pathname && pattern.search === void 0
+  ))
     return config.images;
-  return {
-    ...config.images,
-    localPatterns: [
-      ...localPatterns,
-      {
-        pathname: filePattern
-      }
-    ]
-  };
+  return { ...config.images, localPatterns: [...localPatterns, filePattern] };
 }
 var emptyRewrites = {
   beforeFiles: [],
@@ -122,16 +116,15 @@ function createRewrites(config, adminPath, handlerUrl) {
     }
     return {
       ...rewrites,
-      beforeFiles: [
-        ...rewrites.beforeFiles,
+      afterFiles: [
+        ...rewrites.afterFiles,
         {
+          // The build links media files on disk into the public dir, so only
+          // files synced after it reach the handler.
           source: `${adminPath}/file/:file*`,
           // Next's internal image optimizer does not follow redirects.
           destination: `${handlerUrl}?file=:file*&delivery=proxy`
-        }
-      ],
-      afterFiles: [
-        ...rewrites.afterFiles,
+        },
         {
           source: adminPath,
           destination: `${adminPath}.html`
@@ -141,13 +134,27 @@ function createRewrites(config, adminPath, handlerUrl) {
   };
 }
 function resolveSettings(config) {
-  const adminPath = config.env?.ALINEA_ADMIN_PATH ?? process.env.ALINEA_ADMIN_PATH;
+  const built = builtEnv(config);
+  const adminPath = config.env?.ALINEA_ADMIN_PATH ?? process.env.ALINEA_ADMIN_PATH ?? built?.ALINEA_ADMIN_PATH;
   if (!adminPath) return;
   return {
     adminPath: normalizeBasePath(adminPath),
-    handlerUrl: config.env?.ALINEA_HANDLER_URL ?? process.env.ALINEA_HANDLER_URL ?? "/api/cms"
+    handlerUrl: config.env?.ALINEA_HANDLER_URL ?? process.env.ALINEA_HANDLER_URL ?? built?.ALINEA_HANDLER_URL ?? "/api/cms"
   };
 }
+function builtEnv(config) {
+  if (process.env.NODE_ENV !== "production") return;
+  try {
+    const file = resolve(
+      config.distDir ?? ".next",
+      "required-server-files.json"
+    );
+    const built = JSON.parse(readFileSync(file, "utf-8"));
+    return built?.config?.env;
+  } catch {
+    return;
+  }
+}
 function normalizeBasePath(value) {
   return join("/", value, ".");
 }

package/dist/backend/CommitEntries.d.ts

@@ -0,0 +1,17 @@
+import type { DashboardEntry } from 'alinea/core/DashboardEntry';
+import type { Mutation } from 'alinea/core/db/Mutation';
+import type { Resolver } from 'alinea/core/Resolver';
+/** An entry that no longer exists after a commit */
+export interface RemovedEntry {
+    id: string;
+    type: string;
+    locale: string | null;
+    /** The url the entry had before the commit */
+    url: string;
+}
+/**
+ * The latest version, in every locale, of the entries that mutations change
+ */
+export declare function committedEntries(resolver: Resolver, mutations: ReadonlyArray<Mutation>): Promise<Array<DashboardEntry>>;
+/** The entries of `before` that are not in `after` */
+export declare function removedEntries(before: Array<DashboardEntry>, after: Array<DashboardEntry>): Array<RemovedEntry>;

package/dist/backend/CommitEntries.js

@@ -0,0 +1,39 @@
+import "../chunks/chunk-CQ52GEHY.js";
+
+// src/backend/CommitEntries.ts
+import { Entry } from "alinea/core/Entry";
+var select = {
+  id: Entry.id,
+  type: Entry.type,
+  title: Entry.title,
+  path: Entry.path,
+  url: Entry.url,
+  locale: Entry.locale,
+  status: Entry.status,
+  workspace: Entry.workspace,
+  root: Entry.root,
+  parentId: Entry.parentId,
+  data: Entry.data
+};
+function entryIds(mutations) {
+  const ids = mutations.map((mutation) => "id" in mutation ? mutation.id : "");
+  return [...new Set(ids.filter(Boolean))];
+}
+async function committedEntries(resolver, mutations) {
+  const ids = entryIds(mutations);
+  if (ids.length === 0) return [];
+  return await resolver.resolve({
+    id: { in: ids },
+    status: "preferDraft",
+    select
+  });
+}
+function removedEntries(before, after) {
+  const key = (entry) => `${entry.id}:${entry.locale}`;
+  const remaining = new Set(after.map(key));
+  return before.filter((entry) => !remaining.has(key(entry))).map(({ id, type, locale, url }) => ({ id, type, locale, url }));
+}
+export {
+  committedEntries,
+  removedEntries
+};

package/dist/backend/Handler.d.ts

@@ -1,16 +1,28 @@
 import type { CMS } from 'alinea/core/CMS';
 import type { AuthedContext, RemoteConnection, RequestContext } from 'alinea/core/Connection';
 import type { LocalStore } from 'alinea/core/db/LocalStore';
+import type { DashboardEntry } from 'alinea/core/DashboardEntry';
+import { type RemovedEntry } from './CommitEntries.js';
 import type { Mutation } from 'alinea/core/db/Mutation';
+import type { User } from 'alinea/core/User';
 export interface Handler {
     (request: Request, context: RequestContext): Promise<Response>;
 }
 export type HookResponse<T = void> = void | T | Promise<void | T>;
 export interface BeforeCommitContext {
     mutations: ReadonlyArray<Mutation>;
+    /** The user committing the mutations */
+    user: User;
 }
 export interface AfterCommitContext extends BeforeCommitContext {
     sha: string;
+    /**
+     * The entries the mutations changed as they are after the commit: the
+     * latest version in each locale
+     */
+    entries: Array<DashboardEntry>;
+    /** Entries that no longer exist after the commit, with the url they had */
+    removed: Array<RemovedEntry>;
 }
 export interface HandlerHooks {
     beforeCommit?(context: BeforeCommitContext): HookResponse<ReadonlyArray<Mutation>>;
@@ -20,6 +32,8 @@ export interface HandlerOptions extends HandlerHooks {
     cms: CMS;
     db: LocalStore | Promise<LocalStore>;
     remote?: (context: RequestContext) => RemoteConnection;
+    /** Log why and how long each sync took, for a deployed handler */
+    logSyncs?: boolean;
     forwardMutations?(request: Request, context: AuthedContext): Promise<Response | undefined>;
 }
-export declare function createHandler({ cms, remote, db, forwardMutations, ...hooks }: HandlerOptions): Handler;
+export declare function createHandler({ cms, remote, db, forwardMutations, logSyncs, ...hooks }: HandlerOptions): Handler;