irismail 0.1.0

package/README.md

@@ -0,0 +1,158 @@
+# IrisMail
+
+A modular, secure, and easy-to-use Email and OTP service for Next.js applications, with built-in Shadcn UI support.
+
+## Features
+
+-   📧 **Email Service**: Simple wrapper around Nodemailer for sending emails.
+-   🔐 **Secure OTP**: Server-side OTP generation, encryption, and validation.
+-   🎨 **Shadcn UI**: Ready-to-use OTP Input component compatible with Shadcn UI.
+-   ⚡ **React Hook**: `useOTP` hook for managing timers, rate limiting, and resend cooldowns.
+-   🛡️ **Type-Safe**: Built with TypeScript.
+
+## Installation
+
+```bash
+npm install irismail
+# or
+yarn add irismail
+# or
+pnpm add irismail
+```
+
+## Usage
+
+### 1. Server-Side Setup (API Routes)
+
+Initialize the service with your email configuration and a secret key for encryption.
+
+```typescript
+// app/api/send-otp/route.ts
+import { IrisMailService } from 'irismail/server';
+import { NextResponse } from 'next/server';
+
+const irismail = new IrisMailService({
+  email: {
+    transport: {
+      host: 'smtp.gmail.com',
+      port: 587,
+      auth: {
+        user: process.env.GMAIL_USER,
+        pass: process.env.GMAIL_PASS,
+      },
+    },
+    defaults: {
+      from: {
+        name: 'My App',
+        address: process.env.GMAIL_USER,
+      },
+    },
+  },
+  secretKey: process.env.OTP_SECRET_KEY, // Must be 32 chars
+});
+
+export async function POST(req: Request) {
+  const { email } = await req.json();
+  
+  // Generate and encrypt OTP
+  const otp = irismail.otp.generateOTP();
+  const encryptedOtp = irismail.otp.encryptOTP(otp);
+  
+  // Send email
+  await irismail.email.sendEmail({
+    to: email,
+    subject: 'Your Verification Code',
+    html: `<p>Your code is: <b>${otp}</b></p>`,
+  });
+  
+  return NextResponse.json({ encryptedOtp });
+}
+```
+
+### 2. Client-Side Setup (React Component)
+
+Use the `InputOTP` component and `useOTP` hook in your verification form.
+
+```tsx
+// components/verify-form.tsx
+'use client';
+
+import { useState } from 'react';
+import { InputOTP, InputOTPGroup, InputOTPSlot, useOTP } from 'irismail/react';
+
+export function VerifyForm({ email }) {
+  const [otp, setOtp] = useState('');
+  const { otpTimeLeft, resendTimeLeft, formatTime } = useOTP({ email });
+
+  return (
+    <div className="space-y-4">
+      <InputOTP
+        maxLength={6}
+        value={otp}
+        onChange={setOtp}
+      >
+        <InputOTPGroup>
+          <InputOTPSlot index={0} />
+          <InputOTPSlot index={1} />
+          <InputOTPSlot index={2} />
+          <InputOTPSlot index={3} />
+          <InputOTPSlot index={4} />
+          <InputOTPSlot index={5} />
+        </InputOTPGroup>
+      </InputOTP>
+      
+      <div className="text-sm">
+        Time remaining: {formatTime(otpTimeLeft)}
+      </div>
+    </div>
+  );
+}
+```
+
+## Local Testing
+
+Want to test the package locally before publishing? We've included a complete example app!
+
+1. **Navigate to the example directory**:
+   ```bash
+   cd example
+   ```
+
+2. **Set up environment variables**:
+   ```bash
+   cp .env.example .env.local
+   # Edit .env.local with your Gmail credentials and secret key
+   ```
+
+3. **Run the development server**:
+   ```bash
+   npm run dev
+   ```
+
+4. **Open [http://localhost:3000](http://localhost:3000)** to see:
+   - Interactive OTP demo with email sending
+   - Live documentation with code examples
+   - All features working together
+
+See `example/README.md` for more details.
+
+## Publishing to NPM
+
+1.  **Login to NPM**:
+    ```bash
+    npm login
+    ```
+
+2.  **Build the package**:
+    ```bash
+    npm run build
+    ```
+
+3.  **Publish**:
+    ```bash
+    npm publish --access public
+    ```
+
+## License
+
+ISC

package/dist/chunk-FTNSOYOW.mjs

@@ -0,0 +1,223 @@
+// src/react/components/input-otp.tsx
+import * as React from "react";
+import { OTPInput, OTPInputContext } from "input-otp";
+
+// src/utils/constants.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+var OTP_DEFAULTS = {
+  LENGTH: 6,
+  EXPIRY_MINUTES: 5,
+  RESEND_COOLDOWN_SECONDS: 120,
+  // 2 minutes
+  MAX_ATTEMPTS: 5,
+  RATE_LIMIT_RESET_HOURS: 1
+};
+
+// src/react/components/input-otp.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var Dot = () => /* @__PURE__ */ jsx(
+  "svg",
+  {
+    width: "15",
+    height: "15",
+    viewBox: "0 0 15 15",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    className: "h-4 w-4",
+    children: /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M7.5 7.5C7.5 8.32843 6.82843 9 6 9C5.17157 9 4.5 8.32843 4.5 7.5C4.5 6.67157 5.17157 6 6 6C6.82843 6 7.5 6.67157 7.5 7.5Z",
+        fill: "currentColor",
+        fillRule: "evenodd",
+        clipRule: "evenodd"
+      }
+    )
+  }
+);
+var InputOTP = React.forwardRef(
+  ({ className, containerClassName, ...props }, ref) => /* @__PURE__ */ jsx(
+    OTPInput,
+    {
+      ref,
+      containerClassName: cn("flex items-center gap-2 has-[:disabled]:opacity-50", containerClassName),
+      className: cn("disabled:cursor-not-allowed", className),
+      ...props
+    }
+  )
+);
+InputOTP.displayName = "InputOTP";
+var InputOTPGroup = React.forwardRef(
+  ({ className, ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, className: cn("flex items-center", className), ...props })
+);
+InputOTPGroup.displayName = "InputOTPGroup";
+var InputOTPSlot = React.forwardRef(({ index, className, ...props }, ref) => {
+  const inputOTPContext = React.useContext(OTPInputContext);
+  const { char, hasFakeCaret, isActive } = inputOTPContext.slots[index];
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref,
+      className: cn(
+        "relative flex h-10 w-10 items-center justify-center border-y border-r border-input text-sm transition-all first:rounded-l-md first:border-l last:rounded-r-md",
+        isActive && "z-10 ring-2 ring-ring ring-offset-background",
+        className
+      ),
+      ...props,
+      children: [
+        char,
+        hasFakeCaret && /* @__PURE__ */ jsx("div", { className: "pointer-events-none absolute inset-0 flex items-center justify-center", children: /* @__PURE__ */ jsx("div", { className: "h-4 w-px animate-caret-blink bg-foreground duration-1000" }) })
+      ]
+    }
+  );
+});
+InputOTPSlot.displayName = "InputOTPSlot";
+var InputOTPSeparator = React.forwardRef(
+  ({ ...props }, ref) => /* @__PURE__ */ jsx("div", { ref, role: "separator", ...props, children: /* @__PURE__ */ jsx(Dot, {}) })
+);
+InputOTPSeparator.displayName = "InputOTPSeparator";
+
+// src/react/hooks/use-otp.ts
+import { useState, useEffect } from "react";
+function useOTP({ email, onRateLimit }) {
+  const [otpTimeLeft, setOtpTimeLeft] = useState(OTP_DEFAULTS.EXPIRY_MINUTES * 60);
+  const [resendTimeLeft, setResendTimeLeft] = useState(0);
+  const [attemptsLeft, setAttemptsLeft] = useState(OTP_DEFAULTS.MAX_ATTEMPTS);
+  const [isRateLimited, setIsRateLimited] = useState(false);
+  const [rateLimitResetTime, setRateLimitResetTime] = useState(null);
+  const getStorageKey = (prefix) => `${prefix}_${email}`;
+  const getStoredData = (key) => {
+    if (typeof window === "undefined") return null;
+    const data = sessionStorage.getItem(key);
+    return data ? JSON.parse(data) : null;
+  };
+  const setStoredData = (key, data) => {
+    if (typeof window !== "undefined") {
+      sessionStorage.setItem(key, JSON.stringify(data));
+    }
+  };
+  const removeStoredData = (key) => {
+    if (typeof window !== "undefined") {
+      sessionStorage.removeItem(key);
+    }
+  };
+  const checkRateLimit = () => {
+    const key = getStorageKey("rate_limit");
+    const data = getStoredData(key);
+    if (!data) {
+      setAttemptsLeft(OTP_DEFAULTS.MAX_ATTEMPTS);
+      setIsRateLimited(false);
+      return { limited: false, attemptsLeft: OTP_DEFAULTS.MAX_ATTEMPTS };
+    }
+    const currentTime = Date.now();
+    const resetTime = OTP_DEFAULTS.RATE_LIMIT_RESET_HOURS * 60 * 60 * 1e3;
+    if (currentTime - data.firstAttemptTime > resetTime) {
+      removeStoredData(key);
+      setAttemptsLeft(OTP_DEFAULTS.MAX_ATTEMPTS);
+      setIsRateLimited(false);
+      return { limited: false, attemptsLeft: OTP_DEFAULTS.MAX_ATTEMPTS };
+    }
+    const attempts = OTP_DEFAULTS.MAX_ATTEMPTS - data.attempts;
+    const limited = data.attempts >= OTP_DEFAULTS.MAX_ATTEMPTS;
+    const limitResetTime = data.firstAttemptTime + resetTime;
+    setAttemptsLeft(Math.max(0, attempts));
+    setIsRateLimited(limited);
+    setRateLimitResetTime(limited ? limitResetTime : null);
+    if (limited && onRateLimit) {
+      onRateLimit(limitResetTime);
+    }
+    return { limited, attemptsLeft: Math.max(0, attempts), resetTime: limited ? limitResetTime : void 0 };
+  };
+  const updateRateLimit = () => {
+    const key = getStorageKey("rate_limit");
+    const data = getStoredData(key);
+    const currentTime = Date.now();
+    let newData;
+    if (!data) {
+      newData = {
+        attempts: 1,
+        firstAttemptTime: currentTime,
+        lastAttemptTime: currentTime
+      };
+    } else {
+      const resetTime = OTP_DEFAULTS.RATE_LIMIT_RESET_HOURS * 60 * 60 * 1e3;
+      if (currentTime - data.firstAttemptTime > resetTime) {
+        newData = {
+          attempts: 1,
+          firstAttemptTime: currentTime,
+          lastAttemptTime: currentTime
+        };
+      } else {
+        newData = {
+          ...data,
+          attempts: data.attempts + 1,
+          lastAttemptTime: currentTime
+        };
+      }
+    }
+    setStoredData(key, newData);
+    checkRateLimit();
+    return newData;
+  };
+  const checkResendCooldown = () => {
+    const key = getStorageKey("last_sent");
+    const lastSentTime = getStoredData(key);
+    if (!lastSentTime) {
+      setResendTimeLeft(0);
+      return { canResend: true, timeLeft: 0 };
+    }
+    const currentTime = Date.now();
+    const timeSinceLastSent = currentTime - lastSentTime;
+    const cooldown = OTP_DEFAULTS.RESEND_COOLDOWN_SECONDS * 1e3;
+    const canResend = timeSinceLastSent >= cooldown;
+    const timeLeft = canResend ? 0 : Math.ceil((cooldown - timeSinceLastSent) / 1e3);
+    setResendTimeLeft(timeLeft);
+    return { canResend, timeLeft };
+  };
+  const recordSentOTP = () => {
+    const key = getStorageKey("last_sent");
+    setStoredData(key, Date.now());
+    updateRateLimit();
+    setOtpTimeLeft(OTP_DEFAULTS.EXPIRY_MINUTES * 60);
+    setResendTimeLeft(OTP_DEFAULTS.RESEND_COOLDOWN_SECONDS);
+  };
+  useEffect(() => {
+    checkRateLimit();
+    checkResendCooldown();
+    const timer = setInterval(() => {
+      setOtpTimeLeft((prev) => Math.max(0, prev - 1));
+      const { timeLeft } = checkResendCooldown();
+      setResendTimeLeft(timeLeft);
+    }, 1e3);
+    return () => clearInterval(timer);
+  }, [email]);
+  const formatTime = (seconds) => {
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `${mins}:${secs.toString().padStart(2, "0")}`;
+  };
+  return {
+    otpTimeLeft,
+    resendTimeLeft,
+    attemptsLeft,
+    isRateLimited,
+    rateLimitResetTime,
+    formatTime,
+    recordSentOTP,
+    checkRateLimit
+  };
+}
+
+export {
+  cn,
+  OTP_DEFAULTS,
+  InputOTP,
+  InputOTPGroup,
+  InputOTPSlot,
+  InputOTPSeparator,
+  useOTP
+};

package/dist/chunk-QZ7TP4HQ.mjs

@@ -0,0 +1,7 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+export {
+  __publicField
+};

package/dist/chunk-XGASTZZ6.mjs

@@ -0,0 +1,180 @@
+import {
+  __publicField
+} from "./chunk-QZ7TP4HQ.mjs";
+
+// src/server/email.ts
+import nodemailer from "nodemailer";
+var EmailService = class {
+  constructor(config) {
+    __publicField(this, "transporter");
+    __publicField(this, "config");
+    this.config = config;
+    this.transporter = nodemailer.createTransport(config.transport);
+  }
+  /**
+   * Verify SMTP connection configuration
+   */
+  async verifyConnection() {
+    try {
+      await this.transporter.verify();
+      return true;
+    } catch (error) {
+      console.error("SMTP connection verification failed:", error);
+      return false;
+    }
+  }
+  /**
+   * Send an email
+   * @param options - Email options (to, subject, html, text, from)
+   * @returns - Result of the send operation
+   */
+  async sendEmail(options) {
+    const from = options.from || this.config.defaults?.from;
+    if (!from) {
+      throw new Error("From address is required either in options or config defaults");
+    }
+    const mailOptions = {
+      from: {
+        name: from.name,
+        address: from.address
+      },
+      to: options.to,
+      subject: options.subject,
+      html: options.html,
+      text: options.text || options.html.replace(/<[^>]*>/g, "")
+      // Simple HTML to text fallback
+    };
+    try {
+      const info = await this.transporter.sendMail(mailOptions);
+      return {
+        success: true,
+        messageId: info.messageId
+      };
+    } catch (error) {
+      console.error("Error sending email:", error);
+      throw error;
+    }
+  }
+};
+
+// src/server/crypto.ts
+import crypto from "crypto";
+var ALGORITHM = "aes-256-cbc";
+function encrypt(text, secretKey) {
+  try {
+    const key = Buffer.from(secretKey.padEnd(32).slice(0, 32));
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+    let encrypted = cipher.update(text, "utf8", "base64");
+    encrypted += cipher.final("base64");
+    return iv.toString("hex") + ":" + encrypted;
+  } catch (error) {
+    console.error("Encryption error:", error);
+    throw new Error("Failed to encrypt data");
+  }
+}
+function decrypt(encryptedText, secretKey) {
+  try {
+    const key = Buffer.from(secretKey.padEnd(32).slice(0, 32));
+    const parts = encryptedText.split(":");
+    if (parts.length !== 2) {
+      throw new Error("Invalid encrypted text format");
+    }
+    const iv = Buffer.from(parts[0], "hex");
+    const encrypted = parts[1];
+    const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+    let decrypted = decipher.update(encrypted, "base64", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+  } catch (error) {
+    console.error("Decryption error:", error);
+    throw new Error("Failed to decrypt data");
+  }
+}
+
+// src/server/otp.ts
+var OTPService = class {
+  constructor(secretKey) {
+    __publicField(this, "secretKey");
+    if (!secretKey) {
+      throw new Error("OTPService: secretKey is required");
+    }
+    this.secretKey = secretKey;
+  }
+  /**
+   * Generate a numeric OTP of specified length
+   * @param length - Length of the OTP (default: 6)
+   * @returns - The generated OTP string
+   */
+  generateOTP(length = 6) {
+    const min = Math.pow(10, length - 1);
+    const max = Math.pow(10, length) - 1;
+    return Math.floor(min + Math.random() * (max - min + 1)).toString();
+  }
+  /**
+   * Encrypt OTP data for secure storage/transmission
+   * @param otp - The OTP string
+   * @param timestamp - The timestamp when OTP was generated (default: now)
+   * @returns - Encrypted OTP data string
+   */
+  encryptOTP(otp, timestamp = Date.now()) {
+    const data = JSON.stringify({ otp, timestamp });
+    return encrypt(data, this.secretKey);
+  }
+  /**
+   * Decrypt OTP data
+   * @param encryptedData - The encrypted OTP string
+   * @returns - Decrypted OTP data object or null if failed
+   */
+  decryptOTP(encryptedData) {
+    try {
+      const decryptedData = decrypt(encryptedData, this.secretKey);
+      return JSON.parse(decryptedData);
+    } catch (error) {
+      console.error("Error decrypting OTP data:", error);
+      return null;
+    }
+  }
+  /**
+   * Verify an OTP against encrypted data
+   * @param inputOtp - The OTP provided by the user
+   * @param encryptedData - The encrypted OTP data
+   * @param expiryMinutes - Expiry time in minutes (default: 5)
+   * @returns - Object containing valid status and message
+   */
+  verifyOTP(inputOtp, encryptedData, expiryMinutes = 5) {
+    const data = this.decryptOTP(encryptedData);
+    if (!data) {
+      return { valid: false, message: "Invalid OTP data" };
+    }
+    const { otp, timestamp } = data;
+    const currentTime = Date.now();
+    const otpAge = currentTime - timestamp;
+    const expiryTime = expiryMinutes * 60 * 1e3;
+    if (otpAge > expiryTime) {
+      return { valid: false, message: "OTP has expired" };
+    }
+    if (otp !== inputOtp) {
+      return { valid: false, message: "Incorrect OTP" };
+    }
+    return { valid: true, message: "OTP verified successfully" };
+  }
+};
+
+// src/server/index.ts
+var IrisMailService = class {
+  constructor(config) {
+    __publicField(this, "email");
+    __publicField(this, "otp");
+    this.email = new EmailService(config.email);
+    this.otp = new OTPService(config.secretKey);
+  }
+};
+
+export {
+  EmailService,
+  encrypt,
+  decrypt,
+  OTPService,
+  IrisMailService
+};

package/dist/index.d.mts

@@ -0,0 +1,16 @@
+export { EmailConfig, EmailService, IrisMailService, OTPData, OTPService, SendEmailOptions, decrypt, encrypt } from './server/index.mjs';
+export { InputOTP, InputOTPGroup, InputOTPSeparator, InputOTPSlot, useOTP } from './react/index.mjs';
+import { ClassValue } from 'clsx';
+import 'input-otp';
+import 'react';
+
+declare function cn(...inputs: ClassValue[]): string;
+declare const OTP_DEFAULTS: {
+    LENGTH: number;
+    EXPIRY_MINUTES: number;
+    RESEND_COOLDOWN_SECONDS: number;
+    MAX_ATTEMPTS: number;
+    RATE_LIMIT_RESET_HOURS: number;
+};
+
+export { OTP_DEFAULTS, cn };

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export { EmailConfig, EmailService, IrisMailService, OTPData, OTPService, SendEmailOptions, decrypt, encrypt } from './server/index.js';
+export { InputOTP, InputOTPGroup, InputOTPSeparator, InputOTPSlot, useOTP } from './react/index.js';
+import { ClassValue } from 'clsx';
+import 'input-otp';
+import 'react';
+
+declare function cn(...inputs: ClassValue[]): string;
+declare const OTP_DEFAULTS: {
+    LENGTH: number;
+    EXPIRY_MINUTES: number;
+    RESEND_COOLDOWN_SECONDS: number;
+    MAX_ATTEMPTS: number;
+    RATE_LIMIT_RESET_HOURS: number;
+};
+
+export { OTP_DEFAULTS, cn };