nuxt-convex-module 0.0.0

package/dist/module.d.ts

@@ -0,0 +1,189 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+/**
+ * Configuration for the opt-in Better Auth integration.
+ *
+ * @public
+ */
+interface BetterAuthModuleOptions {
+    /**
+     * Path (relative to the Nuxt `rootDir`, or absolute) to a module that exports
+     * your configured Better Auth client as `authClient` — and, ideally, its type
+     * as `AuthClient`. Mirrors `convex/react`'s "you own the `authClient`" model:
+     * include whatever client plugins you need, e.g. `emailOTPClient()`,
+     * `passkeyClient()`, or `crossDomainClient()` from
+     * `@convex-dev/better-auth/client/plugins` for cross-domain auth. Defaults to
+     * a minimal bundled client carrying only `convexClient()` — the one plugin
+     * the integration itself requires.
+     *
+     * @example './app/convex-auth-client'
+     */
+    authClient?: string;
+    /**
+     * Restrict cross-domain one-time-token (`?ott=`) sign-in completion to one
+     * app route, e.g. `'/auth/callback'`. Only meaningful when your auth client
+     * installs `crossDomainClient()`. Upstream consumes the token on whatever
+     * page it lands on, and the protocol cannot bind it to the browser that
+     * started the flow — so a crafted `?ott=` link to any route silently signs
+     * the visitor into the link author's session (login CSRF). With this set,
+     * tokens are exchanged only on the given route and scrubbed everywhere
+     * else; point every sign-in `callbackURL` at it. Off by default, mirroring
+     * upstream `ConvexBetterAuthProvider`.
+     */
+    crossDomainCallbackRoute?: string;
+}
+interface ModuleOptions {
+    /** Convex deployment URL (defaults to `NUXT_PUBLIC_CONVEX_URL`). */
+    url?: string;
+    /** Convex `.site` URL (defaults to `NUXT_PUBLIC_CONVEX_SITE_URL`). */
+    siteUrl?: string;
+    /**
+     * Better Auth integration. Auto-enabled when `@convex-dev/better-auth` is
+     * installed; set `false` to force it off, `true` to require it, or a
+     * {@link BetterAuthModuleOptions} object to point at a custom auth client.
+     */
+    betterAuth?: boolean | BetterAuthModuleOptions;
+    /**
+     * Polar billing components. Auto-enabled when `@convex-dev/polar` is
+     * installed; set `false` to force it off (or `true` to require it).
+     */
+    polar?: boolean;
+    /**
+     * Clerk auth adapter (`provideConvexAuthFromClerk` / `<ConvexProviderWithClerk>`).
+     * Auto-enabled when `@clerk/vue` is installed; set `false` to force it off.
+     */
+    clerk?: boolean;
+    /**
+     * Auth0 auth adapter (`provideConvexAuthFromAuth0` / `<ConvexProviderWithAuth0>`).
+     * Auto-enabled when `@auth0/auth0-vue` is installed; set `false` to force it off.
+     */
+    auth0?: boolean;
+    /** Route the Better Auth same-origin proxy is mounted at. Defaults to `/api/auth`. */
+    authRoute?: string;
+    /**
+     * Convex panel in Nuxt DevTools (dev only): connection state, live query
+     * subscriptions, auth state, and client logs. Enabled by default whenever
+     * Nuxt DevTools is; set `false` to disable just the Convex tab.
+     */
+    devtools?: boolean;
+}
+declare module '@nuxt/schema' {
+    interface RuntimeConfig {
+        convex: {
+            siteUrl: string;
+        };
+    }
+    interface PublicRuntimeConfig {
+        convex: {
+            url: string;
+            siteUrl: string;
+            crossDomainCallbackRoute: string;
+        };
+    }
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+/**
+ * Which opt-in integrations ended up enabled — returned by
+ * {@link registerIntegrations} for the dev startup summary (and the DevTools
+ * panel, which reports the active adapter).
+ */
+interface IntegrationFlags {
+    betterAuth: boolean;
+    clerk: boolean;
+    auth0: boolean;
+    polar: boolean;
+}
+/**
+ * Decide whether an opt-in integration is enabled, distinguishing the
+ * misconfiguration case: explicitly enabled but the backing package is not
+ * installed (`missingPackage`), where silently registering the runtime would
+ * surface as an opaque Vite import error instead of an actionable message.
+ * Auto-detection (option unset) treats package absence as the normal case.
+ */
+declare function resolveIntegrationState(explicit: boolean | object | undefined, installed: boolean): {
+    enabled: boolean;
+    missingPackage: boolean;
+};
+/** Result of {@link validateModuleOptions}: findings plus normalized values. */
+interface ModuleOptionDiagnostics {
+    errors: string[];
+    warnings: string[];
+    /** `authRoute` with a leading slash ensured and any trailing slash stripped. */
+    authRoute: string;
+}
+/**
+ * Validate the resolved module configuration, turning silent misconfiguration
+ * (swapped `.convex.cloud`/`.convex.site` URLs, malformed URLs, an `authRoute`
+ * that would produce a broken server-handler route, a `betterAuth.authClient`
+ * path that doesn't exist) into actionable messages. Pure — the caller logs
+ * the findings and applies the normalized `authRoute`. Exported for tests.
+ */
+declare function validateModuleOptions(input: {
+    url: string;
+    siteUrl: string;
+    authRoute: string;
+    authClient?: string;
+    rootDir: string;
+}): ModuleOptionDiagnostics;
+/**
+ * The dev-mode one-line startup summary: resolved deployment URL, functions
+ * directory, and which opt-in integrations are active.
+ */
+declare function formatStartupSummary(url: string, functionsDir: string, integrations: IntegrationFlags): string;
+/**
+ * Build the ordered import-alias map for the Convex functions folder and its
+ * generated modules, so user code and server routes can `import from
+ * '#convex/...'` without spelling out `_generated`.
+ *
+ * - `#convex/api`        -> _generated/api        (`api`, `internal`, `components`)
+ * - `#convex/server`     -> _generated/server     (`query`, `mutation`, `action`, `*Ctx`, ...)
+ * - `#convex/dataModel`  -> _generated/dataModel  (`DataModel`, `Doc`, `Id`, `TableNames`)
+ * - `#convex/_generated` -> _generated            (long form, covers every generated file)
+ * - `#convex`            -> <rootDir>/<functionsDir>
+ *
+ * Order is significant: both Vite and Nitro resolve aliases with
+ * `@rollup/plugin-alias`, which is first-match-wins and treats `#convex` as a
+ * prefix of `#convex/api`. The specific generated-module aliases must come
+ * before the catch-all `#convex`, otherwise `#convex/api` would resolve to
+ * `<functionsDir>/api` instead of `<functionsDir>/_generated/api` (and would
+ * shadow any user function file literally named `api.ts` / `server.ts`).
+ */
+declare function getConvexAliases(rootDir: string): Record<string, string>;
+/**
+ * Contents of the fallback type template: placeholder (`any`-typed) ambient
+ * declarations for the generated `#convex/*` modules while `convex dev`
+ * hasn't emitted codegen yet, so a fresh project typechecks instead of failing
+ * on every `#convex/api` import. Once codegen exists the template goes empty
+ * and the real generated types win via the tsconfig `paths` the aliases
+ * already produce.
+ */
+declare function convexTypeFallbackContents(hasApi: boolean, functionsDir: string): string;
+/**
+ * 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.
+ */
+declare function convexConnectSrc(url?: string, siteUrl?: string): string[];
+/**
+ * CSP source for Convex-served resources (`img-src` / `media-src`): files
+ * uploaded through `useStorageUrl()` are served from the deployment origin.
+ */
+declare function convexResourceSrc(url?: string): string[];
+/**
+ * Apply nuxt-convex-module's secure-by-default, Convex-aware CSP onto a security config
+ * object (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.
+ */
+declare function applyConvexSecurityDefaults(security: Record<string, unknown>, connectSrc: string[], resourceSrc: string[]): void;
+
+export { applyConvexSecurityDefaults, convexConnectSrc, convexResourceSrc, convexTypeFallbackContents, _default as default, formatStartupSummary, getConvexAliases, resolveIntegrationState, validateModuleOptions };
+export type { BetterAuthModuleOptions, IntegrationFlags, ModuleOptionDiagnostics, ModuleOptions };

package/dist/module.js

@@ -0,0 +1,489 @@
+import { useLogger, defineNuxtModule, createResolver, addPlugin, addPluginTemplate, addTypeTemplate, updateTemplates, addImports, addComponent, addServerImports, addServerHandler, extendRouteRules, addRouteMiddleware } from '@nuxt/kit';
+import { join, isAbsolute } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+
+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 = functionsDir.replace(/^\.?\//, "").replace(/\/+$/, "");
+  return normalized || void 0;
+}
+
+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. Point at the
+    // deployed docs site once it ships.
+    docs: "https://github.com/qruto/nuxt-convex-module#readme",
+    // `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
+  },
+  // nuxt-security is an integral part of the integration: declaring it as a
+  // module dependency makes Nuxt's core loader install it (hoisting its types
+  // and deduping if you also register it yourself), and guarantees our setup
+  // runs *before* it — so the Convex-aware CSP defaults below land before
+  // nuxt-security reads its config. Configure it via the `security` key.
+  moduleDependencies: {
+    "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",
+      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;
+    registerAuthClientAlias(resolver, nuxt, options);
+    registerConvexAliases(nuxt);
+    registerConvexApiPlugin(resolver, nuxt);
+    registerConvexTypeFallback(nuxt);
+    registerVueComposables(resolver);
+    registerAuthComponents(resolver);
+    registerServerImports(resolver);
+    const integrations = registerIntegrations(resolver, nuxt, options);
+    applyConvexCsp(nuxt, url, siteUrl);
+    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));
+    }
+  }
+});
+function isDevtoolsUiEnabled(nuxt) {
+  const devtools = nuxt.options.devtools;
+  return typeof devtools === "boolean" ? devtools : devtools?.enabled !== false;
+}
+function resolveIntegrationState(explicit, installed) {
+  if (explicit === false) return { enabled: false, missingPackage: false };
+  if (explicit === void 0) return { enabled: installed, missingPackage: false };
+  return installed ? { enabled: true, missingPackage: false } : { enabled: false, missingPackage: true };
+}
+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")) {
+    warnings.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.`
+    );
+  }
+  let authRoute = input.authRoute;
+  if (!authRoute.startsWith("/")) {
+    authRoute = `/${authRoute}`;
+    warnings.push(
+      `\`convex.authRoute\` ("${input.authRoute}") must start with "/" \u2014 using "${authRoute}".`
+    );
+  }
+  if (authRoute.length > 1 && authRoute.endsWith("/")) {
+    authRoute = authRoute.replace(/\/+$/, "");
+  }
+  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 };
+}
+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) => existsSync(`${base}${suffix}`)
+  );
+}
+function formatStartupSummary(url, functionsDir, integrations) {
+  const names = {
+    betterAuth: "better-auth",
+    clerk: "clerk",
+    auth0: "auth0",
+    polar: "polar"
+  };
+  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 registerIntegrations(resolver, nuxt, options) {
+  const resolve = (key, pkg) => {
+    const state = resolveIntegrationState(options[key], isPackageInstalled(pkg, nuxt.options.rootDir));
+    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 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);
+  }
+  return { betterAuth, clerk, auth0, polar };
+}
+function applyConvexCsp(nuxt, url, siteUrl) {
+  const opts = nuxt.options;
+  if (!url || opts.security === false) return;
+  const security = opts.security ??= {};
+  applyConvexSecurityDefaults(
+    security,
+    nuxt.options.dev ? [] : convexConnectSrc(url, siteUrl),
+    convexResourceSrc(url)
+  );
+}
+function isPackageInstalled(id, rootDir) {
+  for (const base of [join(rootDir, "package.json"), import.meta.url]) {
+    const require = createRequire(base);
+    for (const target of [id, `${id}/package.json`]) {
+      try {
+        require.resolve(target);
+        return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function applyRuntimeConfig(nuxt, options) {
+  const url = nuxt.options._prepare ? void 0 : options.url || process.env.NUXT_PUBLIC_CONVEX_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 load."
+    );
+  }
+  const siteUrl = options.siteUrl || process.env.NUXT_PUBLIC_CONVEX_SITE_URL || "";
+  const crossDomainCallbackRoute = typeof options.betterAuth === "object" && options.betterAuth.crossDomainCallbackRoute || "";
+  const runtimeConfig = nuxt.options.runtimeConfig;
+  runtimeConfig.public.convex = {
+    ...runtimeConfig.public.convex,
+    url: url || "",
+    siteUrl,
+    crossDomainCallbackRoute
+  };
+  runtimeConfig.convex = { ...runtimeConfig.convex, siteUrl };
+  return { url: url || "", siteUrl };
+}
+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
+  };
+}
+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 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");
+}
+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 });
+}
+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;
+  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) });
+  });
+}
+function registerVueComposables(resolver) {
+  const composables = [
+    { name: "useConvex", from: resolver.resolve("./runtime/vue/client") },
+    { name: "useQuery", from: resolver.resolve("./runtime/vue/composables/use-query") },
+    { name: "useQuery_experimental", from: resolver.resolve("./runtime/vue/composables/use-query") },
+    { name: "useConvexQuery", from: resolver.resolve("./runtime/vue/composables/use-query") },
+    { name: "useQueries", from: resolver.resolve("./runtime/vue/composables/use-queries") },
+    { name: "useConvexQueries", from: resolver.resolve("./runtime/vue/composables/use-queries") },
+    { name: "useMutation", from: resolver.resolve("./runtime/vue/composables/use-mutation") },
+    { name: "useConvexMutation", from: resolver.resolve("./runtime/vue/composables/use-mutation") },
+    { name: "useAction", from: resolver.resolve("./runtime/vue/composables/use-action") },
+    { name: "useConvexAction", from: resolver.resolve("./runtime/vue/composables/use-action") },
+    { name: "useConvexConnectionState", from: resolver.resolve("./runtime/vue/composables/use-connection-state") },
+    { name: "useUpload", from: resolver.resolve("./runtime/vue/composables/use-upload") },
+    { name: "useConvexUpload", from: resolver.resolve("./runtime/vue/composables/use-upload") },
+    { name: "uploadFile", from: resolver.resolve("./runtime/vue/composables/use-upload") },
+    { name: "useUploadQueue", from: resolver.resolve("./runtime/vue/composables/use-upload-queue") },
+    { name: "useConvexUploadQueue", from: resolver.resolve("./runtime/vue/composables/use-upload-queue") },
+    { name: "useStorageUrl", from: resolver.resolve("./runtime/vue/composables/use-storage-url") },
+    { name: "useConvexStorageUrl", from: resolver.resolve("./runtime/vue/composables/use-storage-url") },
+    { name: "useConvexAuth", from: resolver.resolve("./runtime/vue/auth/index") },
+    { name: "provideConvexAuth", from: resolver.resolve("./runtime/vue/auth/index") },
+    { name: "provideConvexApi", from: resolver.resolve("./runtime/vue/provide") },
+    { name: "useConvexApi", from: resolver.resolve("./runtime/vue/provide") },
+    { name: "useConvexNamespace", from: resolver.resolve("./runtime/vue/provide") },
+    { name: "usePreloadedQuery", from: resolver.resolve("./runtime/vue/hydration") },
+    // Nuxt-only (imports `#app`), hence under runtime/nuxt/ — see PARITY.md.
+    { name: "useAsyncQuery", from: resolver.resolve("./runtime/nuxt/composables/use-async-query") },
+    { name: "useConvexAsyncQuery", from: resolver.resolve("./runtime/nuxt/composables/use-async-query") },
+    { name: "usePaginatedQuery", from: resolver.resolve("./runtime/vue/composables/use-paginated-query") },
+    { name: "useConvexPaginatedQuery", from: resolver.resolve("./runtime/vue/composables/use-paginated-query") },
+    { name: "usePaginatedQuery_experimental", from: resolver.resolve("./runtime/vue/composables/use-paginated-query") }
+  ];
+  addImports(composables);
+}
+function registerAuthComponents(resolver) {
+  const helpersFile = resolver.resolve("./runtime/vue/auth/helpers");
+  for (const name of ["Authenticated", "Unauthenticated", "AuthLoading", "AuthRefreshing"]) {
+    addComponent({ name, filePath: helpersFile, export: name });
+  }
+}
+function registerServerImports(resolver) {
+  const fromNuxt = resolver.resolve("./runtime/nuxt/index");
+  const serverUtils = ["fetchQuery", "fetchMutation", "fetchAction", "preloadQuery", "preloadedQueryResult"];
+  addServerImports(serverUtils.map((name) => ({ name, from: fromNuxt })));
+}
+function registerBetterAuth(resolver, authRoute) {
+  addPlugin(resolver.resolve("./runtime/better-auth/vue/plugin.client"));
+  addPlugin(resolver.resolve("./runtime/better-auth/vue/plugin.server"));
+  addImports([
+    { name: "useAuth", from: resolver.resolve("./runtime/better-auth/vue/use-auth") },
+    { name: "usePreloadedAuthQuery", from: resolver.resolve("./runtime/better-auth/vue/hydration") }
+  ]);
+  addComponent({
+    name: "AuthBoundary",
+    filePath: resolver.resolve("./runtime/better-auth/vue/auth-boundary"),
+    export: "AuthBoundary"
+  });
+  addServerHandler({
+    route: `${authRoute}/**`,
+    handler: resolver.resolve("./runtime/better-auth/nuxt/proxy")
+  });
+  extendRouteRules(`${authRoute}/**`, { cache: false, prerender: false });
+  addRouteMiddleware({
+    name: "auth",
+    path: resolver.resolve("./runtime/better-auth/nuxt/middleware"),
+    global: false
+  });
+  addServerImports([
+    { name: "convexAuth", from: resolver.resolve("./runtime/better-auth/nuxt/server") },
+    { name: "convexBetterAuthNuxt", from: resolver.resolve("./runtime/better-auth/nuxt/server") }
+  ]);
+}
+function registerBaseConvexClient(resolver) {
+  addPlugin(resolver.resolve("./runtime/vue/plugin"));
+}
+function registerClerk(resolver) {
+  const from = resolver.resolve("./runtime/clerk/vue/index");
+  addImports({ name: "provideConvexAuthFromClerk", from });
+  addComponent({ name: "ConvexProviderWithClerk", filePath: from, export: "ConvexProviderWithClerk" });
+}
+function registerAuth0(resolver) {
+  const from = resolver.resolve("./runtime/auth0/vue/index");
+  addImports({ name: "provideConvexAuthFromAuth0", from });
+  addComponent({ name: "ConvexProviderWithAuth0", filePath: from, export: "ConvexProviderWithAuth0" });
+}
+function registerPolarComponents(resolver) {
+  const componentsFile = resolver.resolve("./runtime/polar/vue/components");
+  for (const name of ["CheckoutLink", "CustomerPortalLink"]) {
+    addComponent({ name, filePath: componentsFile, export: name });
+  }
+}
+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))));
+}
+function convexConnectSrc(url, siteUrl) {
+  return uniq([toHttpOrigin(url), toWsOrigin(url), toHttpOrigin(siteUrl), toWsOrigin(siteUrl)]);
+}
+function convexResourceSrc(url) {
+  return uniq([toHttpOrigin(url)]);
+}
+function applyConvexSecurityDefaults(security, connectSrc, resourceSrc) {
+  if (security.headers === false) return;
+  if (typeof security.headers !== "object" || security.headers === null) security.headers = {};
+  const headers = security.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 existing = Array.isArray(csp[name]) ? csp[name] : baseline;
+  csp[name] = uniq([...existing, ...additions]);
+}
+
+export { applyConvexSecurityDefaults, convexConnectSrc, convexResourceSrc, convexTypeFallbackContents, module$1 as default, formatStartupSummary, getConvexAliases, resolveIntegrationState, validateModuleOptions };