@logto/react-router 1.0.0

package/lib/infrastructure/logto/index.js

@@ -0,0 +1,21 @@
+import { makeLogtoClient } from './create-client.js';
+import { createStorage } from './create-storage.js';
+import { makeGetContext } from './get-context.js';
+import { makeHandleSignInCallback } from './handle-sign-in-callback.js';
+import { makeHandleSignIn } from './handle-sign-in.js';
+import { makeHandleSignOut } from './handle-sign-out.js';
+import { makeHandleSignUp } from './handle-sign-up.js';
+
+const makeLogtoAdapter = (config) => (session) => {
+    const storage = createStorage(session);
+    const createClient = makeLogtoClient(config, storage);
+    return {
+        handleSignIn: makeHandleSignIn({ storage, createClient }),
+        handleSignInCallback: makeHandleSignInCallback({ storage, createClient }),
+        handleSignOut: makeHandleSignOut({ createClient }),
+        handleSignUp: makeHandleSignUp({ storage, createClient }),
+        getContext: makeGetContext({ storage, createClient }),
+    };
+};
+
+export { makeLogtoAdapter };

package/lib/useCases/getContext/GetContextController.d.ts

@@ -0,0 +1,13 @@
+import type { GetContextParameters, LogtoContext } from '@logto/node';
+import type { GetContextUseCase } from './GetContextUseCase.js';
+type GetContextControllerDto = GetContextParameters & {
+    readonly useCase: GetContextUseCase;
+};
+export declare class GetContextController {
+    private readonly properties;
+    static readonly fromDto: (dto: GetContextControllerDto) => GetContextController;
+    private readonly useCase;
+    private constructor();
+    readonly execute: (request: Request) => Promise<LogtoContext>;
+}
+export {};

package/lib/useCases/getContext/GetContextController.js

@@ -0,0 +1,19 @@
+import { getCookieHeaderFromRequest } from '../../framework/get-cookie-header-from-request.js';
+
+class GetContextController {
+    static { this.fromDto = (dto) => new GetContextController(dto); }
+    constructor(properties) {
+        this.properties = properties;
+        this.useCase = this.properties.useCase;
+        this.execute = async (request) => {
+            const cookieHeader = getCookieHeaderFromRequest(request);
+            const result = await this.useCase({
+                cookieHeader: cookieHeader ?? undefined,
+                ...this.properties,
+            });
+            return result.context;
+        };
+    }
+}
+
+export { GetContextController };

package/lib/useCases/getContext/GetContextController.spec.d.ts

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

package/lib/useCases/getContext/GetContextController.spec.js

@@ -0,0 +1,15 @@
+import { createLogtoAdapter, sessionStorage } from '../../framework/mocks.js';
+import { GetContextController } from './GetContextController.js';
+import { makeGetContextUseCase } from './GetContextUseCase.js';
+describe('useCases:getContext:GetContextController', () => {
+    it('can be created', () => {
+        const useCase = makeGetContextUseCase({
+            createLogtoAdapter,
+            sessionStorage,
+        });
+        const controller = GetContextController.fromDto({
+            useCase,
+        });
+        expect(controller.constructor.name).toBe('GetContextController');
+    });
+});

package/lib/useCases/getContext/GetContextUseCase.d.ts

@@ -0,0 +1,15 @@
+import type { GetContextParameters } from '@logto/node';
+import type { SessionStorage } from 'react-router';
+import type { CreateLogtoAdapter, LogtoContext } from '../../infrastructure/logto/index.js';
+type GetContextRequest = GetContextParameters & {
+    readonly cookieHeader: string | undefined;
+};
+type GetContextResponse = {
+    context: Readonly<LogtoContext>;
+};
+export declare const makeGetContextUseCase: (deps: {
+    createLogtoAdapter: CreateLogtoAdapter;
+    sessionStorage: SessionStorage;
+}) => (request: GetContextRequest) => Promise<GetContextResponse>;
+export type GetContextUseCase = ReturnType<typeof makeGetContextUseCase>;
+export {};

package/lib/useCases/getContext/GetContextUseCase.js

@@ -0,0 +1,11 @@
+const makeGetContextUseCase = (deps) => async (request) => {
+    const { sessionStorage, createLogtoAdapter } = deps;
+    const session = await sessionStorage.getSession(request.cookieHeader);
+    const logto = createLogtoAdapter(session);
+    const response = await logto.getContext(request);
+    return {
+        context: response.context,
+    };
+};
+
+export { makeGetContextUseCase };

package/lib/useCases/getContext/GetContextUseCase.spec.d.ts

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

package/lib/useCases/getContext/GetContextUseCase.spec.js

@@ -0,0 +1,20 @@
+import { createLogtoAdapter, sessionStorage, getContext, getSession, } from '../../framework/mocks.js';
+import { makeGetContextUseCase } from './GetContextUseCase.js';
+describe('useCases:getContext:GetContextUseCase', () => {
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    it('can make a use case executer', async () => {
+        const execute = makeGetContextUseCase({
+            createLogtoAdapter,
+            sessionStorage,
+        });
+        const response = await execute({
+            cookieHeader: 'abcd',
+        });
+        expect(getContext).toBeCalledTimes(1);
+        expect(getSession).toBeCalledTimes(1);
+        expect(response.context.isAuthenticated).toBe(true);
+        expect(response.context.claims?.email).toBe('test@test.io');
+    });
+});

package/lib/useCases/getContext/index.d.ts

@@ -0,0 +1,9 @@
+import type { GetContextParameters } from '@logto/node';
+import type { SessionStorage } from 'react-router';
+import type { CreateLogtoAdapter } from '../../infrastructure/logto/index.js';
+type HandleGetContextDeps = {
+    readonly createLogtoAdapter: CreateLogtoAdapter;
+    readonly sessionStorage: SessionStorage;
+};
+export declare const makeGetContext: (dto: GetContextParameters, deps: HandleGetContextDeps) => (request: Request) => Promise<import("@logto/node").LogtoContext>;
+export {};

package/lib/useCases/getContext/index.js

@@ -0,0 +1,17 @@
+import { GetContextController } from './GetContextController.js';
+import { makeGetContextUseCase } from './GetContextUseCase.js';
+
+const makeGetContext = (dto, deps) => async (request) => {
+    const { createLogtoAdapter, sessionStorage } = deps;
+    const useCase = makeGetContextUseCase({
+        createLogtoAdapter,
+        sessionStorage,
+    });
+    const controller = GetContextController.fromDto({
+        useCase,
+        ...dto,
+    });
+    return controller.execute(request);
+};
+
+export { makeGetContext };

package/lib/useCases/handleAuthRoutes/HandleAuthRoutesError.d.ts

@@ -0,0 +1,9 @@
+export declare class HandleAuthRoutesError extends Error {
+    private readonly properties;
+    static readonly becauseNoConfigForPath: (anticipatedPath: string) => HandleAuthRoutesError;
+    static readonly becauseOfUnknownRoute: (anticipatedConfigKey: string) => HandleAuthRoutesError;
+    readonly code: number;
+    readonly cause: Error | undefined;
+    readonly plainMessage: string;
+    private constructor();
+}

package/lib/useCases/handleAuthRoutes/HandleAuthRoutesError.js

@@ -0,0 +1,19 @@
+class HandleAuthRoutesError extends Error {
+    static { this.becauseNoConfigForPath = (anticipatedPath) => new HandleAuthRoutesError({
+        code: 1_665_388_277,
+        message: `No configuration available for path "${anticipatedPath}".`,
+    }); }
+    static { this.becauseOfUnknownRoute = (anticipatedConfigKey) => new HandleAuthRoutesError({
+        code: 1_665_388_278,
+        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;
+    }
+}
+
+export { HandleAuthRoutesError };

package/lib/useCases/handleAuthRoutes/index.d.ts

@@ -0,0 +1,15 @@
+import type { LoaderFunction, SessionStorage } from 'react-router';
+import type { CreateLogtoAdapter } from '../../infrastructure/logto/index.js';
+type AuthRouteConfig = {
+    readonly path: string;
+    readonly redirectBackTo: string;
+};
+type PossibleRouteTypes = 'sign-in' | 'sign-in-callback' | 'sign-out' | 'sign-up';
+type HandleAuthRoutesDto = Record<PossibleRouteTypes, AuthRouteConfig>;
+type MakeHandleAuthRoutesDto = {
+    readonly baseUrl: string;
+    readonly createLogtoAdapter: CreateLogtoAdapter;
+    readonly sessionStorage: SessionStorage;
+};
+export declare const makeHandleAuthRoutes: (deps: MakeHandleAuthRoutesDto) => (dto: HandleAuthRoutesDto) => LoaderFunction;
+export {};

package/lib/useCases/handleAuthRoutes/index.js

@@ -0,0 +1,46 @@
+import { makeHandleSignIn } from '../handleSignIn/index.js';
+import { makeHandleSignInCallback } from '../handleSignInCallback/index.js';
+import { makeHandleSignOut } from '../handleSignOut/index.js';
+import { makeHandleSignUp } from '../handleSignUp/index.js';
+import { HandleAuthRoutesError } from './HandleAuthRoutesError.js';
+
+const makeHandleAuthRoutes = (deps) => (dto) => async ({ 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 HandleAuthRoutesError.becauseNoConfigForPath(anticipatedPath);
+    }
+    const { sessionStorage, createLogtoAdapter, baseUrl } = deps;
+    const config = dto[configKey];
+    switch (configKey) {
+        case 'sign-in': {
+            const handler = makeHandleSignIn({
+                redirectBackTo: `${baseUrl}${config.redirectBackTo}`,
+            }, { sessionStorage, createLogtoAdapter });
+            return handler(request);
+        }
+        case 'sign-in-callback': {
+            const handler = makeHandleSignInCallback({
+                redirectBackTo: `${baseUrl}${config.redirectBackTo}`,
+            }, { sessionStorage, createLogtoAdapter });
+            return handler(request);
+        }
+        case 'sign-up': {
+            const handler = makeHandleSignUp({
+                redirectBackTo: `${baseUrl}${config.redirectBackTo}`,
+            }, { sessionStorage, createLogtoAdapter });
+            return handler(request);
+        }
+        case 'sign-out': {
+            const handler = makeHandleSignOut({
+                redirectBackTo: `${baseUrl}${config.redirectBackTo}`,
+            }, { sessionStorage, createLogtoAdapter });
+            return handler(request);
+        }
+    }
+};
+
+export { makeHandleAuthRoutes };

package/lib/useCases/handleSignIn/HandleSignInController.d.ts

@@ -0,0 +1,14 @@
+import type { HandleSignInUseCase } from './HandleSignInUseCase.js';
+type HandleSignInControllerDto = {
+    readonly redirectUri: string;
+    readonly useCase: HandleSignInUseCase;
+};
+export declare class HandleSignInController {
+    private readonly properties;
+    static readonly fromDto: (dto: HandleSignInControllerDto) => HandleSignInController;
+    private readonly useCase;
+    private readonly redirectUri;
+    private constructor();
+    readonly execute: (request: Request) => Promise<Response>;
+}
+export {};

package/lib/useCases/handleSignIn/HandleSignInController.js

@@ -0,0 +1,29 @@
+import { redirect } from 'react-router';
+import { getCookieHeaderFromRequest } from '../../framework/get-cookie-header-from-request.js';
+
+class HandleSignInController {
+    static { this.fromDto = (dto) => new HandleSignInController({
+        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 = getCookieHeaderFromRequest(request);
+            const { redirectUri } = this;
+            const result = await this.useCase({
+                cookieHeader: cookieHeader ?? undefined,
+                redirectUri,
+            });
+            return redirect(result.navigateToUrl, {
+                headers: {
+                    'Set-Cookie': result.cookieHeader,
+                },
+            });
+        };
+    }
+}
+
+export { HandleSignInController };

package/lib/useCases/handleSignIn/HandleSignInController.spec.d.ts

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

package/lib/useCases/handleSignIn/HandleSignInController.spec.js

@@ -0,0 +1,16 @@
+import { createLogtoAdapter, sessionStorage } from '../../framework/mocks.js';
+import { HandleSignInController } from './HandleSignInController.js';
+import { makeHandleSignInUseCase } from './HandleSignInUseCase.js';
+describe('useCases:handleSignIn:HandleSignInController', () => {
+    it('can be created', () => {
+        const useCase = makeHandleSignInUseCase({
+            createLogtoAdapter,
+            sessionStorage,
+        });
+        const controller = HandleSignInController.fromDto({
+            useCase,
+            redirectUri: '/',
+        });
+        expect(controller.constructor.name).toBe('HandleSignInController');
+    });
+});

package/lib/useCases/handleSignIn/HandleSignInUseCase.d.ts

@@ -0,0 +1,16 @@
+import type { SessionStorage } from 'react-router';
+import type { CreateLogtoAdapter } from '../../infrastructure/logto/index.js';
+type SignInRequest = {
+    readonly cookieHeader: string | undefined;
+    readonly redirectUri: string;
+};
+type SignInResponse = {
+    readonly cookieHeader: string;
+    readonly navigateToUrl: string;
+};
+export declare const makeHandleSignInUseCase: (deps: {
+    createLogtoAdapter: CreateLogtoAdapter;
+    sessionStorage: SessionStorage;
+}) => (request: SignInRequest) => Promise<SignInResponse>;
+export type HandleSignInUseCase = ReturnType<typeof makeHandleSignInUseCase>;
+export {};

package/lib/useCases/handleSignIn/HandleSignInUseCase.js

@@ -0,0 +1,15 @@
+const makeHandleSignInUseCase = (deps) => async (request) => {
+    const { sessionStorage, 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,
+        navigateToUrl: response.navigateToUrl,
+    };
+};
+
+export { makeHandleSignInUseCase };

package/lib/useCases/handleSignIn/HandleSignInUseCase.spec.d.ts

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

package/lib/useCases/handleSignIn/HandleSignInUseCase.spec.js

@@ -0,0 +1,18 @@
+import { createLogtoAdapter, sessionStorage, handleSignIn } from '../../framework/mocks.js';
+import { makeHandleSignInUseCase } from './HandleSignInUseCase.js';
+describe('useCases:handleSignIn:HandleSignInUseCase', () => {
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    it('can make a use case executer', async () => {
+        const execute = makeHandleSignInUseCase({
+            createLogtoAdapter,
+            sessionStorage,
+        });
+        await execute({
+            cookieHeader: 'abcd',
+            redirectUri: '/',
+        });
+        expect(handleSignIn).toBeCalledTimes(1);
+    });
+});

package/lib/useCases/handleSignIn/index.d.ts

@@ -0,0 +1,11 @@
+import type { SessionStorage } from 'react-router';
+import type { CreateLogtoAdapter } from '../../infrastructure/logto/index.js';
+type HandleSignInDto = {
+    readonly redirectBackTo: string;
+};
+type HandleSignInDeps = {
+    readonly createLogtoAdapter: CreateLogtoAdapter;
+    readonly sessionStorage: SessionStorage;
+};
+export declare const makeHandleSignIn: (dto: HandleSignInDto, deps: HandleSignInDeps) => (request: Request) => Promise<Response>;
+export {};

package/lib/useCases/handleSignIn/index.js

@@ -0,0 +1,17 @@
+import { HandleSignInController } from './HandleSignInController.js';
+import { makeHandleSignInUseCase } from './HandleSignInUseCase.js';
+
+const makeHandleSignIn = (dto, deps) => async (request) => {
+    const { createLogtoAdapter, sessionStorage } = deps;
+    const useCase = makeHandleSignInUseCase({
+        createLogtoAdapter,
+        sessionStorage,
+    });
+    const controller = HandleSignInController.fromDto({
+        useCase,
+        redirectUri: dto.redirectBackTo,
+    });
+    return controller.execute(request);
+};
+
+export { makeHandleSignIn };

package/lib/useCases/handleSignInCallback/HandleSignInCallbackController.d.ts

@@ -0,0 +1,14 @@
+import type { HandleSignInCallbackUseCase } from './HandleSignInCallbackUseCase.js';
+type HandleSignInCallbackControllerDto = {
+    readonly useCase: HandleSignInCallbackUseCase;
+    readonly redirectUri: string;
+};
+export declare class HandleSignInCallbackController {
+    private readonly properties;
+    static readonly fromDto: (dto: HandleSignInCallbackControllerDto) => HandleSignInCallbackController;
+    private readonly useCase;
+    private readonly redirectUri;
+    private constructor();
+    readonly execute: (request: Request) => Promise<Response>;
+}
+export {};

package/lib/useCases/handleSignInCallback/HandleSignInCallbackController.js

@@ -0,0 +1,40 @@
+import { redirect } from 'react-router';
+import { getCookieHeaderFromRequest } from '../../framework/get-cookie-header-from-request.js';
+import { HandleSignInCallbackError } from './HandleSignInCallbackError.js';
+
+class HandleSignInCallbackController {
+    static { this.fromDto = (dto) => new HandleSignInCallbackController({
+        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 = getCookieHeaderFromRequest(request);
+            if (!cookieHeader) {
+                throw HandleSignInCallbackError.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,
+                callbackUri,
+            });
+            return redirect(this.redirectUri, {
+                headers: {
+                    'Set-Cookie': result.cookieHeader,
+                },
+            });
+        };
+    }
+}
+
+export { HandleSignInCallbackController };

package/lib/useCases/handleSignInCallback/HandleSignInCallbackController.spec.d.ts

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

package/lib/useCases/handleSignInCallback/HandleSignInCallbackController.spec.js

@@ -0,0 +1,16 @@
+import { createLogtoAdapter, sessionStorage } from '../../framework/mocks.js';
+import { HandleSignInCallbackController } from './HandleSignInCallbackController.js';
+import { makeHandleSignInCallbackUseCase } from './HandleSignInCallbackUseCase.js';
+describe('useCases:handleSignInCallback:HandleSignInCallbackController', () => {
+    it('can be created', () => {
+        const useCase = makeHandleSignInCallbackUseCase({
+            createLogtoAdapter,
+            sessionStorage,
+        });
+        const controller = HandleSignInCallbackController.fromDto({
+            useCase,
+            redirectUri: '/',
+        });
+        expect(controller.constructor.name).toBe('HandleSignInCallbackController');
+    });
+});

package/lib/useCases/handleSignInCallback/HandleSignInCallbackError.d.ts

@@ -0,0 +1,8 @@
+export declare class HandleSignInCallbackError extends Error {
+    private readonly properties;
+    static readonly becauseNoCookieHeaderPresent: () => HandleSignInCallbackError;
+    readonly code: number;
+    readonly cause: Error | undefined;
+    readonly plainMessage: string;
+    private constructor();
+}

package/lib/useCases/handleSignInCallback/HandleSignInCallbackError.js

@@ -0,0 +1,15 @@
+class HandleSignInCallbackError extends Error {
+    static { this.becauseNoCookieHeaderPresent = () => new HandleSignInCallbackError({
+        code: 1_665_388_541,
+        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;
+    }
+}
+
+export { HandleSignInCallbackError };

package/lib/useCases/handleSignInCallback/HandleSignInCallbackUseCase.d.ts

@@ -0,0 +1,15 @@
+import type { SessionStorage } from 'react-router';
+import type { CreateLogtoAdapter } from '../../infrastructure/logto/index.js';
+type SignInCallbackRequest = {
+    readonly cookieHeader: string;
+    readonly callbackUri: string;
+};
+type SignInCallbackResponse = {
+    readonly cookieHeader: string;
+};
+export declare const makeHandleSignInCallbackUseCase: (deps: {
+    createLogtoAdapter: CreateLogtoAdapter;
+    sessionStorage: SessionStorage;
+}) => (request: SignInCallbackRequest) => Promise<SignInCallbackResponse>;
+export type HandleSignInCallbackUseCase = ReturnType<typeof makeHandleSignInCallbackUseCase>;
+export {};

package/lib/useCases/handleSignInCallback/HandleSignInCallbackUseCase.js

@@ -0,0 +1,14 @@
+const makeHandleSignInCallbackUseCase = (deps) => async (request) => {
+    const { sessionStorage, 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,
+    };
+};
+
+export { makeHandleSignInCallbackUseCase };

package/lib/useCases/handleSignInCallback/HandleSignInCallbackUseCase.spec.d.ts

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

package/lib/useCases/handleSignInCallback/HandleSignInCallbackUseCase.spec.js

@@ -0,0 +1,18 @@
+import { createLogtoAdapter, sessionStorage, handleSignInCallback } from '../../framework/mocks.js';
+import { makeHandleSignInCallbackUseCase } from './HandleSignInCallbackUseCase.js';
+describe('useCases:handleSignInCallback:HandleSignInCallbackUseCase', () => {
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    it('can make a use case executer', async () => {
+        const execute = makeHandleSignInCallbackUseCase({
+            createLogtoAdapter,
+            sessionStorage,
+        });
+        await execute({
+            cookieHeader: 'abcd',
+            callbackUri: '/',
+        });
+        expect(handleSignInCallback).toBeCalledTimes(1);
+    });
+});

package/lib/useCases/handleSignInCallback/index.d.ts

@@ -0,0 +1,11 @@
+import type { SessionStorage } from 'react-router';
+import type { CreateLogtoAdapter } from '../../infrastructure/logto/index.js';
+type HandleSignInCallbackDto = {
+    readonly redirectBackTo: string;
+};
+type HandleSignInCallbackDeps = {
+    readonly createLogtoAdapter: CreateLogtoAdapter;
+    readonly sessionStorage: SessionStorage;
+};
+export declare const makeHandleSignInCallback: (dto: HandleSignInCallbackDto, deps: HandleSignInCallbackDeps) => (request: Request) => Promise<Response>;
+export {};

package/lib/useCases/handleSignInCallback/index.js

@@ -0,0 +1,17 @@
+import { HandleSignInCallbackController } from './HandleSignInCallbackController.js';
+import { makeHandleSignInCallbackUseCase } from './HandleSignInCallbackUseCase.js';
+
+const makeHandleSignInCallback = (dto, deps) => async (request) => {
+    const { createLogtoAdapter, sessionStorage } = deps;
+    const useCase = makeHandleSignInCallbackUseCase({
+        createLogtoAdapter,
+        sessionStorage,
+    });
+    const controller = HandleSignInCallbackController.fromDto({
+        useCase,
+        redirectUri: dto.redirectBackTo,
+    });
+    return controller.execute(request);
+};
+
+export { makeHandleSignInCallback };

package/lib/useCases/handleSignOut/HandleSignOutController.d.ts

@@ -0,0 +1,14 @@
+import type { HandleSignOutUseCase } from './HandleSignOutUseCase.js';
+type HandleSignOutControllerDto = {
+    readonly useCase: HandleSignOutUseCase;
+    readonly redirectUri: string;
+};
+export declare class HandleSignOutController {
+    private readonly properties;
+    static readonly fromDto: (dto: HandleSignOutControllerDto) => HandleSignOutController;
+    private readonly useCase;
+    private readonly redirectUri;
+    private constructor();
+    readonly execute: (request: Request) => Promise<Response>;
+}
+export {};

package/lib/useCases/handleSignOut/HandleSignOutController.js

@@ -0,0 +1,32 @@
+import { redirect } from 'react-router';
+import { getCookieHeaderFromRequest } from '../../framework/get-cookie-header-from-request.js';
+import { HandleSignOutError } from './HandleSignOutError.js';
+
+class HandleSignOutController {
+    static { this.fromDto = (dto) => new HandleSignOutController({
+        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 = getCookieHeaderFromRequest(request);
+            if (!cookieHeader) {
+                throw HandleSignOutError.becauseNoCookieHeaderPresent();
+            }
+            const result = await this.useCase({
+                cookieHeader,
+                redirectUri: this.redirectUri,
+            });
+            return redirect(result.navigateToUrl, {
+                headers: {
+                    'Set-Cookie': result.cookieHeader,
+                },
+            });
+        };
+    }
+}
+
+export { HandleSignOutController };