alinea 2.0.0-preview.13 → 2.0.0-preview.14

package/dist/.init/content/pages/welcome.json

@@ -1,5 +1,5 @@
 {
-  "_id": "3Kd9mGx2n7q2f3qhMUmFsgaYVyu",
+  "_id": "3Kg2pCrguJIYIFElVMkyXOQsdZa",
   "_type": "Page",
   "_index": "a0",
   "_seeded": "welcome.json",

package/dist/.mcp/later/dev.json

@@ -1 +1 @@
-{"url":"http://localhost:1","pid":3062}
+{"url":"http://localhost:1","pid":3063}

package/dist/.mcp/online/dev.json

@@ -1 +1 @@
-{"url":"http://localhost:36863","pid":3062}
+{"url":"http://localhost:34865","pid":3063}

package/dist/adapter/next/cms.js

@@ -9,7 +9,7 @@ import {
   decodePreviewRequest
 } from "alinea/backend/resolver/ParsePreview";
 import { dashboardUrl } from "./dashboardUrl.js";
-import { createThrottledSync } from "alinea/backend/util/Syncable";
+import { createThrottledSync, syncWait } from "alinea/backend/util/Syncable";
 import { Client } from "alinea/core/Client";
 import { CMS } from "alinea/core/CMS";
 import {
@@ -18,6 +18,7 @@ import {
 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";
@@ -99,7 +100,10 @@ var NextCMS = class extends CMS {
         (row) => timed(row, () => this.#syncDb(db, client, void 0))
       );
     try {
-      const sha = await db.syncWith(client, preValidatedRemote);
+      const sha = await within(
+        db.syncWith(client, preValidatedRemote),
+        syncWait
+      );
       this.#syncedAt = Date.now();
       return sha;
     } catch (error) {

package/dist/adapter/next/context.js

@@ -15,13 +15,10 @@ 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),
+    handlerUrl: Config.serverHandlerUrl(config),
     apiKey,
     publicUrl: localOrigin ? new URL(localOrigin) : void 0
   };

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";
@@ -79,18 +80,28 @@ 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, user });
+      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/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,6 +1,8 @@
 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 {
@@ -14,6 +16,13 @@ export interface BeforeCommitContext {
 }
 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>>;

package/dist/backend/Handler.js

@@ -4,7 +4,7 @@ import {
   object,
   optional,
   string
-} from "../chunks/chunk-UPY2RUZF.js";
+} from "../chunks/chunk-TWBREZWC.js";
 import {
   PLazy
 } from "../chunks/chunk-IKINPSS5.js";
@@ -19,6 +19,10 @@ import {
 } from "alinea/core/BlobTransport";
 import { Config } from "alinea/core/Config";
 import { developmentKeyHeader } from "alinea/core/Connection";
+import {
+  committedEntries,
+  removedEntries
+} from "./CommitEntries.js";
 import { Entry } from "alinea/core/Entry";
 import { ErrorCode, HttpError } from "alinea/core/HttpError";
 import { MediaLocation } from "alinea/core/media/MediaLocation";
@@ -27,15 +31,18 @@ import { assertUploadSize } from "alinea/core/media/UploadLimits";
 import { Permission, Policy } from "alinea/core/Role";
 import { getScope } from "alinea/core/Scope";
 import { ShaMismatchError } from "alinea/core/source/ShaMismatchError";
+import { sourceAtTree } from "alinea/core/source/Source";
 import { base64 } from "alinea/core/util/Encoding";
+import { within } from "alinea/core/util/Async";
 import { isRecord } from "alinea/core/util/Objects";
-import { isAbsolute, normalize } from "alinea/core/util/Paths";
+import { fileVersions } from "alinea/core/util/EntryFilenames";
+import { isAbsolute, normalize, relative } from "alinea/core/util/Paths";
 import { InvalidCredentialsError, MissingCredentialsError } from "./Auth.js";
 import { HandleAction } from "./HandleAction.js";
 import { proxyMediaUrl } from "./api/ProxyMedia.js";
 import { applyPreview, decodePreviewRequest } from "./resolver/ParsePreview.js";
 import { compressResponse } from "./router/Router.js";
-import { createThrottledSync } from "./util/Syncable.js";
+import { createThrottledSync, syncWait } from "./util/Syncable.js";
 var PrepareBody = object({
   filename: string,
   size: optional(number)
@@ -53,9 +60,9 @@ function createHandler({
     const local = await db;
     const simulateLatency = process.env.ALINEA_LATENCY;
     if (simulateLatency) await new Promise((resolve) => setTimeout(resolve, 2e3));
-    async function syncForRead(cnx) {
+    async function syncForRead(sync) {
       try {
-        await local.syncWith(cnx);
+        await within(sync, syncWait);
       } catch (error) {
         console.warn(
           `Alinea could not sync with the remote, serving current content: ${error instanceof Error ? error.message : String(error)}`
@@ -64,7 +71,7 @@ function createHandler({
     }
     async function periodicSync(cnx, syncInterval) {
       if (dev) return;
-      return throttle(() => syncForRead(cnx), syncInterval);
+      return syncForRead(throttle(() => local.syncWith(cnx), syncInterval));
     }
     try {
       const previews = new JWTPreviews(context.apiKey);
@@ -258,7 +265,7 @@ function createHandler({
         } else {
           const preview = await decodePreviewRequest(query.preview);
           if ("contentHash" in preview && await local.sha !== preview.contentHash)
-            await syncForRead(cnx);
+            await syncForRead(local.syncWith(cnx));
           query.preview = await applyPreview(local, preview);
         }
         return Response.json(await local.resolve(query) ?? null);
@@ -278,59 +285,90 @@ function createHandler({
           user: user.claims
         });
         if (adjusted) mutations = adjusted;
+        const before = hooks.afterCommit ? await committedEntries(local, mutations) : [];
         const attempt = async (retry = 0) => {
           if (retry > 0) await local.syncWith(cnx);
           const request2 = {
             ...await local.request(mutations, policy),
             user: user.claims
           };
+          let sha2;
           try {
-            let { sha: sha2 } = await cnx.write(request2);
-            if (sha2 === request2.intoSha) {
-              await local.write(request2);
-            } else {
-              sha2 = await local.syncWith(cnx);
-            }
-            return sha2;
+            sha2 = (await cnx.write(request2)).sha;
           } catch (error) {
             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;
           }
+          try {
+            if (sha2 === request2.intoSha) await local.write(request2);
+            else sha2 = await local.syncWith(cnx);
+          } catch {
+            sha2 = await local.syncWith(cnx).catch(() => sha2);
+          }
+          return sha2;
         };
         const sha = await attempt();
         try {
-          await hooks.afterCommit?.({ mutations, sha, user: user.claims });
+          if (hooks.afterCommit) {
+            const entries = await committedEntries(local, mutations);
+            await hooks.afterCommit({
+              mutations,
+              sha,
+              user: user.claims,
+              entries,
+              removed: removedEntries(before, entries)
+            });
+          }
         } catch (error) {
           console.error("Alinea afterCommit hook failed", error);
         }
         return Response.json({ sha });
       }
       if (action === HandleAction.History && request.method === "GET") {
-        expectUser();
+        const user = expectUser();
         expectJson();
         const file = string(url.searchParams.get("file"));
         const revisionId = string.nullable(url.searchParams.get("revisionId"));
-        const result = await (revisionId ? cnx.revisionData(file, revisionId) : cnx.revisions(file));
+        const record = revisionId ? await cnx.revisionData(file, revisionId) : void 0;
+        const contentDir = Config.contentDir(cms.config);
+        const owners = () => historyEntries(local, contentDir, file, record);
+        let entries = await owners();
+        if (entries.length === 0) {
+          await syncForRead(local.syncWith(cnx));
+          entries = await owners();
+        }
+        if (entries.length === 0)
+          throw new HttpError(ErrorCode.NotFound, "Entry not found");
+        const policy = await user.policy;
+        for (const entry of entries) policy.assert(Permission.Read, entry);
+        const result = revisionId ? record : await cnx.revisions(file);
         return Response.json(result ?? null);
       }
       if (action === HandleAction.Tree && request.method === "GET") {
         expectJson();
         const sha = string(url.searchParams.get("sha"));
-        await syncForRead(cnx);
+        let source = cnx;
+        try {
+          const remoteTree = await cnx.getTreeIfDifferent(sha);
+          if (!remoteTree) return Response.json(null);
+          source = sourceAtTree(cnx, remoteTree);
+        } catch {
+        }
+        await syncForRead(local.syncWith(source));
         const tree = await local.getTreeIfDifferent(sha);
         return compressResponse(request, Response.json(tree ?? null));
       }
       if (action === HandleAction.Sha && request.method === "GET") {
         expectJson();
-        await syncForRead(cnx);
+        await syncForRead(local.syncWith(cnx));
         return Response.json(await local.sha);
       }
       if (action === HandleAction.Blob && request.method === "POST") {
         const { shas } = object({ shas: array(string) })(await body);
         let tree = await local.source.getTree();
         if (!dev && shas.some((sha) => !tree.hasSha(sha))) {
-          await syncForRead(cnx);
+          await syncForRead(local.syncWith(cnx));
           tree = await local.source.getTree();
         }
         const fromLocal = [];
@@ -421,6 +459,28 @@ function createHandler({
     }
   };
 }
+var historyResource = {
+  id: Entry.id,
+  type: Entry.type,
+  workspace: Entry.workspace,
+  root: Entry.root,
+  parents: Entry.parents,
+  locale: Entry.locale
+};
+async function historyEntries(local, contentDir, file, record) {
+  const filePath = relative(contentDir, file);
+  if (filePath.startsWith("../")) return [];
+  const status = "all";
+  const select = historyResource;
+  const atFile = await local.find({
+    filePath: { in: fileVersions(filePath) },
+    status,
+    select
+  });
+  const id = record?._id;
+  if (atFile.length > 0 || typeof id !== "string") return atFile;
+  return local.find({ id, status, select });
+}
 function redirectFile(location, cacheControl) {
   return new Response(null, {
     status: 307,

package/dist/backend/api/BasicAuth.js

@@ -42,7 +42,11 @@ var BasicAuth = class {
     const [scheme, token] = auth.split(" ", 2);
     if (scheme !== "Basic")
       throw new MissingCredentialsError("Invalid authorization scheme");
-    const [username, password] = atob(token).split(":");
+    const credentials = atob(token);
+    const colon = credentials.indexOf(":");
+    if (colon === -1) throw new InvalidCredentialsError("Invalid credentials");
+    const username = credentials.slice(0, colon);
+    const password = credentials.slice(colon + 1);
     const authorized = await this.#verify(username, password);
     if (!authorized) throw new InvalidCredentialsError("Invalid credentials");
     const user = typeof authorized === "boolean" ? {

package/dist/backend/api/CreateBackend.js

@@ -1,8 +1,8 @@
 import {
   driver_exports
-} from "../../chunks/chunk-4ZA6KZHS.js";
-import "../../chunks/chunk-VA6NC3MI.js";
+} from "../../chunks/chunk-6FQ5IMNA.js";
 import "../../chunks/chunk-A2I6MCCS.js";
+import "../../chunks/chunk-VA6NC3MI.js";
 import "../../chunks/chunk-RAR44T5O.js";
 import "../../chunks/chunk-PTYZMV5G.js";
 import "../../chunks/chunk-N47Y62CI.js";

package/dist/backend/api/DatabaseApi.js

@@ -2,12 +2,11 @@ import {
   include
 } from "../../chunks/chunk-XTWYBWP2.js";
 import {
-  blob,
   id,
   integer,
   text,
   varchar
-} from "../../chunks/chunk-5H4D5JQL.js";
+} from "../../chunks/chunk-2PP7WJUJ.js";
 import {
   Builder
 } from "../../chunks/chunk-2BJ2IFQM.js";
@@ -43,11 +42,11 @@ import { slugify } from "alinea/core/util/Slugs";
 import { HandleAction } from "../HandleAction.js";
 var UploadTable = table("alinea_upload", {
   entryId: varchar(void 0, { length: 27 }).primaryKey(),
-  content: blob().notNull()
+  content: largeBlob().notNull()
 });
 var UserTable = table("alinea_user", {
   id: id(),
-  email: text().notNull().unique(),
+  email: indexedText().notNull().unique(),
   name: text()
 });
 var UserRoleTable = table("alinea_user_role", {
@@ -61,7 +60,9 @@ var BlobTable = table("alinea_blob", {
   usedAt: integer().notNull()
 });
 var tables = [UploadTable, UserTable, UserRoleTable, BlobTable];
+var maxParams = 100;
 var blobsPerStatement = 50;
+var blobsPerInsert = Math.floor(maxParams / 3);
 var day = 24 * 60 * 60;
 var blobRetention = 30 * day;
 var blobCleanups = /* @__PURE__ */ new WeakMap();
@@ -141,7 +142,7 @@ var DatabaseApi = class {
     const db = await this.#db;
     const now = seconds();
     const unique = [...new Map(blobs)];
-    for (const batch of chunks(unique, blobsPerStatement)) {
+    for (const batch of chunks(unique, blobsPerInsert)) {
       const shas = batch.map(([sha]) => sha);
       const stored = new Set(
         await db.select(BlobTable.sha).from(BlobTable).where(inArray(BlobTable.sha, shas))
@@ -252,6 +253,18 @@ function largeBlob() {
     }
   });
 }
+function indexedText() {
+  return new Column({
+    type: new ColumnType(
+      "text",
+      [],
+      sql.universal({
+        mysql: sql`varchar(255)`,
+        default: sql`text`
+      })
+    )
+  });
+}
 async function renewBlobs(db, shas, now) {
   if (shas.length === 0) return;
   await db.update(BlobTable).set({ usedAt: now }).where(and(inArray(BlobTable.sha, shas), lt(BlobTable.usedAt, now - day)));

package/dist/backend/api/GithubApi.d.ts

@@ -3,6 +3,19 @@ import type { EntryRecord } from 'alinea/core/EntryRecord';
 import type { CommitRequest } from 'alinea/core/db/CommitRequest';
 import { GithubSource, type GithubSourceOptions } from 'alinea/core/source/GithubSource';
 export interface GithubOptions extends GithubSourceOptions {
+    /**
+     * Commit as this author instead of the account that owns the token. Such
+     * commits are written through the REST API, which GraphQL commits do not
+     * allow, so GitHub does not mark them as verified. A save usually spends
+     * three REST requests, plus one per uploaded file. Removing a file that is
+     * already gone costs one more tree request, and a branch that moved in
+     * the meantime repeats the save.
+     */
+    author?: GithubCommitAuthor;
+}
+export interface GithubCommitAuthor {
+    name: string;
+    email: string;
 }
 export declare class GithubApi extends GithubSource implements HistoryApi, CommitApi, SyncApi {
     #private;