nuxt-convex-module 0.0.0 → 0.9.0

package/dist/runtime/nuxt/composables/use-async-paginated-query.d.ts

@@ -0,0 +1,88 @@
+import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
+import { type PaginatedQueryArgs, type PaginatedQueryItem, type PaginatedQueryReference, type PaginationStatus } from '../../vue/composables/use-paginated-query.js';
+import { type AsyncQueryOptions } from './use-async-query.js';
+/**
+ * Options for {@link useAsyncPaginatedQuery}: `usePaginatedQuery`'s
+ * `initialNumItems` plus the SSR options of {@link AsyncQueryOptions}.
+ *
+ * @public
+ */
+export interface AsyncPaginatedQueryOptions extends Pick<AsyncQueryOptions, 'key' | 'server' | 'lazy' | 'token'> {
+    /** How many items the first page holds — on the server and on the client. */
+    initialNumItems: number;
+}
+/**
+ * The reactive half of {@link AsyncPaginatedQueryReturn}: `usePaginatedQuery`'s
+ * fields plus the `error` and `refresh` of the Nuxt data contract.
+ *
+ * @public
+ */
+export interface AsyncPaginatedQueryData<Item> {
+    /**
+     * The rows: the server-rendered first page until the live subscription
+     * delivers its own, then every loaded page, live. The server page is
+     * shown for the initial args only — after an args change the list is
+     * empty until the new first page arrives.
+     */
+    results: ComputedRef<Item[]>;
+    /**
+     * `usePaginatedQuery`'s status. Before the live subscription has its first
+     * page it is derived from the server page: `'CanLoadMore'` or `'Exhausted'`.
+     */
+    status: ComputedRef<PaginationStatus>;
+    /** `true` while no page — server or live — is available yet, or more rows are loading. */
+    isLoading: ComputedRef<boolean>;
+    /** The SSR fetch error or the live subscription's, `null` when none. Never thrown. */
+    error: ComputedRef<Error | null>;
+    /**
+     * Fetch `numItems` more rows. Takes effect once the live subscription has
+     * its first page (`status` no longer derived from the server page).
+     */
+    loadMore: (numItems: number) => void;
+    /** Re-run the server-side first-page fetch (client-side it is a no-op — the subscription is live). */
+    refresh: (opts?: {
+        dedupe?: 'cancel' | 'defer';
+    }) => Promise<void>;
+}
+/**
+ * Result of {@link useAsyncPaginatedQuery}: awaitable like `useAsyncData`, and
+ * the refs of {@link AsyncPaginatedQueryData}.
+ *
+ * @public
+ */
+export interface AsyncPaginatedQueryReturn<Item> extends PromiseLike<AsyncPaginatedQueryData<Item>>, AsyncPaginatedQueryData<Item> {
+}
+/**
+ * A paginated Convex query the Nuxt way: the first page is fetched during SSR
+ * and hydrated from the payload, then {@link usePaginatedQuery} takes over on
+ * the client — live rows and `loadMore`, no loading flash for the first page.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * import { api } from '#convex/api'
+ *
+ * const { results, status, loadMore } = useAsyncPaginatedQuery(
+ *   api.messages.list,
+ *   {},
+ *   { initialNumItems: 20 },
+ * )
+ * </script>
+ * ```
+ *
+ * The payload entry is keyed on the query name, the *initial* args and
+ * `initialNumItems` (override with `options.key`). Client-side navigation does
+ * not fetch a page over HTTP: the subscription opens straight away, and the
+ * server page only matters for the first paint.
+ *
+ * @param query - a `FunctionReference` for the public paginated query.
+ * @param args - the query's arguments without `paginationOpts`, or `'skip'`.
+ *   Accepts a ref, computed, or getter.
+ * @param options - {@link AsyncPaginatedQueryOptions}.
+ * @returns An awaitable {@link AsyncPaginatedQueryReturn}.
+ *
+ * @public
+ */
+export declare function useAsyncPaginatedQuery<Query extends PaginatedQueryReference>(query: Query, args: MaybeRefOrGetter<PaginatedQueryArgs<Query> | 'skip'>, options: AsyncPaginatedQueryOptions): AsyncPaginatedQueryReturn<PaginatedQueryItem<Query>>;
+/** @public */
+export declare const useConvexAsyncPaginatedQuery: typeof useAsyncPaginatedQuery;

package/dist/runtime/nuxt/composables/use-async-paginated-query.js

@@ -0,0 +1,90 @@
+import { useAsyncData } from "#app";
+import { computed, toValue } from "vue";
+import { getFunctionName } from "convex/server";
+import { convexToJson, jsonToConvex } from "convex/values";
+import {
+  usePaginatedQuery
+} from "../../vue/composables/use-paginated-query.js";
+import { fetchQuery } from "../index.js";
+import { useAsyncQueryContext } from "./use-async-query.js";
+export function useAsyncPaginatedQuery(query, args, options) {
+  const { initialNumItems, server = true, lazy = false, token } = options;
+  const queryName = getFunctionName(query);
+  const initialArgs = toValue(args);
+  const key = options.key ?? defaultAsyncPaginatedQueryKey(queryName, initialArgs, initialNumItems);
+  const { client, deploymentUrl, resolveToken } = useAsyncQueryContext(token);
+  const asyncData = useAsyncData(
+    key,
+    async () => {
+      const currentArgs = toValue(args);
+      if (currentArgs === "skip" || !import.meta.server) {
+        return null;
+      }
+      if (!deploymentUrl) {
+        throw new Error(
+          "`useAsyncPaginatedQuery` could not fetch during SSR: no Convex deployment URL is configured. Set NUXT_PUBLIC_CONVEX_URL or `convex.url` in nuxt.config."
+        );
+      }
+      const result2 = await fetchQuery(
+        query,
+        { ...currentArgs, paginationOpts: { numItems: initialNumItems, cursor: null } },
+        { token: await resolveToken(), url: deploymentUrl }
+      );
+      return { page: convexToJson(result2.page), isDone: result2.isDone };
+    },
+    { server, lazy, deep: false, immediate: initialArgs !== "skip" }
+  );
+  const payloadPage = computed(() => {
+    const entry = asyncData.data.value;
+    return entry ? jsonToConvex(entry.page) : void 0;
+  });
+  const live = !import.meta.server && client ? usePaginatedQuery(query, args, { initialNumItems }) : void 0;
+  const liveState = computed(() => {
+    if (!live) return void 0;
+    try {
+      return { results: live.results.value, status: live.status.value, error: null };
+    } catch (thrown) {
+      return { results: [], status: "LoadingFirstPage", error: thrown };
+    }
+  });
+  const liveHasPage = computed(() => liveState.value !== void 0 && liveState.value.status !== "LoadingFirstPage");
+  const clientError = computed(() => {
+    if (import.meta.server || client || toValue(args) === "skip") return null;
+    return new Error(
+      "`useAsyncPaginatedQuery` could not start on the client: no Convex client is available. Set NUXT_PUBLIC_CONVEX_URL or `convex.url` in nuxt.config."
+    );
+  });
+  const initialArgsJson = argsJson(initialArgs);
+  let payloadRetired = false;
+  const payloadApplies = computed(() => {
+    if (liveHasPage.value || argsJson(toValue(args)) !== initialArgsJson) payloadRetired = true;
+    return !payloadRetired && payloadPage.value !== void 0;
+  });
+  const results = computed(() => {
+    if (liveHasPage.value) return liveState.value.results;
+    return payloadApplies.value ? payloadPage.value : [];
+  });
+  const status = computed(() => {
+    if (liveHasPage.value) return liveState.value.status;
+    if (payloadApplies.value) return asyncData.data.value.isDone ? "Exhausted" : "CanLoadMore";
+    return "LoadingFirstPage";
+  });
+  const isLoading = computed(() => status.value === "LoadingFirstPage" || status.value === "LoadingMore");
+  const error = computed(
+    () => liveState.value?.error ?? clientError.value ?? asyncData.error.value ?? null
+  );
+  const loadMore = (numItems) => {
+    live?.loadMore(numItems);
+  };
+  const refresh = (opts) => asyncData.refresh(opts);
+  const result = { results, status, isLoading, error, loadMore, refresh };
+  const promise = Promise.resolve(asyncData).then(() => result);
+  return Object.assign(promise, result);
+}
+function argsJson(args) {
+  return args === "skip" ? '"skip"' : JSON.stringify(convexToJson(args ?? {}));
+}
+export function defaultAsyncPaginatedQueryKey(queryName, initialArgs, initialNumItems) {
+  return `convex:paginated:${queryName}:${argsJson(initialArgs)}:${initialNumItems}`;
+}
+export const useConvexAsyncPaginatedQuery = useAsyncPaginatedQuery;

package/dist/runtime/nuxt/composables/use-async-query.d.ts

@@ -1,15 +1,3 @@
-/**
- * Nuxt-idiomatic data fetching for Convex queries.
- *
- * {@link useAsyncQuery} is a Vue/Nuxt-only addition (no `convex/react`
- * counterpart — see PARITY.md): it marries Nuxt's `useAsyncData` model with
- * Convex's live queries. During SSR the query runs over HTTP and the result is
- * embedded in the Nuxt payload; after hydration the composable upgrades to the
- * WebSocket subscription, so the page paints with server data and stays live —
- * no loading flash, no client refetch.
- *
- * @module
- */
 import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
 import type { FunctionArgs, FunctionReference, FunctionReturnType } from 'convex/server';
 /**
@@ -94,7 +82,13 @@ export interface AsyncQueryReturn<T> extends PromiseLike<AsyncQueryData<T>> {
         dedupe?: 'cancel' | 'defer';
     }) => Promise<void>;
 }
-type AsyncQueryData<T> = Pick<AsyncQueryReturn<T>, 'data' | 'error' | 'status' | 'refresh'>;
+/**
+ * The reactive half of {@link AsyncQueryReturn} — what `await useAsyncQuery(...)`
+ * resolves to, and the shape to annotate a value passed on from the call site.
+ *
+ * @public
+ */
+export type AsyncQueryData<T> = Pick<AsyncQueryReturn<T>, 'data' | 'error' | 'status' | 'refresh'>;
 /**
  * Load a Convex query the Nuxt way: fetched on the server during SSR,
  * hydrated through the Nuxt payload, then seamlessly upgraded to a live
@@ -137,8 +131,5 @@ type AsyncQueryData<T> = Pick<AsyncQueryReturn<T>, 'data' | 'error' | 'status' |
  * @public
  */
 export declare function useAsyncQuery<Query extends FunctionReference<'query'>>(query: Query, args?: MaybeRefOrGetter<FunctionArgs<Query> | 'skip'>, options?: AsyncQueryOptions): AsyncQueryReturn<FunctionReturnType<Query>>;
-/** Payload key for a query + initial args. Exported for tests. @internal */
-export declare function defaultAsyncQueryKey(queryName: string, initialArgs: unknown): string;
 /** @public */
 export declare const useConvexAsyncQuery: typeof useAsyncQuery;
-export {};

package/dist/runtime/nuxt/composables/use-async-query.js

@@ -4,6 +4,7 @@ import { getFunctionName, makeFunctionReference } from "convex/server";
 import { convexToJson, jsonToConvex } from "convex/values";
 import { useConvex } from "../../vue/client.js";
 import { useConvexQueries } from "../../vue/composables/use-queries.js";
+import { CONVEX_INITIAL_TOKEN_KEY } from "../config.js";
 import { fetchQuery } from "../index.js";
 export function useAsyncQuery(query, args, options = {}) {
   const { server = true, lazy = false, live = true, token } = options;
@@ -11,13 +12,7 @@ export function useAsyncQuery(query, args, options = {}) {
   const queryName = getFunctionName(queryReference);
   const initialArgs = toValue(args) ?? {};
   const key = options.key ?? defaultAsyncQueryKey(queryName, initialArgs);
-  const initialToken = useState("convex:initialToken", () => null);
-  const client = useConvex();
-  const deploymentUrl = import.meta.server ? useRuntimeConfig().public.convex.url : "";
-  const resolveToken = async () => {
-    const resolved = typeof token === "function" ? await token() : token ?? initialToken.value;
-    return resolved ?? void 0;
-  };
+  const { client, deploymentUrl, resolveToken } = useAsyncQueryContext(token);
   const asyncData = useAsyncData(
     key,
     async () => {
@@ -28,7 +23,7 @@ export function useAsyncQuery(query, args, options = {}) {
       if (import.meta.server) {
         if (!deploymentUrl) {
           throw new Error(
-            "`useAsyncQuery` could not fetch during SSR: no Convex deployment URL is configured. Set the `convex.url` module option or NUXT_PUBLIC_CONVEX_URL."
+            "`useAsyncQuery` could not fetch during SSR: no Convex deployment URL is configured. Set NUXT_PUBLIC_CONVEX_URL or `convex.url` in nuxt.config."
           );
         }
         const value2 = await fetchQuery(queryReference, currentArgs, {
@@ -39,7 +34,7 @@ export function useAsyncQuery(query, args, options = {}) {
       }
       if (!client) {
         throw new Error(
-          "`useAsyncQuery` could not fetch on the client: no Convex client is available. Is the `convex.url` module option (or NUXT_PUBLIC_CONVEX_URL) configured?"
+          "`useAsyncQuery` could not fetch on the client: no Convex client is available. Set NUXT_PUBLIC_CONVEX_URL or `convex.url` in nuxt.config."
         );
       }
       const value = await client.query(queryReference, currentArgs);
@@ -97,6 +92,16 @@ export function useAsyncQuery(query, args, options = {}) {
   const promise = Promise.resolve(asyncData).then(() => result);
   return Object.assign(promise, result);
 }
+export function useAsyncQueryContext(token) {
+  const initialToken = useState(CONVEX_INITIAL_TOKEN_KEY, () => null);
+  const client = useConvex();
+  const deploymentUrl = import.meta.server ? useRuntimeConfig().public.convex.url : "";
+  const resolveToken = async () => {
+    const resolved = typeof token === "function" ? await token() : token ?? initialToken.value;
+    return resolved ?? void 0;
+  };
+  return { client, deploymentUrl, resolveToken };
+}
 export function defaultAsyncQueryKey(queryName, initialArgs) {
   const argsJson = initialArgs === "skip" ? '"skip"' : JSON.stringify(convexToJson(initialArgs ?? {}));
   return `convex:${queryName}:${argsJson}`;

package/dist/runtime/nuxt/config.d.ts

@@ -1,3 +1,14 @@
+/**
+ * Nuxt `useState` key the Better Auth server plugin stashes the SSR-prefetched
+ * Convex JWT under, read back by the client plugin and `useAsyncQuery`. Lives
+ * here, dependency-free, so the core composable can read the token without
+ * importing the integration.
+ */
+export declare const CONVEX_INITIAL_TOKEN_KEY = "convex:initialToken";
+/**
+ * The module's runtime config, tolerating a missing Nuxt context (a plain
+ * server import outside a request) by returning an empty object.
+ */
 export declare function getConvexRuntimeConfig(): {
     url: string | undefined;
     siteUrl: string | undefined;

package/dist/runtime/nuxt/config.js

@@ -1,4 +1,5 @@
 import { useRuntimeConfig } from "#imports";
+export const CONVEX_INITIAL_TOKEN_KEY = "convex:initialToken";
 export function getConvexRuntimeConfig() {
   try {
     const config = useRuntimeConfig();

package/dist/runtime/nuxt/csp.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Pure helpers behind the Convex-aware Content Security Policy the module
+ * applies when `nuxt-security` is present — shared by the Nitro plugin
+ * (`./security`) and the unit tests. Import-free so it runs anywhere.
+ */
+/**
+ * The slice of a nuxt-security rule set this module touches: the resolved
+ * options for one route (`rules['/**']` at runtime), where `headers` and
+ * `contentSecurityPolicy` may each be `false` when the app switched them off.
+ */
+export interface SecurityRules {
+    headers?: false | {
+        contentSecurityPolicy?: false | Record<string, unknown>;
+        [header: string]: unknown;
+    };
+    [option: string]: unknown;
+}
+/**
+ * CSP `connect-src` entries the browser needs to reach a Convex deployment: the
+ * deployment URL over both HTTPS and WebSocket (the realtime sync channel) and,
+ * when configured, the `.site` URL that serves Convex HTTP actions. Returns
+ * `[]` for empty or unparseable input.
+ */
+export declare function convexConnectSrc(url?: string, siteUrl?: string): string[];
+/**
+ * CSP sources for Convex-served resources (`img-src` / `media-src`): files
+ * uploaded through `useStorageUrl()` are served from the deployment origin,
+ * and files streamed by HTTP actions from the `.site` origin.
+ */
+export declare function convexResourceSrc(url?: string, siteUrl?: string): string[];
+/**
+ * Apply nuxt-convex-module's secure-by-default, Convex-aware CSP onto a
+ * nuxt-security rule set (mutated in place). This tightens the directives we
+ * can safely pre-fill — locking network egress and Convex-served media to
+ * same-origin plus the Convex deployment — while leaving every other directive
+ * (script/style/font, etc.) to nuxt-security's own defaults.
+ *
+ * For each directive we keep any value the user already set and *append* the
+ * Convex origins, so consumers extend (add their own third parties) rather than
+ * fight the defaults, and the Convex origins are always present. A user who sets
+ * `contentSecurityPolicy: false` (CSP disabled) is left untouched, as is a rule
+ * set with nothing to add (no Convex URL).
+ */
+export declare function applyConvexSecurityDefaults(rules: SecurityRules, connectSrc: string[], resourceSrc: string[]): void;

package/dist/runtime/nuxt/csp.js

@@ -0,0 +1,46 @@
+function toHttpOrigin(raw) {
+  if (!raw) return void 0;
+  try {
+    return new URL(raw).origin;
+  } catch {
+    return void 0;
+  }
+}
+function toWsOrigin(raw) {
+  if (!raw) return void 0;
+  try {
+    const u = new URL(raw);
+    return `${u.protocol === "https:" ? "wss:" : "ws:"}//${u.host}`;
+  } catch {
+    return void 0;
+  }
+}
+function uniq(values) {
+  return Array.from(new Set(values.filter((v) => Boolean(v))));
+}
+export function convexConnectSrc(url, siteUrl) {
+  return uniq([toHttpOrigin(url), toWsOrigin(url), toHttpOrigin(siteUrl), toWsOrigin(siteUrl)]);
+}
+export function convexResourceSrc(url, siteUrl) {
+  return uniq([toHttpOrigin(url), toHttpOrigin(siteUrl)]);
+}
+export function applyConvexSecurityDefaults(rules, connectSrc, resourceSrc) {
+  if (connectSrc.length === 0 && resourceSrc.length === 0) return;
+  if (rules.headers === false) return;
+  if (typeof rules.headers !== "object" || rules.headers === null) rules.headers = {};
+  const headers = rules.headers;
+  if (headers.contentSecurityPolicy === false) return;
+  if (typeof headers.contentSecurityPolicy !== "object" || headers.contentSecurityPolicy === null) {
+    headers.contentSecurityPolicy = {};
+  }
+  const csp = headers.contentSecurityPolicy;
+  tightenDirective(csp, "connect-src", ["'self'"], connectSrc);
+  tightenDirective(csp, "img-src", ["'self'", "data:"], resourceSrc);
+  tightenDirective(csp, "media-src", ["'self'"], resourceSrc);
+}
+function tightenDirective(csp, name, baseline, additions) {
+  if (additions.length === 0) return;
+  const current = csp[name];
+  const existing = Array.isArray(current) ? current : typeof current === "string" ? current.split(/\s+/).filter(Boolean) : baseline;
+  csp[name] = uniq([...existing, ...additions]);
+}

package/dist/runtime/nuxt/index.d.ts

@@ -8,9 +8,12 @@
  *
  * ## Usage
  *
- * All exported functions assume that a Convex deployment URL is set in the
- * `NUXT_PUBLIC_CONVEX_URL` environment variable. `npx convex dev` will
- * automatically set it during local development.
+ * All exported functions assume that a Convex deployment URL is configured —
+ * `convex.url` in `nuxt.config`, `NUXT_PUBLIC_CONVEX_URL`, or the `CONVEX_URL`
+ * that `npx convex dev` writes to `.env.local`. Unlike its Next counterpart,
+ * `npx convex dev` does *not* set the framework-prefixed name for Nuxt: the
+ * Convex CLI has no Nuxt case in its framework detection, so it writes the
+ * unprefixed `CONVEX_URL`, which the module reads too.
  *
  * ### Preloading data
  *
@@ -51,15 +54,12 @@ export type NuxtOptions = {
     token?: string;
     /**
      * The URL of the Convex deployment to use for the function call.
-     * Defaults to `process.env.NUXT_PUBLIC_CONVEX_URL` if not provided.
+     * Defaults to `runtimeConfig.public.convex.url`, then to
+     * `process.env.NUXT_PUBLIC_CONVEX_URL`, if not provided.
      *
      * Explicitly passing undefined here (such as from missing ENV variables) will throw an error in the future.
      */
     url?: string;
-    /**
-     * @internal
-     */
-    adminToken?: string;
     /**
      * Skip validating that the Convex deployment URL looks like
      * `https://happy-animal-123.convex.cloud` or localhost.

package/dist/runtime/nuxt/security.d.ts

@@ -0,0 +1,33 @@
+import { type SecurityRules } from './csp.js';
+/**
+ * The slice of the Nitro app this plugin touches, typed locally: the hook's
+ * real declaration lives in the types nuxt-security generates into the app,
+ * which only exist when the app has it installed — and this plugin is only
+ * registered then. Nitro itself is not imported, so the published types don't
+ * depend on how the app resolves `nitropack`.
+ */
+export interface SecurityNitroApp {
+    hooks: {
+        hook: (name: 'nuxt-security:routeRules', fn: (rules: Record<string, SecurityRules>) => void) => unknown;
+    };
+}
+/**
+ * Nitro plugin: extend nuxt-security's Content Security Policy with the Convex
+ * origins. Registered by the module only when the nuxt-security integration is
+ * on (see `registerSecurity` in `module.ts`).
+ *
+ * Listens for `nuxt-security:routeRules`, which nuxt-security fires once its
+ * global config and every route rule are merged into one table — so the
+ * origins are appended to whatever the app configured, whatever the order of
+ * `modules`. nuxt-security sorts its own Nitro plugins last, so this listener
+ * is in place before the hook fires. The deployment URL comes from runtime
+ * config, so it need not be known at build time.
+ *
+ * `connect-src` is tightened only in production: creating it in dev would
+ * block the Vite HMR and devtools WebSockets, which run on ports `'self'`
+ * doesn't cover, while nuxt-security's defaults leave the directive open.
+ * `img-src` / `media-src` are widened in dev too — nuxt-security enforces its
+ * default `img-src 'self' data:` during `nuxt dev` as well, which would block
+ * files served from Convex storage.
+ */
+export default function convexSecurityPlugin(nitroApp: SecurityNitroApp): void;

package/dist/runtime/nuxt/security.js

@@ -0,0 +1,14 @@
+import { getConvexRuntimeConfig } from "./config.js";
+import { applyConvexSecurityDefaults, convexConnectSrc, convexResourceSrc } from "./csp.js";
+export default function convexSecurityPlugin(nitroApp) {
+  nitroApp.hooks.hook("nuxt-security:routeRules", (rules) => {
+    const global = rules["/**"];
+    if (!global) return;
+    const { url, siteUrl } = getConvexRuntimeConfig();
+    applyConvexSecurityDefaults(
+      global,
+      import.meta.dev ? [] : convexConnectSrc(url, siteUrl),
+      convexResourceSrc(url, siteUrl)
+    );
+  });
+}

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

@@ -48,10 +48,15 @@ export interface PolarComponentApi {
     }>;
 }
 /**
+ * Renders a link to the Polar customer portal for the signed-in user, where
+ * they manage their subscription.
+ *
  * @example
  * ```vue
  * <CustomerPortalLink>Manage subscription</CustomerPortalLink>
  * ```
+ *
+ * @public
  */
 export declare const CustomerPortalLink: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     polarApi: {
@@ -86,6 +91,8 @@ export declare const CustomerPortalLink: import("vue").DefineComponent<import("v
  *   Start free trial
  * </CheckoutLink>
  * ```
+ *
+ * @public
  */
 export declare const CheckoutLink: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     polarApi: {
@@ -172,9 +179,9 @@ export declare const CheckoutLink: import("vue").DefineComponent<import("vue").E
         default: boolean;
     };
 }>> & Readonly<{}>, {
+    embed: boolean;
     lazy: boolean;
     metadata: Record<string, string>;
-    embed: boolean;
     subscriptionId: string;
     trialInterval: "day" | "week" | "month" | "year" | null;
     trialIntervalCount: number | null;

package/dist/runtime/polar/vue/components.js

@@ -13,7 +13,7 @@ export const CustomerPortalLink = defineComponent({
     const polarApi = props.polarApi ?? useConvexNamespace("billing");
     const generateCustomerPortalUrl = polarApi?.generateCustomerPortalUrl ? useAction(polarApi.generateCustomerPortalUrl) : void 0;
     const portalUrl = ref();
-    if (import.meta.client && generateCustomerPortalUrl) {
+    if (!import.meta.server && generateCustomerPortalUrl) {
       watch(
         () => props.returnUrl,
         (returnUrl) => {
@@ -55,7 +55,7 @@ export const CheckoutLink = defineComponent({
     const generateCheckoutLink = polarApi?.generateCheckoutLink ? useAction(polarApi.generateCheckoutLink) : void 0;
     const checkoutLink = ref();
     const isLoading = ref(false);
-    if (import.meta.client && generateCheckoutLink) {
+    if (!import.meta.server && generateCheckoutLink) {
       watch(
         () => [props.lazy, props.productIds, props.subscriptionId, props.metadata, props.embed, props.trialInterval, props.trialIntervalCount, props.locale],
         async () => {
@@ -99,7 +99,7 @@ export const CheckoutLink = defineComponent({
           const { PolarEmbedCheckout } = await import("@polar-sh/checkout/embed");
           await PolarEmbedCheckout.create(url, { theme: props.theme });
         } else {
-          window.open(url, "_blank");
+          window.open(url, "_blank", "noopener");
         }
       } finally {
         isLoading.value = false;

package/dist/runtime/vue/auth/index.d.ts

@@ -89,9 +89,9 @@ export interface ConvexAuthProviderOptions {
  * @example
  * ```vue
  * <script setup lang="ts">
- * import { useAuth } from '~/composables/useAuth'  // your auth provider
+ * import { useAuth } from '~/composables/useMyAuthProvider'  // your auth provider
  *
- * const { client } = useNuxtApp().$convex
+ * const client = useConvex()
  * const authState = provideConvexAuth({ client, useAuth })
  * </script>
  * ```
@@ -112,11 +112,11 @@ export declare function provideConvexAuth(options: ConvexAuthProviderOptions): C
  * (`nuxtApp.vueApp.provide`) rather than from a component's setup function.
  *
  * When `scope` is provided, all watchers are created inside that
- * {@link EffectScope} so callers can dispose them later.
+ * `EffectScope` so callers can dispose them later.
  */
 export declare function createConvexAuthState(options: ConvexAuthProviderOptions, scope?: EffectScope): ConvexAuthState;
 /**
- * Create a fresh {@link EffectScope} and build a Convex auth state inside it.
+ * Create a fresh `EffectScope` and build a Convex auth state inside it.
  * The scope is returned so the caller can `.stop()` it on teardown.
  */
 export declare function createScopedConvexAuthState(options: ConvexAuthProviderOptions): {

package/dist/runtime/vue/auth/index.js

@@ -84,10 +84,14 @@ export function createConvexAuthState(options, scope) {
   const isAuthenticated = computed(
     () => toValue(authProviderAuthenticated) && (isConvexAuthenticated.value ?? false)
   );
+  const isLoading = computed(() => isConvexAuthenticated.value === null);
+  const isRefreshingWhileAuthenticated = computed(
+    () => isRefreshing.value && isAuthenticated.value
+  );
   return {
-    isLoading: computed(() => isConvexAuthenticated.value === null),
+    isLoading,
     isAuthenticated,
-    isRefreshing: computed(() => isRefreshing.value && isAuthenticated.value)
+    isRefreshing: isRefreshingWhileAuthenticated
   };
 }
 export function createScopedConvexAuthState(options) {