alinea 2.0.0-preview.7 → 2.0.0-preview.9

package/dist/adapter/next/handler.js

@@ -10,43 +10,90 @@ import {
 import {
   createHandler as createCoreHandler
 } from "alinea/backend/Handler";
-import { generatedSource } from "alinea/backend/store/GeneratedSource";
+import { HandleAction } from "alinea/backend/HandleAction";
 import { JWTPreviews } from "alinea/backend/util/JWTPreviews";
 import { CloudRemote } from "alinea/cloud/CloudRemote";
+import { Client } from "alinea/core/Client";
 import { Config } from "alinea/core/Config";
-import { LocalDB } from "alinea/core/db/LocalDB";
+import {
+  developmentKeyHeader,
+  forwardedMutationHeader
+} from "alinea/core/Connection";
+import { HttpError } from "alinea/core/HttpError";
 import { trace } from "alinea/core/Trace";
 import { NextCMS } from "./cms.js";
 import { requestContext } from "./context.js";
-import { createDevRemote } from "./DevRemote.js";
 import { revalidateContentSha } from "./syncCheck.js";
-function createHandler(input) {
+function createHandlerWithDatabase(input, openGeneratedDatabase) {
   const options = input instanceof NextCMS ? { cms: input } : input;
   const config = options.cms.config;
   const backend = typeof options.backend === "function" ? options.backend : options.backend ? backendFromOptions(options.backend) : (context) => new CloudRemote(context, config);
-  const remote = (context) => context.isDev ? createDevRemote(context, config) : backend(context, config);
+  const remote = (context) => backend(context, config);
   const span = trace(config, "alinea.next.handler.db");
   const db = PLazy.from(
     () => span(async () => {
-      const source = await generatedSource;
-      const db2 = new LocalDB(config, source);
-      await db2.sync();
-      return db2;
+      if (process.env.NEXT_RUNTIME === "edge")
+        throw new Error(
+          "The Alinea handler is not supported in Edge runtime environments."
+        );
+      if (!openGeneratedDatabase)
+        throw new Error(
+          "A generated database loader is required. Import createHandler from 'alinea/next'."
+        );
+      return openGeneratedDatabase(config);
     })
   );
+  const afterCommit = async (context) => {
+    await revalidateContentSha();
+    await options.afterCommit?.(context);
+  };
   const handleBackend = createCoreHandler({
     ...options,
     remote,
     db,
-    // Revalidate the shared content sha before the user-provided hook so
-    // page revalidation triggered there already sees the fresh sha when
-    // RSC renders resolve. Invalidation never throws (failures are
-    // swallowed inside revalidateContentSha).
-    afterCommit: async (context) => {
-      await revalidateContentSha();
-      await options.afterCommit?.(context);
-    }
+    afterCommit
   });
+  async function handleDevelopment(request, context) {
+    const action = new URL(request.url).searchParams.get("action");
+    if (action !== HandleAction.Mutate || request.method !== "POST")
+      return failure(404, "Answered by the Alinea dev server");
+    const developmentKey = request.headers.get(developmentKeyHeader);
+    if (!context.apiKey || developmentKey !== context.apiKey)
+      return failure(401, "Invalid development credentials");
+    let mutations;
+    try {
+      mutations = await request.json();
+    } catch {
+      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,
+      applyAuth(init) {
+        const authorized = context.applyAuth?.(init) ?? init ?? {};
+        const headers = new Headers(authorized.headers);
+        headers.set(forwardedMutationHeader, "true");
+        return { ...authorized, headers };
+      }
+    });
+    let sha;
+    try {
+      ;
+      ({ sha } = await devServer.mutate(mutations));
+    } catch (error) {
+      if (error instanceof HttpError) return failure(error.code, error.message);
+      throw error;
+    }
+    try {
+      await afterCommit({ mutations, sha });
+    } catch (error) {
+      console.error("Alinea afterCommit hook failed", error);
+    }
+    return Response.json({ sha });
+  }
   const handle = async (request) => {
     const url = new URL(request.url);
     const context = await requestContext(config, request);
@@ -58,6 +105,11 @@ function createHandler(input) {
         backendUrl.pathname = handlerPath;
         backendUrl.searchParams.set("file", rewrittenFile);
         backendUrl.searchParams.set("delivery", "proxy");
+        if (context.isDev) {
+          const devUrl = new URL(context.handlerUrl);
+          devUrl.search = backendUrl.search;
+          return Response.redirect(devUrl, 307);
+        }
         return await handleBackend(new Request(backendUrl, request), context);
       }
       if (url.pathname !== handlerPath)
@@ -85,6 +137,7 @@ function createHandler(input) {
           headers: { location: String(location) }
         });
       }
+      if (context.isDev) return await handleDevelopment(request, context);
       return await handleBackend(request, context);
     } catch (error) {
       console.error(error);
@@ -93,6 +146,9 @@ function createHandler(input) {
   };
   return handle;
 }
+function failure(status, error) {
+  return Response.json({ success: false, error }, { status });
+}
 function handlerPathname(config, requestUrl) {
   return new URL(Config.handlerUrl(config), requestUrl).pathname;
 }
@@ -108,7 +164,11 @@ function rewrittenFilePath(config, request) {
     return;
   }
 }
+function createHandler(input) {
+  return createHandlerWithDatabase(input);
+}
 export {
   createHandler,
+  createHandlerWithDatabase,
   handlerPathname
 };

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

@@ -0,0 +1,5 @@
+import type { Config } from 'alinea/core/Config';
+import { NextCMS } from './cms.js';
+import { type NextHandlerOptions } from './handler.js';
+export declare function createCMS<Definition extends Config>(config: Definition): NextCMS<Definition>;
+export declare function createHandler(input: NextCMS | NextHandlerOptions): (request: Request) => Promise<Response>;

package/dist/adapter/next/node.js

@@ -0,0 +1,16 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/adapter/next/node.ts
+import { generatedDatabase } from "alinea/backend/store/GeneratedDatabaseNode";
+import { NextCMS } from "./cms.js";
+import { createHandlerWithDatabase } from "./handler.js";
+function createCMS(config) {
+  return new NextCMS(config, generatedDatabase);
+}
+function createHandler(input) {
+  return createHandlerWithDatabase(input, generatedDatabase);
+}
+export {
+  createCMS,
+  createHandler
+};

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

@@ -1,10 +1,13 @@
+import { type PreviewStats } from 'alinea/preview/widget';
 export interface NextPreviewsProps {
     dashboardUrl: string;
     widget?: boolean;
+    /** Resolves once the render's CMS queries settled. */
+    stats?: Promise<PreviewStats>;
     root?: string;
     workspace?: string;
 }
-export default function NextPreviews({ dashboardUrl, widget, root, workspace }: NextPreviewsProps): import("react").JSX.Element | null;
+export default function NextPreviews({ dashboardUrl, widget, stats, root, workspace }: NextPreviewsProps): import("react").JSX.Element | null;
 /**
  * Wrapper around `router.refresh()` from `next/navigation` `useRouter()` to return Promise, and resolve after refresh completed
  * @returns Refresh function

package/dist/adapter/next/previews.js

@@ -11,12 +11,14 @@ import { jsx } from "react/jsx-runtime";
 function NextPreviews({
   dashboardUrl,
   widget,
+  stats,
   root,
   workspace
 }) {
   const refresh = useRouterRefresh();
   const [isLoading, setIsLoading] = useState(false);
   const [previewDisabled, setPreviewDisabled] = useState(false);
+  const [renderStats, setRenderStats] = useState();
   const pathname = usePathname();
   const adminUrl = new URL(dashboardUrl, location.origin);
   const host = window.parent !== window ? window.parent : window.opener;
@@ -43,13 +45,23 @@ function NextPreviews({
   useEffect(() => {
     if (widget) registerPreviewWidget();
   }, [widget]);
+  useEffect(() => {
+    let current = true;
+    stats?.then((value) => {
+      if (current) setRenderStats(JSON.stringify(value));
+    });
+    return () => {
+      current = false;
+    };
+  }, [stats]);
   if (!widget) return null;
   return /* @__PURE__ */ jsx(
     "alinea-preview",
     {
       adminUrl: String(adminUrl),
       editUrl: String(editUrl),
-      livePreview: isPreviewing ? isLoading ? "loading" : previewDisabled ? "warning" : "connected" : void 0
+      livePreview: isPreviewing ? isLoading ? "loading" : previewDisabled ? "warning" : "connected" : void 0,
+      stats: renderStats
     }
   );
 }

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

@@ -0,0 +1,45 @@
+import type { GraphQuery } from 'alinea/core/Graph';
+import type { PreviewDatabase, PreviewStat, PreviewStatement, PreviewStats } from 'alinea/preview/widget';
+/** Collects the CMS queries and syncs of one draft render. */
+export declare class RenderStats {
+    #private;
+    rows: Array<PreviewStat>;
+    statements: number;
+    sqlMs: number;
+    slowest: Array<PreviewStatement>;
+    /** The bundled database that answered, once a query reached it. */
+    database?: PreviewDatabase;
+    readonly startedAt: number;
+    /** Add a row and count it as pending until `run` settles; see `timed`. */
+    track<T>(stat: Omit<PreviewStat, 'durationMs'>, run: (row: PreviewStat) => Promise<T>): Promise<T>;
+    /**
+     * Time a database query without the time it waited behind the others:
+     * queries of a render run one at a time in the order they were called, so
+     * one starts executing once the previous one finished, or when it was
+     * called if that is later.
+     */
+    executed<T>(row: PreviewStat, run: () => Promise<T>): Promise<T>;
+    /**
+     * Count a statement towards the render, and towards the row that ran it:
+     * a sync in progress, or else the query executing, which is the earliest
+     * one called that has not finished (see `executed`).
+     */
+    statement(durationMs: number, sql?: string): void;
+    /**
+     * Resolves once nothing ran for `quietMs`, so queries of server components
+     * that render after the caller are counted, or after `maxMs` regardless.
+     */
+    settled(quietMs?: number, maxMs?: number): Promise<PreviewStats>;
+}
+/**
+ * A statement short enough to read in a table, such as
+ * `select … from alinea_entry_index where (visible = ? and id in (?))`.
+ */
+export declare function summarizeSql(sql: string, maxLength?: number): string;
+/**
+ * Time the work a row stands for from call to answer, such as a sync or a
+ * query the handler answers, without the sync it waited for.
+ */
+export declare function timed<T>(row: PreviewStat | undefined, run: () => Promise<T>): Promise<T>;
+/** A short description such as `first(type, url=/about)`. */
+export declare function summarizeQuery(query: GraphQuery): string;

package/dist/adapter/next/renderStats.js

@@ -0,0 +1,142 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/adapter/next/renderStats.ts
+var slowestCount = 5;
+var RenderStats = class {
+  rows = [];
+  statements = 0;
+  sqlMs = 0;
+  slowest = [];
+  /** The bundled database that answered, once a query reached it. */
+  database;
+  startedAt = Date.now();
+  #pending = 0;
+  #idleSince = Date.now();
+  #renderStart = Number.POSITIVE_INFINITY;
+  #renderEnd = Number.NEGATIVE_INFINITY;
+  #executedUntil = Number.NEGATIVE_INFINITY;
+  /** Syncs in progress: their statements run before any query's. */
+  #syncing = [];
+  /** Queries executing or waiting to, in the order they run. */
+  #executing = [];
+  /** Add a row and count it as pending until `run` settles; see `timed`. */
+  async track(stat, run) {
+    const row = { ...stat, durationMs: 0 };
+    this.rows.push(row);
+    this.#pending++;
+    this.#renderStart = Math.min(this.#renderStart, performance.now());
+    if (row.kind === "sync") this.#syncing.push(row);
+    try {
+      return await run(row);
+    } finally {
+      if (row.kind === "sync") remove(this.#syncing, row);
+      this.#pending--;
+      this.#idleSince = Date.now();
+      this.#renderEnd = Math.max(this.#renderEnd, performance.now());
+    }
+  }
+  /**
+   * Time a database query without the time it waited behind the others:
+   * queries of a render run one at a time in the order they were called, so
+   * one starts executing once the previous one finished, or when it was
+   * called if that is later.
+   */
+  async executed(row, run) {
+    const start = performance.now();
+    this.#executing.push(row);
+    try {
+      return await run();
+    } finally {
+      remove(this.#executing, row);
+      const end = performance.now();
+      row.durationMs = end - Math.max(start, this.#executedUntil);
+      this.#executedUntil = end;
+    }
+  }
+  /**
+   * Count a statement towards the render, and towards the row that ran it:
+   * a sync in progress, or else the query executing, which is the earliest
+   * one called that has not finished (see `executed`).
+   */
+  statement(durationMs, sql) {
+    this.statements++;
+    this.sqlMs += durationMs;
+    const row = this.#syncing.at(-1) ?? this.#executing[0];
+    if (row) {
+      row.statements = (row.statements ?? 0) + 1;
+      row.sqlMs = (row.sqlMs ?? 0) + durationMs;
+    }
+    if (sql === void 0) return;
+    const { slowest } = this;
+    if (slowest.length >= slowestCount && durationMs <= slowest[slowest.length - 1].durationMs)
+      return;
+    slowest.push({ sql: summarizeSql(sql), durationMs, query: row?.summary });
+    slowest.sort((a, b) => b.durationMs - a.durationMs);
+    slowest.length = Math.min(slowest.length, slowestCount);
+  }
+  /**
+   * Resolves once nothing ran for `quietMs`, so queries of server components
+   * that render after the caller are counted, or after `maxMs` regardless.
+   */
+  async settled(quietMs = 50, maxMs = 5e3) {
+    const deadline = Date.now() + maxMs;
+    for (let now = Date.now(); now < deadline; now = Date.now()) {
+      const wait = this.#pending > 0 ? quietMs : this.#idleSince + quietMs - now;
+      if (wait <= 0) break;
+      await new Promise(
+        (resolve) => setTimeout(resolve, Math.min(wait, deadline - now))
+      );
+    }
+    const { rows, statements, sqlMs, slowest, database } = this;
+    const renderMs = Math.max(0, this.#renderEnd - this.#renderStart);
+    return {
+      rows: rows.map((row) => ({ ...row })),
+      statements,
+      sqlMs,
+      renderMs,
+      slowest: [...slowest],
+      database
+    };
+  }
+};
+function summarizeSql(sql, maxLength = 200) {
+  const text = sql.replace(/\s+/g, " ").replaceAll('"', "").replace(/^select .*? from /i, "select \u2026 from ").replace(/\b\w+\.(\w+)/g, "$1").trim();
+  return text.length > maxLength ? `${text.slice(0, maxLength - 1)}\u2026` : text;
+}
+async function timed(row, run) {
+  if (!row) return run();
+  const start = performance.now();
+  try {
+    return await run();
+  } finally {
+    row.durationMs += performance.now() - start;
+  }
+}
+var unlisted = /* @__PURE__ */ new Set([
+  "first",
+  "get",
+  "count",
+  "select",
+  "include",
+  "status",
+  "preview",
+  "syncInterval",
+  "disableSync"
+]);
+function summarizeQuery(query) {
+  const mode = query.count ? "count" : query.get ? "get" : query.first ? "first" : "find";
+  const parts = Object.entries(query).filter(([key, value]) => !unlisted.has(key) && value !== void 0).map(
+    ([key, value]) => typeof value === "string" || typeof value === "number" ? `${key}=${value}` : key
+  );
+  return `${mode}(${parts.join(", ")})`;
+}
+function remove(items, item) {
+  const index = items.indexOf(item);
+  if (index !== -1) items.splice(index, 1);
+}
+export {
+  RenderStats,
+  summarizeQuery,
+  summarizeSql,
+  timed
+};

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

@@ -1,5 +1,10 @@
 import type { Client } from 'alinea/core/Client';
-import type { LocalDB } from 'alinea/core/db/LocalDB';
+import type { SyncOptions } from 'alinea/core/db/LocalStore';
+import type { RemoteSource } from 'alinea/core/source/Source';
+interface SyncableDB {
+    readonly sha: string | Promise<string>;
+    syncWith(source: RemoteSource, options?: SyncOptions): Promise<string>;
+}
 export declare const CONTENT_SHA_TAG = "alinea-content-sha";
 export declare function revalidateContentSha(): Promise<void>;
 /**
@@ -9,4 +14,5 @@ export declare function revalidateContentSha(): Promise<void>;
  * Returns false when the sha could not be determined, so the caller falls
  * back to its existing throttle behavior.
  */
-export declare function syncIfStale(db: LocalDB, client: Client, syncInterval?: number): Promise<boolean>;
+export declare function syncIfStale(db: SyncableDB, client: Client, syncInterval?: number, options?: SyncOptions): Promise<boolean>;
+export {};

package/dist/adapter/next/syncCheck.js

@@ -1,10 +1,8 @@
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/adapter/next/syncCheck.ts
-import { ReadonlyTree } from "alinea/core/source/Tree";
 var CONTENT_SHA_TAG = "alinea-content-sha";
 var SHA_REVALIDATE_SECONDS = 60;
-var SENTINEL_SHA = ReadonlyTree.EMPTY.sha;
 var inflight;
 function latestSha(client) {
   if (inflight) return inflight;
@@ -17,18 +15,14 @@ async function loadLatestSha(client) {
   try {
     const { unstable_cache } = await import("next/cache.js");
     const getSha = unstable_cache(
-      async () => {
-        const tree = await client.getTreeIfDifferent(SENTINEL_SHA);
-        return tree?.sha;
-      },
+      () => client.getSha(),
       ["alinea-content-sha"],
       { revalidate: SHA_REVALIDATE_SECONDS, tags: [CONTENT_SHA_TAG] }
     );
     return await getSha();
   } catch {
     try {
-      const tree = await client.getTreeIfDifferent(SENTINEL_SHA);
-      return tree?.sha;
+      return await client.getSha();
     } catch {
       return void 0;
     }
@@ -41,15 +35,15 @@ async function revalidateContentSha() {
   } catch {
   }
 }
-async function syncIfStale(db, client, syncInterval) {
+async function syncIfStale(db, client, syncInterval, options) {
   if (syncInterval === Number.POSITIVE_INFINITY) return true;
   if (syncInterval === 0) {
-    await db.syncWith(client);
+    await db.syncWith(client, options);
     return true;
   }
   const expected = await latestSha(client);
   if (!expected) return false;
-  if (expected !== db.sha) await db.syncWith(client);
+  if (expected !== await db.sha) await db.syncWith(client, options);
   return true;
 }
 export {

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

@@ -27,7 +27,6 @@ function withAlinea(config = {}) {
   } catch {
     console.warn("Alinea could not determine Next.js version, assuming 15+");
   }
-  const redirects = adminPath ? createRedirects(config, adminPath) : config.redirects;
   const rewrites = adminPath ? createRewrites(config, adminPath, settings.handlerUrl) : config.rewrites;
   const images = adminPath ? createImages(config, adminPath) : config.images;
   const env = settings ? {
@@ -42,10 +41,10 @@ function withAlinea(config = {}) {
         ...config.experimental,
         serverComponentsExternalPackages: [
           ...config.experimental?.serverComponentsExternalPackages ?? [],
-          "@alinea/generated"
+          "@alinea/generated",
+          "@alinea/sqlite-wasm"
         ]
       },
-      redirects,
       rewrites,
       images,
       env
@@ -54,9 +53,11 @@ function withAlinea(config = {}) {
     ...config,
     serverExternalPackages: [
       ...config.serverExternalPackages ?? [],
-      "@alinea/generated"
+      "@alinea/generated",
+      // Loads its native extension from the package directory, which file
+      // tracing then includes.
+      "@alinea/sqlite-wasm"
     ],
-    redirects,
     rewrites,
     images,
     env
@@ -82,21 +83,6 @@ function createImages(config, adminPath) {
     ]
   };
 }
-function createRedirects(config, adminPath) {
-  const dev = process.env.ALINEA_DEV_SERVER;
-  if (!dev) return config.redirects;
-  return async () => {
-    const existing = config.redirects ? await config.redirects() : [];
-    return [
-      ...existing,
-      {
-        permanent: true,
-        source: `${adminPath}/~dev`,
-        destination: `${dev}/~dev`
-      }
-    ];
-  };
-}
 var emptyRewrites = {
   beforeFiles: [],
   afterFiles: [],

package/dist/backend/HandleAction.d.ts

@@ -11,6 +11,6 @@ export declare enum HandleAction {
     Mutate = "mutate",
     Upload = "upload",
     Tree = "tree",
-    Commit = "commit",
+    Sha = "sha",
     Blob = "blob"
 }

package/dist/backend/HandleAction.js

@@ -14,7 +14,7 @@ var HandleAction = /* @__PURE__ */ ((HandleAction2) => {
   HandleAction2["Mutate"] = "mutate";
   HandleAction2["Upload"] = "upload";
   HandleAction2["Tree"] = "tree";
-  HandleAction2["Commit"] = "commit";
+  HandleAction2["Sha"] = "sha";
   HandleAction2["Blob"] = "blob";
   return HandleAction2;
 })(HandleAction || {});

package/dist/backend/Handler.d.ts

@@ -1,6 +1,6 @@
 import type { CMS } from 'alinea/core/CMS';
 import type { AuthedContext, RemoteConnection, RequestContext } from 'alinea/core/Connection';
-import { LocalDB } from 'alinea/core/db/LocalDB';
+import type { LocalStore } from 'alinea/core/db/LocalStore';
 import type { Mutation } from 'alinea/core/db/Mutation';
 export interface Handler {
     (request: Request, context: RequestContext): Promise<Response>;
@@ -18,7 +18,7 @@ export interface HandlerHooks {
 }
 export interface HandlerOptions extends HandlerHooks {
     cms: CMS;
-    db: LocalDB | Promise<LocalDB>;
+    db: LocalStore | Promise<LocalStore>;
     remote?: (context: RequestContext) => RemoteConnection;
     forwardMutations?(request: Request, context: AuthedContext): Promise<Response | undefined>;
 }