@vlayer/sdk 0.1.0-nightly-20241001-aa0406f → 0.1.0-nightly-20241001-f254bee

package/package.json

@@ -2,7 +2,7 @@
   "name": "@vlayer/sdk",
   "type": "module",
   "module": "src/index.ts",
-  "version": "0.1.0-nightly-20241001-aa0406f",
+  "version": "0.1.0-nightly-20241001-f254bee",
   "scripts": {
     "build": "npm run gen:types",
     "test": "vitest --run",
@@ -19,7 +19,9 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
+    "dns-over-http-resolver": "^3.0.3",
     "mailparser": "^3.7.1",
+    "postal-mime": "^2.3.2",
     "viem": "^2.21.0"
   }
 }

package/src/api/email/dnsResolver.ts

@@ -1,14 +1,7 @@
-import dns from "node:dns";
+import DnsResolver from "dns-over-http-resolver";
 
 export async function resolveDkimDns(domain: string, selector: string) {
-  return new Promise<string>((resolve, reject) => {
-    dns.resolveTxt(`${selector}._domainkey.${domain}`, (err, addresses) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-
-      resolve(addresses.flat()[0]);
-    });
-  });
+  const resolver = new DnsResolver();
+  const address = await resolver.resolveTxt(`${selector}._domainkey.${domain}`);
+  return address.flat()[0];
 }

package/src/api/email/parseEmail.test.ts

@@ -1,7 +1,5 @@
-import assert from "node:assert";
 import { describe, expect, test } from "vitest";
-import { getDkimSigners, parseEmail } from "./parseEmail.ts";
-import { StructuredHeader } from "mailparser";
+import { getDkimSigners, parseEmail, parseParams } from "./parseEmail.ts";
 
 const emailHeaders = `From: "John Doe" <john@d.oe>
 To: "Jane Doe" <jane@d.oe>
@@ -17,18 +15,12 @@ const body = "Hello, World!";
 const emailFixture = `${emailHeaders}${dkimHeader}\n\n${body}`;
 
 describe("parseEmail", () => {
-  test("should get dkim header from email", async () => {
-    const email = await parseEmail(emailFixture);
-    const dkim = email.headers.get("dkim-signature")!;
-    assert(typeof dkim === "object" && "params" in dkim);
-    expect(dkim.params.d).toBe("example.com");
-    expect(dkim.params.s).toBe("selector1");
-  });
+  test("should get dkim header from email", async () => {});
 
   test("correctly parses untrimmed email", async () => {
     const untrimmed = `\n   ${emailFixture}    \n`;
     const email = await parseEmail(untrimmed);
-    expect(email.headers.get("dkim-signature")).toBeDefined();
+    expect(email.headers.find((h) => h.key === "dkim-signature")).toBeDefined();
   });
 
   test("works well with multiple dkim headers", async () => {
@@ -38,12 +30,11 @@ describe("parseEmail", () => {
     const email = await parseEmail(
       `${emailHeaders}${dkimHeader}\n${dkimHeader2}\n\n${body}`,
     );
-    const dkim = email.headers.get(
-      "dkim-signature",
-    )! as unknown as StructuredHeader[];
+    const dkim = email.headers.filter((h) => h.key === "dkim-signature")!;
+
     expect(dkim).toHaveLength(2);
-    expect(dkim[0].params.s).toBe("selector1");
-    expect(dkim[1].params.s).toBe("selector2");
+    expect(parseParams(dkim[0].value).s).toBe("selector1");
+    expect(parseParams(dkim[1].value).s).toBe("selector2");
   });
 });
 
@@ -103,3 +94,40 @@ describe("getDkimSigners", () => {
     );
   });
 });
+
+describe("parseParams", () => {
+  test("should parse single parameter", () => {
+    const params = parseParams("a=b");
+    expect(params).toEqual({ a: "b" });
+  });
+
+  test("should parse multiple parameters", () => {
+    const params = parseParams("a=b; c=d; e=f");
+    expect(params).toEqual({ a: "b", c: "d", e: "f" });
+  });
+
+  test("should trim spaces around parameters", () => {
+    const params = parseParams(" a = b ; c = d ; e = f ");
+    expect(params).toEqual({ a: "b", c: "d", e: "f" });
+  });
+
+  test("should handle empty values", () => {
+    const params = parseParams("a=; b=c");
+    expect(params).toEqual({ a: "", b: "c" });
+  });
+
+  test("should handle missing values", () => {
+    const params = parseParams("a; b=c");
+    expect(params).toEqual({ a: undefined, b: "c" });
+  });
+
+  test("should handle empty string", () => {
+    const params = parseParams("");
+    expect(params).toEqual({});
+  });
+
+  test("should handle parameters with extra semicolons", () => {
+    const params = parseParams("a=b;; c=d;");
+    expect(params).toEqual({ a: "b", c: "d" });
+  });
+});

package/src/api/email/parseEmail.ts

@@ -1,4 +1,4 @@
-import { simpleParser, HeaderValue, type ParsedMail } from "mailparser";
+import PostalMime, { Email, Header } from "postal-mime";
 
 export class DkimParsingError extends Error {
   constructor(message: string) {
@@ -8,38 +8,42 @@ export class DkimParsingError extends Error {
 }
 
 export async function parseEmail(mime: string) {
-  return simpleParser(mime.trim(), {
-    skipHtmlToText: true,
-    skipTextToHtml: true,
-    skipTextLinks: true,
-    skipImageLinks: true,
-  });
+  return await PostalMime.parse(mime.trim());
 }
 
-export function getDkimSigners(mail: ParsedMail) {
-  const dkimHeader = mail.headers.get("dkim-signature");
-  if (!dkimHeader) throw new DkimParsingError("No DKIM header found");
-  if (Array.isArray(dkimHeader)) {
-    return dkimHeader.map(parseHeader);
-  }
-  return [parseHeader(dkimHeader)];
+export function getDkimSigners(mail: Email) {
+  const dkimHeader = mail.headers.filter((h) => h.key === "dkim-signature");
+  if (dkimHeader.length === 0)
+    throw new DkimParsingError("No DKIM header found");
+  return dkimHeader.map(parseHeader);
+}
+
+export function parseParams(str: string) {
+  return Object.fromEntries(
+    str.split(";").map((s) =>
+      s
+        .trim()
+        .split("=")
+        .map((v) => v && v.trim()),
+    ),
+  );
 }
 
-function parseHeader(header: HeaderValue) {
-  if (typeof header === "string" || !("params" in header)) {
+function parseHeader(header: Header) {
+  const params = parseParams(header.value);
+  if (!params) {
     throw new DkimParsingError(`Invalid DKIM header ${header}`);
   }
 
-  if (!header.params.d) {
+  if (!params.d) {
     throw new DkimParsingError("DKIM header missing domain");
   }
 
-  if (!header.params.s) {
+  if (!params.s) {
     throw new DkimParsingError("DKIM header missing selector");
   }
-
   return {
-    domain: header.params.d,
-    selector: header.params.s,
+    domain: params.d,
+    selector: params.s,
   };
 }

package/src/api/email/preverify.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "vitest";
 import { preverifyEmail } from "./preverify.ts";
-import { readFile } from "testHelpers/readFile";
+import { readFile } from "../../testHelpers/readFile";
 
 describe("Preverify email: integration", () => {
   test("adds dns record to email mime", async () => {