@stackframe/stack-shared 2.7.21 → 2.7.23

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @stackframe/stack-shared
 
+## 2.7.23
+
+### Patch Changes
+
+- Various changes
+
+## 2.7.22
+
+### Patch Changes
+
+- Various changes
+
 ## 2.7.21
 
 ### Patch Changes

package/dist/interface/serverInterface.d.ts

@@ -89,7 +89,7 @@ export declare class StackServerInterface extends StackClientInterface {
     }): Promise<void>;
     grantServerTeamUserPermission(teamId: string, userId: string, permissionId: string): Promise<void>;
     revokeServerTeamUserPermission(teamId: string, userId: string, permissionId: string): Promise<void>;
-    deleteServerServerUser(userId: string): Promise<void>;
+    deleteServerUser(userId: string): Promise<void>;
     createServerContactChannel(data: ContactChannelsCrud['Server']['Create']): Promise<ContactChannelsCrud['Server']['Read']>;
     updateServerContactChannel(userId: string, contactChannelId: string, data: ContactChannelsCrud['Server']['Update']): Promise<ContactChannelsCrud['Server']['Read']>;
     deleteServerContactChannel(userId: string, contactChannelId: string): Promise<void>;

package/dist/interface/serverInterface.js

@@ -235,7 +235,7 @@ export class StackServerInterface extends StackClientInterface {
             body: JSON.stringify({}),
         }, null);
     }
-    async deleteServerServerUser(userId) {
+    async deleteServerUser(userId) {
         await this.sendServerRequest(urlString `/users/${userId}`, {
             method: "DELETE",
             headers: {

package/dist/utils/compile-time.js

@@ -4,22 +4,8 @@
  * to exist at runtime).
  */
 export function scrambleDuringCompileTime(t) {
+    if (Math.random() < 0.00001 && Math.random() > 0.99999 && Math.random() < 0.00001 && Math.random() > 0.99999) {
+        return "this will never happen";
+    }
     return t;
 }
-import.meta.vitest?.test("scrambleDuringCompileTime", ({ expect }) => {
-    // Test with primitive values
-    expect(scrambleDuringCompileTime(42)).toBe(42);
-    expect(scrambleDuringCompileTime("hello")).toBe("hello");
-    expect(scrambleDuringCompileTime(true)).toBe(true);
-    expect(scrambleDuringCompileTime(null)).toBe(null);
-    expect(scrambleDuringCompileTime(undefined)).toBe(undefined);
-    // Test with objects (reference equality)
-    const obj = { a: 1 };
-    expect(scrambleDuringCompileTime(obj)).toBe(obj);
-    // Test with arrays (reference equality)
-    const arr = [1, 2, 3];
-    expect(scrambleDuringCompileTime(arr)).toBe(arr);
-    // Test with functions (reference equality)
-    const fn = () => "test";
-    expect(scrambleDuringCompileTime(fn)).toBe(fn);
-});

package/dist/utils/promises.js

@@ -67,12 +67,13 @@ import.meta.vitest?.test("createPromise", async ({ expect }) => {
     expect(multiResolvePromise.value).toBe(1); // Only first resolve took effect
     expect(await multiResolvePromise).toBe(1);
 });
-const resolvedCache = new DependenciesMap();
+let resolvedCache = null;
 /**
  * Like Promise.resolve(...), but also adds the status and value properties for use with React's `use` hook, and caches
  * the value so that invoking `resolved` twice returns the same promise.
  */
 export function resolved(value) {
+    resolvedCache ??= new DependenciesMap();
     if (resolvedCache.has([value])) {
         return resolvedCache.get([value]);
     }
@@ -103,12 +104,13 @@ import.meta.vitest?.test("resolved", async ({ expect }) => {
     const promise4 = resolved(43);
     expect(promise4).not.toBe(promise1);
 });
-const rejectedCache = new DependenciesMap();
+let rejectedCache = null;
 /**
  * Like Promise.reject(...), but also adds the status and value properties for use with React's `use` hook, and caches
  * the value so that invoking `rejected` twice returns the same promise.
  */
 export function rejected(reason) {
+    rejectedCache ??= new DependenciesMap();
     if (rejectedCache.has([reason])) {
         return rejectedCache.get([reason]);
     }

package/dist/utils/results.d.ts

@@ -67,9 +67,11 @@ declare function mapResult<T, U, E = unknown, P = unknown>(result: AsyncResult<T
 declare class RetryError extends AggregateError {
     readonly errors: unknown[];
     constructor(errors: unknown[]);
-    get retries(): number;
+    get attempts(): number;
 }
-declare function retry<T>(fn: (attempt: number) => Result<T> | Promise<Result<T>>, totalAttempts: number, { exponentialDelayBase }?: {
+declare function retry<T>(fn: (attemptIndex: number) => Result<T> | Promise<Result<T>>, totalAttempts: number, { exponentialDelayBase }?: {
     exponentialDelayBase?: number | undefined;
-}): Promise<Result<T, RetryError>>;
+}): Promise<Result<T, RetryError> & {
+    attempts: number;
+}>;
 export {};

package/dist/utils/results.js

@@ -1,3 +1,4 @@
+import { wait } from "./promises";
 import { deindent } from "./strings";
 export const Result = {
     fromThrowing,
@@ -270,7 +271,7 @@ class RetryError extends AggregateError {
         this.errors = errors;
         this.name = "RetryError";
     }
-    get retries() {
+    get attempts() {
         return this.errors.length;
     }
 }
@@ -281,7 +282,7 @@ import.meta.vitest?.test("RetryError", ({ expect }) => {
     const retryErrorSingle = new RetryError([singleError]);
     expect(retryErrorSingle.name).toBe("RetryError");
     expect(retryErrorSingle.errors).toEqual([singleError]);
-    expect(retryErrorSingle.retries).toBe(1);
+    expect(retryErrorSingle.attempts).toBe(1);
     expect(retryErrorSingle.cause).toBe(singleError);
     expect(retryErrorSingle.message).toContain("Error after 1 attempts");
     // Test with multiple different errors
@@ -290,7 +291,7 @@ import.meta.vitest?.test("RetryError", ({ expect }) => {
     const retryErrorMultiple = new RetryError([error1, error2]);
     expect(retryErrorMultiple.name).toBe("RetryError");
     expect(retryErrorMultiple.errors).toEqual([error1, error2]);
-    expect(retryErrorMultiple.retries).toBe(2);
+    expect(retryErrorMultiple.attempts).toBe(2);
     expect(retryErrorMultiple.cause).toBe(error2);
     expect(retryErrorMultiple.message).toContain("Error after 2 attempts");
     expect(retryErrorMultiple.message).toContain("Attempt 1");
@@ -300,7 +301,7 @@ import.meta.vitest?.test("RetryError", ({ expect }) => {
     const retryErrorSame = new RetryError([sameError, sameError]);
     expect(retryErrorSame.name).toBe("RetryError");
     expect(retryErrorSame.errors).toEqual([sameError, sameError]);
-    expect(retryErrorSame.retries).toBe(2);
+    expect(retryErrorSame.attempts).toBe(2);
     expect(retryErrorSame.cause).toBe(sameError);
     expect(retryErrorSame.message).toContain("Error after 2 attempts");
     expect(retryErrorSame.message).toContain("Attempts 1-2");
@@ -310,61 +311,38 @@ async function retry(fn, totalAttempts, { exponentialDelayBase = 1000 } = {}) {
     for (let i = 0; i < totalAttempts; i++) {
         const res = await fn(i);
         if (res.status === "ok") {
-            return Result.ok(res.data);
+            return Object.assign(Result.ok(res.data), { attempts: i + 1 });
         }
         else {
             errors.push(res.error);
             if (i < totalAttempts - 1) {
-                // Just use a minimal delay for testing
-                await new Promise(resolve => setTimeout(resolve, 1));
+                await wait((Math.random() + 0.5) * exponentialDelayBase * (2 ** i));
             }
         }
     }
-    return Result.error(new RetryError(errors));
+    return Object.assign(Result.error(new RetryError(errors)), { attempts: totalAttempts });
 }
 import.meta.vitest?.test("retry", async ({ expect }) => {
-    // We don't need to mock the wait function anymore
-    // Instead, we've modified the retry function to use a minimal delay
-    try {
-        // Test successful on first attempt
-        const successFn = async () => Result.ok("success");
-        const successResult = await retry(successFn, 3);
-        expect(successResult.status).toBe("ok");
-        if (successResult.status === "ok") {
-            expect(successResult.data).toBe("success");
-        }
-        // Test successful after failures
-        let attemptCount = 0;
-        const eventualSuccessFn = async () => {
-            attemptCount++;
-            if (attemptCount < 2) {
-                return Result.error(new Error(`Attempt ${attemptCount} failed`));
-            }
-            return Result.ok("eventual success");
-        };
-        const eventualSuccessResult = await retry(eventualSuccessFn, 3);
-        expect(eventualSuccessResult.status).toBe("ok");
-        if (eventualSuccessResult.status === "ok") {
-            expect(eventualSuccessResult.data).toBe("eventual success");
-        }
-        // Test all attempts fail
-        const error1 = new Error("Error 1");
-        const error2 = new Error("Error 2");
-        const error3 = new Error("Error 3");
-        const allFailFn = async (attempt) => {
-            const errors = [error1, error2, error3];
-            return Result.error(errors[attempt]);
-        };
-        const allFailResult = await retry(allFailFn, 3);
-        expect(allFailResult.status).toBe("error");
-        if (allFailResult.status === "error") {
-            expect(allFailResult.error).toBeInstanceOf(RetryError);
-            const retryError = allFailResult.error;
-            expect(retryError.errors).toEqual([error1, error2, error3]);
-            expect(retryError.retries).toBe(3);
-        }
-    }
-    finally {
-        // No cleanup needed
-    }
+    // Test successful on first attempt
+    const successFn = async () => Result.ok("success");
+    const successResult = await retry(successFn, 3, { exponentialDelayBase: 0 });
+    expect(successResult).toEqual({ status: "ok", data: "success", attempts: 1 });
+    // Test successful after failures
+    let attemptCount = 0;
+    const eventualSuccessFn = async () => {
+        return ++attemptCount < 2 ? Result.error(new Error(`Attempt ${attemptCount} failed`))
+            : Result.ok("eventual success");
+    };
+    const eventualSuccessResult = await retry(eventualSuccessFn, 3, { exponentialDelayBase: 0 });
+    expect(eventualSuccessResult).toEqual({ status: "ok", data: "eventual success", attempts: 2 });
+    // Test all attempts fail
+    const errors = [new Error("Error 1"), new Error("Error 2"), new Error("Error 3")];
+    const allFailFn = async (attempt) => {
+        return Result.error(errors[attempt]);
+    };
+    const allFailResult = await retry(allFailFn, 3, { exponentialDelayBase: 0 });
+    expect(allFailResult).toEqual({ status: "error", error: expect.any(RetryError), attempts: 3 });
+    const retryError = allFailResult.error;
+    expect(retryError.errors).toEqual(errors);
+    expect(retryError.attempts).toBe(3);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.7.21",
+  "version": "2.7.23",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",