login now username+password based

packages/logic/domains/auth/config.base.ts

@@ -1,52 +1,19 @@
 import {
     admin,
     customSession,
-    magicLink,
     multiSession,
     username,
 } from "better-auth/plugins";
-import { getUserController, UserController } from "../user/controller";
-import { AuthController, getAuthController } from "./controller";
 import { drizzleAdapter } from "better-auth/adapters/drizzle";
-import { FlowExecCtx } from "@/core/flow.execution.context";
 import { UserRoleMap } from "@domains/user/data";
 import { getRedisInstance } from "@pkg/keystore";
-import { APIError } from "better-auth/api";
 import { settings } from "@core/settings";
 import { betterAuth } from "better-auth";
 import { logger } from "@pkg/logger";
 import { db, schema } from "@pkg/db";
-import { nanoid } from "nanoid";
 
-// Constants
-const EMAIL_EXPIRES_IN_MINS = 10;
-const EMAIL_EXPIRES_IN_SECONDS = 60 * EMAIL_EXPIRES_IN_MINS;
 const COOKIE_CACHE_MAX_AGE = 60 * 5;
-
-// Helper to create flow context for better-auth callbacks
-function createAuthFlowContext(contextLabel: string): FlowExecCtx {
-    return {
-        flowId: `auth:${contextLabel}:${nanoid(10)}`,
-    };
-}
-
-// Singleton controller instances
-let authControllerInstance: AuthController | null = null;
-let userControllerInstance: UserController | null = null;
-
-function getAuthControllerInstance(): AuthController {
-    if (!authControllerInstance) {
-        authControllerInstance = getAuthController();
-    }
-    return authControllerInstance;
-}
-
-function getUserControllerInstance(): UserController {
-    if (!userControllerInstance) {
-        userControllerInstance = getUserController();
-    }
-    return userControllerInstance;
-}
+const USERNAME_REGEX = /^[a-zA-Z0-9_]+$/;
 
 export const auth = betterAuth({
     trustedOrigins: ["http://localhost:5173", settings.betterAuthUrl],
@@ -66,48 +33,7 @@ export const auth = betterAuth({
             minUsernameLength: 5,
             maxUsernameLength: 20,
             usernameValidator: async (username) => {
-                const fctx = createAuthFlowContext("username-check");
-                const uc = getUserControllerInstance();
-
-                const result = await uc
-                    .isUsernameAvailable(fctx, username)
-                    .match(
-                        (isAvailable) => ({ success: true, isAvailable }),
-                        (error) => {
-                            logger.error(
-                                `[${fctx.flowId}] Failed to check username availability`,
-                                error,
-                            );
-                            return { success: false, isAvailable: false };
-                        },
-                    );
-
-                return result.isAvailable;
-            },
-        }),
-        magicLink({
-            expiresIn: EMAIL_EXPIRES_IN_SECONDS,
-            rateLimit: { window: 60, max: 4 },
-            sendMagicLink: async ({ email, token, url }, request) => {
-                const fctx = createAuthFlowContext("magic-link");
-                const ac = getAuthControllerInstance();
-
-                const result = await ac
-                    .sendMagicLink(fctx, email, token, url)
-                    .match(
-                        () => ({ success: true, error: undefined }),
-                        (error) => ({ success: false, error }),
-                    );
-
-                if (!result.success || result?.error) {
-                    logger.error(
-                        `[${fctx.flowId}] Failed to send magic link`,
-                        result.error,
-                    );
-                    throw new APIError("INTERNAL_SERVER_ERROR", {
-                        message: result.error?.message,
-                    });
-                }
+                return USERNAME_REGEX.test(username);
             },
         }),
         admin({
@@ -157,38 +83,6 @@ export const auth = betterAuth({
         },
     },
     user: {
-        changeEmail: {
-            enabled: true,
-            sendChangeEmailVerification: async (
-                { user, newEmail, url, token },
-                request,
-            ) => {
-                const fctx = createAuthFlowContext("email-change");
-                const ac = getAuthControllerInstance();
-
-                const result = await ac
-                    .sendEmailChangeVerificationEmail(
-                        fctx,
-                        newEmail,
-                        token,
-                        url,
-                    )
-                    .match(
-                        () => ({ success: true, error: undefined }),
-                        (error) => ({ success: false, error }),
-                    );
-
-                if (!result.success || result?.error) {
-                    logger.error(
-                        `[${fctx.flowId}] Failed to send email change verification`,
-                        result.error,
-                    );
-                    throw new APIError("INTERNAL_SERVER_ERROR", {
-                        message: result.error?.message,
-                    });
-                }
-            },
-        },
         modelName: "user",
         additionalFields: {
             onboardingDone: {

packages/logic/domains/auth/controller.ts

@@ -2,61 +2,14 @@ import { AuthContext, MiddlewareContext, MiddlewareOptions } from "better-auth";
 import { AccountRepository } from "../user/account.repository";
 import { FlowExecCtx } from "@/core/flow.execution.context";
 import { ResultAsync } from "neverthrow";
-import type { Err } from "@pkg/result";
 import { authErrors } from "./errors";
 import { logger } from "@pkg/logger";
 import { nanoid } from "nanoid";
 import { db } from "@pkg/db";
 
 export class AuthController {
-    private readonly mins = 10;
-
     constructor(private accountRepo: AccountRepository) {}
 
-    sendEmailChangeVerificationEmail(
-        fctx: FlowExecCtx,
-        newEmail: string,
-        token: string,
-        url: string,
-    ): ResultAsync<void, Err> {
-        logger.info("Sending email change verification link", {
-            ...fctx,
-            newEmail,
-        });
-        logger.debug("Original URL", { ...fctx, url });
-
-        const transformedUrl = url
-            .replace("/api/auth/verify-email", "/account/verify-email")
-            .replace("/api/", "/");
-
-        logger.debug("Transformed URL", { ...fctx, transformedUrl });
-
-        // Simulate email sending with 90/10 success/failure
-        const success = Math.random() > 0.1;
-
-        if (!success) {
-            logger.error("Failed to send email change verification link", {
-                ...fctx,
-                error: "Simulated email service failure",
-            });
-            return ResultAsync.fromPromise(
-                Promise.reject(
-                    authErrors.emailChangeVerificationFailed(
-                        fctx,
-                        "Simulated email service failure",
-                    ),
-                ),
-                (error) => error as Err,
-            );
-        }
-
-        logger.info("Email change verification sent successfully", {
-            ...fctx,
-            newEmail,
-        });
-        return ResultAsync.fromSafePromise(Promise.resolve(undefined));
-    }
-
     swapAccountPasswordForTwoFactor(
         fctx: FlowExecCtx,
         ctx: MiddlewareContext<
@@ -100,47 +53,6 @@ export class AuthController {
                 };
             });
     }
-
-    sendMagicLink(
-        fctx: FlowExecCtx,
-        email: string,
-        token: string,
-        url: string,
-    ): ResultAsync<void, Err> {
-        logger.info("Sending magic link", { ...fctx, email });
-        logger.debug("Original URL", { ...fctx, url });
-
-        const transformedUrl = url
-            .replace("/api/auth/magic-link/verify", "/auth/magic-link")
-            .replace("/api/", "/");
-
-        logger.debug("Transformed URL", { ...fctx, transformedUrl });
-
-        // Simulate email sending with 90/10 success/failure
-        const success = true;
-
-        if (!success) {
-            logger.error("Failed to send magic link email", {
-                ...fctx,
-                error: "Simulated email service failure",
-            });
-            return ResultAsync.fromPromise(
-                Promise.reject(
-                    authErrors.magicLinkEmailFailed(
-                        fctx,
-                        "Simulated email service failure",
-                    ),
-                ),
-                (error) => error as Err,
-            );
-        }
-
-        logger.info("Magic link email sent successfully (NOT REALLY)", {
-            ...fctx,
-            email,
-        });
-        return ResultAsync.fromSafePromise(Promise.resolve(undefined));
-    }
 }
 
 export function getAuthController(): AuthController {

packages/logic/domains/auth/errors.ts

@@ -3,33 +3,6 @@ import { getError } from "@pkg/logger";
 import { ERROR_CODES, type Err } from "@pkg/result";
 
 export const authErrors = {
-    emailSendFailed: (fctx: FlowExecCtx, detail: string): Err =>
-        getError({
-            flowId: fctx.flowId,
-            code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-            message: "Failed to send email",
-            description: "An error occurred while sending the email",
-            detail,
-        }),
-
-    magicLinkEmailFailed: (fctx: FlowExecCtx, detail: string): Err =>
-        getError({
-            flowId: fctx.flowId,
-            code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-            message: "Failed to send magic link email",
-            description: "An error occurred while sending the magic link",
-            detail,
-        }),
-
-    emailChangeVerificationFailed: (fctx: FlowExecCtx, detail: string): Err =>
-        getError({
-            flowId: fctx.flowId,
-            code: ERROR_CODES.INTERNAL_SERVER_ERROR,
-            message: "Failed to send email change verification link",
-            description: "An error occurred while sending the verification email",
-            detail,
-        }),
-
     passwordRotationFailed: (fctx: FlowExecCtx, detail: string): Err =>
         getError({
             flowId: fctx.flowId,