@robelest/convex-auth 0.0.4-preview.18 → 0.0.4-preview.19

package/src/client/runtime/browser.ts

@@ -0,0 +1,112 @@
+import { Fx } from "@robelest/fx";
+
+/** @internal */
+export function base64urlEncode(buffer: ArrayBuffer): string {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]!);
+  }
+  return btoa(binary)
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=+$/, "");
+}
+
+/** @internal */
+export function base64urlDecode(str: string): Uint8Array {
+  const padded = str.replace(/-/g, "+").replace(/_/g, "/");
+  const binary = atob(padded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
+/** @internal */
+export async function browserMutex<T>(
+  key: string,
+  callback: () => Promise<T>,
+): Promise<T> {
+  const lockManager = (globalThis as any)?.navigator?.locks;
+  return lockManager !== undefined
+    ? await lockManager.request(key, callback)
+    : await manualMutex(key, callback);
+}
+
+/** @internal */
+export function getStorageListenerRegistry(): Record<
+  string,
+  (event: StorageEvent) => void
+> {
+  const globalAny = globalThis as any;
+  if (globalAny.__convexAuthStorageListeners === undefined) {
+    globalAny.__convexAuthStorageListeners = {} as Record<
+      string,
+      (event: StorageEvent) => void
+    >;
+  }
+  return globalAny.__convexAuthStorageListeners as Record<
+    string,
+    (event: StorageEvent) => void
+  >;
+}
+
+function getManualMutexTails(): Record<string, Promise<void>> {
+  const globalAny = globalThis as any;
+  if (globalAny.__convexAuthMutexTails === undefined) {
+    globalAny.__convexAuthMutexTails = {} as Record<string, Promise<void>>;
+  }
+  return globalAny.__convexAuthMutexTails as Record<string, Promise<void>>;
+}
+
+async function manualMutex<T>(
+  key: string,
+  callback: () => Promise<T>,
+): Promise<T> {
+  const mutexTails = getManualMutexTails();
+  const previousTail = mutexTails[key] ?? Promise.resolve();
+
+  let releaseCurrent: (() => void) | undefined;
+  const currentTail = new Promise<void>((resolve) => {
+    releaseCurrent = resolve;
+  });
+
+  mutexTails[key] = previousTail.then(
+    () => currentTail,
+    () => currentTail,
+  );
+
+  await Fx.run(
+    Fx.from({
+      ok: () => previousTail,
+      err: () => undefined,
+    }).pipe(Fx.recover(() => Fx.succeed(undefined))),
+  );
+  let result: T;
+  let threw = false;
+  let thrownError: unknown;
+  await Fx.run(
+    Fx.from({
+      ok: async () => {
+        result = await callback();
+      },
+      err: (e) => e,
+    }).pipe(
+      Fx.recover((e) => {
+        threw = true;
+        thrownError = e;
+        return Fx.succeed(undefined);
+      }),
+    ),
+  );
+  releaseCurrent?.();
+  if (mutexTails[key] === currentTail) {
+    delete mutexTails[key];
+  }
+  if (threw) {
+    throw thrownError;
+  }
+  return result!;
+}

package/src/client/runtime/invite.ts

@@ -0,0 +1,65 @@
+/** @internal */
+export function createInviteManager(args: {
+  param: (name: string) => string | null;
+  storageGet: (name: string) => Promise<string | null>;
+  storageSet: (name: string, value: string) => Promise<void>;
+  storageRemove: (name: string) => Promise<void>;
+  cleanUrlParams: (params: string[]) => void;
+  tokenKey: string;
+  emailKey: string;
+}) {
+  const {
+    param,
+    storageGet,
+    storageSet,
+    storageRemove,
+    cleanUrlParams,
+    tokenKey,
+    emailKey,
+  } = args;
+
+  let pendingInvite: { token: string; email: string | null } | null = null;
+
+  const urlInviteToken = param("invite");
+  if (urlInviteToken) {
+    pendingInvite = { token: urlInviteToken, email: param("email") };
+  } else {
+    void (async () => {
+      const storedToken = await storageGet(tokenKey);
+      if (storedToken && !pendingInvite) {
+        pendingInvite = {
+          token: storedToken,
+          email: (await storageGet(emailKey)) ?? null,
+        };
+        void storageRemove(tokenKey);
+        void storageRemove(emailKey);
+      }
+    })();
+  }
+
+  return {
+    getPendingInvite() {
+      return pendingInvite;
+    },
+    async persistInvite() {
+      if (!pendingInvite) return;
+      await storageSet(tokenKey, pendingInvite.token);
+      if (pendingInvite.email) {
+        await storageSet(emailKey, pendingInvite.email);
+      }
+    },
+    async acceptInvite(): Promise<{
+      ok: boolean;
+      token?: string;
+      message?: string;
+    }> {
+      if (!pendingInvite) return { ok: false, message: "No pending invite" };
+      const { token } = pendingInvite;
+      pendingInvite = null;
+      void storageRemove(tokenKey);
+      void storageRemove(emailKey);
+      cleanUrlParams(["invite", "email"]);
+      return { ok: true, token };
+    },
+  };
+}

package/src/client/runtime/proxy.ts

@@ -0,0 +1,111 @@
+import { Fx } from "@robelest/fx";
+import { ConvexError, type Value } from "convex/values";
+
+const NETWORK_ERROR_PATTERN = /(network|fetch|load failed|failed to fetch)/i;
+
+/** @internal */
+export function isTransientNetworkError(error: unknown): boolean {
+  return (
+    error instanceof TypeError ||
+    (error instanceof Error && NETWORK_ERROR_PATTERN.test(error.message || ""))
+  );
+}
+
+/** @internal */
+export function isRetriableProxyRefreshError(error: unknown): boolean {
+  if (isTransientNetworkError(error)) {
+    return true;
+  }
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const statusMatch = error.message.match(/Proxy request failed:\s*(\d{3})/);
+  if (statusMatch === null) {
+    return false;
+  }
+  const statusCode = Number(statusMatch[1]);
+  return statusCode >= 500 && statusCode < 600;
+}
+
+/** @internal */
+export function createProxyHelpers(args: { proxy: string | undefined }) {
+  const { proxy } = args;
+
+  const resolveProxyUrl = () => {
+    const origin =
+      typeof window !== "undefined" &&
+      typeof window.location?.origin === "string"
+        ? window.location.origin
+        : typeof location !== "undefined" && typeof location.origin === "string"
+          ? location.origin
+          : null;
+    if (origin !== null) {
+      return new URL(proxy!, origin).toString();
+    }
+    return Fx.run(
+      Fx.from({
+        ok: () => new URL(proxy!).toString(),
+        err: () => proxy! as string,
+      }).pipe(Fx.recover((fallback) => Fx.succeed(fallback))),
+    );
+  };
+
+  const isAbsoluteUrl = (value: string) => {
+    return Fx.run(
+      Fx.from({
+        ok: () => {
+          new URL(value);
+          return true;
+        },
+        err: () => false as const,
+      }).pipe(Fx.recover((v) => Fx.succeed(v))),
+    );
+  };
+
+  const proxyFetch = async (body: Record<string, unknown>) => {
+    const proxyUrl = await resolveProxyUrl();
+    if (typeof window === "undefined" && !(await isAbsoluteUrl(proxyUrl))) {
+      throw new Error(
+        `Cannot call relative proxy URL \`${proxy!}\` without a browser origin. ` +
+          "Pass an absolute proxy URL for server runtimes.",
+      );
+    }
+
+    const response = await fetch(proxyUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      credentials: "include",
+      body: JSON.stringify(body),
+    });
+    if (!response.ok) {
+      const errorBody = await Fx.run(
+        Fx.from({
+          ok: () => response.json() as Promise<Record<string, unknown>>,
+          err: () => ({}) as Record<string, unknown>,
+        }).pipe(Fx.recover((fallback) => Fx.succeed(fallback))),
+      );
+      if (
+        typeof errorBody === "object" &&
+        errorBody !== null &&
+        "authError" in errorBody &&
+        typeof (errorBody as Record<string, unknown>).authError === "object"
+      ) {
+        throw new ConvexError(
+          (errorBody as Record<string, unknown>).authError as Value,
+        );
+      }
+      throw new Error(
+        ((errorBody as Record<string, unknown>).error as string) ??
+          `Proxy request failed: ${response.status}`,
+      );
+    }
+    return Fx.run(
+      Fx.from({
+        ok: () => response.json(),
+        err: () => new Error("Proxy response was not valid JSON"),
+      }).pipe(Fx.recover((e) => Fx.fatal(e))),
+    );
+  };
+
+  return { isAbsoluteUrl, proxyFetch, resolveProxyUrl };
+}

package/src/client/runtime/storage.ts

@@ -0,0 +1,79 @@
+import { Fx } from "@robelest/fx";
+
+import type { Storage } from "../core/types";
+
+/** @internal */
+export function createStorageHelpers(args: {
+  storage: Storage | null;
+  key: (name: string) => string;
+}) {
+  const { storage, key } = args;
+
+  const get = async (name: string): Promise<string | null> => {
+    if (!storage) {
+      return null;
+    }
+    return Fx.run(
+      Fx.from({
+        ok: async () => (await storage.getItem(key(name))) ?? null,
+        err: (e) => e,
+      }).pipe(
+        Fx.inspect((error) =>
+          Fx.sync(() =>
+            console.error(
+              `[convex-auth] Failed to read ${name} from storage:`,
+              error,
+            ),
+          ),
+        ),
+        Fx.recover(() => Fx.succeed(null)),
+      ),
+    );
+  };
+
+  const set = async (name: string, value: string): Promise<void> => {
+    if (!storage) {
+      return;
+    }
+    await Fx.run(
+      Fx.from({
+        ok: () => storage.setItem(key(name), value),
+        err: (e) => e,
+      }).pipe(
+        Fx.inspect((error) =>
+          Fx.sync(() =>
+            console.error(
+              `[convex-auth] Failed to write ${name} to storage:`,
+              error,
+            ),
+          ),
+        ),
+        Fx.recover(() => Fx.succeed(undefined)),
+      ),
+    );
+  };
+
+  const remove = async (name: string): Promise<void> => {
+    if (!storage) {
+      return;
+    }
+    await Fx.run(
+      Fx.from({
+        ok: () => storage.removeItem(key(name)),
+        err: (e) => e,
+      }).pipe(
+        Fx.inspect((error) =>
+          Fx.sync(() =>
+            console.error(
+              `[convex-auth] Failed to remove ${name} from storage:`,
+              error,
+            ),
+          ),
+        ),
+        Fx.recover(() => Fx.succeed(undefined)),
+      ),
+    );
+  };
+
+  return { get, set, remove };
+}

package/src/component/_generated/api.ts

@@ -12,12 +12,26 @@ import type * as functions from "../functions.js";
 import type * as index from "../index.js";
 import type * as model from "../model.js";
 import type * as public_ from "../public.js";
-import type * as public_enterprise from "../public/enterprise.js";
-import type * as public_factors from "../public/factors.js";
-import type * as public_groups from "../public/groups.js";
-import type * as public_identity from "../public/identity.js";
-import type * as public_keys from "../public/keys.js";
-import type * as public_shared from "../public/shared.js";
+import type * as public_enterprise_audit from "../public/enterprise/audit.js";
+import type * as public_enterprise_core from "../public/enterprise/core.js";
+import type * as public_enterprise_domains from "../public/enterprise/domains.js";
+import type * as public_enterprise_scim from "../public/enterprise/scim.js";
+import type * as public_enterprise_secrets from "../public/enterprise/secrets.js";
+import type * as public_enterprise_webhooks from "../public/enterprise/webhooks.js";
+import type * as public_factors_devices from "../public/factors/devices.js";
+import type * as public_factors_passkeys from "../public/factors/passkeys.js";
+import type * as public_factors_totp from "../public/factors/totp.js";
+import type * as public_groups_core from "../public/groups/core.js";
+import type * as public_groups_invites from "../public/groups/invites.js";
+import type * as public_groups_members from "../public/groups/members.js";
+import type * as public_identity_accounts from "../public/identity/accounts.js";
+import type * as public_identity_codes from "../public/identity/codes.js";
+import type * as public_identity_sessions from "../public/identity/sessions.js";
+import type * as public_identity_tokens from "../public/identity/tokens.js";
+import type * as public_identity_users from "../public/identity/users.js";
+import type * as public_identity_verifiers from "../public/identity/verifiers.js";
+import type * as public_security_keys from "../public/security/keys.js";
+import type * as public_security_limits from "../public/security/limits.js";
 
 import type {
   ApiFromModules,
@@ -31,12 +45,26 @@ const fullApi: ApiFromModules<{
   index: typeof index;
   model: typeof model;
   public: typeof public_;
-  "public/enterprise": typeof public_enterprise;
-  "public/factors": typeof public_factors;
-  "public/groups": typeof public_groups;
-  "public/identity": typeof public_identity;
-  "public/keys": typeof public_keys;
-  "public/shared": typeof public_shared;
+  "public/enterprise/audit": typeof public_enterprise_audit;
+  "public/enterprise/core": typeof public_enterprise_core;
+  "public/enterprise/domains": typeof public_enterprise_domains;
+  "public/enterprise/scim": typeof public_enterprise_scim;
+  "public/enterprise/secrets": typeof public_enterprise_secrets;
+  "public/enterprise/webhooks": typeof public_enterprise_webhooks;
+  "public/factors/devices": typeof public_factors_devices;
+  "public/factors/passkeys": typeof public_factors_passkeys;
+  "public/factors/totp": typeof public_factors_totp;
+  "public/groups/core": typeof public_groups_core;
+  "public/groups/invites": typeof public_groups_invites;
+  "public/groups/members": typeof public_groups_members;
+  "public/identity/accounts": typeof public_identity_accounts;
+  "public/identity/codes": typeof public_identity_codes;
+  "public/identity/sessions": typeof public_identity_sessions;
+  "public/identity/tokens": typeof public_identity_tokens;
+  "public/identity/users": typeof public_identity_users;
+  "public/identity/verifiers": typeof public_identity_verifiers;
+  "public/security/keys": typeof public_security_keys;
+  "public/security/limits": typeof public_security_limits;
 }> = anyApi as any;
 
 /**