@stackframe/stack-shared 2.6.31 → 2.6.32

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @stackframe/stack-shared
 
+## 2.6.32
+
+### Patch Changes
+
+- Bugfixes
+  - @stackframe/stack-sc@2.6.32
+
 ## 2.6.31
 
 ### Patch Changes

package/dist/interface/clientInterface.d.ts

@@ -33,6 +33,7 @@ export declare class StackClientInterface {
         prodDashboard: string;
         prodBackend: string;
     }>;
+    protected _createNetworkError(cause: Error, session?: InternalSession | null, requestType?: "client" | "server" | "admin"): Promise<Error>;
     protected _networkRetry<T>(cb: () => Promise<Result<T, any>>, session?: InternalSession | null, requestType?: "client" | "server" | "admin"): Promise<T>;
     protected _networkRetryException<T>(cb: () => Promise<T>, session?: InternalSession | null, requestType?: "client" | "server" | "admin"): Promise<T>;
     fetchNewAccessToken(refreshToken: RefreshToken): Promise<AccessToken | null>;

package/dist/interface/clientInterface.js

@@ -5,7 +5,9 @@ import { AccessToken, InternalSession } from '../sessions';
 import { generateSecureRandomString } from '../utils/crypto';
 import { StackAssertionError, throwErr } from '../utils/errors';
 import { globalVar } from '../utils/globals';
+import { HTTP_METHODS } from '../utils/http';
 import { filterUndefined } from '../utils/objects';
+import { wait } from '../utils/promises';
 import { Result } from "../utils/results";
 import { deindent } from '../utils/strings';
 export class StackClientInterface {
@@ -68,6 +70,17 @@ export class StackClientInterface {
             prodBackend,
         };
     }
+    async _createNetworkError(cause, session, requestType) {
+        return new Error(deindent `
+      Stack Auth is unable to connect to the server. Please check your internet connection and try again.
+      
+      If the problem persists, please contact support and provide a screenshot of your entire browser console.
+
+      ${cause}
+      
+      ${JSON.stringify(await this.runNetworkDiagnostics(session, requestType), null, 2)}
+    `, { cause: cause });
+    }
     async _networkRetry(cb, session, requestType) {
         const retriedResult = await Result.retry(cb, 5, { exponentialDelayBase: 1000 });
         // try to diagnose the error for the user
@@ -75,15 +88,7 @@ export class StackClientInterface {
             if (globalVar.navigator && !globalVar.navigator.onLine) {
                 throw new Error("Failed to send Stack network request. It seems like you are offline. (window.navigator.onLine is falsy)", { cause: retriedResult.error });
             }
-            throw new Error(deindent `
-        Stack Auth is unable to connect to the server. Please check your internet connection and try again.
-        
-        If the problem persists, please contact support and provide a screenshot of your entire browser console.
-
-        ${retriedResult.error}
-        
-        ${JSON.stringify(await this.runNetworkDiagnostics(session, requestType), null, 2)}
-      `, { cause: retriedResult.error });
+            throw this._createNetworkError(retriedResult.error, session, requestType);
         }
         return retriedResult.data;
     }
@@ -220,8 +225,13 @@ export class StackClientInterface {
         }
         catch (e) {
             if (e instanceof TypeError) {
-                // Network error, retry
-                return Result.error(e);
+                // Likely to be a network error. Retry if the request is idempotent, throw network error otherwise.
+                if (HTTP_METHODS[(params.method ?? "GET")].idempotent) {
+                    return Result.error(e);
+                }
+                else {
+                    throw this._createNetworkError(e, session, requestType);
+                }
             }
             throw e;
         }
@@ -254,10 +264,25 @@ export class StackClientInterface {
         if (res.ok) {
             return Result.ok(res);
         }
+        else if (res.status === 429) {
+            // Rate limited, so retry if we can
+            const retryAfter = res.headers.get("Retry-After");
+            if (retryAfter !== null) {
+                await wait(Number(retryAfter) * 1000);
+                return Result.error(new Error(`Rate limited, retrying after ${retryAfter} seconds`));
+            }
+            return Result.error(new Error("Rate limited, no retry-after header received"));
+        }
         else {
             const error = await res.text();
+            const errorObj = new StackAssertionError(`Failed to send request to ${url}: ${res.status} ${error}`, { request: params, res });
+            if (res.status === 508 && error.includes("INFINITE_LOOP_DETECTED")) {
+                // Some Vercel deployments seem to have an odd infinite loop bug. In that case, retry.
+                // See: https://github.com/stack-auth/stack/issues/319
+                return Result.error(errorObj);
+            }
             // Do not retry, throw error instead of returning one
-            throw new StackAssertionError(`Failed to send request to ${url}: ${res.status} ${error}`, { request: params, res });
+            throw errorObj;
         }
     }
     async _processResponse(rawRes) {

package/dist/utils/bytes.d.ts

@@ -4,6 +4,7 @@ export declare function encodeBase64(input: Uint8Array): string;
 export declare function decodeBase64(input: string): Uint8Array;
 export declare function encodeBase64Url(input: Uint8Array): string;
 export declare function decodeBase64Url(input: string): Uint8Array;
+export declare function decodeBase64OrBase64Url(input: string): Uint8Array;
 export declare function isBase32(input: string): boolean;
 export declare function isBase64(input: string): boolean;
 export declare function isBase64Url(input: string): boolean;

package/dist/utils/bytes.js

@@ -82,6 +82,17 @@ export function decodeBase64Url(input) {
     }
     return decodeBase64(input.replace(/-/g, "+").replace(/_/g, "/") + "====".slice((input.length - 1) % 4 + 1));
 }
+export function decodeBase64OrBase64Url(input) {
+    if (isBase64Url(input)) {
+        return decodeBase64Url(input);
+    }
+    else if (isBase64(input)) {
+        return decodeBase64(input);
+    }
+    else {
+        throw new StackAssertionError("Invalid base64 or base64url string");
+    }
+}
 export function isBase32(input) {
     for (const char of input) {
         if (char === " ")

package/dist/utils/http.d.ts

@@ -1,2 +1,39 @@
-export declare const HTTP_METHODS: readonly ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"];
-export type HttpMethod = typeof HTTP_METHODS[number];
+export declare const HTTP_METHODS: {
+    readonly GET: {
+        readonly safe: true;
+        readonly idempotent: true;
+    };
+    readonly POST: {
+        readonly safe: false;
+        readonly idempotent: false;
+    };
+    readonly PUT: {
+        readonly safe: false;
+        readonly idempotent: true;
+    };
+    readonly DELETE: {
+        readonly safe: false;
+        readonly idempotent: true;
+    };
+    readonly PATCH: {
+        readonly safe: false;
+        readonly idempotent: false;
+    };
+    readonly OPTIONS: {
+        readonly safe: true;
+        readonly idempotent: true;
+    };
+    readonly HEAD: {
+        readonly safe: true;
+        readonly idempotent: true;
+    };
+    readonly TRACE: {
+        readonly safe: true;
+        readonly idempotent: true;
+    };
+    readonly CONNECT: {
+        readonly safe: false;
+        readonly idempotent: false;
+    };
+};
+export type HttpMethod = keyof typeof HTTP_METHODS;

package/dist/utils/http.js

@@ -1 +1,38 @@
-export const HTTP_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"];
+export const HTTP_METHODS = {
+    "GET": {
+        safe: true,
+        idempotent: true,
+    },
+    "POST": {
+        safe: false,
+        idempotent: false,
+    },
+    "PUT": {
+        safe: false,
+        idempotent: true,
+    },
+    "DELETE": {
+        safe: false,
+        idempotent: true,
+    },
+    "PATCH": {
+        safe: false,
+        idempotent: false,
+    },
+    "OPTIONS": {
+        safe: true,
+        idempotent: true,
+    },
+    "HEAD": {
+        safe: true,
+        idempotent: true,
+    },
+    "TRACE": {
+        safe: true,
+        idempotent: true,
+    },
+    "CONNECT": {
+        safe: false,
+        idempotent: false,
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.6.31",
+  "version": "2.6.32",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -50,7 +50,7 @@
     "oauth4webapi": "^2.10.3",
     "semver": "^7.6.3",
     "uuid": "^9.0.1",
-    "@stackframe/stack-sc": "2.6.31"
+    "@stackframe/stack-sc": "2.6.32"
   },
   "devDependencies": {
     "@simplewebauthn/types": "^11.0.0",