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

package/dist/component/rateLimits.js

@@ -0,0 +1,40 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+import { rateLimitResultValidator } from "./validators";
+export const increment = mutation({
+    args: { key: v.string(), windowMs: v.number() },
+    returns: rateLimitResultValidator,
+    handler: async (context, { key, windowMs }) => {
+        const now = Date.now();
+        const existing = await context.db
+            .query("rateLimits")
+            .withIndex("by_key", (index) => index.eq("key", key))
+            .unique();
+        if (!existing) {
+            const resetAt = now + windowMs;
+            await context.db.insert("rateLimits", { key, count: 1, resetAt });
+            return { count: 1, resetAt };
+        }
+        if (existing.resetAt <= now) {
+            const resetAt = now + windowMs;
+            await context.db.patch(existing._id, { count: 1, resetAt });
+            return { count: 1, resetAt };
+        }
+        const count = existing.count + 1;
+        await context.db.patch(existing._id, { count });
+        return { count, resetAt: existing.resetAt };
+    },
+});
+export const read = query({
+    args: { key: v.string(), now: v.number() },
+    returns: v.union(rateLimitResultValidator, v.null()),
+    handler: async (context, { key, now }) => {
+        const existing = await context.db
+            .query("rateLimits")
+            .withIndex("by_key", (index) => index.eq("key", key))
+            .unique();
+        if (!existing || existing.resetAt <= now)
+            return null;
+        return { count: existing.count, resetAt: existing.resetAt };
+    },
+});

package/dist/component/schema.d.ts

@@ -0,0 +1,24 @@
+declare const _default: import("convex/server").SchemaDefinition<{
+    rateLimits: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        key: string;
+        count: number;
+        resetAt: number;
+    }, {
+        key: import("convex/values").VString<string, "required">;
+        count: import("convex/values").VFloat64<number, "required">;
+        resetAt: import("convex/values").VFloat64<number, "required">;
+    }, "required", "key" | "count" | "resetAt">, {
+        by_key: ["key", "_creationTime"];
+    }, {}, {}>;
+    storageItems: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        key: string;
+        value: string;
+    }, {
+        key: import("convex/values").VString<string, "required">;
+        value: import("convex/values").VString<string, "required">;
+    }, "required", "key" | "value">, {
+        by_key: ["key", "_creationTime"];
+    }, {}, {}>;
+}, true>;
+export default _default;
+//# sourceMappingURL=schema.d.ts.map

package/dist/component/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/component/schema.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAGA,wBAUG"}

package/dist/component/schema.js

@@ -0,0 +1,13 @@
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+export default defineSchema({
+    rateLimits: defineTable({
+        key: v.string(),
+        count: v.number(),
+        resetAt: v.number(),
+    }).index("by_key", ["key"]),
+    storageItems: defineTable({
+        key: v.string(),
+        value: v.string(),
+    }).index("by_key", ["key"]),
+});

package/dist/component/storage.d.ts

@@ -0,0 +1,17 @@
+export declare const getItem: import("convex/server").RegisteredQuery<"public", {
+    key: string;
+}, Promise<string | null>>;
+export declare const setItem: import("convex/server").RegisteredMutation<"public", {
+    key: string;
+    value: string;
+}, Promise<null>>;
+export declare const removeItem: import("convex/server").RegisteredMutation<"public", {
+    key: string;
+}, Promise<null>>;
+export declare const listKeys: import("convex/server").RegisteredQuery<"public", {
+    prefix: string;
+}, Promise<string[]>>;
+export declare const clearItems: import("convex/server").RegisteredMutation<"public", {
+    prefix: string;
+}, Promise<number>>;
+//# sourceMappingURL=storage.d.ts.map

package/dist/component/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../src/component/storage.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,OAAO;;0BAOlB,CAAC;AAEH,eAAO,MAAM,OAAO;;;iBAYlB,CAAC;AAEH,eAAO,MAAM,UAAU;;iBAQrB,CAAC;AAEH,eAAO,MAAM,QAAQ;;qBAOnB,CAAC;AAEH,eAAO,MAAM,UAAU;;mBAQrB,CAAC"}

package/dist/component/storage.js

@@ -0,0 +1,62 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+const CLEAR_BATCH_SIZE = 500;
+function findItem(context, key) {
+    return context.db
+        .query("storageItems")
+        .withIndex("by_key", (index) => index.eq("key", key))
+        .unique();
+}
+function queryItemsWithPrefix(context, prefix) {
+    return context.db
+        .query("storageItems")
+        .withIndex("by_key", (index) => index.gte("key", prefix).lt("key", `${prefix}￿`));
+}
+export const getItem = query({
+    args: { key: v.string() },
+    returns: v.union(v.string(), v.null()),
+    handler: async (context, { key }) => {
+        const item = await findItem(context, key);
+        return item?.value ?? null;
+    },
+});
+export const setItem = mutation({
+    args: { key: v.string(), value: v.string() },
+    returns: v.null(),
+    handler: async (context, { key, value }) => {
+        const item = await findItem(context, key);
+        if (item) {
+            await context.db.patch(item._id, { value });
+            return null;
+        }
+        await context.db.insert("storageItems", { key, value });
+        return null;
+    },
+});
+export const removeItem = mutation({
+    args: { key: v.string() },
+    returns: v.null(),
+    handler: async (context, { key }) => {
+        const item = await findItem(context, key);
+        if (item)
+            await context.db.delete(item._id);
+        return null;
+    },
+});
+export const listKeys = query({
+    args: { prefix: v.string() },
+    returns: v.array(v.string()),
+    handler: async (context, { prefix }) => {
+        const items = await queryItemsWithPrefix(context, prefix).collect();
+        return items.map((item) => item.key);
+    },
+});
+export const clearItems = mutation({
+    args: { prefix: v.string() },
+    returns: v.number(),
+    handler: async (context, { prefix }) => {
+        const items = await queryItemsWithPrefix(context, prefix).take(CLEAR_BATCH_SIZE);
+        await Promise.all(items.map((item) => context.db.delete(item._id)));
+        return items.length;
+    },
+});

package/dist/component/validators.d.ts

@@ -0,0 +1,8 @@
+export declare const rateLimitResultValidator: import("convex/values").VObject<{
+    count: number;
+    resetAt: number;
+}, {
+    count: import("convex/values").VFloat64<number, "required">;
+    resetAt: import("convex/values").VFloat64<number, "required">;
+}, "required", "count" | "resetAt">;
+//# sourceMappingURL=validators.d.ts.map

package/dist/component/validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../src/component/validators.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,wBAAwB;;;;;;mCAGnC,CAAC"}

package/dist/component/validators.js

@@ -0,0 +1,5 @@
+import { v } from "convex/values";
+export const rateLimitResultValidator = v.object({
+    count: v.number(),
+    resetAt: v.number(),
+});

package/dist/component.d.ts

@@ -0,0 +1,12 @@
+import type { ConvexComponentOptions, ConvexExtension } from "./types.js";
+import type { ConvexService } from "./types.js";
+/**
+ * Any Convex component, wired into Farm by convex({ use }). Well-known components, such as
+ * "@convex-dev/better-auth" or "@convex-dev/stripe", come with their routes and defaults.
+ */
+export declare function component(packageName: string, options?: ConvexComponentOptions): ConvexExtension;
+/** Whether an extension signs visitors in: a token, a site token, a token path or a provider. */
+export declare function signsVisitorsIn(extension: ConvexExtension): boolean;
+/** The kind of service an extension provides; signing visitors in means auth. */
+export declare function readExtensionService(extension: ConvexExtension): ConvexService | undefined;
+//# sourceMappingURL=component.d.ts.map

package/dist/component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.d.ts","sourceRoot":"","sources":["../src/component.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,eAAe,EAAwB,MAAM,YAAY,CAAC;AAChG,OAAO,KAAK,EAAwB,aAAa,EAAE,MAAM,YAAY,CAAC;AA8BtE;;;GAGG;AACH,wBAAgB,SAAS,CACvB,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,sBAA2B,GACnC,eAAe,CAiBjB;AAED,iGAAiG;AACjG,wBAAgB,eAAe,CAAC,SAAS,EAAE,eAAe,GAAG,OAAO,CAInE;AAED,iFAAiF;AACjF,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,eAAe,GAAG,aAAa,GAAG,SAAS,CAE1F"}

package/dist/component.js

@@ -0,0 +1,52 @@
+import { KNOWN_COMPONENTS } from "./known.js";
+function toRoutes(routes) {
+    if (!routes)
+        return [];
+    if (Array.isArray(routes))
+        return [...routes];
+    return Object.entries(routes).map(([path, to]) => ({ path, to }));
+}
+function toWebhookRoute(packageName, known, { webhooks, convexPath }) {
+    if (!webhooks)
+        return [];
+    const to = convexPath ?? known?.webhook?.convexPath;
+    const path = webhooks === true ? known?.webhook?.path : webhooks;
+    if (!to || !path) {
+        throw new TypeError(`component("${packageName}") has no default webhook paths. Pass webhooks: "/your/path" and convexPath.`);
+    }
+    return [{ path, methods: ["POST"], to }];
+}
+function withoutUndefined(extension) {
+    return Object.fromEntries(Object.entries(extension).filter(([, value]) => value !== undefined));
+}
+/**
+ * Any Convex component, wired into Farm by convex({ use }). Well-known components, such as
+ * "@convex-dev/better-auth" or "@convex-dev/stripe", come with their routes and defaults.
+ */
+export function component(packageName, options = {}) {
+    if (!packageName.trim())
+        throw new TypeError("component() needs the component's package name.");
+    const known = KNOWN_COMPONENTS[packageName];
+    return withoutUndefined({
+        name: options.name ?? known?.name ?? packageName,
+        component: packageName,
+        service: known?.service,
+        routes: [
+            ...(known?.routes ?? []),
+            ...toRoutes(options.routes),
+            ...toWebhookRoute(packageName, known, options),
+        ],
+        token: options.token,
+        siteToken: options.token ? undefined : known?.siteToken,
+        tokenPath: options.tokenPath ?? known?.tokenPath,
+        provider: options.provider,
+    });
+}
+/** Whether an extension signs visitors in: a token, a site token, a token path or a provider. */
+export function signsVisitorsIn(extension) {
+    return Boolean(extension.token || extension.siteToken || extension.tokenPath || extension.provider);
+}
+/** The kind of service an extension provides; signing visitors in means auth. */
+export function readExtensionService(extension) {
+    return extension.service ?? (signsVisitorsIn(extension) ? "auth" : undefined);
+}

package/dist/detect.d.ts

@@ -0,0 +1,6 @@
+import type { ConvexExtension, ConvexHomes } from "./types.js";
+/** The well-known components installed in convex.config.ts, minus services whose home is Farm. */
+export declare function detectExtensions(root: string, functionsDirectory: string, homes: ConvexHomes): ConvexExtension[];
+/** An extension listed in `use` replaces the detected one for the same component. */
+export declare function mergeExtensions(detected: readonly ConvexExtension[], explicit: readonly ConvexExtension[]): ConvexExtension[];
+//# sourceMappingURL=detect.d.ts.map

package/dist/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../src/detect.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE/D,kGAAkG;AAClG,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,kBAAkB,EAAE,MAAM,EAC1B,KAAK,EAAE,WAAW,GACjB,eAAe,EAAE,CAQnB;AAED,qFAAqF;AACrF,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,SAAS,eAAe,EAAE,EACpC,QAAQ,EAAE,SAAS,eAAe,EAAE,GACnC,eAAe,EAAE,CAGnB"}

package/dist/detect.js

@@ -0,0 +1,18 @@
+import { component, readExtensionService } from "./component.js";
+import { findComponentPackages, readConvexConfigSource } from "./homes.js";
+import { KNOWN_COMPONENTS } from "./known.js";
+/** The well-known components installed in convex.config.ts, minus services whose home is Farm. */
+export function detectExtensions(root, functionsDirectory, homes) {
+    const source = readConvexConfigSource(root, functionsDirectory) ?? "";
+    return findComponentPackages(source)
+        .flatMap((name) => (KNOWN_COMPONENTS[name] ? [component(name)] : []))
+        .filter((extension) => {
+        const service = readExtensionService(extension);
+        return !service || homes[service] !== "farm";
+    });
+}
+/** An extension listed in `use` replaces the detected one for the same component. */
+export function mergeExtensions(detected, explicit) {
+    const listed = new Set(explicit.map(({ component }) => component).filter(Boolean));
+    return [...detected.filter(({ component }) => !listed.has(component)), ...explicit];
+}

package/dist/dev.d.ts

@@ -0,0 +1,10 @@
+import type { ConvexDevOptions, ConvexDevState } from "./types.js";
+import type { ConvexPluginInput } from "./types.js";
+export declare function resolveDevOptions(dev: boolean | ConvexDevOptions | undefined): ConvexDevOptions | undefined;
+export declare function isDeploymentChosen(root: string): boolean;
+export declare function startConvexDev(root: string, options: ConvexDevOptions, state: ConvexDevState): void;
+export declare function stopConvexDev(state: ConvexDevState | undefined): void;
+/** Tell the developer to restart once convex dev has written the new deployment's URL. */
+export declare function announceNewDeployment(root: string, interval?: number): () => void;
+export declare function createConvexPlugin(input: ConvexPluginInput): import("@farm.js/core").FarmPlugin<ConvexDevState, Record<string, never>, unknown, undefined, unknown, false, import("@farm.js/core").PluginRoutes>;
+//# sourceMappingURL=dev.d.ts.map

package/dist/dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../src/dev.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAwB,MAAM,YAAY,CAAC;AACzF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAKpD,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,OAAO,GAAG,gBAAgB,GAAG,SAAS,GAC1C,gBAAgB,GAAG,SAAS,CAG9B;AAiBD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGxD;AASD,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,cAAc,GACpB,IAAI,CA2BN;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,GAAG,SAAS,GAAG,IAAI,CAIrE;AAID,0FAA0F;AAC1F,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,SAAM,GAAG,MAAM,IAAI,CAY9E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,iBAAiB,uJAkC1D"}

package/dist/dev.js

@@ -0,0 +1,122 @@
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, unwatchFile, watchFile } from "node:fs";
+import path from "node:path";
+import { createInterface } from "node:readline";
+import { styleText } from "node:util";
+import { definePlugin } from "@farm.js/core/plugin";
+import { checkServiceHomes } from "./homes.js";
+const CONVEX_BINARY = process.platform === "win32" ? "convex.cmd" : "convex";
+const OUTPUT_LABEL = "convex │ ";
+export function resolveDevOptions(dev) {
+    if (dev === false)
+        return undefined;
+    return dev === true || dev === undefined ? {} : dev;
+}
+function findConvexBinary(root) {
+    const binaryPath = path.join(root, "node_modules", ".bin", CONVEX_BINARY);
+    return existsSync(binaryPath) ? binaryPath : undefined;
+}
+function readEnvironmentFile(root) {
+    try {
+        return readFileSync(path.join(root, ".env.local"), "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return "";
+        throw error;
+    }
+}
+// Before a deployment is chosen, convex dev asks questions on the terminal, so it keeps it.
+export function isDeploymentChosen(root) {
+    if (process.env.CONVEX_DEPLOYMENT || process.env.CONVEX_AGENT_MODE)
+        return true;
+    return /^CONVEX_DEPLOYMENT=\S/m.test(readEnvironmentFile(root));
+}
+function writeLabelledLines(source, target) {
+    const label = styleText("dim", OUTPUT_LABEL, { stream: target });
+    createInterface({ input: source, crlfDelay: Infinity }).on("line", (line) => {
+        target.write(`${label}${line}\n`);
+    });
+}
+export function startConvexDev(root, options, state) {
+    const binaryPath = findConvexBinary(root);
+    if (!binaryPath) {
+        console.warn("[farm:convex] convex is not installed in this app, so `convex dev` was not started.");
+        return;
+    }
+    const labelOutput = isDeploymentChosen(root);
+    const child = spawn(binaryPath, ["dev", ...(options.args ?? [])], {
+        cwd: root,
+        stdio: labelOutput ? ["inherit", "pipe", "pipe"] : "inherit",
+        shell: process.platform === "win32",
+        env: labelOutput && process.stdout.isTTY ? { ...process.env, FORCE_COLOR: "1" } : process.env,
+    });
+    state.child = child;
+    if (labelOutput && child.stdout && child.stderr) {
+        writeLabelledLines(child.stdout, process.stdout);
+        writeLabelledLines(child.stderr, process.stderr);
+    }
+    const stopWithFarm = () => stopConvexDev(state);
+    process.once("exit", stopWithFarm);
+    child.once("exit", () => {
+        process.off("exit", stopWithFarm);
+        // A runner that exits late must not forget the one that replaced it.
+        if (state.child === child)
+            state.child = undefined;
+    });
+}
+export function stopConvexDev(state) {
+    if (!state?.child || state.child.exitCode !== null)
+        return;
+    state.child.kill("SIGINT");
+    state.child = undefined;
+}
+const DEPLOYMENT_URL_PATTERN = /^(?:VITE_)?CONVEX_URL=\S/m;
+/** Tell the developer to restart once convex dev has written the new deployment's URL. */
+export function announceNewDeployment(root, interval = 500) {
+    const filePath = path.join(root, ".env.local");
+    console.warn("[farm:convex] CONVEX_URL is not set yet. convex dev will create a deployment; restart farm dev when it is ready.");
+    const check = () => {
+        if (!DEPLOYMENT_URL_PATTERN.test(readEnvironmentFile(root)))
+            return;
+        unwatchFile(filePath, check);
+        console.log("[farm:convex] Convex deployment is ready. Restart farm dev to connect to it.");
+    };
+    watchFile(filePath, { interval }, check);
+    return () => unwatchFile(filePath, check);
+}
+export function createConvexPlugin(input) {
+    let root = process.cwd();
+    return definePlugin({
+        name: "farm:convex",
+        configure(config) {
+            const view = config;
+            root = path.resolve(view.root ?? root);
+            if (input.waitingForDeployment)
+                return;
+            checkServiceHomes({ ...view, root }, input.functionsDirectory, input.homes, input.extensions);
+        },
+        setup: () => ({}),
+        dev: {
+            server(_viteServer, { state, lifecycle }) {
+                if (input.waitingForDeployment) {
+                    const stopWatching = announceNewDeployment(root);
+                    lifecycle.onShutdown(stopWatching);
+                    if (!input.dev) {
+                        console.warn("[farm:convex] CONVEX_URL is not set. Run `npx convex dev` to create a deployment.");
+                        return;
+                    }
+                }
+                if (!input.dev)
+                    return;
+                // Vite closes its HTTP server on every restart (an edited .env does that), and Farm
+                // runs this hook once per farm dev, so stop only on shutdown.
+                startConvexDev(root, input.dev, state);
+                lifecycle.onShutdown(() => stopConvexDev(state));
+            },
+        },
+        runtime: {
+            close: ({ state }) => stopConvexDev(state),
+        },
+    });
+}

package/dist/environment.d.ts

@@ -0,0 +1,6 @@
+import type { ConvexDeploymentURLs, ConvexIntegrationInput } from "./types.js";
+export declare function hasDeploymentURL(input: ConvexIntegrationInput): boolean;
+export declare function readEnvironmentValue(names: readonly string[]): string | undefined;
+export declare function deriveSiteURL(url: URL): string | undefined;
+export declare function resolveDeploymentURLs(input: ConvexIntegrationInput): ConvexDeploymentURLs;
+//# sourceMappingURL=environment.d.ts.map

package/dist/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../src/environment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAS/E,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAEvE;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAEjF;AAyBD,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,GAAG,SAAS,CAM1D;AA8BD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,sBAAsB,GAAG,oBAAoB,CAMzF"}

package/dist/environment.js

@@ -0,0 +1,62 @@
+const CLOUD_SUFFIX = ".convex.cloud";
+const SITE_SUFFIX = ".convex.site";
+const LOCAL_HOSTS = new Set(["127.0.0.1", "localhost", "0.0.0.0"]);
+const URL_ENVIRONMENT_NAMES = ["CONVEX_URL", "VITE_CONVEX_URL"];
+const SITE_URL_ENVIRONMENT_NAMES = ["CONVEX_SITE_URL", "VITE_CONVEX_SITE_URL"];
+export function hasDeploymentURL(input) {
+    return Boolean(input.url ?? readEnvironmentValue(URL_ENVIRONMENT_NAMES));
+}
+export function readEnvironmentValue(names) {
+    return names.map((name) => process.env[name]?.trim()).find((value) => Boolean(value));
+}
+function parseURL(value, name) {
+    if (!URL.canParse(value)) {
+        throw new Error(`Convex integration: ${name} is not a valid URL (received "${value}").`);
+    }
+    return new URL(value);
+}
+function checkDeploymentURL(url) {
+    if (url.hostname.endsWith(SITE_SUFFIX)) {
+        throw new Error(`Convex integration: CONVEX_URL points at the HTTP actions URL (${SITE_SUFFIX}). Use the deployment URL ending in ${CLOUD_SUFFIX}, and put the ${SITE_SUFFIX} URL in CONVEX_SITE_URL.`);
+    }
+}
+function checkSiteURL(url) {
+    if (url.hostname.endsWith(CLOUD_SUFFIX)) {
+        throw new Error(`Convex integration: CONVEX_SITE_URL points at the deployment URL (${CLOUD_SUFFIX}). Use the HTTP actions URL ending in ${SITE_SUFFIX}.`);
+    }
+}
+export function deriveSiteURL(url) {
+    if (url.hostname.endsWith(CLOUD_SUFFIX)) {
+        return `${url.protocol}//${url.hostname.slice(0, -CLOUD_SUFFIX.length)}${SITE_SUFFIX}`;
+    }
+    if (!LOCAL_HOSTS.has(url.hostname) || !url.port)
+        return undefined;
+    return `${url.protocol}//${url.hostname}:${Number(url.port) + 1}`;
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+function resolveURL(input) {
+    const rawURL = input.url ?? readEnvironmentValue(URL_ENVIRONMENT_NAMES);
+    if (!rawURL) {
+        throw new Error("Convex integration requires CONVEX_URL. Run `npx convex dev` once to create a deployment and write CONVEX_URL to .env.local, or pass convex({ url }).");
+    }
+    const url = parseURL(rawURL, "CONVEX_URL");
+    checkDeploymentURL(url);
+    return url;
+}
+function resolveSiteURL(input, url) {
+    const rawSiteURL = input.siteURL ?? readEnvironmentValue(SITE_URL_ENVIRONMENT_NAMES) ?? deriveSiteURL(url);
+    if (!rawSiteURL) {
+        throw new Error("Convex integration could not work out CONVEX_SITE_URL from CONVEX_URL. Set CONVEX_SITE_URL to your deployment's HTTP actions URL, or pass convex({ siteURL }).");
+    }
+    checkSiteURL(parseURL(rawSiteURL, "CONVEX_SITE_URL"));
+    return rawSiteURL;
+}
+export function resolveDeploymentURLs(input) {
+    const url = resolveURL(input);
+    return {
+        url: trimTrailingSlash(url.href),
+        siteURL: trimTrailingSlash(resolveSiteURL(input, url)),
+    };
+}

package/dist/extensions.d.ts

@@ -0,0 +1,8 @@
+import type { FarmIntegrationRoute } from "@farm.js/core";
+import type { ConvexExtension } from "./types.js";
+type ExtensionValueKey = "token" | "siteToken" | "tokenPath" | "provider";
+export declare function checkExtensions(extensions: readonly ConvexExtension[]): void;
+export declare function pickExtensionValue<Key extends ExtensionValueKey>(extensions: readonly ConvexExtension[], key: Key): ConvexExtension[Key];
+export declare function createExtensionRoutes(extensions: readonly ConvexExtension[], siteURL: string): FarmIntegrationRoute[];
+export {};
+//# sourceMappingURL=extensions.d.ts.map

package/dist/extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.d.ts","sourceRoot":"","sources":["../src/extensions.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAIlD,KAAK,iBAAiB,GAAG,OAAO,GAAG,WAAW,GAAG,WAAW,GAAG,UAAU,CAAC;AA+C1E,wBAAgB,eAAe,CAAC,UAAU,EAAE,SAAS,eAAe,EAAE,GAAG,IAAI,CAM5E;AAED,wBAAgB,kBAAkB,CAAC,GAAG,SAAS,iBAAiB,EAC9D,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,GAAG,EAAE,GAAG,GACP,eAAe,CAAC,GAAG,CAAC,CAEtB;AAED,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,SAAS,eAAe,EAAE,EACtC,OAAO,EAAE,MAAM,GACd,oBAAoB,EAAE,CAQxB"}

package/dist/extensions.js

@@ -0,0 +1,55 @@
+import { readExtensionService } from "./component.js";
+import { forwardRequest } from "./forward.js";
+const DEFAULT_METHODS = ["GET", "POST"];
+function checkSingleOwner(extensions, keys, label, option) {
+    const owners = extensions
+        .filter((extension) => keys.some((key) => extension[key] !== undefined))
+        .map(({ name }) => name);
+    if (owners.length > 1) {
+        throw new Error(`Convex integration: ${owners.join(" and ")} both ${label}. Keep one, or pass convex({ ${option} }) to choose.`);
+    }
+}
+function checkServiceOwners(extensions) {
+    const owners = new Map();
+    for (const extension of extensions) {
+        const service = readExtensionService(extension);
+        if (!service)
+            continue;
+        const other = owners.get(service);
+        if (other) {
+            throw new Error(`Convex integration: ${other} and ${extension.name} both provide ${service}. Keep one.`);
+        }
+        owners.set(service, extension.name);
+    }
+}
+function checkRoutePaths(extensions) {
+    const owners = new Map();
+    for (const { name, routes = [] } of extensions) {
+        for (const { path, to } of routes) {
+            if (!path.startsWith("/") || (to !== undefined && !to.startsWith("/"))) {
+                throw new Error(`Convex integration: ${name} routes must be paths starting with "/".`);
+            }
+            const owner = owners.get(path);
+            if (owner)
+                throw new Error(`Convex integration: ${owner} and ${name} both route ${path}.`);
+            owners.set(path, name);
+        }
+    }
+}
+export function checkExtensions(extensions) {
+    checkSingleOwner(extensions, ["token", "siteToken"], "read a visitor token", "token");
+    checkSingleOwner(extensions, ["tokenPath"], "set a browser token path", "tokenPath");
+    checkSingleOwner(extensions, ["provider"], "set a provider", "provider");
+    checkServiceOwners(extensions);
+    checkRoutePaths(extensions);
+}
+export function pickExtensionValue(extensions, key) {
+    return extensions.find((extension) => extension[key] !== undefined)?.[key];
+}
+export function createExtensionRoutes(extensions, siteURL) {
+    return extensions.flatMap(({ routes = [] }) => routes.map((route) => ({
+        path: route.path,
+        methods: route.methods ?? DEFAULT_METHODS,
+        handler: (request) => forwardRequest(request, siteURL, route.to),
+    })));
+}

package/dist/forward.d.ts

@@ -0,0 +1,2 @@
+export declare function forwardRequest(request: Request, siteURL: string, targetPath?: string): Promise<Response>;
+//# sourceMappingURL=forward.d.ts.map

package/dist/forward.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forward.d.ts","sourceRoot":"","sources":["../src/forward.ts"],"names":[],"mappings":"AA+BA,wBAAsB,cAAc,CAClC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,QAAQ,CAAC,CAYnB"}

package/dist/forward.js

@@ -0,0 +1,38 @@
+const DROPPED_REQUEST_HEADERS = ["connection", "content-length", "host", "transfer-encoding"];
+const DROPPED_RESPONSE_HEADERS = ["content-encoding", "content-length", "transfer-encoding"];
+const BODYLESS_METHODS = new Set(["GET", "HEAD"]);
+function readProtocol(url) {
+    return url.protocol.replace(/:$/, "");
+}
+function createForwardHeaders(request, incomingURL) {
+    const headers = new Headers(request.headers);
+    DROPPED_REQUEST_HEADERS.forEach((name) => headers.delete(name));
+    headers.set("accept-encoding", "identity");
+    headers.set("x-forwarded-host", incomingURL.host);
+    headers.set("x-forwarded-proto", readProtocol(incomingURL));
+    headers.set("x-better-auth-forwarded-host", incomingURL.host);
+    headers.set("x-better-auth-forwarded-proto", readProtocol(incomingURL));
+    return headers;
+}
+function copyResponse(response) {
+    const headers = new Headers(response.headers);
+    DROPPED_RESPONSE_HEADERS.forEach((name) => headers.delete(name));
+    return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+    });
+}
+export async function forwardRequest(request, siteURL, targetPath) {
+    const incomingURL = new URL(request.url);
+    const pathname = targetPath ?? incomingURL.pathname;
+    const targetURL = new URL(`${pathname}${incomingURL.search}`, siteURL);
+    const init = {
+        method: request.method,
+        headers: createForwardHeaders(request, incomingURL),
+        body: BODYLESS_METHODS.has(request.method) ? undefined : request.body,
+        redirect: "manual",
+        duplex: "half",
+    };
+    return copyResponse(await fetch(targetURL, init));
+}