@farm.js/convex 0.0.0-stage → 0.1.0-beta.0

package/dist/functions.d.ts

@@ -0,0 +1,42 @@
+import type { ComponentApi } from "./component/_generated/component.js";
+export declare function requireAdapterSecret(secret: string): void;
+export declare function defineFarmFunctions(component: ComponentApi): {
+    setStorageItem: import("convex/server").RegisteredMutation<"public", {
+        key: string;
+        secret: string;
+        value: string;
+    }, Promise<null>>;
+    removeStorageItem: import("convex/server").RegisteredMutation<"public", {
+        key: string;
+        secret: string;
+    }, Promise<null>>;
+    clearStorageItems: import("convex/server").RegisteredMutation<"public", {
+        secret: string;
+        prefix: string;
+    }, Promise<number>>;
+    getStorageItem: import("convex/server").RegisteredQuery<"public", {
+        key: string;
+        secret: string;
+    }, Promise<string | null>>;
+    listStorageKeys: import("convex/server").RegisteredQuery<"public", {
+        secret: string;
+        prefix: string;
+    }, Promise<string[]>>;
+    incrementRateLimit: import("convex/server").RegisteredMutation<"public", {
+        key: string;
+        secret: string;
+        windowMs: number;
+    }, Promise<{
+        count: number;
+        resetAt: number;
+    }>>;
+    readRateLimit: import("convex/server").RegisteredQuery<"public", {
+        key: string;
+        secret: string;
+        now: number;
+    }, Promise<{
+        count: number;
+        resetAt: number;
+    } | null>>;
+};
+//# sourceMappingURL=functions.d.ts.map

package/dist/functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../src/functions.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAaxE,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAQzD;AAkED,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM1D"}

package/dist/functions.js

@@ -0,0 +1,90 @@
+import { mutationGeneric, queryGeneric } from "convex/server";
+import { v } from "convex/values";
+import { SECRET_ENVIRONMENT_NAME } from "./secret.js";
+function areStringsEqual(left, right) {
+    const encoder = new TextEncoder();
+    const leftBytes = encoder.encode(left);
+    const rightBytes = encoder.encode(right);
+    let difference = leftBytes.length ^ rightBytes.length;
+    for (let index = 0; index < leftBytes.length; index += 1) {
+        difference |= leftBytes[index] ^ (rightBytes[index % rightBytes.length] ?? 0);
+    }
+    return difference === 0;
+}
+export function requireAdapterSecret(secret) {
+    const expected = process.env[SECRET_ENVIRONMENT_NAME];
+    if (!expected) {
+        throw new Error(`${SECRET_ENVIRONMENT_NAME} is not set on this Convex deployment.`);
+    }
+    if (!areStringsEqual(secret, expected)) {
+        throw new Error(`The ${SECRET_ENVIRONMENT_NAME} sent by Farm does not match this deployment.`);
+    }
+}
+function defineRateLimitFunctions(component) {
+    return {
+        incrementRateLimit: mutationGeneric({
+            args: { secret: v.string(), key: v.string(), windowMs: v.number() },
+            handler: (context, { secret, ...args }) => {
+                requireAdapterSecret(secret);
+                return context.runMutation(component.rateLimits.increment, args);
+            },
+        }),
+        readRateLimit: queryGeneric({
+            args: { secret: v.string(), key: v.string(), now: v.number() },
+            handler: (context, { secret, ...args }) => {
+                requireAdapterSecret(secret);
+                return context.runQuery(component.rateLimits.read, args);
+            },
+        }),
+    };
+}
+function defineStorageReadFunctions(component) {
+    return {
+        getStorageItem: queryGeneric({
+            args: { secret: v.string(), key: v.string() },
+            handler: (context, { secret, ...args }) => {
+                requireAdapterSecret(secret);
+                return context.runQuery(component.storage.getItem, args);
+            },
+        }),
+        listStorageKeys: queryGeneric({
+            args: { secret: v.string(), prefix: v.string() },
+            handler: (context, { secret, ...args }) => {
+                requireAdapterSecret(secret);
+                return context.runQuery(component.storage.listKeys, args);
+            },
+        }),
+    };
+}
+function defineStorageWriteFunctions(component) {
+    return {
+        setStorageItem: mutationGeneric({
+            args: { secret: v.string(), key: v.string(), value: v.string() },
+            handler: (context, { secret, ...args }) => {
+                requireAdapterSecret(secret);
+                return context.runMutation(component.storage.setItem, args);
+            },
+        }),
+        removeStorageItem: mutationGeneric({
+            args: { secret: v.string(), key: v.string() },
+            handler: (context, { secret, ...args }) => {
+                requireAdapterSecret(secret);
+                return context.runMutation(component.storage.removeItem, args);
+            },
+        }),
+        clearStorageItems: mutationGeneric({
+            args: { secret: v.string(), prefix: v.string() },
+            handler: (context, { secret, ...args }) => {
+                requireAdapterSecret(secret);
+                return context.runMutation(component.storage.clearItems, args);
+            },
+        }),
+    };
+}
+export function defineFarmFunctions(component) {
+    return {
+        ...defineRateLimitFunctions(component),
+        ...defineStorageReadFunctions(component),
+        ...defineStorageWriteFunctions(component),
+    };
+}

package/dist/homes.d.ts

@@ -0,0 +1,11 @@
+import type { ConvexExtension, ConvexFarmConfigView, ConvexHomeConflict } from "./types.js";
+import type { ConvexHomes, ConvexServiceSetup } from "./types.js";
+export declare function readConvexConfigSource(root: string, functionsDirectory: string): string | undefined;
+export declare function findComponentPackages(source: string): string[];
+export declare function findConvexComponents(source: string): ConvexServiceSetup[];
+export declare function findExtensionServices(extensions: readonly ConvexExtension[]): ConvexServiceSetup[];
+export declare function findFarmIntegrations(config: ConvexFarmConfigView): ConvexServiceSetup[];
+export declare function findHomeConflicts(components: readonly ConvexServiceSetup[], integrations: readonly ConvexServiceSetup[], homes: ConvexHomes): ConvexHomeConflict[];
+export declare function describeHomeConflict(conflict: ConvexHomeConflict): string;
+export declare function checkServiceHomes(config: ConvexFarmConfigView, functionsDirectory: string, homes: ConvexHomes, extensions?: readonly ConvexExtension[]): void;
+//# sourceMappingURL=homes.d.ts.map

package/dist/homes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"homes.d.ts","sourceRoot":"","sources":["../src/homes.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC5F,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAMlE,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,kBAAkB,EAAE,MAAM,GACzB,MAAM,GAAG,SAAS,CAKpB;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAE9D;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAKzE;AAGD,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,SAAS,eAAe,EAAE,GACrC,kBAAkB,EAAE,CAMtB;AA0BD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,GAAG,kBAAkB,EAAE,CASvF;AAWD,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,SAAS,kBAAkB,EAAE,EACzC,YAAY,EAAE,SAAS,kBAAkB,EAAE,EAC3C,KAAK,EAAE,WAAW,GACjB,kBAAkB,EAAE,CAatB;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAEzE;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,oBAAoB,EAC5B,kBAAkB,EAAE,MAAM,EAC1B,KAAK,EAAE,WAAW,EAClB,UAAU,GAAE,SAAS,eAAe,EAAO,GAC1C,IAAI,CAUN"}

package/dist/homes.js

@@ -0,0 +1,81 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { readExtensionService } from "./component.js";
+import { CONVEX_COMPONENT_SERVICES, CONVEX_PAIRS } from "./pairs.js";
+import { FARM_BUILT_IN_AUTH, FARM_INTEGRATION_SERVICES } from "./pairs.js";
+const COMPONENT_IMPORT_PATTERN = /from\s+["']((?:@[\w.-]+\/)?[\w.-]+)\/convex\.config(?:\.js)?["']/g;
+const CONFIG_FILE_NAMES = ["convex.config.ts", "convex.config.js"];
+export function readConvexConfigSource(root, functionsDirectory) {
+    const filePath = CONFIG_FILE_NAMES.map((name) => path.join(root, functionsDirectory, name)).find((candidate) => existsSync(candidate));
+    return filePath ? readFileSync(filePath, "utf8") : undefined;
+}
+export function findComponentPackages(source) {
+    return [...source.matchAll(COMPONENT_IMPORT_PATTERN)].map((match) => match[1]);
+}
+export function findConvexComponents(source) {
+    return [...source.matchAll(COMPONENT_IMPORT_PATTERN)]
+        .map((match) => match[1])
+        .filter((name) => CONVEX_COMPONENT_SERVICES[name] !== undefined)
+        .map((name) => ({ service: CONVEX_COMPONENT_SERVICES[name], side: "convex", name }));
+}
+// An extension's service counts even before its component is installed.
+export function findExtensionServices(extensions) {
+    return extensions.flatMap((extension) => {
+        const service = readExtensionService(extension);
+        const name = extension.component ?? extension.name;
+        return service ? [{ service, side: "convex", name }] : [];
+    });
+}
+function mergeConvexServices(components, extensions) {
+    const names = new Set(components.map((setup) => setup.name));
+    return [...components, ...extensions.filter((setup) => !names.has(setup.name))];
+}
+function warnMissingComponents(source, extensions) {
+    for (const { name, component } of extensions) {
+        if (!component || source.includes(`${component}/convex.config`))
+            continue;
+        const listed = name === component ? component : `${name} (${component})`;
+        console.warn(`[farm:convex] ${listed} is in convex({ use }) but not in convex.config.ts. Add app.use() for it there.`);
+    }
+}
+function isBuiltInAuthEnabled(auth) {
+    if (typeof auth === "boolean")
+        return auth;
+    if (typeof auth !== "object" || auth === null)
+        return false;
+    return Reflect.get(auth, "enabled") !== false;
+}
+export function findFarmIntegrations(config) {
+    const names = Object.values(config.integrations ?? {})
+        .flatMap((integration) => (integration ? [integration.type] : []))
+        .concat(isBuiltInAuthEnabled(config.auth) ? [FARM_BUILT_IN_AUTH] : []);
+    return names
+        .filter((name) => name !== undefined && FARM_INTEGRATION_SERVICES[name] !== undefined)
+        .map((name) => ({ service: FARM_INTEGRATION_SERVICES[name], side: "farm", name }));
+}
+function isTogether(component, integration) {
+    return CONVEX_PAIRS.some((pair) => pair.component === component &&
+        pair.integration === integration &&
+        pair.relation === "together");
+}
+export function findHomeConflicts(components, integrations, homes) {
+    return components.flatMap((component) => integrations
+        .filter((integration) => integration.service === component.service && !homes[component.service])
+        .filter((integration) => !isTogether(component.name, integration.name))
+        .map((integration) => ({
+        service: component.service,
+        component: component.name,
+        integration: integration.name,
+    })));
+}
+export function describeHomeConflict(conflict) {
+    return `${conflict.service} is set up in Convex (${conflict.component}) and in Farm (${conflict.integration}). Remove one, or set convex({ home: { ${conflict.service}: "convex" } }) or "farm" to say which side owns it.`;
+}
+export function checkServiceHomes(config, functionsDirectory, homes, extensions = []) {
+    const source = readConvexConfigSource(config.root ?? process.cwd(), functionsDirectory) ?? "";
+    warnMissingComponents(source, extensions);
+    const conflicts = findHomeConflicts(mergeConvexServices(findConvexComponents(source), findExtensionServices(extensions)), findFarmIntegrations(config), homes);
+    if (conflicts.length === 0)
+        return;
+    throw new Error(`Convex integration:\n${conflicts.map(describeHomeConflict).join("\n")}`);
+}

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import type { ConvexIntegrationInput } from "./types.js";
+export declare function convex(input?: ConvexIntegrationInput): import("@farm.js/core").DefinedIntegration<{
+    category: "database";
+    type: string;
+    instance: undefined;
+    log: import("@farm.js/core").FarmIntegrationLogger | undefined;
+    plugins: import("@farm.js/core").FarmPlugin<import("./types.js").ConvexDevState, Record<string, never>, unknown, undefined, unknown, false, import("@farm.js/core").PluginRoutes>[];
+}, import("@farm.js/core").FarmSchema | undefined> | import("@farm.js/core").DefinedIntegration<{
+    category: "database";
+    type: string;
+    instance: import("./types.js").ConvexDeploymentURLs;
+    log: import("@farm.js/core").FarmIntegrationLogger | undefined;
+    routes: import("@farm.js/core").FarmIntegrationRoute<unknown, unknown, import("@farm.js/core").FarmSchema | undefined>[];
+    providers: {
+        name: string;
+        type: string;
+        props: {
+            url: string;
+            tokenPath: string;
+        } | {
+            url: string;
+            tokenPath?: undefined;
+        };
+        supportsIsolatedHydration: true;
+        component: import("@farm.js/core").FarmIntegrationProviderComponentReference;
+    }[];
+    plugins: import("@farm.js/core").FarmPlugin<import("./types.js").ConvexDevState, Record<string, never>, unknown, undefined, unknown, false, import("@farm.js/core").PluginRoutes>[];
+}, import("@farm.js/core").FarmSchema | undefined>;
+export { component } from "./component.js";
+export { KNOWN_COMPONENTS } from "./known.js";
+export { convexRateLimitStorage } from "./rate-limit.js";
+export { convexStorage } from "./storage.js";
+export { CONVEX_PAIRS } from "./pairs.js";
+export type { ConvexAdapterOptions, ConvexComponentOptions, ConvexDevOptions, ConvexExtension, ConvexExtensionRoute, ConvexHomes, ConvexIntegrationInput, ConvexPair, ConvexService, ConvexServiceSide, ConvexSiteToken, ConvexTokenReader, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAmB,sBAAsB,EAAqB,MAAM,YAAY,CAAC;AAkD7F,wBAAgB,MAAM,CAAC,KAAK,GAAE,sBAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;mDAkCxD;AAED,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,YAAY,EACV,oBAAoB,EACpB,sBAAsB,EACtB,gBAAgB,EAChB,eAAe,EACf,oBAAoB,EACpB,WAAW,EACX,sBAAsB,EACtB,UAAU,EACV,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,iBAAiB,GAClB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,87 @@
+import { defineIntegration } from "@farm.js/core";
+import { createConvexPlugin, resolveDevOptions } from "./dev.js";
+import { detectExtensions, mergeExtensions } from "./detect.js";
+import { hasDeploymentURL, resolveDeploymentURLs } from "./environment.js";
+import { checkExtensions, createExtensionRoutes, pickExtensionValue } from "./extensions.js";
+import { setConvexRuntime } from "./runtime.js";
+import { createSiteTokenReader } from "./site-token.js";
+const DEFAULT_PROVIDER = { module: "@farm.js/convex/client", export: "ConvexClientProvider" };
+const DEFAULT_FUNCTIONS_DIRECTORY = "convex";
+function resolveTokenReader(input, extensions, siteURL) {
+    if (input.token)
+        return input.token;
+    const token = pickExtensionValue(extensions, "token");
+    if (token)
+        return token;
+    const siteToken = pickExtensionValue(extensions, "siteToken");
+    return siteToken ? createSiteTokenReader(siteToken, siteURL) : undefined;
+}
+function isDevelopment() {
+    const mode = process.env.NODE_ENV;
+    return mode === undefined || mode === "development";
+}
+function resolveExtensions(input, functionsDirectory) {
+    const detected = input.detect === false
+        ? []
+        : detectExtensions(process.cwd(), functionsDirectory, input.home ?? {});
+    return mergeExtensions(detected, input.use ?? []);
+}
+// A new app has no deployment yet. farm dev runs convex dev, which creates one and writes
+// CONVEX_URL to .env.local; the app connects after a restart.
+function waitForDeployment(input, functionsDirectory) {
+    return defineIntegration({
+        category: "database",
+        type: "convex",
+        instance: undefined,
+        log: input.log,
+        plugins: [
+            createConvexPlugin({
+                dev: resolveDevOptions(input.dev),
+                homes: input.home ?? {},
+                functionsDirectory,
+                extensions: [],
+                waitingForDeployment: true,
+            }),
+        ],
+    });
+}
+export function convex(input = {}) {
+    const functionsDirectory = input.functionsDirectory ?? DEFAULT_FUNCTIONS_DIRECTORY;
+    if (!hasDeploymentURL(input) && isDevelopment()) {
+        return waitForDeployment(input, functionsDirectory);
+    }
+    const urls = resolveDeploymentURLs(input);
+    const extensions = resolveExtensions(input, functionsDirectory);
+    checkExtensions(extensions);
+    setConvexRuntime({ ...urls, token: resolveTokenReader(input, extensions, urls.siteURL) });
+    const tokenPath = input.tokenPath ?? pickExtensionValue(extensions, "tokenPath");
+    return defineIntegration({
+        category: "database",
+        type: "convex",
+        instance: urls,
+        log: input.log,
+        routes: createExtensionRoutes(extensions, urls.siteURL),
+        providers: [
+            {
+                name: "convex-provider",
+                type: "convex",
+                props: tokenPath ? { url: urls.url, tokenPath } : { url: urls.url },
+                supportsIsolatedHydration: true,
+                component: input.provider ?? pickExtensionValue(extensions, "provider") ?? DEFAULT_PROVIDER,
+            },
+        ],
+        plugins: [
+            createConvexPlugin({
+                dev: resolveDevOptions(input.dev),
+                homes: input.home ?? {},
+                functionsDirectory,
+                extensions,
+            }),
+        ],
+    });
+}
+export { component } from "./component.js";
+export { KNOWN_COMPONENTS } from "./known.js";
+export { convexRateLimitStorage } from "./rate-limit.js";
+export { convexStorage } from "./storage.js";
+export { CONVEX_PAIRS } from "./pairs.js";

package/dist/known.d.ts

@@ -0,0 +1,7 @@
+import type { ConvexKnownComponent } from "./types.js";
+/**
+ * Defaults for well-known Convex components, as data: Farm needs no code or dependencies from them.
+ * Paths match what each component registers by default in convex/http.ts.
+ */
+export declare const KNOWN_COMPONENTS: Readonly<Record<string, ConvexKnownComponent>>;
+//# sourceMappingURL=known.d.ts.map

package/dist/known.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"known.d.ts","sourceRoot":"","sources":["../src/known.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CA4B3E,CAAC"}

package/dist/known.js

@@ -0,0 +1,33 @@
+/**
+ * Defaults for well-known Convex components, as data: Farm needs no code or dependencies from them.
+ * Paths match what each component registers by default in convex/http.ts.
+ */
+export const KNOWN_COMPONENTS = {
+    "@convex-dev/better-auth": {
+        name: "better-auth",
+        service: "auth",
+        routes: [{ path: "/api/auth/[...auth]" }],
+        siteToken: { path: "/api/auth/convex/token", cookie: "session_token=" },
+        tokenPath: "/api/auth/convex/token",
+    },
+    "@convex-dev/workos-authkit": {
+        name: "workos-authkit",
+        service: "auth",
+        webhook: { path: "/api/webhooks/workos", convexPath: "/workos/webhook" },
+    },
+    "@convex-dev/polar": {
+        name: "polar",
+        service: "billing",
+        webhook: { path: "/api/webhooks/polar", convexPath: "/polar/events" },
+    },
+    "@convex-dev/stripe": {
+        name: "stripe",
+        service: "billing",
+        webhook: { path: "/api/webhooks/stripe", convexPath: "/stripe/webhook" },
+    },
+    "@useautumn/convex": { name: "autumn", service: "billing" },
+    "@convex-dev/resend": {
+        name: "resend",
+        webhook: { path: "/api/webhooks/resend", convexPath: "/resend-webhook" },
+    },
+};

package/dist/pairs.d.ts

@@ -0,0 +1,6 @@
+import type { ConvexPair, ConvexService } from "./types.js";
+export declare const FARM_BUILT_IN_AUTH = "farm-auth";
+export declare const CONVEX_COMPONENT_SERVICES: Readonly<Record<string, ConvexService>>;
+export declare const FARM_INTEGRATION_SERVICES: Readonly<Record<string, ConvexService>>;
+export declare const CONVEX_PAIRS: readonly ConvexPair[];
+//# sourceMappingURL=pairs.d.ts.map

package/dist/pairs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pairs.d.ts","sourceRoot":"","sources":["../src/pairs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE5D,eAAO,MAAM,kBAAkB,cAAc,CAAC;AAE9C,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAM7E,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAW7E,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,SAAS,UAAU,EAO7C,CAAC"}

package/dist/pairs.js

@@ -0,0 +1,28 @@
+export const FARM_BUILT_IN_AUTH = "farm-auth";
+export const CONVEX_COMPONENT_SERVICES = {
+    "@convex-dev/better-auth": "auth",
+    "@convex-dev/workos-authkit": "auth",
+    "@convex-dev/polar": "billing",
+    "@convex-dev/stripe": "billing",
+    "@useautumn/convex": "billing",
+};
+export const FARM_INTEGRATION_SERVICES = {
+    [FARM_BUILT_IN_AUTH]: "auth",
+    "better-auth": "auth",
+    clerk: "auth",
+    workos: "auth",
+    auth0: "auth",
+    authjs: "auth",
+    supabase: "auth",
+    polar: "billing",
+    stripe: "billing",
+    autumn: "billing",
+};
+export const CONVEX_PAIRS = [
+    {
+        service: "auth",
+        component: "@convex-dev/workos-authkit",
+        integration: "workos",
+        relation: "together",
+    },
+];

package/dist/rate-limit.d.ts

@@ -0,0 +1,4 @@
+import type { RateLimitStorage } from "@farm.js/core/middleware";
+import type { ConvexAdapterOptions } from "./types.js";
+export declare function convexRateLimitStorage(options?: ConvexAdapterOptions): RateLimitStorage;
+//# sourceMappingURL=rate-limit.d.ts.map

package/dist/rate-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.d.ts","sourceRoot":"","sources":["../src/rate-limit.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAA4B,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC3F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAQvD,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,oBAAyB,GAAG,gBAAgB,CAU3F"}

package/dist/rate-limit.js

@@ -0,0 +1,16 @@
+import { createAdapterCaller } from "./adapter-client.js";
+function checkWindow(windowMs) {
+    if (!Number.isSafeInteger(windowMs) || windowMs <= 0) {
+        throw new TypeError("Rate-limit windowMs must be a positive safe integer.");
+    }
+}
+export function convexRateLimitStorage(options = {}) {
+    const caller = createAdapterCaller(options);
+    return {
+        increment(key, windowMs) {
+            checkWindow(windowMs);
+            return caller.mutation("incrementRateLimit", { key, windowMs });
+        },
+        get: (key) => caller.query("readRateLimit", { key, now: Date.now() }),
+    };
+}

package/dist/runtime.d.ts

@@ -0,0 +1,5 @@
+import type { ConvexRuntime } from "./types.js";
+export declare function setConvexRuntime(runtime: ConvexRuntime): void;
+export declare function readConvexRuntime(): ConvexRuntime | undefined;
+export declare function requireConvexRuntime(): ConvexRuntime;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAuB,MAAM,YAAY,CAAC;AAIrE,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAE7D;AAED,wBAAgB,iBAAiB,IAAI,aAAa,GAAG,SAAS,CAE7D;AAED,wBAAgB,oBAAoB,IAAI,aAAa,CAQpD"}

package/dist/runtime.js

@@ -0,0 +1,14 @@
+const runtimeHolder = globalThis;
+export function setConvexRuntime(runtime) {
+    runtimeHolder.__farmConvexRuntime = runtime;
+}
+export function readConvexRuntime() {
+    return runtimeHolder.__farmConvexRuntime;
+}
+export function requireConvexRuntime() {
+    const runtime = readConvexRuntime();
+    if (!runtime) {
+        throw new Error("@farm.js/convex/server needs convex() in the farm.config.ts integrations with CONVEX_URL set. On a new app, let farm dev create the deployment, then restart it.");
+    }
+    return runtime;
+}

package/dist/secret.d.ts

@@ -0,0 +1,3 @@
+export declare const SECRET_ENVIRONMENT_NAME = "FARM_CONVEX_SECRET";
+export declare function readAdapterSecret(secret: string | undefined): string;
+//# sourceMappingURL=secret.d.ts.map

package/dist/secret.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret.d.ts","sourceRoot":"","sources":["../src/secret.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,uBAAuB,CAAC;AAE5D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAQpE"}

package/dist/secret.js

@@ -0,0 +1,8 @@
+export const SECRET_ENVIRONMENT_NAME = "FARM_CONVEX_SECRET";
+export function readAdapterSecret(secret) {
+    const resolvedSecret = secret ?? process.env[SECRET_ENVIRONMENT_NAME];
+    if (!resolvedSecret) {
+        throw new Error(`Convex adapters need ${SECRET_ENVIRONMENT_NAME}. Set the same value in your Farm server env and with \`npx convex env set ${SECRET_ENVIRONMENT_NAME} <value>\`.`);
+    }
+    return resolvedSecret;
+}

package/dist/server.d.ts

@@ -0,0 +1,10 @@
+import { ConvexHttpClient } from "convex/browser";
+import type { Preloaded } from "convex/react";
+import type { ArgsAndOptions, FunctionReference, FunctionReturnType } from "convex/server";
+import type { ConvexServerOptions } from "./types.js";
+export declare function createConvexServerClient(options?: ConvexServerOptions): Promise<ConvexHttpClient>;
+export declare function fetchQuery<Query extends FunctionReference<"query">>(query: Query, ...argsAndOptions: ArgsAndOptions<Query, ConvexServerOptions>): Promise<FunctionReturnType<Query>>;
+export declare function fetchMutation<Mutation extends FunctionReference<"mutation">>(mutation: Mutation, ...argsAndOptions: ArgsAndOptions<Mutation, ConvexServerOptions>): Promise<FunctionReturnType<Mutation>>;
+export declare function fetchAction<Action extends FunctionReference<"action">>(action: Action, ...argsAndOptions: ArgsAndOptions<Action, ConvexServerOptions>): Promise<FunctionReturnType<Action>>;
+export declare function preloadQuery<Query extends FunctionReference<"query">>(query: Query, ...argsAndOptions: ArgsAndOptions<Query, ConvexServerOptions>): Promise<Preloaded<Query>>;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAOlD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAC3F,OAAO,KAAK,EAAiB,mBAAmB,EAAE,MAAM,YAAY,CAAC;AA4CrE,wBAAsB,wBAAwB,CAC5C,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,gBAAgB,CAAC,CAI3B;AAED,wBAAsB,UAAU,CAAC,KAAK,SAAS,iBAAiB,CAAC,OAAO,CAAC,EACvE,KAAK,EAAE,KAAK,EACZ,GAAG,cAAc,EAAE,cAAc,CAAC,KAAK,EAAE,mBAAmB,CAAC,GAC5D,OAAO,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAIpC;AAED,wBAAsB,aAAa,CAAC,QAAQ,SAAS,iBAAiB,CAAC,UAAU,CAAC,EAChF,QAAQ,EAAE,QAAQ,EAClB,GAAG,cAAc,EAAE,cAAc,CAAC,QAAQ,EAAE,mBAAmB,CAAC,GAC/D,OAAO,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAIvC;AAED,wBAAsB,WAAW,CAAC,MAAM,SAAS,iBAAiB,CAAC,QAAQ,CAAC,EAC1E,MAAM,EAAE,MAAM,EACd,GAAG,cAAc,EAAE,cAAc,CAAC,MAAM,EAAE,mBAAmB,CAAC,GAC7D,OAAO,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAIrC;AAED,wBAAsB,YAAY,CAAC,KAAK,SAAS,iBAAiB,CAAC,OAAO,CAAC,EACzE,KAAK,EAAE,KAAK,EACZ,GAAG,cAAc,EAAE,cAAc,CAAC,KAAK,EAAE,mBAAmB,CAAC,GAC5D,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAS3B"}

package/dist/server.js

@@ -0,0 +1,70 @@
+import { ConvexHttpClient } from "convex/browser";
+import { getFunctionName } from "convex/server";
+import { convexToJson } from "convex/values";
+import { getCurrentRequest } from "@farm.js/core/request";
+import { requireConvexRuntime } from "./runtime.js";
+const MISSING_REQUEST_MESSAGE = "No current request is available";
+function readCurrentRequest() {
+    try {
+        return getCurrentRequest();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.startsWith(MISSING_REQUEST_MESSAGE))
+            return undefined;
+        throw error;
+    }
+}
+const fetchWithoutCache = (input, init) => fetch(input, { ...init, cache: "no-store" });
+function keepPageOutOfSharedCache() {
+    readCurrentRequest();
+}
+// A page that runs several queries reads the visitor's token once.
+const tokensByRequest = new WeakMap();
+async function readRequestToken(reader, request) {
+    let token = tokensByRequest.get(request);
+    if (!token) {
+        token = Promise.resolve(reader(request)).then((value) => value ?? undefined);
+        tokensByRequest.set(request, token);
+    }
+    return token;
+}
+async function resolveToken(options) {
+    if (options.token !== undefined)
+        return options.token;
+    const runtime = requireConvexRuntime();
+    const request = options.request ?? readCurrentRequest();
+    if (!runtime.token || !request)
+        return undefined;
+    return readRequestToken(runtime.token, request);
+}
+export async function createConvexServerClient(options = {}) {
+    const runtime = requireConvexRuntime();
+    const token = await resolveToken(options);
+    return new ConvexHttpClient(runtime.url, { auth: token, fetch: fetchWithoutCache });
+}
+export async function fetchQuery(query, ...argsAndOptions) {
+    const [args, options] = argsAndOptions;
+    const client = await createConvexServerClient(options ?? {});
+    return client.query(query, args ?? {});
+}
+export async function fetchMutation(mutation, ...argsAndOptions) {
+    const [args, options] = argsAndOptions;
+    const client = await createConvexServerClient(options ?? {});
+    return client.mutation(mutation, args ?? {});
+}
+export async function fetchAction(action, ...argsAndOptions) {
+    const [args, options] = argsAndOptions;
+    const client = await createConvexServerClient(options ?? {});
+    return client.action(action, args ?? {});
+}
+export async function preloadQuery(query, ...argsAndOptions) {
+    const [args] = argsAndOptions;
+    keepPageOutOfSharedCache();
+    const value = await fetchQuery(query, ...argsAndOptions);
+    return {
+        _name: getFunctionName(query),
+        _argsJSON: convexToJson(args ?? {}),
+        _valueJSON: convexToJson(value),
+    };
+}

package/dist/site-token.d.ts

@@ -0,0 +1,4 @@
+import type { ConvexSiteToken, ConvexTokenReader } from "./types.js";
+/** Exchange the visitor's cookie for a Convex token at a path on the Convex site URL. */
+export declare function createSiteTokenReader(siteToken: ConvexSiteToken, siteURL: string): ConvexTokenReader;
+//# sourceMappingURL=site-token.d.ts.map

package/dist/site-token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"site-token.d.ts","sourceRoot":"","sources":["../src/site-token.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAgBrE,yFAAyF;AACzF,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,eAAe,EAC1B,OAAO,EAAE,MAAM,GACd,iBAAiB,CAWnB"}

package/dist/site-token.js

@@ -0,0 +1,26 @@
+function isTokenPayload(value) {
+    return (typeof value === "object" && value !== null && typeof Reflect.get(value, "token") === "string");
+}
+async function readTokenPayload(response) {
+    try {
+        return await response.json();
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Exchange the visitor's cookie for a Convex token at a path on the Convex site URL. */
+export function createSiteTokenReader(siteToken, siteURL) {
+    return async (request) => {
+        const cookie = request.headers.get("cookie");
+        if (!cookie || (siteToken.cookie && !cookie.includes(siteToken.cookie)))
+            return undefined;
+        const response = await fetch(new URL(siteToken.path, siteURL), {
+            headers: { cookie, "accept-encoding": "identity" },
+        });
+        if (!response.ok)
+            return undefined;
+        const payload = await readTokenPayload(response);
+        return isTokenPayload(payload) ? payload.token : undefined;
+    };
+}