chore: wip

Author: glennmichael123

config/services.ts

@@ -35,6 +35,7 @@ export default {
   },
 
   mailtrap: {
+    host: env.MAILTRAP_HOST,
     token: env.MAILTRAP_TOKEN,
     inboxId: env.MAILTRAP_INBOX_ID,
     maxRetries: env.MAILTRAP_MAX_RETRIES ? Number.parseInt(env.MAILTRAP_MAX_RETRIES) : 3,
@@ -70,6 +71,13 @@ export default {
   //   apiKey: '',
   // },
 
+  slack: {
+    appId: env.SLACK_APP_ID,
+    clientId: env.SLACK_CLIENT_ID,
+    secretKey: env.SLACK_SECRET_KEY,
+    maxRetries: env.SLACK_MAX_RETRIES ? Number.parseInt(env.SLACK_MAX_RETRIES) : 3,
+    retryTimeout: env.SENDGRID_RETRY_TIMEOUT ? Number.parseInt(env.SENDGRID_RETRY_TIMEOUT) : 1000,
+  },
   stripe: {
     appId: '',
     apiKey: '',

storage/framework/actions/src/UserShowOrmAction.ts

@@ -1,6 +1,5 @@
 import { Action } from '@stacksjs/actions'
 import { mail } from '@stacksjs/email'
-import { response } from '@stacksjs/router'
 
 export default new Action({
   name: 'User Show',
@@ -14,7 +13,7 @@ export default new Action({
       },
       to: 'chrisbreuer93@gmail.com',
       subject: 'Test Email',
-      text: 'test',
+      template: 'WelcomeTest',
     })
 
     // async handle(request: UserRequestType) {

storage/framework/core/chat/src/drivers/base.ts

@@ -0,0 +1,121 @@
+import type { ChatDriver, ChatDriverConfig, ChatMessage, ChatResult, RenderOptions } from '@stacksjs/types'
+import { log } from '@stacksjs/logging'
+
+export abstract class BaseChatDriver implements ChatDriver {
+  public abstract name: string
+  protected config: Required<ChatDriverConfig>
+
+  constructor(config?: ChatDriverConfig) {
+    this.config = {
+      maxRetries: config?.maxRetries || 3,
+      retryTimeout: config?.retryTimeout || 1000,
+      ...config,
+    }
+  }
+
+  public configure(config: ChatDriverConfig): void {
+    this.config = { ...this.config, ...config }
+  }
+
+  public abstract send(message: ChatMessage, options?: RenderOptions): Promise<ChatResult>
+
+  /**
+   * Validates chat message fields
+   */
+  protected validateMessage(message: ChatMessage): boolean {
+    if (!message.to) {
+      throw new Error('Message recipient is required')
+    }
+
+    if (!message.content && !message.template) {
+      throw new Error('Either message content or template is required')
+    }
+
+    return true
+  }
+
+  /**
+   * Error handler with standard formatting
+   */
+  protected async handleError(error: unknown, message: ChatMessage): Promise<ChatResult> {
+    const err = error instanceof Error ? error : new Error(String(error))
+
+    log.error(`[${this.name}] Message sending failed`, {
+      error: err.message,
+      stack: err.stack,
+      to: message.to,
+      subject: message.subject,
+    })
+
+    let result: ChatResult = {
+      message: `Message sending failed: ${err.message}`,
+      success: false,
+      provider: this.name,
+    }
+
+    if (message.onError) {
+      const customResult = message.onError(err)
+      const handlerResult = customResult instanceof Promise
+        ? await customResult
+        : customResult
+
+      result = {
+        ...result,
+        ...handlerResult,
+        success: false,
+        provider: this.name,
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * Success handler with standard formatting
+   */
+  protected async handleSuccess(message: ChatMessage, messageId?: string): Promise<ChatResult> {
+    let result: ChatResult = {
+      message: 'Message sent successfully',
+      success: true,
+      provider: this.name,
+      messageId,
+    }
+
+    try {
+      if (message.handle) {
+        const customResult = message.handle()
+        const handlerResult = customResult instanceof Promise
+          ? await customResult
+          : customResult
+
+        result = {
+          ...result,
+          ...handlerResult,
+          success: true,
+          provider: this.name,
+          messageId,
+        }
+      }
+
+      if (message.onSuccess) {
+        const successResult = message.onSuccess()
+        const handlerResult = successResult instanceof Promise
+          ? await successResult
+          : successResult
+
+        result = {
+          ...result,
+          ...handlerResult,
+          success: true,
+          provider: this.name,
+          messageId,
+        }
+      }
+    }
+    catch (error) {
+      return this.handleError(error, message)
+    }
+
+    return result
+  }
+}

storage/framework/core/chat/src/drivers/slack.ts

@@ -1,24 +1,77 @@
-// import { SlackProvider } from '@novu/slack'
-// import { italic } from '@stacksjs/cli'
-// import type { ChatOptions } from '@stacksjs/types'
-// import { ResultAsync } from '@stacksjs/error-handling'
-// import { notification } from '@stacksjs/config'
-
-// const env = notification.chat.slack
-
-// const provider = new SlackProvider({
-//   applicationId: env.appId,
-//   clientId: env.clientId,
-//   secretKey: env.secret,
-// })
-
-// function send(options: ChatOptions) {
-//   return ResultAsync.fromPromise(
-//     provider.sendMessage(options),
-//     () => new Error(`Failed to send message using provider: ${italic('Slack')}`),
-//   )
-// }
-
-// export { send as Send, send }
-
-export type {}
+import type { ChatMessage, ChatOptions, ChatResult } from '@stacksjs/types'
+import { SlackProvider } from '@novu/slack'
+import { config } from '@stacksjs/config'
+import { log } from '@stacksjs/logging'
+import { BaseChatDriver } from './base'
+
+export class SlackDriver extends BaseChatDriver {
+  public name = 'slack'
+  private provider: SlackProvider
+
+  constructor() {
+    super()
+    const env = config.services.slack
+
+    this.provider = new SlackProvider({
+      applicationId: env?.appId ?? '',
+      clientId: env?.clientId ?? '',
+      secretKey: env?.secret ?? '',
+    })
+  }
+
+  public async send(message: ChatMessage, options?: ChatOptions): Promise<ChatResult> {
+    const logContext = {
+      provider: this.name,
+      to: message.to,
+      subject: message.subject || 'No subject',
+    }
+
+    log.info('Sending message via Slack...', logContext)
+
+    try {
+      this.validateMessage(message)
+
+      const payload = {
+        ...message,
+        ...options,
+      }
+
+      const response = await this.sendWithRetry(payload)
+      return this.handleSuccess(message, response.id)
+    }
+    catch (error) {
+      return this.handleError(error, message)
+    }
+  }
+
+  private async sendWithRetry(payload: any, attempt = 1): Promise<any> {
+    try {
+      const response = await this.provider.sendMessage(payload)
+
+      log.info(`[${this.name}] Message sent successfully`, {
+        attempt,
+        messageId: response.id,
+      })
+
+      return response
+    }
+    catch (error) {
+      if (attempt < (config.services.slack?.maxRetries ?? 3)) {
+        const retryTimeout = config.services.slack?.retryTimeout ?? 1000
+        log.warn(`[${this.name}] Message send failed, retrying (${attempt}/${config.services.slack?.maxRetries ?? 3})`)
+        await new Promise(resolve => setTimeout(resolve, retryTimeout))
+        return this.sendWithRetry(payload, attempt + 1)
+      }
+      throw error
+    }
+  }
+}
+
+export default SlackDriver
+
+export { SlackDriver as Driver }
+export const driver = new SlackDriver()
+
+export async function send(message: ChatMessage, options?: ChatOptions): Promise<ChatResult> {
+  return driver.send(message, options)
+}