dx-mail 1.0.0

package/-d

@@ -0,0 +1 @@
+{"ok":false,"error":"Unauthorized"}

package/a.js

@@ -0,0 +1,19 @@
+const mail = require("./index.js");
+const app = mail();
+
+app.setBaseUrl("https://mailsrv-1a31daad9cb8.herokuapp.com");
+app.auth("dxm_46a9ac05fd8230b856f6d4fb1e1f4c5af63f6b045cda4a48");
+
+app.createMail("anj", (res) => {
+console.log(JSON.stringify(res,null,2));
+})
+
+app.listMail((res) => {
+console.log("kosek mek");
+//console.log(JSON.stringify(res,null,2))
+})
+
+
+app.watchMail("memek", (res) => { if (res.message?.subject) { console.log("ada"); console.log(res.message.subject); console.log(res.message.text); }})
+
+

package/index.js

@@ -0,0 +1,364 @@
+const { io } = require("socket.io-client");
+const EventEmitter = require("events");
+
+function cleanBaseUrl(url) {
+  return String(url || "http://localhost:3000").replace(/\/+$/, "");
+}
+
+function cleanLocalPart(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/^@+/, "")
+    .split("@")[0];
+}
+
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+function callbackify(promise, callback) {
+  if (isFunction(callback)) {
+    promise.then((res) => callback(res)).catch((err) => {
+      callback({
+        ok: false,
+        error: err.message || String(err)
+      });
+    });
+  }
+
+  return promise;
+}
+
+class DxMailClient extends EventEmitter {
+  constructor(options = {}) {
+    super();
+
+    if (typeof options === "string") {
+      options = {
+        token: options
+      };
+    }
+
+    this.baseUrl = cleanBaseUrl(
+      options.baseUrl ||
+      process.env.DX_MAIL_BASE_URL ||
+      "http://localhost:3000"
+    );
+
+    this.token = options.token || process.env.DX_MAIL_TOKEN || null;
+
+    this.socket = null;
+    this.watchers = new Map();
+    this.seenMessageIds = new Set();
+    this.maxSeenMessages = 1000;
+  }
+
+  auth(token) {
+    this.token = token;
+
+    if (this.socket) {
+      this.socket.auth = {
+        token: this.token
+      };
+    }
+
+    return this;
+  }
+
+  setBaseUrl(baseUrl) {
+    this.baseUrl = cleanBaseUrl(baseUrl);
+    return this;
+  }
+
+  ensureToken() {
+    if (!this.token) {
+      throw new Error("DX Mail token belum di-set. Pakai app.auth(token) atau dxMail({ token }).");
+    }
+  }
+
+  async request(path, options = {}) {
+    this.ensureToken();
+
+    const response = await fetch(this.baseUrl + path, {
+      method: options.method || "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": this.token,
+        ...(options.headers || {})
+      },
+      body: options.body ? JSON.stringify(options.body) : undefined
+    });
+
+    const text = await response.text();
+    let data;
+
+    try {
+      data = text ? JSON.parse(text) : {};
+    } catch {
+      data = {
+        ok: false,
+        error: text || "Invalid JSON response"
+      };
+    }
+
+    if (!response.ok || data.ok === false) {
+      const error = new Error(data.error || `Request failed with status ${response.status}`);
+      error.status = response.status;
+      error.data = data;
+      throw error;
+    }
+
+    return data;
+  }
+
+  createMail(nameOrOptions, callback) {
+    let body = {};
+
+    if (isFunction(nameOrOptions)) {
+      callback = nameOrOptions;
+    } else if (typeof nameOrOptions === "string") {
+      body.name = cleanLocalPart(nameOrOptions);
+    } else if (nameOrOptions && typeof nameOrOptions === "object") {
+      body = {
+        ...nameOrOptions
+      };
+
+      if (body.name) {
+        body.name = cleanLocalPart(body.name);
+      }
+    }
+
+    return callbackify(
+      this.request("/api/mail", {
+        method: "POST",
+        body
+      }),
+      callback
+    );
+  }
+
+  createInbox(nameOrOptions, callback) {
+    return this.createMail(nameOrOptions, callback);
+  }
+
+  listMail(callback) {
+    return callbackify(
+      this.request("/api/mail"),
+      callback
+    );
+  }
+
+  listInboxes(callback) {
+    return this.listMail(callback);
+  }
+
+  getMessages(name, optionsOrCallback, callback) {
+    let options = {};
+
+    if (isFunction(optionsOrCallback)) {
+      callback = optionsOrCallback;
+    } else if (optionsOrCallback && typeof optionsOrCallback === "object") {
+      options = optionsOrCallback;
+    }
+
+    const localPart = cleanLocalPart(name);
+    const limit = options.limit ? `?limit=${encodeURIComponent(options.limit)}` : "";
+
+    return callbackify(
+      this.request(`/api/mail/${encodeURIComponent(localPart)}/messages${limit}`),
+      callback
+    );
+  }
+
+  getMail(name, optionsOrCallback, callback) {
+    return this.getMessages(name, optionsOrCallback, callback);
+  }
+
+  connect() {
+    this.ensureToken();
+
+    if (this.socket) {
+      if (!this.socket.connected) {
+        this.socket.connect();
+      }
+
+      return this.socket;
+    }
+
+    this.socket = io(this.baseUrl, {
+      auth: {
+        token: this.token
+      },
+      transports: ["websocket", "polling"],
+      autoConnect: true,
+      reconnection: true
+    });
+
+    this.socket.on("connect", () => {
+      this.emit("connect", {
+        id: this.socket.id
+      });
+
+      for (const localPart of this.watchers.keys()) {
+        this.socket.emit("mail:watch", {
+          name: localPart
+        });
+      }
+    });
+
+    this.socket.on("connect_error", (error) => {
+      this.emit("error", error);
+    });
+
+    this.socket.on("disconnect", (reason) => {
+      this.emit("disconnect", reason);
+    });
+
+    this.socket.on("mail.received", (event) => {
+      const messageId = event?.message?.id;
+
+      if (messageId) {
+        if (this.seenMessageIds.has(messageId)) {
+          return;
+        }
+
+        this.seenMessageIds.add(messageId);
+
+        if (this.seenMessageIds.size > this.maxSeenMessages) {
+          const first = this.seenMessageIds.values().next().value;
+          this.seenMessageIds.delete(first);
+        }
+      }
+
+      const localPart =
+        cleanLocalPart(event?.inbox?.name) ||
+        cleanLocalPart(event?.message?.to);
+
+      this.emit("mail.received", event);
+
+      const callbacks = this.watchers.get(localPart);
+
+      if (!callbacks || callbacks.size === 0) {
+        return;
+      }
+
+      for (const callback of callbacks) {
+        callback(event);
+      }
+    });
+
+    return this.socket;
+  }
+
+  watchMail(name, callback) {
+    if (!isFunction(callback)) {
+      throw new Error("watchMail(name, callback) butuh callback.");
+    }
+
+    const localPart = cleanLocalPart(name);
+
+    if (!localPart) {
+      throw new Error("Nama mail kosong.");
+    }
+
+    if (!this.watchers.has(localPart)) {
+      this.watchers.set(localPart, new Set());
+    }
+
+    this.watchers.get(localPart).add(callback);
+
+    const socket = this.connect();
+
+    socket.emit("mail:watch", {
+      name: localPart
+    }, (ack) => {
+      if (!ack || ack.ok === false) {
+        callback({
+          ok: false,
+          type: "mail.watch.error",
+          error: ack?.error || "Failed to watch mail",
+          inbox: {
+            name: localPart
+          }
+        });
+      }
+    });
+
+    const stop = () => {
+      const callbacks = this.watchers.get(localPart);
+
+      if (callbacks) {
+        callbacks.delete(callback);
+
+        if (callbacks.size === 0) {
+          this.watchers.delete(localPart);
+
+          if (this.socket) {
+            this.socket.emit("mail:unwatch", {
+              name: localPart
+            });
+          }
+        }
+      }
+    };
+
+    return stop;
+  }
+
+  watchAll(callback) {
+    if (!isFunction(callback)) {
+      throw new Error("watchAll(callback) butuh callback.");
+    }
+
+    this.connect();
+    this.on("mail.received", callback);
+
+    return () => {
+      this.off("mail.received", callback);
+    };
+  }
+
+  waitMail(name, options = {}) {
+    const timeoutMs = Number(options.timeoutMs || 60000);
+
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        stop();
+        reject(new Error(`Timeout menunggu email masuk ke ${name}`));
+      }, timeoutMs);
+
+      const stop = this.watchMail(name, (event) => {
+        if (event?.ok === false) {
+          clearTimeout(timer);
+          stop();
+          reject(new Error(event.error || "Failed to watch mail"));
+          return;
+        }
+
+        clearTimeout(timer);
+        stop();
+        resolve(event);
+      });
+    });
+  }
+
+  close() {
+    if (this.socket) {
+      this.socket.close();
+      this.socket = null;
+    }
+
+    this.watchers.clear();
+    this.seenMessageIds.clear();
+    return this;
+  }
+}
+
+function dxMail(options) {
+  return new DxMailClient(options);
+}
+
+dxMail.Client = DxMailClient;
+
+module.exports = dxMail;

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "dx-mail",
+  "version": "1.0.0",
+  "description": "DX Mail client for temp mail API and realtime inbox watcher",
+  "main": "index.js",
+  "keywords": [
+    "temp-mail",
+    "email",
+    "websocket",
+    "cloudflare"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "socket.io-client": "^4.8.3"
+  }
+}