@robelest/convex-auth 0.0.4-preview.25 → 0.0.4-preview.28

package/src/client/runtime/browser.ts

@@ -1,112 +0,0 @@
-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

@@ -1,63 +0,0 @@
-/** @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<{ token: string }> {
-      if (!pendingInvite) {
-        throw new Error("No pending invite to accept.");
-      }
-      const { token } = pendingInvite;
-      pendingInvite = null;
-      void storageRemove(tokenKey);
-      void storageRemove(emailKey);
-      cleanUrlParams(["invite", "email"]);
-      return { token };
-    },
-  };
-}

package/src/client/runtime/proxy.ts

@@ -1,111 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,96 +0,0 @@
-/* eslint-disable */
-/**
- * Generated `api` utility.
- *
- * THIS CODE IS AUTOMATICALLY GENERATED.
- *
- * To regenerate, run `npx convex dev`.
- * @module
- */
-
-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_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,
-  FilterApi,
-  FunctionReference,
-} from "convex/server";
-import { anyApi, componentsGeneric } from "convex/server";
-
-const fullApi: ApiFromModules<{
-  functions: typeof functions;
-  index: typeof index;
-  model: typeof model;
-  public: typeof public_;
-  "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;
-
-/**
- * A utility for referencing Convex functions in your app's public API.
- *
- * Usage:
- * ```js
- * const myFunctionReference = api.myModule.myFunction;
- * ```
- */
-export const api: FilterApi<
-  typeof fullApi,
-  FunctionReference<any, "public">
-> = anyApi as any;
-
-/**
- * A utility for referencing Convex functions in your app's internal API.
- *
- * Usage:
- * ```js
- * const myFunctionReference = internal.myModule.myFunction;
- * ```
- */
-export const internal: FilterApi<
-  typeof fullApi,
-  FunctionReference<any, "internal">
-> = anyApi as any;
-
-export const components = componentsGeneric() as unknown as {};