@storecraft/mailer-providers-http 1.0.0

package/README.md

@@ -0,0 +1,105 @@
+# `storecraft` Official serverless http email providers
+
+Supports wellknown http-based `serverless` friendly `email` providers,
+
+- [Sendgrid](https://docs.sendgrid.com/api-reference/mail-send/mail-send)
+- [Resend](https://resend.com/docs/api-reference/emails/send-email)
+- [Mailchimp](https://mailchimp.com/developer/transactional/api/messages/send-new-message/)
+- [Mailgun](https://documentation.mailgun.com/en/latest/api-sending.html#examples)
+
+> TODO: confirm tests
+
+## Howto
+
+### Sendgrid
+
+```js
+import { MailerSendGrid } from '@storecraft/mailer-providers-http/sendgrid';
+
+const mailer = new MailerSendGrid(
+  {
+      apikey: process.env.SEND_GRID_SECRET
+  }
+);
+
+
+let { success, native_response } = await mailer.email({
+  from: {name: 'bob 👻', address: process.env.FROM_EMAIL }, // sender address
+  to: [ { address: process.env.TO_EMAIL } ], // list of receivers
+  subject: 'subject test', // Subject line
+  text: 'plain text test', // plain text body
+  html: '<p>html test</p>', // html body
+});
+
+```
+
+### Resend
+```js
+import { MailerResend } from '@storecraft/mailer-providers-http/resend';
+
+const mailer = new MailerResend(
+  {
+      apikey: process.env.RESEND_API_KEY
+  }
+);
+
+let { success, native_response } = await mailer.email({
+  from: {name: 'bob 👻', address: process.env.FROM_EMAIL }, // sender address
+  to: [ { address: process.env.TO_EMAIL } ], // list of receivers
+  subject: 'subject test', // Subject line
+  text: 'plain text test', // plain text body
+  html: '<p>html test</p>', // html body
+});
+
+```
+
+
+### Mailchimp
+
+```js
+import { MailerMailChimp } from '@storecraft/mailer-providers-http/mailchimp';
+
+const mailer = new MailerMailChimp(
+  {
+      apikey: process.env.MAILCHIMP_API_KEY
+  }
+);
+
+let { success, native_response } = await mailer.email({
+  from: {name: 'bob 👻', address: process.env.FROM_EMAIL }, // sender address
+  to: [ { address: process.env.TO_EMAIL } ], // list of receivers
+  subject: 'subject test', // Subject line
+  text: 'plain text test', // plain text body
+  html: '<p>html test</p>', // html body
+});
+
+```
+
+
+### Mailgun
+
+```js
+import { MailerMailgun } from '@storecraft/mailer-providers-http/mailgun';
+
+const mailer = new MailerMailgun(
+  {
+      apikey: process.env.MAILGUN_API_KEY
+  }
+);
+
+let { success, native_response } = await mailer.email(
+  {
+    from: {name: 'bob 👻', address: process.env.FROM_EMAIL }, // sender address
+    to: [ { address: process.env.TO_EMAIL } ], // list of receivers
+    subject: 'subject test', // Subject line
+    text: 'plain text test', // plain text body
+    html: '<p>html test</p>', // html body
+  }
+);
+
+```
+
+
+```text
+Author: Tomer Shalev (tomer.shalev@gmail.com)
+```

package/index.js

@@ -0,0 +1,4 @@
+export * as mailchimp from './mailchimp/index.js'
+export * as mailgun from './mailgun/index.js'
+export * as resend from './resend/index.js'
+export * as sendgrid from './sendgrid/index.js'

package/mailchimp/README.md

@@ -0,0 +1,27 @@
+# `mailchimp` mailer over http
+[mailchimp.com](https://mailchimp.com/developer/transactional/api/messages/send-new-message/) client, that can work on eveywhere with `javascript`. We only rely on `fetch api`.
+
+## Howto
+
+```js
+import { MailerMailChimp } from '@storecraft/mailer-mailchimp-http';
+
+const mailer = new MailerMailChimp(
+  {
+      apikey: process.env.MAILCHIMP_API_KEY
+  }
+);
+
+let { success, native_response } = await mailer.email({
+  from: {name: 'bob 👻', address: process.env.FROM_EMAIL }, // sender address
+  to: [ { address: process.env.TO_EMAIL } ], // list of receivers
+  subject: 'subject test', // Subject line
+  text: 'plain text test', // plain text body
+  html: '<p>html test</p>', // html body
+});
+
+```
+
+```text
+Author: Tomer Shalev (tomer.shalev@gmail.com)
+```

package/mailchimp/adapter.js

@@ -0,0 +1,78 @@
+import { convert_to_base64 } from "./adapter.utils.js";
+
+/**
+ * @typedef {import("./types.public.js").Config} Config
+ * @typedef {import('@storecraft/core/v-mailer').mailer<Config>} mailer
+ * @implements {mailer}
+ * 
+ * mailer with mail-chimp / mandrill http api
+ */
+export class MailerMailChimp {
+  
+  /** @type {Config} */ #_config;
+
+  /**
+   * 
+   * @param {Config} config 
+   */
+  constructor(config) {
+    this.#_config = config;
+  }
+
+  get config() { return this.#_config; }
+
+  /**
+   * 
+   * @type {mailer["email"]}
+   */
+  async email(o) {
+
+    /** @type {import("./types.private.js").Mailchimp_sendmail} */
+    const body = {
+      key: this.config.apikey,
+      message: {
+        from_email: o.from.address,
+        from_name: o.from.name,
+        to: o.to.map(t => ({ email:t.address, name: t.name, type: 'to'})),
+        subject: o.subject,
+        html: o.html,
+        text: o.text,
+        attachments: o.attachments && await Promise.all(
+          o.attachments.map(
+            /**
+             * @returns {Promise<import("./types.private.js").Mailchimp_sendmail_message_attachment>}
+             */
+            async a => ({
+              type: a.content_type, 
+              name: a.filename, 
+              content: await convert_to_base64(a.content)
+            })
+          )
+        ),
+      }
+    }
+
+    let r;
+    try {
+      r = await fetch(
+        'https://mandrillapp.com/api/1.0/messages/send',
+        {
+          body: JSON.stringify(body),
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          method: 'POST',
+        }
+      );
+    } catch (e) {
+      console.log(e);
+    }
+    
+    return {
+      success: r.ok,
+      native_response: await r.json()
+    }
+  }
+
+}
+

package/mailchimp/adapter.utils.js

@@ -0,0 +1,26 @@
+import { base64 } from '@storecraft/core/v-crypto'
+
+/**
+ * @param {import('@storecraft/core/v-mailer').MailObject["attachments"][0]["content"]} c 
+ */
+export const convert_to_base64 = async (c) => {
+  if(c instanceof ArrayBuffer)
+    return base64.fromUint8Array(new Uint8Array(c));
+  else if(c instanceof ReadableStream) {
+    const reader = c.getReader();
+    const buffer = []
+    while (true) {
+      // The `read()` method returns a promise that
+      // resolves when a value has been received.
+      const { done, value } = await reader.read();
+      // Result objects contain two properties:
+      // `done`  - `true` if the stream has already given you all its data.
+      // `value` - Some data. Always `undefined` when `done` is `true`.
+      if (done) {
+        return base64.fromUint8Array(new Uint8Array(buffer));
+      }
+      buffer.push(value);
+    }
+  }
+  else return base64.toBase64(c.toString());
+}

package/mailchimp/index.js

@@ -0,0 +1 @@
+export * from './adapter.js'

package/mailchimp/tests/test.js

@@ -0,0 +1,25 @@
+import 'dotenv/config';
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+import { MailerMailChimp } from '../index.js';
+
+const mailer = new MailerMailChimp(
+  {
+      apikey: process.env.MAILCHIMP_API_KEY
+  }
+);
+
+test('send email', async () => {
+  
+  let { success, native_response } = await mailer.email({
+    from: {name: 'bob 👻', address: process.env.FROM_EMAIL }, // sender address
+    to: [ { address: process.env.TO_EMAIL } ], // list of receivers
+    subject: 'subject test', // Subject line
+    text: 'plain text test', // plain text body
+    html: '<p>html test</p>', // html body
+  });
+
+  assert.ok(success, `failed with native_response ${JSON.stringify(native_response, null, 2)}`)  
+});
+
+test.run();

package/mailchimp/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "noEmit": true,
+    "allowJs": true,
+    "checkJs": true,
+    "target": "ESNext",
+    "resolveJsonModule": true,
+    "moduleResolution": "NodeNext",
+    "module": "NodeNext",
+    "composite": true,
+  },
+  "include": ["*", "*/*", "src/*"]
+}

package/mailchimp/types.private.d.ts

@@ -0,0 +1,50 @@
+
+export type Mailchimp_sendmail_message_to = {
+  /** the email address of the recipient */
+  email: string;
+  /** the optional display name to use for the recipient */
+  name?: string;
+  /** the header type to use for the recipient, defaults to "to" if not provided Possible values: "to", "cc", or "bcc". */
+  type?: 'to' | 'cc' | 'bcc';
+}
+
+export type Mailchimp_sendmail_message_attachment = {
+  /** the MIME type of the attachment */
+  type?: string;
+  /** the file name of the attachment */
+  name: string;
+  /** the content of the attachment as a base64-encoded string */
+  content: string;
+}
+
+export type Mailchimp_sendmail_message = {
+  /** the full HTML content to be sent */
+  html?: string;
+  /** optional full text content to be sent */
+  text?: string;
+  /** the message subject */
+  subject: string;
+  /** the sender email address */
+  from_email: string;
+  /** optional from name to be used */
+  from_name?: string;
+  /** an array of recipient information. */
+  to: Mailchimp_sendmail_message_to[];
+  /** optional extra headers to add to the message (most headers are allowed) */
+  headers?: Record<string, string>;
+  /** an array of supported attachments to add to the message */
+  attachments?: Mailchimp_sendmail_message_attachment[];
+}
+
+export type Mailchimp_sendmail = {
+  /** a valid api key */
+  key: string;
+  /** enable a background sending mode that is optimized for bulk sending. In async mode, messages/send will immediately return a status of "queued" for every recipient. To handle rejections when sending in async mode, set up a webhook for the 'reject' event. Defaults to false for messages with no more than 10 recipients; messages with more than 10 recipients are always sent asynchronously, regardless of the value of async. */
+  async?: boolean;
+  /** the name of the dedicated ip pool that should be used to send the message. If you do not have any dedicated IPs, this parameter has no effect. If you specify a pool that does not exist, your default pool will be used instead. */
+  ip_pool?: string;
+  /** when this message should be sent as a UTC timestamp in YYYY-MM-DD HH:MM:SS format. If you specify a time in the past, the message will be sent immediately; for future dates, you're limited to one year from the date of scheduling. */
+  send_at?: string;
+  /** the information on the message to send */
+  message: Mailchimp_sendmail_message;
+}

package/mailchimp/types.public.d.ts

@@ -0,0 +1,10 @@
+export * from './index.js';
+
+/**
+ * config
+ */
+export type Config = {
+  apikey: string,
+
+};
+

package/mailgun/README.md

@@ -0,0 +1,29 @@
+# `mailgun` mailer over http
+[mailgun.com](https://documentation.mailgun.com/en/latest/api-sending.html#examples) client, that can work on eveywhere with `javascript`. We only rely on `fetch api`.
+
+## Howto
+
+```js
+import { MailerMailChimp } from '@storecraft/mailer-mailgun-http';
+
+const mailer = new MailerMailgun(
+  {
+      apikey: process.env.MAILGUN_API_KEY
+  }
+);
+
+let { success, native_response } = await mailer.email(
+  {
+    from: {name: 'bob 👻', address: process.env.FROM_EMAIL }, // sender address
+    to: [ { address: process.env.TO_EMAIL } ], // list of receivers
+    subject: 'subject test', // Subject line
+    text: 'plain text test', // plain text body
+    html: '<p>html test</p>', // html body
+  }
+);
+
+```
+
+```text
+Author: Tomer Shalev (tomer.shalev@gmail.com)
+```

package/mailgun/adapter.js

@@ -0,0 +1,81 @@
+import { base64 } from "@storecraft/core/v-crypto";
+import { address_to_friendly_name, convert_attachment_to_blob } from "./adapter.utils.js";
+
+/**
+ * @typedef {import("./types.public.js").Config} Config
+ * @typedef {import('@storecraft/core/v-mailer').mailer<Config>} mailer
+ * @implements {mailer}
+ * 
+ * mailer with mailgun http api
+ */
+export class MailerMailgun {
+  
+  /** @type {Config} */ #_config;
+
+  /**
+   * 
+   * @param {Config} config 
+   */
+  constructor(config) {
+    this.#_config = config;
+  }
+
+  get config() { return this.#_config; }
+
+  /**
+   * 
+   * @type {mailer["email"]}
+   */
+  async email(o) {
+
+    const form = new FormData();
+    form.append('from', address_to_friendly_name(o.from));
+
+    o.to.forEach(
+      t => {
+        form.append('to', address_to_friendly_name(t));
+      }
+    );
+    form.append('subject', o.subject);
+    form.append('text', o.text);
+    form.append('html', o.html);
+
+    if(Array.isArray(o.attachments)) {
+      o.attachments.forEach(
+        async a => {
+          form.append(
+            'attachment', 
+            await convert_attachment_to_blob(a.content), 
+            a.filename ?? ''
+          );
+        }
+      )
+    }
+
+    const auth = base64.encode(`api:${this.config.apikey}`, false);
+
+    let r;
+    try {
+      r = await fetch(
+        `https://api.mailgun.net/v3/${this.config.domain_name}/messages`,
+        {
+          body: form,
+          headers: {
+            'Content-Type': 'multipart/form-data',
+            'Authorization': `Basic ${auth}`
+          },
+          method: 'POST',
+        }
+      );
+    } catch (e) {
+      console.log(e);
+    }
+    
+    return {
+      success: r.ok,
+      native_response: await r.text()
+    }
+  }
+
+}
+

package/mailgun/adapter.utils.js

@@ -0,0 +1,34 @@
+
+/**
+ * 
+ * @param {import('@storecraft/core/v-mailer').MailObject["attachments"][0]["content"]} c 
+ */
+export const convert_attachment_to_blob = async c => {
+  if(c instanceof ArrayBuffer)
+    return new Blob([new Uint8Array(c)]);
+  else if(c instanceof ReadableStream) {
+    const reader = c.getReader();
+    const buffer = []
+    while (true) {
+      // The `read()` method returns a promise that
+      // resolves when a value has been received.
+      const { done, value } = await reader.read();
+      // Result objects contain two properties:
+      // `done`  - `true` if the stream has already given you all its data.
+      // `value` - Some data. Always `undefined` when `done` is `true`.
+      if (done) {
+        return new Blob([new Uint8Array(buffer)]);
+      }
+      buffer.push(value);
+    }
+  }
+  else return new Blob([c.toString()]);  
+}
+
+/**
+ * 
+ * @param {import('@storecraft/core/v-mailer').MailAddress} a 
+ */
+export const address_to_friendly_name = a => {
+  return a.name ? `${a.name} <${a.address}>` : a.address;
+}

package/mailgun/index.js

@@ -0,0 +1 @@
+export * from './adapter.js'

package/mailgun/tests/test.js

@@ -0,0 +1,30 @@
+import 'dotenv/config';
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+import { MailerMailgun } from '../index.js';
+
+const mailer = new MailerMailgun(
+  {
+      apikey: process.env.MAILGUN_API_KEY,
+      domain_name: process.env.YOUR_DOMAIN_NAME
+  }
+);
+
+test('send email', async () => {
+  
+  let { success, native_response } = await mailer.email({
+    from: {name: 'bob 👻', address: process.env.FROM_EMAIL }, // sender address
+    to: [ { address: process.env.TO_EMAIL } ], // list of receivers
+    subject: 'subject test', // Subject line
+    text: 'plain text test', // plain text body
+    html: '<p>html test</p>', // html body
+  });
+
+  assert.ok(
+    success, 
+    `failed with native_response ${JSON.stringify(native_response, null, 2)}`
+  );
+    
+});
+
+test.run();

package/mailgun/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "noEmit": true,
+    "allowJs": true,
+    "checkJs": true,
+    "target": "ESNext",
+    "resolveJsonModule": true,
+    "moduleResolution": "NodeNext",
+    "module": "NodeNext",
+    "composite": true,
+  },
+  "include": ["*", "*/*", "src/*"]
+}

package/mailgun/types.public.d.ts

@@ -0,0 +1,12 @@
+export * from './index.js';
+
+/**
+ * config
+ */
+export type Config = {
+  /** your mailgun api key */
+  apikey: string,
+  /** your registered domain name at mailgun */
+  domain_name: string;
+};
+

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@storecraft/mailer-providers-http",
+  "version": "1.0.0",
+  "description": "Official Serverless Friendly e-mail adapters for storecraft",
+  "license": "MIT",
+  "author": "Tomer Shalev (https://github.com/store-craft)",
+  "homepage": "https://github.com/store-craft/storecraft",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/store-craft/storecraft.git",
+    "directory": "packages/mailer-providers-http"
+  },
+  "keywords": [
+    "commerce",
+    "dashboard",
+    "code",
+    "storecraft"
+  ],
+  "type": "module",
+  "main": "index.js",
+  "types": "./types.public.d.ts",
+  "scripts": {
+    "mailer-providers-http:test": "uvu -c",
+    "mailer-providers-http:publish": "npm publish --access public"
+  },
+  "exports": {
+    ".": {
+      "import": "./index.js"
+    },
+    "./package.json": "./package.json",
+    "./mailchimp": {
+      "import": "./mailchimp/index.js",
+      "types": "./mailchimp/types.public.d.ts"
+    },
+    "./mailgun": {
+      "import": "./mailgun/index.js",
+      "types": "./mailgun/types.public.d.ts"
+    },
+    "./resend": {
+      "import": "./resend/index.js",
+      "types": "./resend/types.public.d.ts"
+    },
+    "./sendgrid": {
+      "import": "./sendgrid/index.js",
+      "types": "./sendgrid/types.public.d.ts"
+    }
+  },
+  "dependencies": {
+    "@storecraft/core": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "uvu": "^0.5.6",
+    "dotenv": "^16.3.1"
+  }
+}

package/resend/README.md

@@ -0,0 +1,27 @@
+# Resend mailer over http
+[Resend.com](https://resend.com/docs/api-reference/emails/send-email) client, that can work on eveywhere with `javascript`. We only rely on `fetch api`
+
+## Howto
+
+```js
+import { MailerResend } from '@storecraft/mailer-resend-http';
+
+const mailer = new MailerResend(
+  {
+      apikey: process.env.RESEND_API_KEY
+  }
+);
+
+let { success, native_response } = await mailer.email({
+  from: {name: 'bob 👻', address: process.env.FROM_EMAIL }, // sender address
+  to: [ { address: process.env.TO_EMAIL } ], // list of receivers
+  subject: 'subject test', // Subject line
+  text: 'plain text test', // plain text body
+  html: '<p>html test</p>', // html body
+});
+
+```
+
+```text
+Author: Tomer Shalev (tomer.shalev@gmail.com)
+```

package/resend/adapter.js

@@ -0,0 +1,76 @@
+import { address_to_friendly_name, convert_to_base64 } from "./adapter.utils.js";
+
+/**
+ * @typedef {import("./types.public.js").Config} Config
+ * @typedef {import('@storecraft/core/v-mailer').mailer<Config>} mailer
+ * @implements {mailer}
+ * 
+ * mailer with Resend rest api
+ */
+export class MailerResend {
+  
+  /** @type {Config} */ #_config;
+
+  /**
+   * 
+   * @param {Config} config 
+   */
+  constructor(config) {
+    this.#_config = config;
+  }
+
+  get config() { return this.#_config; }
+
+  /**
+   * 
+   * @type {mailer["email"]}
+   */
+  async email(o) {
+
+    /** @type {import("./types.private.js").Resend_sendmail} */
+    const body = {
+      from: address_to_friendly_name(o.from),
+      to: o.to.map(t => t.address),
+      subject: o.subject,
+      html: o.html,
+      text: o.text,
+      attachments: o.attachments && await Promise.all(
+        o.attachments.map(
+          /**
+           * @returns {Promise<import("./types.private.js").Resend_sendmail_attachment>}
+           */
+          async a => (
+            {
+              filename: a.filename,
+              content: await convert_to_base64(a.content)
+            }
+          )
+        )
+      ),
+    }
+
+    let r;
+    try {
+      r = await fetch(
+        'https://api.resend.com/emails',
+        {
+          body: JSON.stringify(body),
+          headers: {
+            'Authorization': `Bearer ${this.config.apikey}`,
+            'Content-Type': 'application/json',
+          },
+          method: 'POST',
+        }
+      );
+    } catch (e) {
+      console.log(e);
+    }
+
+    return {
+      success: r.ok,
+      native_response: await r.json()
+    }
+  }
+
+}
+

package/resend/adapter.utils.js

@@ -0,0 +1,35 @@
+import { base64 } from '@storecraft/core/v-crypto'
+
+/**
+ * 
+ * @param {import('@storecraft/core/v-mailer').MailObject["attachments"][0]["content"]} c 
+ */
+export const convert_to_base64 = async (c) => {
+  if(c instanceof ArrayBuffer)
+    return base64.fromUint8Array(new Uint8Array(c));
+  else if(c instanceof ReadableStream) {
+    const reader = c.getReader();
+    const buffer = []
+    while (true) {
+      // The `read()` method returns a promise that
+      // resolves when a value has been received.
+      const { done, value } = await reader.read();
+      // Result objects contain two properties:
+      // `done`  - `true` if the stream has already given you all its data.
+      // `value` - Some data. Always `undefined` when `done` is `true`.
+      if (done) {
+        return base64.fromUint8Array(new Uint8Array(buffer));
+      }
+      buffer.push(value);
+    }
+  }
+  else return base64.toBase64(c.toString());
+}
+
+/**
+ * 
+ * @param {import('@storecraft/core/v-mailer').MailAddress} a 
+ */
+export const address_to_friendly_name = a => {
+  return a.name ? `${a.name} <${a.address}>` : a.address;
+}

package/resend/index.js

@@ -0,0 +1 @@
+export * from './adapter.js'

package/resend/tests/test.js

@@ -0,0 +1,25 @@
+import 'dotenv/config';
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+import { MailerResend } from '../index.js';
+
+const mailer = new MailerResend(
+  {
+      apikey: process.env.RESEND_API_KEY
+  }
+);
+
+test('send email', async () => {
+  
+  let { success, native_response } = await mailer.email({
+    from: {name: 'bob 👻', address: process.env.FROM_EMAIL }, // sender address
+    to: [ { address: process.env.TO_EMAIL } ], // list of receivers
+    subject: 'subject test', // Subject line
+    text: 'plain text test', // plain text body
+    html: '<p>html test</p>', // html body
+  });
+
+  assert.ok(success, `failed with native_response ${JSON.stringify(native_response, null, 2)}`)  
+});
+
+test.run();

package/resend/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "noEmit": true,
+    "allowJs": true,
+    "checkJs": true,
+    "target": "ESNext",
+    "resolveJsonModule": true,
+    "moduleResolution": "NodeNext",
+    "module": "NodeNext",
+    "composite": true,
+  },
+  "include": ["*", "*/*", "src/*"]
+}

package/resend/types.private.d.ts

@@ -0,0 +1,41 @@
+
+export type Resend_sendmail_tag = {
+  /** The name of the email tag. It can only contain ASCII letters (a–z, A–Z), numbers (0–9), underscores (_), or dashes (-). It can contain no more than 256 characters. */
+  name: string;
+  /** The value of the email tag. It can only contain ASCII letters (a–z, A–Z), numbers (0–9), underscores (_), or dashes (-). It can contain no more than 256 characters. */
+  value?: string;
+}
+
+export type Resend_sendmail_attachment = {
+  /** Content of an attached file, base 64 encoded. */
+  content?: string;
+  /** Name of attached file. */
+  filename?: string;
+  /** Path where the attachment file is hosted */
+  path?: string;
+}
+
+export type Resend_sendmail = {
+  /** Sender email address. To include a friendly name, use the format "Your Name <sender@domain.com>". */
+  from: string,
+  /** Recipient email address. For multiple addresses, send as an array of strings. Max 50. */
+  to: string | string[]
+  /** Email subject. */
+  subject: string,
+  /** Bcc recipient email address. For multiple addresses, send as an array of strings. */
+  bcc?: string | string[],
+  /** Cc recipient email address. For multiple addresses, send as an array of strings. */
+  cc?: string | string[],
+  /** Reply-to email address. For multiple addresses, send as an array of strings. */
+  reply_to?: string | string[],
+  /** The HTML version of the message. */
+  html?: string;
+  /** The plain text version of the message. */
+  text?: string;
+  /** Custom headers to add to the email. */
+  headers?: Record<string, string>,
+  /** Email tags */
+  tags?: Resend_sendmail_tag[],
+  /** Filename and content of attachments (max 40mb per email) */
+  attachments?: Resend_sendmail_attachment[];
+}

package/resend/types.public.d.ts

@@ -0,0 +1,9 @@
+export * from './index.js';
+
+/**
+ * config
+ */
+export type Config = {
+  apikey: string,
+};
+

package/sendgrid/README.md

@@ -0,0 +1,27 @@
+# SendGrid mailer over http
+[sendgrid.com](https://docs.sendgrid.com/api-reference/mail-send/mail-send) client, that can work on eveywhere with `javascript`. We only rely on `fetch api`.
+
+## Howto
+
+```js
+import { MailerSendGrid } from '@storecraft/mailer-sendgrid-http';
+
+const mailer = new MailerSendGrid(
+  {
+      apikey: process.env.SEND_GRID_SECRET
+  }
+);
+
+let { success, native_response } = await mailer.email({
+  from: {name: 'bob 👻', address: process.env.FROM_EMAIL }, // sender address
+  to: [ { address: process.env.TO_EMAIL } ], // list of receivers
+  subject: 'subject test', // Subject line
+  text: 'plain text test', // plain text body
+  html: '<p>html test</p>', // html body
+});
+
+```
+
+```text
+Author: Tomer Shalev (tomer.shalev@gmail.com)
+```

package/sendgrid/adapter.js

@@ -0,0 +1,91 @@
+import { convert_to_base64 } from "./adapter.utils.js";
+
+/**
+ * @typedef {import("./types.public.js").Config} Config
+ * @typedef {import('@storecraft/core/v-mailer').mailer<Config>} mailer
+ * @implements {mailer}
+ * 
+ * mailer with sendgrid http api
+ */
+export class MailerSendGrid {
+  
+  /** @type {Config} */ #_config;
+
+  /**
+   * 
+   * @param {Config} config 
+   */
+  constructor(config) {
+    this.#_config = config;
+  }
+
+  get config() { return this.#_config; }
+
+  /**
+   * 
+   * @type {mailer["email"]}
+   */
+  async email(o) {
+
+    /** @type {import("./types.private.js").SendgridV3_sendmail} */
+    const body = {
+      content: [
+          { 
+            type: 'text/html', value: o.html 
+          }, 
+          { 
+            type: 'text/plain', value: o.text 
+          }
+        ].filter(c => Boolean(c.value)),
+      from: { email: o.from.address, name: o.from.name ?? ''},
+      subject: o.subject,
+      attachments: o.attachments && await Promise.all(
+        o.attachments.map(
+          async a => (
+            {
+              content_id: a.content_id,
+              disposition: a.disposition,
+              filename: a.filename,
+              type: a.content_type,
+              content: await convert_to_base64(a.content)
+            }
+          )
+        )
+      ),
+      personalizations: o.to.map(
+        t => (
+          {
+            to: {
+              email: t.address,
+              name: t.name ?? ''
+            }
+          }
+        )
+      )
+    }
+
+    let r;
+    try {
+      r = await fetch(
+        'https://api.sendgrid.com/v3/mail/send',
+        {
+          body: JSON.stringify(body),
+          headers: {
+            'Authorization': `Bearer ${this.config.apikey}`,
+            'Content-Type': 'application/json',
+          },
+          method: 'POST',
+        }
+      );
+    } catch (e) {
+      console.log(e);
+    }
+
+    return {
+      success: r.ok,
+      native_response: await r.json()
+    }
+  }
+
+}
+

package/sendgrid/adapter.utils.js

@@ -0,0 +1,27 @@
+import { base64 } from '@storecraft/core/v-crypto'
+
+/**
+ * 
+ * @param {import('@storecraft/core/v-mailer').MailObject["attachments"][0]["content"]} c 
+ */
+export const convert_to_base64 = async (c) => {
+  if(c instanceof ArrayBuffer)
+    return base64.fromUint8Array(new Uint8Array(c));
+  else if(c instanceof ReadableStream) {
+    const reader = c.getReader();
+    const buffer = []
+    while (true) {
+      // The `read()` method returns a promise that
+      // resolves when a value has been received.
+      const { done, value } = await reader.read();
+      // Result objects contain two properties:
+      // `done`  - `true` if the stream has already given you all its data.
+      // `value` - Some data. Always `undefined` when `done` is `true`.
+      if (done) {
+        return base64.fromUint8Array(new Uint8Array(buffer));
+      }
+      buffer.push(value);
+    }
+  }
+  else return base64.toBase64(c.toString());
+}

package/sendgrid/index.js

@@ -0,0 +1 @@
+export * from './adapter.js'

package/sendgrid/tests/test.js

@@ -0,0 +1,25 @@
+import 'dotenv/config';
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+import { MailerSendGrid } from '../index.js';
+
+const mailer = new MailerSendGrid(
+  {
+      apikey: process.env.SEND_GRID_SECRET
+  }
+);
+
+test('send email', async () => {
+  
+  let { success, native_response } = await mailer.email({
+    from: {name: 'bob 👻', address: process.env.FROM_EMAIL }, // sender address
+    to: [ { address: process.env.TO_EMAIL } ], // list of receivers
+    subject: 'subject test', // Subject line
+    text: 'plain text test', // plain text body
+    html: '<p>html test</p>', // html body
+  });
+
+  assert.ok(success, `failed with native_response ${JSON.stringify(native_response, null, 2)}`)  
+});
+
+test.run();

package/sendgrid/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "noEmit": true,
+    "allowJs": true,
+    "checkJs": true,
+    "target": "ESNext",
+    "resolveJsonModule": true,
+    "moduleResolution": "NodeNext",
+    "module": "NodeNext",
+    "composite": true,
+  },
+  "include": ["*", "*/*", "src/*"]
+}

package/sendgrid/types.private.d.ts

@@ -0,0 +1,58 @@
+
+export type SendgridV3_sendmail_content = {
+  /** The MIME type of the content you are including in your email (e.g., “text/plain” or “text/html”). */
+  type: string,
+  /** The actual content of the specified MIME type that you are including in your email. */
+  value: string,
+}
+
+export type SendgridV3_sendmail_attachment = {
+  /** The Base64 encoded content of the attachment. */
+  content: string;
+  /** The MIME type of the content you are attaching (e.g., “text/plain” or “text/html”). */
+  type?: string;
+  /** The attachment's filename.  */
+  filename: string;
+  /**
+   * The attachment's content-disposition, specifying how you would like the attachment 
+   * to be displayed. For example, “inline” results in the attached file are displayed 
+   * automatically within the message while “attachment” results in the attached file 
+   * require some action to be taken before it is displayed, such as opening or downloading the file.
+   * default: attachment
+   * Allowed Values: inline, attachment
+   */
+  disposition: 'inline' | 'attachment';
+  /** The attachment's content ID. This is used when the disposition is set to “inline” and the attachment is an image, allowing the file to be displayed within the body of your email. */
+  content_id: string;
+}
+
+export type SendgridV3_sendmail_address = {
+  /** The 'From' email address used to deliver the message. This address should be a verified sender in your Twilio SendGrid account. format: email */
+  email: string,
+  /** A name or title associated with the sending email address. */
+  name?: string
+}
+
+export type SendgridV3_sendmail_personalization = {
+  from?: SendgridV3_sendmail_address,
+  to: SendgridV3_sendmail_address,
+  /** An array of recipients who will receive a copy of your email. Each object in this array must contain the recipient's email address. Each object in the array may optionally contain the recipient's name. maxItems: 1000 */
+  cc?: SendgridV3_sendmail_address[],
+  /** An array of recipients who will receive a copy of your email. Each object in this array must contain the recipient's email address. Each object in the array may optionally contain the recipient's name. maxItems: 1000 */
+  bcc?: SendgridV3_sendmail_address[],
+  /** The subject of your email. See character length requirements according to RFC 2822. */
+  subject?: string
+
+}
+
+export type SendgridV3_sendmail = {
+  from: SendgridV3_sendmail_address,
+  /** The global or 'message level' subject of your email. This may be overridden by subject lines set in personalizations. minLength: 1 */
+  subject: string,
+  /** An array where you can specify the content of your email. You can include multiple MIME types of content, but you must specify at least one MIME type. To include more than one MIME type, add another object to the array containing the type and value parameters. */
+  content: SendgridV3_sendmail_content[],
+  /** An array of objects where you can specify any attachments you want to include. */
+  attachments?: SendgridV3_sendmail_attachment[],
+  /** An array of messages and their metadata. Each object within personalizations can be thought of as an envelope - it defines who should receive an individual message and how that message should be handled. See our Personalizations documentation for examples. */
+  personalizations: SendgridV3_sendmail_personalization[]
+}

package/sendgrid/types.public.d.ts

@@ -0,0 +1,10 @@
+export * from './index.js';
+
+/**
+ * config
+ */
+export type Config = {
+  apikey: string,
+
+};
+

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "noEmit": true,
+    "allowJs": true,
+    "checkJs": true,
+    "target": "ESNext",
+    "resolveJsonModule": true,
+    "moduleResolution": "NodeNext",
+    "module": "NodeNext",
+    "composite": true,
+  },
+  "include": ["*", "*/*"]
+}