@stackframe/stack-shared 2.5.15 → 2.5.17

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @stackframe/stack-shared
 
+## 2.5.17
+
+### Patch Changes
+
+- Bugfixes
+  - @stackframe/stack-sc@2.5.17
+
+## 2.5.16
+
+### Patch Changes
+
+- @stackframe/stack-sc@2.5.16
+
 ## 2.5.15
 
 ### Patch Changes

package/dist/interface/clientInterface.d.ts

@@ -28,6 +28,8 @@ export declare class StackClientInterface {
         prodDashboard: string;
         prodBackend: string;
     }>;
+    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>;
     protected sendClientRequest(path: string, requestOptions: RequestInit, session: InternalSession | null, requestType?: "client" | "server" | "admin"): Promise<Response & {
         usedTokens: {

package/dist/interface/clientInterface.js

@@ -47,13 +47,13 @@ export class StackClientInterface {
             }
         });
         const prodDashboard = await tryRequest(async () => {
-            const res = await fetch("https://app.stackframe.com/health");
+            const res = await fetch("https://app.stack-auth.com/health");
             if (!res.ok) {
                 throw new Error(`${res.status} ${res.statusText}: ${await res.text()}`);
             }
         });
         const prodBackend = await tryRequest(async () => {
-            const res = await fetch("https://api.stackframe.com/health");
+            const res = await fetch("https://api.stack-auth.com/health");
             if (!res.ok) {
                 throw new Error(`${res.status} ${res.statusText}: ${await res.text()}`);
             }
@@ -66,6 +66,28 @@ export class StackClientInterface {
             prodBackend,
         };
     }
+    async _networkRetry(cb, session, requestType) {
+        const retriedResult = await Result.retry(cb, 5, { exponentialDelayBase: 1000 });
+        // try to diagnose the error for the user
+        if (retriedResult.status === "error") {
+            if (!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 is unable to connect to the server. Please check your internet connection and try again.
+        
+        If the problem persists, please contact Stack support and provide a screenshot of your entire browser console.
+
+        ${retriedResult.error}
+        
+        ${JSON.stringify(await this.runNetworkDiagnostics(session, requestType), null, 2)}
+      `, { cause: retriedResult.error });
+        }
+        return retriedResult.data;
+    }
+    async _networkRetryException(cb, session, requestType) {
+        return await this._networkRetry(async () => await Result.fromThrowingAsync(cb), session, requestType);
+    }
     async fetchNewAccessToken(refreshToken) {
         if (!('publishableClientKey' in this.options)) {
             // TODO support it
@@ -81,7 +103,7 @@ export class StackClientInterface {
             client_secret: this.options.publishableClientKey,
             token_endpoint_auth_method: 'client_secret_post',
         };
-        const rawResponse = await oauth.refreshTokenGrantRequest(as, client, refreshToken.token);
+        const rawResponse = await this._networkRetryException(async () => await oauth.refreshTokenGrantRequest(as, client, refreshToken.token));
         const response = await this._processResponse(rawResponse);
         if (response.status === "error") {
             const error = response.error;
@@ -108,23 +130,7 @@ export class StackClientInterface {
         session ??= this.createSession({
             refreshToken: null,
         });
-        const retriedResult = await Result.retry(() => this.sendClientRequestInner(path, requestOptions, session, requestType), 5, { exponentialDelayBase: 1000 });
-        // try to diagnose the error for the user
-        if (retriedResult.status === "error") {
-            if (!navigator.onLine) {
-                throw new Error("Failed to send Stack request. It seems like you are offline. (window.navigator.onLine is falsy)", { cause: retriedResult.error });
-            }
-            throw new Error(deindent `
-        Stack is unable to connect to the server. Please check your internet connection and try again.
-        
-        If the problem persists, please contact Stack support and provide a screenshot of your entire browser console.
-
-        ${retriedResult.error}
-        
-        ${JSON.stringify(await this.runNetworkDiagnostics(session, requestType), null, 2)}
-      `, { cause: retriedResult.error });
-        }
-        return retriedResult.data;
+        return await this._networkRetry(() => this.sendClientRequestInner(path, requestOptions, session, requestType), session, requestType);
     }
     createSession(options) {
         const session = new InternalSession({
@@ -213,7 +219,7 @@ export class StackClientInterface {
         catch (e) {
             if (e instanceof TypeError) {
                 // Network error, retry
-                console.log("Stack detected a network error, retrying.", e);
+                console.warn(`Stack detected a network error while fetching ${url}, retrying.`, e, { url });
                 return Result.error(e);
             }
             throw e;
@@ -492,7 +498,7 @@ export class StackClientInterface {
             client_secret: this.options.publishableClientKey,
             token_endpoint_auth_method: 'client_secret_post',
         };
-        const params = oauth.validateAuthResponse(as, client, options.oauthParams, options.state);
+        const params = await this._networkRetryException(async () => oauth.validateAuthResponse(as, client, options.oauthParams, options.state));
         if (oauth.isOAuth2Error(params)) {
             throw new StackAssertionError("Error validating outer OAuth response", { params }); // Handle OAuth 2.0 redirect error
         }
@@ -551,7 +557,7 @@ export class StackClientInterface {
         return user;
     }
     async listCurrentUserTeamPermissions(options, session) {
-        const response = await this.sendClientRequest(`/team-permissions?team_id=${options.teamId}?user_id=me&recursive=${options.recursive}`, {}, session);
+        const response = await this.sendClientRequest(`/team-permissions?team_id=${options.teamId}&user_id=me&recursive=${options.recursive}`, {}, session);
         const result = await response.json();
         return result.items;
     }

package/dist/interface/crud/current-user.d.ts

@@ -16,6 +16,29 @@ export declare const currentUserCrud: import("../../crud").CrudSchemaFromOptions
         signed_up_at_millis: number;
         has_password: NonNullable<boolean | undefined>;
         auth_with_email: NonNullable<boolean | undefined>;
+        auth_methods: ({
+            type: "password";
+            identifier: string;
+        } | {
+            type: "otp";
+            contact_channel: {
+                type: "email";
+                email: string;
+            };
+        } | {
+            type: "oauth";
+            provider: {
+                type: string;
+                provider_user_id: string;
+            };
+        })[];
+        connected_accounts: {
+            type: "oauth";
+            provider: {
+                type: string;
+                provider_user_id: string;
+            };
+        }[];
     } & {
         selected_team: {
             id: string;
@@ -38,6 +61,8 @@ export declare const currentUserCrud: import("../../crud").CrudSchemaFromOptions
         has_password: undefined;
         auth_with_email: undefined;
         oauth_providers: undefined;
+        auth_methods: undefined;
+        connected_accounts: undefined;
         client_metadata: undefined;
         server_metadata: undefined;
     }, "">;
@@ -62,6 +87,29 @@ export declare const currentUserCrud: import("../../crud").CrudSchemaFromOptions
             id: string;
             account_id: string;
         }[];
+        auth_methods: ({
+            type: "password";
+            identifier: string;
+        } | {
+            type: "otp";
+            contact_channel: {
+                type: "email";
+                email: string;
+            };
+        } | {
+            type: "oauth";
+            provider: {
+                type: string;
+                provider_user_id: string;
+            };
+        })[];
+        connected_accounts: {
+            type: "oauth";
+            provider: {
+                type: string;
+                provider_user_id: string;
+            };
+        }[];
         client_metadata: {} | null;
         server_metadata: {} | null;
     } | null, import("yup").AnyObject, {
@@ -81,6 +129,8 @@ export declare const currentUserCrud: import("../../crud").CrudSchemaFromOptions
         has_password: undefined;
         auth_with_email: undefined;
         oauth_providers: undefined;
+        auth_methods: undefined;
+        connected_accounts: undefined;
         client_metadata: undefined;
         server_metadata: undefined;
     }, "">;

package/dist/interface/crud/current-user.js

@@ -20,6 +20,8 @@ const clientReadSchema = usersCrudServerReadSchema.pick([
     "auth_with_email",
     "oauth_providers",
     "selected_team_id",
+    "auth_methods",
+    "connected_accounts",
 ]).concat(yupObject({
     selected_team: teamsCrudClientReadSchema.nullable().defined(),
 })).nullable().defined(); // TODO: next-release: make required

package/dist/interface/crud/users.d.ts

@@ -41,6 +41,29 @@ export declare const usersCrudServerReadSchema: import("yup").ObjectSchema<{
         id: string;
         account_id: string;
     }[];
+    auth_methods: ({
+        type: "password";
+        identifier: string;
+    } | {
+        type: "otp";
+        contact_channel: {
+            type: "email";
+            email: string;
+        };
+    } | {
+        type: "oauth";
+        provider: {
+            type: string;
+            provider_user_id: string;
+        };
+    })[];
+    connected_accounts: {
+        type: "oauth";
+        provider: {
+            type: string;
+            provider_user_id: string;
+        };
+    }[];
     client_metadata: {} | null;
     server_metadata: {} | null;
 }, import("yup").AnyObject, {
@@ -60,6 +83,8 @@ export declare const usersCrudServerReadSchema: import("yup").ObjectSchema<{
     has_password: undefined;
     auth_with_email: undefined;
     oauth_providers: undefined;
+    auth_methods: undefined;
+    connected_accounts: undefined;
     client_metadata: undefined;
     server_metadata: undefined;
 }, "">;
@@ -114,6 +139,29 @@ export declare const usersCrud: import("../../crud").CrudSchemaFromOptions<{
             id: string;
             account_id: string;
         }[];
+        auth_methods: ({
+            type: "password";
+            identifier: string;
+        } | {
+            type: "otp";
+            contact_channel: {
+                type: "email";
+                email: string;
+            };
+        } | {
+            type: "oauth";
+            provider: {
+                type: string;
+                provider_user_id: string;
+            };
+        })[];
+        connected_accounts: {
+            type: "oauth";
+            provider: {
+                type: string;
+                provider_user_id: string;
+            };
+        }[];
         client_metadata: {} | null;
         server_metadata: {} | null;
     }, import("yup").AnyObject, {
@@ -133,6 +181,8 @@ export declare const usersCrud: import("../../crud").CrudSchemaFromOptions<{
         has_password: undefined;
         auth_with_email: undefined;
         oauth_providers: undefined;
+        auth_methods: undefined;
+        connected_accounts: undefined;
         client_metadata: undefined;
         server_metadata: undefined;
     }, "">;
@@ -238,6 +288,29 @@ export declare const userCreatedWebhookEvent: {
             id: string;
             account_id: string;
         }[];
+        auth_methods: ({
+            type: "password";
+            identifier: string;
+        } | {
+            type: "otp";
+            contact_channel: {
+                type: "email";
+                email: string;
+            };
+        } | {
+            type: "oauth";
+            provider: {
+                type: string;
+                provider_user_id: string;
+            };
+        })[];
+        connected_accounts: {
+            type: "oauth";
+            provider: {
+                type: string;
+                provider_user_id: string;
+            };
+        }[];
         client_metadata: {} | null;
         server_metadata: {} | null;
     }, import("yup").AnyObject, {
@@ -257,6 +330,8 @@ export declare const userCreatedWebhookEvent: {
         has_password: undefined;
         auth_with_email: undefined;
         oauth_providers: undefined;
+        auth_methods: undefined;
+        connected_accounts: undefined;
         client_metadata: undefined;
         server_metadata: undefined;
     }, "">;
@@ -289,6 +364,29 @@ export declare const userUpdatedWebhookEvent: {
             id: string;
             account_id: string;
         }[];
+        auth_methods: ({
+            type: "password";
+            identifier: string;
+        } | {
+            type: "otp";
+            contact_channel: {
+                type: "email";
+                email: string;
+            };
+        } | {
+            type: "oauth";
+            provider: {
+                type: string;
+                provider_user_id: string;
+            };
+        })[];
+        connected_accounts: {
+            type: "oauth";
+            provider: {
+                type: string;
+                provider_user_id: string;
+            };
+        }[];
         client_metadata: {} | null;
         server_metadata: {} | null;
     }, import("yup").AnyObject, {
@@ -308,6 +406,8 @@ export declare const userUpdatedWebhookEvent: {
         has_password: undefined;
         auth_with_email: undefined;
         oauth_providers: undefined;
+        auth_methods: undefined;
+        connected_accounts: undefined;
         client_metadata: undefined;
         server_metadata: undefined;
     }, "">;

package/dist/interface/crud/users.js

@@ -22,12 +22,35 @@ export const usersCrudServerReadSchema = fieldSchema.yupObject({
     profile_image_url: fieldSchema.profileImageUrlSchema.nullable().defined(),
     signed_up_at_millis: fieldSchema.signedUpAtMillisSchema.required(),
     has_password: fieldSchema.yupBoolean().required().meta({ openapiField: { description: 'Whether the user has a password associated with their account', exampleValue: true } }),
-    auth_with_email: fieldSchema.yupBoolean().required().meta({ openapiField: { description: 'Whether the user can authenticate with their primary e-mail. If set to true, the user can log-in with credentials and/or magic link, if enabled in the project settings.', exampleValue: true } }),
+    /**
+     * @deprecated
+     */
+    auth_with_email: fieldSchema.yupBoolean().required().meta({ openapiField: { hidden: true, description: 'Whether the user can authenticate with their primary e-mail. If set to true, the user can log-in with credentials and/or magic link, if enabled in the project settings.', exampleValue: true } }),
+    /**
+     * @deprecated
+     */
     oauth_providers: fieldSchema.yupArray(fieldSchema.yupObject({
         id: fieldSchema.yupString().required(),
         account_id: fieldSchema.yupString().required(),
         email: fieldSchema.yupString().nullable(),
-    }).required()).required().meta({ openapiField: { description: 'A list of OAuth providers connected to this account', exampleValue: [{ id: 'google', account_id: '12345', email: 'john.doe@gmail.com' }] } }),
+    }).required()).required().meta({ openapiField: { hidden: true, description: 'A list of OAuth providers connected to this account', exampleValue: [{ id: 'google', account_id: '12345', email: 'john.doe@gmail.com' }] } }),
+    auth_methods: fieldSchema.yupArray(fieldSchema.yupUnion(fieldSchema.yupObject({
+        type: fieldSchema.yupString().oneOf(['password']).required(),
+        identifier: fieldSchema.yupString().required(),
+    }).required(), fieldSchema.yupObject({
+        type: fieldSchema.yupString().oneOf(['otp']).required(),
+        contact_channel: fieldSchema.yupObject({
+            type: fieldSchema.yupString().oneOf(['email']).required(),
+            email: fieldSchema.yupString().required(),
+        }).required(),
+    }).required(), fieldSchema.yupObject({
+        type: fieldSchema.yupString().oneOf(['oauth']).required(),
+        provider: fieldSchema.userOAuthProviderSchema.required(),
+    }).required())).required().meta({ openapiField: { description: 'A list of authentication methods available for this user to sign in with', exampleValue: [{ "contact_channel": { "email": "john.doe@gmail.com", "type": "email", }, "type": "otp", }] } }),
+    connected_accounts: fieldSchema.yupArray(fieldSchema.yupUnion(fieldSchema.yupObject({
+        type: fieldSchema.yupString().oneOf(['oauth']).required(),
+        provider: fieldSchema.userOAuthProviderSchema.required(),
+    }).required())).required().meta({ openapiField: { description: 'A list of connected accounts to this user', exampleValue: [{ "provider": { "provider_user_id": "12345", "type": "google", }, "type": "oauth", }] } }),
     client_metadata: fieldSchema.userClientMetadataSchema,
     server_metadata: fieldSchema.userServerMetadataSchema,
 }).required();

package/dist/interface/webhooks.d.ts

@@ -31,6 +31,29 @@ export declare const webhookEvents: readonly [{
             id: string;
             account_id: string;
         }[];
+        auth_methods: ({
+            type: "password";
+            identifier: string;
+        } | {
+            type: "otp";
+            contact_channel: {
+                type: "email";
+                email: string;
+            };
+        } | {
+            type: "oauth";
+            provider: {
+                type: string;
+                provider_user_id: string;
+            };
+        })[];
+        connected_accounts: {
+            type: "oauth";
+            provider: {
+                type: string;
+                provider_user_id: string;
+            };
+        }[];
         client_metadata: {} | null;
         server_metadata: {} | null;
     }, yup.AnyObject, {
@@ -50,6 +73,8 @@ export declare const webhookEvents: readonly [{
         has_password: undefined;
         auth_with_email: undefined;
         oauth_providers: undefined;
+        auth_methods: undefined;
+        connected_accounts: undefined;
         client_metadata: undefined;
         server_metadata: undefined;
     }, "">;
@@ -81,6 +106,29 @@ export declare const webhookEvents: readonly [{
             id: string;
             account_id: string;
         }[];
+        auth_methods: ({
+            type: "password";
+            identifier: string;
+        } | {
+            type: "otp";
+            contact_channel: {
+                type: "email";
+                email: string;
+            };
+        } | {
+            type: "oauth";
+            provider: {
+                type: string;
+                provider_user_id: string;
+            };
+        })[];
+        connected_accounts: {
+            type: "oauth";
+            provider: {
+                type: string;
+                provider_user_id: string;
+            };
+        }[];
         client_metadata: {} | null;
         server_metadata: {} | null;
     }, yup.AnyObject, {
@@ -100,6 +148,8 @@ export declare const webhookEvents: readonly [{
         has_password: undefined;
         auth_with_email: undefined;
         oauth_providers: undefined;
+        auth_methods: undefined;
+        connected_accounts: undefined;
         client_metadata: undefined;
         server_metadata: undefined;
     }, "">;

package/dist/known-errors.d.ts

@@ -360,5 +360,8 @@ export declare const KnownErrors: {
     InvalidStandardOAuthProviderId: KnownErrorConstructor<KnownError & KnownErrorBrand<"INVALID_STANDARD_OAUTH_PROVIDER_ID">, [any]> & {
         errorCode: "INVALID_STANDARD_OAUTH_PROVIDER_ID";
     };
+    InvalidAuthorizationCode: KnownErrorConstructor<KnownError & KnownErrorBrand<"INVALID_AUTHORIZATION_CODE">, []> & {
+        errorCode: "INVALID_AUTHORIZATION_CODE";
+    };
 };
 export {};

package/dist/known-errors.js

@@ -502,6 +502,10 @@ const InvalidStandardOAuthProviderId = createKnownErrorConstructor(KnownError, "
         provider_id: providerId,
     },
 ], (json) => [json.provider_id]);
+const InvalidAuthorizationCode = createKnownErrorConstructor(KnownError, "INVALID_AUTHORIZATION_CODE", () => [
+    400,
+    "The given authorization code is invalid.",
+], () => []);
 export const KnownErrors = {
     UnsupportedError,
     BodyParsingError,
@@ -583,6 +587,7 @@ export const KnownErrors = {
     TeamPermissionRequired,
     InvalidSharedOAuthProviderId,
     InvalidStandardOAuthProviderId,
+    InvalidAuthorizationCode,
 };
 // ensure that all known error codes are unique
 const knownErrorCodes = new Set();

package/dist/schema-fields.d.ts

@@ -12,6 +12,7 @@ export declare function yupMixed<A extends {}>(...args: Parameters<typeof yup.mi
 export declare function yupArray<A extends yup.Maybe<yup.AnyObject> = yup.AnyObject, B = any>(...args: Parameters<typeof yup.array<A, B>>): yup.ArraySchema<B[] | undefined, A, undefined, "">;
 export declare function yupTuple<T extends [unknown, ...unknown[]]>(...args: Parameters<typeof yup.tuple<T>>): yup.TupleSchema<T | undefined, yup.AnyObject, undefined, "">;
 export declare function yupObject<A extends yup.Maybe<yup.AnyObject>, B extends yup.ObjectShape>(...args: Parameters<typeof yup.object<A, B>>): yup.ObjectSchema<yup.TypeFromShape<B, yup.AnyObject> extends infer T ? T extends yup.TypeFromShape<B, yup.AnyObject> ? T extends {} ? { [k in keyof T]: T[k]; } : T : never : never, yup.AnyObject, yup.DefaultFromShape<B> extends infer T_1 ? T_1 extends yup.DefaultFromShape<B> ? T_1 extends {} ? { [k_1 in keyof T_1]: T_1[k_1]; } : T_1 : never : never, "">;
+export declare function yupUnion<T extends yup.ISchema<any>[]>(...args: T): yup.ISchema<yup.InferType<T[number]>>;
 export declare const adaptSchema: yup.MixedSchema<typeof StackAdaptSentinel | undefined, yup.AnyObject, undefined, "">;
 /**
  * Yup's URL schema does not recognize some URLs (including `http://localhost`) as a valid URL. This schema is a workaround for that.
@@ -63,6 +64,13 @@ export declare const profileImageUrlSchema: yup.StringSchema<string | undefined,
 export declare const signedUpAtMillisSchema: yup.NumberSchema<number | undefined, yup.AnyObject, undefined, "">;
 export declare const userClientMetadataSchema: yup.MixedSchema<{} | null, yup.AnyObject, undefined, "">;
 export declare const userServerMetadataSchema: yup.MixedSchema<{} | null, yup.AnyObject, undefined, "">;
+export declare const userOAuthProviderSchema: yup.ObjectSchema<{
+    type: string;
+    provider_user_id: string;
+}, yup.AnyObject, {
+    type: undefined;
+    provider_user_id: undefined;
+}, "">;
 export declare const signInEmailSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
 export declare const emailOtpSignInCallbackUrlSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
 export declare const emailVerificationCallbackUrlSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;

package/dist/schema-fields.js

@@ -1,4 +1,5 @@
 import * as yup from "yup";
+import { StackAssertionError } from "./utils/errors";
 import { allProviders } from "./utils/oauth";
 import { isUuid } from "./utils/uuids";
 const _idDescription = (identify) => `The unique identifier of this ${identify}`;
@@ -55,6 +56,30 @@ export function yupObject(...args) {
     return object.default(undefined);
 }
 /* eslint-enable no-restricted-syntax */
+export function yupUnion(...args) {
+    if (args.length === 0)
+        throw new Error('yupUnion must have at least one schema');
+    const [first] = args;
+    const firstDesc = first.describe();
+    for (const schema of args) {
+        const desc = schema.describe();
+        if (desc.type !== firstDesc.type)
+            throw new StackAssertionError(`yupUnion must have schemas of the same type (got: ${firstDesc.type} and ${desc.type})`, { first, schema, firstDesc, desc });
+    }
+    return yupMixed().required().test('is-one-of', 'Invalid value', async (value, context) => {
+        const errors = [];
+        for (const schema of args) {
+            try {
+                await schema.validate(value, context.options);
+                return true;
+            }
+            catch (e) {
+                errors.push(e);
+            }
+        }
+        throw new AggregateError(errors, 'Invalid value; must be one of the provided schemas');
+    });
+}
 // Common
 export const adaptSchema = yupMixed();
 /**
@@ -160,6 +185,10 @@ export const profileImageUrlSchema = yupString().meta({ openapiField: { descript
 export const signedUpAtMillisSchema = yupNumber().meta({ openapiField: { description: _signedUpAtMillisDescription, exampleValue: 1630000000000 } });
 export const userClientMetadataSchema = jsonSchema.meta({ openapiField: { description: _clientMetaDataDescription('user'), exampleValue: { key: 'value' } } });
 export const userServerMetadataSchema = jsonSchema.meta({ openapiField: { description: _serverMetaDataDescription('user'), exampleValue: { key: 'value' } } });
+export const userOAuthProviderSchema = yupObject({
+    type: yupString().required(),
+    provider_user_id: yupString().required(),
+});
 // Auth
 export const signInEmailSchema = emailSchema.meta({ openapiField: { description: 'The email to sign in with.', exampleValue: 'johndoe@example.com' } });
 export const emailOtpSignInCallbackUrlSchema = urlSchema.meta({ openapiField: { description: 'The base callback URL to construct the magic link from. A query argument `code` with the verification code will be appended to it. The page should then make a request to the `/auth/otp/sign-in` endpoint.', exampleValue: 'https://example.com/handler/magic-link-callback' } });

package/dist/utils/arrays.d.ts

@@ -13,3 +13,4 @@ export declare function rotateLeft(arr: readonly any[], n: number): any[];
 export declare function rotateRight(arr: readonly any[], n: number): any[];
 export declare function shuffle<T>(arr: readonly T[]): T[];
 export declare function outerProduct<T, U>(arr1: readonly T[], arr2: readonly U[]): [T, U][];
+export declare function unique<T>(arr: readonly T[]): T[];

package/dist/utils/arrays.js

@@ -65,3 +65,6 @@ export function shuffle(arr) {
 export function outerProduct(arr1, arr2) {
     return arr1.flatMap((item1) => arr2.map((item2) => [item1, item2]));
 }
+export function unique(arr) {
+    return [...new Set(arr)];
+}

package/dist/utils/crypto.d.ts

@@ -1,3 +1,4 @@
+export declare function generateRandomValues(array: Uint8Array): any;
 /**
  * Generates a secure alphanumeric string using the system's cryptographically secure
  * random number generator.

package/dist/utils/crypto.js

@@ -1,5 +1,15 @@
 import { encodeBase32 } from "./bytes";
+import { StackAssertionError } from "./errors";
 import { globalVar } from "./globals";
+export function generateRandomValues(array) {
+    if (!globalVar.crypto) {
+        throw new StackAssertionError("Crypto API is not available in this environment. Are you using an old browser?");
+    }
+    if (!globalVar.crypto.getRandomValues) {
+        throw new StackAssertionError("crypto.getRandomValues is not available in this environment. Are you using an old browser?");
+    }
+    return globalVar.crypto.getRandomValues(array);
+}
 /**
  * Generates a secure alphanumeric string using the system's cryptographically secure
  * random number generator.
@@ -7,7 +17,7 @@ import { globalVar } from "./globals";
 export function generateSecureRandomString(minBitsOfEntropy = 224) {
     const base32CharactersCount = Math.ceil(minBitsOfEntropy / 5);
     const bytesCount = Math.ceil(base32CharactersCount * 5 / 8);
-    const randomBytes = globalVar.crypto.getRandomValues(new Uint8Array(bytesCount));
+    const randomBytes = generateRandomValues(new Uint8Array(bytesCount));
     const str = encodeBase32(randomBytes);
     return str.slice(str.length - base32CharactersCount).toLowerCase();
 }

package/dist/utils/results.d.ts

@@ -12,6 +12,7 @@ export type AsyncResult<T, E = unknown, P = void> = Result<T, E> | ({
 });
 export declare const Result: {
     fromThrowing: typeof fromThrowing;
+    fromThrowingAsync: typeof fromThrowingAsync;
     fromPromise: typeof promiseToResult;
     ok<T>(data: T): {
         status: "ok";
@@ -60,6 +61,7 @@ declare function pending<P>(progress: P): AsyncResult<never, never, P> & {
 };
 declare function promiseToResult<T>(promise: Promise<T>): Promise<Result<T>>;
 declare function fromThrowing<T>(fn: () => T): Result<T, unknown>;
+declare function fromThrowingAsync<T>(fn: () => Promise<T>): Promise<Result<T, unknown>>;
 declare function mapResult<T, U, E = unknown, P = unknown>(result: Result<T, E>, fn: (data: T) => U): Result<U, E>;
 declare function mapResult<T, U, E = unknown, P = unknown>(result: AsyncResult<T, E, P>, fn: (data: T) => U): AsyncResult<U, E, P>;
 declare class RetryError extends AggregateError {

package/dist/utils/results.js

@@ -2,6 +2,7 @@ import { wait } from "./promises";
 import { deindent } from "./strings";
 export const Result = {
     fromThrowing,
+    fromThrowingAsync,
     fromPromise: promiseToResult,
     ok(data) {
         return {
@@ -71,6 +72,14 @@ function fromThrowing(fn) {
         return Result.error(error);
     }
 }
+async function fromThrowingAsync(fn) {
+    try {
+        return Result.ok(await fn());
+    }
+    catch (error) {
+        return Result.error(error);
+    }
+}
 function mapResult(result, fn) {
     if (result.status === "error")
         return {

package/dist/utils/strings.js

@@ -1,4 +1,4 @@
-import { findLastIndex } from "./arrays";
+import { findLastIndex, unique } from "./arrays";
 import { StackAssertionError } from "./errors";
 import { filterUndefined } from "./objects";
 export function typedToLowercase(s) {
@@ -207,6 +207,9 @@ export function nicify(value, options = {}) {
                     return `[${resValues.join(", ")}]`;
                 }
             }
+            if (value instanceof URL) {
+                return `URL(${JSON.stringify(value.toString())})`;
+            }
             const constructorName = [null, Object.prototype].includes(Object.getPrototypeOf(value)) ? null : (nicifiableClassNameOverrides.get(value.constructor) ?? value.constructor.name);
             const constructorString = constructorName ? `${nicifyPropertyString(constructorName)} ` : "";
             const entries = getNicifiableEntries(value).filter(([k]) => !hideFields.includes(k));
@@ -256,7 +259,16 @@ function nicifyPropertyString(str) {
     return JSON.stringify(str);
 }
 function getNicifiableKeys(value) {
-    return ("getNicifiableKeys" in value ? value.getNicifiableKeys?.bind(value) : null)?.() ?? Object.keys(value).sort();
+    const overridden = ("getNicifiableKeys" in value ? value.getNicifiableKeys?.bind(value) : null)?.();
+    if (overridden != null)
+        return overridden;
+    const keys = Object.keys(value).sort();
+    if (value instanceof Error) {
+        if (value.cause)
+            keys.unshift("cause");
+        keys.unshift("message", "stack");
+    }
+    return unique(keys);
 }
 function getNicifiableEntries(value) {
     const recordLikes = [Headers];

package/dist/utils/uuids.js

@@ -1,7 +1,7 @@
-import { globalVar } from "./globals";
+import { generateRandomValues } from "./crypto";
 export function generateUuid() {
     // 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));
+    return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, c => (+c ^ generateRandomValues(new Uint8Array(1))[0] & 15 >> +c / 4).toString(16));
 }
 export function isUuid(str) {
     return /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(str);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.5.15",
+  "version": "2.5.17",
   "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.15"
+    "@stackframe/stack-sc": "2.5.17"
   },
   "devDependencies": {
     "rimraf": "^5.0.5",