@farm.js/auth0 0.1.0-beta.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 Farm.js Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,11 @@
+# @farm.js/auth0
+
+Auth0 integration for Farm.js
+
+Farm.js is currently in beta.
+
+```bash
+npm install @farm.js/auth0@beta
+```
+
+See the [Farm.js repository](https://github.com/farming-labs/farm.js) for documentation, examples, and support.

package/dist/client.d.ts

@@ -0,0 +1,17 @@
+export interface Auth0RedirectQuery {
+    returnTo?: string;
+}
+export interface Auth0RedirectResult {
+    redirectTo: string;
+}
+export interface Auth0ProfileResult {
+    authenticated: boolean;
+    user?: Record<string, unknown>;
+}
+export declare const auth0Client: {
+    login: import("@farm.js/core/client").FarmIntegrationAPIOperation<never, Auth0RedirectQuery, Auth0RedirectResult, false, "GET">;
+    signup: import("@farm.js/core/client").FarmIntegrationAPIOperation<never, Auth0RedirectQuery, Auth0RedirectResult, false, "GET">;
+    logout: import("@farm.js/core/client").FarmIntegrationAPIOperation<never, never, Auth0RedirectResult, false, "GET">;
+    profile: import("@farm.js/core/client").FarmIntegrationAPIOperation<never, never, Auth0ProfileResult, false, "GET">;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,OAAO,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,eAAO,MAAM,WAAW;;;;;CAavB,CAAC"}

package/dist/client.js

@@ -0,0 +1,15 @@
+import { api } from "@farm.js/core/client";
+export const auth0Client = {
+    login: api.get("/auth/login", {
+        responseFormat: "json",
+    }),
+    signup: api.get("/auth/signup", {
+        responseFormat: "json",
+    }),
+    logout: api.get("/auth/logout", {
+        responseFormat: "json",
+    }),
+    profile: api.get("/auth/profile", {
+        responseFormat: "json",
+    }),
+};

package/dist/index.d.ts

@@ -0,0 +1,89 @@
+import { type FarmIntegrationLogger } from "@farm.js/core";
+export interface Auth0Instance {
+    middleware(request: Request): Promise<Response | void> | Response | void;
+    matcher?: string | string[];
+}
+export interface Auth0IntegrationInput {
+    instance?: Auth0Instance;
+    domain?: string;
+    clientId?: string;
+    clientSecret?: string;
+    secret?: string;
+    appBaseUrl?: string;
+    callbackUrl?: string;
+    loginPath?: string;
+    signUpPath?: string;
+    callbackPath?: string;
+    logoutPath?: string;
+    profilePath?: string;
+    protectedRoutes?: string | string[];
+    audience?: string;
+    scopes?: string[];
+    tokenEndpointAuthMethod?: "auto" | "client_secret_basic" | "client_secret_post" | "none";
+    log?: FarmIntegrationLogger;
+}
+interface ResolvedAuth0Env {
+    domain: string;
+    clientId: string;
+    clientSecret?: string;
+    secret: string;
+    appBaseUrl?: string;
+}
+export declare function auth0(input?: Auth0IntegrationInput): import("@farm.js/core").DefinedIntegration<{
+    category: "auth";
+    type: string;
+    instance: Auth0Instance;
+    log: FarmIntegrationLogger | undefined;
+    middleware: {
+        matcher: string | string[];
+        handler(request: Request): void | Response | Promise<void | Response>;
+    }[];
+}> | import("@farm.js/core").DefinedIntegration<{
+    category: "auth";
+    type: string;
+    instance: {
+        domain: string;
+        clientId: string;
+        protectedRoutes: string[];
+    };
+    config: import("@farm.js/core").FarmIntegrationConfigDefinition<ResolvedAuth0Env, import("@farm.js/core").FarmIntegrationSchema | undefined>;
+    api: {
+        [x: string]: {
+            get: {
+                readonly kind: "farm-integration-api-operation";
+                path: string;
+                method: "GET";
+                bodyFormat?: import("@farm.js/core/client").FarmIntegrationAPIBodyFormat | undefined;
+                responseFormat?: import("@farm.js/core/client").FarmIntegrationAPIResponseFormat | undefined;
+                headers?: {
+                    [x: string]: string;
+                } | undefined;
+                credentials?: RequestCredentials | undefined;
+                isServer?: false | undefined;
+                __pathless?: boolean | undefined;
+                __types?: {
+                    body: never;
+                    query: never;
+                    response: {
+                        redirectTo: string;
+                        authenticated: boolean;
+                        user?: {
+                            [x: string]: unknown;
+                        } | undefined;
+                    };
+                } | undefined;
+            };
+        };
+    };
+    log: FarmIntegrationLogger | undefined;
+    documentNavigations: {
+        matcher: string[];
+    }[];
+    routes: import("@farm.js/core").FarmTypedIntegrationRoute<string, never, any, unknown, false, "GET", import("@farm.js/core").FarmIntegrationSchema | undefined>[];
+    middleware: {
+        matcher: string[];
+        handler(request: Request): Response | undefined;
+    }[];
+}>;
+export {};
+//# 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":"AACA,OAAO,EAAuC,KAAK,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAkBhG,MAAM,WAAW,aAAa;IAC5B,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,QAAQ,GAAG,IAAI,CAAC;IACzE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,uBAAuB,CAAC,EAAE,MAAM,GAAG,qBAAqB,GAAG,oBAAoB,GAAG,MAAM,CAAC;IACzF,GAAG,CAAC,EAAE,qBAAqB,CAAC;CAC7B;AAED,UAAU,gBAAgB;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AA2PD,wBAAgB,KAAK,CAAC,KAAK,GAAE,qBAA0B;;;;;;;yBAU5B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA6QH,OAAO;;GAmBrC"}

package/dist/index.js

@@ -0,0 +1,393 @@
+import { createHash, createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { defineIntegration, integrationRoute } from "@farm.js/core";
+import { clearRequestCookie, createPathInferredClientApi, createDocumentNavigationMatchers, createRequestCookie, getOrigin, getReturnTo, integrationConfig, normalizeMatchers, parseCookieHeaderMap, resolveCallbackSettings, } from "@farm.js/integration-utils";
+import { auth0Client } from "./client.js";
+const DEV_SECRET = "farmjs-auth0-development-secret-2026";
+function createAuth0Api(input) {
+    return createPathInferredClientApi({
+        path: input.loginPath,
+        operation: auth0Client.login,
+    }, {
+        path: input.signUpPath,
+        operation: auth0Client.signup,
+    }, {
+        path: input.logoutPath,
+        operation: auth0Client.logout,
+    }, {
+        path: input.profilePath,
+        operation: auth0Client.profile,
+    });
+}
+function normalizeDomain(value) {
+    return value.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+}
+function resolveEnv(input) {
+    const domain = normalizeDomain(input.domain ?? process.env.AUTH0_DOMAIN ?? "");
+    const clientId = input.clientId ?? process.env.AUTH0_CLIENT_ID ?? "";
+    const clientSecret = input.clientSecret ?? process.env.AUTH0_CLIENT_SECRET ?? "";
+    const secret = input.secret ??
+        process.env.AUTH0_SECRET ??
+        (process.env.NODE_ENV === "production" ? "" : DEV_SECRET);
+    const appBaseUrl = input.appBaseUrl ?? process.env.APP_BASE_URL ?? undefined;
+    if (!domain || !clientId) {
+        throw new Error("Auth0 integration requires AUTH0_DOMAIN and AUTH0_CLIENT_ID.");
+    }
+    if (!secret) {
+        throw new Error("Auth0 integration requires AUTH0_SECRET in production.");
+    }
+    return {
+        domain,
+        clientId,
+        clientSecret: clientSecret || undefined,
+        secret,
+        appBaseUrl,
+    };
+}
+function createCodeVerifier() {
+    return randomBytes(32).toString("base64url");
+}
+function createCodeChallenge(verifier) {
+    return createHash("sha256").update(verifier).digest("base64url");
+}
+function signValue(value, secret) {
+    const payload = Buffer.from(JSON.stringify(value), "utf8").toString("base64url");
+    const signature = createHmac("sha256", secret).update(payload).digest("hex");
+    return `${payload}.${signature}`;
+}
+function unsignValue(signed, secret) {
+    if (!signed) {
+        return null;
+    }
+    const separator = signed.lastIndexOf(".");
+    if (separator === -1) {
+        return null;
+    }
+    const payload = signed.slice(0, separator);
+    const signature = signed.slice(separator + 1);
+    const expected = createHmac("sha256", secret).update(payload).digest("hex");
+    if (signature.length !== expected.length) {
+        return null;
+    }
+    if (!timingSafeEqual(Buffer.from(signature, "utf8"), Buffer.from(expected, "utf8"))) {
+        return null;
+    }
+    try {
+        return JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function decodeJwtPayload(token) {
+    if (!token) {
+        return null;
+    }
+    const parts = token.split(".");
+    if (parts.length < 2) {
+        return null;
+    }
+    try {
+        return JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function getSession(request, cookieName, secret) {
+    const cookies = parseCookieHeaderMap(request.headers.get("cookie"));
+    const session = unsignValue(cookies[cookieName], secret);
+    if (!session) {
+        return null;
+    }
+    if (session.expiresAt <= Date.now()) {
+        return null;
+    }
+    return session;
+}
+async function createUserProfile(domain, accessToken, idToken) {
+    if (accessToken) {
+        const response = await fetch(`https://${domain}/userinfo`, {
+            headers: {
+                authorization: `Bearer ${accessToken}`,
+            },
+        });
+        if (response.ok) {
+            return (await response.json());
+        }
+    }
+    return decodeJwtPayload(idToken) || {};
+}
+async function exchangeCode(domain, clientId, clientSecret, code, redirectUri, codeVerifier, tokenEndpointAuthMethod = "auto") {
+    const methods = tokenEndpointAuthMethod && tokenEndpointAuthMethod !== "auto"
+        ? [tokenEndpointAuthMethod]
+        : clientSecret
+            ? ["client_secret_basic", "client_secret_post", "none"]
+            : ["none"];
+    let lastFailure = "Auth0 token exchange failed.";
+    for (const method of methods) {
+        if ((method === "client_secret_basic" || method === "client_secret_post") && !clientSecret) {
+            continue;
+        }
+        const body = new URLSearchParams({
+            grant_type: "authorization_code",
+            code,
+            redirect_uri: redirectUri,
+            client_id: clientId,
+            code_verifier: codeVerifier,
+        });
+        const headers = new Headers({
+            "content-type": "application/x-www-form-urlencoded",
+        });
+        if (method === "client_secret_post") {
+            body.set("client_secret", clientSecret);
+        }
+        if (method === "client_secret_basic") {
+            headers.set("authorization", `Basic ${Buffer.from(`${clientId}:${clientSecret}`, "utf8").toString("base64")}`);
+            body.delete("client_id");
+        }
+        const response = await fetch(`https://${domain}/oauth/token`, {
+            method: "POST",
+            headers,
+            body,
+        });
+        if (response.ok) {
+            return (await response.json());
+        }
+        const message = await response.text();
+        lastFailure = message || "Auth0 token exchange failed.";
+        // Retry only when Auth0 is rejecting the client authentication method.
+        if (response.status === 401 || response.status === 403) {
+            continue;
+        }
+        throw new Error(lastFailure);
+    }
+    throw new Error(lastFailure);
+}
+export function auth0(input = {}) {
+    if (input.instance) {
+        return defineIntegration({
+            category: "auth",
+            type: "auth0",
+            instance: input.instance,
+            log: input.log,
+            middleware: [
+                {
+                    matcher: input.instance.matcher || ["/auth(.*)"],
+                    handler(request) {
+                        return input.instance.middleware(request);
+                    },
+                },
+            ],
+        });
+    }
+    const { domain, clientId, clientSecret, secret, appBaseUrl } = resolveEnv(input);
+    const protectedMatchers = normalizeMatchers(input.protectedRoutes);
+    const loginPath = input.loginPath ?? "/auth/login";
+    const signUpPath = input.signUpPath ?? "/auth/signup";
+    const logoutPath = input.logoutPath ?? "/auth/logout";
+    const profilePath = input.profilePath ?? "/auth/profile";
+    const scopes = input.scopes?.length ? input.scopes : ["openid", "profile", "email"];
+    const stateCookieName = "farm_auth0_state";
+    const sessionCookieName = "farm_auth0_session";
+    const callbackSettings = resolveCallbackSettings({
+        callbackUrl: input.callbackUrl,
+        callbackPath: input.callbackPath,
+        defaultPath: "/auth/callback",
+        label: "Auth0 integration",
+    }, appBaseUrl);
+    const callbackPath = callbackSettings.callbackPath;
+    async function redirectToAuth(request, screenHint) {
+        const requestUrl = new URL(request.url);
+        const callbackUrl = callbackSettings.getCallbackUrl(request);
+        const returnTo = getReturnTo(requestUrl.searchParams.get("returnTo"), "/dashboard");
+        const state = randomBytes(16).toString("hex");
+        const codeVerifier = createCodeVerifier();
+        const codeChallenge = createCodeChallenge(codeVerifier);
+        const authorizeUrl = new URL("/authorize", `https://${domain}`);
+        authorizeUrl.searchParams.set("response_type", "code");
+        authorizeUrl.searchParams.set("client_id", clientId);
+        authorizeUrl.searchParams.set("redirect_uri", callbackUrl);
+        authorizeUrl.searchParams.set("scope", scopes.join(" "));
+        authorizeUrl.searchParams.set("state", state);
+        authorizeUrl.searchParams.set("code_challenge", codeChallenge);
+        authorizeUrl.searchParams.set("code_challenge_method", "S256");
+        if (input.audience) {
+            authorizeUrl.searchParams.set("audience", input.audience);
+        }
+        if (screenHint) {
+            authorizeUrl.searchParams.set("screen_hint", screenHint);
+        }
+        const headers = new Headers();
+        headers.append("set-cookie", createRequestCookie(stateCookieName, signValue({ state, returnTo, codeVerifier }, secret), request, { maxAge: 600 }));
+        return {
+            redirectTo: authorizeUrl.toString(),
+            headers,
+        };
+    }
+    return defineIntegration({
+        category: "auth",
+        type: "auth0",
+        instance: {
+            domain,
+            clientId,
+            protectedRoutes: protectedMatchers,
+        },
+        config: integrationConfig({
+            label: "Auth0 integration",
+            env: {
+                domain: "AUTH0_DOMAIN",
+                clientId: "AUTH0_CLIENT_ID",
+                clientSecret: "AUTH0_CLIENT_SECRET",
+                secret: "AUTH0_SECRET",
+                appBaseUrl: "APP_BASE_URL",
+            },
+            input: {
+                domain,
+                clientId,
+                clientSecret,
+                secret,
+                appBaseUrl,
+            },
+            required: ["domain", "clientId", "secret"],
+        }),
+        api: createAuth0Api({
+            loginPath,
+            signUpPath,
+            logoutPath,
+            profilePath,
+        }),
+        log: input.log,
+        documentNavigations: [
+            {
+                matcher: createDocumentNavigationMatchers(loginPath, signUpPath, callbackPath, logoutPath),
+            },
+        ],
+        routes: [
+            integrationRoute.get(loginPath, {
+                responseFormat: "json",
+                async handler(request) {
+                    const result = await redirectToAuth(request);
+                    const headers = result.headers;
+                    const redirectTo = result.redirectTo;
+                    if (request.headers.get("x-farm-integration-client") === "1") {
+                        return Response.json({ redirectTo }, { status: 200, headers });
+                    }
+                    headers.set("location", redirectTo);
+                    return new Response(null, {
+                        status: 302,
+                        headers,
+                    });
+                },
+            }),
+            integrationRoute.get(signUpPath, {
+                responseFormat: "json",
+                async handler(request) {
+                    const result = await redirectToAuth(request, "signup");
+                    const headers = result.headers;
+                    const redirectTo = result.redirectTo;
+                    if (request.headers.get("x-farm-integration-client") === "1") {
+                        return Response.json({ redirectTo }, { status: 200, headers });
+                    }
+                    headers.set("location", redirectTo);
+                    return new Response(null, {
+                        status: 302,
+                        headers,
+                    });
+                },
+            }),
+            integrationRoute.get(callbackPath, {
+                handler(request) {
+                    return (async () => {
+                        const requestUrl = new URL(request.url);
+                        const error = requestUrl.searchParams.get("error");
+                        const errorDescription = requestUrl.searchParams.get("error_description");
+                        if (error) {
+                            return new Response(errorDescription || error, { status: 400 });
+                        }
+                        const code = requestUrl.searchParams.get("code");
+                        const state = requestUrl.searchParams.get("state");
+                        if (!code || !state) {
+                            return new Response("Missing Auth0 authorization code or state.", { status: 400 });
+                        }
+                        const cookies = parseCookieHeaderMap(request.headers.get("cookie"));
+                        const statePayload = unsignValue(cookies[stateCookieName], secret);
+                        if (!statePayload || statePayload.state !== state) {
+                            return new Response("Invalid Auth0 state.", { status: 400 });
+                        }
+                        const origin = getOrigin(request, appBaseUrl);
+                        const redirectUri = callbackSettings.getCallbackUrl(request);
+                        const tokenResponse = await exchangeCode(domain, clientId, clientSecret, code, redirectUri, statePayload.codeVerifier, input.tokenEndpointAuthMethod);
+                        const user = await createUserProfile(domain, tokenResponse.access_token, tokenResponse.id_token);
+                        const expiresAt = Date.now() + Math.max(tokenResponse.expires_in || 3600, 60) * 1000;
+                        const headers = new Headers();
+                        headers.append("set-cookie", createRequestCookie(sessionCookieName, signValue({ user, expiresAt }, secret), request, {
+                            maxAge: Math.max((expiresAt - Date.now()) / 1000, 60),
+                        }));
+                        headers.append("set-cookie", clearRequestCookie(stateCookieName, request));
+                        headers.set("location", new URL(statePayload.returnTo || "/dashboard", origin).toString());
+                        return new Response(null, {
+                            status: 302,
+                            headers,
+                        });
+                    })();
+                },
+            }),
+            integrationRoute.get(logoutPath, {
+                responseFormat: "json",
+                handler(request) {
+                    const origin = getOrigin(request, appBaseUrl);
+                    const redirectTo = new URL("/v2/logout", `https://${domain}`);
+                    redirectTo.searchParams.set("client_id", clientId);
+                    redirectTo.searchParams.set("returnTo", origin);
+                    const headers = new Headers();
+                    headers.append("set-cookie", clearRequestCookie(sessionCookieName, request));
+                    if (request.headers.get("x-farm-integration-client") === "1") {
+                        return Response.json({
+                            redirectTo: redirectTo.toString(),
+                        }, {
+                            status: 200,
+                            headers,
+                        });
+                    }
+                    headers.set("location", redirectTo.toString());
+                    return new Response(null, {
+                        status: 302,
+                        headers,
+                    });
+                },
+            }),
+            integrationRoute.get(profilePath, {
+                responseFormat: "json",
+                handler(request) {
+                    const session = getSession(request, sessionCookieName, secret);
+                    if (!session) {
+                        return Response.json({
+                            authenticated: false,
+                        }, { status: 401 });
+                    }
+                    return Response.json({
+                        authenticated: true,
+                        user: session.user,
+                    });
+                },
+            }),
+        ],
+        middleware: protectedMatchers.length > 0
+            ? [
+                {
+                    matcher: protectedMatchers,
+                    handler(request) {
+                        const session = getSession(request, sessionCookieName, secret);
+                        if (session) {
+                            return;
+                        }
+                        const requestUrl = new URL(request.url);
+                        const redirectUrl = new URL(loginPath, getOrigin(request, appBaseUrl));
+                        redirectUrl.searchParams.set("returnTo", `${requestUrl.pathname}${requestUrl.search}`);
+                        return Response.redirect(redirectUrl, 307);
+                    },
+                },
+            ]
+            : [],
+    });
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@farm.js/auth0",
+  "version": "0.1.0-beta.0",
+  "description": "Auth0 integration for Farm.js",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/farming-labs/farm.js",
+    "directory": "packages/farm-auth0"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@farm.js/core": "0.1.0-beta.0",
+    "@farm.js/integration-utils": "0.1.0-beta.0"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc",
+    "dev": "tsc --watch",
+    "type-check": "tsc --noEmit",
+    "test": "echo 'No tests in this package'"
+  }
+}