chore: wip

Author: glennmichael123

routes/api.ts

@@ -1,26 +0,0 @@
-import { route } from '@stacksjs/router'
-
-/**
- * This file is the entry point for your application's API routes.
- * The routes defined here are automatically registered. Last but
- * not least, you may also create any other `routes/*.ts` files.
- *
- * @see https://stacksjs.org/docs/routing
- */
-
-await route.get('/', () => 'hello world') // $APP_URL/api
-await route.get('/hello/world', () => 'hello world, buddy') // stacksjs.org/api/hello/world
-await route.get('/hello-world', () => {
-  // $APP_URL/api/welcome
-  return {
-    // you may return an object as well
-    data: 'hello world, friend',
-  }
-})
-
-await route.email('/welcome')
-await route.health() // adds an `/api/health` route
-
-// await route.group('/some-path', async () => {...})
-// await route.action('/example') // equivalent to `route.get('/example', 'ExampleAction')`
-// await route.job('/example-two') // equivalent to `route.get('/example-two', 'ExampleTwoJob')`

storage/framework/core/actions/src/orm/generate-model.ts

@@ -23,11 +23,13 @@ await initiateModelGeneration()
 await setKyselyTypes()
 
 async function generateApiRoutes(model: ModelDefault) {
+
   let routeString = `import { route } from '@stacksjs/router'\n\n\n`
   if (model.default.traits?.useApi) {
     const apiRoutes = model.default.traits?.useApi?.routes
     if (apiRoutes.length) {
       for (const apiRoute of apiRoutes) {
+        await writeOrmActions(apiRoute, model)
         routeString += await writeApiRoutes(apiRoute, model)
       }
     }
@@ -41,36 +43,61 @@ async function generateApiRoutes(model: ModelDefault) {
   }
 }
 
-async function writeOrmActions(): Promise<void> {}
+async function writeOrmActions(apiRoute: string, model: ModelDefault): Promise<void> {
+  const modelName = model.default.name
+  const formattedApiRoute = apiRoute.charAt(0).toUpperCase() + apiRoute.slice(1)
+
+  let actionString = `import { Action } from '@stacksjs/actions'\n`
+   actionString += `import ${modelName} from '../${modelName}'\n\n`
+
+    actionString += `export default new Action({
+      name: '${modelName} ${formattedApiRoute}',
+      description: '${modelName} ${formattedApiRoute} Orm Action',
+    
+      handle() {
+        return ${modelName}.find(1)
+      },
+    })
+  `
+
+  const file = Bun.file(path.projectStoragePath(`framework/orm/Actions/${modelName}${formattedApiRoute}OrmAction.ts`))
+
+  const writer = file.writer()
+
+  writer.write(actionString)
+}
 
 async function writeApiRoutes(
   apiRoute: string,
   model: ModelDefault,
 ): Promise<string> {
   let routeString = ``
-  const modelNameFormatted = model.default.name.toLowerCase()
+  const tableName = model.default.table
   const modelName = model.default.name
 
   if (apiRoute === 'index')
-    routeString += `await route.get('${modelNameFormatted}', () => 'Actions/${modelName}IndexOrmAction')\n\n`
+    routeString += `await route.get('${tableName}', () => 'Actions/${modelName}IndexOrmAction')\n\n`
 
   if (apiRoute === 'store')
-    routeString += `await route.post('${modelNameFormatted}', () => 'Actions/${modelName}StoreOrmAction')\n\n`
+    routeString += `await route.post('${tableName}', () => 'Actions/${modelName}StoreOrmAction')\n\n`
 
   if (apiRoute === 'update')
-    routeString += `await route.patch('${modelNameFormatted}/{id}', () => 'Actions/${modelName}UpdateOrmAction')\n\n`
+    routeString += `await route.patch('${tableName}/{id}', () => 'Actions/${modelName}UpdateOrmAction')\n\n`
 
   if (apiRoute === 'show')
-    routeString += `await route.get('${modelNameFormatted}/{id}', () => 'Actions/${modelName}ShowOrmAction')\n\n`
+    routeString += `await route.get('${tableName}/{id}', () => 'Actions/${modelName}ShowOrmAction')\n\n`
 
   if (apiRoute === 'destroy')
-    routeString += `await route.delete('${modelNameFormatted}/{id}', () => 'Actions/${modelName}DestroyOrmAction')\n\n`
+    routeString += `await route.delete('${tableName}/{id}', () => 'Actions/${modelName}DestroyOrmAction')\n\n`
 
   return routeString
 }
 
 async function initiateModelGeneration(): Promise<void> {
+  
   await deleteExistingModels()
+  await deleteExistingOrmActions()
+
   const modelFiles = glob.sync(path.userModelsPath('*.ts'))
 
   for (const modelFile of modelFiles) {
@@ -79,7 +106,8 @@ async function initiateModelGeneration(): Promise<void> {
     const tableName = model.default.table
     const modelName = model.default.name
 
-    generateApiRoutes(model)
+    await generateApiRoutes(model)
+   
 
     const file = Bun.file(
       path.projectStoragePath(`framework/orm/${modelName}.ts`),
@@ -156,6 +184,14 @@ async function deleteExistingModels() {
   if (fs.existsSync(typePath)) await Bun.$`rm ${typePath}`
 }
 
+async function deleteExistingOrmActions() {
+  const ormPaths = glob.sync(path.projectStoragePath(`framework/orm/Actions/*.ts`))
+
+  for (const ormPath of ormPaths) {
+    if (fs.existsSync(ormPath)) await Bun.$`rm ${ormPath}`
+  }
+}
+
 async function setKyselyTypes() {
   let text = ``
   const modelFiles = glob.sync(path.userModelsPath('*.ts'))

storage/framework/core/router/src/router.ts

@@ -267,15 +267,16 @@ export class Router implements RouterInterface {
     callback: Route['callback'],
   ): Promise<Route['callback']> {
     if (callback instanceof Promise) {
+
       const actionModule = await callback
       return actionModule.default
     }
 
     if (typeof callback === 'string')
-      return this.importCallbackFromPath(callback, this.path)
+      return await this.importCallbackFromPath(callback, this.path)
 
     // in this case, the callback ends up being a function
-    return callback
+    return await callback
   }
 
   private async importCallbackFromPath(
@@ -309,7 +310,7 @@ export class Router implements RouterInterface {
     const newPath = actionModule.default.path ?? originalPath
     this.updatePathIfNeeded(newPath, originalPath)
 
-    return actionModule.default.handle
+    return await actionModule.default.handle()
   }
 
   private normalizePath(path: string): string {

storage/framework/core/router/src/server.ts

@@ -27,8 +27,8 @@ export async function serve(options: ServeOptions = {}) {
     port,
     development,
 
-    fetch(req: Request) {
-      return serverResponse(req)
+    async fetch(req: Request) {
+      return await serverResponse(req)
     },
   })
 }
@@ -70,7 +70,7 @@ export async function serverResponse(req: Request) {
   addRouteParamsAndQuery(url, foundRoute)
   executeMiddleware(foundRoute)
 
-  return execute(foundRoute, req, { statusCode: foundRoute?.statusCode })
+  return await execute(foundRoute, req, { statusCode: foundRoute?.statusCode })
 }
 
 function addRouteParamsAndQuery(url: URL, route: Route): void {
@@ -109,14 +109,14 @@ interface Options {
   statusCode?: StatusCode
 }
 
-function execute(route: Route, request: Request, { statusCode }: Options) {
+async function execute(route: Route, request: Request, { statusCode }: Options) {
   if (!statusCode) statusCode = 200
 
   if (route?.method === 'GET' && (statusCode === 301 || statusCode === 302)) {
     const callback = String(route.callback)
     const response = Response.redirect(callback, statusCode)
 
-    return noCache(response)
+    return await noCache(response)
   }
 
   if (route?.method !== request.method)
@@ -127,26 +127,26 @@ function execute(route: Route, request: Request, { statusCode }: Options) {
     try {
       const fileContent = Bun.file(route.callback)
 
-      return new Response(fileContent, {
+      return await new Response(fileContent, {
         headers: { 'Content-Type': 'text/html' },
       })
     } catch (error) {
-      return new Response('Error reading the HTML file', { status: 500 })
+      return await new Response('Error reading the HTML file', { status: 500 })
     }
   }
 
-  if (isString(route.callback)) return new Response(route.callback)
+  if (isString(route.callback)) return await new Response(route.callback)
 
   if (isFunction(route.callback)) {
     const result = route.callback()
-    return new Response(JSON.stringify(result))
+    return await new Response(JSON.stringify(result))
   }
 
   if (isObject(route.callback))
-    return new Response(JSON.stringify(route.callback))
+    return await new Response(JSON.stringify(route.callback))
 
   // If no known type matched, return a generic error.
-  return new Response('Unknown callback type.', { status: 500 })
+  return await new Response('Unknown callback type.', { status: 500 })
 }
 
 function noCache(response: Response) {