@logto/remix 1.1.0 → 1.1.2

package/lib/infrastructure/logto/create-storage.mjs

@@ -0,0 +1,28 @@
+class LogtoStorage {
+    static { this.fromSession = (session) => {
+        return new LogtoStorage({ 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 createStorage = (session) => LogtoStorage.fromSession(session);
+
+export { createStorage };

package/lib/infrastructure/logto/create-storage.spec.d.ts

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

package/lib/infrastructure/logto/get-context.d.ts

@@ -0,0 +1,11 @@
+import type { GetContextParameters, LogtoContext } from '@logto/node';
+import type { CreateLogtoClient } from './create-client';
+import type { LogtoStorage } from './create-storage';
+type GetContextResponse = {
+    readonly context: LogtoContext;
+};
+export declare const makeGetContext: (deps: {
+    storage: LogtoStorage;
+    createClient: CreateLogtoClient;
+}) => (request: GetContextParameters) => Promise<GetContextResponse>;
+export {};

package/lib/infrastructure/logto/get-context.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const makeGetContext = (deps) => async (request) => {
+    const { storage, createClient } = deps;
+    const client = createClient();
+    const context = await client.getContext(request);
+    return {
+        context,
+    };
+};
+
+exports.makeGetContext = makeGetContext;

package/lib/infrastructure/logto/get-context.mjs

@@ -0,0 +1,10 @@
+const makeGetContext = (deps) => async (request) => {
+    const { storage, createClient } = deps;
+    const client = createClient();
+    const context = await client.getContext(request);
+    return {
+        context,
+    };
+};
+
+export { makeGetContext };

package/lib/infrastructure/logto/handle-sign-in-callback.d.ts

@@ -0,0 +1,14 @@
+import type { Session } from '@remix-run/node';
+import type { CreateLogtoClient } from './create-client';
+import type { LogtoStorage } from './create-storage';
+type HandleSignInCallbackRequest = {
+    callbackUri: string;
+};
+type HandleSignInCallbackResponse = {
+    readonly session: Session;
+};
+export declare const makeHandleSignInCallback: (deps: {
+    storage: LogtoStorage;
+    createClient: CreateLogtoClient;
+}) => (request: HandleSignInCallbackRequest) => Promise<HandleSignInCallbackResponse>;
+export {};

package/lib/infrastructure/logto/handle-sign-in-callback.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const makeHandleSignInCallback = (deps) => async (request) => {
+    const { storage, createClient } = deps;
+    const client = createClient();
+    await client.handleSignInCallback(request.callbackUri);
+    return {
+        session: storage.session,
+    };
+};
+
+exports.makeHandleSignInCallback = makeHandleSignInCallback;

package/lib/infrastructure/logto/handle-sign-in-callback.mjs

@@ -0,0 +1,10 @@
+const makeHandleSignInCallback = (deps) => async (request) => {
+    const { storage, createClient } = deps;
+    const client = createClient();
+    await client.handleSignInCallback(request.callbackUri);
+    return {
+        session: storage.session,
+    };
+};
+
+export { makeHandleSignInCallback };

package/lib/infrastructure/logto/handle-sign-in.d.ts

@@ -0,0 +1,15 @@
+import type { Session } from '@remix-run/node';
+import type { CreateLogtoClient } from './create-client';
+import type { LogtoStorage } from './create-storage';
+type HandleSignInRequest = {
+    readonly redirectUri: string;
+};
+type HandleSignInResponse = {
+    readonly session: Session;
+    readonly navigateToUrl: string;
+};
+export declare const makeHandleSignIn: (deps: {
+    storage: LogtoStorage;
+    createClient: CreateLogtoClient;
+}) => (request: HandleSignInRequest) => Promise<HandleSignInResponse>;
+export {};

package/lib/infrastructure/logto/handle-sign-in.js

@@ -0,0 +1,30 @@
+'use strict';
+
+class HandleSignInCommand {
+    static { this.fromDependencies = (dependencies) => new HandleSignInCommand({ createClient: dependencies.createClient }); }
+    constructor(properties) {
+        this.properties = properties;
+        this.navigateToUrl = '/api/sign-in';
+    }
+    async execute(request) {
+        const { createClient } = this.properties;
+        const client = createClient((url) => {
+            this.navigateToUrl = url;
+        });
+        await client.signIn(request.redirectUri);
+        return {
+            navigateToUrl: this.navigateToUrl,
+        };
+    }
+}
+const makeHandleSignIn = (deps) => async (request) => {
+    const { storage, createClient } = deps;
+    const command = HandleSignInCommand.fromDependencies({ createClient });
+    const { navigateToUrl } = await command.execute(request);
+    return {
+        session: storage.session,
+        navigateToUrl,
+    };
+};
+
+exports.makeHandleSignIn = makeHandleSignIn;

package/lib/infrastructure/logto/handle-sign-in.mjs

@@ -0,0 +1,28 @@
+class HandleSignInCommand {
+    static { this.fromDependencies = (dependencies) => new HandleSignInCommand({ createClient: dependencies.createClient }); }
+    constructor(properties) {
+        this.properties = properties;
+        this.navigateToUrl = '/api/sign-in';
+    }
+    async execute(request) {
+        const { createClient } = this.properties;
+        const client = createClient((url) => {
+            this.navigateToUrl = url;
+        });
+        await client.signIn(request.redirectUri);
+        return {
+            navigateToUrl: this.navigateToUrl,
+        };
+    }
+}
+const makeHandleSignIn = (deps) => async (request) => {
+    const { storage, createClient } = deps;
+    const command = HandleSignInCommand.fromDependencies({ createClient });
+    const { navigateToUrl } = await command.execute(request);
+    return {
+        session: storage.session,
+        navigateToUrl,
+    };
+};
+
+export { makeHandleSignIn };

package/lib/infrastructure/logto/handle-sign-out.d.ts

@@ -0,0 +1,11 @@
+import type { CreateLogtoClient } from './create-client';
+type HandleSignOutRequest = {
+    readonly redirectUri: string;
+};
+type HandleSignOutResponse = {
+    readonly navigateToUrl: string;
+};
+export declare const makeHandleSignOut: (deps: {
+    createClient: CreateLogtoClient;
+}) => (request: HandleSignOutRequest) => Promise<HandleSignOutResponse>;
+export {};

package/lib/infrastructure/logto/handle-sign-out.js

@@ -0,0 +1,26 @@
+'use strict';
+
+class HandleSignOutCommand {
+    static { this.fromDependencies = (dependencies) => new HandleSignOutCommand({ createClient: dependencies.createClient }); }
+    constructor(properties) {
+        this.properties = properties;
+        this.navigateToUrl = '/api/sign-in';
+    }
+    async execute(request) {
+        const { createClient } = this.properties;
+        const client = createClient((url) => {
+            this.navigateToUrl = url;
+        });
+        await client.signOut(request.redirectUri);
+        return {
+            navigateToUrl: this.navigateToUrl,
+        };
+    }
+}
+const makeHandleSignOut = (deps) => async (request) => {
+    const { createClient } = deps;
+    const command = HandleSignOutCommand.fromDependencies({ createClient });
+    return command.execute(request);
+};
+
+exports.makeHandleSignOut = makeHandleSignOut;

package/lib/infrastructure/logto/handle-sign-out.mjs

@@ -0,0 +1,24 @@
+class HandleSignOutCommand {
+    static { this.fromDependencies = (dependencies) => new HandleSignOutCommand({ createClient: dependencies.createClient }); }
+    constructor(properties) {
+        this.properties = properties;
+        this.navigateToUrl = '/api/sign-in';
+    }
+    async execute(request) {
+        const { createClient } = this.properties;
+        const client = createClient((url) => {
+            this.navigateToUrl = url;
+        });
+        await client.signOut(request.redirectUri);
+        return {
+            navigateToUrl: this.navigateToUrl,
+        };
+    }
+}
+const makeHandleSignOut = (deps) => async (request) => {
+    const { createClient } = deps;
+    const command = HandleSignOutCommand.fromDependencies({ createClient });
+    return command.execute(request);
+};
+
+export { makeHandleSignOut };

package/lib/infrastructure/logto/index.d.ts

@@ -0,0 +1,26 @@
+import type { LogtoConfig } from '@logto/node';
+import type { Session } from '@remix-run/node';
+type MakeLogtoAdapterConfiguration = LogtoConfig;
+export declare const makeLogtoAdapter: (config: MakeLogtoAdapterConfiguration) => (session: Session) => {
+    handleSignIn: (request: {
+        readonly redirectUri: string;
+    }) => Promise<{
+        readonly session: Session;
+        readonly navigateToUrl: string;
+    }>;
+    handleSignInCallback: (request: {
+        callbackUri: string;
+    }) => Promise<{
+        readonly session: Session;
+    }>;
+    handleSignOut: (request: {
+        readonly redirectUri: string;
+    }) => Promise<{
+        readonly navigateToUrl: string;
+    }>;
+    getContext: (request: import("@logto/node").GetContextParameters) => Promise<{
+        readonly context: import("@logto/node").LogtoContext;
+    }>;
+};
+export type CreateLogtoAdapter = ReturnType<typeof makeLogtoAdapter>;
+export { type LogtoContext } from '@logto/node';

package/lib/infrastructure/logto/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var createClient = require('./create-client.js');
+var createStorage = require('./create-storage.js');
+var getContext = require('./get-context.js');
+var handleSignIn = require('./handle-sign-in.js');
+var handleSignInCallback = require('./handle-sign-in-callback.js');
+var handleSignOut = require('./handle-sign-out.js');
+
+const makeLogtoAdapter = (config) => (session) => {
+    const storage = createStorage.createStorage(session);
+    const createClient$1 = createClient.makeLogtoClient(config, storage);
+    return {
+        handleSignIn: handleSignIn.makeHandleSignIn({ storage, createClient: createClient$1 }),
+        handleSignInCallback: handleSignInCallback.makeHandleSignInCallback({ storage, createClient: createClient$1 }),
+        handleSignOut: handleSignOut.makeHandleSignOut({ createClient: createClient$1 }),
+        getContext: getContext.makeGetContext({ storage, createClient: createClient$1 }),
+    };
+};
+
+exports.makeLogtoAdapter = makeLogtoAdapter;

package/lib/infrastructure/logto/index.mjs

@@ -0,0 +1,19 @@
+import { makeLogtoClient } from './create-client.mjs';
+import { createStorage } from './create-storage.mjs';
+import { makeGetContext } from './get-context.mjs';
+import { makeHandleSignIn } from './handle-sign-in.mjs';
+import { makeHandleSignInCallback } from './handle-sign-in-callback.mjs';
+import { makeHandleSignOut } from './handle-sign-out.mjs';
+
+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 }),
+        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';
+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,21 @@
+'use strict';
+
+var getCookieHeaderFromRequest = require('../../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.getCookieHeaderFromRequest(request);
+            const result = await this.useCase({
+                cookieHeader: cookieHeader ?? undefined,
+                ...this.properties,
+            });
+            return result.context;
+        };
+    }
+}
+
+exports.GetContextController = GetContextController;

package/lib/useCases/getContext/GetContextController.mjs

@@ -0,0 +1,19 @@
+import { getCookieHeaderFromRequest } from '../../framework/get-cookie-header-from-request.mjs';
+
+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/GetContextUseCase.d.ts

@@ -0,0 +1,15 @@
+import type { GetContextParameters } from '@logto/node';
+import type { SessionStorage } from '@remix-run/node';
+import type { CreateLogtoAdapter, LogtoContext } from '../../infrastructure/logto';
+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,13 @@
+'use strict';
+
+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,
+    };
+};
+
+exports.makeGetContextUseCase = makeGetContextUseCase;

package/lib/useCases/getContext/GetContextUseCase.mjs

@@ -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/index.d.ts

@@ -0,0 +1,9 @@
+import type { GetContextParameters } from '@logto/node';
+import type { SessionStorage } from '@remix-run/node';
+import type { CreateLogtoAdapter } from '../../infrastructure/logto';
+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,19 @@
+'use strict';
+
+var GetContextController = require('./GetContextController.js');
+var GetContextUseCase = require('./GetContextUseCase.js');
+
+const makeGetContext = (dto, deps) => async (request) => {
+    const { createLogtoAdapter, sessionStorage } = deps;
+    const useCase = GetContextUseCase.makeGetContextUseCase({
+        createLogtoAdapter,
+        sessionStorage,
+    });
+    const controller = GetContextController.GetContextController.fromDto({
+        useCase,
+        ...dto,
+    });
+    return controller.execute(request);
+};
+
+exports.makeGetContext = makeGetContext;

package/lib/useCases/getContext/index.mjs

@@ -0,0 +1,17 @@
+import { GetContextController } from './GetContextController.mjs';
+import { makeGetContextUseCase } from './GetContextUseCase.mjs';
+
+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,21 @@
+'use strict';
+
+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;
+    }
+}
+
+exports.HandleAuthRoutesError = HandleAuthRoutesError;

package/lib/useCases/handleAuthRoutes/HandleAuthRoutesError.mjs

@@ -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 '@remix-run/node';
+import type { CreateLogtoAdapter } from '../../infrastructure/logto';
+type AuthRouteConfig = {
+    readonly path: string;
+    readonly redirectBackTo: string;
+};
+type PossibleRouteTypes = 'sign-in' | 'sign-in-callback' | 'sign-out';
+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,44 @@
+'use strict';
+
+var index$2 = require('../handleSignIn/index.js');
+var index$1 = require('../handleSignInCallback/index.js');
+var index = require('../handleSignOut/index.js');
+var HandleAuthRoutesError = require('./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.HandleAuthRoutesError.becauseNoConfigForPath(anticipatedPath);
+    }
+    const { sessionStorage, createLogtoAdapter, baseUrl } = deps;
+    const config = dto[configKey];
+    switch (configKey) {
+        case 'sign-in': {
+            const handler = index$2.makeHandleSignIn({
+                redirectBackTo: `${baseUrl}${config.redirectBackTo}`,
+            }, { sessionStorage, createLogtoAdapter });
+            return handler(request);
+        }
+        case 'sign-in-callback': {
+            const handler = index$1.makeHandleSignInCallback({
+                redirectBackTo: `${baseUrl}${config.redirectBackTo}`,
+            }, { sessionStorage, createLogtoAdapter });
+            return handler(request);
+        }
+        case 'sign-out': {
+            const handler = index.makeHandleSignOut({
+                redirectBackTo: `${baseUrl}${config.redirectBackTo}`,
+            }, { sessionStorage, createLogtoAdapter });
+            return handler(request);
+        }
+        default: {
+            throw HandleAuthRoutesError.HandleAuthRoutesError.becauseOfUnknownRoute(configKey);
+        }
+    }
+};
+
+exports.makeHandleAuthRoutes = makeHandleAuthRoutes;

package/lib/useCases/handleAuthRoutes/index.mjs

@@ -0,0 +1,42 @@
+import { makeHandleSignIn } from '../handleSignIn/index.mjs';
+import { makeHandleSignInCallback } from '../handleSignInCallback/index.mjs';
+import { makeHandleSignOut } from '../handleSignOut/index.mjs';
+import { HandleAuthRoutesError } from './HandleAuthRoutesError.mjs';
+
+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-out': {
+            const handler = makeHandleSignOut({
+                redirectBackTo: `${baseUrl}${config.redirectBackTo}`,
+            }, { sessionStorage, createLogtoAdapter });
+            return handler(request);
+        }
+        default: {
+            throw HandleAuthRoutesError.becauseOfUnknownRoute(configKey);
+        }
+    }
+};
+
+export { makeHandleAuthRoutes };

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

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