@main12/auth-login 0.1.0

package/dist/endpoints/authEndpoints.js

@@ -0,0 +1,422 @@
+import { generateOtp, hashOtp, verifyOtp, getOtpExpiry, isOtpExpired } from '../auth/domain/otp.js';
+import { generateWelcomeEmail, generateOtpEmail } from '../components/email/index.js';
+/**
+ * POST /api/auth/check-email — Check if user exists and has password
+ */ export const checkEmailEndpoint = {
+    path: '/api/auth/check-email',
+    method: 'post',
+    handler: async (req)=>{
+        const { email } = req.json ? await req.json() : req.body || {};
+        if (!email) return Response.json({
+            error: 'Email is required'
+        }, {
+            status: 400
+        });
+        try {
+            const users = await req.payload.find({
+                collection: 'users',
+                where: {
+                    email: {
+                        equals: email.toLowerCase().trim()
+                    }
+                },
+                limit: 1
+            });
+            if (!users.docs?.length) {
+                return Response.json({
+                    exists: false,
+                    hasPassword: false,
+                    authProvider: null
+                });
+            }
+            const user = users.docs[0];
+            return Response.json({
+                exists: true,
+                hasPassword: !!user.password,
+                authProvider: user.authProvider || null
+            });
+        } catch (err) {
+            return Response.json({
+                error: 'Failed to check email'
+            }, {
+                status: 500
+            });
+        }
+    }
+};
+/**
+ * POST /api/auth/otp/send — Generate OTP, store it, send email via Payload
+ */ export const sendOtpEndpoint = {
+    path: '/api/auth/otp/send',
+    method: 'post',
+    handler: async (req)=>{
+        const body = req.json ? await req.json() : req.body || {};
+        const { email, purpose = 'login' } = body;
+        if (!email) return Response.json({
+            success: false,
+            message: 'Email is required'
+        }, {
+            status: 400
+        });
+        try {
+            // Check user exists
+            const users = await req.payload.find({
+                collection: 'users',
+                where: {
+                    email: {
+                        equals: email.toLowerCase().trim()
+                    }
+                },
+                limit: 1
+            });
+            if (!users.docs?.length) {
+                return Response.json({
+                    success: false,
+                    message: 'No account found with this email'
+                }, {
+                    status: 404
+                });
+            }
+            const user = users.docs[0];
+            const otp = generateOtp();
+            const hashed = hashOtp(otp);
+            const expiresAt = getOtpExpiry(10);
+            // Store OTP in a custom collection or users doc
+            // For simplicity, we'll use the users collection with an otp field
+            // In production, use a dedicated `otps` collection
+            try {
+                await req.payload.update({
+                    collection: 'users',
+                    id: user.id,
+                    data: {
+                        otpHash: hashed,
+                        otpPurpose: purpose,
+                        otpAttempts: 0,
+                        otpExpiresAt: expiresAt.toISOString()
+                    }
+                });
+            } catch  {
+                // If the users collection doesn't have OTP fields, create a dedicated otps doc
+                await req.payload.create({
+                    collection: 'otps',
+                    data: {
+                        email: email.toLowerCase().trim(),
+                        hash: hashed,
+                        purpose,
+                        attempts: 0,
+                        expiresAt: expiresAt.toISOString()
+                    }
+                });
+            }
+            // Send email via Payload's configured adapter
+            const emailResult = purpose === 'signup' ? generateOtpEmail({
+                userName: user.name || user.email,
+                otp,
+                purpose: 'login'
+            }) : generateOtpEmail({
+                userName: user.name || user.email,
+                otp,
+                purpose: purpose
+            });
+            await req.payload.sendEmail({
+                to: email,
+                subject: emailResult.subject,
+                html: emailResult.html
+            });
+            return Response.json({
+                success: true
+            });
+        } catch (err) {
+            console.error('OTP send error:', err);
+            return Response.json({
+                success: false,
+                message: err.message || 'Failed to send OTP'
+            }, {
+                status: 500
+            });
+        }
+    }
+};
+/**
+ * POST /api/auth/otp/verify — Verify OTP and login the user
+ */ export const verifyOtpEndpoint = {
+    path: '/api/auth/otp/verify',
+    method: 'post',
+    handler: async (req)=>{
+        const body = req.json ? await req.json() : req.body || {};
+        const { email, otp } = body;
+        if (!email || !otp) return Response.json({
+            success: false,
+            error: 'Email and OTP are required'
+        }, {
+            status: 400
+        });
+        try {
+            // Find OTP record — try users collection first
+            const users = await req.payload.find({
+                collection: 'users',
+                where: {
+                    email: {
+                        equals: email.toLowerCase().trim()
+                    }
+                },
+                limit: 1
+            });
+            let otpHash;
+            let otpAttempts = 0;
+            let otpExpiresAt;
+            const user = users.docs?.[0];
+            if (user?.otpHash) {
+                otpHash = user.otpHash;
+                otpAttempts = user.otpAttempts || 0;
+                otpExpiresAt = user.otpExpiresAt;
+            } else {
+                // Try dedicated otps collection
+                const otpDocs = await req.payload.find({
+                    collection: 'otps',
+                    where: {
+                        email: {
+                            equals: email.toLowerCase().trim()
+                        }
+                    },
+                    sort: '-createdAt',
+                    limit: 1
+                });
+                const otpDoc = otpDocs.docs?.[0];
+                if (otpDoc) {
+                    otpHash = otpDoc.hash;
+                    otpAttempts = otpDoc.attempts || 0;
+                    otpExpiresAt = otpDoc.expiresAt;
+                }
+            }
+            if (!otpHash) {
+                return Response.json({
+                    success: false,
+                    error: 'No OTP found. Please request a new code.'
+                }, {
+                    status: 400
+                });
+            }
+            if (isOtpExpired(otpExpiresAt)) {
+                return Response.json({
+                    success: false,
+                    error: 'Code has expired. Please request a new one.'
+                }, {
+                    status: 400
+                });
+            }
+            if (otpAttempts >= 3) {
+                return Response.json({
+                    success: false,
+                    error: 'Too many attempts. Please request a new code.'
+                }, {
+                    status: 400
+                });
+            }
+            // Increment attempts
+            if (user?.otpHash) {
+                await req.payload.update({
+                    collection: 'users',
+                    id: user.id,
+                    data: {
+                        otpAttempts: otpAttempts + 1
+                    }
+                });
+            }
+            if (!verifyOtp(otp, otpHash)) {
+                return Response.json({
+                    success: false,
+                    error: 'Invalid code. Please try again.'
+                }, {
+                    status: 400
+                });
+            }
+            // OTP is valid — log the user in
+            // Payload requires password for login. We use the stored password
+            // (auto-generated during signup or previously set by user).
+            const userData = users.docs?.[0];
+            const result = await req.payload.login({
+                collection: 'users',
+                data: {
+                    email: email.toLowerCase().trim(),
+                    password: userData?.password || ''
+                },
+                req: req
+            });
+            // Clean up OTP
+            if (user?.otpHash) {
+                await req.payload.update({
+                    collection: 'users',
+                    id: user.id,
+                    data: {
+                        otpHash: null,
+                        otpPurpose: null,
+                        otpAttempts: null,
+                        otpExpiresAt: null
+                    }
+                });
+            }
+            return Response.json({
+                success: true,
+                token: result.token,
+                isNewUser: !user?.password
+            });
+        } catch (err) {
+            console.error('OTP verify error:', err);
+            return Response.json({
+                success: false,
+                error: err.message || 'Verification failed'
+            }, {
+                status: 500
+            });
+        }
+    }
+};
+/**
+ * POST /api/auth/set-password — Set/update password for authenticated user
+ */ export const setPasswordEndpoint = {
+    path: '/api/auth/set-password',
+    method: 'post',
+    handler: async (req)=>{
+        const body = req.json ? await req.json() : req.body || {};
+        const { password, confirmPassword } = body;
+        if (!password || !confirmPassword) {
+            return Response.json({
+                success: false,
+                message: 'Password and confirmation are required'
+            }, {
+                status: 400
+            });
+        }
+        if (password !== confirmPassword) {
+            return Response.json({
+                success: false,
+                message: 'Passwords do not match'
+            }, {
+                status: 400
+            });
+        }
+        if (password.length < 8) {
+            return Response.json({
+                success: false,
+                message: 'Password must be at least 8 characters'
+            }, {
+                status: 400
+            });
+        }
+        try {
+            const user = req.user;
+            if (!user) {
+                return Response.json({
+                    success: false,
+                    message: 'Not authenticated'
+                }, {
+                    status: 401
+                });
+            }
+            await req.payload.update({
+                collection: 'users',
+                id: user.id,
+                data: {
+                    password,
+                    confirmPassword
+                }
+            });
+            return Response.json({
+                success: true,
+                message: 'Password set successfully'
+            });
+        } catch (err) {
+            return Response.json({
+                success: false,
+                message: err.message || 'Failed to set password'
+            }, {
+                status: 500
+            });
+        }
+    }
+};
+/**
+ * POST /api/auth/signup — Create new user + send welcome email
+ */ export const signupEndpoint = {
+    path: '/api/auth/signup',
+    method: 'post',
+    handler: async (req)=>{
+        const body = req.json ? await req.json() : req.body || {};
+        const { name, email } = body;
+        if (!email) {
+            return Response.json({
+                success: false,
+                message: 'Email is required'
+            }, {
+                status: 400
+            });
+        }
+        try {
+            // Check if user already exists
+            const existing = await req.payload.find({
+                collection: 'users',
+                where: {
+                    email: {
+                        equals: email.toLowerCase().trim()
+                    }
+                },
+                limit: 1
+            });
+            if (existing.docs?.length) {
+                return Response.json({
+                    success: false,
+                    message: 'An account with this email already exists'
+                }, {
+                    status: 409
+                });
+            }
+            // Auto-generate a random password (user sets their own via OTP flow)
+            const tempPassword = `tmp_${Math.random().toString(36).slice(2)}_${Date.now()}`;
+            const user = await req.payload.create({
+                collection: 'users',
+                data: {
+                    email: email.toLowerCase().trim(),
+                    password: tempPassword,
+                    name: name?.trim() || email.split('@')[0],
+                    role: 'user'
+                }
+            });
+            // Send welcome email
+            try {
+                const welcomeEmail = generateWelcomeEmail({
+                    userName: name?.trim() || email.split('@')[0],
+                    userEmail: email.toLowerCase().trim()
+                });
+                await req.payload.sendEmail({
+                    to: email,
+                    subject: welcomeEmail.subject,
+                    html: welcomeEmail.html
+                });
+            } catch (emailErr) {
+                console.error('Welcome email failed:', emailErr);
+            // Don't fail signup if email fails
+            }
+            return Response.json({
+                success: true,
+                message: 'Account created',
+                userId: user.id
+            });
+        } catch (err) {
+            console.error('Signup error:', err);
+            return Response.json({
+                success: false,
+                message: err.message || 'Signup failed'
+            }, {
+                status: 500
+            });
+        }
+    }
+};
+export const authEndpoints = [
+    checkEmailEndpoint,
+    sendOtpEndpoint,
+    verifyOtpEndpoint,
+    setPasswordEndpoint,
+    signupEndpoint
+];

package/dist/exports/client.d.ts

@@ -0,0 +1,24 @@
+export { useLoginFlow } from '../auth/application/hooks/useLoginFlow.js';
+export { useVerifyOtpFlow } from '../auth/application/hooks/useVerifyOtpFlow.js';
+export { useForgotPasswordFlow } from '../auth/application/hooks/useForgotPasswordFlow.js';
+export { useSetPasswordFlow } from '../auth/application/hooks/useSetPasswordFlow.js';
+export { checkEmail, sendOtp, verifyOtp, setUserPassword, signup, initiateGoogleLogin, } from '../auth/application/services/authService.js';
+export { evaluatePasswordStrength, isPasswordValid, MIN_PASSWORD_LENGTH } from '../auth/domain/passwordRules.js';
+export { default as LoginPage } from '../components/pages/LoginPage.js';
+export { default as SignupPage } from '../components/pages/SignupPage.js';
+export { default as ForgotPasswordPage } from '../components/pages/ForgotPasswordPage.js';
+export { default as VerifyOtpPage } from '../components/pages/VerifyOtpPage.js';
+export { default as SetPasswordPage } from '../components/pages/SetPasswordPage.js';
+export { AuthLayout } from '../components/AuthLayout.js';
+export { PoweredBy } from '../components/PoweredBy.js';
+export type { LoginStep, OTPPurpose, CheckEmailResponse, SendOtpResponse, VerifyOtpResponse, SetPasswordResponse, SignupResponse, PasswordStrengthResult, } from '../auth/domain/types.js';
+export type { UseLoginFlowOptions } from '../auth/application/hooks/useLoginFlow.js';
+export type { UseVerifyOtpFlowOptions } from '../auth/application/hooks/useVerifyOtpFlow.js';
+export type { UseSetPasswordFlowOptions } from '../auth/application/hooks/useSetPasswordFlow.js';
+export type { LoginPageProps } from '../components/pages/LoginPage.js';
+export type { SignupPageProps } from '../components/pages/SignupPage.js';
+export type { ForgotPasswordPageProps } from '../components/pages/ForgotPasswordPage.js';
+export type { VerifyOtpPageProps } from '../components/pages/VerifyOtpPage.js';
+export type { SetPasswordPageProps } from '../components/pages/SetPasswordPage.js';
+export type { AuthLayoutConfig, AuthLayoutProps } from '../components/AuthLayout.js';
+export type { PoweredByProps } from '../components/PoweredBy.js';

package/dist/exports/client.js

@@ -0,0 +1,22 @@
+'use client';
+// ============================================================
+// Client-side exports for @main12/auth-login/client
+// ============================================================
+// Auth hooks
+export { useLoginFlow } from '../auth/application/hooks/useLoginFlow.js';
+export { useVerifyOtpFlow } from '../auth/application/hooks/useVerifyOtpFlow.js';
+export { useForgotPasswordFlow } from '../auth/application/hooks/useForgotPasswordFlow.js';
+export { useSetPasswordFlow } from '../auth/application/hooks/useSetPasswordFlow.js';
+// Auth service functions (client-side fetch wrappers)
+export { checkEmail, sendOtp, verifyOtp, setUserPassword, signup, initiateGoogleLogin } from '../auth/application/services/authService.js';
+// Domain utilities
+export { evaluatePasswordStrength, isPasswordValid, MIN_PASSWORD_LENGTH } from '../auth/domain/passwordRules.js';
+// Page components
+export { default as LoginPage } from '../components/pages/LoginPage.js';
+export { default as SignupPage } from '../components/pages/SignupPage.js';
+export { default as ForgotPasswordPage } from '../components/pages/ForgotPasswordPage.js';
+export { default as VerifyOtpPage } from '../components/pages/VerifyOtpPage.js';
+export { default as SetPasswordPage } from '../components/pages/SetPasswordPage.js';
+// Layout & shared components
+export { AuthLayout } from '../components/AuthLayout.js';
+export { PoweredBy } from '../components/PoweredBy.js';

package/dist/exports/rsc.d.ts

@@ -0,0 +1,6 @@
+export { wrapInBaseTemplate, DEFAULT_COLORS, SOCIAL_ICONS, getBaseUrl, getSenderEmail, getEmailTranslations, generateOtpEmail, generateWelcomeEmail, generatePasswordResetEmail, generatePasswordChangedEmail, } from '../components/email/index.js';
+export type { BaseTemplateOptions, } from '../components/email/baseTemplate.js';
+export type { EmailColors, SocialLink, SocialPlatform, } from '../components/email/constants.js';
+export type { SupportedLanguage, EmailTranslations, } from '../components/email/translations.js';
+export type { OtpEmailParams, OtpEmailResult, WelcomeEmailParams, WelcomeEmailResult, PasswordResetEmailParams, PasswordResetEmailResult, PasswordChangedEmailParams, PasswordChangedEmailResult, } from '../components/email/index.js';
+export type { AuthLoginPluginOptions } from '../index.js';

package/dist/exports/rsc.js

@@ -0,0 +1,5 @@
+// ============================================================
+// RSC (React Server Components) exports for @main12/auth-login/rsc
+// ============================================================
+// Email template system (server-only — uses Node APIs)
+export { wrapInBaseTemplate, DEFAULT_COLORS, SOCIAL_ICONS, getBaseUrl, getSenderEmail, getEmailTranslations, generateOtpEmail, generateWelcomeEmail, generatePasswordResetEmail, generatePasswordChangedEmail } from '../components/email/index.js';

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import type { Config } from 'payload';
+export interface AuthLoginPluginOptions {
+    /** Enable/disable the plugin */
+    enabled?: boolean;
+    /** Project name used in emails */
+    projectName?: string;
+    /** Contact email used in email footers */
+    contactEmail?: string;
+    /** Domain for links in emails */
+    domain?: string;
+}
+export declare const authLoginPlugin: (options?: AuthLoginPluginOptions) => (config: Config) => Config;

package/dist/index.js

@@ -0,0 +1,16 @@
+import { authEndpoints } from './endpoints/authEndpoints.js';
+export const authLoginPlugin = (options = {})=>(config)=>{
+        if (options.enabled === false) return config;
+        // Register auth API endpoints
+        config.endpoints = [
+            ...config.endpoints || [],
+            ...authEndpoints
+        ];
+        // Chain onInit
+        const incomingOnInit = config.onInit;
+        config.onInit = async (payload)=>{
+            if (incomingOnInit) await incomingOnInit(payload);
+            payload.logger.info(`[auth-login] Plugin initialized for ${options.projectName || 'project'}`);
+        };
+        return config;
+    };

package/package.json

@@ -0,0 +1,115 @@
+{
+  "name": "@main12/auth-login",
+  "version": "0.1.0",
+  "description": "Reusable Payload CMS auth plugin — login, signup, OTP, forgot password, branded emails, Powered by Main12",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./client": {
+      "import": "./src/exports/client.ts",
+      "types": "./src/exports/client.ts",
+      "default": "./src/exports/client.ts"
+    },
+    "./rsc": {
+      "import": "./src/exports/rsc.ts",
+      "types": "./src/exports/rsc.ts",
+      "default": "./src/exports/rsc.ts"
+    }
+  },
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "pnpm copyfiles && pnpm build:types && pnpm build:swc",
+    "build:swc": "swc ./src -d ./dist --config-file .swcrc --strip-leading-paths",
+    "build:types": "tsc --outDir dist",
+    "clean": "rimraf {dist,*.tsbuildinfo}",
+    "copyfiles": "copyfiles -u 1 \"src/**/*.{html,css,scss,ttf,woff,woff2,eot,svg,jpg,png,json}\" dist/",
+    "dev": "next dev dev --turbo",
+    "dev:generate-importmap": "pnpm dev:payload generate:importmap",
+    "dev:generate-types": "pnpm dev:payload generate:types",
+    "dev:payload": "cross-env PAYLOAD_CONFIG_PATH=./dev/payload.config.ts payload",
+    "lint": "eslint",
+    "lint:fix": "eslint ./src --fix",
+    "test": "vitest"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.2.0",
+    "@payloadcms/db-sqlite": "3.82.1",
+    "@payloadcms/next": "3.82.1",
+    "@payloadcms/richtext-lexical": "3.82.1",
+    "@payloadcms/ui": "3.82.1",
+    "@swc/cli": "0.6.0",
+    "@tailwindcss/postcss": "^4.3.3",
+    "@types/node": "24.12.3",
+    "@types/react": "19.2.14",
+    "@types/react-dom": "19.2.3",
+    "copyfiles": "2.4.1",
+    "cross-env": "10.1.0",
+    "eslint": "^9.23.0",
+    "next": "16.2.7",
+    "payload": "3.82.1",
+    "react": "19.2.6",
+    "react-dom": "19.2.6",
+    "rimraf": "3.0.2",
+    "sharp": "0.34.2",
+    "tailwindcss": "^4.3.3",
+    "typescript": "6.0.3",
+    "vitest": "4.1.6"
+  },
+  "peerDependencies": {
+    "next": "^16.0.0",
+    "payload": "^3.82.0",
+    "react": "^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@heroui/react": {
+      "optional": true
+    },
+    "framer-motion": {
+      "optional": true
+    },
+    "next-intl": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.20.2"
+  },
+  "publishConfig": {
+    "exports": {
+      ".": {
+        "import": "./dist/index.js",
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "./client": {
+        "import": "./dist/exports/client.js",
+        "types": "./dist/exports/client.d.ts",
+        "default": "./dist/exports/client.js"
+      },
+      "./rsc": {
+        "import": "./dist/exports/rsc.js",
+        "types": "./dist/exports/rsc.d.ts",
+        "default": "./dist/exports/rsc.js"
+      }
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "@swc/core",
+      "sharp",
+      "esbuild"
+    ]
+  },
+  "registry": "https://registry.npmjs.org/"
+}