nuxt-convex-module 0.0.0 → 0.9.0

package/dist/module.mjs

@@ -0,0 +1,576 @@
+import { useLogger, updateTemplates, defineNuxtModule, createResolver, addPlugin, hasNuxtModule, addServerPlugin, addPluginTemplate, addTypeTemplate, addImports, addServerImports, addComponent, addServerHandler, extendRouteRules, addRouteMiddleware } from '@nuxt/kit';
+import { join, isAbsolute } from 'node:path';
+import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+
+function resolveIntegrationState(explicit, installed, declared = installed) {
+  if (explicit === false) return { enabled: false, missingPackage: false };
+  if (explicit === void 0) return { enabled: installed && declared, missingPackage: false };
+  return installed ? { enabled: true, missingPackage: false } : { enabled: false, missingPackage: true };
+}
+function isDeclaredDependency(id, rootDir) {
+  try {
+    const manifest = JSON.parse(readFileSync(join(rootDir, "package.json"), "utf8"));
+    return ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"].some((field) => typeof manifest[field] === "object" && manifest[field] !== null && id in manifest[field]);
+  } catch {
+    return false;
+  }
+}
+function stripTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "/") end--;
+  return value.slice(0, end);
+}
+function normalizeRoutePath(value, option, warnings) {
+  let path = value;
+  if (!path.startsWith("/")) {
+    path = `/${path}`;
+    warnings.push(`\`${option}\` ("${value}") must start with "/" \u2014 using "${path}".`);
+  }
+  return path.length > 1 && path.endsWith("/") ? stripTrailingSlashes(path) : path;
+}
+function validateModuleOptions(input) {
+  const errors = [];
+  const warnings = [];
+  if (input.url && input.url.endsWith(".convex.site")) {
+    errors.push(
+      `\`convex.url\` ("${input.url}") ends with .convex.site, which is the HTTP Actions domain \u2014 deployment URLs end with .convex.cloud. Did you mean to set \`convex.siteUrl\`?`
+    );
+  } else if (input.url && !isHttpUrl(input.url)) {
+    warnings.push(
+      `\`convex.url\` ("${input.url}") does not look like a valid http(s) URL \u2014 Convex clients will fail to connect.`
+    );
+  }
+  if (input.siteUrl && input.siteUrl.endsWith(".convex.cloud")) {
+    errors.push(
+      `\`convex.siteUrl\` ("${input.siteUrl}") ends with .convex.cloud, which is the deployment domain \u2014 site URLs (HTTP Actions) end with .convex.site. Did you swap it with \`convex.url\`?`
+    );
+  } else if (input.siteUrl && !isHttpUrl(input.siteUrl)) {
+    warnings.push(
+      `\`convex.siteUrl\` ("${input.siteUrl}") does not look like a valid http(s) URL.`
+    );
+  }
+  const authRoute = normalizeRoutePath(input.authRoute, "convex.authRoute", warnings);
+  const loginPath = normalizeRoutePath(input.loginPath ?? "/login", "convex.betterAuth.loginPath", warnings);
+  if (authRoute !== "/api/auth" && !input.authClient) {
+    errors.push(
+      `\`convex.authRoute\` is "${authRoute}" but the bundled Better Auth client still calls /api/auth, so every auth request would 404. Keep the default route, or set \`convex.betterAuth.authClient\` to a client created with \`basePath: "${authRoute}"\`.`
+    );
+  }
+  if (input.authClient && !authClientModuleExists(input.authClient, input.rootDir)) {
+    errors.push(
+      `\`convex.betterAuth.authClient\` points at "${input.authClient}", which does not exist (resolved against \`${input.rootDir}\`). The build would fail with an opaque import error \u2014 fix the path or remove the option to use the bundled client.`
+    );
+  }
+  return { errors, warnings, authRoute, loginPath };
+}
+function isHttpUrl(value) {
+  if (!value.startsWith("http://") && !value.startsWith("https://")) {
+    return false;
+  }
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function authClientModuleExists(authClient, rootDir) {
+  const base = isAbsolute(authClient) ? authClient : join(rootDir, authClient);
+  return ["", ".ts", ".js", ".mts", ".mjs", "/index.ts", "/index.js"].some((suffix) => {
+    const candidate = `${base}${suffix}`;
+    return existsSync(candidate) && statSync(candidate).isFile();
+  });
+}
+function integrationWarnings(flags, isInstalled) {
+  const warnings = [];
+  const rivals = [flags.clerk && "Clerk", flags.auth0 && "Auth0"].filter((name) => Boolean(name));
+  if (flags.betterAuth && rivals.length > 0) {
+    const options = rivals.map((name) => `\`convex.${name.toLowerCase()}: false\``).join(" / ");
+    warnings.push(
+      `Better Auth and ${rivals.join(" and ")} are both enabled. Better Auth's plugin owns the Convex client's auth, so the ${rivals.join(" / ")} adapter would fight it \u2014 set ${options}, or \`convex.betterAuth: false\`, to pick one.`
+    );
+  }
+  if (flags.polar && !isInstalled("@polar-sh/checkout")) {
+    warnings.push(
+      "`@convex-dev/polar` is installed but its peer `@polar-sh/checkout` is not \u2014 `<CheckoutLink>` imports it and the build fails the moment the component is used. Run `npm install @polar-sh/checkout`."
+    );
+  }
+  return warnings;
+}
+function formatStartupSummary(url, functionsDir, integrations) {
+  const names = {
+    betterAuth: "better-auth",
+    clerk: "clerk",
+    auth0: "auth0",
+    polar: "polar",
+    security: "nuxt-security"
+  };
+  const enabled = Object.keys(names).filter((key) => integrations[key]).map((key) => names[key]);
+  return `Convex ${url || "(no URL)"} \xB7 functions: ${functionsDir}/ \xB7 integrations: ${enabled.join(", ") || "none"}`;
+}
+function isPackageInstalled(id, rootDir) {
+  for (const base of [join(rootDir, "package.json"), import.meta.url]) {
+    const lookupPaths = createRequire(base).resolve.paths(id) ?? [];
+    if (lookupPaths.some((dir) => existsSync(join(dir, id, "package.json")))) return true;
+  }
+  return false;
+}
+function resolveDeploymentUrls(options, env) {
+  return {
+    url: stripTrailingSlashes(options.url || env.NUXT_PUBLIC_CONVEX_URL || env.CONVEX_URL || ""),
+    siteUrl: stripTrailingSlashes(options.siteUrl || env.NUXT_PUBLIC_CONVEX_SITE_URL || env.CONVEX_SITE_URL || "")
+  };
+}
+
+const logger$1 = useLogger("nuxt-convex-module");
+const DEFAULT_FUNCTIONS_DIR = "convex";
+function resolveFunctionsDir(rootDir) {
+  return readFunctionsDirFromConvexJson(join(rootDir, "convex.json")) ?? DEFAULT_FUNCTIONS_DIR;
+}
+function hasGeneratedApi(rootDir, functionsDir = resolveFunctionsDir(rootDir)) {
+  const generatedApi = join(rootDir, functionsDir, "_generated", "api");
+  return existsSync(`${generatedApi}.d.ts`) || existsSync(`${generatedApi}.js`);
+}
+function readFunctionsDirFromConvexJson(convexJsonPath) {
+  if (!existsSync(convexJsonPath)) {
+    return;
+  }
+  try {
+    const convexJson = JSON.parse(readFileSync(convexJsonPath, "utf-8"));
+    if (typeof convexJson.functions !== "string") {
+      return;
+    }
+    return normalizeFunctionsDir(convexJson.functions);
+  } catch (error) {
+    logger$1.warn(`Failed to parse convex.json: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function normalizeFunctionsDir(functionsDir) {
+  const normalized = stripTrailingSlashes(functionsDir.replace(/^\.?\//, ""));
+  return normalized || void 0;
+}
+
+function getConvexAliases(rootDir) {
+  const functionsDir = resolveFunctionsDir(rootDir);
+  const convexDir = join(rootDir, functionsDir);
+  const generatedDir = join(convexDir, "_generated");
+  return {
+    "#convex/api": join(generatedDir, "api"),
+    "#convex/server": join(generatedDir, "server"),
+    "#convex/dataModel": join(generatedDir, "dataModel"),
+    "#convex/_generated": generatedDir,
+    "#convex": convexDir
+  };
+}
+
+const CODEGEN_GUARDED_TEMPLATES = ["nuxt-convex-module-provide-api.mjs", "types/nuxt-convex-module-api-fallback.d.ts"];
+function watchConvexCodegen(nuxt) {
+  if (!nuxt.options.dev) return;
+  const generatedDir = join(nuxt.options.rootDir, resolveFunctionsDir(nuxt.options.rootDir), "_generated");
+  if (!nuxt.options.watch.includes(generatedDir)) nuxt.options.watch.push(generatedDir);
+  nuxt.hook("builder:watch", async (_event, path) => {
+    if (!path.replace(/\\/g, "/").includes("_generated/api")) return;
+    await updateTemplates({ filter: (template) => CODEGEN_GUARDED_TEMPLATES.includes(template.filename) });
+  });
+}
+
+const PLAIN_NUXT_DEV = /^(?:npx )?(?:nuxt|nuxi) dev(?: [^&|;]*)?$/;
+function combinedDevScript(nuxtCommand) {
+  return `convex dev --start '${nuxtCommand}'`;
+}
+function setupDevScript(rootDir) {
+  const path = join(rootDir, "package.json");
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch {
+    return { changed: false };
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(raw);
+  } catch {
+    return { changed: false };
+  }
+  const scripts = manifest.scripts;
+  if (typeof scripts !== "object" || scripts === null) return { changed: false };
+  const dev = scripts.dev;
+  if (typeof dev !== "string" || !PLAIN_NUXT_DEV.test(dev.trim())) return { changed: false };
+  if (Object.values(scripts).some((s) => typeof s === "string" && s.includes("convex dev"))) return { changed: false };
+  if (!isDeclaredDependency("convex", rootDir)) return { changed: false };
+  const to = combinedDevScript(dev.trim());
+  scripts.dev = to;
+  const indent = raw.match(/^[ \t]+(?=")/m)?.[0] ?? "  ";
+  const newline = raw.endsWith("\n") ? "\n" : "";
+  writeFileSync(path, JSON.stringify(manifest, null, indent) + newline);
+  return { changed: true, from: dev, to };
+}
+
+const vue = (file) => `runtime/vue/${file}`;
+const composable = (file) => vue(`composables/${file}`);
+const asyncQuery = "runtime/nuxt/composables/use-async-query";
+const asyncPaginatedQuery = "runtime/nuxt/composables/use-async-paginated-query";
+const APP_IMPORTS = {
+  core: [
+    { name: "useConvex", from: vue("client") },
+    { name: "useQuery", from: composable("use-query") },
+    { name: "useQuery_experimental", from: composable("use-query") },
+    { name: "useConvexQuery", from: composable("use-query") },
+    { name: "useQueries", from: composable("use-queries") },
+    { name: "useConvexQueries", from: composable("use-queries") },
+    { name: "useMutation", from: composable("use-mutation") },
+    { name: "useConvexMutation", from: composable("use-mutation") },
+    { name: "useAction", from: composable("use-action") },
+    { name: "useConvexAction", from: composable("use-action") },
+    { name: "useConvexConnectionState", from: composable("use-connection-state") },
+    { name: "useUpload", from: composable("use-upload") },
+    { name: "useConvexUpload", from: composable("use-upload") },
+    { name: "uploadFile", from: composable("use-upload") },
+    { name: "useUploadQueue", from: composable("use-upload-queue") },
+    { name: "useConvexUploadQueue", from: composable("use-upload-queue") },
+    { name: "useStorageUrl", from: composable("use-storage-url") },
+    { name: "useConvexStorageUrl", from: composable("use-storage-url") },
+    { name: "useConvexAuth", from: vue("auth/index") },
+    { name: "provideConvexAuth", from: vue("auth/index") },
+    { name: "provideConvexApi", from: vue("provide") },
+    { name: "useConvexApi", from: vue("provide") },
+    { name: "useConvexNamespace", from: vue("provide") },
+    { name: "usePreloadedQuery", from: vue("hydration") },
+    // Nuxt-only (imports `#app`), hence under runtime/nuxt/ — see PARITY.md.
+    // Its types too, so `import type { AsyncQueryReturn } from '#imports'` works
+    // without spelling out the `nuxt-convex-module/app` subpath.
+    { name: "useAsyncQuery", from: asyncQuery },
+    { name: "useConvexAsyncQuery", from: asyncQuery },
+    { name: "AsyncQueryData", from: asyncQuery, type: true },
+    { name: "AsyncQueryOptions", from: asyncQuery, type: true },
+    { name: "AsyncQueryReturn", from: asyncQuery, type: true },
+    { name: "AsyncQueryStatus", from: asyncQuery, type: true },
+    { name: "usePaginatedQuery", from: composable("use-paginated-query") },
+    { name: "useConvexPaginatedQuery", from: composable("use-paginated-query") },
+    { name: "usePaginatedQuery_experimental", from: composable("use-paginated-query") },
+    { name: "useAsyncPaginatedQuery", from: asyncPaginatedQuery },
+    { name: "useConvexAsyncPaginatedQuery", from: asyncPaginatedQuery },
+    { name: "AsyncPaginatedQueryData", from: asyncPaginatedQuery, type: true },
+    { name: "AsyncPaginatedQueryOptions", from: asyncPaginatedQuery, type: true },
+    { name: "AsyncPaginatedQueryReturn", from: asyncPaginatedQuery, type: true }
+  ],
+  betterAuth: [
+    { name: "useBetterAuth", from: "runtime/better-auth/vue/use-better-auth" },
+    { name: "usePreloadedAuthQuery", from: "runtime/better-auth/vue/hydration" },
+    { name: "resolveAuthRedirect", from: "runtime/better-auth/vue/redirect" }
+  ],
+  clerk: [{ name: "provideConvexAuthFromClerk", from: "runtime/clerk/vue/index" }],
+  auth0: [{ name: "provideConvexAuthFromAuth0", from: "runtime/auth0/vue/index" }],
+  polar: []
+};
+const APP_COMPONENTS = {
+  core: [
+    ...["Authenticated", "Unauthenticated", "AuthLoading", "AuthRefreshing"].map((name) => ({ name, from: vue("auth/helpers") })),
+    { name: "ConvexImage", from: vue("components/convex-image") }
+  ],
+  betterAuth: [{ name: "AuthBoundary", from: "runtime/better-auth/vue/auth-boundary" }],
+  clerk: [{ name: "ConvexProviderWithClerk", from: "runtime/clerk/vue/index" }],
+  auth0: [{ name: "ConvexProviderWithAuth0", from: "runtime/auth0/vue/index" }],
+  polar: ["CheckoutLink", "CustomerPortalLink"].map((name) => ({ name, from: "runtime/polar/vue/components" }))
+};
+const SERVER_IMPORTS = {
+  core: ["fetchQuery", "fetchMutation", "fetchAction", "preloadQuery", "preloadedQueryResult"].map((name) => ({ name, from: "runtime/nuxt/index" })),
+  betterAuth: ["convexAuth", "convexBetterAuthNuxt"].map((name) => ({ name, from: "runtime/better-auth/nuxt/server" })),
+  clerk: [],
+  auth0: [],
+  polar: []
+};
+
+function convexTypeFallbackContents(hasApi, functionsDir) {
+  if (hasApi) {
+    return "export {}\n";
+  }
+  return [
+    `// Placeholder until \`npx convex dev\` generates ${functionsDir}/_generated.`,
+    "declare module '#convex/api' {",
+    "  export const api: any",
+    "  export const internal: any",
+    "  export const components: any",
+    "}",
+    "declare module '#convex/server' {",
+    "  export const query: any",
+    "  export const internalQuery: any",
+    "  export const mutation: any",
+    "  export const internalMutation: any",
+    "  export const action: any",
+    "  export const internalAction: any",
+    "  export const httpAction: any",
+    "  export type QueryCtx = any",
+    "  export type MutationCtx = any",
+    "  export type ActionCtx = any",
+    "  export type DatabaseReader = any",
+    "  export type DatabaseWriter = any",
+    "}",
+    "declare module '#convex/dataModel' {",
+    "  export type Doc<TableName extends string = string> = any",
+    "  export type Id<TableName extends string = string> = string",
+    "  export type DataModel = any",
+    "  export type TableNames = string",
+    "}",
+    ""
+  ].join("\n");
+}
+
+const logger = useLogger("nuxt-convex-module");
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "nuxt-convex-module",
+    configKey: "convex",
+    // Surfaced by Nuxt DevTools and the nuxt/modules registry.
+    docs: "https://nuxt-convex-module.dev",
+    // `moduleDependencies` (below) is a Nuxt >= 4.1 feature — fail fast with a
+    // clear kit error on older Nuxt instead of silently skipping nuxt-security.
+    compatibility: {
+      nuxt: ">=4.1.0"
+    }
+  },
+  defaults: {
+    authRoute: "/api/auth",
+    devtools: true,
+    devScript: true
+  },
+  // nuxt-security is optional. When the app has it installed (and hasn't
+  // switched it off), declare it as a module dependency so Nuxt's core loader
+  // registers it — deduping if it's already in `modules`, hoisting its types —
+  // with no extra entry on the consumer's side. The Convex-aware CSP is applied
+  // at runtime (see `registerSecurity`), so module order is irrelevant. Nothing
+  // is declared otherwise: kit fails the build resolving an absent package.
+  moduleDependencies: (nuxt) => resolveSecurityState(nuxt, readSecurityOption(nuxt)).enabled ? { "nuxt-security": {} } : {},
+  async setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    nuxt.options.build.transpile.push(resolver.resolve("./runtime"));
+    const { url, siteUrl } = applyRuntimeConfig(nuxt, options);
+    const diagnostics = validateModuleOptions({
+      url,
+      siteUrl,
+      authRoute: options.authRoute || "/api/auth",
+      loginPath: nuxt.options.runtimeConfig.public.convex.loginPath,
+      authClient: typeof options.betterAuth === "object" ? options.betterAuth.authClient : void 0,
+      rootDir: nuxt.options.rootDir
+    });
+    for (const message of diagnostics.errors) logger.error(message);
+    for (const message of diagnostics.warnings) logger.warn(message);
+    options.authRoute = diagnostics.authRoute;
+    nuxt.options.runtimeConfig.public.convex.loginPath = diagnostics.loginPath;
+    registerAuthClientAlias(resolver, nuxt, options);
+    registerConvexAliases(nuxt);
+    registerConvexApiPlugin(resolver, nuxt);
+    registerConvexTypeFallback(nuxt);
+    registerVueComposables(resolver);
+    registerAuthComponents(resolver);
+    const integrations = registerIntegrations(resolver, nuxt, options);
+    watchConvexCodegen(nuxt);
+    if (nuxt.options.dev && options.devtools !== false && isDevtoolsUiEnabled(nuxt)) {
+      const { setupDevtools } = await import('./chunks/index.mjs');
+      setupDevtools(resolver, nuxt, {
+        url,
+        siteUrl,
+        rootDir: nuxt.options.rootDir,
+        functionsDir: resolveFunctionsDir(nuxt.options.rootDir),
+        integrations
+      });
+      addPlugin({ src: resolver.resolve("./runtime/devtools/plugin.client"), mode: "client" }, { append: true });
+    }
+    if (nuxt.options.dev && !nuxt.options._prepare) {
+      logger.info(formatStartupSummary(url, resolveFunctionsDir(nuxt.options.rootDir), integrations));
+    }
+    if (options.devScript !== false && (nuxt.options.dev || nuxt.options._prepare)) {
+      const result = setupDevScript(nuxt.options.rootDir);
+      if (result.changed) {
+        logger.info(`Set \`scripts.dev\` to \`${result.to}\` \u2014 one command now runs Convex beside Nuxt, no .env needed locally. Set \`convex.devScript: false\` to keep your own script.`);
+      }
+    }
+  }
+});
+function isDevtoolsUiEnabled(nuxt) {
+  const devtools = nuxt.options.devtools;
+  return typeof devtools === "boolean" ? devtools : devtools?.enabled !== false;
+}
+function registerIntegrations(resolver, nuxt, options) {
+  const report = (key, pkg, state) => {
+    if (state.missingPackage) {
+      logger.error(`\`convex.${key}\` is enabled but \`${pkg}\` is not installed. Run \`npm install ${pkg}\` or remove the option.`);
+    }
+    return state.enabled;
+  };
+  const rootDir = nuxt.options.rootDir;
+  const resolve = (key, pkg) => report(key, pkg, resolveIntegrationState(options[key], isPackageInstalled(pkg, rootDir), isDeclaredDependency(pkg, rootDir)));
+  const betterAuth = resolve("betterAuth", "@convex-dev/better-auth");
+  if (betterAuth) {
+    registerBetterAuth(resolver, options.authRoute || "/api/auth");
+  } else {
+    registerBaseConvexClient(resolver);
+  }
+  const clerk = resolve("clerk", "@clerk/vue");
+  if (clerk) {
+    registerClerk(resolver);
+  }
+  const auth0 = resolve("auth0", "@auth0/auth0-vue");
+  if (auth0) {
+    registerAuth0(resolver);
+  }
+  const polar = resolve("polar", "@convex-dev/polar");
+  if (polar) {
+    registerPolarComponents(resolver);
+  }
+  const security = report("security", "nuxt-security", resolveSecurityState(nuxt, options.security));
+  if (security) {
+    registerSecurity(resolver);
+  }
+  const flags = { betterAuth, clerk, auth0, polar, security };
+  for (const message of integrationWarnings(flags, (pkg) => isPackageInstalled(pkg, rootDir))) logger.warn(message);
+  return flags;
+}
+function readSecurityOption(nuxt) {
+  const opts = nuxt.options;
+  return opts.convex?.security;
+}
+function resolveSecurityState(nuxt, explicit) {
+  const opts = nuxt.options;
+  if (opts.security === false) return { enabled: false, missingPackage: false };
+  const registered = hasNuxtModule("nuxt-security", nuxt);
+  const installed = registered || isPackageInstalled("nuxt-security", nuxt.options.rootDir);
+  const declared = registered || isDeclaredDependency("nuxt-security", nuxt.options.rootDir);
+  return resolveIntegrationState(explicit, installed, declared);
+}
+function registerSecurity(resolver) {
+  addServerPlugin(resolver.resolve("./runtime/nuxt/security"));
+}
+function applyRuntimeConfig(nuxt, options) {
+  const resolved = resolveDeploymentUrls(options, process.env);
+  const url = nuxt.options._prepare ? "" : resolved.url;
+  if (!url && !nuxt.options._prepare) {
+    logger.warn(
+      "No Convex deployment URL configured. Set NUXT_PUBLIC_CONVEX_URL or `convex.url` in nuxt.config. Note: `npx convex dev` writes CONVEX_URL to .env.local, which Nuxt does not read without `nuxt dev --dotenv .env.local`."
+    );
+  }
+  const siteUrl = resolved.siteUrl;
+  const crossDomainCallbackRoute = typeof options.betterAuth === "object" && options.betterAuth.crossDomainCallbackRoute || "";
+  const loginPath = typeof options.betterAuth === "object" && options.betterAuth.loginPath || "/login";
+  const runtimeConfig = nuxt.options.runtimeConfig;
+  runtimeConfig.public.convex = {
+    ...runtimeConfig.public.convex,
+    url,
+    siteUrl,
+    crossDomainCallbackRoute,
+    loginPath
+  };
+  runtimeConfig.convex = { ...runtimeConfig.convex, siteUrl };
+  return { url, siteUrl };
+}
+function registerConvexAliases(nuxt) {
+  const aliases = getConvexAliases(nuxt.options.rootDir);
+  nuxt.options.nitro ||= {};
+  nuxt.options.nitro.alias ||= {};
+  for (const [alias, target] of Object.entries(aliases)) {
+    nuxt.options.alias[alias] = target;
+    nuxt.options.nitro.alias[alias] = target;
+  }
+}
+function registerAuthClientAlias(resolver, nuxt, options) {
+  const custom = typeof options.betterAuth === "object" ? options.betterAuth.authClient : void 0;
+  const target = custom ? isAbsolute(custom) ? custom : join(nuxt.options.rootDir, custom) : resolver.resolve("./runtime/better-auth/vue/client");
+  nuxt.options.nitro ||= {};
+  nuxt.options.nitro.alias ||= {};
+  nuxt.options.alias["#convex/auth-client"] = target;
+  nuxt.options.nitro.alias["#convex/auth-client"] = target;
+}
+function registerConvexApiPlugin(resolver, nuxt) {
+  const functionsDir = resolveFunctionsDir(nuxt.options.rootDir);
+  const provideModule = resolver.resolve("./runtime/vue/provide");
+  let notifiedMissing = false;
+  addPluginTemplate({
+    filename: "nuxt-convex-module-provide-api.mjs",
+    getContents: () => {
+      if (!hasGeneratedApi(nuxt.options.rootDir, functionsDir)) {
+        if (nuxt.options.dev && !nuxt.options._prepare && !notifiedMissing) {
+          notifiedMissing = true;
+          logger.info(`Convex codegen not found in \`${functionsDir}/_generated\` \u2014 run \`npx convex dev\`. Convex features no-op until it exists.`);
+        }
+        return "import { defineNuxtPlugin } from '#app'\nexport default defineNuxtPlugin(() => {})\n";
+      }
+      if (notifiedMissing) {
+        notifiedMissing = false;
+        logger.success("Convex codegen detected \u2014 generated `api` wired app-wide.");
+      }
+      return [
+        "import { defineNuxtPlugin } from '#app'",
+        "import { api } from '#convex/api'",
+        `import { provideConvexApi } from ${JSON.stringify(provideModule)}`,
+        "export default defineNuxtPlugin((nuxtApp) => {",
+        "  provideConvexApi(api, nuxtApp.vueApp)",
+        "})",
+        ""
+      ].join("\n");
+    }
+  });
+}
+function registerConvexTypeFallback(nuxt) {
+  const functionsDir = resolveFunctionsDir(nuxt.options.rootDir);
+  addTypeTemplate({
+    filename: "types/nuxt-convex-module-api-fallback.d.ts",
+    getContents: () => convexTypeFallbackContents(hasGeneratedApi(nuxt.options.rootDir, functionsDir), functionsDir)
+  }, { nuxt: true, nitro: true });
+}
+function registerVueComposables(resolver) {
+  registerIntegrationImports(resolver, "core");
+}
+function registerAuthComponents(resolver) {
+  registerComponents(resolver, "core");
+}
+function registerIntegrationImports(resolver, integration) {
+  const resolve = (entry) => ({ ...entry, from: resolver.resolve(`./${entry.from}`) });
+  if (APP_IMPORTS[integration].length > 0) addImports(APP_IMPORTS[integration].map(resolve));
+  if (SERVER_IMPORTS[integration].length > 0) addServerImports(SERVER_IMPORTS[integration].map(resolve));
+}
+function registerComponents(resolver, integration) {
+  for (const { name, from } of APP_COMPONENTS[integration]) {
+    addComponent({ name, filePath: resolver.resolve(`./${from}`), export: name });
+  }
+}
+const AUTH_PROXY_SECURITY_RULES = {
+  xssValidator: false,
+  allowedMethodsRestricter: { methods: ["GET", "HEAD", "POST", "OPTIONS"] }
+};
+function registerBetterAuth(resolver, authRoute) {
+  addPlugin(resolver.resolve("./runtime/better-auth/vue/plugin.client"));
+  addPlugin(resolver.resolve("./runtime/better-auth/vue/plugin.server"));
+  registerIntegrationImports(resolver, "betterAuth");
+  registerComponents(resolver, "betterAuth");
+  addServerHandler({
+    route: `${authRoute}/**`,
+    handler: resolver.resolve("./runtime/better-auth/nuxt/proxy")
+  });
+  extendRouteRules(`${authRoute}/**`, {
+    cache: false,
+    prerender: false,
+    security: AUTH_PROXY_SECURITY_RULES
+  });
+  addRouteMiddleware({
+    name: "auth",
+    path: resolver.resolve("./runtime/better-auth/nuxt/middleware"),
+    global: false
+  });
+}
+function registerBaseConvexClient(resolver) {
+  addPlugin(resolver.resolve("./runtime/vue/plugin"));
+}
+function registerClerk(resolver) {
+  registerIntegrationImports(resolver, "clerk");
+  registerComponents(resolver, "clerk");
+}
+function registerAuth0(resolver) {
+  registerIntegrationImports(resolver, "auth0");
+  registerComponents(resolver, "auth0");
+}
+function registerPolarComponents(resolver) {
+  registerComponents(resolver, "polar");
+}
+
+export { module$1 as default };

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

@@ -4,12 +4,12 @@ import { type ConvexAuthState, type IConvexVueClient } from '../../vue/auth/inde
  * Options for {@link provideConvexAuthFromAuth0} / `<ConvexProviderWithAuth0>`.
  */
 export interface ConvexProviderWithAuth0Options {
-    /** Convex client to authenticate. Defaults to the provided {@link useConvex} client. */
+    /** Convex client to authenticate. Defaults to the client `useConvex()` returns. */
     client?: IConvexVueClient;
 }
 /**
  * The composable form of {@link ConvexProviderWithAuth0} — provides a
- * {@link ConvexVueClient} authenticated with Auth0.
+ * {@link client!ConvexVueClient | ConvexVueClient} authenticated with Auth0.
  *
  * It must be called in an app wrapped by a configured Auth0 plugin from
  * `@auth0/auth0-vue`.
@@ -29,7 +29,7 @@ export interface ConvexProviderWithAuth0Options {
  */
 export declare function provideConvexAuthFromAuth0(options?: ConvexProviderWithAuth0Options): ConvexAuthState;
 /**
- * A wrapper Vue component which provides a {@link ConvexVueClient}
+ * A wrapper Vue component which provides a {@link client!ConvexVueClient | ConvexVueClient}
  * authenticated with Auth0 — the component form of
  * {@link provideConvexAuthFromAuth0}. Renders its default slot once Convex
  * auth is wired.

package/dist/runtime/better-auth/nuxt/middleware.d.ts

@@ -1,6 +1,10 @@
 /**
  * Auth route middleware — protects pages from unauthenticated access.
  *
+ * Unauthenticated visitors are sent to the configured login route
+ * (`convex.betterAuth.loginPath`, default `/login`) with the original
+ * destination in a `?redirect=` query.
+ *
  * Usage in page:
  * ```vue
  * <script setup>
@@ -8,7 +12,5 @@
  * </script>
  * ```
  */
-/** Exported for unit tests — `import.meta.server` is compile-time. @internal */
-export declare function serverGuard(path: string): Promise<string | false | void | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric | import("vue-router").NavigationFailure>;
 declare const _default: import("nuxt/app").RouteMiddleware;
 export default _default;

package/dist/runtime/better-auth/nuxt/middleware.js

@@ -1,14 +1,16 @@
-import { defineNuxtRouteMiddleware, navigateTo, useNuxtApp, useRequestEvent } from "#app";
+import { defineNuxtRouteMiddleware, navigateTo, useNuxtApp, useRequestEvent, useRuntimeConfig } from "#app";
 import { watch } from "vue";
-import { useAuth } from "../vue/use-auth.js";
+import { useBetterAuth } from "../vue/use-better-auth.js";
 import { convexAuth } from "./server.js";
-export async function serverGuard(path) {
-  const event = useRequestEvent();
-  if (!event) return;
+function loginTarget(to, loginPath) {
+  return { path: loginPath, query: { redirect: to.fullPath } };
+}
+export async function serverGuard(to, loginPath) {
   const nuxtApp = useNuxtApp();
-  const authed = await convexAuth(event).isAuthenticated();
-  if (!authed && path !== "/login") {
-    return nuxtApp.runWithContext(() => navigateTo("/login"));
+  const event = useRequestEvent();
+  const authed = event ? await convexAuth(event).isAuthenticated() : false;
+  if (!authed && to.path !== loginPath) {
+    return nuxtApp.runWithContext(() => navigateTo(loginTarget(to, loginPath)));
   }
 }
 function waitForSession(isPending) {
@@ -26,14 +28,15 @@ function waitForSession(isPending) {
   });
 }
 export default defineNuxtRouteMiddleware(async (to) => {
+  const loginPath = useRuntimeConfig().public.convex.loginPath || "/login";
   if (import.meta.server) {
-    return serverGuard(to.path);
+    return serverGuard(to, loginPath);
   }
-  const { session } = useAuth();
+  const { session } = useBetterAuth();
   if (session.value.isPending) {
     await waitForSession(() => session.value.isPending);
   }
-  if (!session.value.data && to.path !== "/login") {
-    return navigateTo("/login");
+  if (!session.value.data && to.path !== loginPath) {
+    return navigateTo(loginTarget(to, loginPath));
   }
 });