alinea 2.0.0-preview.9 → 2.0.0-rc2

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,23 +19,31 @@ import {
 } from "alinea/core/BlobTransport";
 import { Config } from "alinea/core/Config";
 import { developmentKeyHeader } from "alinea/core/Connection";
+import { loggedSync } from "alinea/core/db/SyncStats";
+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";
-import { MediaFile } from "alinea/core/media/MediaTypes";
+import { FileData } from "alinea/core/media/MediaTypes";
 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)
@@ -45,6 +53,7 @@ function createHandler({
   remote = (context) => new CloudRemote(context, cms.config),
   db,
   forwardMutations,
+  logSyncs = false,
   ...hooks
 }) {
   const throttle = createThrottledSync();
@@ -53,18 +62,22 @@ 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(sync2) {
       try {
-        await local.syncWith(cnx);
+        await within(sync2, syncWait);
       } catch (error) {
         console.warn(
           `Alinea could not sync with the remote, serving current content: ${error instanceof Error ? error.message : String(error)}`
         );
       }
     }
+    function sync(remote2, reason) {
+      if (dev || !logSyncs) return local.syncWith(remote2);
+      return loggedSync(local, remote2, reason);
+    }
     async function periodicSync(cnx, syncInterval) {
       if (dev) return;
-      return throttle(() => syncForRead(cnx), syncInterval);
+      return syncForRead(throttle(() => sync(cnx, "interval"), syncInterval));
     }
     try {
       const previews = new JWTPreviews(context.apiKey);
@@ -102,11 +115,11 @@ function createHandler({
           url: Entry.url,
           filePath: Entry.filePath,
           workspace: Entry.workspace,
-          location: MediaFile.location,
-          previewUrl: MediaFile.previewUrl
+          location: FileData.location,
+          previewUrl: FileData.previewUrl
         };
         const query = {
-          type: MediaFile,
+          type: Config.fileTypes(cms.config),
           status: "published",
           main: true,
           select
@@ -152,7 +165,7 @@ function createHandler({
         if (!source || source === requestedUrl)
           return new Response("Not found", { status: 404 });
         if (!proxy) return redirectFile(source, "public, max-age=60");
-        const deliveryBase = !context.isDev && Config.baseUrl(cms.config, "production") || context.handlerUrl;
+        const deliveryBase = context.publicUrl ?? (context.isDev ? context.handlerUrl : new URL(request.url));
         return proxyMedia(
           new URL(source, deliveryBase).href,
           "public, max-age=60"
@@ -258,7 +271,9 @@ function createHandler({
         } else {
           const preview = await decodePreviewRequest(query.preview);
           if ("contentHash" in preview && await local.sha !== preview.contentHash)
-            await syncForRead(cnx);
+            await syncForRead(
+              sync(cnx, `preview at ${preview.contentHash.slice(0, 7)}`)
+            );
           query.preview = await applyPreview(local, preview);
         }
         return Response.json(await local.resolve(query) ?? null);
@@ -272,64 +287,101 @@ function createHandler({
         expectJson();
         const policy = await user.policy;
         let mutations = await body;
-        await local.syncWith(cnx);
-        const adjusted = await hooks.beforeCommit?.({ mutations });
+        await sync(cnx, "commit");
+        const adjusted = await hooks.beforeCommit?.({
+          mutations,
+          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);
+          if (retry > 0) await sync(cnx, "commit retry");
           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 sync(cnx, "after commit");
+          } catch {
+            sha2 = await sync(cnx, "after commit").catch(() => sha2);
+          }
+          return sha2;
         };
         const sha = await attempt();
         try {
-          await hooks.afterCommit?.({
-            mutations,
-            sha
-          });
+          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(sync(cnx, "history of an unknown entry"));
+          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;
+        const start = performance.now();
+        try {
+          const remoteTree = await cnx.getTreeIfDifferent(sha);
+          if (!remoteTree) return Response.json(null);
+          source = sourceAtTree(cnx, remoteTree);
+        } catch {
+        }
+        const remoteMs = Math.round(performance.now() - start);
+        const reason = `tree from ${sha.slice(0, 7)}, remote tree ${remoteMs} ms`;
+        await syncForRead(sync(source, reason));
         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(sync(cnx, "sha"));
         return Response.json(await local.sha);
       }
       if (action === HandleAction.Blob && request.method === "POST") {
         const { shas } = object({ shas: array(string) })(await body);
-        await periodicSync(cnx);
-        const tree = await local.source.getTree();
+        let tree = await local.source.getTree();
+        if (!dev && shas.some((sha) => !tree.hasSha(sha))) {
+          await syncForRead(sync(cnx, "blobs of a newer tree"));
+          tree = await local.source.getTree();
+        }
         const fromLocal = [];
         const fromRemote = [];
         for (const sha of shas) {
@@ -418,6 +470,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/BlobStore.d.ts

@@ -0,0 +1,21 @@
+import type { CommitApi, SyncApi } from 'alinea/core/Connection';
+/**
+ * Content blobs kept where every handler instance finds them, such as the
+ * backend database: an instance that is behind reads what another one
+ * fetched or committed, instead of fetching it from the remote again.
+ */
+export interface BlobStore {
+    /** The stored blobs among `shas`. */
+    readBlobs(shas: ReadonlyArray<string>): Promise<Map<string, Uint8Array>>;
+    /** Keep blobs, found again by their sha. */
+    storeBlobs(blobs: ReadonlyArray<[sha: string, blob: Uint8Array]>): Promise<void>;
+}
+export declare function isBlobStore<T extends object>(value: T): value is T & BlobStore;
+/**
+ * Answer from the store what it has, and fetch the rest from the remote,
+ * storing it. The store only saves requests: when it fails, the remote
+ * answers instead.
+ */
+export declare function storedBlobs(store: BlobStore, getBlobs: SyncApi['getBlobs']): SyncApi['getBlobs'];
+/** Commit through the remote, and store the committed content. */
+export declare function storedWrites(store: BlobStore, write: CommitApi['write']): CommitApi['write'];

package/dist/backend/api/BlobStore.js

@@ -0,0 +1,63 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/backend/api/BlobStore.ts
+import { hashBlob } from "alinea/core/source/GitUtils";
+var storeBatch = 100;
+function isBlobStore(value) {
+  return "readBlobs" in value && typeof value.readBlobs === "function" && "storeBlobs" in value && typeof value.storeBlobs === "function";
+}
+function storedBlobs(store, getBlobs) {
+  return async function* (shas, options) {
+    const stored = await store.readBlobs(shas).catch((error) => {
+      console.warn("Alinea could not read stored blobs", error);
+      return /* @__PURE__ */ new Map();
+    });
+    for (const sha of shas) {
+      const blob = stored.get(sha);
+      if (blob) yield [sha, blob];
+    }
+    const missing = shas.filter((sha) => !stored.has(sha));
+    if (missing.length === 0) return;
+    let fetched = Array();
+    const keep = async () => {
+      const blobs = fetched;
+      fetched = [];
+      if (blobs.length > 0) await keepBlobs(store, blobs);
+    };
+    try {
+      for await (const entry of getBlobs(missing, options)) {
+        fetched.push(entry);
+        if (fetched.length >= storeBatch) await keep();
+        yield entry;
+      }
+    } finally {
+      await keep();
+    }
+  };
+}
+function storedWrites(store, write) {
+  return async (request) => {
+    const result = await write(request);
+    const encoder = new TextEncoder();
+    const blobs = Array();
+    for (const change of request.changes) {
+      if (change.op !== "addContent") continue;
+      const blob = encoder.encode(change.contents);
+      if (await hashBlob(blob) === change.sha) blobs.push([change.sha, blob]);
+    }
+    if (blobs.length > 0) await keepBlobs(store, blobs);
+    return result;
+  };
+}
+async function keepBlobs(store, blobs) {
+  try {
+    await store.storeBlobs(blobs);
+  } catch (error) {
+    console.warn("Alinea could not store blobs", error);
+  }
+}
+export {
+  isBlobStore,
+  storedBlobs,
+  storedWrites
+};

package/dist/backend/api/CreateBackend.js

@@ -1,15 +1,15 @@
 import {
   driver_exports
-} from "../../chunks/chunk-QJGGYF6E.js";
-import "../../chunks/chunk-QSN6RH6X.js";
-import "../../chunks/chunk-ETWOY4AL.js";
-import "../../chunks/chunk-66YZ47TY.js";
-import "../../chunks/chunk-AIU6CMVT.js";
+} from "../../chunks/chunk-4ZA6KZHS.js";
+import "../../chunks/chunk-VA6NC3MI.js";
+import "../../chunks/chunk-A2I6MCCS.js";
+import "../../chunks/chunk-RAR44T5O.js";
+import "../../chunks/chunk-PTYZMV5G.js";
 import "../../chunks/chunk-N47Y62CI.js";
 import "../../chunks/chunk-QBPYWU6C.js";
 import "../../chunks/chunk-2BJ2IFQM.js";
 import "../../chunks/chunk-XCZXR3C2.js";
-import "../../chunks/chunk-MOWR65LM.js";
+import "../../chunks/chunk-PYDOMKJZ.js";
 import "../../chunks/chunk-76VMZTLN.js";
 import "../../chunks/chunk-2PIFHEYR.js";
 import "../../chunks/chunk-K62JP6HR.js";
@@ -20,6 +20,7 @@ import "../../chunks/chunk-CQ52GEHY.js";
 // src/backend/api/CreateBackend.ts
 import { assert } from "alinea/core/util/Assert";
 import { BasicAuth } from "./BasicAuth.js";
+import { isBlobStore, storedBlobs, storedWrites } from "./BlobStore.js";
 import { DatabaseApi } from "./DatabaseApi.js";
 import { GithubApi } from "./GithubApi.js";
 import { OAuth2 } from "./OAuth2.js";
@@ -65,13 +66,14 @@ function composeBackend(...impl) {
       throw new Error(`Backend does not implement ${name}`);
     };
   };
+  const blobStore = impl.find(isBlobStore);
   return {
     authenticate: call("authenticate"),
     verify: call("verify"),
     capabilities: call("capabilities"),
     getTreeIfDifferent: call("getTreeIfDifferent"),
-    getBlobs: call("getBlobs"),
-    write: call("write"),
+    getBlobs: blobStore ? storedBlobs(blobStore, call("getBlobs")) : call("getBlobs"),
+    write: blobStore ? storedWrites(blobStore, call("write")) : call("write"),
     revisions: call("revisions"),
     revisionData: call("revisionData"),
     getDraft: call("getDraft"),

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

@@ -2,10 +2,11 @@ import type { DraftsApi, RequestContext, UploadResponse, UploadsApi, UserApi } f
 import { type Draft, type DraftKey } from 'alinea/core/Draft';
 import type { User, UserInput } from 'alinea/core/User';
 import { type Database } from 'rado';
+import type { BlobStore } from './BlobStore.js';
 export interface DatabaseOptions {
     db: Database;
 }
-export declare class DatabaseApi implements DraftsApi, UploadsApi, UserApi {
+export declare class DatabaseApi implements DraftsApi, UploadsApi, UserApi, BlobStore {
     #private;
     constructor(context: RequestContext, { db }: DatabaseOptions);
     getDraft(draftKey: DraftKey): Promise<Draft | undefined>;
@@ -13,6 +14,8 @@ export declare class DatabaseApi implements DraftsApi, UploadsApi, UserApi {
     prepareUpload(file: string): Promise<UploadResponse>;
     handleUpload(entryId: string, file: Blob): Promise<void>;
     previewUpload(entryId: string): Promise<Response>;
+    readBlobs(shas: ReadonlyArray<string>): Promise<Map<string, Uint8Array>>;
+    storeBlobs(blobs: ReadonlyArray<[sha: string, blob: Uint8Array]>): Promise<void>;
     enrichUser(user: User): Promise<User>;
     listUsers(): Promise<Array<User>>;
     createUser(user: UserInput): Promise<User>;

package/dist/backend/api/DatabaseApi.js

@@ -2,21 +2,25 @@ import {
   include
 } from "../../chunks/chunk-XTWYBWP2.js";
 import {
-  blob,
   id,
   integer,
   text,
   varchar
-} from "../../chunks/chunk-ASYKC6IE.js";
+} from "../../chunks/chunk-2PP7WJUJ.js";
 import {
   Builder
 } from "../../chunks/chunk-2BJ2IFQM.js";
 import {
-  eq
+  and,
+  eq,
+  inArray,
+  lt
 } from "../../chunks/chunk-XCZXR3C2.js";
 import {
+  Column,
+  ColumnType,
   table
-} from "../../chunks/chunk-MOWR65LM.js";
+} from "../../chunks/chunk-PYDOMKJZ.js";
 import "../../chunks/chunk-76VMZTLN.js";
 import "../../chunks/chunk-2PIFHEYR.js";
 import "../../chunks/chunk-K62JP6HR.js";
@@ -33,22 +37,35 @@ import "../../chunks/chunk-CQ52GEHY.js";
 import { createId } from "alinea/core/Id";
 import { assert } from "alinea/core/util/Assert";
 import { basename, extname } from "alinea/core/util/Paths";
+import { chunks } from "alinea/core/util/Arrays";
 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", {
   userId: integer().notNull().references(UserTable.id),
   role: text().notNull()
 });
-var tables = [UploadTable, UserTable, UserRoleTable];
+var BlobTable = table("alinea_blob", {
+  sha: varchar(void 0, { length: 40 }).primaryKey(),
+  content: largeBlob().notNull(),
+  /** When the blob was last stored or read, in seconds */
+  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();
 var preparedDatabases = /* @__PURE__ */ new WeakMap();
 var selectUser = {
   ...UserTable,
@@ -108,6 +125,35 @@ var DatabaseApi = class {
       }
     });
   }
+  async readBlobs(shas) {
+    const db = await this.#db;
+    const found = /* @__PURE__ */ new Map();
+    for (const batch of chunks(shas, blobsPerStatement)) {
+      const rows = await db.select({ sha: BlobTable.sha, content: BlobTable.content }).from(BlobTable).where(inArray(BlobTable.sha, batch));
+      for (const row of rows) found.set(row.sha, row.content);
+    }
+    const now = seconds();
+    for (const batch of chunks([...found.keys()], blobsPerStatement))
+      await renewBlobs(db, batch, now);
+    await removeUnusedBlobs(db, now);
+    return found;
+  }
+  async storeBlobs(blobs) {
+    const db = await this.#db;
+    const now = seconds();
+    const unique = [...new Map(blobs)];
+    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))
+      );
+      await renewBlobs(db, [...stored], now);
+      const rows = batch.filter(([sha]) => !stored.has(sha)).map(([sha, content]) => ({ sha, content, usedAt: now }));
+      if (rows.length === 0) continue;
+      await db.insert(BlobTable).values(rows).catch(() => insertMissingBlobs(db, rows));
+    }
+    await removeUnusedBlobs(db, now);
+  }
   async enrichUser(user) {
     const normalized = normalizeUser(user);
     const found = await this.#getUser(normalized.email);
@@ -191,6 +237,57 @@ function prepareDatabase(db) {
   preparedDatabases.set(db, prepared);
   return prepared;
 }
+function largeBlob() {
+  return new Column({
+    type: new ColumnType(
+      "blob",
+      [],
+      sql.universal({
+        postgres: sql`bytea`,
+        mysql: sql`longblob`,
+        default: sql`blob`
+      })
+    ),
+    mapFromDriverValue(value) {
+      return new Uint8Array(value);
+    }
+  });
+}
+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)));
+}
+async function insertMissingBlobs(db, rows) {
+  for (const row of rows) {
+    try {
+      await db.insert(BlobTable).values(row);
+    } catch (error) {
+      const stored = await db.select(BlobTable.sha).from(BlobTable).where(eq(BlobTable.sha, row.sha)).get();
+      if (!stored) throw error;
+    }
+  }
+}
+async function removeUnusedBlobs(db, now) {
+  const last = blobCleanups.get(db) ?? 0;
+  if (now - last < 60 * 60) return;
+  blobCleanups.set(db, now);
+  await db.delete(BlobTable).where(lt(BlobTable.usedAt, now - blobRetention));
+}
+function seconds() {
+  return Math.floor(Date.now() / 1e3);
+}
 async function enablePostgresRowLevelSecurity(db) {
   if (db.dialect.runtime !== "postgres") return;
   for (const table2 of tables) {

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;