@develit-services/notification 0.0.2

package/src/database/migrations/meta/0000_snapshot.json

@@ -0,0 +1,101 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "a975fc44-2981-453f-abe4-53763432eb34",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "tables": {
+    "audit_log": {
+      "name": "audit_log",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false,
+          "default": "(unixepoch('subsec') * 1000)"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false,
+          "default": "(unixepoch('subsec') * 1000)"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false,
+          "default": "null"
+        },
+        "event": {
+          "name": "event",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "ip": {
+          "name": "ip",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "user_agent": {
+          "name": "user_agent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "initiator_service": {
+          "name": "initiator_service",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "initiator_user_id": {
+          "name": "initiator_user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

package/src/database/migrations/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1757619388118,
+      "tag": "0000_funny_beast",
+      "breakpoints": true
+    }
+  ]
+}

package/src/database/schema/audit-log.schema.ts

@@ -0,0 +1,13 @@
+import { base } from '@develit-io/backend-sdk'
+import type { AuditLogEventType } from '@services/notification/@types'
+import { sqliteTable, text } from 'drizzle-orm/sqlite-core'
+
+export const auditLog = sqliteTable('audit_log', {
+  ...base,
+  event: text('event').$type<AuditLogEventType>().notNull(),
+  ip: text('ip'),
+  userAgent: text('user_agent'),
+  description: text('description'),
+  initiatorService: text('initiator_service').notNull(),
+  initiatorUserId: text('initiator_user_id'),
+})

package/src/database/schema/index.ts

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

package/src/defineNotificationService.ts

@@ -0,0 +1,321 @@
+import {
+  type IRPCResponse,
+  action,
+  cloudflareQueue,
+  createInternalError,
+  develitWorker,
+  useResult,
+  uuidv4,
+} from '@develit-io/backend-sdk'
+import {
+  type IEmailConnector,
+  type ISmsConnector,
+  type NotificationQueueMessage,
+  type SendEmailInput,
+  type SendEmailOutput,
+  type SendSlackInput,
+  type SendSlackOutput,
+  type SendSmsInput,
+  type SendSmsOutput,
+  sendEmailInputSchema,
+  sendSlackInputSchema,
+  sendSmsInputSchema,
+} from '@develit-services/notification/@types'
+import { tables } from '@develit-services/notification/src/database/drizzle'
+import {
+  createAuditLogCommand,
+  initiateEmailConnector,
+  initiateSmsConnector,
+} from '@develit-services/notification/src/utils'
+import { WorkerEntrypoint } from 'cloudflare:workers'
+import { type DrizzleD1Database, drizzle } from 'drizzle-orm/d1'
+import { SlackConnector } from '../@types/slack/slack.connector'
+
+export class NotificationServiceBase extends develitWorker(
+  WorkerEntrypoint<NotificationEnv>,
+) {
+  readonly name: string
+
+  readonly slackConnector = new SlackConnector(this.env.SLACK_WEBHOOKS)
+  protected emailConnector!: IEmailConnector
+  protected smsConnector!: ISmsConnector
+
+  readonly db: DrizzleD1Database<typeof tables>
+
+  constructor(ctx: ExecutionContext, env: NotificationEnv) {
+    super(ctx, env)
+    this.name = 'notification-service'
+    this.db = drizzle(this.env.NOTIFICATION_D1, { schema: tables })
+  }
+
+  @cloudflareQueue({ baseDelay: 60 })
+  async queue(batch: MessageBatch<NotificationQueueMessage>): Promise<void> {
+    for (const message of batch.messages) {
+      this.logInput({ message })
+
+      let notificationAction
+
+      const { type, metadata, payload } = message.body
+
+      if (type === 'email') {
+        const [emailConnector, error] = await useResult(
+          initiateEmailConnector(
+            this.env.EMAIL_PROVIDER,
+            this.env.EMAIL_API_KEY,
+            this.env.EMAIL_SMTP_HOST,
+            this.env.EMAIL_SENDER,
+          ),
+        )
+
+        if (error) {
+          this.logError({ error })
+          message.retry()
+          continue
+        }
+
+        this.emailConnector = emailConnector!
+      }
+
+      if (type === 'sms') {
+        const [smsConnector, error] = await useResult(
+          initiateSmsConnector(
+            this.env.SMS_PROVIDER,
+            this.env.SMS_ACCOUNT_ID,
+            this.env.SMS_AUTH_TOKEN,
+            this.env.SMS_SERVICE_ID,
+          ),
+        )
+
+        if (error) {
+          this.logError({ error })
+          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
+      }
+
+      const { error, message: errorMessage } = await notificationAction()
+
+      if (error) {
+        this.logError({ error: errorMessage })
+        message.retry()
+        continue
+      }
+
+      message.ack()
+    }
+  }
+
+  @action('private-send-email')
+  private async _sendEmail(
+    input: SendEmailInput,
+  ): Promise<IRPCResponse<SendEmailOutput>> {
+    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')
+  private async _sendSms(
+    input: SendSmsInput,
+  ): Promise<IRPCResponse<SendSmsOutput>> {
+    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: SendEmailInput,
+  ): Promise<IRPCResponse<SendEmailOutput>> {
+    return this.handleAction(
+      { data: input, schema: sendEmailInputSchema },
+      { successMessage: 'Email sent.' },
+      async (params) => {
+        const { email, metadata } = params!
+
+        await this.pushToQueue<NotificationQueueMessage>(
+          this.env.NOTIFICATIONS_QUEUE,
+          {
+            type: 'email',
+            payload: {
+              email,
+            },
+            metadata,
+          },
+        )
+
+        return {}
+      },
+    )
+  }
+
+  @action('public-send-sms')
+  async sendSms(input: SendSmsInput): Promise<IRPCResponse<SendSmsOutput>> {
+    return this.handleAction(
+      { data: input, schema: sendSmsInputSchema },
+      { successMessage: 'SMS sent.' },
+      async (params) => {
+        const {
+          sms: { message, to },
+          metadata,
+        } = params!
+
+        await this.pushToQueue<NotificationQueueMessage>(
+          this.env.NOTIFICATIONS_QUEUE,
+          {
+            type: 'sms',
+            payload: {
+              sms: {
+                message,
+                to,
+              },
+            },
+            metadata,
+          },
+        )
+
+        return {}
+      },
+    )
+  }
+
+  @action('send-push-notification')
+  private async _sendPushNotification(): Promise<IRPCResponse<{}>> {
+    this.logInput({})
+
+    this.logError({ error: 'Method not implemented.' })
+    throw new Error('Method not implemented.')
+  }
+
+  @action('send-slack-notification')
+  async sendSlackNotification(
+    input: SendSlackInput,
+  ): Promise<IRPCResponse<SendSlackOutput>> {
+    return this.handleAction(
+      {
+        data: input,
+        schema: sendSlackInputSchema,
+      },
+      { successMessage: 'Slack sent.' },
+      async (params) => {
+        const { slack } = params!
+
+        await this.slackConnector.sendNotificationToAllSlack(slack.message)
+
+        return {}
+      },
+    )
+  }
+}
+
+export function defineNotificationService() {
+  return class NotificationService extends NotificationServiceBase {
+    constructor(ctx: ExecutionContext, env: NotificationEnv) {
+      super(ctx, env)
+    }
+  }
+}

package/src/defineNotificationWrangler.ts

@@ -0,0 +1,78 @@
+// defineNotificationServiceWrangler.ts
+/** biome-ignore-all lint/suspicious/noExplicitAny: allow any */
+import type { NotificationServiceWranglerConfig } from '../@types'
+
+export function defineNotificationServiceWrangler(
+  config: NotificationServiceWranglerConfig,
+) {
+  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: {} as Record<string, any>,
+  }
+
+  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
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+import { defineNotificationService } from './defineNotificationService'
+import type { WorkerEntrypoint } from 'cloudflare:workers'
+
+const NotificationService = defineNotificationService()
+
+export default NotificationService as new (
+  ctx: ExecutionContext,
+  env: NotificationEnv,
+) => WorkerEntrypoint<NotificationEnv>

package/src/utils/connectors.ts

@@ -0,0 +1 @@
+export const initiateConnector = () => {}

package/src/utils/database/command/create-audit-log.command.ts

@@ -0,0 +1,34 @@
+import { uuidv4 } from '@develit-io/backend-sdk'
+import type { AuditLogInsertType } from '@services/notification/@types'
+import { tables } from '@services/notification/src/database/drizzle'
+import type { DrizzleD1Database } from 'drizzle-orm/d1'
+
+export const createAuditLogCommand = async ({
+  db,
+  auditLog: {
+    event,
+    description,
+    initiatorService,
+    initiatorUserId,
+    ip,
+    userAgent,
+  },
+}: {
+  db: DrizzleD1Database<typeof tables>
+  auditLog: AuditLogInsertType
+}) => {
+  const command = db.insert(tables.auditLog).values({
+    id: uuidv4(),
+    createdAt: new Date(),
+    event,
+    description,
+    ip,
+    userAgent,
+    initiatorService,
+    initiatorUserId,
+  })
+
+  return {
+    command,
+  }
+}

package/src/utils/database/command/index.ts

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

package/src/utils/database/index.ts

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

package/src/utils/email.ts

@@ -0,0 +1,25 @@
+import { createInternalError } from '@develit-io/backend-sdk'
+import {
+  EcomailConnector,
+  type IContact,
+  type IEmailConnector,
+} from '@services/notification/@types'
+
+export const initiateEmailConnector = async (
+  provider: string,
+  apiKey: string,
+  smtpHost: string,
+  sender: IContact,
+): Promise<IEmailConnector> => {
+  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 })
+}

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './email'
+export * from './database'
+export * from './sms'

package/src/utils/sms.ts

@@ -0,0 +1,28 @@
+import { createInternalError } from '@develit-io/backend-sdk'
+import {
+  type ISmsConnector,
+  TwilioConnector,
+} from '@services/notification/@types/sms'
+
+export const initiateSmsConnector = async (
+  provider: string,
+  accountId: string,
+  authToken: string,
+  serviceId: string,
+): Promise<ISmsConnector> => {
+  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,
+  })
+}

package/test/env.d.ts

@@ -0,0 +1,7 @@
+declare module 'cloudflare:test' {
+  interface ProvidedEnv extends NotificationEnv {
+    MIGRATIONS: D1Migration[]
+  }
+
+  export const SELF: Service<import('../src/index').default>
+}