@stacksjs/actions 0.61.20 → 0.61.22

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.20";
+var version = "0.61.22";
 
 // src/upgrade.ts
 function checkForUncommittedChanges(options) {

package/package.json

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

package/src/orm/generate-model.ts

@@ -1,11 +1,10 @@
 import { log } from '@stacksjs/logging'
-import { modelTableName } from '@stacksjs/orm'
 import { path } from '@stacksjs/path'
 import { fs, glob } from '@stacksjs/storage'
-import { pascalCase } from '@stacksjs/strings'
+import { camelCase, pascalCase } from '@stacksjs/strings'
 import type { Model, RelationConfig } from '@stacksjs/types'
-import { isString } from '@stacksjs/validation'
-
+import { isString, isBoolean } from '@stacksjs/validation'
+import { getModelName, getTableName} from '@stacksjs/orm'
 export interface FieldArrayElement {
   entity: string
   charValue?: string | null
@@ -29,44 +28,47 @@ async function generateApiRoutes(modelFiles: string[]) {
 
   for (const modelFile of modelFiles) {
     log.debug(`Processing model file: ${modelFile}`)
-
+    let middlewareString = ''
     const model = (await import(modelFile)).default as Model
+    const modelName = getModelName(model, modelFile)
+    const tableName = getTableName(model, modelFile)
 
     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 += ','
+      if (middlewares) {
+        middlewareString = `.middleware([`
+        if (middlewares.length) {
+          for (let i = 0; i < middlewares.length; i++) {
+            middlewareString += `'${middlewares[i]}'`
+  
+            if (i < middlewares.length - 1) {
+              middlewareString += ','
+            }
           }
         }
-      }
 
-      middlewareString += `])`
+        middlewareString += `])`
+      }
 
       if (apiRoutes?.length) {
         for (const apiRoute of apiRoutes) {
-          await writeOrmActions(apiRoute, model)
+          await writeOrmActions(apiRoute as string, modelName)
 
           if (apiRoute === 'index')
-            routeString += `await route.get('${model.table}', 'Actions/${model.name}IndexOrmAction')${middlewareString}\n\n`
+            routeString += `await route.get('${tableName}', 'Actions/${modelName}IndexOrmAction')${middlewareString}\n\n`
 
           if (apiRoute === 'store')
-            routeString += `await route.post('${model.table}', 'Actions/${model.name}StoreOrmAction')${middlewareString}\n\n`
+            routeString += `await route.post('${tableName}', 'Actions/${modelName}StoreOrmAction')${middlewareString}\n\n`
 
           if (apiRoute === 'update')
-            routeString += `await route.patch('${model.table}/{id}', 'Actions/${model.name}UpdateOrmAction')${middlewareString}\n\n`
+            routeString += `await route.patch('${tableName}/{id}', 'Actions/${modelName}UpdateOrmAction')${middlewareString}\n\n`
 
           if (apiRoute === 'show')
-            routeString += `await route.get('${model.table}/{id}', 'Actions/${model.name}ShowOrmAction')${middlewareString}\n\n`
+            routeString += `await route.get('${tableName}/{id}', 'Actions/${modelName}ShowOrmAction')${middlewareString}\n\n`
 
           if (apiRoute === 'destroy')
-            routeString += `await route.delete('${model.table}/{id}', 'Actions/${model.name}DestroyOrmAction')${middlewareString}\n\n`
+            routeString += `await route.delete('${tableName}/{id}', 'Actions/${modelName}DestroyOrmAction')${middlewareString}\n\n`
         }
       }
     }
@@ -85,10 +87,11 @@ async function writeModelNames() {
     const modeFileElement = modelFiles[i] as string
 
     const model = (await import(modeFileElement)).default as Model
+    const modelName = getModelName(model, modeFileElement)
 
     const typeFile = Bun.file(path.projectStoragePath(`framework/core/types/src/model-names.ts`))
 
-    fileString += `'${model.name}'`
+    fileString += `'${modelName}'`
 
     if (i < modelFiles.length - 1) {
       fileString += ' | '
@@ -100,18 +103,74 @@ async function writeModelNames() {
   }
 }
 
-async function writeOrmActions(apiRoute: string, model: Model): Promise<void> {
-  const modelName = model.name
+async function writeModelRequests() {
+  const modelFiles = glob.sync(path.userModelsPath('*.ts'))
+
+  for (let i = 0; i < modelFiles.length; i++) {
+    let fieldString = ``
+    let fieldStringInt = ``
+    let fileString = `import { Request } from '@stacksjs/router'\nimport { validateField } from '@stacksjs/validation'\nimport type { RequestInstance } from '@stacksjs/types'\n\n`
+
+    const modeFileElement = modelFiles[i] as string
+
+    const model = (await import(modeFileElement)).default as Model
+    const modelName = getModelName(model, modeFileElement)
+
+    const attributes = await extractFields(model, modeFileElement)
+  
+    for (const attribute of attributes) {
+      let defaultValue: any = `''`
+      const entity = attribute.fieldArray?.entity === 'enum' ? 'string' : attribute.fieldArray?.entity
+
+      if (attribute.fieldArray?.entity === 'boolean')
+        defaultValue = false
+
+      if (attribute.fieldArray?.entity === 'number')
+        defaultValue = 0
+
+      fieldString += ` ${attribute.field}: ${entity}\n     `
+
+      fieldStringInt += `public ${attribute.field} = ${defaultValue}\n`
+    } 
+
+    const modelLowerCase = camelCase(modelName)
+
+    const requestFile = Bun.file(path.projectStoragePath(`framework/requests/${modelName}Request.ts`))
+
+    fileString += `export interface ${modelName}RequestType extends RequestInstance{
+      validate(): void
+      ${fieldString}
+    }\n\n`
+    
+    fileString += `export class ${modelName}Request extends Request implements ${modelName}RequestType  {
+      ${fieldStringInt}
+      public validate(): void {
+        validateField('${modelName}', this.all())
+      }
+    }
+    
+    export const ${modelLowerCase}Request = new ${modelName}Request()
+    `
+
+    const writer = requestFile.writer()
+
+    writer.write(fileString)
+  }
+}
+
+async function writeOrmActions(apiRoute: string, modelName: String): Promise<void> {
   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/models/${modelName}'\n\n`
-  actionString += `import { request } from '@stacksjs/router'\n\n`
+  actionString += `import ${modelName} from '../src/models/${modelName}'\n`
 
   let handleString = ``
 
+
+  actionString += ` import type { ${modelName}RequestType } from '../../requests/${modelName}Request'\n\n`
+
   if (apiRoute === 'index') {
-    handleString += `async handle() {
+    handleString += `async handle(request: ${modelName}RequestType) {
         return await ${modelName}.all()
       },`
 
@@ -119,7 +178,7 @@ async function writeOrmActions(apiRoute: string, model: Model): Promise<void> {
   }
 
   if (apiRoute === 'show') {
-    handleString += `async handle() {
+    handleString += `async handle(request: ${modelName}RequestType) {
         const id = await request.getParam('id')
 
         return ${modelName}.findOrFail(Number(id))
@@ -129,7 +188,7 @@ async function writeOrmActions(apiRoute: string, model: Model): Promise<void> {
   }
 
   if (apiRoute === 'destroy') {
-    handleString += `async handle() {
+    handleString += `async handle(request: ${modelName}RequestType) {
         const id = request.getParam('id')
 
         const model = await ${modelName}.findOrFail(Number(id))
@@ -143,7 +202,7 @@ async function writeOrmActions(apiRoute: string, model: Model): Promise<void> {
   }
 
   if (apiRoute === 'store') {
-    handleString += `async handle() {
+    handleString += `async handle(request: ${modelName}RequestType) {
         const model = await ${modelName}.create(request.all())
 
         return model
@@ -153,7 +212,7 @@ async function writeOrmActions(apiRoute: string, model: Model): Promise<void> {
   }
 
   if (apiRoute === 'update') {
-    handleString += `async handle() {
+    handleString += `async handle(request: ${modelName}RequestType) {
         const id = request.getParam('id')
 
         const model = await ${modelName}.findOrFail(Number(id))
@@ -179,32 +238,14 @@ async function writeOrmActions(apiRoute: string, model: Model): Promise<void> {
   writer.write(actionString)
 }
 
-async function writeApiRoutes(apiRoute: string, model: Model): Promise<string> {
-  let routeString = ``
-  const tableName = await modelTableName(model)
-  const modelName = model.name
-
-  if (apiRoute === 'index') routeString += `await route.get('${tableName}', 'Actions/${modelName}IndexOrmAction')\n\n`
-
-  if (apiRoute === 'store') routeString += `await route.post('${tableName}', 'Actions/${modelName}StoreOrmAction')\n\n`
-
-  if (apiRoute === 'update')
-    routeString += `await route.patch('${tableName}/{id}', 'Actions/${modelName}UpdateOrmAction')\n\n`
-
-  if (apiRoute === 'show')
-    routeString += `await route.get('${tableName}/{id}', 'Actions/${modelName}ShowOrmAction')\n\n`
-
-  if (apiRoute === 'destroy')
-    routeString += `await route.delete('${tableName}/{id}', 'Actions/${modelName}DestroyOrmAction')\n\n`
-
-  return routeString
-}
-
 async function initiateModelGeneration(): Promise<void> {
   await deleteExistingModels()
   await deleteExistingOrmActions()
   await deleteExistingModelNameTypes()
+  await deleteExistingModelRequests()
+
   await writeModelNames()
+  await writeModelRequests()
 
   const modelFiles = glob.sync(path.userModelsPath('*.ts'))
 
@@ -214,12 +255,12 @@ async function initiateModelGeneration(): Promise<void> {
     log.debug(`Processing model file: ${modelFile}`)
 
     const model = (await import(modelFile)).default as Model
-    const tableName = await modelTableName(model)
-    const modelName = path.basename(modelFile, '.ts')
+    const tableName = await getTableName(model, modelFile)
+    const modelName = getModelName(model, modelFile)
 
     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)
+    const classString = await generateModelString(tableName, modelName, model, fields)
 
     const writer = file.writer()
     writer.write(classString)
@@ -227,7 +268,7 @@ async function initiateModelGeneration(): Promise<void> {
   }
 }
 
-async function getRelations(model: Model): Promise<RelationConfig[]> {
+async function getRelations(model: Model, modelName: string): Promise<RelationConfig[]> {
   const relationsArray = ['hasOne', 'belongsTo', 'hasMany', 'belongsToMany', 'hasOneThrough']
 
   const relationships = []
@@ -245,7 +286,7 @@ async function getRelations(model: Model): Promise<RelationConfig[]> {
 
         const modelRelation = (await import(modelRelationPath)).default as Model
 
-        const formattedModelName = model.name?.toLowerCase()
+        const formattedModelName = modelName.toLowerCase()
 
         relationships.push({
           relationship: relation,
@@ -297,14 +338,22 @@ async function deleteExistingModelNameTypes() {
   if (fs.existsSync(typeFile)) await Bun.$`rm ${typeFile}`
 }
 
+async function deleteExistingModelRequests() {
+  const requestFiles = glob.sync(path.projectStoragePath(`framework/requests/*.ts`))
+
+  for (const requestFile of requestFiles) {
+    if (fs.existsSync(requestFile)) await Bun.$`rm ${requestFile}`
+  }
+}
+
 async function setKyselyTypes() {
   let text = ``
   const modelFiles = glob.sync(path.userModelsPath('*.ts'))
 
   for (const modelFile of modelFiles) {
     const model = (await import(modelFile)).default as Model
-    const tableName = await modelTableName(model)
-    const modelName = model.name
+    const tableName = await getTableName(model, modelFile)
+    const modelName = getModelName(model, modelFile)
 
     const words = tableName.split('_')
 
@@ -318,8 +367,9 @@ async function setKyselyTypes() {
   let pivotFormatted = ''
   for (const modelFile of modelFiles) {
     const model = (await import(modelFile)).default as Model
-    const pivotTables = await getPivotTables(model)
-
+    const modelName = getModelName(model, modelFile)
+    const pivotTables = await getPivotTables(model, modelName)
+    
     for (const pivotTable of pivotTables) {
       const words = pivotTable.table.split('_')
 
@@ -337,8 +387,9 @@ async function setKyselyTypes() {
 
   for (const modelFile of modelFiles) {
     const model = (await import(modelFile)).default as Model
-    const tableName = await modelTableName(model)
-    const pivotTables = await getPivotTables(model)
+    const modelName = getModelName(model, modelFile)
+    const tableName = await getTableName(model, modelFile)
+    const pivotTables = await getPivotTables(model, modelName)
 
     for (const pivotTable of pivotTables) text += `  ${pivotTable.table}: ${pivotFormatted}\n`
 
@@ -453,6 +504,7 @@ function getRelationCount(relation: string): string {
 
 async function getPivotTables(
   model: Model,
+  modelName: string
 ): Promise<{ table: string; firstForeignKey?: string; secondForeignKey?: string }[]> {
   const pivotTable = []
 
@@ -461,10 +513,10 @@ async function getPivotTables(
     for (const belongsToManyRelation of belongsToManyArr) {
       const modelRelationPath = path.userModelsPath(`${belongsToManyRelation}.ts`)
       const modelRelation = (await import(modelRelationPath)).default as Model
-      const formattedModelName = model?.name?.toLowerCase()
+      const formattedModelName = modelName.toLowerCase()
 
       const firstForeignKey =
-        belongsToManyRelation.firstForeignKey || `${model.name?.toLowerCase()}_${model.primaryKey}`
+        belongsToManyRelation.firstForeignKey || `${modelName.toLowerCase()}_${model.primaryKey}`
       const secondForeignKey =
         belongsToManyRelation.secondForeignKey || `${modelRelation.name?.toLowerCase()}_${model.primaryKey}`
 
@@ -481,21 +533,23 @@ async function getPivotTables(
   return []
 }
 
-export async function fetchOtherModelRelations(model: Model): Promise<RelationConfig[]> {
+export async function fetchOtherModelRelations(model: Model, modelName: string): Promise<RelationConfig[]> {
   const modelFiles = glob.sync(path.userModelsPath('*.ts'))
   const modelRelations = []
 
   for (let i = 0; i < modelFiles.length; i++) {
     const modelFileElement = modelFiles[i] as string
     const modelFile = await import(modelFileElement)
+      
+    if (modelName === modelFile.default.name) continue
 
-    if (model.name === modelFile.default.name) continue
+    const otherModelName = getModelName(modelFile, modelFileElement)
 
-    const relations = await getRelations(modelFile.default)
+    const relations = await getRelations(modelFile.default, otherModelName)
 
     if (!relations.length) continue
 
-    const relation = relations.find((relation) => relation.model === model.name)
+    const relation = relations.find((relation) => relation.model === modelName)
 
     if (relation) modelRelations.push(relation)
   }
@@ -503,16 +557,15 @@ export async function fetchOtherModelRelations(model: Model): Promise<RelationCo
   return modelRelations
 }
 
-async function generateModelString(tableName: string, model: Model, attributes: ModelElement[]): Promise<string> {
-  const modelName = model.name
+async function generateModelString(tableName: string, modelName: string, model: Model, attributes: ModelElement[]): Promise<string> {
   const formattedTableName = pascalCase(tableName) // users -> Users
-  const formattedModelName = modelName?.toLowerCase() // User -> user
+  const formattedModelName = modelName.toLowerCase() // User -> user
 
   let fieldString = ''
   let relationMethods = ``
   let relationImports = ``
 
-  const relations = await getRelations(model)
+  const relations = await getRelations(model, modelName)
 
   for (const relationInstance of relations) {
     relationImports += `import ${relationInstance.model} from './${relationInstance.model}'\n\n`
@@ -636,7 +689,7 @@ async function generateModelString(tableName: string, model: Model, attributes:
 
   for (const attribute of attributes) fieldString += ` ${attribute.field}: ${attribute.fieldArray?.entity}\n     `
 
-  const otherModelRelations = await fetchOtherModelRelations(model)
+  const otherModelRelations = await fetchOtherModelRelations(model, modelName)
 
   for (const otherModelRelation of otherModelRelations) fieldString += ` ${otherModelRelation.foreignKey}: number \n`
 
@@ -808,7 +861,20 @@ async function generateModelString(tableName: string, model: Model, attributes:
         return new ${modelName}Model(model)
       }
 
-      async where(column: string, operator = '=', value: any): Promise<${modelName}Type[]> {
+      async where(...args: (string | number)[]): Promise<${modelName}Type[]> {
+        let column: any
+        let operator: any
+        let value: any
+
+        if (args.length === 2) {
+          [column, value] = args
+          operator = '='
+        } else if (args.length === 3) {
+            [column, operator, value] = args
+        } else {
+            throw new Error("Invalid number of arguments")
+        }
+
         let query = db.selectFrom('${tableName}')
 
         query = query.where(column, operator, value)
@@ -861,6 +927,7 @@ async function generateModelString(tableName: string, model: Model, attributes:
       }
 
       async whereIn(column: keyof ${modelName}Type, values: any[], options: QueryOptions = {}): Promise<${modelName}Type[]> {
+
         let query = db.selectFrom('${tableName}')
 
         query = query.where(column, 'in', values)
@@ -1142,7 +1209,20 @@ async function generateModelString(tableName: string, model: Model, attributes:
         .executeTakeFirst()
     }
 
-    export async function where(column: string, operator = '=', value: any) {
+    export async function where(...args: (string | number)[]) {
+      let column: any
+      let operator: any
+      let value: any
+
+      if (args.length === 2) {
+        [column, value] = args
+        operator = '='
+      } else if (args.length === 3) {
+          [column, operator, value] = args
+      } else {
+          throw new Error("Invalid number of arguments")
+      }
+
       let query = db.selectFrom('${tableName}')
 
       query = query.where(column, operator, value)