nuxt-convex-module 0.0.1 → 0.9.0

package/dist/module.mjs

@@ -1,8 +1,128 @@
-import { useLogger, defineNuxtModule, createResolver, addPlugin, hasNuxtModule, addServerPlugin, addPluginTemplate, addTypeTemplate, updateTemplates, addImports, addComponent, addServerImports, addServerHandler, extendRouteRules, addRouteMiddleware } from '@nuxt/kit';
+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 } from 'node:fs';
+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) {
@@ -27,18 +147,183 @@ function readFunctionsDirFromConvexJson(convexJsonPath) {
   }
 }
 function normalizeFunctionsDir(functionsDir) {
-  const normalized = functionsDir.replace(/^\.?\//, "").replace(/\/+$/, "");
+  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. Point at the
-    // deployed docs site once it ships.
-    docs: "https://github.com/qruto/nuxt-convex-module#readme",
+    // 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: {
@@ -47,7 +332,8 @@ const module$1 = defineNuxtModule({
   },
   defaults: {
     authRoute: "/api/auth",
-    devtools: true
+    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
@@ -64,19 +350,20 @@ const module$1 = defineNuxtModule({
       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);
-    registerServerImports(resolver);
     const integrations = registerIntegrations(resolver, nuxt, options);
     watchConvexCodegen(nuxt);
     if (nuxt.options.dev && options.devtools !== false && isDevtoolsUiEnabled(nuxt)) {
@@ -93,88 +380,18 @@ const module$1 = defineNuxtModule({
     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 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 stripTrailingSlashes(value) {
-  let end = value.length;
-  while (end > 0 && value[end - 1] === "/") end--;
-  return value.slice(0, end);
-}
-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 = stripTrailingSlashes(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 };
-}
-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",
-    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 registerIntegrations(resolver, nuxt, options) {
   const report = (key, pkg, state) => {
     if (state.missingPackage) {
@@ -182,7 +399,8 @@ function registerIntegrations(resolver, nuxt, options) {
     }
     return state.enabled;
   };
-  const resolve = (key, pkg) => report(key, pkg, resolveIntegrationState(options[key], isPackageInstalled(pkg, nuxt.options.rootDir)));
+  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");
@@ -205,7 +423,9 @@ function registerIntegrations(resolver, nuxt, options) {
   if (security) {
     registerSecurity(resolver);
   }
-  return { betterAuth, clerk, auth0, polar, security };
+  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;
@@ -214,25 +434,14 @@ function readSecurityOption(nuxt) {
 function resolveSecurityState(nuxt, explicit) {
   const opts = nuxt.options;
   if (opts.security === false) return { enabled: false, missingPackage: false };
-  const installed = hasNuxtModule("nuxt-security", nuxt) || isPackageInstalled("nuxt-security", nuxt.options.rootDir);
-  return resolveIntegrationState(explicit, installed);
+  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 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: options.url || env.NUXT_PUBLIC_CONVEX_URL || env.CONVEX_URL || "",
-    siteUrl: options.siteUrl || env.NUXT_PUBLIC_CONVEX_SITE_URL || env.CONVEX_SITE_URL || ""
-  };
-}
 function applyRuntimeConfig(nuxt, options) {
   const resolved = resolveDeploymentUrls(options, process.env);
   const url = nuxt.options._prepare ? "" : resolved.url;
@@ -255,18 +464,6 @@ function applyRuntimeConfig(nuxt, options) {
   runtimeConfig.convex = { ...runtimeConfig.convex, siteUrl };
   return { 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 ||= {};
@@ -314,40 +511,6 @@ function registerConvexApiPlugin(resolver, nuxt) {
     }
   });
 }
-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({
@@ -355,59 +518,21 @@ function registerConvexTypeFallback(nuxt) {
     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);
+  registerIntegrationImports(resolver, "core");
 }
 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 });
-  }
+  registerComponents(resolver, "core");
 }
-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 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,
@@ -416,16 +541,8 @@ const AUTH_PROXY_SECURITY_RULES = {
 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") },
-    { name: "resolveAuthRedirect", from: resolver.resolve("./runtime/better-auth/vue/redirect") }
-  ]);
-  addComponent({
-    name: "AuthBoundary",
-    filePath: resolver.resolve("./runtime/better-auth/vue/auth-boundary"),
-    export: "AuthBoundary"
-  });
+  registerIntegrationImports(resolver, "betterAuth");
+  registerComponents(resolver, "betterAuth");
   addServerHandler({
     route: `${authRoute}/**`,
     handler: resolver.resolve("./runtime/better-auth/nuxt/proxy")
@@ -440,29 +557,20 @@ function registerBetterAuth(resolver, authRoute) {
     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" });
+  registerIntegrationImports(resolver, "clerk");
+  registerComponents(resolver, "clerk");
 }
 function registerAuth0(resolver) {
-  const from = resolver.resolve("./runtime/auth0/vue/index");
-  addImports({ name: "provideConvexAuthFromAuth0", from });
-  addComponent({ name: "ConvexProviderWithAuth0", filePath: from, export: "ConvexProviderWithAuth0" });
+  registerIntegrationImports(resolver, "auth0");
+  registerComponents(resolver, "auth0");
 }
 function registerPolarComponents(resolver) {
-  const componentsFile = resolver.resolve("./runtime/polar/vue/components");
-  for (const name of ["CheckoutLink", "CustomerPortalLink"]) {
-    addComponent({ name, filePath: componentsFile, export: name });
-  }
+  registerComponents(resolver, "polar");
 }
 
-export { convexTypeFallbackContents, module$1 as default, formatStartupSummary, getConvexAliases, resolveDeploymentUrls, resolveIntegrationState, validateModuleOptions };
+export { module$1 as default };