@develit-services/notification 0.0.3 → 0.0.5

package/src/defineNotificationService.ts

@@ -1,328 +0,0 @@
-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 '../@types'
-import { tables } from './database/drizzle'
-import {
-  createAuditLogCommand,
-  initiateEmailConnector,
-  initiateSmsConnector,
-} from './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
-        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')
-  protected 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')
-  protected 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')
-  protected 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(): new (
-  ctx: ExecutionContext,
-  env: NotificationEnv,
-) => NotificationServiceBase {
-  return class NotificationService extends NotificationServiceBase {
-    constructor(ctx: ExecutionContext, env: NotificationEnv) {
-      super(ctx, env)
-    }
-  }
-}

package/src/defineNotificationWrangler.ts

@@ -1,78 +0,0 @@
-// 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

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

package/src/utils/connectors.ts

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

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

@@ -1,34 +0,0 @@
-import { uuidv4 } from '@develit-io/backend-sdk'
-import type { AuditLogInsertType } from '../../../../@types'
-import { tables } from '../../../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

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

package/src/utils/database/index.ts

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

package/src/utils/email.ts

@@ -1,25 +0,0 @@
-import { createInternalError } from '@develit-io/backend-sdk'
-import {
-  EcomailConnector,
-  type IContact,
-  type IEmailConnector,
-} from '../../@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

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

package/src/utils/sms.ts

@@ -1,25 +0,0 @@
-import { createInternalError } from '@develit-io/backend-sdk'
-import { type ISmsConnector, TwilioConnector } from '../../@types'
-
-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

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

package/test/integration/sendEmail.test.ts

@@ -1,88 +0,0 @@
-// import { SELF } from 'cloudflare:test'
-import { describe, expect, it } from 'vitest'
-
-describe('integration placeholder', () => {
-  it('should pass', () => {
-    expect(true).toBe(true)
-  })
-})
-
-// // class MockEmailConnector extends IEmailConnector {
-// //   constructor() {
-// //     super({
-// //       API_KEY: 'mock_api_key',
-// //       SMTP_HOST: 'mock_smtp_host',
-// //       SENDER: { email: 'sender@example.com', name: 'Sender Name' } as IContact,
-// //     })
-// //   }
-
-// //   async sendEmail(email: IEmail): Promise<Response | null> {
-// //     // Mock implementation for success case
-
-// //     return Promise.resolve(new Response('Email sent.', { status: 200 }))
-// //   }
-// // }
-
-// describe('sendEmail', () => {
-//   // beforeEach(() => {
-//   //   vi.resetModules()
-//   //   vi.doUnmock('../../@types/email/IEmail.connector')
-//   // })
-//   describe('should return a successful response when', () => {
-//     it('the input is valid', async () => {
-//       const { status, message, data, error } = await SELF.sendEmail({
-//         email: {
-//           to: 'anna@example.com',
-//           replyTo: 'anna@example.com',
-//           cc: 'manager@example.com',
-//           bcc: 'admin@example.com',
-//           from: 'ben@example.com',
-//           subject: 'Meeting Reminder',
-//           text: 'Hi! Meeting tomorrow!',
-//           html: undefined,
-//           templateId: 0,
-//           templateVariables: {},
-//         },
-//         metadata: {
-//           userAgent: 'v8',
-//           initiator: {
-//             service: 'test',
-//           },
-//         },
-//       })
-
-//       expect(error).toBeFalsy()
-//       expect(status).toEqual(200)
-//       expect(message).toEqual('Email sent.')
-//       expect(data).toEqual({})
-//     })
-//   })
-
-//   // describe('should return an error when', () => {
-//   //   it('the input is valid', async () => {
-//   //     vi.doMock('../../@types/email/IEmail.connector', () => ({
-//   //       sendEmail: vi.fn().mockRejectedValueOnce(new Error('Error mock')),
-//   //     }))
-
-//   //     const { status, message, data, error } = await SELF.sendEmail({
-//   //       email: {
-//   //         to: 'anna@example.com',
-//   //         replyTo: 'anna@example.com',
-//   //         cc: 'manager@example.com',
-//   //         bcc: 'admin@example.com',
-//   //         from: 'ben@example.com',
-//   //         subject: 'Meeting Reminder',
-//   //         text: 'Hi! Meeting tomorrow!',
-//   //         html: undefined,
-//   //         templateId: 0,
-//   //         templateVariables: {},
-//   //       },
-//   //     })
-
-//   //     expect(error).toBeTruthy()
-//   //     expect(status).toEqual(500)
-//   //     expect(message).toEqual('')
-//   //     expect(data).toEqual(null)
-//   //   })
-//   // })
-// })

package/test/setup/migrations.ts

@@ -1,3 +0,0 @@
-import { applyD1Migrations, env } from 'cloudflare:test'
-
-await applyD1Migrations(env.NOTIFICATION_D1, env.MIGRATIONS)