@stackframe/stack-shared 2.5.2 → 2.5.3

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @stackframe/stack-shared
 
+## 2.5.3
+
+### Patch Changes
+
+- Bugfixes
+- Updated dependencies
+  - @stackframe/stack-sc@2.5.3
+
 ## 2.5.2
 
 ### Patch Changes

package/dist/interface/adminInterface.js

@@ -1,6 +1,5 @@
 import { StackServerInterface } from "./serverInterface";
 export class StackAdminInterface extends StackServerInterface {
-    options;
     constructor(options) {
         super(options);
         this.options = options;

package/dist/interface/clientInterface.js

@@ -27,7 +27,6 @@ export function toSharedProvider(provider) {
     return "shared-" + provider;
 }
 export class StackClientInterface {
-    options;
     constructor(options) {
         this.options = options;
         // nothing here

package/dist/interface/serverInterface.js

@@ -2,7 +2,6 @@ import { StackClientInterface, } from "./clientInterface";
 import { Result } from "../utils/results";
 export const emailTemplateTypes = ['EMAIL_VERIFICATION', 'PASSWORD_RESET', 'MAGIC_LINK'];
 export class StackServerInterface extends StackClientInterface {
-    options;
     constructor(options) {
         super(options);
         this.options = options;

package/dist/known-errors.js

@@ -2,15 +2,12 @@ import { StatusError, throwErr } from "./utils/errors";
 import { identityArgs } from "./utils/functions";
 import { deindent } from "./utils/strings";
 export class KnownError extends StatusError {
-    statusCode;
-    humanReadableMessage;
-    details;
-    name = "KnownError";
     constructor(statusCode, humanReadableMessage, details) {
         super(statusCode, humanReadableMessage);
         this.statusCode = statusCode;
         this.humanReadableMessage = humanReadableMessage;
         this.details = details;
+        this.name = "KnownError";
     }
     getBody() {
         return new TextEncoder().encode(JSON.stringify({
@@ -52,18 +49,17 @@ function createKnownErrorConstructor(SuperClass, errorCode, create, constructorA
     const constructorArgsFromJsonFn = constructorArgsFromJson === "inherit" ? SuperClass.constructorArgsFromJson : constructorArgsFromJson;
     // @ts-expect-error this is not a mixin, but TS detects it as one
     class KnownErrorImpl extends SuperClass {
-        static errorCode = errorCode;
-        name = `KnownError<${errorCode}>`;
-        constructorArgs;
         constructor(...args) {
             // @ts-expect-error
             super(...createFn(...args));
+            this.name = `KnownError<${errorCode}>`;
             this.constructorArgs = args;
         }
         static constructorArgsFromJson(json) {
             return constructorArgsFromJsonFn(json);
         }
     }
+    KnownErrorImpl.errorCode = errorCode;
     ;
     // @ts-expect-error
     return KnownErrorImpl;

package/dist/schema-fields.js

@@ -29,7 +29,6 @@ export const projectIdSchema = yup.string().meta({ openapiField: { description:
 // Users
 export const userIdRequestSchema = yup.string().uuid().meta({ openapiField: { description: 'The ID of the user', exampleValue: '3241a285-8329-4d69-8f3d-316e08cf140c' } });
 export class ReplaceFieldWithOwnUserId extends Error {
-    path;
     constructor(path) {
         super(`This error should be caught by whoever validated the schema, and the field in the path '${path}' should be replaced with the current user's id. This is a workaround to yup not providing access to the context inside the transform function.`);
         this.path = path;

package/dist/sessions.js

@@ -1,12 +1,10 @@
 import { Store } from "./utils/stores";
 export class AccessToken {
-    token;
     constructor(token) {
         this.token = token;
     }
 }
 export class RefreshToken {
-    token;
     constructor(token) {
         this.token = token;
     }
@@ -17,29 +15,15 @@ export class RefreshToken {
  * A session never changes which user or session it belongs to, but the tokens in it may change over time.
  */
 export class InternalSession {
-    _options;
-    /**
-    * Each session has a session key that depends on the tokens inside. If the session has a refresh token, the session key depends only on the refresh token. If the session does not have a refresh token, the session key depends only on the access token.
-    *
-    * Multiple Session objects may have the same session key, which implies that they represent the same session by the same user. Furthermore, a session's key never changes over the lifetime of a session object.
-    *
-    * This is useful for caching and indexing sessions.
-    */
-    sessionKey;
-    /**
-     * An access token that is not known to be invalid (ie. may be valid, but may have expired).
-     */
-    _accessToken;
-    _refreshToken;
-    /**
-     * Whether the session as a whole is known to be invalid. Used as a cache to avoid making multiple requests to the server (sessions never go back to being valid after being invalidated).
-     *
-     * Applies to both the access token and the refresh token (it is possible for the access token to be invalid but the refresh token to be valid, in which case the session is still valid).
-     */
-    _knownToBeInvalid = new Store(false);
-    _refreshPromise = null;
     constructor(_options) {
         this._options = _options;
+        /**
+         * Whether the session as a whole is known to be invalid. Used as a cache to avoid making multiple requests to the server (sessions never go back to being valid after being invalidated).
+         *
+         * Applies to both the access token and the refresh token (it is possible for the access token to be invalid but the refresh token to be valid, in which case the session is still valid).
+         */
+        this._knownToBeInvalid = new Store(false);
+        this._refreshPromise = null;
         this._accessToken = new Store(_options.accessToken ? new AccessToken(_options.accessToken) : null);
         this._refreshToken = _options.refreshToken ? new RefreshToken(_options.refreshToken) : null;
         this.sessionKey = InternalSession.calculateSessionKey({ accessToken: _options.accessToken ?? null, refreshToken: _options.refreshToken });

package/dist/utils/arrays.d.ts

@@ -1,6 +1,10 @@
 export declare function typedIncludes<T extends readonly any[]>(arr: T, item: unknown): item is T[number];
 export declare function enumerate<T extends readonly any[]>(arr: T): [number, T[number]][];
 export declare function isShallowEqual(a: readonly any[], b: readonly any[]): boolean;
+/**
+ * Ponyfill for ES2023's findLastIndex.
+ */
+export declare function findLastIndex<T>(arr: readonly T[], predicate: (item: T) => boolean): number;
 export declare function groupBy<T extends any, K>(arr: Iterable<T>, key: (item: T) => K): Map<K, T[]>;
 export declare function range(endExclusive: number): number[];
 export declare function range(startInclusive: number, endExclusive: number): number[];

package/dist/utils/arrays.js

@@ -14,6 +14,16 @@ export function isShallowEqual(a, b) {
     }
     return true;
 }
+/**
+ * Ponyfill for ES2023's findLastIndex.
+ */
+export function findLastIndex(arr, predicate) {
+    for (let i = arr.length - 1; i >= 0; i--) {
+        if (predicate(arr[i]))
+            return i;
+    }
+    return -1;
+}
 export function groupBy(arr, key) {
     const result = new Map;
     for (const item of arr) {

package/dist/utils/caches.js

@@ -17,12 +17,18 @@ export function cacheFunction(f) {
     });
 }
 export class AsyncCache {
-    _fetcher;
-    _options;
-    _map = new DependenciesMap();
     constructor(_fetcher, _options = {}) {
         this._fetcher = _fetcher;
         this._options = _options;
+        this._map = new DependenciesMap();
+        this.isCacheAvailable = this._createKeyed("isCacheAvailable");
+        this.getIfCached = this._createKeyed("getIfCached");
+        this.getOrWait = this._createKeyed("getOrWait");
+        this.forceSetCachedValue = this._createKeyed("forceSetCachedValue");
+        this.forceSetCachedValueAsync = this._createKeyed("forceSetCachedValueAsync");
+        this.refresh = this._createKeyed("refresh");
+        this.invalidate = this._createKeyed("invalidate");
+        this.onStateChange = this._createKeyed("onStateChange");
         // nothing here yet
     }
     _createKeyed(functionName) {
@@ -42,25 +48,12 @@ export class AsyncCache {
         }
         return cache;
     }
-    isCacheAvailable = this._createKeyed("isCacheAvailable");
-    getIfCached = this._createKeyed("getIfCached");
-    getOrWait = this._createKeyed("getOrWait");
-    forceSetCachedValue = this._createKeyed("forceSetCachedValue");
-    forceSetCachedValueAsync = this._createKeyed("forceSetCachedValueAsync");
-    refresh = this._createKeyed("refresh");
-    invalidate = this._createKeyed("invalidate");
-    onStateChange = this._createKeyed("onStateChange");
 }
 class AsyncValueCache {
-    _options;
-    _store;
-    _pendingPromise;
-    _fetcher;
-    _rateLimitOptions;
-    _subscriptionsCount = 0;
-    _unsubscribers = [];
     constructor(fetcher, _options = {}) {
         this._options = _options;
+        this._subscriptionsCount = 0;
+        this._unsubscribers = [];
         this._store = new AsyncStore();
         this._rateLimitOptions = {
             concurrency: 1,

package/dist/utils/errors.js

@@ -12,7 +12,6 @@ export function throwErr(...args) {
     }
 }
 export class StackAssertionError extends Error {
-    extraData;
     constructor(message, extraData, options) {
         const disclaimer = `\n\nThis is likely an error in Stack. Please report it.`;
         super(`${message}${message.endsWith(disclaimer) ? "" : disclaimer}`, options);
@@ -40,48 +39,6 @@ export function captureError(location, error) {
     }
 }
 export class StatusError extends Error {
-    name = "StatusError";
-    statusCode;
-    static BadRequest = { statusCode: 400, message: "Bad Request" };
-    static Unauthorized = { statusCode: 401, message: "Unauthorized" };
-    static PaymentRequired = { statusCode: 402, message: "Payment Required" };
-    static Forbidden = { statusCode: 403, message: "Forbidden" };
-    static NotFound = { statusCode: 404, message: "Not Found" };
-    static MethodNotAllowed = { statusCode: 405, message: "Method Not Allowed" };
-    static NotAcceptable = { statusCode: 406, message: "Not Acceptable" };
-    static ProxyAuthenticationRequired = { statusCode: 407, message: "Proxy Authentication Required" };
-    static RequestTimeout = { statusCode: 408, message: "Request Timeout" };
-    static Conflict = { statusCode: 409, message: "Conflict" };
-    static Gone = { statusCode: 410, message: "Gone" };
-    static LengthRequired = { statusCode: 411, message: "Length Required" };
-    static PreconditionFailed = { statusCode: 412, message: "Precondition Failed" };
-    static PayloadTooLarge = { statusCode: 413, message: "Payload Too Large" };
-    static URITooLong = { statusCode: 414, message: "URI Too Long" };
-    static UnsupportedMediaType = { statusCode: 415, message: "Unsupported Media Type" };
-    static RangeNotSatisfiable = { statusCode: 416, message: "Range Not Satisfiable" };
-    static ExpectationFailed = { statusCode: 417, message: "Expectation Failed" };
-    static ImATeapot = { statusCode: 418, message: "I'm a teapot" };
-    static MisdirectedRequest = { statusCode: 421, message: "Misdirected Request" };
-    static UnprocessableEntity = { statusCode: 422, message: "Unprocessable Entity" };
-    static Locked = { statusCode: 423, message: "Locked" };
-    static FailedDependency = { statusCode: 424, message: "Failed Dependency" };
-    static TooEarly = { statusCode: 425, message: "Too Early" };
-    static UpgradeRequired = { statusCode: 426, message: "Upgrade Required" };
-    static PreconditionRequired = { statusCode: 428, message: "Precondition Required" };
-    static TooManyRequests = { statusCode: 429, message: "Too Many Requests" };
-    static RequestHeaderFieldsTooLarge = { statusCode: 431, message: "Request Header Fields Too Large" };
-    static UnavailableForLegalReasons = { statusCode: 451, message: "Unavailable For Legal Reasons" };
-    static InternalServerError = { statusCode: 500, message: "Internal Server Error" };
-    static NotImplemented = { statusCode: 501, message: "Not Implemented" };
-    static BadGateway = { statusCode: 502, message: "Bad Gateway" };
-    static ServiceUnavailable = { statusCode: 503, message: "Service Unavailable" };
-    static GatewayTimeout = { statusCode: 504, message: "Gateway Timeout" };
-    static HTTPVersionNotSupported = { statusCode: 505, message: "HTTP Version Not Supported" };
-    static VariantAlsoNegotiates = { statusCode: 506, message: "Variant Also Negotiates" };
-    static InsufficientStorage = { statusCode: 507, message: "Insufficient Storage" };
-    static LoopDetected = { statusCode: 508, message: "Loop Detected" };
-    static NotExtended = { statusCode: 510, message: "Not Extended" };
-    static NetworkAuthenticationRequired = { statusCode: 511, message: "Network Authentication Required" };
     constructor(status, message) {
         if (typeof status === "object") {
             message ??= status.message;
@@ -89,6 +46,7 @@ export class StatusError extends Error {
         }
         message ??= "Server Error";
         super(message);
+        this.name = "StatusError";
         this.statusCode = status;
     }
     isClientError() {
@@ -116,3 +74,43 @@ export class StatusError extends Error {
         };
     }
 }
+StatusError.BadRequest = { statusCode: 400, message: "Bad Request" };
+StatusError.Unauthorized = { statusCode: 401, message: "Unauthorized" };
+StatusError.PaymentRequired = { statusCode: 402, message: "Payment Required" };
+StatusError.Forbidden = { statusCode: 403, message: "Forbidden" };
+StatusError.NotFound = { statusCode: 404, message: "Not Found" };
+StatusError.MethodNotAllowed = { statusCode: 405, message: "Method Not Allowed" };
+StatusError.NotAcceptable = { statusCode: 406, message: "Not Acceptable" };
+StatusError.ProxyAuthenticationRequired = { statusCode: 407, message: "Proxy Authentication Required" };
+StatusError.RequestTimeout = { statusCode: 408, message: "Request Timeout" };
+StatusError.Conflict = { statusCode: 409, message: "Conflict" };
+StatusError.Gone = { statusCode: 410, message: "Gone" };
+StatusError.LengthRequired = { statusCode: 411, message: "Length Required" };
+StatusError.PreconditionFailed = { statusCode: 412, message: "Precondition Failed" };
+StatusError.PayloadTooLarge = { statusCode: 413, message: "Payload Too Large" };
+StatusError.URITooLong = { statusCode: 414, message: "URI Too Long" };
+StatusError.UnsupportedMediaType = { statusCode: 415, message: "Unsupported Media Type" };
+StatusError.RangeNotSatisfiable = { statusCode: 416, message: "Range Not Satisfiable" };
+StatusError.ExpectationFailed = { statusCode: 417, message: "Expectation Failed" };
+StatusError.ImATeapot = { statusCode: 418, message: "I'm a teapot" };
+StatusError.MisdirectedRequest = { statusCode: 421, message: "Misdirected Request" };
+StatusError.UnprocessableEntity = { statusCode: 422, message: "Unprocessable Entity" };
+StatusError.Locked = { statusCode: 423, message: "Locked" };
+StatusError.FailedDependency = { statusCode: 424, message: "Failed Dependency" };
+StatusError.TooEarly = { statusCode: 425, message: "Too Early" };
+StatusError.UpgradeRequired = { statusCode: 426, message: "Upgrade Required" };
+StatusError.PreconditionRequired = { statusCode: 428, message: "Precondition Required" };
+StatusError.TooManyRequests = { statusCode: 429, message: "Too Many Requests" };
+StatusError.RequestHeaderFieldsTooLarge = { statusCode: 431, message: "Request Header Fields Too Large" };
+StatusError.UnavailableForLegalReasons = { statusCode: 451, message: "Unavailable For Legal Reasons" };
+StatusError.InternalServerError = { statusCode: 500, message: "Internal Server Error" };
+StatusError.NotImplemented = { statusCode: 501, message: "Not Implemented" };
+StatusError.BadGateway = { statusCode: 502, message: "Bad Gateway" };
+StatusError.ServiceUnavailable = { statusCode: 503, message: "Service Unavailable" };
+StatusError.GatewayTimeout = { statusCode: 504, message: "Gateway Timeout" };
+StatusError.HTTPVersionNotSupported = { statusCode: 505, message: "HTTP Version Not Supported" };
+StatusError.VariantAlsoNegotiates = { statusCode: 506, message: "Variant Also Negotiates" };
+StatusError.InsufficientStorage = { statusCode: 507, message: "Insufficient Storage" };
+StatusError.LoopDetected = { statusCode: 508, message: "Loop Detected" };
+StatusError.NotExtended = { statusCode: 510, message: "Not Extended" };
+StatusError.NetworkAuthenticationRequired = { statusCode: 511, message: "Network Authentication Required" };

package/dist/utils/globals.js

@@ -4,6 +4,9 @@ const globalVar = typeof globalThis !== 'undefined' ? globalThis :
             typeof self !== 'undefined' ? self :
                 {};
 export { globalVar, };
+if (typeof globalThis === 'undefined') {
+    globalVar.globalThis = globalVar;
+}
 const stackGlobalsSymbol = Symbol.for('__stack-globals');
 globalVar[stackGlobalsSymbol] ??= {};
 export function createGlobal(key, init) {

package/dist/utils/maps.js

@@ -1,8 +1,8 @@
+var _a, _b;
 import { Result } from "./results";
 export class MaybeWeakMap {
-    _primitiveMap;
-    _weakMap;
     constructor(entries) {
+        this[_a] = "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])));
@@ -43,10 +43,13 @@ export class MaybeWeakMap {
             return this._primitiveMap.has(key);
         }
     }
-    [Symbol.toStringTag] = "MaybeWeakMap";
 }
+_a = Symbol.toStringTag;
 export class DependenciesMap {
-    _inner = { map: new MaybeWeakMap(), hasValue: false, value: undefined };
+    constructor() {
+        this._inner = { map: new MaybeWeakMap(), hasValue: false, value: undefined };
+        this[_b] = "DependenciesMap";
+    }
     _valueToResult(inner) {
         if (inner.hasValue) {
             return Result.ok(inner.value);
@@ -106,5 +109,5 @@ export class DependenciesMap {
     clear() {
         this._inner = { map: new MaybeWeakMap(), hasValue: false, value: undefined };
     }
-    [Symbol.toStringTag] = "DependenciesMap";
 }
+_b = Symbol.toStringTag;

package/dist/utils/numbers.js

@@ -1,9 +1,9 @@
 const magnitudes = [
-    [1_000_000_000_000_000, "trln"],
-    [1_000_000_000_000, "bln"],
-    [1_000_000_000, "bn"],
-    [1_000_000, "M"],
-    [1_000, "k"],
+    [1000000000000000, "trln"],
+    [1000000000000, "bln"],
+    [1000000000, "bn"],
+    [1000000, "M"],
+    [1000, "k"],
 ];
 export function prettyPrintWithMagnitudes(num) {
     if (typeof num !== "number")

package/dist/utils/promises.js

@@ -118,7 +118,6 @@ export function runAsynchronously(promiseOrFunc, options = {}) {
     });
 }
 class TimeoutError extends Error {
-    ms;
     constructor(ms) {
         super(`Timeout after ${ms}ms`);
         this.ms = ms;

package/dist/utils/results.js

@@ -85,7 +85,6 @@ function mapResult(result, fn) {
     return Result.ok(fn(result.data));
 }
 class RetryError extends AggregateError {
-    errors;
     constructor(errors) {
         super(errors, deindent `
       Error after retrying ${errors.length} times.

package/dist/utils/stores.js

@@ -2,10 +2,9 @@ import { AsyncResult, Result } from "./results";
 import { generateUuid } from "./uuids";
 import { pending, rejected, resolved } from "./promises";
 export class Store {
-    _value;
-    _callbacks = new Map();
     constructor(_value) {
         this._value = _value;
+        this._callbacks = new Map();
     }
     get() {
         return this._value;
@@ -38,15 +37,13 @@ export class Store {
     }
 }
 export class AsyncStore {
-    _isAvailable;
-    _mostRecentOkValue = undefined;
-    _isRejected = false;
-    _rejectionError;
-    _waitingRejectFunctions = new Map();
-    _callbacks = new Map();
-    _updateCounter = 0;
-    _lastSuccessfulUpdate = -1;
     constructor(...args) {
+        this._mostRecentOkValue = undefined;
+        this._isRejected = false;
+        this._waitingRejectFunctions = new Map();
+        this._callbacks = new Map();
+        this._updateCounter = 0;
+        this._lastSuccessfulUpdate = -1;
         if (args.length === 0) {
             this._isAvailable = false;
         }

package/dist/utils/strings.js

@@ -1,3 +1,4 @@
+import { findLastIndex } from "./arrays";
 import { StackAssertionError } from "./errors";
 import { filterUndefined } from "./objects";
 export function typedToLowercase(s) {
@@ -42,7 +43,7 @@ export function trimEmptyLinesStart(s) {
  */
 export function trimEmptyLinesEnd(s) {
     const lines = s.split("\n");
-    const lastNonEmptyLineIndex = lines.findLastIndex((line) => line.trim() !== "");
+    const lastNonEmptyLineIndex = findLastIndex(lines, (line) => line.trim() !== "");
     return lines.slice(0, lastNonEmptyLineIndex + 1).join("\n");
 }
 /**
@@ -105,9 +106,13 @@ export function mergeScopeStrings(...scopes) {
     return extractScopes(allScope).join(" ");
 }
 export function snakeCaseToCamelCase(snakeCase) {
+    if (snakeCase.match(/[A-Z]/))
+        return snakeCase; // TODO: this is a hack for fixing the email templates, remove this after v2 migration
     return snakeCase.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
 }
 export function camelCaseToSnakeCase(camelCase) {
+    if (camelCase.match(/_/))
+        return camelCase; // TODO: this is a hack for fixing the email templates, remove this after v2 migration
     return camelCase.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
 /**

package/dist/utils/uuids.d.ts

@@ -1 +1 @@
-export declare function generateUuid(): any;
+export declare function generateUuid(): string;

package/dist/utils/uuids.js

@@ -1,4 +1,5 @@
 import { globalVar } from "./globals";
 export function generateUuid() {
-    return globalVar.crypto.randomUUID();
+    // crypto.randomUuid is not supported in all browsers, so this is a polyfill
+    return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, c => (+c ^ globalVar.crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.5.2",
+  "version": "2.5.3",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -36,7 +36,7 @@
     "jose": "^5.2.2",
     "oauth4webapi": "^2.10.3",
     "uuid": "^9.0.1",
-    "@stackframe/stack-sc": "2.5.2"
+    "@stackframe/stack-sc": "2.5.3"
   },
   "devDependencies": {
     "rimraf": "^5.0.5",