@logto/remix 1.0.0-beta.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Silverhand
+
+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,132 @@
+# Logto Remix SDK
+[![Version](https://img.shields.io/npm/v/@logto/remix)](https://www.npmjs.com/package/@logto/remix)
+[![Build Status](https://github.com/logto-io/js/actions/workflows/main.yml/badge.svg)](https://github.com/logto-io/js/actions/workflows/main.yml)
+[![Codecov](https://img.shields.io/codecov/c/github/logto-io/js)](https://app.codecov.io/gh/logto-io/js?branch=master)
+
+The Logto Remix SDK written in TypeScript.
+
+## Installation
+
+### Using npm
+
+```bash
+npm install @logto/remix
+```
+
+### Using yarn
+
+```bash
+yarn add @logto/remix
+```
+
+### Using pnpm
+
+```bash
+pnpm add @logto/remix
+```
+
+## Usage
+
+Before initializing the SDK, we have to create a `SessionStorage` instance which takes care of the session persistence. In our case, we want to use a cookie-based session:
+
+```ts
+// services/authentication.ts
+import { createCookieSessionStorage } from "@remix-run/node";
+
+const sessionStorage = createCookieSessionStorage({
+  cookie: {
+    name: "logto-session",
+    maxAge: 14 * 24 * 60 * 60,
+    secrets: ["s3cret1"],
+  },
+});
+```
+
+Afterwards, we can initialize the SDK via:
+
+```ts
+// app/services/authentication.ts
+
+import { makeLogtoRemix } from "@logto/remix";
+
+export const logto = makeLogtoRemix(
+  {
+    endpoint: process.env.LOGTO_ENDPOINT!,
+    appId: process.env.LOGTO_APP_ID!,
+    appSecret: process.env.LOGTO_APP_SECRET!,
+    baseUrl: process.env.LOGTO_BASE_URL!,
+  },
+  { sessionStorage }
+);
+```
+
+Whereas the environment variables reflect the respective configuration of the application in Logto.
+
+### Mounting the authentication route handlers
+
+The SDK ships with a convenient function that mounts the authentication routes: sign-in, sign-in callback and the sign-out route:
+
+```ts
+// app/routes/api/logto/$action.ts
+
+import { logto } from "../../../services/authentication";
+
+export const loader = logto.handleAuthRoutes({
+  "sign-in": {
+    path: "/api/logto/sign-in",
+    redirectBackTo: "/api/logto/callback",
+  },
+  "sign-in-callback": {
+    path: "/api/logto/callback",
+    redirectBackTo: "/",
+  },
+  "sign-out": {
+    path: "/api/logto/sign-out",
+    redirectBackTo: "/",
+  },
+});
+```
+
+As you can see, the mount process is configurable and you can adjust it for your particular route structure. The whole URL path structure can be customized via the passed configuration object.
+
+When mounting the routes as described above, you can navigate your browser to `/api/logto/sign-in` and you should be redirected to your Logto instance where you have to authenticate then.
+
+### Get the authentication context
+
+A typical use case is to fetch the _authentication context_ which contains information about the respective user. With that information, it is possible to decide if the user is authenticated or not. The SDK exposes a function that can be used in a Remix `loader` function:
+
+```ts
+// app/routes/index.tsx
+import type { LogtoContext } from "@openformation/logto-remix";
+import { LoaderFunction, json } from "@remix-run/node";
+import { useLoaderData } from "@remix-run/react";
+
+import { logto } from "~/services/authentication";
+
+type LoaderResponse = {
+  readonly context: LogtoContext;
+};
+
+export const loader: LoaderFunction = async ({ request }) => {
+  const context = await logto.getContext({ includeAccessToken: false })(
+    request
+  );
+
+  if (!context.isAuthenticated) {
+    return redirect("/api/logto/sign-in");
+  }
+
+  return json<LoaderResponse>({ context });
+};
+
+const Home = () => {
+  const data = useLoaderData<LoaderResponse>();
+
+  return <div>Protected Route.</div>;
+};
+```
+
+## Resources
+
+[![Website](https://img.shields.io/badge/website-logto.io-8262F8.svg)](https://logto.io/)
+[![Discord](https://img.shields.io/discord/965845662535147551?logo=discord&logoColor=ffffff&color=7389D8&cacheSeconds=600)](https://discord.gg/UEPaF3j5e6)

package/lib/index.d.ts

@@ -0,0 +1,31 @@
+import { LogtoConfig } from "@logto/node";
+import { SessionStorage } from "@remix-run/node";
+export { type LogtoConfig } from '@logto/node';
+export { type LogtoContext } from '@logto/node';
+type Config = Readonly<LogtoConfig> & {
+    readonly baseUrl: string;
+};
+export const makeLogtoRemix: (config: Config, deps: {
+    sessionStorage: SessionStorage;
+}) => Readonly<{
+    handleAuthRoutes: (dto: {
+        "sign-in": {
+            readonly path: string;
+            readonly redirectBackTo: string;
+        };
+        "sign-in-callback": {
+            readonly path: string;
+            readonly redirectBackTo: string;
+        };
+        "sign-out": {
+            readonly path: string;
+            readonly redirectBackTo: string;
+        };
+    }) => import("@remix-run/node").LoaderFunction;
+    getContext: (dto: {
+        includeAccessToken: boolean;
+    }) => (request: Request) => Promise<import("@logto/node").LogtoContext>;
+}>;
+export { type LogtoContext } from '@logto/node';
+
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"mappings":";;ACeA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AKW/C,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AkBnBhD,cAAc,QAAQ,CAAC,WAAW,CAAC,GAAG;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,OAAO,MAAM,yBACH,MAAM,QACR;IACJ,gBAAgB,cAAc,CAAC;CAChC;;;;;;;;;;;;;;;sBAemB;QAAE,kBAAkB,EAAE,OAAO,CAAA;KAAE;EAMpD,CAAC;AAEF,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC","sources":["packages/remix/src/src/infrastructure/logto/create-storage.ts","packages/remix/src/src/infrastructure/logto/create-client.ts","packages/remix/src/src/infrastructure/logto/get-context.ts","packages/remix/src/src/infrastructure/logto/handle-sign-in.ts","packages/remix/src/src/infrastructure/logto/handle-sign-in-callback.ts","packages/remix/src/src/infrastructure/logto/handle-sign-out.ts","packages/remix/src/src/infrastructure/logto/index.ts","packages/remix/src/src/framework/get-cookie-header-from-request.ts","packages/remix/src/src/useCases/getContext/GetContextUseCase.ts","packages/remix/src/src/useCases/getContext/GetContextController.ts","packages/remix/src/src/useCases/getContext/index.ts","packages/remix/src/src/useCases/handleSignIn/HandleSignInUseCase.ts","packages/remix/src/src/useCases/handleSignIn/HandleSignInController.ts","packages/remix/src/src/useCases/handleSignIn/index.ts","packages/remix/src/src/useCases/handleSignInCallback/HandleSignInCallbackError.ts","packages/remix/src/src/useCases/handleSignInCallback/HandleSignInCallbackUseCase.ts","packages/remix/src/src/useCases/handleSignInCallback/HandleSignInCallbackController.ts","packages/remix/src/src/useCases/handleSignInCallback/index.ts","packages/remix/src/src/useCases/handleSignOut/HandleSignOutError.ts","packages/remix/src/src/useCases/handleSignOut/HandleSignOutUseCase.ts","packages/remix/src/src/useCases/handleSignOut/HandleSignOutController.ts","packages/remix/src/src/useCases/handleSignOut/index.ts","packages/remix/src/src/useCases/handleAuthRoutes/HandleAuthRoutesError.ts","packages/remix/src/src/useCases/handleAuthRoutes/index.ts","packages/remix/src/src/index.ts","packages/remix/src/index.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"import { LogtoConfig } from '@logto/node';\nimport { SessionStorage } from '@remix-run/node';\n\nimport { makeLogtoAdapter } from './infrastructure/logto';\nimport { makeGetContext } from './useCases/getContext';\nimport { makeHandleAuthRoutes } from './useCases/handleAuthRoutes';\n\ntype Config = Readonly<LogtoConfig> & {\n  readonly baseUrl: string;\n};\n\nexport const makeLogtoRemix = (\n  config: Config,\n  deps: {\n    sessionStorage: SessionStorage;\n  }\n) => {\n  const { sessionStorage } = deps;\n\n  const { baseUrl } = config;\n\n  const createLogtoAdapter = makeLogtoAdapter(config);\n\n  return Object.freeze({\n    handleAuthRoutes: makeHandleAuthRoutes({\n      baseUrl,\n      createLogtoAdapter,\n      sessionStorage,\n    }),\n\n    getContext: (dto: { includeAccessToken: boolean }) =>\n      makeGetContext(dto, {\n        createLogtoAdapter,\n        sessionStorage,\n      }),\n  });\n};\n\nexport { type LogtoContext } from '@logto/node';\n"],"names":[],"version":3,"file":"index.d.ts.map"}

package/lib/index.js

@@ -0,0 +1,494 @@
+var $jCOgx$logtonode = require("@logto/node");
+var $jCOgx$remixrunnode = require("@remix-run/node");
+
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+function $parcel$interopDefault(a) {
+  return a && a.__esModule ? a.default : a;
+}
+
+$parcel$export(module.exports, "makeLogtoRemix", () => $0ca379f5bbbb8613$export$502a4d54d411a9fd);
+
+const $94c40b1de01e2ef7$export$60d790dda55ffee6 = (config, storage)=>// Have to deactivate the eslint rule here as the `LogtoClient`
+    // awaits a `navigate` function.
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    (navigate = ()=>{})=>{
+        return new (0, ($parcel$interopDefault($jCOgx$logtonode)))(config, {
+            storage: storage,
+            navigate: navigate
+        });
+    };
+
+
+class $827429ca01feafa0$var$LogtoStorage {
+    static fromSession = (session)=>{
+        return new $827429ca01feafa0$var$LogtoStorage({
+            session: session
+        });
+    };
+    constructor(properties){
+        this.properties = properties;
+        this.session = this.properties.session;
+        this.setItem = async (key, value)=>{
+            this.session.set(key, value);
+        };
+        this.getItem = async (key)=>{
+            const itemExists = this.session.has(key);
+            if (!itemExists) return null;
+            return String(this.session.get(key));
+        };
+        this.removeItem = async (key)=>{
+            this.session.unset(key);
+        };
+        this.save = async ()=>{
+        // Not required as the persistence happens in the integration layer
+        };
+    }
+}
+const $827429ca01feafa0$export$d184a47a971dd4b9 = (session)=>$827429ca01feafa0$var$LogtoStorage.fromSession(session);
+
+
+const $929a552c463d8b64$export$f4d9bb4cf5d2b40c = (deps)=>async (request)=>{
+        const { storage: storage , createClient: createClient  } = deps;
+        const client = createClient();
+        const context = await client.getContext(request.includeAccessToken);
+        return {
+            context: context
+        };
+    };
+
+
+class $57de529bd46d1977$var$HandleSignInCommand {
+    static fromDependencies = (dependencies)=>new $57de529bd46d1977$var$HandleSignInCommand({
+            createClient: dependencies.createClient
+        });
+    constructor(properties){
+        this.properties = properties;
+        this.navigateToUrl = "/api/sign-in";
+    }
+    async execute(request) {
+        const { createClient: createClient  } = this.properties;
+        const client = createClient((url)=>{
+            this.navigateToUrl = url;
+        });
+        await client.signIn(request.redirectUri);
+        return {
+            navigateToUrl: this.navigateToUrl
+        };
+    }
+}
+const $57de529bd46d1977$export$3c00ad1b716e9134 = (deps)=>async (request)=>{
+        const { storage: storage , createClient: createClient  } = deps;
+        const command = $57de529bd46d1977$var$HandleSignInCommand.fromDependencies({
+            createClient: createClient
+        });
+        const { navigateToUrl: navigateToUrl  } = await command.execute(request);
+        return {
+            session: storage.session,
+            navigateToUrl: navigateToUrl
+        };
+    };
+
+
+const $a5a397d32fbbf55b$export$9c07365b51e93ba3 = (deps)=>async (request)=>{
+        const { storage: storage , createClient: createClient  } = deps;
+        const client = createClient();
+        await client.handleSignInCallback(request.callbackUri);
+        return {
+            session: storage.session
+        };
+    };
+
+
+class $43687e20c64eb0a9$var$HandleSignOutCommand {
+    static fromDependencies = (dependencies)=>new $43687e20c64eb0a9$var$HandleSignOutCommand({
+            createClient: dependencies.createClient
+        });
+    constructor(properties){
+        this.properties = properties;
+        this.navigateToUrl = "/api/sign-in";
+    }
+    async execute(request) {
+        const { createClient: createClient  } = this.properties;
+        const client = createClient((url)=>{
+            this.navigateToUrl = url;
+        });
+        await client.signOut(request.redirectUri);
+        return {
+            navigateToUrl: this.navigateToUrl
+        };
+    }
+}
+const $43687e20c64eb0a9$export$89f18ff1488dade0 = (deps)=>async (request)=>{
+        const { createClient: createClient  } = deps;
+        const command = $43687e20c64eb0a9$var$HandleSignOutCommand.fromDependencies({
+            createClient: createClient
+        });
+        return command.execute(request);
+    };
+
+
+const $be51f08b006ed125$export$5e1ab578feca185a = (config)=>(session)=>{
+        const storage = (0, $827429ca01feafa0$export$d184a47a971dd4b9)(session);
+        const createClient = (0, $94c40b1de01e2ef7$export$60d790dda55ffee6)(config, storage);
+        return {
+            handleSignIn: (0, $57de529bd46d1977$export$3c00ad1b716e9134)({
+                storage: storage,
+                createClient: createClient
+            }),
+            handleSignInCallback: (0, $a5a397d32fbbf55b$export$9c07365b51e93ba3)({
+                storage: storage,
+                createClient: createClient
+            }),
+            handleSignOut: (0, $43687e20c64eb0a9$export$89f18ff1488dade0)({
+                createClient: createClient
+            }),
+            getContext: (0, $929a552c463d8b64$export$f4d9bb4cf5d2b40c)({
+                storage: storage,
+                createClient: createClient
+            })
+        };
+    };
+
+
+const $978a582c6f8c8e7b$export$5c6fae4c79d686e4 = (request)=>request.headers.get("Cookie");
+
+
+class $9d799c5e2ef306d6$export$32386402b3f0a45 {
+    static fromDto = (dto)=>new $9d799c5e2ef306d6$export$32386402b3f0a45({
+            useCase: dto.useCase,
+            includeAccessToken: dto.includeAccessToken ?? false
+        });
+    constructor(properties){
+        this.properties = properties;
+        this.useCase = this.properties.useCase;
+        this.includeAccessToken = this.properties.includeAccessToken;
+        this.execute = async (request)=>{
+            const cookieHeader = (0, $978a582c6f8c8e7b$export$5c6fae4c79d686e4)(request);
+            const { includeAccessToken: includeAccessToken  } = this;
+            const result = await this.useCase({
+                cookieHeader: cookieHeader ?? undefined,
+                includeAccessToken: includeAccessToken
+            });
+            return result.context;
+        };
+    }
+}
+
+
+const $407324a9de7811e9$export$53ae38c062671653 = (deps)=>async (request)=>{
+        const { sessionStorage: sessionStorage , createLogtoAdapter: createLogtoAdapter  } = deps;
+        const session = await sessionStorage.getSession(request.cookieHeader);
+        const logto = createLogtoAdapter(session);
+        const response = await logto.getContext({
+            includeAccessToken: request.includeAccessToken
+        });
+        return {
+            context: response.context
+        };
+    };
+
+
+const $7b69d37f648a005c$export$f4d9bb4cf5d2b40c = (dto, deps)=>async (request)=>{
+        const { createLogtoAdapter: createLogtoAdapter , sessionStorage: sessionStorage  } = deps;
+        const useCase = (0, $407324a9de7811e9$export$53ae38c062671653)({
+            createLogtoAdapter: createLogtoAdapter,
+            sessionStorage: sessionStorage
+        });
+        const controller = (0, $9d799c5e2ef306d6$export$32386402b3f0a45).fromDto({
+            useCase: useCase,
+            includeAccessToken: dto.includeAccessToken
+        });
+        return controller.execute(request);
+    };
+
+
+
+
+class $6ca04f2e8ce3f248$export$8bb8370a824a554b {
+    static fromDto = (dto)=>new $6ca04f2e8ce3f248$export$8bb8370a824a554b({
+            useCase: dto.useCase,
+            redirectUri: dto.redirectUri
+        });
+    constructor(properties){
+        this.properties = properties;
+        this.useCase = this.properties.useCase;
+        this.redirectUri = this.properties.redirectUri;
+        this.execute = async (request)=>{
+            const cookieHeader = (0, $978a582c6f8c8e7b$export$5c6fae4c79d686e4)(request);
+            const { redirectUri: redirectUri  } = this;
+            const result = await this.useCase({
+                cookieHeader: cookieHeader ?? undefined,
+                redirectUri: redirectUri
+            });
+            return (0, $jCOgx$remixrunnode.redirect)(result.navigateToUrl, {
+                headers: {
+                    "Set-Cookie": result.cookieHeader
+                }
+            });
+        };
+    }
+}
+
+
+const $b3adef7963962600$export$463099392e1e6404 = (deps)=>async (request)=>{
+        const { sessionStorage: sessionStorage , createLogtoAdapter: createLogtoAdapter  } = deps;
+        const session = await sessionStorage.getSession(request.cookieHeader);
+        const logto = createLogtoAdapter(session);
+        const response = await logto.handleSignIn({
+            redirectUri: request.redirectUri
+        });
+        const cookieHeader = await sessionStorage.commitSession(response.session);
+        return {
+            cookieHeader: cookieHeader,
+            navigateToUrl: response.navigateToUrl
+        };
+    };
+
+
+const $4e85595756955e84$export$3c00ad1b716e9134 = (dto, deps)=>async (request)=>{
+        const { createLogtoAdapter: createLogtoAdapter , sessionStorage: sessionStorage  } = deps;
+        const useCase = (0, $b3adef7963962600$export$463099392e1e6404)({
+            createLogtoAdapter: createLogtoAdapter,
+            sessionStorage: sessionStorage
+        });
+        const controller = (0, $6ca04f2e8ce3f248$export$8bb8370a824a554b).fromDto({
+            useCase: useCase,
+            redirectUri: dto.redirectBackTo
+        });
+        return controller.execute(request);
+    };
+
+
+
+
+class $21e03cfddf6418cf$export$144a9ac3253d5e56 extends Error {
+    static becauseNoCookieHeaderPresent = ()=>new $21e03cfddf6418cf$export$144a9ac3253d5e56({
+            code: 1665388541,
+            message: `The authentication sign-in callback route can't be accessed without a valid cookie.`
+        });
+    constructor(properties){
+        super(`#[${properties.code}] ${properties.message}`);
+        this.properties = properties;
+        this.code = this.properties.code;
+        this.cause = this.properties.cause;
+        this.plainMessage = this.properties.message;
+    }
+}
+
+
+class $f663abe9edb298e3$export$c8d670afaf17c618 {
+    static fromDto = (dto)=>new $f663abe9edb298e3$export$c8d670afaf17c618({
+            useCase: dto.useCase,
+            redirectUri: dto.redirectUri
+        });
+    constructor(properties){
+        this.properties = properties;
+        this.useCase = this.properties.useCase;
+        this.redirectUri = this.properties.redirectUri;
+        this.execute = async (request)=>{
+            const cookieHeader = (0, $978a582c6f8c8e7b$export$5c6fae4c79d686e4)(request);
+            if (!cookieHeader) throw (0, $21e03cfddf6418cf$export$144a9ac3253d5e56).becauseNoCookieHeaderPresent();
+            // In some scenarios, like performing the sign-in callback within a Gitpod
+            // environment, the load balancer rewrites the URL and uses `http` as the
+            // protocol. Here, we make sure that when the `x-forwarded-proto` HTTP header
+            // is present, we will replace `http` with `https` in the `callbackUri`.
+            const isForwardedHttpsTraffic = request.headers.get("x-forwarded-proto") === "https";
+            const callbackUri = isForwardedHttpsTraffic ? request.url.replace("http", "https") : request.url;
+            const result = await this.useCase({
+                cookieHeader: cookieHeader,
+                callbackUri: callbackUri
+            });
+            return (0, $jCOgx$remixrunnode.redirect)(this.redirectUri, {
+                headers: {
+                    "Set-Cookie": result.cookieHeader
+                }
+            });
+        };
+    }
+}
+
+
+const $ff5498b695abf304$export$22e357c661ee13a4 = (deps)=>async (request)=>{
+        const { sessionStorage: sessionStorage , createLogtoAdapter: createLogtoAdapter  } = deps;
+        const session = await sessionStorage.getSession(request.cookieHeader);
+        const logto = createLogtoAdapter(session);
+        const response = await logto.handleSignInCallback({
+            callbackUri: request.callbackUri
+        });
+        const cookieHeader = await sessionStorage.commitSession(response.session);
+        return {
+            cookieHeader: cookieHeader
+        };
+    };
+
+
+const $7a39fdd186e8afdc$export$9c07365b51e93ba3 = (dto, deps)=>async (request)=>{
+        const { createLogtoAdapter: createLogtoAdapter , sessionStorage: sessionStorage  } = deps;
+        const useCase = (0, $ff5498b695abf304$export$22e357c661ee13a4)({
+            createLogtoAdapter: createLogtoAdapter,
+            sessionStorage: sessionStorage
+        });
+        const controller = (0, $f663abe9edb298e3$export$c8d670afaf17c618).fromDto({
+            useCase: useCase,
+            redirectUri: dto.redirectBackTo
+        });
+        return controller.execute(request);
+    };
+
+
+
+
+class $311025c6b993527d$export$e01614cfebe90908 extends Error {
+    static becauseNoCookieHeaderPresent = ()=>new $311025c6b993527d$export$e01614cfebe90908({
+            code: 1665388713,
+            message: `The authentication sign-out route can't be accessed without a valid cookie.`
+        });
+    constructor(properties){
+        super(`#[${properties.code}] ${properties.message}`);
+        this.properties = properties;
+        this.code = this.properties.code;
+        this.cause = this.properties.cause;
+        this.plainMessage = this.properties.message;
+    }
+}
+
+
+class $dbef723619a85b93$export$543cea0b68ca8887 {
+    static fromDto = (dto)=>new $dbef723619a85b93$export$543cea0b68ca8887({
+            useCase: dto.useCase,
+            redirectUri: dto.redirectUri
+        });
+    constructor(properties){
+        this.properties = properties;
+        this.useCase = this.properties.useCase;
+        this.redirectUri = this.properties.redirectUri;
+        this.execute = async (request)=>{
+            const cookieHeader = (0, $978a582c6f8c8e7b$export$5c6fae4c79d686e4)(request);
+            if (!cookieHeader) throw (0, $311025c6b993527d$export$e01614cfebe90908).becauseNoCookieHeaderPresent();
+            const result = await this.useCase({
+                cookieHeader: cookieHeader,
+                redirectUri: this.redirectUri
+            });
+            return (0, $jCOgx$remixrunnode.redirect)(result.navigateToUrl, {
+                headers: {
+                    "Set-Cookie": result.cookieHeader
+                }
+            });
+        };
+    }
+}
+
+
+const $2453e8ad28193ffe$export$8ccb0e4b7ccc1fc4 = (deps)=>async (request)=>{
+        const { sessionStorage: sessionStorage , createLogtoAdapter: createLogtoAdapter  } = deps;
+        const session = await sessionStorage.getSession(request.cookieHeader);
+        const logto = createLogtoAdapter(session);
+        const response = await logto.handleSignOut({
+            redirectUri: request.redirectUri
+        });
+        const cookieHeader = await sessionStorage.destroySession(session);
+        return {
+            cookieHeader: cookieHeader,
+            navigateToUrl: response.navigateToUrl
+        };
+    };
+
+
+const $380e7b1772b43f91$export$89f18ff1488dade0 = (dto, deps)=>async (request)=>{
+        const { createLogtoAdapter: createLogtoAdapter , sessionStorage: sessionStorage  } = deps;
+        const useCase = (0, $2453e8ad28193ffe$export$8ccb0e4b7ccc1fc4)({
+            createLogtoAdapter: createLogtoAdapter,
+            sessionStorage: sessionStorage
+        });
+        const controller = (0, $dbef723619a85b93$export$543cea0b68ca8887).fromDto({
+            useCase: useCase,
+            redirectUri: dto.redirectBackTo
+        });
+        return controller.execute(request);
+    };
+
+
+class $1a27034d0b6c1fa0$export$fcbf49abe9908796 extends Error {
+    static becauseNoConfigForPath = (anticipatedPath)=>new $1a27034d0b6c1fa0$export$fcbf49abe9908796({
+            code: 1665388277,
+            message: `No configuration available for path "${anticipatedPath}".`
+        });
+    static becauseOfUnknownRoute = (anticipatedConfigKey)=>new $1a27034d0b6c1fa0$export$fcbf49abe9908796({
+            code: 1665388278,
+            message: `The config key "${anticipatedConfigKey}" is invalid.`
+        });
+    constructor(properties){
+        super(`#[${properties.code}] ${properties.message}`);
+        this.properties = properties;
+        this.code = this.properties.code;
+        this.cause = this.properties.cause;
+        this.plainMessage = this.properties.message;
+    }
+}
+
+
+const $4726b3ba230d3664$export$d6e32a8c2b1ad7f3 = (deps)=>(dto)=>async ({ request: request  })=>{
+            const anticipatedPath = new URL(request.url).pathname;
+            /* eslint-disable no-restricted-syntax */ const configKey = Object.keys(dto).find((type)=>dto[type].path === anticipatedPath);
+            const configExists = Boolean(configKey);
+            /* eslint-enable no-restricted-syntax */ if (!configExists) throw (0, $1a27034d0b6c1fa0$export$fcbf49abe9908796).becauseNoConfigForPath(anticipatedPath);
+            const { sessionStorage: sessionStorage , createLogtoAdapter: createLogtoAdapter , baseUrl: baseUrl  } = deps;
+            const config = dto[configKey];
+            switch(configKey){
+                case "sign-in":
+                    {
+                        const handler = (0, $4e85595756955e84$export$3c00ad1b716e9134)({
+                            redirectBackTo: `${baseUrl}${config.redirectBackTo}`
+                        }, {
+                            sessionStorage: sessionStorage,
+                            createLogtoAdapter: createLogtoAdapter
+                        });
+                        return handler(request);
+                    }
+                case "sign-in-callback":
+                    {
+                        const handler1 = (0, $7a39fdd186e8afdc$export$9c07365b51e93ba3)({
+                            redirectBackTo: `${baseUrl}${config.redirectBackTo}`
+                        }, {
+                            sessionStorage: sessionStorage,
+                            createLogtoAdapter: createLogtoAdapter
+                        });
+                        return handler1(request);
+                    }
+                case "sign-out":
+                    {
+                        const handler2 = (0, $380e7b1772b43f91$export$89f18ff1488dade0)({
+                            redirectBackTo: `${baseUrl}${config.redirectBackTo}`
+                        }, {
+                            sessionStorage: sessionStorage,
+                            createLogtoAdapter: createLogtoAdapter
+                        });
+                        return handler2(request);
+                    }
+                default:
+                    throw (0, $1a27034d0b6c1fa0$export$fcbf49abe9908796).becauseOfUnknownRoute(configKey);
+            }
+        };
+
+
+const $0ca379f5bbbb8613$export$502a4d54d411a9fd = (config, deps)=>{
+    const { sessionStorage: sessionStorage  } = deps;
+    const { baseUrl: baseUrl  } = config;
+    const createLogtoAdapter = (0, $be51f08b006ed125$export$5e1ab578feca185a)(config);
+    return Object.freeze({
+        handleAuthRoutes: (0, $4726b3ba230d3664$export$d6e32a8c2b1ad7f3)({
+            baseUrl: baseUrl,
+            createLogtoAdapter: createLogtoAdapter,
+            sessionStorage: sessionStorage
+        }),
+        getContext: (dto)=>(0, $7b69d37f648a005c$export$f4d9bb4cf5d2b40c)(dto, {
+                createLogtoAdapter: createLogtoAdapter,
+                sessionStorage: sessionStorage
+            })
+    });
+};
+
+
+//# sourceMappingURL=index.js.map