github-repository-provider 7.23.43 → 7.24.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "github-repository-provider",
-  "version": "7.23.43",
+  "version": "7.24.0",
   "publishConfig": {
     "access": "public"
   },
@@ -30,19 +30,19 @@
     "lint:docs": "documentation lint ./src/**/*.mjs"
   },
   "dependencies": {
-    "content-entry": "^3.0.0",
+    "content-entry": "^3.0.1",
     "fetch-link-util": "^1.0.4",
     "fetch-rate-limit-util": "^1.1.6",
     "matching-iterator": "^2.0.0",
     "node-fetch": "3.1.0",
     "one-time-execution-method": "^2.0.9",
-    "repository-provider": "^26.0.1"
+    "repository-provider": "^26.0.2"
   },
   "devDependencies": {
     "ava": "^3.15.0",
     "c8": "^7.10.0",
     "documentation": "^13.2.5",
-    "repository-provider-test-support": "^1.8.10",
+    "repository-provider-test-support": "^1.8.11",
     "semantic-release": "^18.0.1"
   },
   "engines": {

package/src/github-branch.mjs

@@ -154,17 +154,22 @@ export class GithubBranch extends Branch {
     const url = `repos/${this.slug}/git/trees/${treeSha}?recursive=1`;
 
     let res;
-    for (const i = 0; i < 3; i++) {
-      res = await this.provider.fetch(url);
-      if (res.ok) {
-        const json = await res.json();
-        return json.tree;
+    for (let i = 0; i < 3; i++) {
+      try {
+        res = await this.provider.fetch(url);
+        if (res.ok) {
+          const json = await res.json();
+          return json.tree;
+        }
+      } catch (e) {
+        // errno: 'ERR_STREAM_PREMATURE_CLOSE',
+        // code: 'ERR_STREAM_PREMATURE_CLOSE',
+        
+        this.error(e);
       }
     }
 
     console.log(res.errno, res.code);
-    // errno: 'ERR_STREAM_PREMATURE_CLOSE',
-    // code: 'ERR_STREAM_PREMATURE_CLOSE',
 
     throw new Error(res.status);
   }

package/src/github-branch.mjs.x

@@ -0,0 +1,194 @@
+import { matcher } from "matching-iterator";
+import { Branch } from "repository-provider";
+import {
+  BaseCollectionEntry,
+  BufferContentEntry,
+  BufferContentEntryMixin,
+  ContentEntry
+} from "content-entry";
+
+/**
+ * Branch on GitHub.
+ */
+export class GithubBranch extends Branch {
+  /**
+   * Writes content into the branch
+   * {@link https://developer.github.com/v3/git/blobs/#get-a-blob}
+   * @param {ConentEntry} entry
+   * @return {Promise<Entry>} written content with sha values set
+   */
+  async writeEntry(entry) {
+    const res = await this.provider.fetch(`repos/${this.slug}/git/blobs`, {
+      method: "POST",
+      body: JSON.stringify({
+        content: await entry.string,
+        encoding: "utf8"
+      })
+    });
+    const json = await res.json();
+
+    entry.sha = json.sha;
+
+    return entry;
+  }
+
+  /**
+   * {@link https://developer.github.com/v3/git/commits/#get-a-commit}
+   * @param {string} sha
+   */
+  async baseTreeSha(sha) {
+    const json = await this.provider.fetchJSON(
+      `repos/${this.slug}/git/commits/${sha}`
+    );
+    return json.tree;
+  }
+
+  /**
+   * {@link https://developer.github.com/v3/git/trees/#create-a-tree}
+   * {@link https://developer.github.com/v3/git/commits/#create-a-commit}
+   * {@link https://developer.github.com/v3/git/refs/#update-a-reference}
+   * @param {string} message
+   * @param {ContentEntry[]} entries
+   * @param {Object} options
+   */
+  async commit(message, entries, options = {}) {
+    const updates = await Promise.all(
+      entries.map(entry => this.writeEntry(entry))
+    );
+
+    /*
+     * 1st. commit on empty tree
+     * https://stackoverflow.com/questions/9765453/is-gits-semi-secret-empty-tree-object-reliable-and-why-is-there-not-a-symbolic/9766506#9766506
+     * empty_tree=$(git mktree </dev/null)
+     * sha1:4b825dc642cb6eb9a060e54bf8d69288fbee4904
+     * sha256:6ef19b41225c5369f1c104d45d8d85efa9b057b53b14b4b9b939dd74decc5321
+     */
+
+    const shaLatestCommit = await this.refId();
+    const shaBaseTree = await this.baseTreeSha(shaLatestCommit);
+
+    let json = await this.provider.fetchJSON(`repos/${this.slug}/git/trees`, {
+      method: "POST",
+      body: JSON.stringify({
+        base_tree: shaBaseTree,
+        tree: updates.map(u => {
+          return {
+            path: u.name,
+            sha: u.sha,
+            type: "blob",
+            mode: "100" + u.mode.toString(8)
+          };
+        })
+      })
+    });
+
+    const shaNewTree = json.sha;
+
+    json = await this.provider.fetchJSON(`repos/${this.slug}/git/commits`, {
+      method: "POST",
+      body: JSON.stringify({
+        message,
+        tree: shaNewTree,
+        parents: [shaLatestCommit]
+      })
+    });
+    const sha = json.sha;
+
+    return this.provider.fetchJSON(
+      `repos/${this.slug}/git/refs/heads/${this.name}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify({
+          ...options,
+          sha
+        })
+      }
+    );
+  }
+
+  /**
+   * {@link https://developer.github.com/v3/repos/contents/#get-repository-content}
+   * @param {string} name
+   */
+  async entry(name) {
+    const json = await this.provider.fetchJSON(
+      `repos/${this.slug}/contents/${name}?ref=${this.ref}`
+    );
+
+    return new this.entryClass(name, Buffer.from(json.content, "base64"));
+  }
+
+  /** @inheritdoc */
+  async maybeEntry(name) {
+    const json = await this.provider.fetchJSON(
+      `repos/${this.slug}/contents/${name}?ref=${this.ref}`
+    );
+    return new this.entryClass(name, Buffer.from(json.content, "base64"));
+  }
+
+  /**
+   * @see https://developer.github.com/v3/git/trees/
+   * @param {string } treeSha
+   * @return {Object[]}
+   */
+  async tree(treeSha) {
+    const json = await this.provider.fetchJSON(
+      `repos/${this.slug}/git/trees/${treeSha}?recursive=1`
+    );
+    return json.tree;
+  }
+
+  async *entries(patterns) {
+    const shaBaseTree = await this.baseTreeSha(await this.refId());
+
+    for (const entry of matcher(await this.tree(shaBaseTree), patterns, {
+      name: "path"
+    })) {
+      yield entry.type === "tree"
+        ? new BaseCollectionEntry(entry.path)
+        : new LazyBufferContentEntry(entry.path, this);
+    }
+  }
+
+  /**
+   * https://developer.github.com/v3/repos/contents/
+   * @param {Iterator<ContentEntry>} entries
+   */
+  async removeEntries(entries) {
+    for await (const entry of entries) {
+      await this.provider.fetch(`repos/${this.slug}/contents/${entry.name}`, {
+        method: "DELETE",
+        body: JSON.stringify({ branch: this.name, message: "", sha: "" })
+      });
+    }
+  }
+
+  get entryClass() {
+    return BufferContentEntry;
+  }
+}
+
+class LazyBufferContentEntry extends BufferContentEntryMixin(ContentEntry) {
+  constructor(name, branch) {
+    super(name);
+    this.branch = branch;
+  }
+
+  get buffer() {
+    return this.getBuffer();
+  }
+
+  async getBuffer() {
+    if (this._buffer) {
+      return this._buffer;
+    }
+
+    const branch = this.branch;
+    const json = await branch.provider.fetchJSON(
+      `repos/${branch.slug}/contents/${this.name}?ref=${branch.ref}`
+    );
+
+    this._buffer = Buffer.from(json.content, "base64");
+    return this._buffer;
+  }
+}

package/src/github-provider.mjs

@@ -42,7 +42,7 @@ export class GithubProvider extends MultiGroupProvider {
    * @return {string} default instance environment name prefix
    */
   static get instanceIdentifier() {
-    return "GITHUB_"
+    return "GITHUB_";
   }
 
   static get attributes() {
@@ -116,16 +116,37 @@ export class GithubProvider extends MultiGroupProvider {
     );
   }
 
+  async fetchJSON(url, options) {
+    for (let i = 0; i < 3; i++) {
+      try {
+        const response = await this.fetch(url, options);
+        if (!response.ok) {
+          this.error(`Unable to fetch ${response.status} ${response.url}`);
+          throw new Error(`Unable to fetch ${response.status} ${response.url}`);
+          //break;
+        }
+        return await response.json();
+      } catch (e) {
+        this.error(e);
+        throw e;
+      }
+    }
+  }
+
   /**
    * {@link https://developer.github.com/v3/repos/#list-repositories-for-the-authenticated-user}
    */
   async initializeRepositories() {
     for (let page = 1; ; page++) {
-      const response = await this.fetch(`user/repos?page=${page}`, {
-        headers: {
-          accept: "application/vnd.github.baptiste-preview+json"
+      const response = await this.fetch(
+        `user/repos?page=${page}&per_page=30`,
+        {
+          headers: {
+            accept: "application/vnd.github.baptiste-preview+json"
+//            accept: "application/vnd.github.v3+json"
+          }
         }
-      });
+      );
 
       if (!response.ok) {
         this.error(
@@ -134,16 +155,23 @@ export class GithubProvider extends MultiGroupProvider {
         return;
       }
 
-      const json = await response.json();
+      try {
+        const json = await response.json();
 
-      if (json.length === 0 || !Array.isArray(json)) {
-        break;
-      }
+        if (json.length === 0 || !Array.isArray(json)) {
+          break;
+        }
 
-      json.forEach(r => {
-        const [groupName, repoName] = r.full_name.split(/\//);
-        this.addRepositoryGroup(groupName, r.owner).addRepository(repoName, r);
-      });
+        json.forEach(r => {
+          const [groupName, repoName] = r.full_name.split(/\//);
+          this.addRepositoryGroup(groupName, r.owner).addRepository(
+            repoName,
+            r
+          );
+        });
+      } catch (e) {
+        this.error(e);
+      }
     }
   }
 

package/src/github-provider.mjs.x

@@ -0,0 +1,199 @@
+import fetch from "node-fetch";
+import { replaceWithOneTimeExecutionMethod } from "one-time-execution-method";
+import { rateLimitHandler, defaultWaitDecide } from "fetch-rate-limit-util";
+
+import { MultiGroupProvider } from "repository-provider";
+import { GithubRepository } from "./github-repository.mjs";
+import { GithubBranch } from "./github-branch.mjs";
+import { GithubOwner } from "./github-owner.mjs";
+import { GithubPullRequest } from "./github-pull-request.mjs";
+export { GithubRepository, GithubBranch, GithubOwner, GithubPullRequest };
+
+const domain = "github.com";
+
+/**
+ * <!-- skip-example -->
+ * GitHub provider.
+ * Lookup a repository.
+ * known environment variables
+ * - GITHUB_TOKEN or GH_TOKEN api token
+ * @example
+ * import GithubProvider from 'github-repository-provider';
+ *
+ * const ghp = new GithubProvider();
+ * const r1 = ghp.repository('git@github.com:arlac77/github-repository-provider.git');
+ * const r2 = ghp.repository('git://github.com/arlac77/github-repository-provider.git');
+ * const r3 = ghp.repository('git+ssh://github.com/arlac77/github-repository-provider.git');
+ * const r4 = ghp.repository('https://github.com/arlac77/github-repository-provider.git#master');
+ * const r5 = ghp.repository('git+https://github.com/arlac77/github-repository-provider.git#master');
+ * const r6 = ghp.repository('arlac77/github-repository-provider');
+ * // different ways to address the same repository
+ */
+export class GithubProvider extends MultiGroupProvider {
+  /**
+   * We are called github.
+   * @return {string} github
+   */
+  static get name() {
+    return "github";
+  }
+
+  /**
+   * @return {string} default instance environment name prefix
+   */
+  static get instanceIdentifier() {
+    return "GITHUB_";
+  }
+
+  static get attributes() {
+    return {
+      ...super.attributes,
+      ssh: {
+        type: "url",
+        default: `git@${domain}:`
+      },
+      url: {
+        type: "url",
+        env: ["{{instanceIdentifier}}SERVER_URL"],
+        set: value => (value.endsWith("/") ? value : value + "/"),
+        default: `https://${domain}/`
+      },
+      api: {
+        type: "url",
+        env: ["{{instanceIdentifier}}API_URL"],
+        set: value => value.replace(/\/$/, ""),
+        default: `https://api.${domain}`
+      },
+      "authentication.token": {
+        type: "string",
+        env: ["{{instanceIdentifier}}TOKEN", "GH_TOKEN"],
+        additionalAttributes: { "authentication.type": "token" },
+        private: true,
+        mandatory: true
+      },
+      priority: { default: 1000.0 },
+      reateLimitRemaining: { writable: true, default: 5000 }
+    };
+  }
+
+  get repositoryClass() {
+    return GithubRepository;
+  }
+
+  get branchClass() {
+    return GithubBranch;
+  }
+
+  get repositoryGroupClass() {
+    return GithubOwner;
+  }
+
+  fetch(url, options = {}) {
+    return rateLimitHandler(
+      () =>
+        fetch(new URL(url, this.api), {
+          ...options,
+          headers: {
+            authorization: `token ${this.authentication.token}`,
+            ...options.headers
+          }
+        }),
+      (millisecondsToWait, rateLimitRemaining, nthTry, response) => {
+        this.rateLimitRemaining = rateLimitRemaining;
+
+        const msecs = defaultWaitDecide(
+          millisecondsToWait,
+          rateLimitRemaining,
+          nthTry,
+          response
+        );
+
+        if (msecs > 0) {
+          this.warn(`Rate limit reached: waiting for ${msecs / 1000}s`);
+        }
+        return msecs;
+      }
+    );
+  }
+
+  async fetchJSON(url, options) {
+    for (let i = 0; i < 3; i++) {
+      try {
+        const response = await this.fetch(url, options);
+        if (!response.ok) {
+          this.error(`Unable to fetch ${response.status} ${response.url}`);
+          throw new Error(`Unable to fetch ${response.status} ${response.url}`);
+          //break;
+        }
+        return await response.json();
+      } catch (e) {
+        this.error(e);
+        throw e;
+      }
+    }
+  }
+
+  /**
+   * {@link https://developer.github.com/v3/repos/#list-repositories-for-the-authenticated-user}
+   */
+  async initializeRepositories() {
+    for (let page = 1; ; page++) {
+      const json = await this.fetchJSON(
+        `user/repos?page=${page}`,
+        {
+          headers: {
+            accept: "application/vnd.github.v3+json"
+          }
+        }
+      );
+
+      if (json.length === 0 || !Array.isArray(json)) {
+        break;
+      }
+
+      json.forEach(r => {
+        const [groupName, repoName] = r.full_name.split(/\//);
+        this.addRepositoryGroup(groupName, r.owner).addRepository(repoName, r);
+      });
+    }
+  }
+
+  /**
+   * All possible base urls.
+   * - github:
+   * - git@github.com
+   * - git://github.com
+   * - git+ssh://github.com
+   * - https://github.com
+   * - git+https://github.com
+   * @return {string[]} common base urls of all repositories
+   */
+  get repositoryBases() {
+    return super.repositoryBases.concat([
+      this.url,
+      "git+" + this.url,
+      `git+ssh://${domain}`,
+      `git://${domain}/`,
+      `git@${domain}:`
+    ]);
+  }
+
+  get areRepositoryNamesCaseSensitive() {
+    return false;
+  }
+
+  get areGroupNamesCaseSensitive() {
+    return false;
+  }
+
+  get pullRequestClass() {
+    return GithubPullRequest;
+  }
+}
+
+replaceWithOneTimeExecutionMethod(
+  GithubProvider.prototype,
+  "initializeRepositories"
+);
+
+export default GithubProvider;

package/src/github-repository.mjs.x

@@ -0,0 +1,235 @@
+import { replaceWithOneTimeExecutionMethod } from "one-time-execution-method";
+import { Repository } from "repository-provider";
+import { getHeaderLink } from "fetch-link-util";
+
+/**
+ * Repository on GitHub.
+ */
+export class GithubRepository extends Repository {
+  static get attributeMapping() {
+    return {
+      ...super.attributeMapping,
+      archived: "isArchived",
+      is_template: "isTemplate",
+      private: "isPrivate",
+      fork: "isFork",
+      default_branch: "defaultBranchName"
+    };
+  }
+
+  static get attributes() {
+    return {
+      ...super.attributes,
+      auto_init: { type: "boolean", writable: true },
+      allow_squash_merge: { type: "boolean", writable: true },
+      allow_merge_commit: { type: "boolean", writable: true },
+      allow_rebase_merge: { type: "boolean", writable: true },
+      allow_auto_merge: { type: "boolean", writable: true },
+      delete_branch_on_merge: { type: "boolean", writable: true }
+    };
+  }
+
+  get defaultBranchName() {
+    return "main";
+  }
+
+  async _initializeSlot(typeName, addMethodName) {
+    let next = `repos/${this.slug}/${typeName}`;
+
+    do {
+      const response = await this.provider.fetch(next);
+
+      if (!response.ok) {
+        this.error(
+          `Unable to fetch ${typeName} ${response.status} ${response.url}`
+        );
+        return;
+      }
+
+      const json = await response.json();
+      json.forEach(b => this[addMethodName](b.name, b));
+      next = getHeaderLink(response.headers);
+    } while (next);
+  }
+
+  /**
+   * {@link https://developer.github.com/v3/repos/branches/#list-branches}
+   */
+  async initializeBranches() {
+    return this._initializeSlot("branches", "addBranch");
+  }
+
+  /**
+   * {@link https://docs.github.com/en/rest/reference/repos#list-repository-tags}
+   */
+  async initializeTags() {
+    return this._initializeSlot("tags", "addTag");
+  }
+
+  /**
+   * @return {string[]} github https url
+   */
+  get urls() {
+    return [`${this.provider.url}${this.fullName}.git`];
+  }
+
+  /**
+   * Deliver the url of issue tracking system.
+   * @return {string}
+   */
+  get issuesURL() {
+    return `${this.provider.url}${this.fullName}/issues`;
+  }
+
+  /**
+   * Deliver the url of the repositories home page.
+   * @return {string}
+   */
+  get homePageURL() {
+    return `${this.provider.url}${this.fullName}#readme`;
+  }
+
+  /**
+   * {@link https://developer.github.com/v3/repos/#update-a-repository}
+   */
+  async update() {
+    return this.provider.fetch(`repos/${this.slug}`, {
+      method: "PATCH",
+      body: JSON.stringify(
+        mapAttributesInverse(
+          optionJSON(this, undefined, this.constructor.writableAttributes),
+          this.constructor.attributeMapping
+        )
+      )
+    });
+  }
+
+  /**
+   * {@link https://developer.github.com/v3/git/refs/}
+   * @param {string} ref
+   * @return {string} sha of the ref
+   */
+  async refId(ref) {
+    ref = ref.replace(/^refs\//, "");
+
+    const json = await this.provider.fetchJSON(`repos/${this.slug}/git/ref/${ref}`);
+
+    // TODO why does this happen ?
+    if (!json.object.sha) {
+      throw new Error(`No refId for '${this.name}' '${ref}'`);
+    }
+
+    return json.object.sha;
+  }
+
+  async createBranch(name, from, options) {
+    const branch = this._branches.get(name);
+    if (branch) {
+      return branch;
+    }
+
+    let sha;
+
+    if (this._branches.size === 0) {
+      /*
+       * https://stackoverflow.com/questions/9765453/is-gits-semi-secret-empty-tree-object-reliable-and-why-is-there-not-a-symbolic/9766506#9766506
+       * sha1:4b825dc642cb6eb9a060e54bf8d69288fbee4904
+       * sha256:6ef19b41225c5369f1c104d45d8d85efa9b057b53b14b4b9b939dd74decc5321
+       */
+      sha = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+      /*const res = await this.provider.fetch(`repos/${this.slug}/git/commits`, {
+        method: "POST",
+        body: JSON.stringify({
+          message: "Initial commit",
+          tree: sha
+        })
+      });
+      console.log(res);
+      */
+    } else {
+      const json = await this.provider.fetchJSON(
+        `repos/${this.slug}/git/ref/heads/${
+          from === undefined ? this.defaultBranchName : from.name
+        }`
+      );
+      sha = json.object.sha;
+    }
+
+    const res = await this.provider.fetch(`repos/${this.slug}/git/refs`, {
+      method: "POST",
+      body: JSON.stringify({
+        ref: `refs/heads/${name}`,
+        sha
+      })
+    });
+
+    if (res.ok) {
+      return this.addBranch(name, options);
+    }
+  }
+
+  async deleteBranch(name) {
+    const res = await this.provider.fetch(
+      `repos/${this.slug}/git/refs/heads/${name}`,
+      {
+        method: "DELETE"
+      }
+    );
+
+    if (res.ok) {
+      return super.deleteBranch(name);
+    }
+  }
+
+  /**
+   * {@link https://developer.github.com/v3/pulls/#update-a-pull-request}
+   *
+   * @param {string} name
+   */
+  async deletePullRequest(name) {
+    const res = await this.provider.fetch(`repos/${this.slug}/pulls/${name}`, {
+      method: "PATCH",
+      body: JSON.stringify({ state: "closed" })
+    });
+
+    if (res.ok) {
+      this._pullRequests.delete(name);
+    }
+  }
+
+  /**
+   * {@link https://developer.github.com/v3/repos/hooks/}
+   */
+  async initializeHooks() {
+    let next = `repos/${this.slug}/hooks`;
+
+    do {
+      const response = await this.provider.fetch(next);
+
+      for (const h of await response.json()) {
+        const id = h.id;
+        delete h.id;
+        new this.hookClass(this, id, new Set(h.events), {
+          ...h,
+          ...h.config
+        });
+      }
+      next = getHeaderLink(response.headers);
+    } while (next);
+  }
+}
+
+replaceWithOneTimeExecutionMethod(
+  GithubRepository.prototype,
+  "initializeBranches"
+);
+
+replaceWithOneTimeExecutionMethod(
+  GithubRepository.prototype,
+  "initializeHooks"
+);
+
+replaceWithOneTimeExecutionMethod(
+  GithubRepository.prototype,
+  "initializePullRequests"
+);