irismail 0.1.0 → 0.5.0

package/dist/server/index.d.mts

@@ -1,110 +1,50 @@
-interface EmailConfig {
-    transport: {
-        host: string;
-        port: number;
-        secure?: boolean;
-        auth: {
-            user: string;
-            pass: string;
-        };
-    };
-    defaults?: {
-        from?: {
-            name: string;
-            address: string;
-        };
+interface IrisMailConfig {
+    auth: {
+        user: string;
+        pass: string;
     };
 }
-interface SendEmailOptions {
+interface SendMailOptions {
+    from: string;
     to: string;
     subject: string;
     html: string;
-    text?: string;
-    from?: {
-        name: string;
-        address: string;
-    };
 }
-declare class EmailService {
+interface SendMailResult {
+    success: boolean;
+    messageId: string;
+}
+/**
+ * IrisMail - Simple Gmail email sending service
+ *
+ * Automatically configured for Gmail SMTP. Only requires your Gmail credentials.
+ *
+ * @example
+ * ```typescript
+ * const mail = new IrisMail({
+ *   auth: {
+ *     user: process.env.GMAIL_USERNAME,
+ *     pass: process.env.GMAIL_PASSWORD
+ *   }
+ * });
+ *
+ * await mail.sendMail({
+ *   from: process.env.GMAIL_USERNAME,
+ *   to: 'friend@example.com',
+ *   subject: 'Hello!',
+ *   html: '<h1>Welcome</h1><p>Thanks for signing up!</p>'
+ * });
+ * ```
+ */
+declare class IrisMail {
     private transporter;
-    private config;
-    constructor(config: EmailConfig);
-    /**
-     * Verify SMTP connection configuration
-     */
-    verifyConnection(): Promise<boolean>;
+    constructor(config: IrisMailConfig);
     /**
      * Send an email
-     * @param options - Email options (to, subject, html, text, from)
-     * @returns - Result of the send operation
-     */
-    sendEmail(options: SendEmailOptions): Promise<{
-        success: boolean;
-        messageId: any;
-    }>;
-}
-
-interface OTPData {
-    otp: string;
-    timestamp: number;
-}
-declare class OTPService {
-    private secretKey;
-    constructor(secretKey: string);
-    /**
-     * Generate a numeric OTP of specified length
-     * @param length - Length of the OTP (default: 6)
-     * @returns - The generated OTP string
-     */
-    generateOTP(length?: number): string;
-    /**
-     * 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: string, timestamp?: number): string;
-    /**
-     * Decrypt OTP data
-     * @param encryptedData - The encrypted OTP string
-     * @returns - Decrypted OTP data object or null if failed
+     * @param options - Email options (from, to, subject, html)
+     * @returns Promise with success status and messageId
      */
-    decryptOTP(encryptedData: string): OTPData | 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: string, encryptedData: string, expiryMinutes?: number): {
-        valid: boolean;
-        message: string;
-    };
-}
-
-/**
- * Encrypts a string using AES-256-CBC
- * @param text - The text to encrypt
- * @param secretKey - The 32-character secret key
- * @returns - The encrypted value with IV and encrypted data, base64 encoded
- */
-declare function encrypt(text: string, secretKey: string): string;
-/**
- * Decrypts a string that was encrypted using the encrypt function
- * @param encryptedText - The encrypted text (IV:EncryptedData format)
- * @param secretKey - The 32-character secret key
- * @returns - The decrypted string
- */
-declare function decrypt(encryptedText: string, secretKey: string): string;
-
-declare class IrisMailService {
-    email: EmailService;
-    otp: OTPService;
-    constructor(config: {
-        email: EmailConfig;
-        secretKey: string;
-    });
+    sendMail(options: SendMailOptions): Promise<SendMailResult>;
 }
 
-export { type EmailConfig, EmailService, IrisMailService, type OTPData, OTPService, type SendEmailOptions, decrypt, encrypt };
+export { IrisMail, type IrisMailConfig, type SendMailOptions, type SendMailResult };

package/dist/server/index.d.ts

@@ -1,110 +1,50 @@
-interface EmailConfig {
-    transport: {
-        host: string;
-        port: number;
-        secure?: boolean;
-        auth: {
-            user: string;
-            pass: string;
-        };
-    };
-    defaults?: {
-        from?: {
-            name: string;
-            address: string;
-        };
+interface IrisMailConfig {
+    auth: {
+        user: string;
+        pass: string;
     };
 }
-interface SendEmailOptions {
+interface SendMailOptions {
+    from: string;
     to: string;
     subject: string;
     html: string;
-    text?: string;
-    from?: {
-        name: string;
-        address: string;
-    };
 }
-declare class EmailService {
+interface SendMailResult {
+    success: boolean;
+    messageId: string;
+}
+/**
+ * IrisMail - Simple Gmail email sending service
+ *
+ * Automatically configured for Gmail SMTP. Only requires your Gmail credentials.
+ *
+ * @example
+ * ```typescript
+ * const mail = new IrisMail({
+ *   auth: {
+ *     user: process.env.GMAIL_USERNAME,
+ *     pass: process.env.GMAIL_PASSWORD
+ *   }
+ * });
+ *
+ * await mail.sendMail({
+ *   from: process.env.GMAIL_USERNAME,
+ *   to: 'friend@example.com',
+ *   subject: 'Hello!',
+ *   html: '<h1>Welcome</h1><p>Thanks for signing up!</p>'
+ * });
+ * ```
+ */
+declare class IrisMail {
     private transporter;
-    private config;
-    constructor(config: EmailConfig);
-    /**
-     * Verify SMTP connection configuration
-     */
-    verifyConnection(): Promise<boolean>;
+    constructor(config: IrisMailConfig);
     /**
      * Send an email
-     * @param options - Email options (to, subject, html, text, from)
-     * @returns - Result of the send operation
-     */
-    sendEmail(options: SendEmailOptions): Promise<{
-        success: boolean;
-        messageId: any;
-    }>;
-}
-
-interface OTPData {
-    otp: string;
-    timestamp: number;
-}
-declare class OTPService {
-    private secretKey;
-    constructor(secretKey: string);
-    /**
-     * Generate a numeric OTP of specified length
-     * @param length - Length of the OTP (default: 6)
-     * @returns - The generated OTP string
-     */
-    generateOTP(length?: number): string;
-    /**
-     * 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: string, timestamp?: number): string;
-    /**
-     * Decrypt OTP data
-     * @param encryptedData - The encrypted OTP string
-     * @returns - Decrypted OTP data object or null if failed
+     * @param options - Email options (from, to, subject, html)
+     * @returns Promise with success status and messageId
      */
-    decryptOTP(encryptedData: string): OTPData | 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: string, encryptedData: string, expiryMinutes?: number): {
-        valid: boolean;
-        message: string;
-    };
-}
-
-/**
- * Encrypts a string using AES-256-CBC
- * @param text - The text to encrypt
- * @param secretKey - The 32-character secret key
- * @returns - The encrypted value with IV and encrypted data, base64 encoded
- */
-declare function encrypt(text: string, secretKey: string): string;
-/**
- * Decrypts a string that was encrypted using the encrypt function
- * @param encryptedText - The encrypted text (IV:EncryptedData format)
- * @param secretKey - The 32-character secret key
- * @returns - The decrypted string
- */
-declare function decrypt(encryptedText: string, secretKey: string): string;
-
-declare class IrisMailService {
-    email: EmailService;
-    otp: OTPService;
-    constructor(config: {
-        email: EmailConfig;
-        secretKey: string;
-    });
+    sendMail(options: SendMailOptions): Promise<SendMailResult>;
 }
 
-export { type EmailConfig, EmailService, IrisMailService, type OTPData, OTPService, type SendEmailOptions, decrypt, encrypt };
+export { IrisMail, type IrisMailConfig, type SendMailOptions, type SendMailResult };

package/dist/server/index.js

@@ -32,187 +32,45 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // src/server/index.ts
 var server_exports = {};
 __export(server_exports, {
-  EmailService: () => EmailService,
-  IrisMailService: () => IrisMailService,
-  OTPService: () => OTPService,
-  decrypt: () => decrypt,
-  encrypt: () => encrypt
+  IrisMail: () => IrisMail
 });
 module.exports = __toCommonJS(server_exports);
 
 // src/server/email.ts
 var import_nodemailer = __toESM(require("nodemailer"));
-var EmailService = class {
+var IrisMail = class {
   constructor(config) {
     __publicField(this, "transporter");
-    __publicField(this, "config");
-    this.config = config;
-    this.transporter = import_nodemailer.default.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;
-    }
+    this.transporter = import_nodemailer.default.createTransport({
+      host: "smtp.gmail.com",
+      port: 587,
+      secure: false,
+      // true for 465, false for other ports
+      auth: config.auth
+    });
   }
   /**
    * Send an email
-   * @param options - Email options (to, subject, html, text, from)
-   * @returns - Result of the send operation
+   * @param options - Email options (from, to, subject, html)
+   * @returns Promise with success status and messageId
    */
-  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
+  async sendMail(options) {
+    const { from, to, subject, html } = options;
+    const text = html.replace(/<[^>]*>/g, "");
+    const info = await this.transporter.sendMail({
+      from,
+      to,
+      subject,
+      html,
+      text
+    });
+    return {
+      success: true,
+      messageId: info.messageId
     };
-    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
-var import_crypto = __toESM(require("crypto"));
-var ALGORITHM = "aes-256-cbc";
-function encrypt(text, secretKey) {
-  try {
-    const key = Buffer.from(secretKey.padEnd(32).slice(0, 32));
-    const iv = import_crypto.default.randomBytes(16);
-    const cipher = import_crypto.default.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 = import_crypto.default.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);
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  EmailService,
-  IrisMailService,
-  OTPService,
-  decrypt,
-  encrypt
+  IrisMail
 });

package/dist/server/index.mjs

@@ -1,15 +1,7 @@
 import {
-  EmailService,
-  IrisMailService,
-  OTPService,
-  decrypt,
-  encrypt
-} from "../chunk-XGASTZZ6.mjs";
+  IrisMail
+} from "../chunk-64MVNASE.mjs";
 import "../chunk-QZ7TP4HQ.mjs";
 export {
-  EmailService,
-  IrisMailService,
-  OTPService,
-  decrypt,
-  encrypt
+  IrisMail
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "irismail",
-  "version": "0.1.0",
-  "description": "A modular email and OTP service with Shadcn UI support",
+  "version": "0.5.0",
+  "description": "Simple email sending service and beautiful OTP input components for React",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -28,14 +28,24 @@
     "build": "tsup src/index.ts src/server/index.ts src/react/index.ts --format cjs,esm --dts --clean",
     "dev": "tsup src/index.ts src/server/index.ts src/react/index.ts --format cjs,esm --dts --watch",
     "lint": "eslint src/**",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "site": "npm --prefix site run dev",
+    "site:build": "npm --prefix site run build",
+    "site:start": "npm --prefix site run start",
+    "prepublishOnly": "npm run build",
+    "postpublish": "git push origin --tags",
+    "release:patch": "npm version patch && npm publish",
+    "release:minor": "npm version minor && npm publish",
+    "release:major": "npm version major && npm publish"
   },
   "keywords": [
     "email",
     "otp",
+    "otp-input",
     "shadcn",
     "react",
-    "authentication"
+    "nodemailer",
+    "smtp"
   ],
   "author": "",
   "license": "ISC",
@@ -43,8 +53,7 @@
     "clsx": "^2.1.1",
     "input-otp": "^1.4.2",
     "nodemailer": "^7.0.10",
-    "tailwind-merge": "^2.3.0",
-    "zod": "^3.23.8"
+    "tailwind-merge": "^2.3.0"
   },
   "devDependencies": {
     "@types/node": "^20.12.12",