@develit-services/notification 0.0.2 → 0.0.4

package/dist/src.mjs

@@ -0,0 +1,625 @@
+import { useResult, createInternalError, base, uuidv4, develitWorker, cloudflareQueue, action } from '@develit-io/backend-sdk';
+import z$1, { z } from 'zod';
+import { z as z$2 } from 'zod/v4';
+import twilio from 'twilio';
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import 'drizzle-orm';
+import { WorkerEntrypoint } from 'cloudflare:workers';
+import { drizzle } from 'drizzle-orm/d1';
+
+const iContactSchema = z.union([
+  z.string(),
+  z.object({
+    email: z.string(),
+    name: z.union([z.string(), z.undefined()])
+  })
+]);
+const iEmailSchema = z.object({
+  to: z.union([iContactSchema, z.array(iContactSchema)]),
+  replyTo: z.union([iContactSchema, z.array(iContactSchema)]).optional(),
+  cc: z.union([iContactSchema, z.array(iContactSchema)]).optional(),
+  bcc: z.union([iContactSchema, z.array(iContactSchema)]).optional(),
+  from: iContactSchema.optional(),
+  subject: z.string(),
+  text: z.string().optional(),
+  html: z.string().optional(),
+  templateId: z.number().optional(),
+  templateVariables: z.record(z.string(), z.string()).optional()
+});
+
+class IEmailConnector {
+  static providerName;
+  API_KEY;
+  SMTP_HOST;
+  SENDER;
+  constructor({
+    API_KEY,
+    SMTP_HOST,
+    SENDER
+  }) {
+    this.API_KEY = API_KEY;
+    this.SMTP_HOST = SMTP_HOST;
+    this.SENDER = SENDER;
+  }
+}
+
+class EcomailConnector extends IEmailConnector {
+  static providerName = "ecomail";
+  constructor({
+    API_KEY,
+    SMTP_HOST,
+    SENDER
+  }) {
+    super({ API_KEY, SMTP_HOST, SENDER });
+  }
+  async sendEmail(email) {
+    if (email.templateVariables) {
+      for (const [key, value] of Object.entries(email.templateVariables)) {
+        if (typeof value === "string" && String(value).includes("localhost") && key in email.templateVariables) {
+          email.templateVariables[key] = String(value).replace("localhost", "origin");
+        }
+      }
+    }
+    const emEmail = this.convertEmail(email);
+    const uri = emEmail.message.template_id ? "https://api2.ecomailapp.cz/transactional/send-template" : "https://api2.ecomailapp.cz/transactional/send-message";
+    const [data, error] = await useResult(
+      fetch(uri, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          key: this.API_KEY
+        },
+        body: JSON.stringify(emEmail)
+      })
+    );
+    if (error) throw error;
+    return data;
+  }
+  convertEmail(email) {
+    const toContacts = this.convertContacts(email.to);
+    const ccContacts = email.cc ? this.convertContacts(email.cc) : [];
+    const bccContacts = email.bcc ? this.convertContacts(email.bcc) : [];
+    const replyTo = email.replyTo ? this.convertContacts(email.replyTo)[0] : void 0;
+    const from = this.convertContact(email.from || this.SENDER);
+    const subject = email.subject;
+    const textAttachments = email.text ? [{ name: "plain", type: "text/plain", content: email.text }] : [];
+    const htmlAttachments = email.html ? [{ type: "text/html", content: email.html, name: "email_body.html" }] : [];
+    const attachments = [...textAttachments, ...htmlAttachments];
+    const contacts = toContacts.flatMap((to) => {
+      const entries = [];
+      if (ccContacts.length > 0) {
+        ccContacts.forEach((cc) => {
+          entries.push({ email: cc?.email, name: cc?.name, cc: cc?.email });
+        });
+      }
+      if (bccContacts.length > 0) {
+        bccContacts.forEach((bcc) => {
+          entries.push({ email: bcc?.email, name: bcc?.name, bcc: bcc?.email });
+        });
+      }
+      return entries.length > 0 ? entries : [to];
+    });
+    return {
+      message: {
+        from_email: from?.email,
+        from_name: from.name || "",
+        subject,
+        attachments,
+        to: contacts,
+        text: email.text,
+        html: email.html,
+        reply_to: replyTo?.email,
+        template_id: email.templateId,
+        global_merge_vars: email.templateVariables ? Object.keys(email.templateVariables).map((key) => ({
+          name: key,
+          content: email.templateVariables[key]
+        })) : null
+      }
+    };
+  }
+  convertContacts(contacts) {
+    if (!contacts) {
+      return [];
+    }
+    const contactArray = Array.isArray(contacts) ? contacts : [contacts];
+    return contactArray.map(this.convertContact);
+  }
+  convertContact(contact) {
+    if (typeof contact === "string") {
+      return { email: contact, name: void 0 };
+    }
+    return { email: contact?.email, name: contact?.name };
+  }
+}
+
+const sendEmailInputSchema = z$1.object({
+  email: iEmailSchema,
+  metadata: z$1.object({
+    userAgent: z$1.string().optional(),
+    ip: z$1.ipv4().or(z$1.ipv6()).optional(),
+    initiator: z$1.object({
+      service: z$1.string(),
+      userId: z$1.string().optional()
+    })
+  })
+});
+
+const sendSlackInputSchema = z$2.object({
+  slack: z$2.object({
+    message: z$2.string()
+  }),
+  metadata: z$2.object({
+    userAgent: z$2.string().optional(),
+    ip: z$2.ipv4().or(z$2.ipv6()).optional(),
+    initiator: z$2.object({
+      service: z$2.string(),
+      userId: z$2.string().optional()
+    })
+  })
+});
+
+const sendSmsInputSchema = z.object({
+  sms: z.object({
+    message: z.string(),
+    to: z.string()
+  }),
+  metadata: z.object({
+    userAgent: z.string().optional(),
+    ip: z.ipv4().or(z.ipv6()).optional(),
+    initiator: z.object({
+      service: z.string(),
+      userId: z.string().optional()
+    })
+  })
+});
+
+class ISmsConnector {
+  static providerName;
+  ACCOUNT_ID;
+  AUTH_TOKEN;
+  SERVICE_ID;
+  constructor({
+    ACCOUNT_ID,
+    AUTH_TOKEN,
+    SERVICE_ID
+  }) {
+    this.ACCOUNT_ID = ACCOUNT_ID;
+    this.AUTH_TOKEN = AUTH_TOKEN;
+    this.SERVICE_ID = SERVICE_ID;
+  }
+}
+
+class TwilioConnector extends ISmsConnector {
+  static providerName = "twilio";
+  twilioClient;
+  constructor({
+    ACCOUNT_ID,
+    AUTH_TOKEN,
+    SERVICE_ID
+  }) {
+    super({ ACCOUNT_ID, AUTH_TOKEN, SERVICE_ID });
+    this.twilioClient = twilio(ACCOUNT_ID, AUTH_TOKEN);
+  }
+  async sendSms(sms) {
+    const message = await this.twilioClient.messages.create({
+      body: sms.message,
+      messagingServiceSid: this.SERVICE_ID,
+      to: sms.to
+    });
+    if (message.errorMessage)
+      return createInternalError(null, {
+        message: message.errorMessage,
+        status: message.errorCode
+      });
+  }
+}
+
+const auditLog = sqliteTable("audit_log", {
+  ...base,
+  event: text("event").$type().notNull(),
+  ip: text("ip"),
+  userAgent: text("user_agent"),
+  description: text("description"),
+  initiatorService: text("initiator_service").notNull(),
+  initiatorUserId: text("initiator_user_id")
+});
+
+const schema = {
+  __proto__: null,
+  auditLog: auditLog
+};
+
+const tables = schema;
+
+const initiateEmailConnector = async (provider, apiKey, smtpHost, sender) => {
+  const connector = [EcomailConnector].find(
+    (conn) => conn.providerName === provider
+  );
+  if (!connector)
+    throw createInternalError(null, {
+      message: "Unsupported email provider",
+      status: 404
+    });
+  return new connector({ API_KEY: apiKey, SMTP_HOST: smtpHost, SENDER: sender });
+};
+
+const createAuditLogCommand = async ({
+  db,
+  auditLog: {
+    event,
+    description,
+    initiatorService,
+    initiatorUserId,
+    ip,
+    userAgent
+  }
+}) => {
+  const command = db.insert(tables.auditLog).values({
+    id: uuidv4(),
+    createdAt: /* @__PURE__ */ new Date(),
+    event,
+    description,
+    ip,
+    userAgent,
+    initiatorService,
+    initiatorUserId
+  });
+  return {
+    command
+  };
+};
+
+const initiateSmsConnector = async (provider, accountId, authToken, serviceId) => {
+  const connector = [TwilioConnector].find(
+    (conn) => conn.providerName === provider
+  );
+  if (!connector)
+    throw createInternalError(null, {
+      message: "Unsupported sms provider",
+      status: 404
+    });
+  return new connector({
+    ACCOUNT_ID: accountId,
+    AUTH_TOKEN: authToken,
+    SERVICE_ID: serviceId
+  });
+};
+
+class SlackConnector {
+  webhooks;
+  constructor(webhooks) {
+    this.webhooks = webhooks;
+  }
+  async sendNotificationToAllSlack(message) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e3);
+    for (const webhook of this.webhooks) {
+      let response = await fetch(webhook, {
+        method: "POST",
+        body: JSON.stringify({ text: message }),
+        headers: { "Content-Type": "application/json" },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error("Failed sending Slack notification to " + message);
+      }
+    }
+  }
+}
+
+class NotificationServiceBase extends develitWorker(
+  WorkerEntrypoint
+) {
+  name;
+  slackConnector = new SlackConnector(this.env.SLACK_WEBHOOKS);
+  emailConnector;
+  smsConnector;
+  db;
+  constructor(ctx, env) {
+    super(ctx, env);
+    this.name = "notification-service";
+    this.db = drizzle(this.env.NOTIFICATION_D1, { schema: tables });
+  }
+  @cloudflareQueue({ baseDelay: 60 })
+  async queue(batch) {
+    for (const message of batch.messages) {
+      this.logInput({ message });
+      let notificationAction;
+      const { type, metadata, payload } = message.body;
+      if (type === "email") {
+        const [emailConnector, error2] = await useResult(
+          initiateEmailConnector(
+            this.env.EMAIL_PROVIDER,
+            this.env.EMAIL_API_KEY,
+            this.env.EMAIL_SMTP_HOST,
+            this.env.EMAIL_SENDER
+          )
+        );
+        if (error2) {
+          this.logError({ error: error2 });
+          message.retry();
+          continue;
+        }
+        this.emailConnector = emailConnector;
+      }
+      if (type === "sms") {
+        const [smsConnector, error2] = await useResult(
+          initiateSmsConnector(
+            this.env.SMS_PROVIDER,
+            this.env.SMS_ACCOUNT_ID,
+            this.env.SMS_AUTH_TOKEN,
+            this.env.SMS_SERVICE_ID
+          )
+        );
+        if (error2) {
+          this.logError({ error: error2 });
+          message.retry();
+          continue;
+        }
+        this.smsConnector = smsConnector;
+      }
+      switch (type) {
+        case "email":
+          notificationAction = async () => this._sendEmail({
+            email: payload.email,
+            metadata
+          });
+          break;
+        case "sms":
+          notificationAction = async () => this._sendSms({
+            sms: payload.sms,
+            metadata
+          });
+          break;
+        case "pushNotification":
+          notificationAction = async () => this._sendPushNotification();
+          break;
+        case "slack":
+          notificationAction = async () => this.sendSlackNotification({
+            slack: message.body.payload.slack,
+            metadata
+          });
+          break;
+        default:
+          this.logError({ error: `Unknown notification type: ${type}` });
+          message.retry();
+          continue;
+      }
+      const { error, message: errorMessage } = await notificationAction();
+      if (error) {
+        this.logError({ error: errorMessage });
+        message.retry();
+        continue;
+      }
+      message.ack();
+    }
+  }
+  @action("private-send-email")
+  async _sendEmail(input) {
+    return this.handleAction(
+      { data: input, schema: sendEmailInputSchema },
+      { successMessage: "Email sent." },
+      async (params) => {
+        const {
+          email,
+          metadata: {
+            ip,
+            userAgent,
+            initiator: { service, userId }
+          }
+        } = params;
+        if (!this.emailConnector)
+          this.emailConnector = await initiateEmailConnector(
+            this.env.EMAIL_PROVIDER,
+            this.env.EMAIL_API_KEY,
+            this.env.EMAIL_SMTP_HOST,
+            this.env.EMAIL_SENDER
+          );
+        const response = await this.emailConnector.sendEmail(email);
+        if (!response?.ok) {
+          throw createInternalError(null, {
+            message: `Could not send email: ${JSON.stringify(await response?.json())}`,
+            status: 500
+          });
+        }
+        const { command } = await createAuditLogCommand({
+          db: this.db,
+          auditLog: {
+            id: uuidv4(),
+            event: "EMAIL",
+            ip,
+            initiatorService: service,
+            initiatorUserId: userId,
+            userAgent,
+            description: JSON.stringify(input)
+          }
+        });
+        await this.db.batch([command]);
+        return {};
+      }
+    );
+  }
+  @action("private-send-sms")
+  async _sendSms(input) {
+    return this.handleAction(
+      { data: input, schema: sendSmsInputSchema },
+      { successMessage: "Sms sent." },
+      async (params) => {
+        const {
+          sms: { message, to },
+          metadata: {
+            ip,
+            userAgent,
+            initiator: { service, userId }
+          }
+        } = params;
+        await this.smsConnector.sendSms({ message, to });
+        const { command } = await createAuditLogCommand({
+          db: this.db,
+          auditLog: {
+            id: uuidv4(),
+            event: "SMS",
+            ip,
+            userAgent,
+            initiatorService: service,
+            initiatorUserId: userId,
+            description: JSON.stringify(input)
+          }
+        });
+        await this.db.batch([command]);
+        return {};
+      }
+    );
+  }
+  @action("public-send-email")
+  async sendEmail(input) {
+    return this.handleAction(
+      { data: input, schema: sendEmailInputSchema },
+      { successMessage: "Email sent." },
+      async (params) => {
+        const { email, metadata } = params;
+        await this.pushToQueue(
+          this.env.NOTIFICATIONS_QUEUE,
+          {
+            type: "email",
+            payload: {
+              email
+            },
+            metadata
+          }
+        );
+        return {};
+      }
+    );
+  }
+  @action("public-send-sms")
+  async sendSms(input) {
+    return this.handleAction(
+      { data: input, schema: sendSmsInputSchema },
+      { successMessage: "SMS sent." },
+      async (params) => {
+        const {
+          sms: { message, to },
+          metadata
+        } = params;
+        await this.pushToQueue(
+          this.env.NOTIFICATIONS_QUEUE,
+          {
+            type: "sms",
+            payload: {
+              sms: {
+                message,
+                to
+              }
+            },
+            metadata
+          }
+        );
+        return {};
+      }
+    );
+  }
+  @action("send-push-notification")
+  async _sendPushNotification() {
+    this.logInput({});
+    this.logError({ error: "Method not implemented." });
+    throw new Error("Method not implemented.");
+  }
+  @action("send-slack-notification")
+  async sendSlackNotification(input) {
+    return this.handleAction(
+      {
+        data: input,
+        schema: sendSlackInputSchema
+      },
+      { successMessage: "Slack sent." },
+      async (params) => {
+        const { slack } = params;
+        await this.slackConnector.sendNotificationToAllSlack(slack.message);
+        return {};
+      }
+    );
+  }
+}
+function defineNotificationService() {
+  return class NotificationService extends NotificationServiceBase {
+    constructor(ctx, env) {
+      super(ctx, env);
+    }
+  };
+}
+
+function defineNotificationServiceWrangler(config) {
+  const { name, envs } = config;
+  const base = {
+    name,
+    main: "./src/index.ts",
+    compatibility_date: "2025-06-04",
+    compatibility_flags: ["nodejs_compat"],
+    d1_databases: [
+      {
+        binding: "NOTIFICATION_D1",
+        database_name: name,
+        database_id: envs.local.d1.id,
+        migrations_dir: "./src/database/migrations"
+      }
+    ],
+    queues: {
+      producers: [
+        {
+          binding: "NOTIFICATIONS_QUEUE",
+          queue: `${name}`
+        }
+      ],
+      consumers: [
+        {
+          queue: `${name}`,
+          max_batch_size: 1,
+          max_batch_timeout: 5,
+          dead_letter_queue: `${name}-dlq`
+        }
+      ]
+    },
+    env: {}
+  };
+  for (const [envName, envCfg] of Object.entries(envs).filter(
+    ([key]) => key !== "local"
+  )) {
+    base.env[envName] = {
+      vars: {
+        ...envCfg.vars,
+        ENVIRONMENT: envName
+      },
+      d1_databases: [
+        {
+          binding: "NOTIFICATION_D1",
+          database_name: `${name}-${envName}`,
+          database_id: envCfg.d1.id,
+          migrations_dir: "./src/database/migrations"
+        }
+      ],
+      queues: {
+        producers: [
+          {
+            binding: "NOTIFICATIONS_QUEUE",
+            queue: `${name}-${envName}`
+          }
+        ],
+        consumers: [
+          {
+            queue: `${name}-${envName}`,
+            max_batch_size: envCfg.queue?.max_batch_size ?? 1,
+            max_batch_timeout: envCfg.queue?.max_batch_timeout ?? 5,
+            dead_letter_queue: `${name}-dlq-${envName}`
+          }
+        ]
+      }
+    };
+  }
+  return base;
+}
+
+const NotificationService = defineNotificationService();
+
+export { NotificationService as default, defineNotificationService, defineNotificationServiceWrangler };

package/package.json

@@ -1,8 +1,24 @@
 {
   "name": "@develit-services/notification",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "author": "Develit.io s.r.o.",
   "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/src.mjs",
+      "require": "./dist/src.cjs",
+      "types": "./dist/src.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/src.cjs",
+  "types": "./dist/src.d.ts",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "notification-wrangler": "./scripts/generate-wrangler.ts"
+  },
   "scripts": {
     "postinstall": "bun cf:typegen",
     "wrangler:generate": "bun ./scripts/generate-wrangler.ts",

package/@types/consts/audit-log.consts.ts

@@ -1,7 +0,0 @@
-export const AUDIT_LOG_EVENT_TYPES = [
-  'EMAIL',
-  'SMS',
-  'PUSH_NOTIFICATION',
-  'SLACK',
-] as const
-export type AuditLogEventType = (typeof AUDIT_LOG_EVENT_TYPES)[number]

package/@types/consts/index.ts

@@ -1 +0,0 @@
-export * from './audit-log.consts'

package/@types/database/audit-log.types.ts

@@ -1,7 +0,0 @@
-import type { tables } from '@services/notification/src/database/drizzle'
-import type { InferInsertModel, InferSelectModel } from 'drizzle-orm'
-
-export interface AuditLogSelectType
-  extends InferSelectModel<typeof tables.auditLog> {}
-export interface AuditLogInsertType
-  extends InferInsertModel<typeof tables.auditLog> {}

package/@types/database/index.ts

@@ -1 +0,0 @@
-export * from './audit-log.types'

package/@types/email/IEmail.connector.ts

@@ -1,21 +0,0 @@
-import type { IContact, IEmail } from '@develit-services/notification/@types'
-
-export abstract class IEmailConnector {
-  static providerName: string
-
-  public API_KEY: string
-  public SMTP_HOST: string
-  public SENDER: IContact
-
-  protected constructor({
-    API_KEY,
-    SMTP_HOST,
-    SENDER,
-  }: { API_KEY: string; SMTP_HOST: string; SENDER: IContact }) {
-    this.API_KEY = API_KEY
-    this.SMTP_HOST = SMTP_HOST
-    this.SENDER = SENDER
-  }
-
-  abstract sendEmail(email: IEmail): Promise<Response | null>
-}