@gamerdexapp/gamerdex-sync 0.1.1 → 0.2.1

package/dist/index.mjs

@@ -287,10 +287,11 @@ var decodeBase64 = (base64) => {
 
 // src/provider/detail.ts
 var MAX_DETAIL_LENGTH = 300;
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var detailOf = async (response) => {
   const body = await response.json().catch(() => null);
-  if (typeof body !== "object" || body === null) return void 0;
-  const message = body.message;
+  if (!isRecord2(body)) return void 0;
+  const message = isRecord2(body.error) ? body.error.message : body.message;
   return typeof message === "string" ? message.slice(0, MAX_DETAIL_LENGTH) : void 0;
 };
 
@@ -322,7 +323,7 @@ var ProviderError = class extends Error {
 var API = "https://api.github.com";
 var API_VERSION = "2022-11-28";
 var encodePath = (path) => path.split("/").map(encodeURIComponent).join("/");
-var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var retryAfterOf = (response) => {
   const header = response.headers.get("retry-after");
   if (header !== null && Number.isFinite(Number(header))) return Number(header);
@@ -388,10 +389,10 @@ var GitHubProvider = class {
     const response = await this.request("GET", `${API}/repos/${this.options.repository}`);
     await this.assertOk(response);
     const body = await response.json();
-    if (!isRecord2(body) || typeof body.private !== "boolean") {
+    if (!isRecord3(body) || typeof body.private !== "boolean") {
       throw this.invalid("The repository answer is not understood.");
     }
-    const permissions = isRecord2(body.permissions) ? body.permissions : {};
+    const permissions = isRecord3(body.permissions) ? body.permissions : {};
     return {
       private: body.private,
       canWrite: permissions.push === true,
@@ -621,10 +622,10 @@ var GITHUB_APP = {
 };
 
 // src/auth/tokens.ts
-var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isSeconds = (value) => typeof value === "number" && Number.isFinite(value) && value > 0;
 var parseTokenResponse = (body) => {
-  if (!isRecord3(body)) return null;
+  if (!isRecord4(body)) return null;
   const { accessToken, expiresIn, refreshToken, refreshExpiresIn } = body;
   if (typeof accessToken !== "string" || accessToken === "") return null;
   if (typeof refreshToken !== "string" || refreshToken === "") return null;
@@ -714,7 +715,7 @@ var readCallback = (search, expectedState) => {
 // src/provider/repositories.ts
 var API2 = "https://api.github.com";
 var PAGE_SIZE = 100;
-var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var getJson = async (send, token, url) => {
   let response;
   try {
@@ -745,7 +746,7 @@ var getJson = async (send, token, url) => {
     );
   }
   const body = await response.json().catch(() => null);
-  if (!isRecord4(body)) {
+  if (!isRecord5(body)) {
     throw new ProviderError("invalid", "GitHub answer is not understood.", response.status);
   }
   return body;
@@ -756,7 +757,7 @@ var listInstalledRepositories = async (token, send = (...args) => globalThis.fet
     token,
     `${API2}/user/installations?per_page=${PAGE_SIZE}`
   );
-  const ids = (Array.isArray(installations.installations) ? installations.installations : []).filter(isRecord4).map((installation) => installation.id).filter((id) => typeof id === "number");
+  const ids = (Array.isArray(installations.installations) ? installations.installations : []).filter(isRecord5).map((installation) => installation.id).filter((id) => typeof id === "number");
   const repositories = [];
   for (const id of ids) {
     const page = await getJson(
@@ -765,17 +766,286 @@ var listInstalledRepositories = async (token, send = (...args) => globalThis.fet
       `${API2}/user/installations/${id}/repositories?per_page=${PAGE_SIZE}`
     );
     for (const item of Array.isArray(page.repositories) ? page.repositories : []) {
-      if (isRecord4(item) && typeof item.full_name === "string" && typeof item.private === "boolean") {
+      if (isRecord5(item) && typeof item.full_name === "string" && typeof item.private === "boolean") {
         repositories.push({ fullName: item.full_name, private: item.private });
       }
     }
   }
   return repositories;
 };
+
+// src/provider/drive.ts
+var API3 = "https://www.googleapis.com/drive/v3";
+var UPLOAD = "https://www.googleapis.com/upload/drive/v3";
+var FOLDER_TYPE = "application/vnd.google-apps.folder";
+var RATE_LIMIT_REASONS = ["rateLimitExceeded", "userRateLimitExceeded", "dailyLimitExceeded"];
+var isRecord6 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var quoted = (value) => `'${value.replace(/[\\']/g, "\\$&")}'`;
+var oldestFirst = (a, b) => a.createdTime.localeCompare(b.createdTime) || a.id.localeCompare(b.id);
+var withOwn = (found, own4) => (found.some((item) => item.id === own4.id) ? found : [...found, own4]).sort(oldestFirst);
+var reasonOf = (body) => {
+  if (!isRecord6(body) || !isRecord6(body.error) || !Array.isArray(body.error.errors))
+    return void 0;
+  const first = body.error.errors[0];
+  return isRecord6(first) && typeof first.reason === "string" ? first.reason : void 0;
+};
+var GoogleDriveProvider = class {
+  constructor(options) {
+    this.options = options;
+    this.send = options.fetch ?? ((...args) => globalThis.fetch(...args));
+  }
+  options;
+  send;
+  folders = /* @__PURE__ */ new Map();
+  async read(path) {
+    const file = await this.findFile(path);
+    if (!file) return null;
+    const head = await this.headOf(file.id);
+    if (head === null) return null;
+    return { content: await this.revisionContent(file.id, head), version: head };
+  }
+  async write(path, content, expectedVersion) {
+    if (expectedVersion === null) return this.create(path, content);
+    const file = await this.findFile(path);
+    if (!file || await this.headOf(file.id) !== expectedVersion) {
+      throw new VersionConflictError(path);
+    }
+    const version = await this.upload(file.id, content);
+    if (version === expectedVersion) return { version };
+    const previous = await this.revisionBefore(file.id, version);
+    if (previous === expectedVersion) return { version };
+    await this.upload(file.id, await this.revisionContent(file.id, previous));
+    throw new VersionConflictError(path);
+  }
+  async remove(path, expectedVersion) {
+    const file = await this.findFile(path);
+    if (!file) return;
+    if (await this.headOf(file.id) !== expectedVersion) throw new VersionConflictError(path);
+    await this.deleteItem(file.id);
+  }
+  async create(path, content) {
+    const { parentId, name } = await this.locate(path, true);
+    if ((await this.children(parentId, name)).length > 0) throw new VersionConflictError(path);
+    const created = await this.createFile(parentId, name, content);
+    const [oldest] = withOwn(await this.children(parentId, name), created);
+    if (oldest.id !== created.id) {
+      await this.deleteItem(created.id);
+      throw new VersionConflictError(path);
+    }
+    return { version: created.version };
+  }
+  async findFile(path) {
+    const located = await this.locate(path, false);
+    if (!located) return null;
+    return (await this.children(located.parentId, located.name))[0] ?? null;
+  }
+  async locate(path, create) {
+    const parts = path.split("/");
+    const name = parts.pop();
+    let parentId = "root";
+    let walked = "";
+    for (const folder of parts) {
+      walked += `/${folder}`;
+      const known = this.folders.get(walked);
+      if (known) {
+        parentId = known;
+        continue;
+      }
+      const id = await this.folderId(parentId, folder, create);
+      if (id === null) return null;
+      this.folders.set(walked, id);
+      parentId = id;
+    }
+    return { parentId, name };
+  }
+  async folderId(parentId, name, create) {
+    const found = await this.children(parentId, name, true);
+    if (found.length > 0) return found[0].id;
+    if (!create) return null;
+    const response = await this.request("POST", `${API3}/files?fields=id,createdTime`, {
+      body: JSON.stringify({ name, mimeType: FOLDER_TYPE, parents: [parentId] }),
+      headers: { "Content-Type": "application/json" }
+    });
+    const created = this.itemOf(await response.json());
+    const [oldest] = withOwn(await this.children(parentId, name, true), created);
+    if (oldest.id !== created.id) {
+      await this.deleteItem(created.id);
+      return oldest.id;
+    }
+    return created.id;
+  }
+  async children(parentId, name, folder = false) {
+    const query = [
+      `name = ${quoted(name)}`,
+      `${quoted(parentId)} in parents`,
+      "trashed = false",
+      `mimeType ${folder ? "=" : "!="} '${FOLDER_TYPE}'`
+    ].join(" and ");
+    const url = `${API3}/files?${new URLSearchParams({
+      q: query,
+      fields: "files(id,createdTime)",
+      pageSize: "100"
+    })}`;
+    const body = await (await this.request("GET", url)).json();
+    const files = isRecord6(body) && Array.isArray(body.files) ? body.files : [];
+    return files.filter(
+      (item) => isRecord6(item) && typeof item.id === "string" && typeof item.createdTime === "string"
+    ).sort(oldestFirst);
+  }
+  async headOf(id) {
+    const response = await this.request(
+      "GET",
+      `${API3}/files/${encodeURIComponent(id)}?fields=headRevisionId,trashed`,
+      { allowMissing: true }
+    );
+    if (response.status === 404) return null;
+    const body = await response.json();
+    if (isRecord6(body) && body.trashed === true) return null;
+    return this.stringField(body, "headRevisionId");
+  }
+  async revisionContent(id, revision) {
+    const url = `${API3}/files/${encodeURIComponent(id)}/revisions/${encodeURIComponent(revision)}?alt=media`;
+    return (await this.request("GET", url)).text();
+  }
+  async revisionBefore(id, revision) {
+    const url = `${API3}/files/${encodeURIComponent(id)}/revisions?${new URLSearchParams({
+      fields: "revisions(id)",
+      pageSize: "1000"
+    })}`;
+    const body = await (await this.request("GET", url)).json();
+    const revisions = (isRecord6(body) && Array.isArray(body.revisions) ? body.revisions : []).filter(isRecord6).map((item) => item.id);
+    const index = revisions.indexOf(revision);
+    const previous = revisions[index - 1];
+    if (index < 1 || typeof previous !== "string") {
+      throw new ProviderError("server", "The new revision is not in the revision list.");
+    }
+    return previous;
+  }
+  async upload(id, content) {
+    const url = `${UPLOAD}/files/${encodeURIComponent(id)}?uploadType=media&fields=headRevisionId`;
+    const response = await this.request("PATCH", url, {
+      body: content,
+      headers: { "Content-Type": "application/json" }
+    });
+    return this.stringField(await response.json(), "headRevisionId");
+  }
+  async createFile(parentId, name, content) {
+    const boundary = `gamerdex-${crypto.randomUUID()}`;
+    const metadata = JSON.stringify({ name, parents: [parentId], mimeType: "application/json" });
+    const body = `--${boundary}\r
+Content-Type: application/json; charset=UTF-8\r
+\r
+${metadata}\r
+--${boundary}\r
+Content-Type: application/json\r
+\r
+${content}\r
+--${boundary}--`;
+    const response = await this.request(
+      "POST",
+      `${UPLOAD}/files?uploadType=multipart&fields=id,headRevisionId,createdTime`,
+      { body, headers: { "Content-Type": `multipart/related; boundary=${boundary}` } }
+    );
+    const answer = await response.json();
+    return { ...this.itemOf(answer), version: this.stringField(answer, "headRevisionId") };
+  }
+  async deleteItem(id) {
+    await this.request("DELETE", `${API3}/files/${encodeURIComponent(id)}`, { allowMissing: true });
+  }
+  itemOf(body) {
+    return { id: this.stringField(body, "id"), createdTime: this.stringField(body, "createdTime") };
+  }
+  stringField(body, field) {
+    const value = isRecord6(body) ? body[field] : void 0;
+    if (typeof value !== "string") {
+      throw new ProviderError("invalid", `Google Drive answered without ${field}.`);
+    }
+    return value;
+  }
+  async request(method, url, options = {}) {
+    const token = await this.options.getToken();
+    let response;
+    try {
+      response = await this.send(url, {
+        method,
+        headers: { Authorization: `Bearer ${token}`, ...options.headers ?? {} },
+        body: options.body
+      });
+    } catch {
+      throw new ProviderError("network", "Google Drive could not be reached.");
+    }
+    if (response.ok || options.allowMissing && response.status === 404) return response;
+    throw await this.failure(response);
+  }
+  async failure(response) {
+    const { status } = response;
+    const body = await response.clone().json().catch(() => null);
+    const detail = await detailOf(response);
+    if (status === 401) {
+      return new ProviderError("auth", "The token is not valid.", status, void 0, detail);
+    }
+    const reason = reasonOf(body);
+    if (status === 429 || status === 403 && reason && RATE_LIMIT_REASONS.includes(reason)) {
+      const retryAfter = Number(response.headers.get("retry-after"));
+      return new ProviderError(
+        "rate-limit",
+        "Google Drive limits the calls.",
+        status,
+        Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter : void 0,
+        detail
+      );
+    }
+    if (status === 403) {
+      return new ProviderError(
+        "auth",
+        "The token has no permission for Drive.",
+        status,
+        void 0,
+        detail
+      );
+    }
+    if (status === 404) {
+      return new ProviderError(
+        "not-found",
+        "The file or folder was not found.",
+        status,
+        void 0,
+        detail
+      );
+    }
+    if (status >= 500) {
+      return new ProviderError("server", "Google Drive failed.", status, void 0, detail);
+    }
+    return new ProviderError(
+      "invalid",
+      `Google Drive answered ${status}.`,
+      status,
+      void 0,
+      detail
+    );
+  }
+};
+
+// src/auth/google.ts
+var GOOGLE_DRIVE_SCOPE = "https://www.googleapis.com/auth/drive.file";
+var googleAuthorizeUrl = (clientId, redirectUri, state) => {
+  const query = new URLSearchParams({
+    client_id: clientId,
+    redirect_uri: redirectUri,
+    response_type: "code",
+    scope: GOOGLE_DRIVE_SCOPE,
+    access_type: "offline",
+    prompt: "consent",
+    state
+  });
+  return `https://accounts.google.com/o/oauth2/v2/auth?${query}`;
+};
 export {
   DATA_FILE,
   GITHUB_APP,
+  GOOGLE_DRIVE_SCOPE,
   GitHubProvider,
+  GoogleDriveProvider,
   META_FILE,
   META_FORMAT,
   MemoryProvider,
@@ -791,6 +1061,7 @@ export {
   emptyMeta,
   encodeBase64,
   equal,
+  googleAuthorizeUrl,
   installUrl,
   isAppId,
   isObject,