@logto/remix 1.1.1 → 2.0.0

package/lib/useCases/handleSignIn/HandleSignInController.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var node = require('@remix-run/node');
+var getCookieHeaderFromRequest = require('../../framework/get-cookie-header-from-request.cjs');
+
+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.getCookieHeaderFromRequest(request);
+            const { redirectUri } = this;
+            const result = await this.useCase({
+                cookieHeader: cookieHeader ?? undefined,
+                redirectUri,
+            });
+            return node.redirect(result.navigateToUrl, {
+                headers: {
+                    'Set-Cookie': result.cookieHeader,
+                },
+            });
+        };
+    }
+}
+
+exports.HandleSignInController = HandleSignInController;

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

@@ -0,0 +1,15 @@
+import type { TypedResponse } from '@remix-run/node';
+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<TypedResponse<never>>;
+}
+export {};

package/lib/useCases/handleSignIn/HandleSignInController.js

@@ -0,0 +1,29 @@
+import { redirect } from '@remix-run/node';
+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/HandleSignInUseCase.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+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,
+    };
+};
+
+exports.makeHandleSignInUseCase = makeHandleSignInUseCase;

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

@@ -0,0 +1,16 @@
+import type { SessionStorage } from '@remix-run/node';
+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/index.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var HandleSignInController = require('./HandleSignInController.cjs');
+var HandleSignInUseCase = require('./HandleSignInUseCase.cjs');
+
+const makeHandleSignIn = (dto, deps) => async (request) => {
+    const { createLogtoAdapter, sessionStorage } = deps;
+    const useCase = HandleSignInUseCase.makeHandleSignInUseCase({
+        createLogtoAdapter,
+        sessionStorage,
+    });
+    const controller = HandleSignInController.HandleSignInController.fromDto({
+        useCase,
+        redirectUri: dto.redirectBackTo,
+    });
+    return controller.execute(request);
+};
+
+exports.makeHandleSignIn = makeHandleSignIn;

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

@@ -0,0 +1,11 @@
+import type { SessionStorage } from '@remix-run/node';
+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<import("@remix-run/node").TypedResponse<never>>;
+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.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+var node = require('@remix-run/node');
+var getCookieHeaderFromRequest = require('../../framework/get-cookie-header-from-request.cjs');
+var HandleSignInCallbackError = require('./HandleSignInCallbackError.cjs');
+
+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.getCookieHeaderFromRequest(request);
+            if (!cookieHeader) {
+                throw HandleSignInCallbackError.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 node.redirect(this.redirectUri, {
+                headers: {
+                    'Set-Cookie': result.cookieHeader,
+                },
+            });
+        };
+    }
+}
+
+exports.HandleSignInCallbackController = HandleSignInCallbackController;

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

@@ -0,0 +1,15 @@
+import type { TypedResponse } from '@remix-run/node';
+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<TypedResponse<never>>;
+}
+export {};

package/lib/useCases/handleSignInCallback/HandleSignInCallbackController.js

@@ -0,0 +1,40 @@
+import { redirect } from '@remix-run/node';
+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/HandleSignInCallbackError.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+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;
+    }
+}
+
+exports.HandleSignInCallbackError = HandleSignInCallbackError;

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.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+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,
+    };
+};
+
+exports.makeHandleSignInCallbackUseCase = makeHandleSignInCallbackUseCase;

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

@@ -0,0 +1,15 @@
+import type { SessionStorage } from '@remix-run/node';
+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/index.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var HandleSignInCallbackController = require('./HandleSignInCallbackController.cjs');
+var HandleSignInCallbackUseCase = require('./HandleSignInCallbackUseCase.cjs');
+
+const makeHandleSignInCallback = (dto, deps) => async (request) => {
+    const { createLogtoAdapter, sessionStorage } = deps;
+    const useCase = HandleSignInCallbackUseCase.makeHandleSignInCallbackUseCase({
+        createLogtoAdapter,
+        sessionStorage,
+    });
+    const controller = HandleSignInCallbackController.HandleSignInCallbackController.fromDto({
+        useCase,
+        redirectUri: dto.redirectBackTo,
+    });
+    return controller.execute(request);
+};
+
+exports.makeHandleSignInCallback = makeHandleSignInCallback;

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

@@ -0,0 +1,11 @@
+import type { SessionStorage } from '@remix-run/node';
+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<import("@remix-run/node").TypedResponse<never>>;
+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.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var node = require('@remix-run/node');
+var getCookieHeaderFromRequest = require('../../framework/get-cookie-header-from-request.cjs');
+var HandleSignOutError = require('./HandleSignOutError.cjs');
+
+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.getCookieHeaderFromRequest(request);
+            if (!cookieHeader) {
+                throw HandleSignOutError.HandleSignOutError.becauseNoCookieHeaderPresent();
+            }
+            const result = await this.useCase({
+                cookieHeader,
+                redirectUri: this.redirectUri,
+            });
+            return node.redirect(result.navigateToUrl, {
+                headers: {
+                    'Set-Cookie': result.cookieHeader,
+                },
+            });
+        };
+    }
+}
+
+exports.HandleSignOutController = HandleSignOutController;

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

@@ -0,0 +1,15 @@
+import type { TypedResponse } from '@remix-run/node';
+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<TypedResponse<never>>;
+}
+export {};

package/lib/useCases/handleSignOut/HandleSignOutController.js

@@ -0,0 +1,32 @@
+import { redirect } from '@remix-run/node';
+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 };

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

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

package/lib/useCases/handleSignOut/HandleSignOutError.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+class HandleSignOutError extends Error {
+    static { this.becauseNoCookieHeaderPresent = () => new HandleSignOutError({
+        code: 1_665_388_713,
+        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;
+    }
+}
+
+exports.HandleSignOutError = HandleSignOutError;

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

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

package/lib/useCases/handleSignOut/HandleSignOutError.js

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

package/lib/useCases/handleSignOut/HandleSignOutUseCase.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+const makeHandleSignOutUseCase = (deps) => async (request) => {
+    const { sessionStorage, 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,
+        navigateToUrl: response.navigateToUrl,
+    };
+};
+
+exports.makeHandleSignOutUseCase = makeHandleSignOutUseCase;

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

@@ -0,0 +1,16 @@
+import type { SessionStorage } from '@remix-run/node';
+import type { CreateLogtoAdapter } from '../../infrastructure/logto/index.js';
+type SignOutRequest = {
+    readonly cookieHeader: string | undefined;
+    redirectUri: string;
+};
+type SignOutResponse = {
+    cookieHeader: string;
+    readonly navigateToUrl: string;
+};
+export declare const makeHandleSignOutUseCase: (deps: {
+    createLogtoAdapter: CreateLogtoAdapter;
+    sessionStorage: SessionStorage;
+}) => (request: SignOutRequest) => Promise<SignOutResponse>;
+export type HandleSignOutUseCase = ReturnType<typeof makeHandleSignOutUseCase>;
+export {};

package/lib/useCases/handleSignOut/HandleSignOutUseCase.js

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

package/lib/useCases/handleSignOut/HandleSignOutUseCase.spec.d.ts

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

package/lib/useCases/handleSignOut/index.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var HandleSignOutController = require('./HandleSignOutController.cjs');
+var HandleSignOutUseCase = require('./HandleSignOutUseCase.cjs');
+
+const makeHandleSignOut = (dto, deps) => async (request) => {
+    const { createLogtoAdapter, sessionStorage } = deps;
+    const useCase = HandleSignOutUseCase.makeHandleSignOutUseCase({
+        createLogtoAdapter,
+        sessionStorage,
+    });
+    const controller = HandleSignOutController.HandleSignOutController.fromDto({
+        useCase,
+        redirectUri: dto.redirectBackTo,
+    });
+    return controller.execute(request);
+};
+
+exports.makeHandleSignOut = makeHandleSignOut;