securepool 1.0.0

package/packages/persistence/src/prisma/repositories/PrismaOtpRepository.ts

@@ -0,0 +1,43 @@
+import { PrismaClient } from "@prisma/client";
+import { OtpCode } from "@securepool/core";
+import { IOtpRepository } from "@securepool/application";
+
+export class PrismaOtpRepository implements IOtpRepository {
+  constructor(private readonly prisma: PrismaClient) {}
+
+  async save(otp: OtpCode): Promise<void> {
+    await this.prisma.otpCode.create({
+      data: {
+        id: otp.id,
+        userId: otp.userId,
+        code: otp.code,
+        expiresAt: otp.expiresAt,
+        attempts: otp.attempts,
+      },
+    });
+  }
+
+  async findLatest(userId: string): Promise<OtpCode | null> {
+    const record = await this.prisma.otpCode.findFirst({
+      where: { userId },
+      orderBy: { expiresAt: "desc" },
+    });
+    if (!record) return null;
+    return new OtpCode(record.id, record.userId, record.code, record.expiresAt, record.attempts);
+  }
+
+  async update(otp: OtpCode): Promise<void> {
+    await this.prisma.otpCode.update({
+      where: { id: otp.id },
+      data: {
+        code: otp.code,
+        expiresAt: otp.expiresAt,
+        attempts: otp.attempts,
+      },
+    });
+  }
+
+  async deleteAllForUser(userId: string): Promise<void> {
+    await this.prisma.otpCode.deleteMany({ where: { userId } });
+  }
+}

package/packages/persistence/src/prisma/repositories/PrismaRoleRepository.ts

@@ -0,0 +1,36 @@
+import { PrismaClient } from "@prisma/client";
+import { Role, UserRole } from "@securepool/core";
+import { IRoleRepository } from "@securepool/application";
+
+export class PrismaRoleRepository implements IRoleRepository {
+  constructor(private readonly prisma: PrismaClient) {}
+
+  async findById(id: string): Promise<Role | null> {
+    const record = await this.prisma.role.findUnique({ where: { id } });
+    if (!record) return null;
+    return new Role(record.id, record.name);
+  }
+
+  async findByName(name: string): Promise<Role | null> {
+    const record = await this.prisma.role.findUnique({ where: { name } });
+    if (!record) return null;
+    return new Role(record.id, record.name);
+  }
+
+  async assignRole(userRole: UserRole): Promise<void> {
+    await this.prisma.userRole.create({
+      data: {
+        userId: userRole.userId,
+        roleId: userRole.roleId,
+      },
+    });
+  }
+
+  async getUserRoles(userId: string): Promise<Role[]> {
+    const userRoles = await this.prisma.userRole.findMany({
+      where: { userId },
+      include: { role: true },
+    });
+    return userRoles.map((ur: any) => new Role(ur.role.id, ur.role.name));
+  }
+}

package/packages/persistence/src/prisma/repositories/PrismaSessionRepository.ts

@@ -0,0 +1,39 @@
+import { PrismaClient } from "@prisma/client";
+import { Session } from "@securepool/core";
+import { ISessionRepository } from "@securepool/application";
+
+export class PrismaSessionRepository implements ISessionRepository {
+  constructor(private readonly prisma: PrismaClient) {}
+
+  async create(session: Session): Promise<void> {
+    await this.prisma.session.create({
+      data: {
+        id: session.id,
+        userId: session.userId,
+        device: session.device,
+        ip: session.ip,
+        createdAt: session.createdAt,
+        isActive: session.isActive,
+      },
+    });
+  }
+
+  async findByUserId(userId: string): Promise<Session[]> {
+    const records = await this.prisma.session.findMany({ where: { userId } });
+    return records.map((record: any) => new Session(record.id, record.userId, record.device, record.ip, record.createdAt, record.isActive));
+  }
+
+  async deactivate(sessionId: string): Promise<void> {
+    await this.prisma.session.update({
+      where: { id: sessionId },
+      data: { isActive: false },
+    });
+  }
+
+  async deactivateAllForUser(userId: string): Promise<void> {
+    await this.prisma.session.updateMany({
+      where: { userId },
+      data: { isActive: false },
+    });
+  }
+}

package/packages/persistence/src/prisma/repositories/PrismaTokenRepository.ts

@@ -0,0 +1,50 @@
+import { PrismaClient } from "@prisma/client";
+import { RefreshToken } from "@securepool/core";
+import { ITokenRepository } from "@securepool/application";
+
+export class PrismaTokenRepository implements ITokenRepository {
+  constructor(private readonly prisma: PrismaClient) {}
+
+  async save(token: RefreshToken): Promise<void> {
+    await this.prisma.refreshToken.create({
+      data: {
+        id: token.id,
+        userId: token.userId,
+        tokenHash: token.tokenHash,
+        expiresAt: token.expiresAt,
+        isRevoked: token.isRevoked,
+      },
+    });
+  }
+
+  async findByTokenHash(tokenHash: string): Promise<RefreshToken | null> {
+    const record = await this.prisma.refreshToken.findFirst({ where: { tokenHash } });
+    if (!record) return null;
+    return new RefreshToken(record.id, record.userId, record.tokenHash, record.expiresAt, record.isRevoked);
+  }
+
+  async findActiveByUserId(userId: string): Promise<RefreshToken[]> {
+    const records = await this.prisma.refreshToken.findMany({
+      where: {
+        userId,
+        isRevoked: false,
+        expiresAt: { gt: new Date() },
+      },
+    });
+    return records.map((record: any) => new RefreshToken(record.id, record.userId, record.tokenHash, record.expiresAt, record.isRevoked));
+  }
+
+  async revoke(tokenId: string): Promise<void> {
+    await this.prisma.refreshToken.update({
+      where: { id: tokenId },
+      data: { isRevoked: true },
+    });
+  }
+
+  async revokeAllForUser(userId: string): Promise<void> {
+    await this.prisma.refreshToken.updateMany({
+      where: { userId },
+      data: { isRevoked: true },
+    });
+  }
+}

package/packages/persistence/src/prisma/repositories/PrismaUserRepository.ts

@@ -0,0 +1,45 @@
+import { PrismaClient } from "@prisma/client";
+import { User } from "@securepool/core";
+import { IUserRepository } from "@securepool/application";
+
+export class PrismaUserRepository implements IUserRepository {
+  constructor(private readonly prisma: PrismaClient) {}
+
+  async findById(id: string): Promise<User | null> {
+    const record = await this.prisma.user.findUnique({ where: { id } });
+    if (!record) return null;
+    return new User(record.id, record.tenantId, record.email, record.passwordHash, record.isVerified, record.createdAt);
+  }
+
+  async findByEmail(email: string, tenantId: string): Promise<User | null> {
+    const record = await this.prisma.user.findUnique({
+      where: { email_tenantId: { email, tenantId } },
+    });
+    if (!record) return null;
+    return new User(record.id, record.tenantId, record.email, record.passwordHash, record.isVerified, record.createdAt);
+  }
+
+  async create(user: User): Promise<void> {
+    await this.prisma.user.create({
+      data: {
+        id: user.id,
+        tenantId: user.tenantId,
+        email: user.email,
+        passwordHash: user.passwordHash,
+        isVerified: user.isVerified,
+        createdAt: user.createdAt,
+      },
+    });
+  }
+
+  async update(user: User): Promise<void> {
+    await this.prisma.user.update({
+      where: { id: user.id },
+      data: {
+        email: user.email,
+        passwordHash: user.passwordHash,
+        isVerified: user.isVerified,
+      },
+    });
+  }
+}

package/packages/persistence/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}

package/packages/react-sdk/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@securepool/react-sdk",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0"
+  }
+}

package/packages/react-sdk/src/components/GoogleLoginButton.tsx

@@ -0,0 +1,54 @@
+import React from "react";
+import { useAuth } from "../hooks/useAuth";
+
+interface GoogleLoginButtonProps {
+  onSuccess?: () => void;
+  onError?: (error: string) => void;
+  className?: string;
+  style?: React.CSSProperties;
+  label?: string;
+}
+
+export const GoogleLoginButton: React.FC<GoogleLoginButtonProps> = ({
+  onSuccess,
+  onError,
+  className,
+  style,
+  label = "Sign in with Google",
+}) => {
+  const { loginWithGoogle, isLoading } = useAuth();
+
+  const handleClick = async () => {
+    try {
+      // In production, integrate with Google Identity Services SDK
+      // to obtain the credential token, then pass it here.
+      const google = (window as any).google;
+      if (google?.accounts?.id) {
+        google.accounts.id.prompt((response: any) => {
+          if (response.credential) {
+            loginWithGoogle(response.credential).then(onSuccess).catch((err: any) => {
+              onError?.(err.message);
+            });
+          }
+        });
+      } else {
+        throw new Error(
+          "Google Identity Services SDK not loaded. Add the script to your HTML."
+        );
+      }
+    } catch (err: any) {
+      onError?.(err.message);
+    }
+  };
+
+  return (
+    <button
+      onClick={handleClick}
+      disabled={isLoading}
+      className={className}
+      style={style}
+    >
+      {isLoading ? "Signing in..." : label}
+    </button>
+  );
+};

package/packages/react-sdk/src/components/LoginForm.tsx

@@ -0,0 +1,67 @@
+import React, { useState, FormEvent } from "react";
+import { useAuth } from "../hooks/useAuth";
+
+interface LoginFormProps {
+  onSuccess?: () => void;
+  onError?: (error: string) => void;
+  className?: string;
+  style?: React.CSSProperties;
+}
+
+export const LoginForm: React.FC<LoginFormProps> = ({
+  onSuccess,
+  onError,
+  className,
+  style,
+}) => {
+  const { login, isLoading, error } = useAuth();
+  const [email, setEmail] = useState("");
+  const [password, setPassword] = useState("");
+
+  const handleSubmit = async (e: FormEvent) => {
+    e.preventDefault();
+    try {
+      await login(email, password);
+      onSuccess?.();
+    } catch (err: any) {
+      onError?.(err.message);
+    }
+  };
+
+  return (
+    <form onSubmit={handleSubmit} className={className} style={style}>
+      <div>
+        <label htmlFor="sp-login-email">Email</label>
+        <input
+          id="sp-login-email"
+          type="email"
+          value={email}
+          onChange={(e) => setEmail(e.target.value)}
+          placeholder="Enter your email"
+          required
+          disabled={isLoading}
+        />
+      </div>
+      <div>
+        <label htmlFor="sp-login-password">Password</label>
+        <input
+          id="sp-login-password"
+          type="password"
+          value={password}
+          onChange={(e) => setPassword(e.target.value)}
+          placeholder="Enter your password"
+          required
+          disabled={isLoading}
+        />
+      </div>
+      {error && (
+        <div role="alert" style={{ color: "red" }}>
+          {error}
+        </div>
+      )}
+      <button type="submit" disabled={isLoading}>
+        {isLoading ? "Logging in..." : "Login"}
+      </button>
+    </form>
+  );
+};

package/packages/react-sdk/src/components/OTPVerification.tsx

@@ -0,0 +1,104 @@
+import React, { useState, FormEvent } from "react";
+import { useAuth } from "../hooks/useAuth";
+
+interface OTPVerificationProps {
+  onSuccess?: () => void;
+  onError?: (error: string) => void;
+  className?: string;
+  style?: React.CSSProperties;
+}
+
+export const OTPVerification: React.FC<OTPVerificationProps> = ({
+  onSuccess,
+  onError,
+  className,
+  style,
+}) => {
+  const { requestOtp, verifyOtp, isLoading, error } = useAuth();
+  const [email, setEmail] = useState("");
+  const [code, setCode] = useState("");
+  const [otpSent, setOtpSent] = useState(false);
+
+  const handleRequestOtp = async (e: FormEvent) => {
+    e.preventDefault();
+    try {
+      await requestOtp(email);
+      setOtpSent(true);
+    } catch (err: any) {
+      onError?.(err.message);
+    }
+  };
+
+  const handleVerifyOtp = async (e: FormEvent) => {
+    e.preventDefault();
+    try {
+      await verifyOtp(email, code);
+      onSuccess?.();
+    } catch (err: any) {
+      onError?.(err.message);
+    }
+  };
+
+  if (!otpSent) {
+    return (
+      <form onSubmit={handleRequestOtp} className={className} style={style}>
+        <div>
+          <label htmlFor="sp-otp-email">Email</label>
+          <input
+            id="sp-otp-email"
+            type="email"
+            value={email}
+            onChange={(e) => setEmail(e.target.value)}
+            placeholder="Enter your email"
+            required
+            disabled={isLoading}
+          />
+        </div>
+        {error && (
+          <div role="alert" style={{ color: "red" }}>
+            {error}
+          </div>
+        )}
+        <button type="submit" disabled={isLoading}>
+          {isLoading ? "Sending OTP..." : "Send OTP"}
+        </button>
+      </form>
+    );
+  }
+
+  return (
+    <form onSubmit={handleVerifyOtp} className={className} style={style}>
+      <div>
+        <label htmlFor="sp-otp-code">Enter OTP</label>
+        <input
+          id="sp-otp-code"
+          type="text"
+          value={code}
+          onChange={(e) => setCode(e.target.value)}
+          placeholder="Enter 6-digit OTP"
+          maxLength={6}
+          required
+          disabled={isLoading}
+        />
+      </div>
+      {error && (
+        <div role="alert" style={{ color: "red" }}>
+          {error}
+        </div>
+      )}
+      <button type="submit" disabled={isLoading}>
+        {isLoading ? "Verifying..." : "Verify OTP"}
+      </button>
+      <button
+        type="button"
+        onClick={() => {
+          setOtpSent(false);
+          setCode("");
+        }}
+        disabled={isLoading}
+      >
+        Back
+      </button>
+    </form>
+  );
+};

package/packages/react-sdk/src/components/SessionList.tsx

@@ -0,0 +1,64 @@
+import React, { useEffect } from "react";
+import { useAuth } from "../hooks/useAuth";
+
+interface SessionListProps {
+  className?: string;
+  style?: React.CSSProperties;
+}
+
+export const SessionList: React.FC<SessionListProps> = ({
+  className,
+  style,
+}) => {
+  const {
+    sessions,
+    fetchSessions,
+    revokeSession,
+    revokeAllSessions,
+    isLoading,
+  } = useAuth();
+
+  useEffect(() => {
+    fetchSessions();
+  }, [fetchSessions]);
+
+  return (
+    <div className={className} style={style}>
+      <h3>Active Sessions</h3>
+      {sessions.length === 0 && <p>No active sessions</p>}
+      <ul style={{ listStyle: "none", padding: 0 }}>
+        {sessions.map((session) => (
+          <li
+            key={session.id}
+            style={{
+              display: "flex",
+              justifyContent: "space-between",
+              alignItems: "center",
+              padding: "8px 0",
+              borderBottom: "1px solid #eee",
+            }}
+          >
+            <div>
+              <strong>{session.device}</strong>
+              <br />
+              <small>
+                IP: {session.ip} | {new Date(session.createdAt).toLocaleString()}
+              </small>
+            </div>
+            <button
+              onClick={() => revokeSession(session.id)}
+              disabled={isLoading}
+            >
+              Revoke
+            </button>
+          </li>
+        ))}
+      </ul>
+      {sessions.length > 0 && (
+        <button onClick={revokeAllSessions} disabled={isLoading}>
+          Revoke All Sessions
+        </button>
+      )}
+    </div>
+  );
+};

package/packages/react-sdk/src/components/SignupForm.tsx

@@ -0,0 +1,95 @@
+import React, { useState, FormEvent } from "react";
+import { useAuth } from "../hooks/useAuth";
+
+interface SignupFormProps {
+  onSuccess?: () => void;
+  onError?: (error: string) => void;
+  className?: string;
+  style?: React.CSSProperties;
+}
+
+export const SignupForm: React.FC<SignupFormProps> = ({
+  onSuccess,
+  onError,
+  className,
+  style,
+}) => {
+  const { register, isLoading, error } = useAuth();
+  const [email, setEmail] = useState("");
+  const [password, setPassword] = useState("");
+  const [confirmPassword, setConfirmPassword] = useState("");
+  const [localError, setLocalError] = useState<string | null>(null);
+
+  const handleSubmit = async (e: FormEvent) => {
+    e.preventDefault();
+    setLocalError(null);
+
+    if (password !== confirmPassword) {
+      setLocalError("Passwords do not match");
+      return;
+    }
+
+    if (password.length < 8) {
+      setLocalError("Password must be at least 8 characters");
+      return;
+    }
+
+    try {
+      await register(email, password);
+      onSuccess?.();
+    } catch (err: any) {
+      onError?.(err.message);
+    }
+  };
+
+  const displayError = localError || error;
+
+  return (
+    <form onSubmit={handleSubmit} className={className} style={style}>
+      <div>
+        <label htmlFor="sp-signup-email">Email</label>
+        <input
+          id="sp-signup-email"
+          type="email"
+          value={email}
+          onChange={(e) => setEmail(e.target.value)}
+          placeholder="Enter your email"
+          required
+          disabled={isLoading}
+        />
+      </div>
+      <div>
+        <label htmlFor="sp-signup-password">Password</label>
+        <input
+          id="sp-signup-password"
+          type="password"
+          value={password}
+          onChange={(e) => setPassword(e.target.value)}
+          placeholder="Create a password"
+          required
+          disabled={isLoading}
+        />
+      </div>
+      <div>
+        <label htmlFor="sp-signup-confirm">Confirm Password</label>
+        <input
+          id="sp-signup-confirm"
+          type="password"
+          value={confirmPassword}
+          onChange={(e) => setConfirmPassword(e.target.value)}
+          placeholder="Confirm your password"
+          required
+          disabled={isLoading}
+        />
+      </div>
+      {displayError && (
+        <div role="alert" style={{ color: "red" }}>
+          {displayError}
+        </div>
+      )}
+      <button type="submit" disabled={isLoading}>
+        {isLoading ? "Creating account..." : "Sign Up"}
+      </button>
+    </form>
+  );
+};

package/packages/react-sdk/src/context/AuthContext.ts

@@ -0,0 +1,4 @@
+import { createContext } from "react";
+import { AuthContextValue } from "../types";
+
+export const AuthContext = createContext<AuthContextValue | null>(null);