irismail 0.1.0

package/dist/server/index.js

@@ -0,0 +1,218 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  EmailService: () => EmailService,
+  IrisMailService: () => IrisMailService,
+  OTPService: () => OTPService,
+  decrypt: () => decrypt,
+  encrypt: () => encrypt
+});
+module.exports = __toCommonJS(server_exports);
+
+// src/server/email.ts
+var import_nodemailer = __toESM(require("nodemailer"));
+var EmailService = 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;
+    }
+  }
+  /**
+   * 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
+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
+});

package/dist/server/index.mjs

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

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "irismail",
+  "version": "0.1.0",
+  "description": "A modular email and OTP service with Shadcn UI support",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "import": "./dist/react/index.mjs",
+      "require": "./dist/react/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.mjs",
+      "require": "./dist/server/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "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"
+  },
+  "keywords": [
+    "email",
+    "otp",
+    "shadcn",
+    "react",
+    "authentication"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "clsx": "^2.1.1",
+    "input-otp": "^1.4.2",
+    "nodemailer": "^7.0.10",
+    "tailwind-merge": "^2.3.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.12",
+    "@types/nodemailer": "^6.4.15",
+    "@types/react": "^18.3.3",
+    "react": "^18.3.1",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.5"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  }
+}