@farm.js/workos 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/workos
+
+WorkOS integration for Farm.js
+
+Farm.js is currently in beta.
+
+```bash
+npm install @farm.js/workos@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,25 @@
+export interface WorkOSRedirectQuery {
+    returnTo?: string;
+}
+export interface WorkOSRedirectResult {
+    redirectTo: string;
+}
+export interface WorkOSSessionResult {
+    authenticated: boolean;
+    sessionId?: string;
+    organizationId?: string;
+    user?: {
+        id: string;
+        email: string;
+        firstName?: string | null;
+        lastName?: string | null;
+        profilePictureUrl?: string | null;
+    };
+}
+export declare const workosClient: {
+    login: import("@farm.js/core/client").FarmIntegrationAPIOperation<never, WorkOSRedirectQuery, WorkOSRedirectResult, false, "GET">;
+    signup: import("@farm.js/core/client").FarmIntegrationAPIOperation<never, WorkOSRedirectQuery, WorkOSRedirectResult, false, "GET">;
+    logout: import("@farm.js/core/client").FarmIntegrationAPIOperation<never, never, WorkOSRedirectResult, false, "POST">;
+    session: import("@farm.js/core/client").FarmIntegrationAPIOperation<never, never, WorkOSSessionResult, 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,mBAAmB;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,OAAO,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,IAAI,CAAC,EAAE;QACL,EAAE,EAAE,MAAM,CAAC;QACX,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC1B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACzB,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KACnC,CAAC;CACH;AAED,eAAO,MAAM,YAAY;;;;;CAaxB,CAAC"}

package/dist/client.js

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

package/dist/index.d.ts

@@ -0,0 +1,97 @@
+import { type FarmIntegrationLogger } from "@farm.js/core";
+import type { WorkOSRedirectResult } from "./client.js";
+export interface WorkOSIntegrationInput {
+    clientId?: string;
+    apiKey?: string;
+    cookiePassword?: string;
+    cookieName?: string;
+    loginPath?: string;
+    signUpPath?: string;
+    callbackPath?: string;
+    logoutPath?: string;
+    sessionPath?: string;
+    protectedRoutes?: string | string[];
+    log?: FarmIntegrationLogger;
+}
+interface ResolvedWorkOSConfig {
+    clientId: string;
+    apiKey: string;
+    cookiePassword: string;
+}
+export declare function workos(input?: WorkOSIntegrationInput): import("@farm.js/core").DefinedIntegration<{
+    category: "auth";
+    type: string;
+    instance: {
+        clientId: string;
+        apiKey: string;
+        protectedRoutes: string[];
+    };
+    config: import("@farm.js/core").FarmIntegrationConfigDefinition<ResolvedWorkOSConfig, 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;
+                        sessionId?: string | undefined;
+                        organizationId?: string | undefined;
+                        user?: {
+                            id: string;
+                            email: string;
+                            firstName?: string | null | undefined;
+                            lastName?: string | null | undefined;
+                            profilePictureUrl?: string | null | undefined;
+                        } | undefined;
+                    };
+                } | undefined;
+            };
+            post: {
+                readonly kind: "farm-integration-api-operation";
+                path: string;
+                method: "POST";
+                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;
+                    };
+                } | 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> | import("@farm.js/core").FarmTypedIntegrationRoute<string, {
+        returnTo?: string;
+    }, never, WorkOSRedirectResult, false, "POST", import("@farm.js/core").FarmIntegrationSchema | undefined>)[];
+    middleware: {
+        matcher: string[];
+        handler(request: Request): Promise<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;AAWhG,OAAO,KAAK,EAAuB,oBAAoB,EAAuB,MAAM,aAAa,CAAC;AAGlG,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,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,GAAG,CAAC,EAAE,qBAAqB,CAAC;CAC7B;AAID,UAAU,oBAAoB;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;CACxB;AA+ED,wBAAgB,MAAM,CAAC,KAAK,GAAE,sBAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAkJG,MAAM;;;;yBAoE7B,OAAO;;GAe3C"}

package/dist/index.js

@@ -0,0 +1,252 @@
+import { WorkOS } from "@workos-inc/node";
+import { defineIntegration, integrationRoute } from "@farm.js/core";
+import { clearRequestCookie, createPathInferredClientApi, createDocumentNavigationMatchers, createRequestCookie, getCookieValue, getReturnTo, integrationConfig, normalizeMatchers, } from "@farm.js/integration-utils";
+import { workosClient } from "./client.js";
+const DEV_COOKIE_PASSWORD = "farmjs-workos-cookie-password-development-2026";
+function createWorkOSApi(input) {
+    return createPathInferredClientApi({
+        path: input.loginPath,
+        operation: workosClient.login,
+    }, {
+        path: input.signUpPath,
+        operation: workosClient.signup,
+    }, {
+        path: input.logoutPath,
+        operation: workosClient.logout,
+    }, {
+        path: input.sessionPath,
+        operation: workosClient.session,
+    });
+}
+function resolveEnv(input) {
+    const clientId = input.clientId ?? process.env.WORKOS_CLIENT_ID ?? "";
+    const apiKey = input.apiKey ?? process.env.WORKOS_API_KEY ?? "";
+    const cookiePassword = input.cookiePassword ??
+        process.env.WORKOS_COOKIE_PASSWORD ??
+        process.env.FARM_WORKOS_COOKIE_PASSWORD ??
+        (process.env.NODE_ENV === "production" ? "" : DEV_COOKIE_PASSWORD);
+    if (!clientId || !apiKey) {
+        throw new Error("WorkOS integration requires WORKOS_CLIENT_ID and WORKOS_API_KEY.");
+    }
+    if (!cookiePassword) {
+        throw new Error("WorkOS integration requires WORKOS_COOKIE_PASSWORD in production.");
+    }
+    return {
+        clientId,
+        apiKey,
+        cookiePassword,
+    };
+}
+async function getSession(workos, request, cookieName, cookiePassword) {
+    const sessionData = getCookieValue(request.headers, cookieName);
+    if (!sessionData) {
+        return null;
+    }
+    const session = workos.userManagement.loadSealedSession({
+        sessionData,
+        cookiePassword,
+    });
+    const authentication = await session.authenticate();
+    if (!authentication.authenticated) {
+        return null;
+    }
+    return {
+        session,
+        authentication,
+    };
+}
+export function workos(input = {}) {
+    const { clientId, apiKey, cookiePassword } = resolveEnv(input);
+    const protectedMatchers = normalizeMatchers(input.protectedRoutes);
+    const cookieName = input.cookieName ?? "wos-session";
+    const loginPath = input.loginPath ?? "/login";
+    const signUpPath = input.signUpPath ?? "/signup";
+    const callbackPath = input.callbackPath ?? "/callback";
+    const logoutPath = input.logoutPath ?? "/logout";
+    const sessionPath = input.sessionPath ?? "/auth/session";
+    const workos = new WorkOS({
+        apiKey,
+        clientId,
+    });
+    async function redirectToAuth(request, screenHint) {
+        const requestUrl = new URL(request.url);
+        const returnTo = getReturnTo(requestUrl.searchParams.get("returnTo"), "/dashboard");
+        const callbackUrl = new URL(callbackPath, requestUrl.origin);
+        const authorizationUrl = workos.userManagement.getAuthorizationUrl({
+            provider: "authkit",
+            clientId,
+            redirectUri: callbackUrl.toString(),
+            screenHint,
+            state: JSON.stringify({ returnTo }),
+        });
+        return {
+            redirectTo: authorizationUrl,
+        };
+    }
+    return defineIntegration({
+        category: "auth",
+        type: "workos",
+        instance: {
+            clientId,
+            apiKey: "[redacted]",
+            protectedRoutes: protectedMatchers,
+        },
+        config: integrationConfig({
+            label: "WorkOS integration",
+            env: {
+                clientId: "WORKOS_CLIENT_ID",
+                apiKey: "WORKOS_API_KEY",
+                cookiePassword: ["WORKOS_COOKIE_PASSWORD", "FARM_WORKOS_COOKIE_PASSWORD"],
+            },
+            input: {
+                clientId,
+                apiKey,
+                cookiePassword,
+            },
+            required: ["clientId", "apiKey", "cookiePassword"],
+        }),
+        api: createWorkOSApi({
+            loginPath,
+            signUpPath,
+            logoutPath,
+            sessionPath,
+        }),
+        log: input.log,
+        documentNavigations: [
+            {
+                matcher: createDocumentNavigationMatchers(loginPath, signUpPath, callbackPath),
+            },
+        ],
+        routes: [
+            integrationRoute.get(loginPath, {
+                responseFormat: "json",
+                async handler(request) {
+                    const result = await redirectToAuth(request, "sign-in");
+                    if (request.headers.get("x-farm-integration-client") === "1") {
+                        return Response.json(result);
+                    }
+                    return Response.redirect(result.redirectTo, 302);
+                },
+            }),
+            integrationRoute.get(signUpPath, {
+                responseFormat: "json",
+                async handler(request) {
+                    const result = await redirectToAuth(request, "sign-up");
+                    if (request.headers.get("x-farm-integration-client") === "1") {
+                        return Response.json(result);
+                    }
+                    return Response.redirect(result.redirectTo, 302);
+                },
+            }),
+            integrationRoute.get(callbackPath, {
+                async handler(request) {
+                    const requestUrl = new URL(request.url);
+                    const code = requestUrl.searchParams.get("code");
+                    const error = requestUrl.searchParams.get("error");
+                    const errorDescription = requestUrl.searchParams.get("error_description");
+                    if (error) {
+                        return new Response(errorDescription || error, { status: 400 });
+                    }
+                    if (!code) {
+                        return new Response("Missing WorkOS authorization code.", { status: 400 });
+                    }
+                    const authentication = await workos.userManagement.authenticateWithCode({
+                        clientId,
+                        code,
+                        session: {
+                            sealSession: true,
+                            cookiePassword,
+                        },
+                    });
+                    if (!authentication.sealedSession) {
+                        return new Response("WorkOS did not return a sealed session.", { status: 500 });
+                    }
+                    let returnTo = "/dashboard";
+                    const rawState = requestUrl.searchParams.get("state");
+                    if (rawState) {
+                        try {
+                            const parsed = JSON.parse(rawState);
+                            returnTo = getReturnTo(parsed.returnTo ?? null, "/dashboard");
+                        }
+                        catch {
+                            returnTo = "/dashboard";
+                        }
+                    }
+                    const headers = new Headers();
+                    headers.set("set-cookie", createRequestCookie(cookieName, authentication.sealedSession, request));
+                    headers.set("location", new URL(returnTo, requestUrl.origin).toString());
+                    return new Response(null, {
+                        status: 302,
+                        headers,
+                    });
+                },
+            }),
+            integrationRoute.post(logoutPath, {
+                responseFormat: "json",
+                async handler(request) {
+                    const requestUrl = new URL(request.url);
+                    const sessionState = await getSession(workos, request, cookieName, cookiePassword);
+                    const headers = new Headers();
+                    headers.set("set-cookie", clearRequestCookie(cookieName, request));
+                    if (!sessionState) {
+                        const redirectTo = new URL("/", requestUrl.origin).toString();
+                        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: 303, headers });
+                    }
+                    const logoutUrl = await sessionState.session.getLogoutUrl({
+                        returnTo: requestUrl.origin,
+                    });
+                    if (request.headers.get("x-farm-integration-client") === "1") {
+                        return Response.json({ redirectTo: logoutUrl }, { status: 200, headers });
+                    }
+                    headers.set("location", logoutUrl);
+                    return new Response(null, { status: 303, headers });
+                },
+            }),
+            integrationRoute.get(sessionPath, {
+                responseFormat: "json",
+                async handler(request) {
+                    const sessionState = await getSession(workos, request, cookieName, cookiePassword);
+                    if (!sessionState) {
+                        return Response.json({
+                            authenticated: false,
+                        }, { status: 401 });
+                    }
+                    const { authentication } = sessionState;
+                    return Response.json({
+                        authenticated: true,
+                        sessionId: authentication.sessionId,
+                        organizationId: authentication.organizationId,
+                        user: {
+                            id: authentication.user.id,
+                            email: authentication.user.email,
+                            firstName: authentication.user.firstName,
+                            lastName: authentication.user.lastName,
+                            profilePictureUrl: authentication.user.profilePictureUrl,
+                        },
+                    });
+                },
+            }),
+        ],
+        middleware: protectedMatchers.length > 0
+            ? [
+                {
+                    matcher: protectedMatchers,
+                    async handler(request) {
+                        const sessionState = await getSession(workos, request, cookieName, cookiePassword);
+                        if (sessionState) {
+                            return;
+                        }
+                        const requestUrl = new URL(request.url);
+                        const loginUrl = new URL(loginPath, request.url);
+                        loginUrl.searchParams.set("returnTo", `${requestUrl.pathname}${requestUrl.search}`);
+                        return Response.redirect(loginUrl, 307);
+                    },
+                },
+            ]
+            : [],
+    });
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@farm.js/workos",
+  "version": "0.1.0-beta.0",
+  "description": "WorkOS integration for Farm.js",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/farming-labs/farm.js",
+    "directory": "packages/farm-workos"
+  },
+  "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": {
+    "@workos-inc/node": "^8.9.0",
+    "@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'"
+  }
+}