@develit-services/notification 0.0.4 → 0.0.6

package/dist/src.mjs

@@ -1,555 +1,3 @@
-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 = {
@@ -620,6 +68,4 @@ function defineNotificationServiceWrangler(config) {
   return base;
 }
 
-const NotificationService = defineNotificationService();
-
-export { NotificationService as default, defineNotificationService, defineNotificationServiceWrangler };
+export { defineNotificationServiceWrangler };