@gamerdexapp/gamerdex-sync 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -285,6 +285,16 @@ var decodeBase64 = (base64) => {
   return new TextDecoder().decode(Uint8Array.from(binary, (char) => char.charCodeAt(0)));
 };
 
+// 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 (!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;
+};
+
 // src/provider/types.ts
 var VersionConflictError = class extends Error {
   constructor(path) {
@@ -295,23 +305,25 @@ var VersionConflictError = class extends Error {
   path;
 };
 var ProviderError = class extends Error {
-  constructor(kind, message, status, retryAfterSeconds) {
+  constructor(kind, message, status, retryAfterSeconds, detail) {
     super(message);
     this.kind = kind;
     this.status = status;
     this.retryAfterSeconds = retryAfterSeconds;
+    this.detail = detail;
     this.name = "ProviderError";
   }
   kind;
   status;
   retryAfterSeconds;
+  detail;
 };
 
 // src/provider/github.ts
 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);
@@ -377,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,
@@ -415,7 +427,10 @@ var GitHubProvider = class {
   async assertOk(response) {
     if (response.ok) return;
     const { status } = response;
-    if (status === 401) throw new ProviderError("auth", "The token is not valid.", status);
+    const detail = await detailOf(response);
+    if (status === 401) {
+      throw new ProviderError("auth", "The token is not valid.", status, void 0, detail);
+    }
     if (status === 403 || status === 429) {
       const limited = status === 429 || response.headers.get("x-ratelimit-remaining") === "0";
       if (limited) {
@@ -423,18 +438,34 @@ var GitHubProvider = class {
           "rate-limit",
           "GitHub limits the calls.",
           status,
-          retryAfterOf(response)
+          retryAfterOf(response),
+          detail
         );
       }
-      throw new ProviderError("auth", "The token has no permission for the repository.", status);
+      throw new ProviderError(
+        "auth",
+        "The token has no permission for the repository.",
+        status,
+        void 0,
+        detail
+      );
+    }
+    if (status === 404) {
+      throw new ProviderError(
+        "not-found",
+        "The repository was not found.",
+        status,
+        void 0,
+        detail
+      );
     }
-    if (status === 404)
-      throw new ProviderError("not-found", "The repository was not found.", status);
-    if (status >= 500) throw new ProviderError("server", "GitHub failed.", status);
-    throw this.invalid(`GitHub answered ${status}.`, status);
+    if (status >= 500) {
+      throw new ProviderError("server", "GitHub failed.", status, void 0, detail);
+    }
+    throw this.invalid(`GitHub answered ${status}.`, status, detail);
   }
-  invalid(message, status) {
-    return new ProviderError("invalid", message, status);
+  invalid(message, status, detail) {
+    return new ProviderError("invalid", message, status, void 0, detail);
   }
 };
 
@@ -497,11 +528,14 @@ var readMeta = (text, appId) => {
   if (!parsed.ok) throw new RemoteDataError(parsed.error);
   return parsed.meta;
 };
-var writeMeta = async (options) => {
+var writeMeta = async (options, uploaded) => {
   const { provider, appId, deviceId, deviceName, updateMeta, now } = options;
   for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
     const current = await provider.read(metaPath(appId));
     const meta = readMeta(current?.content, appId);
+    if (current && !uploaded && !updateMeta && Object.hasOwn(meta.devices, deviceId)) {
+      return current.version;
+    }
     const time = now();
     const updated = withDevice(updateMeta ? updateMeta(meta) : meta, deviceId, {
       name: deviceName,
@@ -531,7 +565,7 @@ var sync = async (options) => {
       const cloud = restoreCloudValues(local, void 0, schema);
       const created = await tryWrite(provider, path, cloud, null);
       if (created === null) continue;
-      const metaVersion2 = await writeMeta(options);
+      const metaVersion2 = await writeMeta(options, true);
       return done(local, cloud, created, metaVersion2, [], true);
     }
     const remote = parseData(file.content, validate);
@@ -544,12 +578,12 @@ var sync = async (options) => {
       throw new RemoteDataError("The merged data is not valid.");
     }
     if (equal(merged.cloud, remote)) {
-      const metaVersion2 = await writeMeta(options);
+      const metaVersion2 = await writeMeta(options, false);
       return done(merged.merged, merged.cloud, file.version, metaVersion2, merged.conflicts, false);
     }
     const version = await tryWrite(provider, path, merged.cloud, file.version);
     if (version === null) continue;
-    const metaVersion = await writeMeta(options);
+    const metaVersion = await writeMeta(options, true);
     return done(merged.merged, merged.cloud, version, metaVersion, merged.conflicts, true);
   }
   throw new SyncBusyError();
@@ -588,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;
@@ -681,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 {
@@ -695,13 +729,26 @@ var getJson = async (send, token, url) => {
   } catch {
     throw new ProviderError("network", "GitHub could not be reached.");
   }
-  if (response.status === 401 || response.status === 403) {
-    throw new ProviderError("auth", "The token is not valid.", response.status);
+  if (!response.ok) {
+    const { status } = response;
+    const detail = await detailOf(response);
+    if (status === 401 || status === 403) {
+      throw new ProviderError("auth", "The token is not valid.", status, void 0, detail);
+    }
+    if (status >= 500)
+      throw new ProviderError("server", "GitHub failed.", status, void 0, detail);
+    throw new ProviderError(
+      "invalid",
+      "GitHub answer is not understood.",
+      status,
+      void 0,
+      detail
+    );
   }
-  if (response.status >= 500) throw new ProviderError("server", "GitHub failed.", response.status);
-  const body = response.ok ? await response.json().catch(() => null) : null;
-  if (!isRecord4(body))
+  const body = await response.json().catch(() => null);
+  if (!isRecord5(body)) {
     throw new ProviderError("invalid", "GitHub answer is not understood.", response.status);
+  }
   return body;
 };
 var listInstalledRepositories = async (token, send = (...args) => globalThis.fetch(...args)) => {
@@ -710,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(
@@ -719,17 +766,285 @@ 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 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] = await this.children(parentId, name);
+    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`, {
+      body: JSON.stringify({ name, mimeType: FOLDER_TYPE, parents: [parentId] }),
+      headers: { "Content-Type": "application/json" }
+    });
+    const id = this.stringField(await response.json(), "id");
+    const [oldest] = await this.children(parentId, name, true);
+    if (oldest.id !== id) {
+      await this.deleteItem(id);
+      return oldest.id;
+    }
+    return 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`,
+      { body, headers: { "Content-Type": `multipart/related; boundary=${boundary}` } }
+    );
+    const answer = await response.json();
+    return {
+      id: this.stringField(answer, "id"),
+      version: this.stringField(answer, "headRevisionId")
+    };
+  }
+  async deleteItem(id) {
+    await this.request("DELETE", `${API3}/files/${encodeURIComponent(id)}`, { allowMissing: true });
+  }
+  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,
@@ -745,6 +1060,7 @@ export {
   emptyMeta,
   encodeBase64,
   equal,
+  googleAuthorizeUrl,
   installUrl,
   isAppId,
   isObject,