chore: wip

Author: glennmichael123

app/Actions/NotifyUser.ts

@@ -10,4 +10,5 @@ import type { Events } from '@stacksjs/types'
 export default {
   // eventName: ['Listener1', 'Listener2'] -> listeners default to ./app/actions/*
   'user:registered': ['SendWelcomeEmail'],
+  'user:created': ['NotifyUser'],
 } satisfies Events

app/Actions/ExampleAction.ts renamed to app/Actions/SendWelcomeEmail.ts

@@ -1,29 +1,30 @@
-import { listen } from '@stacksjs/events'
+import type { StacksEvents, WildcardHandler } from '@stacksjs/events'
+import { handleError } from '@stacksjs/error-handling'
+import { emitter } from '@stacksjs/events'
 import { path as p } from '@stacksjs/path'
 import events from './Events'
 
 export async function handleEvents() {
-  for (const key in events) {
-    if (Object.hasOwn(events, key)) {
-      const eventKey = key
-      const eventListeners = events[key]
+  emitter.on('*', listenEvents as WildcardHandler<StacksEvents>)
+}
 
-      for (const eventListener of eventListeners) {
-        const modulePath = eventListener
+async function listenEvents(type: keyof typeof events, event: any) {
+  const eventListeners = events[type]
 
-        if (isFunction(modulePath)) {
-          await modulePath()
-        }
-        else {
-          try {
-            const actionModule = await import(p.projectPath(`Actions/${modulePath}.ts`))
+  if (!eventListeners)
+    return
 
-            listen(eventKey, e => actionModule.default.handle(e))
-          }
-          catch (error) {
-            handleError(`Module not found: ${modulePath}`, error)
-          }
-        }
+  for (const eventListener of eventListeners) {
+    if (isFunction(eventListener)) {
+      await eventListener(event)
+    }
+    else {
+      try {
+        const actionModule = await import(p.projectPath(`Actions/${eventListener}.ts`))
+        await actionModule.default.handle(event)
+      }
+      catch (error) {
+        handleError(`Module not found: ${eventListener}`, error)
       }
     }
   }

app/Events.ts

@@ -0,0 +1,6 @@
+[2025-02-17T13:07:26.478Z] DEBUG: Using database driver: sqlite
+[2025-02-17T13:07:37.907Z] DEBUG: Using database driver: sqlite
+[2025-02-17T13:08:09.939Z] DEBUG: Using database driver: sqlite
+[2025-02-17T13:08:19.049Z] DEBUG: Using database driver: sqlite
+[2025-02-17T13:08:39.004Z] DEBUG: Using database driver: sqlite
+[2025-02-17T13:27:47.210Z] DEBUG: Using database driver: sqlite

app/Listener.ts

@@ -1,7 +1,6 @@
 import type { UserRequestType } from '@stacksjs/orm'
 import { Action } from '@stacksjs/actions'
 import { response } from '@stacksjs/router'
-import User from '../../orm/src/models/User'
 
 export default new Action({
   name: 'User Show',

app/storage/logs/stacks.log

@@ -5,6 +5,7 @@ import { log, runCommandSync } from '@stacksjs/cli'
 import { app, ports } from '@stacksjs/config'
 import { join, path } from '@stacksjs/path'
 import { serve } from '@stacksjs/router'
+import { handleEvents } from '../../../app/Listener'
 
 declare global {
   let counter: number
@@ -66,6 +67,8 @@ serve({
   timezone: app.timezone || 'UTC',
 })
 
+await handleEvents()
+
 process.on('SIGINT', () => {
   log.info(`Exited using Ctrl-C`)
   process.exit()

storage/framework/actions/src/UserShowOrmAction.ts

@@ -104,13 +104,15 @@ export default function mitt<Events extends Record<EventType, unknown>>(
      */
     emit<Key extends keyof Events>(type: Key, evt?: Events[Key]) {
       let handlers = (all as EventHandlerMap<Events>).get(type)
+
       if (handlers) {
         ;(handlers as EventHandlerList<Events[keyof Events]>).slice().forEach((handler) => {
           if (evt !== undefined)
             handler(evt)
         })
       }
       handlers = (all as EventHandlerMap<Events>).get('*')
+
       if (handlers) {
         ;(handlers as WildCardEventHandlerList<Events>).slice().forEach((handler) => {
           if (evt !== undefined)
@@ -144,7 +146,7 @@ export default function mitt<Events extends Record<EventType, unknown>>(
  */
 
 // TODO: need to create an action that auto generates this Events type from the ./app/Events
-interface StacksEvents extends ModelEvents {
+export interface StacksEvents extends ModelEvents, Record<EventType, unknown> {
   'user:registered': UserModel
   'user:logged-in': UserModel
   'user:logged-out': UserModel
@@ -153,13 +155,19 @@ interface StacksEvents extends ModelEvents {
 }
 
 const events: Emitter<StacksEvents> = mitt<StacksEvents>()
+
+// Export clean, typed methods
+type Dispatch = <Key extends keyof StacksEvents>(type: Key, event: StacksEvents[Key]) => void
+type Listen = <Key extends keyof StacksEvents>(type: Key, handler: Handler<StacksEvents[Key]>) => void
+type Off = <Key extends keyof StacksEvents>(type: Key, handler?: Handler<StacksEvents[Key]>) => void
+
 const emitter: Emitter<StacksEvents> = events
-const useEvent: typeof emitter.emit = emitter.emit.bind(emitter)
-const useEvents: any = events
-const dispatch: typeof emitter.emit = emitter.emit.bind(emitter)
 
-const listen: typeof emitter.on = emitter.on.bind(emitter)
-const off: typeof emitter.off = emitter.off.bind(emitter)
-const all: typeof emitter.all = emitter.all
+const useEvents: Emitter<StacksEvents> = events
+const dispatch: Dispatch = emitter.emit
+const all: EventHandlerMap<StacksEvents> = emitter.all
+const listen: Listen = emitter.on
+const useListen: Listen = emitter.on
+const off: Off = emitter.off
 
-export { all, dispatch, events, listen, mitt, off, useEvent, useEvents }
+export { all, dispatch, emitter, events, listen, mitt, off, useEvents, useListen }

storage/framework/api/dev.ts

@@ -416,9 +416,9 @@ export async function writeModelEvents(): Promise<void> {
 
     if (typeof observer === 'boolean') {
       if (observer) {
-        observerString += `'${formattedModelName}:created': Partial<${modelName}Model>\n`
-        observerString += `'${formattedModelName}:updated': Partial<${modelName}Model>\n`
-        observerString += `'${formattedModelName}:deleted': Partial<${modelName}Model>\n`
+        observerString += `'${formattedModelName}:created': ${modelName}Model\n`
+        observerString += `'${formattedModelName}:updated': ${modelName}Model\n`
+        observerString += `'${formattedModelName}:deleted': ${modelName}Model\n`
 
         observerImports += `import type { ${modelName}Model } from '../orm/src/models/${modelName}'`
       }

storage/framework/core/events/src/index.ts

@@ -1,43 +0,0 @@
-import type { ErrorRequestType } from '../types/requests'
-import { Request } from '@stacksjs/router'
-import { customValidate, type schema, validateField } from '@stacksjs/validation'
-
-interface ValidationField {
-  rule: ReturnType<typeof schema.string>
-  message: Record<string, string>
-}
-
-interface CustomAttributes {
-  [key: string]: ValidationField
-}
-interface RequestDataError {
-  id: number
-  type: string
-  message: string
-  stack: string
-  status: number
-  additional_info: string
-  created_at?: Date
-  updated_at?: Date
-}
-export class ErrorRequest extends Request<RequestDataError> implements ErrorRequestType {
-  public id = 1
-  public type = ''
-  public message = ''
-  public stack = ''
-  public status = 0
-  public additional_info = ''
-  public created_at = new Date()
-  public updated_at = new Date()
-
-  public async validate(attributes?: CustomAttributes): Promise<void> {
-    if (attributes === undefined || attributes === null) {
-      await validateField('Error', this.all())
-    }
-    else {
-      await customValidate(attributes, this.all())
-    }
-  }
-}
-
-export const errorRequest = new ErrorRequest()