use-convex 0.0.2

package/dist/runtime/components/AuthLoading.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/AuthRefreshing.d.vue.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/AuthRefreshing.vue

@@ -0,0 +1,8 @@
+<script setup>
+import { useConvexAuth } from "../composables/useConvexAuth";
+const { isAuthenticated, isRefreshing } = useConvexAuth();
+</script>
+
+<template>
+  <slot v-if="isAuthenticated && isRefreshing" />
+</template>

package/dist/runtime/components/AuthRefreshing.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Authenticated.d.vue.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Authenticated.vue

@@ -0,0 +1,8 @@
+<script setup>
+import { useConvexAuth } from "../composables/useConvexAuth";
+const { showAuthedUi } = useConvexAuth();
+</script>
+
+<template>
+  <slot v-if="showAuthedUi" />
+</template>

package/dist/runtime/components/Authenticated.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Unauthenticated.d.vue.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Unauthenticated.vue

@@ -0,0 +1,8 @@
+<script setup>
+import { useConvexAuth } from "../composables/useConvexAuth";
+const { showAuthedUi, isLoading } = useConvexAuth();
+</script>
+
+<template>
+  <slot v-if="!showAuthedUi && !isLoading" />
+</template>

package/dist/runtime/components/Unauthenticated.vue.d.ts

@@ -0,0 +1,13 @@
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/composables/prewarmQuery.d.ts

@@ -0,0 +1,9 @@
+import type { FunctionArgs, FunctionReference } from 'convex/server';
+/**
+ * Start a live subscription early so the first `useConvexQuery` / screen
+ * paint can reuse warm client state (React `prewarmQuery` parity).
+ *
+ * Returns an unsubscribe function. When called during Vue `setup`, the
+ * subscription is also cleaned up with the current effect scope.
+ */
+export declare function prewarmQuery<Query extends FunctionReference<'query'>>(query: Query, args?: FunctionArgs<Query>): () => void;

package/dist/runtime/composables/prewarmQuery.js

@@ -0,0 +1,14 @@
+import { onScopeDispose } from "vue";
+import { useConvex } from "./useConvex.js";
+export function prewarmQuery(query, args = {}) {
+  const client = useConvex();
+  const unsubscribe = client.onUpdate(query, args, () => {
+  });
+  try {
+    onScopeDispose(() => {
+      unsubscribe();
+    });
+  } catch {
+  }
+  return unsubscribe;
+}

package/dist/runtime/composables/useAuth.d.ts

@@ -0,0 +1,60 @@
+import { type ComputedRef, type Ref } from 'vue';
+export type AuthTokens = {
+    token: string;
+    refreshToken: string;
+};
+export type SignInResult = {
+    signingIn: boolean;
+    redirect?: URL;
+};
+export interface UseAuthReturn {
+    isLoading: ComputedRef<boolean>;
+    isAuthenticated: ComputedRef<boolean>;
+    isRefreshing: ComputedRef<boolean>;
+    /**
+     * JWT cookie is present. Use with `isAuthenticated` to keep an SSR-gated
+     * shell mounted while Convex confirms — do not live-subscribe on this alone.
+     */
+    hasSsrSession: ComputedRef<boolean>;
+    /**
+     * Mount the signed-in shell when the SSR cookie is present **or** Convex
+     * has confirmed auth. Prefer this over `isAuthenticated` alone.
+     * Live subscriptions must still gate on `isAuthenticated`.
+     */
+    showAuthedUi: ComputedRef<boolean>;
+    error: Ref<string | null>;
+    pending: Ref<boolean>;
+    signIn: typeof signIn;
+    signOut: typeof signOut;
+}
+/**
+ * First-party Convex Auth session state + actions.
+ *
+ * Only auto-imported when `convex.auth.provider === 'convex-auth'`.
+ * Wire-up happens in `plugin.auth.client` — call `signIn` / `signOut` from forms.
+ */
+export declare function useAuth(): UseAuthReturn;
+/**
+ * Sign in with a Convex Auth provider (password, OAuth, OTP, …).
+ * Mirrors `@convex-dev/auth/react` `useAuthActions().signIn`.
+ */
+export declare function signIn(provider?: string, params?: FormData | Record<string, string>): Promise<SignInResult>;
+/**
+ * Sign out and clear local tokens + SSR JWT cookie.
+ */
+export declare function signOut(): Promise<void>;
+/** @internal Used by the Convex Auth client plugin. */
+export declare function hydrateAuthFromStorage(): void;
+/** @internal Token fetcher for `useConvexAuth({ fetchToken })`. */
+export declare function getAuthToken({ forceRefreshToken, }: {
+    forceRefreshToken: boolean;
+}): Promise<string | null>;
+/** @internal Sync check for OAuth `?code=` + stored verifier (no await). */
+export declare function hasPendingOAuthCallback(): boolean;
+/** @internal Used by the Convex Auth client plugin. */
+export declare function consumeOAuthCodeFromUrl(): Promise<boolean>;
+/** @internal Provider session flags for `useConvexAuth`. */
+export declare function useAuthProviderState(): {
+    isLoading: ComputedRef<boolean>;
+    hasSession: ComputedRef<boolean>;
+};

package/dist/runtime/composables/useAuth.js

@@ -0,0 +1,426 @@
+import { ConvexHttpClient } from "convex/browser";
+import { makeFunctionReference } from "convex/server";
+import {
+  computed,
+  nextTick
+} from "vue";
+import {
+  useRuntimeConfig,
+  useState
+} from "nuxt/app";
+import { useConvexAuth } from "./useConvexAuth.js";
+import { withRefreshMutex } from "../utils/authMutex.js";
+import {
+  useAuthJwtCookie,
+  useAuthPresentCookie
+} from "../utils/authCookie.js";
+import {
+  flattenSignInParams,
+  isHttpOnlyAuth,
+  JWT_STORAGE_KEY,
+  readLocal,
+  REFRESH_TOKEN_STORAGE_KEY,
+  shouldConsumeOAuthCode,
+  storageKey,
+  VERIFIER_STORAGE_KEY,
+  writeLocal
+} from "../utils/authStorage.js";
+import { tryUseConvexContext } from "../utils/context.js";
+import { parseOAuthRedirect } from "../utils/oauthRedirect.js";
+const authSignIn = makeFunctionReference("auth:signIn");
+const authSignOut = makeFunctionReference(
+  "auth:signOut"
+);
+const RETRY_BACKOFF = [500, 2e3];
+const RETRY_JITTER = 100;
+export function useAuth() {
+  const session = useAuthSession();
+  if (!tryUseConvexContext()) {
+    return {
+      isLoading: computed(() => session.isLoading.value),
+      isAuthenticated: computed(() => false),
+      isRefreshing: computed(() => false),
+      hasSsrSession: computed(() => false),
+      showAuthedUi: computed(() => false),
+      error: session.error,
+      pending: session.pending,
+      signIn,
+      signOut
+    };
+  }
+  const convexAuth = useConvexAuth();
+  return {
+    isLoading: convexAuth.isLoading,
+    isAuthenticated: convexAuth.isAuthenticated,
+    isRefreshing: convexAuth.isRefreshing,
+    hasSsrSession: convexAuth.hasSsrSession,
+    showAuthedUi: convexAuth.showAuthedUi,
+    error: session.error,
+    pending: session.pending,
+    signIn,
+    signOut
+  };
+}
+export async function signIn(provider, params) {
+  const session = useAuthSession();
+  const convexUrl = session.convexUrl;
+  if (!convexUrl) {
+    throw new Error("Convex URL is not configured");
+  }
+  session.pending.value = true;
+  session.error.value = null;
+  try {
+    const flatParams = flattenSignInParams(params);
+    const existingVerifier = readLocal(session.verifierKey.value) ?? void 0;
+    writeLocal(session.verifierKey.value, null);
+    const result = await callSignIn(convexUrl, {
+      provider,
+      params: flatParams,
+      verifier: existingVerifier
+    });
+    if (result.redirect !== void 0) {
+      const url = parseOAuthRedirect(result.redirect);
+      if (result.verifier) {
+        writeLocal(session.verifierKey.value, result.verifier);
+      }
+      if (import.meta.client) {
+        window.location.href = url.toString();
+      }
+      return { signingIn: false, redirect: url };
+    }
+    if (result.tokens !== void 0) {
+      await persistTokens(session, result.tokens);
+      return { signingIn: result.tokens !== null };
+    }
+    return { signingIn: false };
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : "Authentication failed";
+    session.error.value = message;
+    throw cause;
+  } finally {
+    session.pending.value = false;
+  }
+}
+export async function signOut() {
+  const session = useAuthSession();
+  const convexUrl = session.convexUrl;
+  session.pending.value = true;
+  session.error.value = null;
+  try {
+    if (convexUrl) {
+      const token = readLocal(session.jwtKey.value);
+      const http = new ConvexHttpClient(convexUrl);
+      if (token) {
+        http.setAuth(token);
+      }
+      try {
+        await http.action(authSignOut, {});
+      } catch {
+      }
+    }
+    await persistTokens(session, null);
+  } finally {
+    session.pending.value = false;
+  }
+}
+export function hydrateAuthFromStorage() {
+  const session = useAuthSession();
+  if (!session.convexUrl) {
+    session.isLoading.value = false;
+    session.hasSession.value = false;
+    return;
+  }
+  if (session.httpOnly) {
+    const present = useAuthPresentCookie();
+    if (present?.value === "1") {
+      session.hasSession.value = true;
+      session.isLoading.value = false;
+      return;
+    }
+    session.isLoading.value = true;
+    void fetchAuthSession().then((result) => {
+      session.hasSession.value = result.hasSession;
+      session.isLoading.value = false;
+      if (result.hasSession) {
+        const marker = useAuthPresentCookie();
+        if (marker) {
+          marker.value = "1";
+        }
+      }
+    });
+    return;
+  }
+  const token = readLocal(session.jwtKey.value);
+  session.hasSession.value = token !== null;
+  session.isLoading.value = false;
+  if (token) {
+    setJwtCookie(token);
+  }
+}
+export async function getAuthToken({
+  forceRefreshToken
+}) {
+  const session = useAuthSession();
+  const convexUrl = session.convexUrl;
+  if (!convexUrl) {
+    return null;
+  }
+  if (session.httpOnly) {
+    return withRefreshMutex(session.refreshKey.value, async () => {
+      if (!forceRefreshToken) {
+        const current = await fetchAuthSessionToken();
+        if (current.token) {
+          session.hasSession.value = true;
+          return current.token;
+        }
+      }
+      const refreshed = await refreshAuthSession();
+      if (!refreshed) {
+        await clearAuthSession();
+        session.hasSession.value = false;
+        return null;
+      }
+      session.hasSession.value = true;
+      return refreshed;
+    });
+  }
+  if (!forceRefreshToken) {
+    return readLocal(session.jwtKey.value);
+  }
+  return withRefreshMutex(session.refreshKey.value, async () => {
+    const refreshToken = readLocal(session.refreshKey.value);
+    if (!refreshToken) {
+      persistTokens(session, null);
+      return null;
+    }
+    try {
+      const result = await callSignInWithRetry(convexUrl, { refreshToken });
+      const tokens = result.tokens ?? null;
+      if (!tokens) {
+        persistTokens(session, null);
+        return null;
+      }
+      persistTokens(session, tokens);
+      return tokens.token;
+    } catch {
+      persistTokens(session, null);
+      return null;
+    }
+  });
+}
+export function hasPendingOAuthCallback() {
+  if (!import.meta.client) {
+    return false;
+  }
+  const session = useAuthSession();
+  if (!session.convexUrl) {
+    return false;
+  }
+  const code = new URLSearchParams(window.location.search).get("code");
+  const verifier = readLocal(session.verifierKey.value);
+  return shouldConsumeOAuthCode({ code, verifier });
+}
+export async function consumeOAuthCodeFromUrl() {
+  if (!import.meta.client) {
+    return false;
+  }
+  const session = useAuthSession();
+  if (!session.convexUrl) {
+    return false;
+  }
+  const code = new URLSearchParams(window.location.search).get("code");
+  const verifier = readLocal(session.verifierKey.value);
+  if (!shouldConsumeOAuthCode({ code, verifier })) {
+    return false;
+  }
+  const url = new URL(window.location.href);
+  url.searchParams.delete("code");
+  window.history.replaceState({}, "", url.pathname + url.search + url.hash);
+  session.pending.value = true;
+  session.error.value = null;
+  session.isLoading.value = true;
+  try {
+    writeLocal(session.verifierKey.value, null);
+    const result = await callSignInWithRetry(session.convexUrl, {
+      params: { code },
+      verifier
+    });
+    await persistTokens(session, result.tokens ?? null);
+    return result.tokens != null;
+  } catch (cause) {
+    const message = cause instanceof Error ? cause.message : "OAuth callback failed";
+    session.error.value = message;
+    await persistTokens(session, null);
+    return false;
+  } finally {
+    session.pending.value = false;
+  }
+}
+export function useAuthProviderState() {
+  const session = useAuthSession();
+  return {
+    isLoading: computed(() => session.isLoading.value),
+    hasSession: computed(() => session.hasSession.value)
+  };
+}
+function useAuthSession() {
+  const config = useRuntimeConfig();
+  const convexConfig = config.public.convex;
+  const convexUrl = convexConfig?.url;
+  const httpOnly = isHttpOnlyAuth(convexConfig?.auth);
+  const isLoading = useState("convex-auth-loading", () => true);
+  const hasSession = useState("convex-auth-has-session", () => false);
+  const error = useState("convex-auth-error", () => null);
+  const pending = useState("convex-auth-pending", () => false);
+  const jwtKey = computed(
+    () => convexUrl ? storageKey(JWT_STORAGE_KEY, convexUrl) : JWT_STORAGE_KEY
+  );
+  const refreshKey = computed(
+    () => convexUrl ? storageKey(REFRESH_TOKEN_STORAGE_KEY, convexUrl) : REFRESH_TOKEN_STORAGE_KEY
+  );
+  const verifierKey = computed(
+    () => convexUrl ? storageKey(VERIFIER_STORAGE_KEY, convexUrl) : VERIFIER_STORAGE_KEY
+  );
+  return {
+    convexUrl,
+    httpOnly,
+    jwtKey,
+    refreshKey,
+    verifierKey,
+    isLoading,
+    hasSession,
+    error,
+    pending
+  };
+}
+function setJwtCookie(token) {
+  const cookie = useAuthJwtCookie();
+  if (!cookie) {
+    return;
+  }
+  cookie.value = token;
+}
+function setPresentCookie(value) {
+  const cookie = useAuthPresentCookie();
+  if (!cookie) {
+    return;
+  }
+  cookie.value = value;
+}
+const AUTH_SESSION_PATH = "/api/convex/auth/session";
+async function fetchAuthSession() {
+  try {
+    return await $fetch(AUTH_SESSION_PATH, {
+      method: "GET"
+    });
+  } catch {
+    return { hasSession: false };
+  }
+}
+async function fetchAuthSessionToken() {
+  try {
+    return await $fetch(
+      AUTH_SESSION_PATH,
+      {
+        method: "POST",
+        body: { getToken: true }
+      }
+    );
+  } catch {
+    return { hasSession: false, token: null };
+  }
+}
+async function refreshAuthSession() {
+  try {
+    const result = await $fetch(AUTH_SESSION_PATH, {
+      method: "POST",
+      body: { refresh: true }
+    });
+    return result.token;
+  } catch {
+    return null;
+  }
+}
+async function clearAuthSession() {
+  try {
+    await $fetch(AUTH_SESSION_PATH, { method: "DELETE" });
+  } catch {
+  }
+  setPresentCookie(null);
+}
+async function writeHttpOnlySession(tokens) {
+  if (tokens === null) {
+    await clearAuthSession();
+    return;
+  }
+  await $fetch(AUTH_SESSION_PATH, {
+    method: "POST",
+    body: {
+      token: tokens.token,
+      refreshToken: tokens.refreshToken
+    }
+  });
+  setPresentCookie("1");
+}
+async function persistTokens(session, tokens) {
+  if (session.httpOnly) {
+    if (tokens === null) {
+      await writeHttpOnlySession(null);
+      writeLocal(session.jwtKey.value, null);
+      writeLocal(session.refreshKey.value, null);
+      session.hasSession.value = false;
+      session.isLoading.value = false;
+      return;
+    }
+    session.hasSession.value = true;
+    session.isLoading.value = false;
+    await writeHttpOnlySession(tokens);
+    return;
+  }
+  if (tokens === null) {
+    writeLocal(session.jwtKey.value, null);
+    writeLocal(session.refreshKey.value, null);
+    setJwtCookie(null);
+    session.hasSession.value = false;
+    session.isLoading.value = false;
+    return;
+  }
+  writeLocal(session.jwtKey.value, tokens.token);
+  writeLocal(session.refreshKey.value, tokens.refreshToken);
+  session.hasSession.value = true;
+  session.isLoading.value = false;
+  nextTick(() => {
+    setJwtCookie(tokens.token);
+  });
+}
+async function callSignIn(convexUrl, args) {
+  const http = new ConvexHttpClient(convexUrl);
+  return await http.action(authSignIn, args);
+}
+async function callSignInWithRetry(convexUrl, args) {
+  let lastError;
+  let retry = 0;
+  while (retry < RETRY_BACKOFF.length) {
+    try {
+      return await callSignIn(convexUrl, args);
+    } catch (e) {
+      lastError = e;
+      if (!isNetworkError(e)) {
+        break;
+      }
+      const wait = RETRY_BACKOFF[retry] + RETRY_JITTER * Math.random();
+      retry++;
+      await new Promise((resolve) => setTimeout(resolve, wait));
+    }
+  }
+  throw lastError;
+}
+function isNetworkError(error) {
+  if (error instanceof TypeError) {
+    return true;
+  }
+  if (error instanceof Error && /network|fetch|Failed to fetch/i.test(error.message)) {
+    return true;
+  }
+  return false;
+}

package/dist/runtime/composables/useAuthToken.d.ts

@@ -0,0 +1,24 @@
+import { navigateTo } from 'nuxt/app';
+import { type ComputedRef } from 'vue';
+/**
+ * Current JWT for authenticated HTTP calls (React `@convex-dev/auth`
+ * `useAuthToken` parity).
+ *
+ * Prefers `ConvexClient.getAuth()`, then the configured `fetchToken`
+ * (Convex Auth / BYO). Returns `null` when signed out or unavailable.
+ */
+export declare function useAuthToken(): ComputedRef<string | null>;
+/**
+ * Nuxt route middleware helper — redirect when the user is signed out.
+ *
+ * @example
+ * ```ts
+ * // middleware/auth.ts
+ * export default defineNuxtRouteMiddleware(() => {
+ *   return requireConvexAuthMiddleware({ redirectTo: '/login' })
+ * })
+ * ```
+ */
+export declare function requireConvexAuthMiddleware(options?: {
+    redirectTo?: string;
+}): ReturnType<typeof navigateTo> | void;