@farm.js/auth 0.1.1-beta.2 → 0.1.1-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@farm.js/auth",
-  "version": "0.1.1-beta.2",
+  "version": "0.1.1-beta.3",
   "description": "Farm-native authentication with email/password, server helpers, and React hooks",
   "license": "MIT",
   "repository": {

package/dist/client.d.ts

@@ -1,539 +0,0 @@
-import type { FarmAuthClientOptions, FarmAuthCredentials, FarmAuthSignUpInput } from "./types.js";
-export declare function createFarmAuthClient(options?: FarmAuthClientOptions): {
-    signIn: (input: FarmAuthCredentials) => Promise<{
-        data: Omit<{
-            redirect: boolean;
-            token: string;
-            url?: string | undefined;
-            user: {
-                id: string;
-                createdAt: Date;
-                updatedAt: Date;
-                email: string;
-                emailVerified: boolean;
-                name: string;
-                image?: string | null | undefined | undefined;
-            };
-        }, "user"> & {
-            user: import("better-auth").StripEmptyObjects<{
-                id: string;
-                createdAt: Date;
-                updatedAt: Date;
-                email: string;
-                emailVerified: boolean;
-                name: string;
-                image?: string | null | undefined;
-            }>;
-        };
-        error: null;
-    } | {
-        data: null;
-        error: {
-            code?: string | undefined | undefined;
-            message?: string | undefined | undefined;
-            status: number;
-            statusText: string;
-        };
-    }>;
-    signUp: (input: FarmAuthSignUpInput) => Promise<{
-        data: (Omit<{
-            token: null;
-            user: {
-                id: string;
-                createdAt: Date;
-                updatedAt: Date;
-                email: string;
-                emailVerified: boolean;
-                name: string;
-                image?: string | null | undefined | undefined;
-            };
-        }, "user"> & {
-            user: import("better-auth").StripEmptyObjects<{
-                id: string;
-                createdAt: Date;
-                updatedAt: Date;
-                email: string;
-                emailVerified: boolean;
-                name: string;
-                image?: string | null | undefined;
-            }>;
-        }) | (Omit<{
-            token: string;
-            user: {
-                id: string;
-                createdAt: Date;
-                updatedAt: Date;
-                email: string;
-                emailVerified: boolean;
-                name: string;
-                image?: string | null | undefined | undefined;
-            };
-        }, "user"> & {
-            user: import("better-auth").StripEmptyObjects<{
-                id: string;
-                createdAt: Date;
-                updatedAt: Date;
-                email: string;
-                emailVerified: boolean;
-                name: string;
-                image?: string | null | undefined;
-            }>;
-        });
-        error: null;
-    } | {
-        data: null;
-        error: {
-            code?: string | undefined | undefined;
-            message?: string | undefined | undefined;
-            status: number;
-            statusText: string;
-        };
-    }>;
-    signOut: () => Promise<{
-        data: {
-            success: boolean;
-            url: string | undefined;
-            redirect: boolean | undefined;
-        };
-        error: null;
-    } | {
-        data: null;
-        error: {
-            code?: string | undefined | undefined;
-            message?: string | undefined | undefined;
-            status: number;
-            statusText: string;
-        };
-    }>;
-    getSession: () => Promise<{
-        data: {
-            user: import("better-auth").StripEmptyObjects<{
-                id: string;
-                createdAt: Date;
-                updatedAt: Date;
-                email: string;
-                emailVerified: boolean;
-                name: string;
-                image?: string | null | undefined;
-            }>;
-            session: import("better-auth").StripEmptyObjects<{
-                id: string;
-                createdAt: Date;
-                updatedAt: Date;
-                userId: string;
-                expiresAt: Date;
-                token: string;
-                ipAddress?: string | null | undefined;
-                userAgent?: string | null | undefined;
-            }>;
-        } | null;
-        error: null;
-    } | {
-        data: null;
-        error: {
-            code?: string | undefined | undefined;
-            message?: string | undefined | undefined;
-            status: number;
-            statusText: string;
-        };
-    }>;
-    useAuth: () => {
-        user: import("better-auth").StripEmptyObjects<{
-            id: string;
-            createdAt: Date;
-            updatedAt: Date;
-            email: string;
-            emailVerified: boolean;
-            name: string;
-            image?: string | null | undefined;
-        }> | null;
-        session: import("better-auth").StripEmptyObjects<{
-            id: string;
-            createdAt: Date;
-            updatedAt: Date;
-            userId: string;
-            expiresAt: Date;
-            token: string;
-            ipAddress?: string | null | undefined;
-            userAgent?: string | null | undefined;
-        }> | null;
-        isPending: boolean;
-        isRefetching: boolean;
-        error: import("better-auth/react").BetterFetchError | null;
-        refetch: (queryParams?: {
-            query?: import("better-auth").SessionQueryParams;
-        } | undefined) => Promise<void>;
-        signIn: (input: FarmAuthCredentials) => Promise<{
-            data: Omit<{
-                redirect: boolean;
-                token: string;
-                url?: string | undefined;
-                user: {
-                    id: string;
-                    createdAt: Date;
-                    updatedAt: Date;
-                    email: string;
-                    emailVerified: boolean;
-                    name: string;
-                    image?: string | null | undefined | undefined;
-                };
-            }, "user"> & {
-                user: import("better-auth").StripEmptyObjects<{
-                    id: string;
-                    createdAt: Date;
-                    updatedAt: Date;
-                    email: string;
-                    emailVerified: boolean;
-                    name: string;
-                    image?: string | null | undefined;
-                }>;
-            };
-            error: null;
-        } | {
-            data: null;
-            error: {
-                code?: string | undefined | undefined;
-                message?: string | undefined | undefined;
-                status: number;
-                statusText: string;
-            };
-        }>;
-        signUp: (input: FarmAuthSignUpInput) => Promise<{
-            data: (Omit<{
-                token: null;
-                user: {
-                    id: string;
-                    createdAt: Date;
-                    updatedAt: Date;
-                    email: string;
-                    emailVerified: boolean;
-                    name: string;
-                    image?: string | null | undefined | undefined;
-                };
-            }, "user"> & {
-                user: import("better-auth").StripEmptyObjects<{
-                    id: string;
-                    createdAt: Date;
-                    updatedAt: Date;
-                    email: string;
-                    emailVerified: boolean;
-                    name: string;
-                    image?: string | null | undefined;
-                }>;
-            }) | (Omit<{
-                token: string;
-                user: {
-                    id: string;
-                    createdAt: Date;
-                    updatedAt: Date;
-                    email: string;
-                    emailVerified: boolean;
-                    name: string;
-                    image?: string | null | undefined | undefined;
-                };
-            }, "user"> & {
-                user: import("better-auth").StripEmptyObjects<{
-                    id: string;
-                    createdAt: Date;
-                    updatedAt: Date;
-                    email: string;
-                    emailVerified: boolean;
-                    name: string;
-                    image?: string | null | undefined;
-                }>;
-            });
-            error: null;
-        } | {
-            data: null;
-            error: {
-                code?: string | undefined | undefined;
-                message?: string | undefined | undefined;
-                status: number;
-                statusText: string;
-            };
-        }>;
-        signOut: () => Promise<{
-            data: {
-                success: boolean;
-                url: string | undefined;
-                redirect: boolean | undefined;
-            };
-            error: null;
-        } | {
-            data: null;
-            error: {
-                code?: string | undefined | undefined;
-                message?: string | undefined | undefined;
-                status: number;
-                statusText: string;
-            };
-        }>;
-    };
-};
-export declare const getSession: () => Promise<{
-    data: {
-        user: import("better-auth").StripEmptyObjects<{
-            id: string;
-            createdAt: Date;
-            updatedAt: Date;
-            email: string;
-            emailVerified: boolean;
-            name: string;
-            image?: string | null | undefined;
-        }>;
-        session: import("better-auth").StripEmptyObjects<{
-            id: string;
-            createdAt: Date;
-            updatedAt: Date;
-            userId: string;
-            expiresAt: Date;
-            token: string;
-            ipAddress?: string | null | undefined;
-            userAgent?: string | null | undefined;
-        }>;
-    } | null;
-    error: null;
-} | {
-    data: null;
-    error: {
-        code?: string | undefined | undefined;
-        message?: string | undefined | undefined;
-        status: number;
-        statusText: string;
-    };
-}>, signIn: (input: FarmAuthCredentials) => Promise<{
-    data: Omit<{
-        redirect: boolean;
-        token: string;
-        url?: string | undefined;
-        user: {
-            id: string;
-            createdAt: Date;
-            updatedAt: Date;
-            email: string;
-            emailVerified: boolean;
-            name: string;
-            image?: string | null | undefined | undefined;
-        };
-    }, "user"> & {
-        user: import("better-auth").StripEmptyObjects<{
-            id: string;
-            createdAt: Date;
-            updatedAt: Date;
-            email: string;
-            emailVerified: boolean;
-            name: string;
-            image?: string | null | undefined;
-        }>;
-    };
-    error: null;
-} | {
-    data: null;
-    error: {
-        code?: string | undefined | undefined;
-        message?: string | undefined | undefined;
-        status: number;
-        statusText: string;
-    };
-}>, signOut: () => Promise<{
-    data: {
-        success: boolean;
-        url: string | undefined;
-        redirect: boolean | undefined;
-    };
-    error: null;
-} | {
-    data: null;
-    error: {
-        code?: string | undefined | undefined;
-        message?: string | undefined | undefined;
-        status: number;
-        statusText: string;
-    };
-}>, signUp: (input: FarmAuthSignUpInput) => Promise<{
-    data: (Omit<{
-        token: null;
-        user: {
-            id: string;
-            createdAt: Date;
-            updatedAt: Date;
-            email: string;
-            emailVerified: boolean;
-            name: string;
-            image?: string | null | undefined | undefined;
-        };
-    }, "user"> & {
-        user: import("better-auth").StripEmptyObjects<{
-            id: string;
-            createdAt: Date;
-            updatedAt: Date;
-            email: string;
-            emailVerified: boolean;
-            name: string;
-            image?: string | null | undefined;
-        }>;
-    }) | (Omit<{
-        token: string;
-        user: {
-            id: string;
-            createdAt: Date;
-            updatedAt: Date;
-            email: string;
-            emailVerified: boolean;
-            name: string;
-            image?: string | null | undefined | undefined;
-        };
-    }, "user"> & {
-        user: import("better-auth").StripEmptyObjects<{
-            id: string;
-            createdAt: Date;
-            updatedAt: Date;
-            email: string;
-            emailVerified: boolean;
-            name: string;
-            image?: string | null | undefined;
-        }>;
-    });
-    error: null;
-} | {
-    data: null;
-    error: {
-        code?: string | undefined | undefined;
-        message?: string | undefined | undefined;
-        status: number;
-        statusText: string;
-    };
-}>, useAuth: () => {
-    user: import("better-auth").StripEmptyObjects<{
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-        email: string;
-        emailVerified: boolean;
-        name: string;
-        image?: string | null | undefined;
-    }> | null;
-    session: import("better-auth").StripEmptyObjects<{
-        id: string;
-        createdAt: Date;
-        updatedAt: Date;
-        userId: string;
-        expiresAt: Date;
-        token: string;
-        ipAddress?: string | null | undefined;
-        userAgent?: string | null | undefined;
-    }> | null;
-    isPending: boolean;
-    isRefetching: boolean;
-    error: import("better-auth/react").BetterFetchError | null;
-    refetch: (queryParams?: {
-        query?: import("better-auth").SessionQueryParams;
-    } | undefined) => Promise<void>;
-    signIn: (input: FarmAuthCredentials) => Promise<{
-        data: Omit<{
-            redirect: boolean;
-            token: string;
-            url?: string | undefined;
-            user: {
-                id: string;
-                createdAt: Date;
-                updatedAt: Date;
-                email: string;
-                emailVerified: boolean;
-                name: string;
-                image?: string | null | undefined | undefined;
-            };
-        }, "user"> & {
-            user: import("better-auth").StripEmptyObjects<{
-                id: string;
-                createdAt: Date;
-                updatedAt: Date;
-                email: string;
-                emailVerified: boolean;
-                name: string;
-                image?: string | null | undefined;
-            }>;
-        };
-        error: null;
-    } | {
-        data: null;
-        error: {
-            code?: string | undefined | undefined;
-            message?: string | undefined | undefined;
-            status: number;
-            statusText: string;
-        };
-    }>;
-    signUp: (input: FarmAuthSignUpInput) => Promise<{
-        data: (Omit<{
-            token: null;
-            user: {
-                id: string;
-                createdAt: Date;
-                updatedAt: Date;
-                email: string;
-                emailVerified: boolean;
-                name: string;
-                image?: string | null | undefined | undefined;
-            };
-        }, "user"> & {
-            user: import("better-auth").StripEmptyObjects<{
-                id: string;
-                createdAt: Date;
-                updatedAt: Date;
-                email: string;
-                emailVerified: boolean;
-                name: string;
-                image?: string | null | undefined;
-            }>;
-        }) | (Omit<{
-            token: string;
-            user: {
-                id: string;
-                createdAt: Date;
-                updatedAt: Date;
-                email: string;
-                emailVerified: boolean;
-                name: string;
-                image?: string | null | undefined | undefined;
-            };
-        }, "user"> & {
-            user: import("better-auth").StripEmptyObjects<{
-                id: string;
-                createdAt: Date;
-                updatedAt: Date;
-                email: string;
-                emailVerified: boolean;
-                name: string;
-                image?: string | null | undefined;
-            }>;
-        });
-        error: null;
-    } | {
-        data: null;
-        error: {
-            code?: string | undefined | undefined;
-            message?: string | undefined | undefined;
-            status: number;
-            statusText: string;
-        };
-    }>;
-    signOut: () => Promise<{
-        data: {
-            success: boolean;
-            url: string | undefined;
-            redirect: boolean | undefined;
-        };
-        error: null;
-    } | {
-        data: null;
-        error: {
-            code?: string | undefined | undefined;
-            message?: string | undefined | undefined;
-            status: number;
-            statusText: string;
-        };
-    }>;
-};
-export type { FarmAuthClientOptions, FarmAuthCredentials, FarmAuthSignUpInput } from "./types.js";
-//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAElG,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,qBAA0B;oBAG/C,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAInB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0CilB,CAAC;;wBA9CrmB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAInB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmC3C;AAID,eAAO,MAAQ,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAE,MAAM,UA3CR,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2CT,OAAO;;;;;;;;;;;;;;;IAAE,MAAM,UAvCzB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuCQ,OAAO;;;;;;;;;;;;;;;;;;;;;;;;aAGkkB,CAAC;;oBA9CrmB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAInB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCiC,CAAC;AAE9E,YAAY,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC"}

package/dist/client.js

@@ -1,40 +0,0 @@
-"use client";
-import { createAuthClient } from "better-auth/react";
-export function createFarmAuthClient(options = {}) {
-    const client = createAuthClient(options);
-    function signIn(input) {
-        return client.signIn.email(input);
-    }
-    function signUp(input) {
-        return client.signUp.email(input);
-    }
-    function signOut() {
-        return client.signOut();
-    }
-    function getSession() {
-        return client.getSession();
-    }
-    function useAuth() {
-        const state = client.useSession();
-        return {
-            user: state.data?.user ?? null,
-            session: state.data?.session ?? null,
-            isPending: state.isPending,
-            isRefetching: state.isRefetching,
-            error: state.error,
-            refetch: state.refetch,
-            signIn,
-            signUp,
-            signOut,
-        };
-    }
-    return {
-        signIn,
-        signUp,
-        signOut,
-        getSession,
-        useAuth,
-    };
-}
-const defaultClient = createFarmAuthClient();
-export const { getSession, signIn, signOut, signUp, useAuth } = defaultClient;

package/dist/config.d.ts

@@ -1,3 +0,0 @@
-import type { FarmAuthUserConfig, ResolvedFarmAuthConfig } from "./types.js";
-export declare function resolveFarmAuthConfig(input: FarmAuthUserConfig | undefined): ResolvedFarmAuthConfig;
-//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAK7E,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,kBAAkB,GAAG,SAAS,GACpC,sBAAsB,CAiDxB"}

package/dist/config.js

@@ -1,106 +0,0 @@
-const DEFAULT_SESSION_EXPIRES_IN = 60 * 60 * 24 * 7;
-const DEFAULT_SESSION_UPDATE_AGE = 60 * 60 * 24;
-export function resolveFarmAuthConfig(input) {
-    if (input === false || input === undefined) {
-        return {
-            enabled: false,
-            basePath: "/api/auth",
-            emailAndPassword: {
-                enabled: true,
-                requireEmailVerification: false,
-                minPasswordLength: 8,
-                maxPasswordLength: 128,
-            },
-            session: {
-                expiresIn: DEFAULT_SESSION_EXPIRES_IN,
-                updateAge: DEFAULT_SESSION_UPDATE_AGE,
-            },
-            database: {
-                path: ".farm/auth.sqlite",
-                migrateInDevelopment: true,
-            },
-        };
-    }
-    const config = input === true ? {} : input;
-    const passwordConfig = typeof config.emailAndPassword === "object" ? config.emailAndPassword : {};
-    const basePath = normalizeBasePath(config.basePath);
-    const resolved = {
-        enabled: config.enabled !== false,
-        appName: config.appName,
-        basePath,
-        emailAndPassword: {
-            enabled: config.emailAndPassword !== false,
-            requireEmailVerification: passwordConfig.requireEmailVerification ?? false,
-            minPasswordLength: passwordConfig.minPasswordLength ?? 8,
-            maxPasswordLength: passwordConfig.maxPasswordLength ?? 128,
-        },
-        session: {
-            expiresIn: config.session?.expiresIn ?? DEFAULT_SESSION_EXPIRES_IN,
-            updateAge: config.session?.updateAge ?? DEFAULT_SESSION_UPDATE_AGE,
-        },
-        database: {
-            url: config.database?.url,
-            path: config.database?.path || ".farm/auth.sqlite",
-            migrateInDevelopment: config.database?.migrateInDevelopment ?? true,
-        },
-    };
-    validateFarmAuthConfig(resolved);
-    return resolved;
-}
-function normalizeBasePath(value) {
-    const route = (value || "/api/auth").trim();
-    if (!route)
-        return "/api/auth";
-    assertStableBasePath(route);
-    const withLeadingSlash = route.startsWith("/") ? route : `/${route}`;
-    const normalized = withLeadingSlash.replace(/\/+/g, "/").replace(/\/+$/, "");
-    return normalized || "/api/auth";
-}
-function assertStableBasePath(route) {
-    if (route.includes("?") || route.includes("#")) {
-        throw new Error("auth.basePath cannot contain a query string or fragment.");
-    }
-    if (route.startsWith("//") || /^[a-z][a-z\d+.-]*:\/\//i.test(route)) {
-        throw new Error('auth.basePath must be an application pathname such as "/api/auth".');
-    }
-    if (hasUnstablePathCharacters(route)) {
-        throw new Error("auth.basePath cannot contain backslashes or control characters.");
-    }
-    for (const segment of route.split("/")) {
-        let decoded = segment;
-        try {
-            decoded = decodeURIComponent(segment);
-        }
-        catch {
-            // Malformed escapes remain literal URL pathname segments.
-        }
-        if (hasUnstablePathCharacters(decoded) || decoded.includes("/")) {
-            throw new Error("auth.basePath cannot contain encoded path separators.");
-        }
-        if (decoded === "." || decoded === "..") {
-            throw new Error('auth.basePath cannot contain "." or ".." path segments.');
-        }
-    }
-}
-function hasUnstablePathCharacters(value) {
-    return (value.includes("\\") ||
-        Array.from(value).some((character) => {
-            const code = character.charCodeAt(0);
-            return code <= 31 || (code >= 127 && code <= 159);
-        }));
-}
-function validateFarmAuthConfig(config) {
-    const { minPasswordLength, maxPasswordLength } = config.emailAndPassword;
-    if (!Number.isInteger(minPasswordLength) || minPasswordLength < 1) {
-        throw new Error("auth.emailAndPassword.minPasswordLength must be a positive integer.");
-    }
-    if (!Number.isInteger(maxPasswordLength) || maxPasswordLength < minPasswordLength) {
-        throw new Error("auth.emailAndPassword.maxPasswordLength must be an integer greater than or equal to minPasswordLength.");
-    }
-    if (!Number.isInteger(config.session.expiresIn) || config.session.expiresIn < 1) {
-        throw new Error("auth.session.expiresIn must be a positive integer.");
-    }
-    if (!Number.isInteger(config.session.updateAge) || config.session.updateAge < 0) {
-        throw new Error("auth.session.updateAge must be a non-negative integer.");
-    }
-}

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-export { resolveFarmAuthConfig } from "./config.js";
-export type { FarmAuthConfig, FarmAuthClientOptions, FarmAuthCredentials, FarmAuthDatabaseConfig, FarmAuthEmailAndPasswordConfig, FarmAuthSession, FarmAuthSessionConfig, FarmAuthSessionData, FarmAuthSignUpInput, FarmAuthUser, FarmAuthUserConfig, ResolvedFarmAuthConfig, } from "./types.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,YAAY,EACV,cAAc,EACd,qBAAqB,EACrB,mBAAmB,EACnB,sBAAsB,EACtB,8BAA8B,EAC9B,eAAe,EACf,qBAAqB,EACrB,mBAAmB,EACnB,mBAAmB,EACnB,YAAY,EACZ,kBAAkB,EAClB,sBAAsB,GACvB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1 +0,0 @@
-export { resolveFarmAuthConfig } from "./config.js";

package/dist/internal.d.ts

@@ -1,24 +0,0 @@
-import type { ResolvedFarmAuthConfig } from "./types.js";
-interface FarmAuthIntegrationOptions {
-    root: string;
-    mode: "development" | "production";
-}
-interface FarmAuthIntegration {
-    readonly kind: "farm-integration";
-    category: "auth";
-    type: "farm-auth";
-    instance: {
-        readonly kind: "farm-auth-runtime";
-    };
-    routes: Array<{
-        path: string;
-        methods: readonly ["GET", "POST"];
-        handler(request: Request): Promise<Response>;
-    }>;
-}
-export declare function createFarmAuthIntegration(config: ResolvedFarmAuthConfig, options: FarmAuthIntegrationOptions): FarmAuthIntegration;
-export declare function migrateFarmAuth(): Promise<void>;
-export declare function compileFarmAuthMigration(): Promise<string>;
-export declare function disposeFarmAuth(): Promise<void>;
-export {};
-//# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AASzD,UAAU,0BAA0B;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,GAAG,YAAY,CAAC;CACpC;AAED,UAAU,mBAAmB;IAC3B,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAA;KAAE,CAAC;IACjD,MAAM,EAAE,KAAK,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QAClC,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;KAC9C,CAAC,CAAC;CACJ;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,sBAAsB,EAC9B,OAAO,EAAE,0BAA0B,GAClC,mBAAmB,CAmBrB;AAED,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAErD;AAED,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,MAAM,CAAC,CAEhE;AAED,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAErD"}

package/dist/internal.js

@@ -1,29 +0,0 @@
-import { configureFarmAuth, disposeFarmAuth as runDispose, getFarmAuthRuntime, migrateFarmAuth as runMigration, compileFarmAuthMigration as runCompileMigration, } from "./runtime.js";
-export function createFarmAuthIntegration(config, options) {
-    configureFarmAuth(config, options);
-    return {
-        kind: "farm-integration",
-        category: "auth",
-        type: "farm-auth",
-        instance: Object.freeze({ kind: "farm-auth-runtime" }),
-        routes: [
-            {
-                path: `${config.basePath}/[...auth]`,
-                methods: ["GET", "POST"],
-                async handler(request) {
-                    const runtime = await getFarmAuthRuntime();
-                    return runtime.handler(request);
-                },
-            },
-        ],
-    };
-}
-export async function migrateFarmAuth() {
-    await runMigration();
-}
-export async function compileFarmAuthMigration() {
-    return runCompileMigration();
-}
-export async function disposeFarmAuth() {
-    await runDispose();
-}

package/dist/runtime.d.ts

@@ -1,53 +0,0 @@
-import type { ResolvedFarmAuthConfig } from "./types.js";
-interface FarmAuthRuntimeOptions {
-    root: string;
-    mode: "development" | "production";
-}
-interface BetterAuthRuntime {
-    handler(request: Request): Promise<Response>;
-    api: {
-        getSession(input: {
-            headers: Headers;
-        }): Promise<unknown>;
-    };
-}
-export declare function configureFarmAuth(config: ResolvedFarmAuthConfig, options: FarmAuthRuntimeOptions): void;
-export declare function getFarmAuthRuntime(): Promise<BetterAuthRuntime>;
-export declare function getFarmAuthRequest(request?: Request): Request;
-/**
- * Close the connection opened for the runtime and drop the cached instance.
- *
- * The runtime is cached on globalThis and its connection stays open for the life
- * of the process, which leaves a file lock behind on SQLite and a pool open on
- * every other driver. Call this from a teardown hook.
- */
-export declare function disposeFarmAuth(): Promise<void>;
-export declare function migrateFarmAuth(): Promise<void>;
-/**
- * The statements `migrateFarmAuth` would run, for review before applying them.
- * Better Auth owns the schema, so the sql comes from its migrator rather than
- * from Farm's own table declarations.
- */
-export declare function compileFarmAuthMigration(): Promise<string>;
-/**
- * The origin Better Auth signs cookies and validates requests against.
- *
- * Better Auth trusts the baseURL's own origin and rejects everything else
- * with INVALID_ORIGIN, so this has to resolve to the host users actually
- * visit. Vercel exposes two: `VERCEL_URL` is unique per deployment
- * (`my-app-a1b2c3.vercel.app`) while `VERCEL_PROJECT_PRODUCTION_URL` is the
- * project's canonical domain. Pinning a production deployment to its
- * per-deployment hostname rejects every request arriving on the real domain,
- * so production prefers the canonical one and previews keep their own URL.
- */
-export declare function resolveFarmAuthBaseURL(mode: "development" | "production", env?: NodeJS.ProcessEnv): string | undefined;
-/**
- * Hosts that stay valid alongside the base URL.
- *
- * A production deployment is still reachable at its own deployment hostname,
- * and previews get a fresh one per build, so both are trusted explicitly
- * rather than leaving direct deployment-URL access broken.
- */
-export declare function resolveFarmAuthTrustedOrigins(env?: NodeJS.ProcessEnv): string[];
-export {};
-//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAMzD,UAAU,sBAAsB;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,GAAG,YAAY,CAAC;CACpC;AAED,UAAU,iBAAiB;IACzB,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC7C,GAAG,EAAE;QACH,UAAU,CAAC,KAAK,EAAE;YAAE,OAAO,EAAE,OAAO,CAAA;SAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;KAC3D,CAAC;CACH;AAqBD,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,sBAAsB,EAC9B,OAAO,EAAE,sBAAsB,GAC9B,IAAI,CAeN;AAED,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,iBAAiB,CAAC,CA6BrE;AAED,wBAAgB,kBAAkB,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAU7D;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CASrD;AAED,wBAAsB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAIrD;AAED;;;;GAIG;AACH,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,MAAM,CAAC,CAEhE;AA4ED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,aAAa,GAAG,YAAY,EAClC,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,MAAM,GAAG,SAAS,CAWpB;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,EAAE,CAM5F"}

package/dist/runtime.js

@@ -1,226 +0,0 @@
-import { mkdir } from "node:fs/promises";
-import { createRequire } from "node:module";
-import path from "node:path";
-const FARM_AUTH_STATE_KEY = Symbol.for("@farm.js/auth/runtime");
-const CURRENT_REQUEST_RESOLVER_KEY = Symbol.for("farm.currentRequestResolver");
-const loadNodeModule = createRequire(import.meta.url);
-function getState() {
-    const runtime = globalThis;
-    runtime[FARM_AUTH_STATE_KEY] ||= {};
-    return runtime[FARM_AUTH_STATE_KEY];
-}
-export function configureFarmAuth(config, options) {
-    const state = getState();
-    const changed = JSON.stringify(state.config) !== JSON.stringify(config) ||
-        state.options?.root !== options.root ||
-        state.options?.mode !== options.mode;
-    state.config = config;
-    state.options = options;
-    if (changed) {
-        const previous = state.database;
-        state.runtime = undefined;
-        state.database = undefined;
-        if (previous)
-            void closeDatabase(previous).catch(() => { });
-    }
-}
-export async function getFarmAuthRuntime() {
-    const state = getState();
-    if (!state.config?.enabled || !state.options) {
-        throw new Error("Farm Auth is not enabled. Add `auth: true` to farm.config.ts before using @farm.js/auth.");
-    }
-    if (!state.runtime) {
-        const runtime = createRuntime(state.config, state.options, (database) => {
-            // A dispose or reconfigure that raced this creation already closed what it
-            // knew about, so an orphaned connection closes itself instead of leaking.
-            if (state.runtime === runtime) {
-                state.database = database;
-            }
-            else {
-                void closeDatabase(database).catch(() => { });
-            }
-        });
-        state.runtime = runtime;
-        void runtime.catch(() => {
-            if (state.runtime === runtime) {
-                state.runtime = undefined;
-                const database = state.database;
-                state.database = undefined;
-                if (database)
-                    void closeDatabase(database).catch(() => { });
-            }
-        });
-    }
-    return state.runtime;
-}
-export function getFarmAuthRequest(request) {
-    if (request)
-        return request;
-    const current = globalThis[CURRENT_REQUEST_RESOLVER_KEY]?.();
-    if (!current) {
-        throw new Error("No current request is available. Farm Auth server helpers can only be used during a request, or with an explicit `request` option.");
-    }
-    return current;
-}
-/**
- * Close the connection opened for the runtime and drop the cached instance.
- *
- * The runtime is cached on globalThis and its connection stays open for the life
- * of the process, which leaves a file lock behind on SQLite and a pool open on
- * every other driver. Call this from a teardown hook.
- */
-export async function disposeFarmAuth() {
-    const state = getState();
-    // Let an in-flight creation finish so its connection is registered and closed
-    // here, instead of resolving before the handle even exists.
-    if (state.runtime)
-        await state.runtime.catch(() => { });
-    const database = state.database;
-    state.runtime = undefined;
-    state.database = undefined;
-    await closeDatabase(database);
-}
-export async function migrateFarmAuth() {
-    await withAuthMigrations(async (migrations) => {
-        await migrations.runMigrations();
-    });
-}
-/**
- * The statements `migrateFarmAuth` would run, for review before applying them.
- * Better Auth owns the schema, so the sql comes from its migrator rather than
- * from Farm's own table declarations.
- */
-export async function compileFarmAuthMigration() {
-    return withAuthMigrations((migrations) => migrations.compileMigrations());
-}
-async function withAuthMigrations(use) {
-    const state = getState();
-    if (!state.config?.enabled || !state.options) {
-        throw new Error("Farm Auth is not enabled in farm.config.ts.");
-    }
-    const options = await createBetterAuthOptions(state.config, state.options, {
-        migration: true,
-    });
-    const { getMigrations } = await import("better-auth/db/migration");
-    try {
-        return await use(await getMigrations(options));
-    }
-    finally {
-        await closeDatabase(options.database);
-    }
-}
-async function createRuntime(config, options, onDatabase) {
-    const authOptions = await createBetterAuthOptions(config, options);
-    onDatabase(authOptions.database);
-    if (options.mode === "development" && config.database.migrateInDevelopment) {
-        const { getMigrations } = await import("better-auth/db/migration");
-        const migrations = await getMigrations(authOptions);
-        await migrations.runMigrations();
-    }
-    const { betterAuth } = await import("better-auth");
-    return betterAuth(authOptions);
-}
-async function createBetterAuthOptions(config, options, runtimeOptions = {}) {
-    const secret = process.env.FARM_AUTH_SECRET || process.env.AUTH_SECRET || process.env.BETTER_AUTH_SECRET;
-    if (options.mode === "production" && !secret && !runtimeOptions.migration) {
-        throw new Error("Farm Auth requires FARM_AUTH_SECRET (or AUTH_SECRET) in production. Generate a random 32-byte secret and add it to your deployment environment.");
-    }
-    return {
-        appName: config.appName || "Farm app",
-        baseURL: resolveFarmAuthBaseURL(options.mode),
-        trustedOrigins: resolveFarmAuthTrustedOrigins(),
-        basePath: config.basePath,
-        secret: secret || "farm-auth-development-or-migration-secret",
-        database: await createDatabase(config, options),
-        emailAndPassword: {
-            enabled: config.emailAndPassword.enabled,
-            requireEmailVerification: config.emailAndPassword.requireEmailVerification,
-            minPasswordLength: config.emailAndPassword.minPasswordLength,
-            maxPasswordLength: config.emailAndPassword.maxPasswordLength,
-        },
-        session: {
-            expiresIn: config.session.expiresIn,
-            updateAge: config.session.updateAge,
-        },
-    };
-}
-/**
- * The origin Better Auth signs cookies and validates requests against.
- *
- * Better Auth trusts the baseURL's own origin and rejects everything else
- * with INVALID_ORIGIN, so this has to resolve to the host users actually
- * visit. Vercel exposes two: `VERCEL_URL` is unique per deployment
- * (`my-app-a1b2c3.vercel.app`) while `VERCEL_PROJECT_PRODUCTION_URL` is the
- * project's canonical domain. Pinning a production deployment to its
- * per-deployment hostname rejects every request arriving on the real domain,
- * so production prefers the canonical one and previews keep their own URL.
- */
-export function resolveFarmAuthBaseURL(mode, env = process.env) {
-    const configured = env.FARM_AUTH_URL || env.BETTER_AUTH_URL;
-    if (configured)
-        return configured;
-    const vercelHost = env.VERCEL_ENV === "production"
-        ? env.VERCEL_PROJECT_PRODUCTION_URL || env.VERCEL_URL
-        : env.VERCEL_URL;
-    if (vercelHost)
-        return toAbsoluteOrigin(vercelHost);
-    return mode === "development" ? "http://localhost:3000" : undefined;
-}
-/**
- * Hosts that stay valid alongside the base URL.
- *
- * A production deployment is still reachable at its own deployment hostname,
- * and previews get a fresh one per build, so both are trusted explicitly
- * rather than leaving direct deployment-URL access broken.
- */
-export function resolveFarmAuthTrustedOrigins(env = process.env) {
-    const origins = new Set();
-    for (const host of [env.VERCEL_URL, env.VERCEL_PROJECT_PRODUCTION_URL, env.VERCEL_BRANCH_URL]) {
-        if (host)
-            origins.add(toAbsoluteOrigin(host));
-    }
-    return [...origins];
-}
-function toAbsoluteOrigin(host) {
-    return host.startsWith("http://") || host.startsWith("https://") ? host : `https://${host}`;
-}
-async function closeDatabase(database) {
-    if (!database || typeof database !== "object")
-        return;
-    const connection = database;
-    if (typeof connection.end === "function") {
-        await connection.end();
-        return;
-    }
-    if (typeof connection.close === "function") {
-        await connection.close();
-    }
-}
-async function createDatabase(config, options) {
-    const databaseUrl = config.database.url || process.env.DATABASE_URL;
-    if (databaseUrl) {
-        const { Pool } = await import("pg");
-        return new Pool({ connectionString: databaseUrl });
-    }
-    if (options.mode === "production") {
-        throw new Error("Farm Auth requires DATABASE_URL in production. Config loading and `farm build` do not connect to the database; the connection is opened only by auth requests or `farm auth migrate`.");
-    }
-    const databasePath = path.resolve(options.root, config.database.path);
-    await mkdir(path.dirname(databasePath), { recursive: true });
-    try {
-        const { DatabaseSync } = loadNodeModule("node:sqlite");
-        return new DatabaseSync(databasePath);
-    }
-    catch {
-        // node:sqlite is available on Node 22+. Keep the native package fallback
-        // for supported older Node releases.
-    }
-    try {
-        const imported = await import("better-sqlite3");
-        const Database = imported.default;
-        return new Database(databasePath);
-    }
-    catch (error) {
-        throw new Error(`Farm Auth could not open its local SQLite database. Install better-sqlite3 or set DATABASE_URL. ${error instanceof Error ? error.message : String(error)}`);
-    }
-}

package/dist/server.d.ts

@@ -1,19 +0,0 @@
-import type { FarmAuthLookupOptions, FarmAuthSession, FarmAuthUser } from "./types.js";
-/**
- * Farm Auth server helpers. Use `required: true` when anonymous access should
- * immediately return a 401 response.
- */
-declare function session(options: FarmAuthLookupOptions & {
-    required: true;
-}): Promise<FarmAuthSession>;
-declare function session(options?: FarmAuthLookupOptions): Promise<FarmAuthSession | null>;
-declare function user(options: FarmAuthLookupOptions & {
-    required: true;
-}): Promise<FarmAuthUser>;
-declare function user(options?: FarmAuthLookupOptions): Promise<FarmAuthUser | null>;
-export declare const auth: {
-    session: typeof session;
-    user: typeof user;
-};
-export type { FarmAuthLookupOptions, FarmAuthSession, FarmAuthSessionData, FarmAuthUser, } from "./types.js";
-//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAsBvF;;;GAGG;AACH,iBAAS,OAAO,CAAC,OAAO,EAAE,qBAAqB,GAAG;IAAE,QAAQ,EAAE,IAAI,CAAA;CAAE,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;AAChG,iBAAS,OAAO,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;AAKnF,iBAAS,IAAI,CAAC,OAAO,EAAE,qBAAqB,GAAG;IAAE,QAAQ,EAAE,IAAI,CAAA;CAAE,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAC1F,iBAAS,IAAI,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;AAK7E,eAAO,MAAM,IAAI;;;CAAoB,CAAC;AAEtC,YAAY,EACV,qBAAqB,EACrB,eAAe,EACf,mBAAmB,EACnB,YAAY,GACb,MAAM,YAAY,CAAC"}

package/dist/server.js

@@ -1,22 +0,0 @@
-import { getFarmAuthRequest, getFarmAuthRuntime } from "./runtime.js";
-async function readSession(options = {}) {
-    const request = getFarmAuthRequest(options.request);
-    const runtime = await getFarmAuthRuntime();
-    const session = (await runtime.api.getSession({
-        headers: request.headers,
-    }));
-    if (!session && options.required) {
-        throw Response.json({
-            error: "Authentication required",
-            code: "FARM_AUTH_REQUIRED",
-        }, { status: 401 });
-    }
-    return session;
-}
-function session(options) {
-    return readSession(options);
-}
-async function user(options) {
-    return (await readSession(options))?.user ?? null;
-}
-export const auth = { session, user };

package/dist/types.d.ts

@@ -1,105 +0,0 @@
-export interface FarmAuthEmailAndPasswordConfig {
-    /** Require a verified email before creating a session. @default false */
-    requireEmailVerification?: boolean;
-    /** Smallest accepted password length. @default 8 */
-    minPasswordLength?: number;
-    /** Largest accepted password length. @default 128 */
-    maxPasswordLength?: number;
-}
-export interface FarmAuthSessionConfig {
-    /** Session lifetime in seconds. @default 604800 */
-    expiresIn?: number;
-    /** Session refresh interval in seconds. @default 86400 */
-    updateAge?: number;
-}
-export interface FarmAuthDatabaseConfig {
-    /**
-     * Postgres connection string. Defaults to DATABASE_URL.
-     * Local development falls back to SQLite when no URL is present.
-     */
-    url?: string;
-    /** Local SQLite path. @default ".farm/auth.sqlite" */
-    path?: string;
-    /** Automatically update the schema in development. @default true */
-    migrateInDevelopment?: boolean;
-}
-export interface FarmAuthConfig {
-    /** Set false to disable auth without removing its configuration. @default true */
-    enabled?: boolean;
-    /** Display name used by authentication emails and metadata. */
-    appName?: string;
-    /** Route prefix for the auth endpoints. @default "/api/auth" */
-    basePath?: string;
-    /**
-     * Email/password authentication. It is enabled by default; set false to
-     * disable it when adding another sign-in method.
-     */
-    emailAndPassword?: boolean | FarmAuthEmailAndPasswordConfig;
-    session?: FarmAuthSessionConfig;
-    database?: FarmAuthDatabaseConfig;
-}
-export type FarmAuthUserConfig = boolean | FarmAuthConfig;
-export interface ResolvedFarmAuthConfig {
-    enabled: boolean;
-    appName?: string;
-    basePath: string;
-    emailAndPassword: {
-        enabled: boolean;
-        requireEmailVerification: boolean;
-        minPasswordLength: number;
-        maxPasswordLength: number;
-    };
-    session: {
-        expiresIn: number;
-        updateAge: number;
-    };
-    database: {
-        url?: string;
-        path: string;
-        migrateInDevelopment: boolean;
-    };
-}
-export interface FarmAuthUser {
-    id: string;
-    name: string;
-    email: string;
-    emailVerified: boolean;
-    image?: string | null;
-    createdAt: Date;
-    updatedAt: Date;
-}
-export interface FarmAuthSessionData {
-    id: string;
-    userId: string;
-    expiresAt: Date;
-    token: string;
-    createdAt: Date;
-    updatedAt: Date;
-    ipAddress?: string | null;
-    userAgent?: string | null;
-}
-export interface FarmAuthSession {
-    session: FarmAuthSessionData;
-    user: FarmAuthUser;
-}
-export interface FarmAuthLookupOptions {
-    /** Return a 401 Response when no session exists. */
-    required?: boolean;
-    /** Override the current Farm request, primarily for route handlers and tests. */
-    request?: Request;
-}
-export interface FarmAuthCredentials {
-    email: string;
-    password: string;
-    rememberMe?: boolean;
-}
-export interface FarmAuthSignUpInput extends FarmAuthCredentials {
-    name: string;
-}
-export interface FarmAuthClientOptions {
-    /** Must match auth.basePath when that option is customized. */
-    basePath?: string;
-    /** Optional absolute origin for non-browser clients. */
-    baseURL?: string;
-}
-//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -1 +0,0 @@
-export {};