@gamerdexapp/gamerdex-sync 0.2.1 → 0.3.1

package/dist/index.mjs

@@ -291,7 +291,8 @@ var isRecord2 = (value) => typeof value === "object" && value !== null && !Array
 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;
+  const nested = isRecord2(body.error) ? body.error.message : void 0;
+  const message = nested ?? body.message ?? body.error_summary;
   return typeof message === "string" ? message.slice(0, MAX_DETAIL_LENGTH) : void 0;
 };
 
@@ -1040,8 +1041,354 @@ var googleAuthorizeUrl = (clientId, redirectUri, state) => {
   });
   return `https://accounts.google.com/o/oauth2/v2/auth?${query}`;
 };
+
+// src/provider/dropbox.ts
+var API4 = "https://api.dropboxapi.com/2";
+var CONTENT = "https://content.dropboxapi.com/2";
+var isRecord7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var headerJson = (value) => JSON.stringify(value).replace(
+  /[\u007f-￿]/g,
+  (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`
+);
+var tagsOf = (value, found = /* @__PURE__ */ new Set()) => {
+  if (!isRecord7(value)) return found;
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === ".tag" && typeof entry === "string") found.add(entry);
+    else tagsOf(entry, found);
+  }
+  return found;
+};
+var retryAfterOf2 = (response, body) => {
+  const header = response.headers.get("retry-after");
+  if (header !== null && Number.isFinite(Number(header))) return Number(header);
+  const seconds = isRecord7(body) && isRecord7(body.error) ? body.error.retry_after : void 0;
+  return typeof seconds === "number" ? seconds : void 0;
+};
+var DropboxProvider = class {
+  constructor(options) {
+    this.options = options;
+    this.send = options.fetch ?? ((...args) => globalThis.fetch(...args));
+  }
+  options;
+  send;
+  async read(path) {
+    const response = await this.request(`${CONTENT}/files/download`, {
+      "Dropbox-API-Arg": headerJson({ path: `/${path}` })
+    });
+    if (!response.ok) {
+      const failure = await this.failure(response);
+      if (failure.tags.has("not_found")) return null;
+      throw this.unexpected(failure);
+    }
+    const result = JSON.parse(response.headers.get("dropbox-api-result") ?? "null");
+    if (!isRecord7(result) || typeof result.rev !== "string") {
+      throw this.invalid("The file has no version.");
+    }
+    return { content: await response.text(), version: result.rev };
+  }
+  async write(path, content, expectedVersion) {
+    const mode = expectedVersion === null ? { ".tag": "add" } : { ".tag": "update", update: expectedVersion };
+    const response = await this.request(
+      `${CONTENT}/files/upload`,
+      {
+        "Content-Type": "application/octet-stream",
+        "Dropbox-API-Arg": headerJson({
+          path: `/${path}`,
+          mode,
+          autorename: false,
+          mute: true,
+          strict_conflict: true
+        })
+      },
+      content
+    );
+    if (!response.ok) {
+      const failure = await this.failure(response);
+      if (failure.tags.has("conflict")) throw new VersionConflictError(path);
+      throw this.unexpected(failure);
+    }
+    const result = await response.json().catch(() => null);
+    if (!isRecord7(result) || typeof result.rev !== "string") {
+      throw this.invalid("The write returned no version.");
+    }
+    return { version: result.rev };
+  }
+  async remove(path, expectedVersion) {
+    const response = await this.request(
+      `${API4}/files/delete_v2`,
+      { "Content-Type": "application/json" },
+      JSON.stringify({ path: `/${path}`, parent_rev: expectedVersion })
+    );
+    if (response.ok) return;
+    const failure = await this.failure(response);
+    if (failure.tags.has("conflict")) throw new VersionConflictError(path);
+    if (failure.tags.has("not_found")) {
+      if (await this.read(path) !== null) throw new VersionConflictError(path);
+      return;
+    }
+    throw this.unexpected(failure);
+  }
+  async request(url, headers, body) {
+    const token = await this.options.getToken();
+    try {
+      return await this.send(url, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${token}`, ...headers },
+        body
+      });
+    } catch {
+      throw new ProviderError("network", "Dropbox could not be reached.");
+    }
+  }
+  /**
+   * Reads a failed answer. Dropbox reports a failure that belongs to the call, such as a missing
+   * file or a conflict, with status 409. The caller decides what that means. Every other status
+   * is a failure of the request and is thrown here.
+   */
+  async failure(response) {
+    const { status } = response;
+    const body = await response.clone().json().catch(() => null);
+    const detail = await detailOf(response);
+    if (status === 409) return { status, tags: tagsOf(isRecord7(body) ? body.error : null), detail };
+    if (status === 401) {
+      throw new ProviderError("auth", "The token is not valid.", status, void 0, detail);
+    }
+    if (status === 403) {
+      throw new ProviderError(
+        "auth",
+        "The token has no permission for Dropbox.",
+        status,
+        void 0,
+        detail
+      );
+    }
+    if (status === 429) {
+      throw new ProviderError(
+        "rate-limit",
+        "Dropbox limits the calls.",
+        status,
+        retryAfterOf2(response, body),
+        detail
+      );
+    }
+    if (status >= 500) {
+      throw new ProviderError("server", "Dropbox failed.", status, void 0, detail);
+    }
+    throw this.invalid(`Dropbox answered ${status}.`, status, detail);
+  }
+  unexpected({ status, tags, detail }) {
+    if (tags.has("too_many_write_operations")) {
+      return new ProviderError(
+        "rate-limit",
+        "Dropbox limits the writes.",
+        status,
+        void 0,
+        detail
+      );
+    }
+    if (tags.has("no_write_permission")) {
+      return new ProviderError(
+        "auth",
+        "The token has no permission for Dropbox.",
+        status,
+        void 0,
+        detail
+      );
+    }
+    if (tags.has("insufficient_space")) {
+      return this.invalid("Dropbox has no space left.", status, detail);
+    }
+    return this.invalid(`Dropbox answered ${status}.`, status, detail);
+  }
+  invalid(message, status, detail) {
+    return new ProviderError("invalid", message, status, void 0, detail);
+  }
+};
+
+// src/provider/onedrive.ts
+var APP_FOLDER = "https://graph.microsoft.com/v1.0/me/drive/special/approot";
+var isRecord8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var encodePath2 = (path) => path.split("/").map(encodeURIComponent).join("/");
+var retryAfterOf3 = (response) => {
+  const header = response.headers.get("retry-after");
+  return header !== null && Number.isFinite(Number(header)) ? Number(header) : void 0;
+};
+var OneDriveProvider = class {
+  constructor(options) {
+    this.options = options;
+    this.send = options.fetch ?? ((...args) => globalThis.fetch(...args));
+  }
+  options;
+  send;
+  async read(path) {
+    const info = await this.info(path);
+    if (info === null) return null;
+    const content = await this.fetchContent(info.downloadUrl);
+    return content === null ? null : { content, version: info.eTag };
+  }
+  async write(path, content, expectedVersion) {
+    const url = expectedVersion === null ? `${this.itemUrl(path)}:/content?@microsoft.graph.conflictBehavior=fail` : `${this.itemUrl(path)}:/content`;
+    const response = await this.request(
+      "PUT",
+      url,
+      { "Content-Type": "text/plain", ...this.ifMatch(expectedVersion) },
+      content
+    );
+    const expectedFileIsGone = expectedVersion !== null && response.status === 404;
+    if (response.status === 412 || response.status === 409 || expectedFileIsGone) {
+      throw new VersionConflictError(path);
+    }
+    await this.assertOk(response);
+    const result = await response.json().catch(() => null);
+    if (expectedVersion !== null && response.status === 201) {
+      await this.undoCreate(path, result);
+      throw new VersionConflictError(path);
+    }
+    if (!isRecord8(result) || typeof result.eTag !== "string") {
+      throw this.invalid("The write returned no version.");
+    }
+    return { version: result.eTag };
+  }
+  async remove(path, expectedVersion) {
+    const response = await this.request(
+      "DELETE",
+      this.itemUrl(path),
+      this.ifMatch(expectedVersion)
+    );
+    if (response.status === 404) return;
+    if (response.status === 412) throw new VersionConflictError(path);
+    await this.assertOk(response);
+  }
+  /**
+   * OneDrive creates the file when a write with `If-Match` finds none, which would undo the
+   * removal that another device made. The file that was just created is removed again.
+   */
+  async undoCreate(path, created) {
+    if (!isRecord8(created) || typeof created.eTag !== "string") return;
+    try {
+      await this.remove(path, created.eTag);
+    } catch (error) {
+      if (!(error instanceof VersionConflictError)) throw error;
+    }
+  }
+  itemUrl(path) {
+    return `${APP_FOLDER}:/${encodePath2(path)}`;
+  }
+  ifMatch(version) {
+    return version === null ? {} : { "If-Match": version };
+  }
+  async info(path) {
+    const response = await this.request("GET", this.itemUrl(path));
+    if (response.status === 404) return null;
+    await this.assertOk(response);
+    const body = await response.json().catch(() => null);
+    if (!isRecord8(body) || typeof body.eTag !== "string") {
+      throw this.invalid("The file has no version.");
+    }
+    const url = body["@microsoft.graph.downloadUrl"];
+    if (typeof url !== "string") throw this.invalid("The file has no download address.");
+    return { eTag: body.eTag, downloadUrl: url };
+  }
+  /** The download address is signed, so it must not carry the token. */
+  async fetchContent(url) {
+    let response;
+    try {
+      response = await this.send(url);
+    } catch {
+      throw new ProviderError("network", "OneDrive could not be reached.");
+    }
+    if (response.status === 404) return null;
+    await this.assertOk(response);
+    return response.text();
+  }
+  async request(method, url, headers = {}, body) {
+    const token = await this.options.getToken();
+    try {
+      return await this.send(url, {
+        method,
+        headers: { Authorization: `Bearer ${token}`, ...headers },
+        body
+      });
+    } catch {
+      throw new ProviderError("network", "OneDrive could not be reached.");
+    }
+  }
+  async assertOk(response) {
+    if (response.ok) return;
+    const { status } = response;
+    const detail = await detailOf(response);
+    if (status === 401) {
+      throw new ProviderError("auth", "The token is not valid.", status, void 0, detail);
+    }
+    if (status === 403) {
+      throw new ProviderError(
+        "auth",
+        "The token has no permission for OneDrive.",
+        status,
+        void 0,
+        detail
+      );
+    }
+    if (status === 429 || status === 503 && retryAfterOf3(response) !== void 0) {
+      throw new ProviderError(
+        "rate-limit",
+        "OneDrive limits the calls.",
+        status,
+        retryAfterOf3(response),
+        detail
+      );
+    }
+    if (status === 404) {
+      throw new ProviderError(
+        "not-found",
+        "The app folder was not found.",
+        status,
+        void 0,
+        detail
+      );
+    }
+    if (status >= 500) {
+      throw new ProviderError("server", "OneDrive failed.", status, void 0, detail);
+    }
+    throw this.invalid(`OneDrive answered ${status}.`, status, detail);
+  }
+  invalid(message, status, detail) {
+    return new ProviderError("invalid", message, status, void 0, detail);
+  }
+};
+
+// src/auth/dropbox.ts
+var DROPBOX_SCOPES = ["files.content.read", "files.content.write"];
+var dropboxAuthorizeUrl = (clientId, redirectUri, state) => {
+  const query = new URLSearchParams({
+    client_id: clientId,
+    redirect_uri: redirectUri,
+    response_type: "code",
+    token_access_type: "offline",
+    scope: DROPBOX_SCOPES.join(" "),
+    state
+  });
+  return `https://www.dropbox.com/oauth2/authorize?${query}`;
+};
+
+// src/auth/microsoft.ts
+var ONEDRIVE_FILE_SCOPE = "Files.ReadWrite.AppFolder";
+var ONEDRIVE_SCOPES = [ONEDRIVE_FILE_SCOPE, "offline_access"];
+var microsoftAuthorizeUrl = (clientId, redirectUri, state) => {
+  const query = new URLSearchParams({
+    client_id: clientId,
+    redirect_uri: redirectUri,
+    response_type: "code",
+    response_mode: "query",
+    scope: ONEDRIVE_SCOPES.join(" "),
+    state
+  });
+  return `https://login.microsoftonline.com/consumers/oauth2/v2.0/authorize?${query}`;
+};
 export {
   DATA_FILE,
+  DROPBOX_SCOPES,
+  DropboxProvider,
   GITHUB_APP,
   GOOGLE_DRIVE_SCOPE,
   GitHubProvider,
@@ -1049,6 +1396,9 @@ export {
   META_FILE,
   META_FORMAT,
   MemoryProvider,
+  ONEDRIVE_FILE_SCOPE,
+  ONEDRIVE_SCOPES,
+  OneDriveProvider,
   ProviderError,
   ROOT_FOLDER,
   RemoteDataError,
@@ -1058,6 +1408,7 @@ export {
   createTokenSource,
   dataPath,
   decodeBase64,
+  dropboxAuthorizeUrl,
   emptyMeta,
   encodeBase64,
   equal,
@@ -1068,6 +1419,7 @@ export {
   listInstalledRepositories,
   merge,
   metaPath,
+  microsoftAuthorizeUrl,
   newState,
   parseMeta,
   parseTokenResponse,