@logto/remix 2.1.9 → 2.2.1

package/README.md

@@ -84,6 +84,10 @@ export const loader = logto.handleAuthRoutes({
     path: "/api/logto/sign-out",
     redirectBackTo: "/",
   },
+  "sign-up": {
+    path: "/api/logto/sign-up",
+    redirectBackTo: "/api/logto/callback",
+  },
 });
 ```
 

package/lib/index.d.ts

@@ -19,6 +19,10 @@ export declare const makeLogtoRemix: (config: Config, deps: {
             readonly path: string;
             readonly redirectBackTo: string;
         };
+        "sign-up": {
+            readonly path: string;
+            readonly redirectBackTo: string;
+        };
     }) => import("@remix-run/node").LoaderFunction;
     getContext: (dto: GetContextParameters) => (request: Request) => Promise<import("@logto/node").LogtoContext>;
 }>;

package/lib/infrastructure/logto/handle-sign-up.cjs

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

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

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

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

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

package/lib/infrastructure/logto/index.cjs

@@ -6,6 +6,7 @@ var getContext = require('./get-context.cjs');
 var handleSignInCallback = require('./handle-sign-in-callback.cjs');
 var handleSignIn = require('./handle-sign-in.cjs');
 var handleSignOut = require('./handle-sign-out.cjs');
+var handleSignUp = require('./handle-sign-up.cjs');
 
 const makeLogtoAdapter = (config) => (session) => {
     const storage = createStorage.createStorage(session);
@@ -14,6 +15,7 @@ const makeLogtoAdapter = (config) => (session) => {
         handleSignIn: handleSignIn.makeHandleSignIn({ storage, createClient: createClient$1 }),
         handleSignInCallback: handleSignInCallback.makeHandleSignInCallback({ storage, createClient: createClient$1 }),
         handleSignOut: handleSignOut.makeHandleSignOut({ createClient: createClient$1 }),
+        handleSignUp: handleSignUp.makeHandleSignUp({ storage, createClient: createClient$1 }),
         getContext: getContext.makeGetContext({ storage, createClient: createClient$1 }),
     };
 };

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

@@ -18,6 +18,12 @@ export declare const makeLogtoAdapter: (config: MakeLogtoAdapterConfiguration) =
     }) => Promise<{
         readonly navigateToUrl: string;
     }>;
+    handleSignUp: (request: {
+        readonly redirectUri: string;
+    }) => Promise<{
+        readonly session: Session<import("@remix-run/node").SessionData, import("@remix-run/node").SessionData>;
+        readonly navigateToUrl: string;
+    }>;
     getContext: (request: import("@logto/node").GetContextParameters) => Promise<{
         readonly context: import("@logto/node").LogtoContext;
     }>;

package/lib/infrastructure/logto/index.js

@@ -4,6 +4,7 @@ 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);
@@ -12,6 +13,7 @@ const makeLogtoAdapter = (config) => (session) => {
         handleSignIn: makeHandleSignIn({ storage, createClient }),
         handleSignInCallback: makeHandleSignInCallback({ storage, createClient }),
         handleSignOut: makeHandleSignOut({ createClient }),
+        handleSignUp: makeHandleSignUp({ storage, createClient }),
         getContext: makeGetContext({ storage, createClient }),
     };
 };

package/lib/useCases/handleAuthRoutes/index.cjs

@@ -1,8 +1,9 @@
 'use strict';
 
-var index$2 = require('../handleSignIn/index.cjs');
-var index$1 = require('../handleSignInCallback/index.cjs');
+var index$3 = require('../handleSignIn/index.cjs');
+var index$2 = require('../handleSignInCallback/index.cjs');
 var index = require('../handleSignOut/index.cjs');
+var index$1 = require('../handleSignUp/index.cjs');
 var HandleAuthRoutesError = require('./HandleAuthRoutesError.cjs');
 
 const makeHandleAuthRoutes = (deps) => (dto) => async ({ request }) => {
@@ -18,13 +19,19 @@ const makeHandleAuthRoutes = (deps) => (dto) => async ({ request }) => {
     const config = dto[configKey];
     switch (configKey) {
         case 'sign-in': {
-            const handler = index$2.makeHandleSignIn({
+            const handler = index$3.makeHandleSignIn({
                 redirectBackTo: `${baseUrl}${config.redirectBackTo}`,
             }, { sessionStorage, createLogtoAdapter });
             return handler(request);
         }
         case 'sign-in-callback': {
-            const handler = index$1.makeHandleSignInCallback({
+            const handler = index$2.makeHandleSignInCallback({
+                redirectBackTo: `${baseUrl}${config.redirectBackTo}`,
+            }, { sessionStorage, createLogtoAdapter });
+            return handler(request);
+        }
+        case 'sign-up': {
+            const handler = index$1.makeHandleSignUp({
                 redirectBackTo: `${baseUrl}${config.redirectBackTo}`,
             }, { sessionStorage, createLogtoAdapter });
             return handler(request);

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

@@ -4,7 +4,7 @@ type AuthRouteConfig = {
     readonly path: string;
     readonly redirectBackTo: string;
 };
-type PossibleRouteTypes = 'sign-in' | 'sign-in-callback' | 'sign-out';
+type PossibleRouteTypes = 'sign-in' | 'sign-in-callback' | 'sign-out' | 'sign-up';
 type HandleAuthRoutesDto = Record<PossibleRouteTypes, AuthRouteConfig>;
 type MakeHandleAuthRoutesDto = {
     readonly baseUrl: string;

package/lib/useCases/handleAuthRoutes/index.js

@@ -1,6 +1,7 @@
 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 }) => {
@@ -27,6 +28,12 @@ const makeHandleAuthRoutes = (deps) => (dto) => async ({ request }) => {
             }, { 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}`,

package/lib/useCases/handleSignUp/HandleSignUpController.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+var node = require('@remix-run/node');
+var getCookieHeaderFromRequest = require('../../framework/get-cookie-header-from-request.cjs');
+
+class HandleSignUpController {
+    static { this.fromDto = (dto) => new HandleSignUpController({
+        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.HandleSignUpController = HandleSignUpController;

package/lib/useCases/handleSignUp/HandleSignUpController.d.ts

@@ -0,0 +1,15 @@
+import type { TypedResponse } from '@remix-run/node';
+import type { HandleSignUpUseCase } from './HandleSignUpUseCase.js';
+type HandleSignUpControllerDto = {
+    readonly redirectUri: string;
+    readonly useCase: HandleSignUpUseCase;
+};
+export declare class HandleSignUpController {
+    private readonly properties;
+    static readonly fromDto: (dto: HandleSignUpControllerDto) => HandleSignUpController;
+    private readonly useCase;
+    private readonly redirectUri;
+    private constructor();
+    readonly execute: (request: Request) => Promise<TypedResponse<never>>;
+}
+export {};

package/lib/useCases/handleSignUp/HandleSignUpController.js

@@ -0,0 +1,29 @@
+import { redirect } from '@remix-run/node';
+import { getCookieHeaderFromRequest } from '../../framework/get-cookie-header-from-request.js';
+
+class HandleSignUpController {
+    static { this.fromDto = (dto) => new HandleSignUpController({
+        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 { HandleSignUpController };

package/lib/useCases/handleSignUp/HandleSignUpController.spec.d.ts

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

package/lib/useCases/handleSignUp/HandleSignUpUseCase.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+const makeHandleSignUpUseCase = (deps) => async (request) => {
+    const { sessionStorage, createLogtoAdapter } = deps;
+    const session = await sessionStorage.getSession(request.cookieHeader);
+    const logto = createLogtoAdapter(session);
+    const response = await logto.handleSignUp({
+        redirectUri: request.redirectUri,
+    });
+    const cookieHeader = await sessionStorage.commitSession(response.session);
+    return {
+        cookieHeader,
+        navigateToUrl: response.navigateToUrl,
+    };
+};
+
+exports.makeHandleSignUpUseCase = makeHandleSignUpUseCase;

package/lib/useCases/handleSignUp/HandleSignUpUseCase.d.ts

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

package/lib/useCases/handleSignUp/HandleSignUpUseCase.js

@@ -0,0 +1,15 @@
+const makeHandleSignUpUseCase = (deps) => async (request) => {
+    const { sessionStorage, createLogtoAdapter } = deps;
+    const session = await sessionStorage.getSession(request.cookieHeader);
+    const logto = createLogtoAdapter(session);
+    const response = await logto.handleSignUp({
+        redirectUri: request.redirectUri,
+    });
+    const cookieHeader = await sessionStorage.commitSession(response.session);
+    return {
+        cookieHeader,
+        navigateToUrl: response.navigateToUrl,
+    };
+};
+
+export { makeHandleSignUpUseCase };

package/lib/useCases/handleSignUp/HandleSignUpUseCase.spec.d.ts

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

package/lib/useCases/handleSignUp/index.cjs

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

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

@@ -0,0 +1,11 @@
+import type { SessionStorage } from '@remix-run/node';
+import type { CreateLogtoAdapter } from '../../infrastructure/logto/index.js';
+type HandleSignUpDto = {
+    readonly redirectBackTo: string;
+};
+type HandleSignUpDeps = {
+    readonly createLogtoAdapter: CreateLogtoAdapter;
+    readonly sessionStorage: SessionStorage;
+};
+export declare const makeHandleSignUp: (dto: HandleSignUpDto, deps: HandleSignUpDeps) => (request: Request) => Promise<import("@remix-run/node").TypedResponse<never>>;
+export {};

package/lib/useCases/handleSignUp/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logto/remix",
-  "version": "2.1.9",
+  "version": "2.2.1",
   "type": "module",
   "main": "./lib/index.cjs",
   "module": "./lib/index.js",
@@ -21,7 +21,7 @@
     "directory": "packages/remix"
   },
   "dependencies": {
-    "@logto/node": "^2.5.0"
+    "@logto/node": "^2.5.2"
   },
   "devDependencies": {
     "@remix-run/node": "^2.0.0",