@hexclave/react 1.0.29 → 1.0.32

package/src/lib/hexclave-app/apps/implementations/server-app-impl.ts

@@ -2,8 +2,7 @@
 //===========================================
 // THIS FILE IS AUTO-GENERATED FROM TEMPLATE. DO NOT EDIT IT DIRECTLY UNLESS YOU ALSO EDIT THE CORRESPONDING FILE IN packages/template
 //===========================================
-import { WebAuthnError, startRegistration } from "@simplewebauthn/browser";
-import { KnownErrors, HexclaveServerInterface } from "@hexclave/shared";
+import { HexclaveServerInterface, KnownErrors } from "@hexclave/shared";
 import { ContactChannelsCrud } from "@hexclave/shared/dist/interface/crud/contact-channels";
 import { ItemCrud } from "@hexclave/shared/dist/interface/crud/items";
 import { NotificationPreferenceCrud } from "@hexclave/shared/dist/interface/crud/notification-preferences";
@@ -23,6 +22,7 @@ import { ProviderType } from "@hexclave/shared/dist/utils/oauth";
 import { runAsynchronously } from "@hexclave/shared/dist/utils/promises";
 import { suspend } from "@hexclave/shared/dist/utils/react";
 import { Result } from "@hexclave/shared/dist/utils/results";
+import { WebAuthnError, startRegistration } from "@simplewebauthn/browser";
 import { useMemo } from "react"; // THIS_LINE_PLATFORM react-like
 import * as yup from "yup";
 import { constructRedirectUrl } from "../../../../utils/url";
@@ -64,14 +64,16 @@ export class _HexclaveServerAppImplIncomplete<HasTokenStore extends boolean, Pro
     includeAnonymous?: boolean,
     onlyAnonymous?: boolean,
     teamId?: string,
-  ], UsersCrud['Server']['List']>(async ([cursor, limit, orderBy, desc, query, includeRestricted, includeAnonymous, onlyAnonymous, teamId]) => {
+    excludedEmailDomains?: string,
+  ], UsersCrud['Server']['List']>(async ([cursor, limit, orderBy, desc, query, includeRestricted, includeAnonymous, onlyAnonymous, teamId, excludedEmailDomains]) => {
     if (onlyAnonymous && !includeAnonymous) {
       throw new HexclaveAssertionError("onlyAnonymous=true requires includeAnonymous=true");
     }
+    const excludedEmailDomainList = excludedEmailDomains?.split(",");
     if (onlyAnonymous) {
-      return await this._interface.listServerUsers({ cursor, limit, orderBy, desc, query, includeRestricted, includeAnonymous: true, onlyAnonymous: true, teamId });
+      return await this._interface.listServerUsers({ cursor, limit, orderBy, desc, query, excludedEmailDomains: excludedEmailDomainList, includeRestricted, includeAnonymous: true, onlyAnonymous: true, teamId });
     }
-    return await this._interface.listServerUsers({ cursor, limit, orderBy, desc, query, includeRestricted, includeAnonymous, teamId });
+    return await this._interface.listServerUsers({ cursor, limit, orderBy, desc, query, excludedEmailDomains: excludedEmailDomainList, includeRestricted, includeAnonymous, teamId });
   });
   private readonly _serverUserCache = createCache<string[], UsersCrud['Server']['Read'] | null>(async ([userId]) => {
     const user = await this._interface.getServerUserById(userId);
@@ -1343,14 +1345,16 @@ export class _HexclaveServerAppImplIncomplete<HasTokenStore extends boolean, Pro
   }
 
   async listUsers(options?: ServerListUsersOptions): Promise<ServerUser[] & { nextCursor: string | null }> {
-    const crud = Result.orThrow(await this._serverUsersCache.getOrWait([options?.cursor, options?.limit, options?.orderBy, options?.desc, options?.query, options?.includeRestricted, options?.includeAnonymous, options?.onlyAnonymous, options?.teamId], "write-only"));
+    const excludedEmailDomains = options?.excludedEmailDomains && options.excludedEmailDomains.length > 0 ? options.excludedEmailDomains.join(",") : undefined;
+    const crud = Result.orThrow(await this._serverUsersCache.getOrWait([options?.cursor, options?.limit, options?.orderBy, options?.desc, options?.query, options?.includeRestricted, options?.includeAnonymous, options?.onlyAnonymous, options?.teamId, excludedEmailDomains], "write-only"));
     const result: any = crud.items.map((j) => this._serverUserFromCrud(j));
     result.nextCursor = crud.pagination?.next_cursor ?? null;
     return result as any;
   }
 
   useUsers(options?: ServerListUsersOptions): ServerUser[] & { nextCursor: string | null } {
-    const crud = useAsyncCache(this._serverUsersCache, [options?.cursor, options?.limit, options?.orderBy, options?.desc, options?.query, options?.includeRestricted, options?.includeAnonymous, options?.onlyAnonymous, options?.teamId] as const, "serverApp.useUsers()");
+    const excludedEmailDomains = options?.excludedEmailDomains && options.excludedEmailDomains.length > 0 ? options.excludedEmailDomains.join(",") : undefined;
+    const crud = useAsyncCache(this._serverUsersCache, [options?.cursor, options?.limit, options?.orderBy, options?.desc, options?.query, options?.includeRestricted, options?.includeAnonymous, options?.onlyAnonymous, options?.teamId, excludedEmailDomains] as const, "serverApp.useUsers()");
     const result: any = crud.items.map((j) => this._serverUserFromCrud(j));
     result.nextCursor = crud.pagination?.next_cursor ?? null;
     return result as any;
@@ -1426,23 +1430,24 @@ export class _HexclaveServerAppImplIncomplete<HasTokenStore extends boolean, Pro
     const result = useAsyncCache(cache, cacheKey, debugLabel);
     return useMemo(() => this._serverItemFromCrud({ type, id }, result), [result]);
   }
+  private _resolveCustomer(
+    options: { userId: string } | { teamId: string } | { customCustomerId: string }
+  ): { customerType: "user" | "team" | "custom", customerId: string } {
+    if ("userId" in options) {
+      return { customerType: "user", customerId: options.userId };
+    }
+    if ("teamId" in options) {
+      return { customerType: "team", customerId: options.teamId };
+    }
+    return { customerType: "custom", customerId: options.customCustomerId };
+  }
+
   async grantProduct(options: (
     ({ userId: string } | { teamId: string } | { customCustomerId: string }) &
     ({ productId: string } | { product: InlineProduct }) &
     { quantity?: number }
   )): Promise<void> {
-    let customerType: "user" | "team" | "custom";
-    let customerId: string;
-    if ("userId" in options) {
-      customerType = "user";
-      customerId = options.userId;
-    } else if ("teamId" in options) {
-      customerType = "team";
-      customerId = options.teamId;
-    } else {
-      customerType = "custom";
-      customerId = options.customCustomerId;
-    }
+    const { customerType, customerId } = this._resolveCustomer(options);
 
     await this._interface.grantProduct({
       customerType,
@@ -1460,6 +1465,17 @@ export class _HexclaveServerAppImplIncomplete<HasTokenStore extends boolean, Pro
     await cache.refresh([customerId, null, null]);
   }
 
+  async createCheckoutUrl(options: (
+    ({ userId: string } | { teamId: string } | { customCustomerId: string }) &
+    ({ productId: string } | { product: InlineProduct }) &
+    { returnUrl?: string }
+  )): Promise<string> {
+    const { customerType, customerId } = this._resolveCustomer(options);
+
+    const productIdOrInline = "productId" in options ? options.productId : options.product;
+    return await this._interface.createCheckoutUrl(customerType, customerId, productIdOrInline, null, options.returnUrl, "server");
+  }
+
   async createTeam(data: ServerTeamCreateOptions): Promise<ServerTeam> {
     const team = await this._interface.createServerTeam(serverTeamCreateOptionsToCrud(data));
     await this._serverTeamsCache.refreshWhere(() => true);

package/src/lib/hexclave-app/apps/implementations/session-replay.ts

@@ -114,6 +114,9 @@ const MAX_APPROX_BYTES_PER_BATCH = 512_000;
 // envelope overhead (browser_session_id, timestamps, wrapper keys, etc.).
 const MAX_FLUSH_PAYLOAD_BYTES = 900_000;
 
+// Reused across the emit hot path to avoid per-event allocation.
+const textEncoder = new TextEncoder();
+
 export type StoredSession = {
   session_id: string,
   created_at_ms: number,
@@ -290,6 +293,17 @@ export class SessionRecorder {
         // When _flushInProgress blocked earlier flushes, events can accumulate
         // well past MAX_APPROX_BYTES_PER_BATCH; sending them all at once would
         // exceed the server's 1MB body limit (413).
+        // A single event over the limit can't be sent (rrweb events aren't splittable); drop it and move on.
+        const firstSize = allSizes[offset] ?? throwErr("_eventSizes out of sync with _events — this should never happen");
+        if (firstSize > MAX_FLUSH_PAYLOAD_BYTES) {
+          captureWarning(
+            "SessionRecorder.flush",
+            new Error(`Dropping oversized session replay event (${firstSize} bytes > ${MAX_FLUSH_PAYLOAD_BYTES} byte limit); it cannot be sent without a 413.`),
+          );
+          offset += 1;
+          continue;
+        }
+
         let batchBytes = 0;
         let batchEnd = offset;
         for (let i = offset; i < allEvents.length; i++) {
@@ -388,7 +402,8 @@ export class SessionRecorder {
           }
         }
 
-        const eventSize = JSON.stringify(event).length;
+        // Measure UTF-8 byte length to match the server's byte limit (.length counts UTF-16 units, undercounting multibyte content).
+        const eventSize = textEncoder.encode(JSON.stringify(event)).byteLength;
         this._events.push(event);
         this._eventSizes.push(eventSize);
         this._approxBytes += eventSize;

package/src/lib/hexclave-app/apps/interfaces/client-app.ts

@@ -136,6 +136,7 @@ export type StackClientApp<HasTokenStore extends boolean = boolean, ProjectId ex
       redirectToUrl(url: string | URL, options?: { replace?: boolean }): Promise<void>,
       redirectToHandler(handlerName: keyof HandlerUrls, options?: RedirectToOptions): Promise<void>,
       signInWithTokens(tokens: { accessToken: string, refreshToken: string }): Promise<void>,
+      awaitPendingAuthResolutions(): Promise<void>,
     },
   }
   & AsyncStoreProperty<"project", [], Project, false>

package/src/lib/hexclave-app/apps/interfaces/server-app.ts

@@ -35,6 +35,11 @@ export type StackServerApp<HasTokenStore extends boolean = boolean, ProjectId ex
       ({ productId: string } | { product: InlineProduct }) &
       { quantity?: number }
     )): Promise<void>,
+    createCheckoutUrl(options: (
+      ({ userId: string } | { teamId: string } | { customCustomerId: string }) &
+      ({ productId: string } | { product: InlineProduct }) &
+      { returnUrl?: string }
+    )): Promise<string>,
 
     useUser(options: GetCurrentUserOptions<HasTokenStore> & { or: 'redirect' }): ProjectCurrentServerUser<ProjectId>,
     useUser(options: GetCurrentUserOptions<HasTokenStore> & { or: 'throw' }): ProjectCurrentServerUser<ProjectId>,

package/src/lib/hexclave-app/teams/index.ts

@@ -139,6 +139,10 @@ type ServerListUsersOptionsBase = {
    * Free-text search. Matches user ID (exact UUID), display name, and contact channels (e.g. primary email).
    */
   query?: string,
+  /**
+   * Exclude users whose primary email domain matches one of these exact domains.
+   */
+  excludedEmailDomains?: string[],
   /**
    * Only return users who are members of the given team.
    */