@stackframe/stack-shared 2.6.39 → 2.7.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @stackframe/stack-shared
 
+## 2.7.1
+
+### Patch Changes
+
+- Various changes
+  - @stackframe/stack-sc@2.7.1
+
+## 2.7.0
+
+### Minor Changes
+
+- Various changes
+
+### Patch Changes
+
+- @stackframe/stack-sc@2.7.0
+
 ## 2.6.39
 
 ### Patch Changes

package/dist/interface/adminInterface.d.ts

@@ -25,7 +25,7 @@ export type ApiKeyCreateCrudResponse = ApiKeysCrud["Admin"]["Read"] & {
 export declare class StackAdminInterface extends StackServerInterface {
     readonly options: AdminAuthApplicationOptions;
     constructor(options: AdminAuthApplicationOptions);
-    protected sendAdminRequest(path: string, options: RequestInit, session: InternalSession | null, requestType?: "admin"): Promise<Response & {
+    sendAdminRequest(path: string, options: RequestInit, session: InternalSession | null, requestType?: "admin"): Promise<Response & {
         usedTokens: {
             accessToken: import("../sessions").AccessToken;
             refreshToken: import("../sessions").RefreshToken | null;
@@ -46,4 +46,19 @@ export declare class StackAdminInterface extends StackServerInterface {
     deletePermissionDefinition(permissionId: string): Promise<void>;
     getSvixToken(): Promise<SvixTokenCrud["Admin"]["Read"]>;
     deleteProject(): Promise<void>;
+    getMetrics(): Promise<any>;
+    sendTestEmail(data: {
+        recipient_email: string;
+        email_config: {
+            host: string;
+            port: number;
+            username: string;
+            password: string;
+            sender_email: string;
+            sender_name: string;
+        };
+    }): Promise<{
+        success: boolean;
+        error_message?: string;
+    }>;
 }

package/dist/interface/adminInterface.js

@@ -120,4 +120,20 @@ export class StackAdminInterface extends StackServerInterface {
             method: "DELETE",
         }, null);
     }
+    async getMetrics() {
+        const response = await this.sendAdminRequest("/internal/metrics", {
+            method: "GET",
+        }, null);
+        return await response.json();
+    }
+    async sendTestEmail(data) {
+        const response = await this.sendAdminRequest(`/internal/send-test-email`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(data),
+        }, null);
+        return await response.json();
+    }
 }

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

@@ -1,6 +1,6 @@
 import { CrudTypeOf } from "../../crud";
 export declare const currentUserCrud: import("../../crud").CrudSchemaFromOptions<{
-    clientReadSchema: import("yup").ObjectSchema<({
+    clientReadSchema: import("yup").ObjectSchema<{
         primary_email: string | null;
         id: string;
         display_name: string | null;
@@ -28,7 +28,7 @@ export declare const currentUserCrud: import("../../crud").CrudSchemaFromOptions
             display_name: string;
             profile_image_url: string | null;
         } | null;
-    }) | null, import("yup").AnyObject, {
+    }, import("yup").AnyObject, {
         id: undefined;
         primary_email: undefined;
         primary_email_verified: undefined;
@@ -87,7 +87,7 @@ export declare const currentUserCrud: import("../../crud").CrudSchemaFromOptions
         }[];
         auth_with_email: boolean;
         requires_totp_mfa: boolean;
-    } | null, import("yup").AnyObject, {
+    }, import("yup").AnyObject, {
         id: undefined;
         primary_email: undefined;
         primary_email_verified: undefined;

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

@@ -30,9 +30,8 @@ const clientReadSchema = usersCrudServerReadSchema.pick([
     "passkey_auth_enabled",
 ]).concat(yupObject({
     selected_team: teamsCrudClientReadSchema.nullable().defined(),
-})).nullable().defined(); // TODO: next-release: make required
-// TODO: next-release: make required
-const serverReadSchema = usersCrudServerReadSchema.nullable().defined();
+})).defined();
+const serverReadSchema = usersCrudServerReadSchema.defined();
 const clientDeleteSchema = usersCrudServerDeleteSchema;
 export const currentUserCrud = createCrud({
     clientReadSchema,

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

@@ -1,4 +1,21 @@
 import { CrudTypeOf } from "../../crud";
+export declare const emailConfigSchema: import("yup").ObjectSchema<{
+    type: "shared" | "standard";
+    host: string | undefined;
+    port: number | undefined;
+    username: string | undefined;
+    password: string | undefined;
+    sender_name: string | undefined;
+    sender_email: string | undefined;
+}, import("yup").AnyObject, {
+    type: undefined;
+    host: undefined;
+    port: undefined;
+    username: undefined;
+    password: undefined;
+    sender_name: undefined;
+    sender_email: undefined;
+}, "">;
 export declare const projectsCrudAdminReadSchema: import("yup").ObjectSchema<{
     id: string;
     display_name: string;

package/dist/interface/crud/projects.js

@@ -1,6 +1,6 @@
 import { createCrud } from "../../crud";
 import * as schemaFields from "../../schema-fields";
-import { yupArray, yupDefinedWhen, yupObject, yupString } from "../../schema-fields";
+import { yupArray, yupObject, yupString } from "../../schema-fields";
 const teamPermissionSchema = yupObject({
     id: yupString().defined(),
 }).defined();
@@ -8,8 +8,14 @@ const oauthProviderSchema = yupObject({
     id: schemaFields.oauthIdSchema.defined(),
     enabled: schemaFields.oauthEnabledSchema.defined(),
     type: schemaFields.oauthTypeSchema.defined(),
-    client_id: yupDefinedWhen(schemaFields.oauthClientIdSchema, 'type', 'standard'),
-    client_secret: yupDefinedWhen(schemaFields.oauthClientSecretSchema, 'type', 'standard'),
+    client_id: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.oauthClientIdSchema, {
+        type: 'standard',
+        enabled: true,
+    }),
+    client_secret: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.oauthClientSecretSchema, {
+        type: 'standard',
+        enabled: true,
+    }),
     // extra params
     facebook_config_id: schemaFields.oauthFacebookConfigIdSchema.optional(),
     microsoft_tenant_id: schemaFields.oauthMicrosoftTenantIdSchema.optional(),
@@ -17,14 +23,26 @@ const oauthProviderSchema = yupObject({
 const enabledOAuthProviderSchema = yupObject({
     id: schemaFields.oauthIdSchema.defined(),
 });
-const emailConfigSchema = yupObject({
+export const emailConfigSchema = yupObject({
     type: schemaFields.emailTypeSchema.defined(),
-    host: yupDefinedWhen(schemaFields.emailHostSchema, 'type', 'standard'),
-    port: yupDefinedWhen(schemaFields.emailPortSchema, 'type', 'standard'),
-    username: yupDefinedWhen(schemaFields.emailUsernameSchema, 'type', 'standard'),
-    password: yupDefinedWhen(schemaFields.emailPasswordSchema, 'type', 'standard'),
-    sender_name: yupDefinedWhen(schemaFields.emailSenderNameSchema, 'type', 'standard'),
-    sender_email: yupDefinedWhen(schemaFields.emailSenderEmailSchema, 'type', 'standard'),
+    host: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.emailHostSchema, {
+        type: 'standard',
+    }),
+    port: schemaFields.yupDefinedWhen(schemaFields.emailPortSchema, {
+        type: 'standard',
+    }),
+    username: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.emailUsernameSchema, {
+        type: 'standard',
+    }),
+    password: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.emailPasswordSchema, {
+        type: 'standard',
+    }),
+    sender_name: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.emailSenderNameSchema, {
+        type: 'standard',
+    }),
+    sender_email: schemaFields.yupDefinedAndNonEmptyWhen(schemaFields.emailSenderEmailSchema, {
+        type: 'standard',
+    }),
 });
 const domainSchema = yupObject({
     domain: schemaFields.projectTrustedDomainSchema.defined(),

package/dist/known-errors.d.ts

@@ -66,21 +66,6 @@ export declare const KnownErrors: {
     } & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION">, [statusCode: number, humanReadableMessage: string, details?: Json | undefined]> & {
         errorCode: "INVALID_PROJECT_AUTHENTICATION";
     };
-    ProjectKeyWithoutRequestType: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & {
-        constructorArgs: [statusCode: number, humanReadableMessage: string, details?: Json | undefined];
-    } & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"PROJECT_KEY_WITHOUT_REQUEST_TYPE">, []> & {
-        errorCode: "PROJECT_KEY_WITHOUT_REQUEST_TYPE";
-    };
-    InvalidRequestType: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & {
-        constructorArgs: [statusCode: number, humanReadableMessage: string, details?: Json | undefined];
-    } & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"INVALID_REQUEST_TYPE">, [requestType: string]> & {
-        errorCode: "INVALID_REQUEST_TYPE";
-    };
-    RequestTypeWithoutProjectId: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & {
-        constructorArgs: [statusCode: number, humanReadableMessage: string, details?: Json | undefined];
-    } & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"REQUEST_TYPE_WITHOUT_PROJECT_ID">, [requestType: "client" | "server" | "admin"]> & {
-        errorCode: "REQUEST_TYPE_WITHOUT_PROJECT_ID";
-    };
     ProjectKeyWithoutAccessType: KnownErrorConstructor<KnownError & KnownErrorBrand<"PROJECT_AUTHENTICATION_ERROR"> & {
         constructorArgs: [statusCode: number, humanReadableMessage: string, details?: Json | undefined];
     } & KnownErrorBrand<"INVALID_PROJECT_AUTHENTICATION"> & KnownErrorBrand<"PROJECT_KEY_WITHOUT_ACCESS_TYPE">, []> & {

package/dist/known-errors.js

@@ -105,35 +105,6 @@ const AllOverloadsFailed = createKnownErrorConstructor(KnownError, "ALL_OVERLOAD
 ]);
 const ProjectAuthenticationError = createKnownErrorConstructor(KnownError, "PROJECT_AUTHENTICATION_ERROR", "inherit", "inherit");
 const InvalidProjectAuthentication = createKnownErrorConstructor(ProjectAuthenticationError, "INVALID_PROJECT_AUTHENTICATION", "inherit", "inherit");
-// TODO next-release: delete deprecated error type
-/**
- * @deprecated Use ProjectKeyWithoutAccessType instead
- */
-const ProjectKeyWithoutRequestType = createKnownErrorConstructor(InvalidProjectAuthentication, "PROJECT_KEY_WITHOUT_REQUEST_TYPE", () => [
-    400,
-    "Either an API key or an admin access token was provided, but the x-stack-access-type header is missing. Set it to 'client', 'server', or 'admin' as appropriate.",
-], () => []);
-// TODO next-release: delete deprecated error type
-/**
- * @deprecated Use InvalidAccessType instead
- */
-const InvalidRequestType = createKnownErrorConstructor(InvalidProjectAuthentication, "INVALID_REQUEST_TYPE", (requestType) => [
-    400,
-    `The x-stack-access-type header must be 'client', 'server', or 'admin', but was '${requestType}'.`,
-], (json) => [
-    json?.requestType ?? throwErr("requestType not found in InvalidRequestType details"),
-]);
-// TODO next-release: delete deprecated error type
-/**
- * @deprecated Use AccessTypeWithoutProjectId instead
- */
-const RequestTypeWithoutProjectId = createKnownErrorConstructor(InvalidProjectAuthentication, "REQUEST_TYPE_WITHOUT_PROJECT_ID", (requestType) => [
-    400,
-    `The x-stack-access-type header was '${requestType}', but the x-stack-project-id header was not provided.`,
-    {
-        request_type: requestType,
-    },
-], (json) => [json.request_type]);
 const ProjectKeyWithoutAccessType = createKnownErrorConstructor(InvalidProjectAuthentication, "PROJECT_KEY_WITHOUT_ACCESS_TYPE", () => [
     400,
     "Either an API key or an admin access token was provided, but the x-stack-access-type header is missing. Set it to 'client', 'server', or 'admin' as appropriate.",
@@ -288,7 +259,7 @@ const ProviderRejected = createKnownErrorConstructor(RefreshTokenError, "PROVIDE
 ], () => []);
 const UserEmailAlreadyExists = createKnownErrorConstructor(KnownError, "USER_EMAIL_ALREADY_EXISTS", () => [
     400,
-    "User already exists.",
+    "User email already exists.",
 ], () => []);
 const CannotGetOwnUserWithoutUser = createKnownErrorConstructor(KnownError, "CANNOT_GET_OWN_USER_WITHOUT_USER", () => [
     400,
@@ -570,9 +541,6 @@ export const KnownErrors = {
     AllOverloadsFailed,
     ProjectAuthenticationError,
     InvalidProjectAuthentication,
-    ProjectKeyWithoutRequestType,
-    InvalidRequestType,
-    RequestTypeWithoutProjectId,
     ProjectKeyWithoutAccessType,
     InvalidAccessType,
     AccessTypeWithoutProjectId,

package/dist/schema-fields.d.ts

@@ -2,6 +2,7 @@ import * as yup from "yup";
 declare module "yup" {
     interface StringSchema<TType, TContext, TDefault, TFlags> {
         nonEmpty(message?: string): StringSchema<TType, TContext, TDefault, TFlags>;
+        empty(): StringSchema<TType, TContext, TDefault, TFlags>;
     }
 }
 export declare function yupValidate<S extends yup.ISchema<any>>(schema: S, obj: unknown, options?: yup.ValidateOptions & {
@@ -149,5 +150,6 @@ export declare const contactChannelIsVerifiedSchema: yup.BooleanSchema<boolean |
 export declare const contactChannelIsPrimarySchema: yup.BooleanSchema<boolean | undefined, yup.AnyObject, undefined, "">;
 export declare const basicAuthorizationHeaderSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
 export declare const neonAuthorizationHeaderSchema: yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
-export declare function yupDefinedWhen<S extends yup.AnyObject>(schema: S, triggerName: string, isValue: any): S;
+export declare function yupDefinedWhen<S extends yup.AnyObject>(schema: S, triggers: Record<string, any>): S;
+export declare function yupDefinedAndNonEmptyWhen<S extends yup.StringSchema>(schema: S, triggers: Record<string, any>): S;
 export {};

package/dist/schema-fields.js

@@ -9,7 +9,7 @@ import { isValidUrl } from "./utils/urls";
 import { isUuid } from "./utils/uuids";
 // eslint-disable-next-line no-restricted-syntax
 yup.addMethod(yup.string, "nonEmpty", function (message) {
-    return this.test("non-empty", message ?? "String must not be empty", (value) => {
+    return this.test("non-empty", message ?? (({ path }) => `${path} must not be empty`), (value) => {
         return value !== "";
     });
 });
@@ -371,10 +371,19 @@ export const neonAuthorizationHeaderSchema = basicAuthorizationHeaderSchema.test
     return false;
 });
 // Utils
-export function yupDefinedWhen(schema, triggerName, isValue) {
-    return schema.when(triggerName, {
-        is: isValue,
+export function yupDefinedWhen(schema, triggers) {
+    const entries = Object.entries(triggers);
+    return schema.when(entries.map(([key]) => key), {
+        is: (...values) => entries.every(([key, value], index) => value === values[index]),
         then: (schema) => schema.defined(),
         otherwise: (schema) => schema.optional()
     });
 }
+export function yupDefinedAndNonEmptyWhen(schema, triggers) {
+    const entries = Object.entries(triggers);
+    return schema.when(entries.map(([key]) => key), {
+        is: (...values) => entries.every(([key, value], index) => value === values[index]),
+        then: (schema) => schema.defined().nonEmpty(),
+        otherwise: (schema) => schema.optional()
+    });
+}

package/dist/utils/dates.d.ts

@@ -1,3 +1,4 @@
+export declare function isWeekend(date: Date): boolean;
 export declare function fromNow(date: Date): string;
 export declare function fromNowDetailed(date: Date): {
     result: string;

package/dist/utils/dates.js

@@ -1,4 +1,7 @@
 import { remainder } from "./math";
+export function isWeekend(date) {
+    return date.getDay() === 0 || date.getDay() === 6;
+}
 const agoUnits = [
     [60, 'second'],
     [60, 'minute'],

package/dist/utils/locks.d.ts

@@ -0,0 +1,14 @@
+type LockCallback<T> = () => Promise<T>;
+export declare class ReadWriteLock {
+    private semaphore;
+    private readers;
+    private readersMutex;
+    constructor();
+    withReadLock<T>(callback: LockCallback<T>): Promise<T>;
+    withWriteLock<T>(callback: LockCallback<T>): Promise<T>;
+    private _acquireReadLock;
+    private _releaseReadLock;
+    private _acquireWriteLock;
+    private _releaseWriteLock;
+}
+export {};

package/dist/utils/locks.js

@@ -0,0 +1,62 @@
+import { Semaphore } from 'async-mutex';
+export class ReadWriteLock {
+    constructor() {
+        this.semaphore = new Semaphore(1); // Semaphore with 1 permit
+        this.readers = 0; // Track the number of readers
+        this.readersMutex = new Semaphore(1); // Protect access to `readers` count
+    }
+    async withReadLock(callback) {
+        await this._acquireReadLock();
+        try {
+            return await callback();
+        }
+        finally {
+            await this._releaseReadLock();
+        }
+    }
+    async withWriteLock(callback) {
+        await this._acquireWriteLock();
+        try {
+            return await callback();
+        }
+        finally {
+            await this._releaseWriteLock();
+        }
+    }
+    async _acquireReadLock() {
+        // Increment the readers count
+        await this.readersMutex.acquire();
+        try {
+            this.readers += 1;
+            // If this is the first reader, block writers
+            if (this.readers === 1) {
+                await this.semaphore.acquire();
+            }
+        }
+        finally {
+            this.readersMutex.release();
+        }
+    }
+    async _releaseReadLock() {
+        // Decrement the readers count
+        await this.readersMutex.acquire();
+        try {
+            this.readers -= 1;
+            // If this was the last reader, release the writer block
+            if (this.readers === 0) {
+                this.semaphore.release();
+            }
+        }
+        finally {
+            this.readersMutex.release();
+        }
+    }
+    async _acquireWriteLock() {
+        // Writers acquire the main semaphore exclusively
+        await this.semaphore.acquire();
+    }
+    async _releaseWriteLock() {
+        // Writers release the main semaphore
+        this.semaphore.release();
+    }
+}

package/dist/utils/objects.d.ts

@@ -10,8 +10,6 @@ export declare function deepPlainEquals<T>(obj1: T, obj2: unknown, options?: {
     ignoreUndefinedValues?: boolean;
 }): obj2 is T;
 export declare function deepPlainClone<T>(obj: T): T;
-export declare function deepPlainSnakeCaseToCamelCase(snakeCaseObj: any): any;
-export declare function deepPlainCamelCaseToSnakeCase(camelCaseObj: any): any;
 export declare function typedEntries<T extends {}>(obj: T): [keyof T, T[keyof T]][];
 export declare function typedFromEntries<K extends PropertyKey, V>(entries: [K, V][]): Record<K, V>;
 export declare function typedKeys<T extends {}>(obj: T): (keyof T)[];

package/dist/utils/objects.js

@@ -1,5 +1,4 @@
 import { StackAssertionError } from "./errors";
-import { camelCaseToSnakeCase, snakeCaseToCamelCase } from "./strings";
 /**
  * Assumes both objects are primitives, arrays, or non-function plain objects, and compares them deeply.
  *
@@ -57,24 +56,6 @@ export function deepPlainClone(obj) {
         return obj.map(deepPlainClone);
     return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, deepPlainClone(v)]));
 }
-export function deepPlainSnakeCaseToCamelCase(snakeCaseObj) {
-    if (typeof snakeCaseObj === 'function')
-        throw new StackAssertionError("deepPlainSnakeCaseToCamelCase does not support functions");
-    if (typeof snakeCaseObj !== 'object' || !snakeCaseObj)
-        return snakeCaseObj;
-    if (Array.isArray(snakeCaseObj))
-        return snakeCaseObj.map(o => deepPlainSnakeCaseToCamelCase(o));
-    return Object.fromEntries(Object.entries(snakeCaseObj).map(([k, v]) => [snakeCaseToCamelCase(k), deepPlainSnakeCaseToCamelCase(v)]));
-}
-export function deepPlainCamelCaseToSnakeCase(camelCaseObj) {
-    if (typeof camelCaseObj === 'function')
-        throw new StackAssertionError("deepPlainCamelCaseToSnakeCase does not support functions");
-    if (typeof camelCaseObj !== 'object' || !camelCaseObj)
-        return camelCaseObj;
-    if (Array.isArray(camelCaseObj))
-        return camelCaseObj.map(o => deepPlainCamelCaseToSnakeCase(o));
-    return Object.fromEntries(Object.entries(camelCaseObj).map(([k, v]) => [camelCaseToSnakeCase(k), deepPlainCamelCaseToSnakeCase(v)]));
-}
 export function typedEntries(obj) {
     return Object.entries(obj);
 }

package/dist/utils/stores.d.ts

@@ -1,5 +1,6 @@
-import { AsyncResult, Result } from "./results";
+import { ReadWriteLock } from "./locks";
 import { ReactPromise } from "./promises";
+import { AsyncResult, Result } from "./results";
 export type ReadonlyStore<T> = {
     get(): T;
     onChange(callback: (value: T, oldValue: T | undefined) => void): {
@@ -45,6 +46,7 @@ export declare class Store<T> implements ReadonlyStore<T> {
         unsubscribe: () => void;
     };
 }
+export declare const storeLock: ReadWriteLock;
 export declare class AsyncStore<T> implements ReadonlyAsyncStore<T> {
     private _isAvailable;
     private _mostRecentOkValue;

package/dist/utils/stores.js

@@ -1,6 +1,7 @@
+import { ReadWriteLock } from "./locks";
+import { pending, rejected, resolved } from "./promises";
 import { AsyncResult, Result } from "./results";
 import { generateUuid } from "./uuids";
-import { pending, rejected, resolved } from "./promises";
 export class Store {
     constructor(_value) {
         this._value = _value;
@@ -36,6 +37,7 @@ export class Store {
         return { unsubscribe };
     }
 }
+export const storeLock = new ReadWriteLock();
 export class AsyncStore {
     constructor(...args) {
         this._mostRecentOkValue = undefined;
@@ -135,9 +137,11 @@ export class AsyncStore {
         return value;
     }
     async setAsync(promise) {
-        const curCounter = ++this._updateCounter;
-        const result = await Result.fromPromise(promise);
-        return this._setIfLatest(result, curCounter);
+        return await storeLock.withReadLock(async () => {
+            const curCounter = ++this._updateCounter;
+            const result = await Result.fromPromise(promise);
+            return this._setIfLatest(result, curCounter);
+        });
     }
     setUnavailable() {
         this._lastSuccessfulUpdate = ++this._updateCounter;

package/dist/utils/strings.d.ts

@@ -41,8 +41,6 @@ export declare function deindent(code: string): string;
 export declare function deindent(strings: TemplateStringsArray | readonly string[], ...values: any[]): string;
 export declare function extractScopes(scope: string, removeDuplicates?: boolean): string[];
 export declare function mergeScopeStrings(...scopes: string[]): string;
-export declare function snakeCaseToCamelCase(snakeCase: string): string;
-export declare function camelCaseToSnakeCase(camelCase: string): string;
 export type Nicifiable = {
     getNicifiableKeys?(): PropertyKey[];
     getNicifiedObjectExtraLines?(): string[];

package/dist/utils/strings.js

@@ -105,16 +105,6 @@ export function mergeScopeStrings(...scopes) {
     const allScope = scopes.map((s) => extractScopes(s)).flat().join(" ");
     return extractScopes(allScope).join(" ");
 }
-export function snakeCaseToCamelCase(snakeCase) {
-    if (snakeCase.match(/[A-Z]/))
-        return snakeCase; // TODO next-release: 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 next-release: this is a hack for fixing the email templates, remove this after v2 migration
-    return camelCase.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
 /**
  * Some classes have different constructor names in different environments (eg. `Headers` is sometimes called `_Headers`,
  * so we create an object of overrides to handle these cases.

package/dist/utils/unicode.d.ts

@@ -0,0 +1 @@
+export declare function getFlagEmoji(twoLetterCountryCode: string): string;

package/dist/utils/unicode.js

@@ -0,0 +1,10 @@
+import { StackAssertionError } from "./errors";
+export function getFlagEmoji(twoLetterCountryCode) {
+    if (!/^[a-zA-Z][a-zA-Z]$/.test(twoLetterCountryCode))
+        throw new StackAssertionError("Country code must be two alphabetical letters");
+    const codePoints = twoLetterCountryCode
+        .toUpperCase()
+        .split('')
+        .map(char => 127397 + char.charCodeAt(0));
+    return String.fromCodePoint(...codePoints);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.6.39",
+  "version": "2.7.1",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -20,11 +20,11 @@
     }
   },
   "peerDependencies": {
-    "react": ">=18.2 || >=19.0.0-rc.0",
-    "react-dom": ">=18.2 || >=19.0.0-rc.0",
     "@types/react": ">=18.2 || >=19.0.0-rc.0",
     "@types/react-dom": ">=18.2 || >=19.0.0-rc.0",
     "next": ">=14.1.0 || >=15.0.0-rc.0",
+    "react": ">=18.2 || >=19.0.0-rc.0",
+    "react-dom": ">=18.2 || >=19.0.0-rc.0",
     "yup": "^1.4.0"
   },
   "peerDependenciesMeta": {
@@ -43,26 +43,27 @@
   },
   "dependencies": {
     "@simplewebauthn/browser": "^11.0.0",
+    "async-mutex": "^0.5.0",
     "bcrypt": "^5.1.1",
     "elliptic": "^6.5.7",
-    "jose": "^5.2.2",
     "ip-regex": "^5.0.0",
+    "jose": "^5.2.2",
     "oauth4webapi": "^2.10.3",
     "semver": "^7.6.3",
     "uuid": "^9.0.1",
-    "@stackframe/stack-sc": "2.6.39"
+    "@stackframe/stack-sc": "2.7.1"
   },
   "devDependencies": {
+    "@sentry/nextjs": "^8.40.0",
     "@simplewebauthn/types": "^11.0.0",
     "@types/bcrypt": "^5.0.2",
     "@types/elliptic": "^6.4.18",
     "@types/semver": "^7.5.8",
     "@types/uuid": "^9.0.8",
-    "rimraf": "^5.0.5",
+    "next": "^14.1.0",
     "react": "^18.2",
     "react-dom": "^18.2",
-    "next": "^14.1.0",
-    "@sentry/nextjs": "^8.40.0"
+    "rimraf": "^5.0.5"
   },
   "scripts": {
     "build": "tsc",