@rewritejs/sdk 1.0.0 → 1.0.1

package/dist/index.js

@@ -14,8 +14,33 @@ class HTTPError extends Error {
   }
 }
 
+class RateLimitError extends HTTPError {
+  limit;
+  global;
+  retryAfter;
+  constructor(message, url, method, context) {
+    super(message, 429, url, method);
+    this.limit = context.limit;
+    this.global = context.isGlobal;
+    this.retryAfter = context.retryAfter;
+    this.name = "RateLimitError";
+  }
+}
+
+class RewriteError extends Error {
+  message;
+  code;
+  detailed;
+  constructor(message, code, detailed) {
+    super(message);
+    this.message = message;
+    this.code = code;
+    this.detailed = detailed;
+  }
+}
+
 // node_modules/@rewritejs/rest/dist/utils.js
-var createURL = (route, query, baseURL = "https://api.userewrite.me") => {
+var createURL = (route, query, baseURL = "https://api.rewritetoday.com") => {
   const url = `${baseURL}/v1${route}`;
   return query ? `${url}?${new URLSearchParams(query)}` : url;
 };
@@ -30,6 +55,7 @@ var backoff = (attempt) => {
   return Math.floor(exp + jitter);
 };
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var RATE_LIMIT_STATUS = 429;
 
 // node_modules/@rewritejs/rest/dist/client.js
 class REST {
@@ -38,6 +64,7 @@ class REST {
   constructor(options) {
     this.options = typeof options === "string" ? { auth: options } : options;
     this.headers = {
+      "Content-Type": "application/json",
       ...this.options.headers,
       Authorization: `Bearer ${this.options.auth}`
     };
@@ -63,7 +90,7 @@ class REST {
     return this.fetch(route, { data, ...options, method: "PATCH" });
   }
   async fetch(route, options, attempt = 0) {
-    const response = await this.createRequest(route, options);
+    const response = await this.prefetch(route, options);
     if (!response.ok)
       return this.handleError({
         route,
@@ -77,19 +104,62 @@ class REST {
   }
   async handleError({ route, method, options, attempt, response }) {
     if (!isRetryableStatus(response.status)) {
-      const { error } = await response.json();
-      throw new HTTPError(error, response.status, response.url, method);
+      const { code, error, message } = await response.json();
+      throw new RewriteError(message, code, error.detailed);
     }
-    const { retry } = this.options;
+    const { onRateLimit, retry } = this.options;
+    const rateLimitContext = response.status === RATE_LIMIT_STATUS ? this.parseRateLimitContext(response) : null;
     if (attempt >= (retry?.max ?? 3))
-      throw new HTTPError("Max retries reached", response.status, response.url, method);
+      throw this.buildRetryExceededError(response, method, rateLimitContext);
+    if (rateLimitContext && onRateLimit)
+      await onRateLimit(rateLimitContext);
     if (retry?.onRetry)
       await retry.onRetry({ route, attempt, options, response, method });
-    const delay = (retry?.delay ?? backoff)(attempt);
+    const delay = this.resolveRetryDelay(attempt, retry, rateLimitContext);
     await sleep(delay);
     return this.fetch(route, options, attempt + 1);
   }
-  createRequest(route, options) {
+  buildRetryExceededError(response, method, rateLimitContext) {
+    if (rateLimitContext)
+      return new RateLimitError("Rate limit has not been reset yet", response.url, method, rateLimitContext);
+    return new HTTPError("Max retries reached", response.status, response.url, method);
+  }
+  resolveRetryDelay(attempt, retry, rateLimitContext) {
+    const retryAfterDelay = rateLimitContext?.retryAfter ?? 0;
+    if (retryAfterDelay > 0)
+      return retryAfterDelay;
+    return (retry?.delay ?? backoff)(attempt);
+  }
+  parseRateLimitContext(response) {
+    const { headers } = response;
+    const xRateLimitRetryAfter = this.parseNumberHeader(headers, "X-RateLimit-Retry-After");
+    const retryAfter = xRateLimitRetryAfter > 0 ? xRateLimitRetryAfter : this.parseRetryAfterHeader(headers.get("Retry-After"));
+    return {
+      retryAfter,
+      limit: Number(headers.get("X-RateLimit-Limit")),
+      isGlobal: this.parseBooleanHeader(headers, "X-RateLimit-Global")
+    };
+  }
+  parseNumberHeader(headers, key) {
+    const value = headers.get(key);
+    if (!value)
+      return 0;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  parseBooleanHeader(headers, key) {
+    return headers.get(key)?.toLowerCase() === "true";
+  }
+  parseRetryAfterHeader(header) {
+    if (!header)
+      return 0;
+    const seconds = Number(header);
+    if (Number.isFinite(seconds))
+      return Math.max(0, Math.ceil(seconds * 1000));
+    const date = Date.parse(header);
+    return Number.isNaN(date) ? 0 : Math.max(0, date - Date.now());
+  }
+  prefetch(route, options) {
     const timeout = options.timeout ?? this.options.timeout ?? FIVE_SECONDS_IN_MS;
     const url = createURL(route, options.query, this.options.baseURL);
     return fetch(url, {
@@ -306,7 +376,7 @@ class Rewrite {
   }
 }
 // src/version.ts
-var version = "1.0.0";
+var version = "1.0.1";
 export {
   version,
   Rewrite

package/dist/version.d.ts

@@ -1,4 +1,4 @@
 /**
  * Current version of [@rewritejs/sdk](https://www.npmjs.com/package/@rewritejs/sdk).
  */
-export declare const version: "1.0.0";
+export declare const version: "1.0.1";

package/package.json

@@ -3,16 +3,16 @@
 	"module": "src/index.ts",
 	"type": "module",
 	"private": false,
-	"version": "1.0.0",
+	"version": "1.0.1",
 	"devDependencies": {
 		"@biomejs/biome": "^2.4.2",
 		"@types/bun": "latest"
 	},
 	"peerDependencies": {
-		"typescript": "^5"
+		"typescript": "^5.9.3"
 	},
 	"dependencies": {
-		"@rewritejs/rest": "^1.0.1",
+		"@rewritejs/rest": "^1.0.2",
 		"@rewritejs/types": "^1.0.0"
 	},
 	"main": "./dist/index.js",