@stackframe/stack-shared 2.6.38 → 2.7.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @stackframe/stack-shared
 
+## 2.7.0
+
+### Minor Changes
+
+- Various changes
+
+### Patch Changes
+
+- @stackframe/stack-sc@2.7.0
+
+## 2.6.39
+
+### Patch Changes
+
+- Various changes
+  - @stackframe/stack-sc@2.6.39
+
 ## 2.6.38
 
 ### 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/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

@@ -17,7 +17,7 @@ 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'),

package/dist/utils/caches.js

@@ -146,7 +146,6 @@ class AsyncValueCache {
             });
             this._unsubscribers.push(unsubscribe);
         }
-        console.log("add", this._subscriptionsCount, new Date().toISOString());
         let hasUnsubscribed = false;
         return {
             unsubscribe: () => {
@@ -154,7 +153,6 @@ class AsyncValueCache {
                     return;
                 hasUnsubscribed = true;
                 storeObj.unsubscribe();
-                console.log("remove", this._subscriptionsCount - 1, new Date().toISOString());
                 if (--this._subscriptionsCount === 0) {
                     for (const unsubscribe of this._unsubscribers) {
                         unsubscribe();

package/dist/utils/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/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/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.38",
+  "version": "2.7.0",
   "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.38"
+    "@stackframe/stack-sc": "2.7.0"
   },
   "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",