nuxt-convex-module 0.0.0 → 0.9.0

package/dist/module.js

@@ -1,489 +0,0 @@
-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 };

package/dist/types.d.ts

@@ -1,3 +0,0 @@
-export { type applyConvexSecurityDefaults, type convexConnectSrc, type convexResourceSrc, type convexTypeFallbackContents, default, type formatStartupSummary, type getConvexAliases, type resolveIntegrationState, type validateModuleOptions } from './module.js'
-
-export { type BetterAuthModuleOptions, type IntegrationFlags, type ModuleOptionDiagnostics, type ModuleOptions } from './module.js'