@stacksjs/actions 0.61.18 → 0.61.19

package/dist/index.js

@@ -611,20 +611,24 @@ export default {
 class Action3 {
   name;
   description;
-  fields;
   rate;
   tries;
   backoff;
   enabled;
+  path;
+  method;
+  validations;
   handle;
-  constructor({ name, description, fields, handle, rate, tries, backoff, enabled }) {
+  constructor({ name, description, validations, handle, rate, tries, backoff, enabled, path: path4, method }) {
     this.name = name;
     this.description = description;
-    this.fields = fields;
+    this.validations = validations;
     this.rate = rate;
     this.tries = tries;
     this.backoff = backoff;
     this.enabled = enabled;
+    this.path = path4;
+    this.method = method;
     this.handle = handle;
   }
 }

package/dist/lint/fix.js

@@ -1,12 +1,6 @@
 // @bun
 // src/lint/fix.ts
-import {log, parseOptions, runCommand} from "@stacksjs/cli";
-import {NpmScript} from "@stacksjs/enums";
-import {projectPath} from "@stacksjs/path";
+import {log, parseOptions} from "@stacksjs/cli";
 log.info("Ensuring Code Style...");
 var options = parseOptions();
-var result = await runCommand(NpmScript.LintFix, {
-  cwd: projectPath(),
-  ...options
-});
 log.success("Linted");

package/dist/lint/index.js

@@ -1,16 +1,5 @@
 // @bun
 // src/lint/index.ts
-import process from "process";
-import {log, runCommands} from "@stacksjs/cli";
-import {NpmScript} from "@stacksjs/enums";
-import {projectPath} from "@stacksjs/path";
-import {ExitCode} from "@stacksjs/types";
+import {log} from "@stacksjs/cli";
 log.info("Ensuring Code Style...");
-var result = await runCommands([NpmScript.Lint, NpmScript.LintPackageJson], {
-  cwd: projectPath()
-});
-if (Array.isArray(result)) {
-  if (result.map((r) => r.isErr()).includes(true))
-    process.exit(ExitCode.FatalError);
-}
 log.success("Linted");

package/dist/release.js

@@ -613,20 +613,24 @@ export default {
 class Action3 {
   name;
   description;
-  fields;
   rate;
   tries;
   backoff;
   enabled;
+  path;
+  method;
+  validations;
   handle;
-  constructor({ name, description, fields, handle, rate, tries, backoff, enabled }) {
+  constructor({ name, description, validations, handle, rate, tries, backoff, enabled, path: path4, method }) {
     this.name = name;
     this.description = description;
-    this.fields = fields;
+    this.validations = validations;
     this.rate = rate;
     this.tries = tries;
     this.backoff = backoff;
     this.enabled = enabled;
+    this.path = path4;
+    this.method = method;
     this.handle = handle;
   }
 }

package/dist/upgrade.js

@@ -7,7 +7,7 @@ import {log} from "@stacksjs/logging";
 import {projectPath} from "@stacksjs/path";
 import * as storage from "@stacksjs/storage";
 // package.json
-var version = "0.61.18";
+var version = "0.61.19";
 
 // src/upgrade.ts
 function checkForUncommittedChanges(options) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/actions",
   "type": "module",
-  "version": "0.61.18",
+  "version": "0.61.19",
   "description": "The Stacks actions.",
   "author": "Chris Breuer",
   "license": "MIT",

package/src/action.ts

@@ -1,12 +1,10 @@
 import type { JobOptions, Nullable } from '@stacksjs/types'
 import type { ValidationBoolean, ValidationNumber, ValidationString } from '@stacksjs/validation'
 
-type FieldKey = string
-interface FieldValue {
+type ValidationKey = string
+interface ValidationValue {
   rule: ValidationString | ValidationNumber | ValidationBoolean | Date | Nullable<any>
   message: string
-  factory?: any
-  unique?: boolean
 }
 
 // TODO: this is temporary and will get auto generated based on ./app/Actions/*
@@ -19,8 +17,9 @@ interface ActionOptions {
   name?: string
   description?: string
   apiResponse?: boolean
-  fields?: Record<FieldKey, FieldValue>
+  validations?: Record<ValidationKey, ValidationValue>
   path?: string
+  method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'
   rate?: JobOptions['rate']
   tries?: JobOptions['tries']
   backoff?: JobOptions['backoff']
@@ -31,23 +30,27 @@ interface ActionOptions {
 export class Action {
   name?: string
   description?: string
-  fields?: Record<FieldKey, FieldValue>
-  rate?: JobOptions['rate']
-  tries?: JobOptions['tries']
-  backoff?: JobOptions['backoff']
-  enabled?: boolean
+  rate?: ActionOptions['rate']
+  tries?: ActionOptions['tries']
+  backoff?: ActionOptions['backoff']
+  enabled?: ActionOptions['enabled']
+  path?: ActionOptions['path']
+  method?: ActionOptions['method']
+  validations?: Record<ValidationKey, ValidationValue>
   handle: (request?: Request) => Promise<any> | object | string
 
-  constructor({ name, description, fields, handle, rate, tries, backoff, enabled }: ActionOptions) {
+  constructor({ name, description, validations, handle, rate, tries, backoff, enabled, path, method }: ActionOptions) {
     // log.debug(`Action ${name} created`) // TODO: this does not yet work because the cloud does not yet have proper file system (efs) access
 
     this.name = name
     this.description = description
-    this.fields = fields
+    this.validations = validations
     this.rate = rate
     this.tries = tries
     this.backoff = backoff
     this.enabled = enabled
+    this.path = path
+    this.method = method
     this.handle = handle
   }
 }

package/src/bump.ts

@@ -3,11 +3,6 @@ import { path as p } from '@stacksjs/path'
 
 const options = parseOptions()
 const changelogCommand = options?.dryRun ? 'buddy changelog --quiet --dry-run' : 'buddy changelog --quiet'
-
-// await runCommand(changelogCommand, {
-//   cwd: p.projectPath(),
-// })
-
 const bumpCommand = options?.dryRun
   ? `bunx bumpp ./package.json ./**/package.json ../ide/vscode/package.json --no-push --execute "../scripts/lint"`
   : `bunx bumpp ./package.json ./**/package.json ../ide/vscode/package.json --all --execute "../scripts/lint"`

package/src/lint/fix.ts

@@ -8,10 +8,10 @@ log.info('Ensuring Code Style...')
 
 const options = parseOptions()
 
-const result = await runCommand(NpmScript.LintFix, {
-  cwd: projectPath(),
-  ...options,
-})
+// const result = await runCommand(NpmScript.LintFix, {
+//   cwd: projectPath(),
+//   ...options,
+// })
 
 // console.log('rs', result.error)
 // if (result.isErr()) {

package/src/lint/index.ts

@@ -12,12 +12,12 @@ log.info('Ensuring Code Style...')
 // await $`${NpmScript.Lint}`
 // await $`${NpmScript.LintPackageJson}`
 
-const result = await runCommands([NpmScript.Lint, NpmScript.LintPackageJson], {
-  cwd: projectPath(),
-})
+// const result = await runCommands([NpmScript.Lint, NpmScript.LintPackageJson], {
+//   cwd: projectPath(),
+// })
 
-if (Array.isArray(result)) {
-  if (result.map((r) => r.isErr()).includes(true)) process.exit(ExitCode.FatalError)
-}
+// if (Array.isArray(result)) {
+//   if (result.map((r) => r.isErr()).includes(true)) process.exit(ExitCode.FatalError)
+// }
 
 log.success('Linted')

package/src/orm/generate-model.ts

@@ -22,23 +22,58 @@ export interface ModelElement {
 await initiateModelGeneration()
 await setKyselyTypes()
 
-async function generateApiRoutes(model: Model) {
-  if (model.traits?.useApi) {
-    let routeString = `import { route } from '@stacksjs/router'\n\n\n`
-    const apiRoutes = model.traits?.useApi?.routes
-
-    if (apiRoutes?.length) {
-      for (const apiRoute of apiRoutes) {
-        await writeOrmActions(apiRoute, model)
-        routeString += await writeApiRoutes(apiRoute, model)
+async function generateApiRoutes(modelFiles: string[]) {
+  const file = Bun.file(path.projectStoragePath(`framework/orm/routes.ts`))
+  const writer = file.writer()
+  let routeString = `import { route } from '@stacksjs/router'\n\n\n`
+
+  for (const modelFile of modelFiles) {
+    log.debug(`Processing model file: ${modelFile}`)
+
+    const model = (await import(modelFile)).default as Model
+
+    if (model.traits?.useApi) {
+      const apiRoutes = model.traits?.useApi?.routes
+      const middlewares = model.traits.useApi?.middleware
+      let middlewareString = `.middleware([`
+
+      if (middlewares.length) {
+        for (let i = 0; i < middlewares.length; i++) {
+          middlewareString += `'${middlewares[i]}'`
+
+          if (i < middlewares.length - 1) {
+            middlewareString += ','
+          }
+        }
       }
-    }
 
-    const file = Bun.file(path.projectStoragePath(`framework/orm/routes.ts`))
-    const writer = file.writer()
-    writer.write(routeString)
-    await writer.end()
+      middlewareString += `])`
+
+      if (apiRoutes?.length) {
+        for (const apiRoute of apiRoutes) {
+          await writeOrmActions(apiRoute, model)
+
+          if (apiRoute === 'index')
+            routeString += `await route.get('${model.table}', 'Actions/${model.name}IndexOrmAction')${middlewareString}\n\n`
+
+          if (apiRoute === 'store')
+            routeString += `await route.post('${model.table}', 'Actions/${model.name}StoreOrmAction')${middlewareString}\n\n`
+
+          if (apiRoute === 'update')
+            routeString += `await route.patch('${model.table}/{id}', 'Actions/${model.name}UpdateOrmAction')${middlewareString}\n\n`
+
+          if (apiRoute === 'show')
+            routeString += `await route.get('${model.table}/{id}', 'Actions/${model.name}ShowOrmAction')${middlewareString}\n\n`
+
+          if (apiRoute === 'destroy')
+            routeString += `await route.delete('${model.table}/{id}', 'Actions/${model.name}DestroyOrmAction')${middlewareString}\n\n`
+        }
+      }
+    }
   }
+
+  writer.write(routeString)
+  await writer.end()
 }
 
 async function writeModelNames() {
@@ -68,57 +103,71 @@ async function writeModelNames() {
 async function writeOrmActions(apiRoute: string, model: Model): Promise<void> {
   const modelName = model.name
   const formattedApiRoute = apiRoute.charAt(0).toUpperCase() + apiRoute.slice(1)
-
+  let method = 'GET'
   let actionString = `import { Action } from '@stacksjs/actions'\n`
-  actionString += `import ${modelName} from '../src/${modelName}'\n\n`
+  actionString += `import ${modelName} from '../src/models/${modelName}'\n\n`
   actionString += `import { request } from '@stacksjs/router'\n\n`
 
   let handleString = ``
 
   if (apiRoute === 'index') {
-    handleString += `handle() {
-        return ${modelName}.all()
+    handleString += `async handle() {
+        return await ${modelName}.all()
       },`
+
+    method = 'GET'
   }
 
   if (apiRoute === 'show') {
-    handleString += `handle() {
-        return ${modelName}.find(1)
+    handleString += `async handle() {
+        const id = await request.getParam('id')
+
+        return ${modelName}.findOrFail(Number(id))
       },`
+
+    method = 'GET'
   }
 
   if (apiRoute === 'destroy') {
-    handleString += `handle() {
-        const model = ${modelName}.find(1)
+    handleString += `async handle() {
+        const id = request.getParam('id')
+
+        const model = await ${modelName}.findOrFail(Number(id))
 
         model.delete()
 
         return 'Model deleted!'
       },`
+
+    method = 'DELETE'
   }
 
   if (apiRoute === 'store') {
-    handleString += `handle() {
-        const model = ${modelName}.create(request.all())
+    handleString += `async handle() {
+        const model = await ${modelName}.create(request.all())
 
         return model
       },`
+
+    method = 'POST'
   }
 
   if (apiRoute === 'update') {
-    handleString += `handle() {
-        const id = request.get(req.params.id)
+    handleString += `async handle() {
+        const id = request.getParam('id')
 
-        const model = ${modelName}.find(req.params.id)
+        const model = await ${modelName}.findOrFail(Number(id))
 
-        return model.update(req.all())
+        return model.update(request.all())
       },`
+
+    method = 'PATCH'
   }
 
   actionString += `export default new Action({
       name: '${modelName} ${formattedApiRoute}',
       description: '${modelName} ${formattedApiRoute} ORM Action',
-
+      method: '${method}',
       ${handleString}
     })
   `
@@ -159,6 +208,8 @@ async function initiateModelGeneration(): Promise<void> {
 
   const modelFiles = glob.sync(path.userModelsPath('*.ts'))
 
+  await generateApiRoutes(modelFiles)
+
   for (const modelFile of modelFiles) {
     log.debug(`Processing model file: ${modelFile}`)
 
@@ -166,8 +217,6 @@ async function initiateModelGeneration(): Promise<void> {
     const tableName = await modelTableName(model)
     const modelName = path.basename(modelFile, '.ts')
 
-    await generateApiRoutes(model)
-
     const file = Bun.file(path.projectStoragePath(`framework/orm/src/models/${modelName}.ts`))
     const fields = await extractFields(model, modelFile)
     const classString = await generateModelString(tableName, model, fields)
@@ -220,7 +269,7 @@ function hasRelations(obj: any, key: string): boolean {
 }
 
 async function deleteExistingModels() {
-  const modelPaths = glob.sync(path.projectStoragePath(`framework/orm/src/models*.ts`))
+  const modelPaths = glob.sync(path.projectStoragePath(`framework/orm/src/models/*.ts`))
 
   for (const modelPath of modelPaths) {
     if (fs.existsSync(modelPath)) await Bun.$`rm ${modelPath}`
@@ -233,10 +282,13 @@ async function deleteExistingModels() {
 
 async function deleteExistingOrmActions() {
   const ormPaths = glob.sync(path.projectStoragePath(`framework/orm/Actions/*.ts`))
+  const routes = path.projectStoragePath(`framework/orm/routes`)
 
   for (const ormPath of ormPaths) {
     if (fs.existsSync(ormPath)) await Bun.$`rm ${ormPath}`
   }
+
+  if (fs.existsSync(routes)) await Bun.$`rm ${routes}`
 }
 
 async function deleteExistingModelNameTypes() {
@@ -586,7 +638,7 @@ async function generateModelString(tableName: string, model: Model, attributes:
 
   const otherModelRelations = await fetchOtherModelRelations(model)
 
-  for (const otherModelRelation of otherModelRelations) fieldString += ` ${otherModelRelation.foreignKey}: number`
+  for (const otherModelRelation of otherModelRelations) fieldString += ` ${otherModelRelation.foreignKey}: number \n`
 
   return `import type { ColumnType, Generated, Insertable, Selectable, Updateable } from 'kysely'
     import type { Result } from '@stacksjs/error-handling'
@@ -643,7 +695,7 @@ async function generateModelString(tableName: string, model: Model, attributes:
       }
 
       // Method to find a ${formattedModelName} by ID
-      static async find(id: number, fields?: (keyof ${modelName}Type)[]) {
+      static async find(id: number, fields?: (keyof ${modelName}Type)[]): Promise<${modelName}Model> {
         let query = db.selectFrom('${tableName}').where('id', '=', id)
 
         if (fields)
@@ -659,7 +711,23 @@ async function generateModelString(tableName: string, model: Model, attributes:
         return new ${modelName}Model(model)
       }
 
-      static async findMany(ids: number[], fields?: (keyof ${modelName}Type)[]) {
+      static async findOrFail(id: number, fields?: (keyof ${modelName}Type)[]): Promise<${modelName}Model> {
+        let query = db.selectFrom('${tableName}').where('id', '=', id)
+
+        if (fields)
+          query = query.select(fields)
+        else
+          query = query.selectAll()
+
+        const model = await query.executeTakeFirst()
+
+        if (!model)
+          throw(\`No model results found for \${id}\ \`)
+
+        return new ${modelName}Model(model)
+      }
+
+      static async findMany(ids: number[], fields?: (keyof ${modelName}Type)[]): Promise<${modelName}Model[]> {
         let query = db.selectFrom('${tableName}').where('id', 'in', ids)
 
         if (fields)
@@ -724,36 +792,23 @@ async function generateModelString(tableName: string, model: Model, attributes:
 
       // Method to create a new ${formattedModelName}
       static async create(new${modelName}: New${modelName}): Promise<${modelName}Model> {
-        const model = await db.insertInto('${tableName}')
+        const result = await db.insertInto('${tableName}')
           .values(new${modelName})
-          .returningAll()
-          .executeTakeFirstOrThrow()
-
-        return new ${modelName}Model(model)
-      }
-
-      // Method to update a ${formattedModelName}
-      static async update(id: number, ${formattedModelName}Update: ${modelName}Update): Promise<${modelName}Model> {
-        const model = await db.updateTable('${tableName}')
-          .set(${formattedModelName}Update)
-          .where('id', '=', id)
-          .returningAll()
           .executeTakeFirstOrThrow()
 
-        return new ${modelName}Model(model)
+        return await find(Number(result.insertId)) as ${modelName}Model
       }
 
       // Method to remove a ${formattedModelName}
       static async remove(id: number): Promise<${modelName}Model> {
         const model = await db.deleteFrom('${tableName}')
           .where('id', '=', id)
-          .returningAll()
           .executeTakeFirstOrThrow()
 
         return new ${modelName}Model(model)
       }
 
-      async where(column: string, operator = '=', value: any) {
+      async where(column: string, operator = '=', value: any): Promise<${modelName}Type[]> {
         let query = db.selectFrom('${tableName}')
 
         query = query.where(column, operator, value)
@@ -805,7 +860,7 @@ async function generateModelString(tableName: string, model: Model, attributes:
         return await query.selectAll().execute()
       }
 
-      async whereIn(column: keyof ${modelName}Type, values: any[], options: QueryOptions = {}) {
+      async whereIn(column: keyof ${modelName}Type, values: any[], options: QueryOptions = {}): Promise<${modelName}Type[]> {
         let query = db.selectFrom('${tableName}')
 
         query = query.where(column, 'in', values)
@@ -824,34 +879,34 @@ async function generateModelString(tableName: string, model: Model, attributes:
         return await query.selectAll().execute()
       }
 
-      async first() {
+      async first(): Promise<${modelName}Type> {
         return await db.selectFrom('${tableName}')
           .selectAll()
           .executeTakeFirst()
       }
 
-      async last() {
+      async last(): Promise<${modelName}Type> {
         return await db.selectFrom('${tableName}')
           .selectAll()
           .orderBy('id', 'desc')
           .executeTakeFirst()
       }
 
-      async orderBy(column: keyof ${modelName}Type, order: 'asc' | 'desc') {
+      async orderBy(column: keyof ${modelName}Type, order: 'asc' | 'desc'): Promise<${modelName}Type[]> {
         return await db.selectFrom('${tableName}')
           .selectAll()
           .orderBy(column, order)
           .execute()
       }
 
-      async orderByDesc(column: keyof ${modelName}Type) {
+      async orderByDesc(column: keyof ${modelName}Type): Promise<${modelName}Type[]> {
         return await db.selectFrom('${tableName}')
           .selectAll()
           .orderBy(column, 'desc')
           .execute()
       }
 
-      async orderByAsc(column: keyof ${modelName}Type) {
+      async orderByAsc(column: keyof ${modelName}Type): Promise<${modelName}Type[]> {
         return await db.selectFrom('${tableName}')
           .selectAll()
           .orderBy(column, 'asc')
@@ -859,7 +914,7 @@ async function generateModelString(tableName: string, model: Model, attributes:
       }
 
       // Method to get the ${formattedModelName} instance itself
-      self() {
+      self(): ${modelName}Model {
         return this
       }
 
@@ -876,14 +931,11 @@ async function generateModelString(tableName: string, model: Model, attributes:
         const updatedModel = await db.updateTable('${tableName}')
           .set(${formattedModelName})
           .where('id', '=', this.${formattedModelName}.id)
-          .returningAll()
           .executeTakeFirst()
 
         if (!updatedModel)
           return err(handleError('${modelName} not found'))
 
-        this.${formattedModelName} = updatedModel
-
         return ok(updatedModel)
       }
 
@@ -896,9 +948,7 @@ async function generateModelString(tableName: string, model: Model, attributes:
           // Insert new ${formattedModelName}
           const newModel = await db.insertInto('${tableName}')
             .values(this.${formattedModelName} as New${modelName})
-            .returningAll()
             .executeTakeFirstOrThrow()
-          this.${formattedModelName} = newModel
         }
         else {
           // Update existing ${formattedModelName}
@@ -969,6 +1019,22 @@ async function generateModelString(tableName: string, model: Model, attributes:
       return new ${modelName}Model(model)
     }
 
+    export async function findOrFail(id: number, fields?: (keyof ${modelName}Type)[]) {
+      let query = db.selectFrom('${tableName}').where('id', '=', id)
+
+      if (fields)
+        query = query.select(fields)
+      else
+        query = query.selectAll()
+
+      const model = await query.executeTakeFirst()
+
+      if (!model)
+        throw(\`No model results found for \${id}\ \`)
+
+      return new ${modelName}Model(model)
+    }
+
     export async function findMany(ids: number[], fields?: (keyof ${modelName}Type)[]) {
       let query = db.selectFrom('${tableName}').where('id', 'in', ids)
 
@@ -982,7 +1048,7 @@ async function generateModelString(tableName: string, model: Model, attributes:
       return model.map(modelItem => new ${modelName}Model(modelItem))
     }
 
-    export async function count() {
+    export async function count(): Number {
       const results = await db.selectFrom('${tableName}')
         .selectAll()
         .execute()
@@ -1025,7 +1091,7 @@ async function generateModelString(tableName: string, model: Model, attributes:
       return await query.selectAll().execute()
     }
 
-    export async function all(limit: number = 10, offset: number = 0) {
+    export async function all(limit: number = 10, offset: number = 0): Promise<${modelName}Type[]> {
       return await db.selectFrom('${tableName}')
         .selectAll()
         .orderBy('created_at', 'desc')
@@ -1034,27 +1100,28 @@ async function generateModelString(tableName: string, model: Model, attributes:
         .execute()
     }
 
-    export async function create(new${modelName}: New${modelName}) {
-      return await db.insertInto('${tableName}')
-        .values(new${modelName})
-        .returningAll()
-        .executeTakeFirstOrThrow()
+    export async function create(new${modelName}: New${modelName}): Promise<${modelName}Model> {
+      const result = await db.insertInto('${tableName}')
+      .values(new${modelName})
+      .executeTakeFirstOrThrow()
+
+      return await find(Number(result.insertId))
     }
 
-    export async function first() {
+    export async function first(): Promise<${modelName}Model> {
      return await db.selectFrom('${tableName}')
         .selectAll()
         .executeTakeFirst()
     }
 
-    export async function recent(limit: number) {
+    export async function recent(limit: number): Promise<${modelName}Model[]> {
       return await db.selectFrom('${tableName}')
          .selectAll()
          .limit(limit)
          .execute()
      }
 
-     export async function last(limit: number) {
+     export async function last(limit: number): Promise<${modelName}Type> {
       return await db.selectFrom('${tableName}')
          .selectAll()
          .orderBy('id', 'desc')
@@ -1072,7 +1139,6 @@ async function generateModelString(tableName: string, model: Model, attributes:
     export async function remove(id: number) {
       return await db.deleteFrom('${tableName}')
         .where('id', '=', id)
-        .returningAll()
         .executeTakeFirst()
     }
 
@@ -1156,6 +1222,7 @@ async function generateModelString(tableName: string, model: Model, attributes:
 
     export const ${modelName} = {
       find,
+      findOrFail,
       findMany,
       get,
       count,

package/src/route/list.ts

@@ -0,0 +1,14 @@
+import process from 'node:process'
+import { log } from '@stacksjs/logging'
+import { listRoutes } from '@stacksjs/router'
+
+// first, reset the database, if it exists
+const result = await listRoutes()
+
+if (result?.isErr()) {
+  console.error(result.error)
+  log.error('Route lists failed', result.error)
+  process.exit(1)
+}
+
+process.exit(0)