chore: wip

Author: glennmichael123

app/Listener.ts

@@ -2,25 +2,27 @@ import { listen } from '@stacksjs/events'
 import { path as p } from '@stacksjs/path'
 import events from './Events'
 
-for (const key in events) {
-  if (Object.hasOwn(events, key)) {
-    const eventKey = key
-    const eventListeners = events[key]
+export async function handleEvents() {
+  for (const key in events) {
+    if (Object.hasOwn(events, key)) {
+      const eventKey = key
+      const eventListeners = events[key]
 
-    for (const eventListener of eventListeners) {
-      const modulePath = eventListener
+      for (const eventListener of eventListeners) {
+        const modulePath = eventListener
 
-      if (isFunction(modulePath)) {
-        await modulePath()
-      }
-      else {
-        try {
-          const actionModule = await import(p.projectPath(`Actions/${modulePath}.ts`))
-
-          listen(eventKey, e => actionModule.default.handle(e))
+        if (isFunction(modulePath)) {
+          await modulePath()
         }
-        catch (error) {
-          handleError(`Module not found: ${modulePath}`, error)
+        else {
+          try {
+            const actionModule = await import(p.projectPath(`Actions/${modulePath}.ts`))
+
+            listen(eventKey, e => actionModule.default.handle(e))
+          }
+          catch (error) {
+            handleError(`Module not found: ${modulePath}`, error)
+          }
         }
       }
     }

app/Middleware/Api.ts

@@ -1,4 +1,5 @@
 import { Middleware, request } from '@stacksjs/router'
+import { HttpError } from 'index'
 import { AccessToken, Team } from '../../storage/framework/orm/src'
 
 export default new Middleware({
@@ -7,42 +8,36 @@ export default new Middleware({
   async handle() {
     const bearerToken = request.bearerToken() || ''
 
-    if (!bearerToken) {
-      throw { message: 'Unauthorized.', status: 401 }
-    }
+    if (!bearerToken)
+      throw new HttpError(401, 'Unauthorized.')
 
     const parts = bearerToken.split(':')
 
-    if (parts.length !== 3) {
-      throw { message: 'Invalid bearer token format', status: 401 }
-    }
+    if (parts.length !== 3)
+      throw new HttpError(401, 'Invalid bearer token format')
 
     const tokenId = Number(parts[0])
     const teamId = parts[1] as string
     const plainString = parts[2] as string
 
     const team = await Team.find(Number(teamId))
 
-    if (!team) {
-      throw new Error(JSON.stringify({ message: 'Invalid bearer token', status: 401 }))
-    }
+    if (!team)
+      throw new HttpError(401, 'Invalid bearer token')
 
     const accessTokens = await team.teamAccessTokens()
 
-    if (!accessTokens.length) {
-      throw new Error(JSON.stringify({ message: 'Invalid bearer token', status: 401 }))
-    }
+    if (!accessTokens.length)
+      throw new HttpError(401, 'Invalid bearer token')
 
     const accessTokenIds = accessTokens.map(accessToken => accessToken.id)
 
-    if (!accessTokenIds.includes(tokenId)) {
-      throw new Error(JSON.stringify({ message: 'Invalid bearer token', status: 401 }))
-    }
+    if (!accessTokenIds.includes(tokenId))
+      throw new HttpError(401, 'Invalid bearer token')
 
     const teamBearerToken = await AccessToken.where('token', plainString).first()
 
-    if (!teamBearerToken) {
-      throw new Error(JSON.stringify({ message: 'Invalid bearer token', status: 401 }))
-    }
+    if (!teamBearerToken)
+      throw new HttpError(401, 'Invalid bearer token')
   },
 })

app/Models/User.ts

@@ -1,4 +1,5 @@
 import type { Model } from '@stacksjs/types'
+import type { UserModel } from '../../storage/framework/orm/src/models/User'
 // soon, these will be auto-imported
 import { faker } from '@stacksjs/faker'
 import { capitalize } from '@stacksjs/strings'
@@ -107,7 +108,7 @@ export default {
   },
 
   get: {
-    fullName: (user: User) => capitalize(user.name),
+    fullName: (user: UserModel) => capitalize(user.name || ''),
   },
 
   set: {

resources/views/auth/login.vue

@@ -1,13 +1,11 @@
 <script setup lang="ts">
-import { startAuthentication } from '@simplewebauthn/browser'
 // Imports
 import { ref } from 'vue'
 import { useRouter } from 'vue-router'
 
 // Reactive state for form inputs and messages
 const email = ref('')
 const password = ref('')
-const successMessage = ref('')
 const errorMessage = ref('')
 
 // Router instance
@@ -51,48 +49,6 @@ async function login() {
     password.value = ''
   }
 }
-
-// Method to handle passkey login
-async function loginPasskey() {
-  // Reset success/error messages
-  successMessage.value = ''
-  errorMessage.value = ''
-
-  try {
-    // Fetch authentication options based on email
-    const resp = await fetch(`http://localhost:3008/generate-authentication-options?email=${email.value}`)
-    const options: any = await resp.json()
-
-    // Start the WebAuthn authentication process
-    const asseResp = await startAuthentication(options)
-
-    // Verify the authentication response with the backend
-    const verificationResp: any = await fetch('http://localhost:3008/verify-authentication', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        res: asseResp,
-        email: email.value,
-        challenge: options.challenge,
-      }),
-    })
-
-    const verificationJSON = await verificationResp.json()
-
-    if (verificationJSON?.verified) {
-      successMessage.value = 'Authentication successful!'
-      router.push({ path: '/dashboard' })
-    }
-    else {
-      errorMessage.value = `Authentication failed. Response: ${JSON.stringify(verificationJSON)}`
-    }
-  }
-  catch (error) {
-    errorMessage.value = 'An error occurred during passkey authentication'
-  }
-}
 </script>
 
 <template>
@@ -133,7 +89,7 @@ async function loginPasskey() {
           </div>
 
           <div>
-            <button type="submit" class="w-full flex justify-center rounded-md bg-indigo-600 px-3 py-1.5 text-sm text-white font-semibold leading-6 shadow-sm hover:bg-indigo-500 focus-visible:outline-2 focus-visible:outline-indigo-600 focus-visible:outline-offset-2 focus-visible:outline" @click="loginPasskey" @click="login">
+            <button type="submit" class="w-full flex justify-center rounded-md bg-indigo-600 px-3 py-1.5 text-sm text-white font-semibold leading-6 shadow-sm hover:bg-indigo-500 focus-visible:outline-2 focus-visible:outline-indigo-600 focus-visible:outline-offset-2 focus-visible:outline" @click="login">
               Sign in
             </button>
           </div>

storage/framework/actions/src/UserIndexOrmAction.ts

@@ -1,12 +1,11 @@
-import type { UserRequestType } from '../../types/requests'
 import { Action } from '@stacksjs/actions'
 import User from '../../orm/src/models/User'
 
 export default new Action({
   name: 'User Index',
   description: 'User Index ORM Action',
   method: 'GET',
-  async handle(request: UserRequestType) {
+  async handle() {
     return await User.all()
   },
 })

storage/framework/core/auth/src/authentication.ts

@@ -1,3 +1,4 @@
+import { HttpError } from '@stacksjs/error-handling'
 import { request } from '@stacksjs/router'
 import { verifyHash } from '@stacksjs/security'
 import AccessToken from '../../../orm/src/models/AccessToken'
@@ -53,9 +54,8 @@ export async function team(): Promise<TeamModel | undefined> {
 
   const parts = bearerToken.split(':')
 
-  if (parts.length !== 3) {
-    throw { message: 'Invalid bearer token format', status: 401 }
-  }
+  if (parts.length !== 3)
+    throw new HttpError(401, 'Invalid bearer token format')
 
   const tokenId = Number(parts[0])
   const teamId = parts[1]
@@ -83,9 +83,8 @@ export async function authToken(): Promise<AuthToken | undefined> {
 
     const tokenId = accessToken?.id
 
-    if (!accessToken) {
-      throw { error: 'Error generating token!' }
-    }
+    if (!accessToken)
+      throw new HttpError(500, 'Error generating token!')
 
     return `${tokenId}:${team.id}:${accessToken.token}`
   }

storage/framework/core/cache/src/drivers/dynamodb.ts

@@ -30,13 +30,21 @@ const client = new BentoCache({
 
 export const dynamodb: CacheDriver = {
   async set(key: string, value: string, ttl?: number): Promise<void> {
-    await client.set({
+    const data: { key: string, value: string, gracePeriod?: { enabled: boolean, duration: string } } = {
       key,
       value,
-      gracePeriod: { enabled: true, duration: '5m' },
-    })
+    }
+
+    if (ttl) {
+      data.gracePeriod = {
+        enabled: true,
+        duration: `${ttl}m`,
+      }
+    }
+
+    await client.set(data)
   },
-  async setForever(key: string, value: string, ttl?: number): Promise<void> {
+  async setForever(key: string, value: string): Promise<void> {
     await client.setForever({
       key,
       value,

storage/framework/core/cache/src/drivers/filesystem.ts

@@ -16,13 +16,21 @@ const client = new BentoCache({
 
 export const fileSystem: CacheDriver = {
   async set(key: string, value: string, ttl?: number): Promise<void> {
-    await client.set({
+    const data: { key: string, value: string, gracePeriod?: { enabled: boolean, duration: string } } = {
       key,
       value,
-      gracePeriod: { enabled: true, duration: '5m' },
-    })
+    }
+
+    if (ttl) {
+      data.gracePeriod = {
+        enabled: true,
+        duration: `${ttl}m`,
+      }
+    }
+
+    await client.set(data)
   },
-  async setForever(key: string, value: string, ttl?: number): Promise<void> {
+  async setForever(key: string, value: string): Promise<void> {
     await client.setForever({
       key,
       value,

storage/framework/core/cache/src/drivers/memory.ts

@@ -16,13 +16,21 @@ const client = new BentoCache({
 
 export const memory: CacheDriver = {
   async set(key: string, value: string, ttl?: number): Promise<void> {
-    await client.set({
+    const data: { key: string, value: string, gracePeriod?: { enabled: boolean, duration: string } } = {
       key,
       value,
-      gracePeriod: { enabled: true, duration: '5m' },
-    })
+    }
+
+    if (ttl) {
+      data.gracePeriod = {
+        enabled: true,
+        duration: `${ttl}m`,
+      }
+    }
+
+    await client.set(data)
   },
-  async setForever(key: string, value: string, ttl?: number): Promise<void> {
+  async setForever(key: string, value: string): Promise<void> {
     await client.setForever({
       key,
       value,

storage/framework/core/cache/src/drivers/redis.ts

@@ -15,13 +15,21 @@ const client = new BentoCache({
 
 export const redis: CacheDriver = {
   async set(key: string, value: string, ttl?: number): Promise<void> {
-    await client.set({
+    const data: { key: string, value: string, gracePeriod?: { enabled: boolean, duration: string } } = {
       key,
       value,
-      gracePeriod: { enabled: true, duration: '5m' },
-    })
+    }
+
+    if (ttl) {
+      data.gracePeriod = {
+        enabled: true,
+        duration: `${ttl}m`,
+      }
+    }
+
+    await client.set(data)
   },
-  async setForever(key: string, value: string, ttl?: number): Promise<void> {
+  async setForever(key: string, value: string): Promise<void> {
     await client.setForever({
       key,
       value,