@stackframe/stack-shared 2.6.19 → 2.6.21

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @stackframe/stack-shared
 
+## 2.6.21
+
+### Patch Changes
+
+- Fixed inviteUser
+- Updated dependencies
+  - @stackframe/stack-sc@2.6.21
+
+## 2.6.20
+
+### Patch Changes
+
+- Next.js 15 fixes
+- Updated dependencies
+  - @stackframe/stack-sc@2.6.20
+
 ## 2.6.19
 
 ### Patch Changes

package/dist/interface/clientInterface.d.ts

@@ -90,7 +90,7 @@ export declare class StackClientInterface {
         email: string;
         teamId: string;
         callbackUrl: string;
-        session: InternalSession | null;
+        session: InternalSession;
     }): Promise<void>;
     acceptTeamInvitation<T extends 'use' | 'details' | 'check'>(options: {
         code: string;

package/dist/interface/clientInterface.js

@@ -162,7 +162,7 @@ export class StackClientInterface {
         let adminSession = "projectOwnerSession" in this.options ? this.options.projectOwnerSession : null;
         let adminTokenObj = adminSession ? await adminSession.getPotentiallyExpiredTokens() : null;
         // all requests should be dynamic to prevent Next.js caching
-        cookies?.();
+        await cookies?.();
         const url = this.getApiUrl() + path;
         const params = {
             /**

package/dist/interface/serverInterface.d.ts

@@ -77,6 +77,11 @@ export declare class StackServerInterface extends StackClientInterface {
         teamId: string;
         userId: string;
     }): Promise<void>;
+    updateServerTeamMemberProfile(options: {
+        teamId: string;
+        userId: string;
+        profile: TeamMemberProfilesCrud['Server']['Update'];
+    }): 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>;
@@ -85,4 +90,9 @@ export declare class StackServerInterface extends StackClientInterface {
     deleteServerContactChannel(userId: string, contactChannelId: string): Promise<void>;
     listServerContactChannels(userId: string): Promise<ContactChannelsCrud['Server']['Read'][]>;
     sendServerContactChannelVerificationEmail(userId: string, contactChannelId: string, callbackUrl: string): Promise<void>;
+    sendServerTeamInvitation(options: {
+        email: string;
+        teamId: string;
+        callbackUrl: string;
+    }): Promise<void>;
 }

package/dist/interface/serverInterface.js

@@ -199,6 +199,15 @@ export class StackServerInterface extends StackClientInterface {
             body: JSON.stringify({}),
         }, null);
     }
+    async updateServerTeamMemberProfile(options) {
+        await this.sendServerRequest(`/team-member-profiles/${options.teamId}/${options.userId}`, {
+            method: "PATCH",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(options.profile),
+        }, null);
+    }
     async grantServerTeamUserPermission(teamId, userId, permissionId) {
         await this.sendServerRequest(`/team-permissions/${teamId}/${userId}/${permissionId}`, {
             method: "POST",
@@ -267,4 +276,17 @@ export class StackServerInterface extends StackClientInterface {
             body: JSON.stringify({ callback_url: callbackUrl }),
         }, null);
     }
+    async sendServerTeamInvitation(options) {
+        await this.sendServerRequest("/team-invitations/send-code", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                email: options.email,
+                team_id: options.teamId,
+                callback_url: options.callbackUrl,
+            }),
+        }, null);
+    }
 }

package/dist/utils/caches.d.ts

@@ -14,6 +14,7 @@ export declare class AsyncCache<D extends any[], T> {
     });
     private _createKeyed;
     getValueCache(dependencies: D): AsyncValueCache<T>;
+    refreshWhere(predicate: (dependencies: D) => boolean): Promise<void>;
     readonly isCacheAvailable: (key: D) => boolean;
     readonly getIfCached: (key: D) => ({
         status: "pending";

package/dist/utils/caches.js

@@ -48,6 +48,15 @@ export class AsyncCache {
         }
         return cache;
     }
+    async refreshWhere(predicate) {
+        const promises = [];
+        for (const [dependencies, cache] of this._map) {
+            if (predicate(dependencies)) {
+                promises.push(cache.refresh());
+            }
+        }
+        await Promise.all(promises);
+    }
 }
 class AsyncValueCache {
     constructor(fetcher, _options = {}) {

package/dist/utils/maps.d.ts

@@ -1,3 +1,30 @@
+export declare class WeakRefIfAvailable<T extends object> {
+    private readonly _ref;
+    constructor(value: T);
+    deref(): T | undefined;
+}
+/**
+ * A WeakMap-like object that can be iterated over.
+ *
+ * Note that it relies on WeakRef, and always falls back to the regular Map behavior (ie. no GC) in browsers that don't support it.
+ */
+export declare class IterableWeakMap<K extends object, V> {
+    private readonly _weakMap;
+    private readonly _keyRefs;
+    constructor(entries?: readonly (readonly [K, V])[] | null);
+    get(key: K): V | undefined;
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    has(key: K): boolean;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    [Symbol.toStringTag]: string;
+}
+/**
+ * A map that is a IterableWeakMap for object keys and a regular Map for primitive keys. Also provides iteration over both
+ * object and primitive keys.
+ *
+ * Note that, just like IterableWeakMap, older browsers without support for WeakRef will use a regular Map for object keys.
+ */
 export declare class MaybeWeakMap<K, V> {
     private readonly _primitiveMap;
     private readonly _weakMap;
@@ -7,17 +34,24 @@ export declare class MaybeWeakMap<K, V> {
     set(key: K, value: V): this;
     delete(key: K): boolean;
     has(key: K): boolean;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
     [Symbol.toStringTag]: string;
 }
+/**
+ * A map that stores values indexed by an array of keys. If the keys are objects and the environment supports WeakRefs,
+ * they are stored in a WeakMap.
+ */
 export declare class DependenciesMap<K extends any[], V> {
     private _inner;
     private _valueToResult;
     private _unwrapFromInner;
     private _setInInner;
+    private _iterateInner;
     get(dependencies: K): V | undefined;
     set(dependencies: K, value: V): this;
     delete(dependencies: K): boolean;
     has(dependencies: K): boolean;
     clear(): void;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
     [Symbol.toStringTag]: string;
 }

package/dist/utils/maps.js

@@ -1,11 +1,79 @@
-var _a, _b;
+var _a, _b, _c;
 import { Result } from "./results";
+export class WeakRefIfAvailable {
+    constructor(value) {
+        if (typeof WeakRef === "undefined") {
+            this._ref = { deref: () => value };
+        }
+        else {
+            this._ref = new WeakRef(value);
+        }
+    }
+    deref() {
+        return this._ref.deref();
+    }
+}
+/**
+ * A WeakMap-like object that can be iterated over.
+ *
+ * Note that it relies on WeakRef, and always falls back to the regular Map behavior (ie. no GC) in browsers that don't support it.
+ */
+export class IterableWeakMap {
+    constructor(entries) {
+        this[_a] = "IterableWeakMap";
+        const mappedEntries = entries?.map((e) => [e[0], { value: e[1], keyRef: new WeakRefIfAvailable(e[0]) }]);
+        this._weakMap = new WeakMap(mappedEntries ?? []);
+        this._keyRefs = new Set(mappedEntries?.map((e) => e[1].keyRef) ?? []);
+    }
+    get(key) {
+        return this._weakMap.get(key)?.value;
+    }
+    set(key, value) {
+        const existing = this._weakMap.get(key);
+        const updated = { value, keyRef: existing?.keyRef ?? new WeakRefIfAvailable(key) };
+        this._weakMap.set(key, updated);
+        this._keyRefs.add(updated.keyRef);
+        return this;
+    }
+    delete(key) {
+        const res = this._weakMap.get(key);
+        if (res) {
+            this._weakMap.delete(key);
+            this._keyRefs.delete(res.keyRef);
+            return true;
+        }
+        return false;
+    }
+    has(key) {
+        return this._weakMap.has(key) && this._keyRefs.has(this._weakMap.get(key).keyRef);
+    }
+    *[Symbol.iterator]() {
+        for (const keyRef of this._keyRefs) {
+            const key = keyRef.deref();
+            const existing = key ? this._weakMap.get(key) : undefined;
+            if (!key) {
+                // This can happen if the key was GCed. Remove it so the next iteration is faster.
+                this._keyRefs.delete(keyRef);
+            }
+            else if (existing) {
+                yield [key, existing.value];
+            }
+        }
+    }
+}
+_a = Symbol.toStringTag;
+/**
+ * A map that is a IterableWeakMap for object keys and a regular Map for primitive keys. Also provides iteration over both
+ * object and primitive keys.
+ *
+ * Note that, just like IterableWeakMap, older browsers without support for WeakRef will use a regular Map for object keys.
+ */
 export class MaybeWeakMap {
     constructor(entries) {
-        this[_a] = "MaybeWeakMap";
+        this[_b] = "MaybeWeakMap";
         const entriesArray = [...entries ?? []];
         this._primitiveMap = new Map(entriesArray.filter((e) => !this._isAllowedInWeakMap(e[0])));
-        this._weakMap = new WeakMap(entriesArray.filter((e) => this._isAllowedInWeakMap(e[0])));
+        this._weakMap = new IterableWeakMap(entriesArray.filter((e) => this._isAllowedInWeakMap(e[0])));
     }
     _isAllowedInWeakMap(key) {
         return (typeof key === "object" && key !== null) || (typeof key === "symbol" && Symbol.keyFor(key) === undefined);
@@ -43,12 +111,20 @@ export class MaybeWeakMap {
             return this._primitiveMap.has(key);
         }
     }
+    *[Symbol.iterator]() {
+        yield* this._primitiveMap;
+        yield* this._weakMap;
+    }
 }
-_a = Symbol.toStringTag;
+_b = Symbol.toStringTag;
+/**
+ * A map that stores values indexed by an array of keys. If the keys are objects and the environment supports WeakRefs,
+ * they are stored in a WeakMap.
+ */
 export class DependenciesMap {
     constructor() {
         this._inner = { map: new MaybeWeakMap(), hasValue: false, value: undefined };
-        this[_b] = "DependenciesMap";
+        this[_c] = "DependenciesMap";
     }
     _valueToResult(inner) {
         if (inner.hasValue) {
@@ -93,6 +169,14 @@ export class DependenciesMap {
             return this._setInInner(rest, value, newInner);
         }
     }
+    *_iterateInner(dependencies, inner) {
+        if (inner.hasValue) {
+            yield [dependencies, inner.value];
+        }
+        for (const [key, value] of inner.map) {
+            yield* this._iterateInner([...dependencies, key], value);
+        }
+    }
     get(dependencies) {
         return Result.or(this._unwrapFromInner(dependencies, this._inner), undefined);
     }
@@ -109,5 +193,8 @@ export class DependenciesMap {
     clear() {
         this._inner = { map: new MaybeWeakMap(), hasValue: false, value: undefined };
     }
+    *[Symbol.iterator]() {
+        yield* this._iterateInner([], this._inner);
+    }
 }
-_b = Symbol.toStringTag;
+_c = Symbol.toStringTag;

package/dist/utils/react.d.ts

@@ -1,4 +1,7 @@
 import React from "react";
+export declare function forwardRefIfNeeded<T, P = {}>(render: React.ForwardRefRenderFunction<T, P>): React.FC<P & {
+    ref?: React.Ref<T>;
+}>;
 export declare function getNodeText(node: React.ReactNode): string;
 /**
  * Suspends the currently rendered component indefinitely. Will not unsuspend unless the component rerenders.

package/dist/utils/react.js

@@ -2,6 +2,17 @@ import React from "react";
 import { neverResolve } from "./promises";
 import { deindent } from "./strings";
 import { isBrowserLike } from "./env";
+export function forwardRefIfNeeded(render) {
+    // TODO: when we drop support for react 18, remove this
+    const version = React.version;
+    const major = parseInt(version.split(".")[0]);
+    if (major < 19) {
+        return React.forwardRef(render);
+    }
+    else {
+        return ((props) => render(props, props.ref));
+    }
+}
 export function getNodeText(node) {
     if (["number", "string"].includes(typeof node)) {
         return `${node}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.6.19",
+  "version": "2.6.21",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -21,12 +21,22 @@
   },
   "peerDependencies": {
     "react": ">=18.2",
+    "react-dom": ">=18.2",
+    "@types/react": ">=18.2",
+    "@types/react-dom": ">=18.2",
+    "next": ">=14.1.0",
     "yup": "^1.4.0"
   },
   "peerDependenciesMeta": {
     "react": {
       "optional": true
     },
+    "@types/react": {
+      "optional": true
+    },
+    "@types/react-dom": {
+      "optional": true
+    },
     "yup": {
       "optional": true
     }
@@ -39,18 +49,18 @@
     "oauth4webapi": "^2.10.3",
     "semver": "^7.6.3",
     "uuid": "^9.0.1",
-    "@stackframe/stack-sc": "2.6.19"
+    "@stackframe/stack-sc": "2.6.21"
   },
   "devDependencies": {
     "@simplewebauthn/types": "^11.0.0",
     "@types/bcrypt": "^5.0.2",
     "@types/elliptic": "^6.4.18",
-    "@types/react": "^18.2.66",
     "@types/semver": "^7.5.8",
     "@types/uuid": "^9.0.8",
-    "next": "^14.1.0",
-    "react": "^18.2.0",
-    "rimraf": "^5.0.5"
+    "rimraf": "^5.0.5",
+    "react": "^18.2",
+    "react-dom": "^18.2",
+    "next": "^14.1.0"
   },
   "scripts": {
     "build": "tsc",