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

package/dist/backend/api/GithubApi.js

@@ -1,3 +1,6 @@
+import {
+  pLimit
+} from "../../chunks/chunk-U5Z2VE7Z.js";
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/backend/api/GithubApi.ts
@@ -26,10 +29,12 @@ var GithubApi = class extends GithubSource {
   }
   /**
    * Commit through GraphQL, which also answers the content sha before and
-   * after: a save spends none of the REST rate limit.
+   * after: a save spends none of the REST rate limit. A configured author
+   * commits through REST, writing only the commit there.
    */
   async #write(request) {
-    const { oid: currentCommit, contentSha: currentSha } = await this.#getLatestCommit();
+    const current = await this.#getLatestCommit();
+    const currentSha = current.contentSha;
     if (currentSha !== request.fromSha)
       throw new ShaMismatchError(currentSha, request.fromSha);
     const { user } = request;
@@ -39,8 +44,13 @@ var GithubApi = class extends GithubSource {
 
 Co-authored-by: ${user.name} <${user.email}>`;
     }
-    const newCommit = await this.#applyChangesToRepo(
-      currentCommit,
+    const newCommit = this.#options.author ? await this.#commitThroughRest(
+      current,
+      request.changes,
+      commitMessage,
+      this.#options.author
+    ) : await this.#applyChangesToRepo(
+      current.oid,
       request.changes,
       commitMessage
     );
@@ -94,6 +104,7 @@ Co-authored-by: ${user.name} <${user.email}>`;
       if (requestCount === maxRequests) break;
       requestCount++;
       const versions = [...queue].filter((v) => !seen.has(v));
+      if (versions.length === 0) break;
       for (const v of versions) seen.add(v);
       queue.length = 0;
       const aliasMap = versions.map((v, idx) => ({
@@ -101,9 +112,10 @@ Co-authored-by: ${user.name} <${user.email}>`;
         version: v,
         path: join(rootDir, v)
       }));
+      const params = aliasMap.map(({ alias }) => `$${alias}: String!`).join(", ");
       const query = aliasMap.map(
-        ({ alias, path }) => `
-          ${alias}: history(path: "${path}", first: 100) {
+        ({ alias }) => `
+          ${alias}: history(path: $${alias}, first: 100) {
             nodes {
               oid
               committedDate
@@ -113,14 +125,16 @@ Co-authored-by: ${user.name} <${user.email}>`;
           }`
       ).join("");
       const gql = `
-        query GetFileHistory($owner: String!, $repo: String!, $branch: String!) {
+        query GetFileHistory($owner: String!, $repo: String!, $branch: String!, ${params}) {
           repository(owner: $owner, name: $repo) {
             ref(qualifiedName: $branch) {
               target { ... on Commit {${query}} }
             }
           }
         }`;
-      const result = await this.#graphQL(gql, { owner, repo, branch }, authToken);
+      const variables = { owner, repo, branch };
+      for (const { alias, path } of aliasMap) variables[alias] = path;
+      const result = await this.#graphQL(gql, variables, authToken);
       for (const { alias, version, path } of aliasMap) {
         const commits = result.data.repository.ref.target[alias]?.nodes || [];
         if (!commits.length) continue;
@@ -216,37 +230,147 @@ Co-authored-by: ${user.name} <${user.email}>`;
       throw error;
     });
   }
+  /**
+   * Write a commit with its own author through the REST API: a tree on the
+   * current one, the commit, and the branch moved to it. Uploaded files are
+   * stored as blobs first, entries are passed in the tree as text.
+   */
+  async #commitThroughRest(parent, changes, commitMessage, author) {
+    const { branch } = this.#options;
+    if (!parent.treeOid)
+      throw new Error(`GitHub did not answer the tree of ${parent.oid}`);
+    const limit = pLimit(4);
+    let entries = await Promise.all(
+      changes.map((change) => limit(() => this.#treeEntry(change)))
+    );
+    const writeTree = () => this.#rest("POST", "git/trees", {
+      base_tree: parent.treeOid,
+      tree: entries
+    });
+    let tree;
+    try {
+      tree = await writeTree();
+    } catch (error) {
+      const removed = entries.filter((entry) => entry.sha === null);
+      if (!(error instanceof HttpError && error.code === 422) || !removed.length)
+        throw error;
+      const existing = await this.#existingPaths(
+        parent.oid,
+        removed.map((entry) => entry.path)
+      );
+      if (existing.size === removed.length) throw error;
+      entries = entries.filter(
+        (entry) => entry.sha !== null || existing.has(entry.path)
+      );
+      tree = await writeTree();
+    }
+    assert(isRecord(tree) && typeof tree.sha === "string");
+    const commit = await this.#rest("POST", "git/commits", {
+      message: commitMessage,
+      tree: tree.sha,
+      parents: [parent.oid],
+      author
+    });
+    assert(isRecord(commit) && typeof commit.sha === "string");
+    const ref = `git/refs/heads/${branch.split("/").map(encodeURIComponent).join("/")}`;
+    try {
+      await this.#rest("PATCH", ref, { sha: commit.sha, force: false });
+    } catch (error) {
+      if (error instanceof HttpError && error.code === 422 && /fast.forward/i.test(error.message))
+        throw new HttpError(409, error.message);
+      throw error;
+    }
+    return this.#getCommit(commit.sha);
+  }
+  /** The paths that exist in a commit. */
+  async #existingPaths(commit, paths) {
+    const { owner, repo, authToken } = this.#options;
+    const params = paths.map((_, i) => `$p${i}: String!`).join(", ");
+    const fields = paths.map((_, i) => `p${i}: object(expression: $p${i}) { oid }`).join("\n");
+    const variables = { owner, repo };
+    for (const [i, path] of paths.entries())
+      variables[`p${i}`] = `${commit}:${path}`;
+    const result = await this.#graphQL(
+      `query ExistingPaths($owner: String!, $repo: String!, ${params}) {
+      repository(owner: $owner, name: $repo) {
+        ${fields}
+      }
+    }`,
+      variables,
+      authToken
+    );
+    const repository = result.data.repository;
+    return new Set(paths.filter((_, i) => isRecord(repository[`p${i}`])));
+  }
+  async #treeEntry(change) {
+    const path = this.#changePath(change);
+    const mode = "100644";
+    switch (change.op) {
+      case "addContent":
+        return { path, mode, type: "blob", content: change.contents };
+      case "uploadFile": {
+        const blob = await this.#rest("POST", "git/blobs", {
+          content: await this.#fetchUploadedContent(change.url),
+          encoding: "base64"
+        });
+        assert(isRecord(blob) && typeof blob.sha === "string");
+        return { path, mode, type: "blob", sha: blob.sha };
+      }
+      case "deleteContent":
+      case "removeFile":
+        return { path, mode, type: "blob", sha: null };
+    }
+  }
+  /** The repository path a change writes or removes. */
+  #changePath(change) {
+    switch (change.op) {
+      case "addContent":
+      case "deleteContent":
+        return repositoryPath(this.contentLocation, change.path);
+      case "uploadFile":
+      case "removeFile":
+        return repositoryPath(this.#options.rootDir, change.location);
+    }
+  }
+  async #rest(method, path, body) {
+    const { owner, repo, authToken } = this.#options;
+    const response = await this.githubFetch(
+      `https://api.github.com/repos/${owner}/${repo}/${path}`,
+      {
+        method,
+        headers: {
+          Authorization: `Bearer ${authToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      }
+    );
+    if (!response.ok)
+      throw new HttpError(
+        response.status,
+        `GitHub ${method} ${path} failed: ${await response.text()}`
+      );
+    return response.json();
+  }
   async #processChanges(changes) {
-    const { rootDir } = this.#options;
     const additions = Array();
     const deletions = Array();
     for (const change of changes) {
+      const path = this.#changePath(change);
       switch (change.op) {
-        case "addContent": {
-          additions.push({
-            path: repositoryPath(this.contentLocation, change.path),
-            contents: btoa(change.contents)
-          });
+        case "addContent":
+          additions.push({ path, contents: btoa(change.contents) });
           break;
-        }
-        case "uploadFile": {
-          const file = repositoryPath(rootDir, change.location);
+        case "uploadFile":
           additions.push({
-            path: file,
+            path,
             contents: await this.#fetchUploadedContent(change.url)
           });
           break;
-        }
-        case "deleteContent": {
-          const file = repositoryPath(this.contentLocation, change.path);
-          deletions.push({ path: file });
-          break;
-        }
-        case "removeFile": {
-          const file = repositoryPath(rootDir, change.location);
-          deletions.push({ path: file });
+        case "deleteContent":
+        case "removeFile":
+          deletions.push({ path });
           break;
-        }
       }
     }
     return { additions, deletions };
@@ -267,6 +391,20 @@ Co-authored-by: ${user.name} <${user.email}>`;
       authToken
     ).then((result) => commitState(result.data.repository.ref.target));
   }
+  async #getCommit(oid) {
+    const { owner, repo, authToken } = this.#options;
+    return this.#graphQL(
+      `query GetCommit($owner: String!, $repo: String!, $oid: GitObjectID!, $content: String!) {
+      repository(owner: $owner, name: $repo) {
+        object(oid: $oid) {
+          ${commitStateFields}
+        }
+      }
+    }`,
+      { owner, repo, oid, content: this.contentLocation },
+      authToken
+    ).then((result) => commitState(result.data.repository.object));
+  }
   async #fetchUploadedContent(url) {
     const response = await fetch(url);
     if (!response.ok)
@@ -277,12 +415,14 @@ Co-authored-by: ${user.name} <${user.email}>`;
 function repositoryPath(...segments) {
   return relative("/", join("/", ...segments));
 }
-var commitStateFields = `oid ... on Commit { file(path: $content) { oid } }`;
+var commitStateFields = `oid ... on Commit { tree { oid } file(path: $content) { oid } }`;
 function commitState(commit) {
   assert(isRecord(commit) && typeof commit.oid === "string");
+  const tree = commit.tree;
+  const treeOid = isRecord(tree) && typeof tree.oid === "string" ? tree.oid : void 0;
   const file = commit.file;
   const contentSha = isRecord(file) && typeof file.oid === "string" ? file.oid : ReadonlyTree.EMPTY.sha;
-  return { oid: commit.oid, contentSha };
+  return { oid: commit.oid, treeOid, contentSha };
 }
 function isMissingFile(error) {
   return isRecord(error) && error.type === "NOT_FOUND" && Array.isArray(error.path) && error.path.at(-1) === "file";

package/dist/backend/api/database.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/util/Syncable.d.ts

@@ -1 +1,7 @@
+/**
+ * How long a read waits for a sync with the remote. A slower or hung remote
+ * must not hold up every read: past this the read answers with the content
+ * it has, while the sync carries on.
+ */
+export declare const syncWait = 10000;
 export declare function createThrottledSync(): (sync: () => Promise<unknown>, interval?: number) => Promise<void>;

package/dist/backend/util/Syncable.js

@@ -4,6 +4,7 @@ import {
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/backend/util/Syncable.ts
+var syncWait = 1e4;
 function createThrottledSync() {
   let lastSync = 0;
   const limit = pLimit(1);
@@ -18,5 +19,6 @@ function createThrottledSync() {
   };
 }
 export {
-  createThrottledSync
+  createThrottledSync,
+  syncWait
 };