@stackframe/stack-shared 2.6.36 → 2.6.38

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @stackframe/stack-shared
 
+## 2.6.38
+
+### Patch Changes
+
+- Various changes
+  - @stackframe/stack-sc@2.6.38
+
+## 2.6.37
+
+### Patch Changes
+
+- Various changes
+  - @stackframe/stack-sc@2.6.37
+
 ## 2.6.36
 
 ### Patch Changes

package/dist/utils/caches.d.ts

@@ -37,7 +37,7 @@ export declare class AsyncCache<D extends any[], T> {
     readonly forceSetCachedValue: (key: D, value: T) => void;
     readonly forceSetCachedValueAsync: (key: D, value: Promise<T>) => ReactPromise<boolean>;
     readonly refresh: (key: D) => Promise<T>;
-    readonly invalidate: (key: D) => Promise<T>;
+    readonly invalidate: (key: D) => void;
     readonly onStateChange: (key: D, callback: (value: T, oldValue: T | undefined) => void) => {
         unsubscribe: () => void;
     };
@@ -78,8 +78,15 @@ declare class AsyncValueCache<T> {
     private _refetch;
     forceSetCachedValue(value: T): void;
     forceSetCachedValueAsync(value: Promise<T>): ReactPromise<boolean>;
+    /**
+     * Refetches the value from the fetcher, and updates the cache with it.
+     */
     refresh(): Promise<T>;
-    invalidate(): Promise<T>;
+    /**
+     * Invalidates the cache, marking it to refresh on the next read. If anyone was listening to it, it will refresh
+     * immediately.
+     */
+    invalidate(): void;
     onStateChange(callback: (value: T, oldValue: T | undefined) => void): {
         unsubscribe: () => void;
     };

package/dist/utils/caches.js

@@ -1,6 +1,6 @@
 import { DependenciesMap } from "./maps";
 import { filterUndefined } from "./objects";
-import { pending, rateLimited, resolved, runAsynchronously } from "./promises";
+import { pending, rateLimited, resolved, runAsynchronously, wait } from "./promises";
 import { AsyncStore } from "./stores";
 /**
  * Can be used to cache the result of a function call, for example for the `use` hook in React.
@@ -111,23 +111,42 @@ class AsyncValueCache {
     forceSetCachedValueAsync(value) {
         return this._setAsync(value);
     }
+    /**
+     * Refetches the value from the fetcher, and updates the cache with it.
+     */
     async refresh() {
         return await this.getOrWait("write-only");
     }
-    async invalidate() {
+    /**
+     * Invalidates the cache, marking it to refresh on the next read. If anyone was listening to it, it will refresh
+     * immediately.
+     */
+    invalidate() {
         this._store.setUnavailable();
         this._pendingPromise = undefined;
-        return await this.refresh();
+        if (this._subscriptionsCount > 0) {
+            runAsynchronously(this.refresh());
+        }
     }
     onStateChange(callback) {
         const storeObj = this._store.onChange(callback);
+        runAsynchronously(this.getOrWait("read-write"));
         if (this._subscriptionsCount++ === 0 && this._options.onSubscribe) {
+            let mostRecentRefreshPromiseIndex = 0;
             const unsubscribe = this._options.onSubscribe(() => {
-                runAsynchronously(this.refresh());
+                const currentRefreshPromiseIndex = mostRecentRefreshPromiseIndex++;
+                runAsynchronously(async () => {
+                    // wait a few seconds; if anything changes during that time, we don't want to refresh
+                    // else we do unnecessary requests if we unsubscribe and then subscribe again immediately
+                    await wait(5000);
+                    if (this._subscriptionsCount === 0 && currentRefreshPromiseIndex === mostRecentRefreshPromiseIndex) {
+                        this.invalidate();
+                    }
+                });
             });
             this._unsubscribers.push(unsubscribe);
         }
-        runAsynchronously(this.refresh());
+        console.log("add", this._subscriptionsCount, new Date().toISOString());
         let hasUnsubscribed = false;
         return {
             unsubscribe: () => {
@@ -135,6 +154,7 @@ class AsyncValueCache {
                     return;
                 hasUnsubscribed = true;
                 storeObj.unsubscribe();
+                console.log("remove", this._subscriptionsCount - 1, new Date().toISOString());
                 if (--this._subscriptionsCount === 0) {
                     for (const unsubscribe of this._unsubscribers) {
                         unsubscribe();

package/dist/utils/errors.d.ts

@@ -28,6 +28,7 @@ export declare class StackAssertionError extends Error {
     readonly extraData?: (Record<string, any> & ErrorOptions) | undefined;
     constructor(message: string, extraData?: (Record<string, any> & ErrorOptions) | undefined);
 }
+export declare function errorToNiceString(error: unknown): string;
 export declare function registerErrorSink(sink: (location: string, error: unknown) => void): void;
 export declare function captureError(location: string, error: unknown): void;
 type Status = {

package/dist/utils/errors.js

@@ -64,6 +64,15 @@ export class StackAssertionError extends Error {
     }
 }
 StackAssertionError.prototype.name = "StackAssertionError";
+export function errorToNiceString(error) {
+    if (!(error instanceof Error))
+        return `${typeof error}<${error}>`;
+    const stack = error.stack ?? "";
+    const toString = error.toString();
+    if (stack.startsWith(toString))
+        return stack;
+    return `${toString}\n${stack}`;
+}
 const errorSinks = new Set();
 export function registerErrorSink(sink) {
     if (errorSinks.has(sink)) {
@@ -71,8 +80,11 @@ export function registerErrorSink(sink) {
     }
     errorSinks.add(sink);
 }
-registerErrorSink((location, ...args) => {
-    console.error(`\x1b[41mCaptured error in ${location}:`, ...args, "\x1b[0m");
+registerErrorSink((location, error, ...extraArgs) => {
+    console.error(`\x1b[41mCaptured error in ${location}:`, 
+    // HACK: Log a nicified version of the error to get around buggy Next.js pretty-printing
+    // https://www.reddit.com/r/nextjs/comments/1gkxdqe/comment/m19kxgn/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button
+    errorToNiceString(error), ...extraArgs, "\x1b[0m");
 });
 registerErrorSink((location, error, ...extraArgs) => {
     globalVar.stackCapturedErrors = globalVar.stackCapturedErrors ?? [];

package/dist/utils/results.d.ts

@@ -69,7 +69,7 @@ declare class RetryError extends AggregateError {
     constructor(errors: unknown[]);
     get retries(): number;
 }
-declare function retry<T>(fn: (attempt: number) => Result<T> | Promise<Result<T>>, retries: number, { exponentialDelayBase }?: {
+declare function retry<T>(fn: (attempt: number) => Result<T> | Promise<Result<T>>, totalAttempts: number, { exponentialDelayBase }?: {
     exponentialDelayBase?: number | undefined;
 }): Promise<Result<T, RetryError>>;
 export {};

package/dist/utils/results.js

@@ -98,7 +98,7 @@ class RetryError extends AggregateError {
         const strings = errors.map(e => String(e));
         const isAllSame = strings.length > 1 && strings.every(s => s === strings[0]);
         super(errors, deindent `
-      Error after retrying ${errors.length} times.
+      Error after ${errors.length} attempts.
       
       ${isAllSame ? deindent `
         Attempts 1-${errors.length}:
@@ -116,16 +116,16 @@ class RetryError extends AggregateError {
     }
 }
 RetryError.prototype.name = "RetryError";
-async function retry(fn, retries, { exponentialDelayBase = 1000 } = {}) {
+async function retry(fn, totalAttempts, { exponentialDelayBase = 1000 } = {}) {
     const errors = [];
-    for (let i = 0; i < retries; i++) {
+    for (let i = 0; i < totalAttempts; i++) {
         const res = await fn(i);
         if (res.status === "ok") {
             return Result.ok(res.data);
         }
         else {
             errors.push(res.error);
-            if (i < retries - 1) {
+            if (i < totalAttempts - 1) {
                 await wait((Math.random() + 0.5) * exponentialDelayBase * (2 ** i));
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.6.36",
+  "version": "2.6.38",
   "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.36"
+    "@stackframe/stack-sc": "2.6.38"
   },
   "devDependencies": {
     "@simplewebauthn/types": "^11.0.0",