@stacksjs/actions 0.62.0 → 0.63.0

package/src/orm/generate-model.ts

@@ -2,9 +2,10 @@ import { log } from '@stacksjs/logging'
 import { getModelName, getTableName } from '@stacksjs/orm'
 import { path } from '@stacksjs/path'
 import { fs, glob } from '@stacksjs/storage'
-import { camelCase, pascalCase, plural, singular } from '@stacksjs/strings'
+import { camelCase, pascalCase, plural, singular, snakeCase } from '@stacksjs/strings'
 import type { Attributes, Model, RelationConfig } from '@stacksjs/types'
 import { isString } from '@stacksjs/validation'
+
 export interface FieldArrayElement {
   entity: string
   charValue?: string | null
@@ -22,7 +23,7 @@ await initiateModelGeneration()
 await setKyselyTypes()
 
 async function generateApiRoutes(modelFiles: string[]) {
-  const file = Bun.file(path.projectStoragePath(`framework/orm/routes.ts`))
+  const file = Bun.file(path.frameworkPath(`orm/routes.ts`))
   const writer = file.writer()
   let routeString = `import { route } from '@stacksjs/router'\n\n\n`
 
@@ -36,6 +37,8 @@ async function generateApiRoutes(modelFiles: string[]) {
     if (model.traits?.useApi) {
       const apiRoutes = model.traits?.useApi?.routes
       const middlewares = model.traits.useApi?.middleware
+      const uri = model.traits.useApi?.uri || tableName
+
       if (middlewares) {
         middlewareString = `.middleware([`
         if (middlewares.length) {
@@ -51,24 +54,37 @@ async function generateApiRoutes(modelFiles: string[]) {
         middlewareString += `])`
       }
 
-      if (apiRoutes?.length) {
-        for (const apiRoute of apiRoutes) {
-          await writeOrmActions(apiRoute as string, modelName)
+      if (Object.keys(model.traits.useApi.routes).length > 0) {
+        if (apiRoutes) {
+          for (const apiRoute in apiRoutes) {
+            // if (Object.prototype.hasOwnProperty.call(apiRoutes, route)) {
+            //   console.log(`Route: ${route}, Path: ${apiRoutes[route]}`);
+            // }
+
+            let path: string | null = ''
+
+            await writeOrmActions(apiRoute as string, modelName)
 
-          if (apiRoute === 'index')
-            routeString += `await route.get('${tableName}', 'Actions/${modelName}IndexOrmAction')${middlewareString}\n\n`
+            path = `${apiRoutes[apiRoute]}.ts`
 
-          if (apiRoute === 'store')
-            routeString += `await route.post('${tableName}', 'Actions/${modelName}StoreOrmAction')${middlewareString}\n\n`
+            if (!path.includes('/')) {
+              path = await lookupFile(path)
+            }
+
+            if (!path) {
+              throw { message: 'Action Not Found!' }
+            }
 
-          if (apiRoute === 'update')
-            routeString += `await route.patch('${tableName}/{id}', 'Actions/${modelName}UpdateOrmAction')${middlewareString}\n\n`
+            if (apiRoute === 'index') routeString += `await route.get('${uri}', '${path}')\n\n`
 
-          if (apiRoute === 'show')
-            routeString += `await route.get('${tableName}/{id}', 'Actions/${modelName}ShowOrmAction')${middlewareString}\n\n`
+            if (apiRoute === 'show') routeString += `await route.get('${uri}/{id}', '${path}')\n\n`
 
-          if (apiRoute === 'destroy')
-            routeString += `await route.delete('${tableName}/{id}', 'Actions/${modelName}DestroyOrmAction')${middlewareString}\n\n`
+            if (apiRoute === 'store') routeString += `await route.post('${uri}', '${path}')\n\n`
+
+            if (apiRoute === 'update') routeString += `await route.patch('${uri}/{id}', '${path}')\n\n`
+
+            if (apiRoute === 'destroy') routeString += `await route.delete('${uri}/{id}', '${path}')\n\n`
+          }
         }
       }
     }
@@ -78,18 +94,36 @@ async function generateApiRoutes(modelFiles: string[]) {
   await writer.end()
 }
 
+async function lookupFile(fileName: string): Promise<string | null> {
+  const ormDirectory = path.builtUserActionsPath('src')
+  const filePath = path.join(ormDirectory, fileName)
+  const pathExists = await fs.existsSync(filePath)
+
+  // Check if the directory exists
+  if (pathExists) {
+    return filePath
+  }
+
+  const actionDirectory = path.userActionsPath()
+  const actionFilePath = path.join(actionDirectory, fileName)
+  const fileExists = await fs.existsSync(actionFilePath)
+
+  if (fileExists) {
+    return actionFilePath
+  }
+
+  return null
+}
+
 async function writeModelNames() {
   const modelFiles = glob.sync(path.userModelsPath('*.ts'))
-
   let fileString = `export type ModelNames = `
 
   for (let i = 0; i < modelFiles.length; i++) {
     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`))
+    const typeFile = Bun.file(path.corePath(`types/src/model-names.ts`))
 
     fileString += `'${modelName}'`
 
@@ -105,8 +139,8 @@ async function writeModelNames() {
 
 async function writeModelRequest() {
   const modelFiles = glob.sync(path.userModelsPath('*.ts'))
-
   const requestD = Bun.file(path.frameworkPath('types/requests.d.ts'))
+
   let importTypes = ``
   let importTypesString = ``
   let typeString = `import { Request } from '../core/router/src/request'\n\n`
@@ -132,10 +166,10 @@ async function writeModelRequest() {
     let fileString = `import { Request } from '@stacksjs/router'\nimport type { VineType } from '@stacksjs/types'\nimport { validateField } from '@stacksjs/validation'\nimport { customValidate } from '@stacksjs/validation'\n\n`
 
     const modeFileElement = modelFiles[i] as string
-
     const model = (await import(modeFileElement)).default as Model
     const modelName = getModelName(model, modeFileElement)
-
+    const useTimestamps = model?.traits?.useTimestamps ?? model?.traits?.timestampable ?? true
+    const useSoftDeletes = model?.traits?.useSoftDeletes ?? model?.traits?.softDeletable ?? false
     const attributes = await extractFields(model, modeFileElement)
 
     fieldString += ` id?: number\n`
@@ -147,20 +181,18 @@ async function writeModelRequest() {
     const otherModelRelations = await fetchOtherModelRelations(model, modelName)
 
     for (const attribute of attributes) {
-      let defaultValue: any = `''`
       const entity = attribute.fieldArray?.entity === 'enum' ? 'string[]' : attribute.fieldArray?.entity
+      let defaultValue: any = `''`
 
       if (attribute.fieldArray?.entity === 'boolean') defaultValue = false
-
       if (attribute.fieldArray?.entity === 'number') defaultValue = 0
 
       fieldString += ` ${attribute.field}: ${entity}\n     `
-
       fieldStringType += `'${attribute.field}'`
+
       if (keyCounter < attributes.length - 1) fieldStringType += ' |'
 
       fieldStringInt += `public ${attribute.field} = ${defaultValue}\n`
-
       keyCounter++
     }
 
@@ -175,14 +207,20 @@ async function writeModelRequest() {
       //   fieldStringType += ' |'
 
       fieldStringInt += `public ${otherModel.foreignKey} = 0\n`
-
       keyCounterForeign++
     }
 
-    fieldStringInt += `public created_at = ''
-      public updated_at = ''
-      public deleted_at = ''
+    if (useTimestamps) {
+      fieldStringInt += `public created_at = ''
+        public updated_at = ''
       `
+    }
+
+    if (useSoftDeletes) {
+      fieldStringInt += `
+        public deleted_at = ''
+      `
+    }
 
     fieldString += `created_at?: string
       updated_at?: string
@@ -190,7 +228,7 @@ async function writeModelRequest() {
 
     const modelLowerCase = camelCase(modelName)
 
-    const requestFile = Bun.file(path.projectStoragePath(`framework/requests/${modelName}Request.ts`))
+    const requestFile = Bun.file(path.frameworkPath(`requests/${modelName}Request.ts`))
 
     importTypes = `${modelName}RequestType`
     importTypesString += `${importTypes}`
@@ -233,11 +271,11 @@ async function writeModelRequest() {
         } else {
           await customValidate(attributes, this.all())
         }
-     
+
       }
     }
-    
-    export const ${modelLowerCase}Request = new ${modelName}Request()
+
+    export const request = new ${modelName}Request()
     `
 
     const writer = requestFile.writer()
@@ -274,7 +312,7 @@ async function writeOrmActions(apiRoute: string, modelName: String): Promise<voi
     handleString += `async handle(request: ${modelName}RequestType) {
         const id = await request.getParam('id')
 
-        return ${modelName}.findOrFail(Number(id))
+        return await ${modelName}.findOrFail(Number(id))
       },`
 
     method = 'GET'
@@ -308,7 +346,7 @@ async function writeOrmActions(apiRoute: string, modelName: String): Promise<voi
   if (apiRoute === 'update') {
     handleString += `async handle(request: ${modelName}RequestType) {
         await request.validate()
-        
+
         const id = request.getParam('id')
 
         const model = await ${modelName}.findOrFail(Number(id))
@@ -327,18 +365,19 @@ async function writeOrmActions(apiRoute: string, modelName: String): Promise<voi
     })
   `
 
-  const file = Bun.file(path.projectStoragePath(`framework/orm/Actions/${modelName}${formattedApiRoute}OrmAction.ts`))
+  const file = Bun.file(path.builtUserActionsPath(`src/${modelName}${formattedApiRoute}OrmAction.ts`))
 
   const writer = file.writer()
 
   writer.write(actionString)
 }
 
-async function initiateModelGeneration(): Promise<void> {
-  await deleteExistingModels()
-  await deleteExistingOrmActions()
+async function initiateModelGeneration(modelStringFile?: string): Promise<void> {
+  await deleteExistingModels(modelStringFile)
+  await deleteExistingOrmActions(modelStringFile)
   await deleteExistingModelNameTypes()
-  await deleteExistingModelRequest()
+  await deleteExistingModelRequest(modelStringFile)
+  await deleteExistingOrmRoute()
 
   await writeModelNames()
   await writeModelRequest()
@@ -348,13 +387,15 @@ async function initiateModelGeneration(): Promise<void> {
   await generateApiRoutes(modelFiles)
 
   for (const modelFile of modelFiles) {
+    if (modelStringFile && modelStringFile !== modelFile) continue
+
     log.debug(`Processing model file: ${modelFile}`)
 
     const model = (await import(modelFile)).default as Model
     const tableName = await getTableName(model, modelFile)
     const modelName = getModelName(model, modelFile)
 
-    const file = Bun.file(path.projectStoragePath(`framework/orm/src/models/${modelName}.ts`))
+    const file = Bun.file(path.frameworkPath(`orm/src/models/${modelName}.ts`))
     const fields = await extractFields(model, modelFile)
     const classString = await generateModelString(tableName, modelName, model, fields)
 
@@ -422,44 +463,74 @@ function hasRelations(obj: any, key: string): boolean {
   return key in obj
 }
 
-async function deleteExistingModels() {
-  const modelPaths = glob.sync(path.projectStoragePath(`framework/orm/src/models/*.ts`))
+async function deleteExistingModels(modelStringFile?: string) {
+  const typePath = path.frameworkPath(`orm/src/types.ts`)
+
+  if (fs.existsSync(typePath)) await Bun.$`rm ${typePath}`
+
+  if (modelStringFile) {
+    const modelPath = path.frameworkPath(`orm/src/models/${modelStringFile}.ts`)
+
+    await Bun.$`rm ${modelPath}`
+
+    return
+  }
+
+  const modelPaths = glob.sync(path.frameworkPath(`orm/src/models/*.ts`))
 
   for (const modelPath of modelPaths) {
     if (fs.existsSync(modelPath)) await Bun.$`rm ${modelPath}`
   }
+}
+
+async function deleteExistingOrmActions(modelStringFile?: string) {
+  const routes = path.frameworkPath(`orm/routes`)
+  if (fs.existsSync(routes)) await Bun.$`rm ${routes}`
 
-  const typePath = path.projectStoragePath(`framework/core/orm/src/generated/types.ts`)
+  if (modelStringFile) {
+    const ormPath = path.builtUserActionsPath(`src/${modelStringFile}.ts`)
 
-  if (fs.existsSync(typePath)) await Bun.$`rm ${typePath}`
-}
+    if (fs.existsSync(ormPath)) await Bun.$`rm ${ormPath}`
+
+    return
+  }
 
-async function deleteExistingOrmActions() {
-  const ormPaths = glob.sync(path.projectStoragePath(`framework/orm/Actions/*.ts`))
-  const routes = path.projectStoragePath(`framework/orm/routes`)
+  const ormPaths = glob.sync(path.builtUserActionsPath(`**/*.ts`))
 
   for (const ormPath of ormPaths) {
     if (fs.existsSync(ormPath)) await Bun.$`rm ${ormPath}`
   }
-
-  if (fs.existsSync(routes)) await Bun.$`rm ${routes}`
 }
 
 async function deleteExistingModelNameTypes() {
-  const typeFile = path.projectStoragePath(`framework/core/types/src/model-names.ts`)
+  const typeFile = path.corePath(`types/src/model-names.ts`)
 
   if (fs.existsSync(typeFile)) await Bun.$`rm ${typeFile}`
 }
 
-async function deleteExistingModelRequest() {
-  const requestFiles = glob.sync(path.projectStoragePath(`framework/requests/*.ts`))
+async function deleteExistingModelRequest(modelStringFile?: string) {
   const requestD = path.frameworkPath('types/requests.d.ts')
+  if (fs.existsSync(requestD)) await Bun.$`rm ${requestD}`
+
+  if (modelStringFile) {
+    const requestFile = path.frameworkPath(`requests/${modelStringFile}.ts`)
+
+    if (fs.existsSync(requestFile)) await Bun.$`rm ${requestFile}`
+
+    return
+  }
+
+  const requestFiles = glob.sync(path.frameworkPath(`requests/*.ts`))
 
   for (const requestFile of requestFiles) {
     if (fs.existsSync(requestFile)) await Bun.$`rm ${requestFile}`
   }
+}
 
-  if (fs.existsSync(requestD)) await Bun.$`rm ${requestD}`
+async function deleteExistingOrmRoute() {
+  const ormRoute = path.projectStoragePath('framework/orm/routes.ts')
+
+  if (fs.existsSync(ormRoute)) await Bun.$`rm ${ormRoute}`
 }
 
 async function setKyselyTypes() {
@@ -518,7 +589,7 @@ async function setKyselyTypes() {
 
   text += `}`
 
-  const file = Bun.file(path.projectStoragePath(`framework/core/orm/src/generated/types.ts`))
+  const file = Bun.file(path.frameworkPath(`orm/src/types.ts`))
 
   const writer = file.writer()
 
@@ -688,11 +759,13 @@ function getHiddenAttributes(attributes: Attributes | undefined): string[] {
 function getFillableAttributes(attributes: Attributes | undefined): string[] {
   if (attributes === undefined) return []
 
-  return Object.keys(attributes).filter((key) => {
-    if (attributes === undefined) return false
+  return Object.keys(attributes)
+    .filter((key) => {
+      if (attributes === undefined) return false
 
-    return attributes[key]?.fillable === true
-  })
+      return attributes[key]?.fillable === true
+    })
+    .map((attribute) => snakeCase(attribute))
 }
 
 async function generateModelString(
@@ -706,12 +779,16 @@ async function generateModelString(
 
   let fieldString = ''
   let constructorFields = ''
+  let jsonFields = '{\n'
   let declareFields = ''
   let whereStatements = ''
   let whereFunctionStatements = ''
   let relationMethods = ``
   let relationImports = ``
   let twoFactorStatements = ''
+  let mittCreateStatement = ``
+  let mittUpdateStatement = ``
+  let mittDeleteStatement = ``
 
   const relations = await getRelations(model, modelName)
 
@@ -719,6 +796,31 @@ async function generateModelString(
     relationImports += `import ${relationInstance.model} from './${relationInstance.model}'\n\n`
   }
 
+  const useTimestamps = model?.traits?.useTimestamps ?? model?.traits?.timestampable ?? true
+  const useSoftDeletes = model?.traits?.useSoftDeletes ?? model?.traits?.softDeletable ?? false
+  const observer = model?.traits?.observe
+
+  if (typeof observer === 'boolean') {
+    if (observer) {
+      mittCreateStatement += `dispatch('${formattedModelName}.created', model)`
+      mittUpdateStatement += `dispatch('${formattedModelName}.updated', model)`
+      mittDeleteStatement += `dispatch('${formattedModelName}.deleted', this)`
+    }
+  }
+
+  if (Array.isArray(observer)) {
+    // Iterate through the array and append statements based on its contents
+    if (observer.includes('create')) {
+      mittCreateStatement += `dispatch('${formattedModelName}.created', model);`
+    }
+    if (observer.includes('update')) {
+      mittUpdateStatement += `dispatch('${formattedModelName}.updated', model);`
+    }
+    if (observer.includes('delete')) {
+      mittDeleteStatement += `dispatch('${formattedModelName}.deleted', model);`
+    }
+  }
+
   for (const relation of relations) {
     const modelRelation = relation.model
     const foreignKeyRelation = relation.foreignKey
@@ -733,7 +835,9 @@ async function generateModelString(
       const relationName = relation.relationName || formattedModelName + modelRelation
       const throughRelation = relation.throughModel
 
-      const formattedThroughRelation = relation.throughModel.toLowerCase()
+      if (relation.throughModel === undefined) continue
+
+      const formattedThroughRelation = relation?.throughModel?.toLowerCase()
       const throughTableRelation = throughRelation
       const foreignKeyThroughRelation = relation.throughForeignKey || `${formattedThroughRelation}_id`
 
@@ -824,9 +928,12 @@ async function generateModelString(
           .where('${foreignKeyRelation}', '=', this.id)
           .selectAll()
           .execute()
-          
+
           const tableRelationIds = results.map(result => result.${singular(tableRelation)}_id)
 
+          if (! tableRelationIds.length)
+            throw new Error('Relation Error!')
+
           const relationResults = await ${modelRelation}.whereIn('id', tableRelationIds).get()
 
           return relationResults
@@ -862,20 +969,22 @@ async function generateModelString(
     `
   }
 
+  jsonFields += `\nid: this.id,\n`
   for (const attribute of attributes) {
     const entity = attribute.fieldArray?.entity === 'enum' ? 'string[]' : attribute.fieldArray?.entity
 
     fieldString += ` ${attribute.field}: ${entity}\n     `
 
-    declareFields += `public ${attribute.field}: ${entity} | undefined \n   `
+    declareFields += `public ${snakeCase(attribute.field)}: ${entity} | undefined \n   `
 
-    constructorFields += `this.${attribute.field} = ${formattedModelName}?.${attribute.field}\n   `
+    constructorFields += `this.${snakeCase(attribute.field)} = ${formattedModelName}?.${snakeCase(attribute.field)}\n   `
+    jsonFields += `${snakeCase(attribute.field)}: this.${snakeCase(attribute.field)},\n   `
 
     whereStatements += `static where${pascalCase(attribute.field)}(value: string | number | boolean | undefined | null): ${modelName}Model {
         const instance = new this(null)
 
         instance.query = instance.query.where('${attribute.field}', '=', value)
-  
+
         return instance
       } \n\n`
 
@@ -888,6 +997,39 @@ async function generateModelString(
       } \n\n`
   }
 
+  if (useTimestamps) {
+    declareFields += `
+      public created_at: Date | undefined
+      public updated_at: Date | undefined
+    `
+
+    constructorFields += `
+      this.created_at = user?.created_at\n
+      this.updated_at = user?.updated_at\n
+    `
+
+    jsonFields += `
+      created_at: this.created_at,\n
+      updated_at: this.updated_at,\n
+    `
+  }
+
+  if (useSoftDeletes) {
+    declareFields += `
+      public deleted_at: Date | undefined
+    `
+
+    constructorFields += `
+      this.deleted_at = user?.deleted_at\n
+    `
+
+    jsonFields += `
+      deleted_at: this.deleted_at,\n
+    `
+  }
+
+  jsonFields += '}'
+
   const otherModelRelations = await fetchOtherModelRelations(model, modelName)
 
   for (const otherModelRelation of otherModelRelations) {
@@ -902,12 +1044,26 @@ async function generateModelString(
     fieldString += `two_factor_secret: string \n`
   }
 
+  if (useTimestamps) {
+    fieldString += `
+      created_at: ColumnType<Date, string | undefined, never>\n
+      updated_at: ColumnType<Date, string | undefined, never>
+    `
+  }
+
+  if (useSoftDeletes) {
+    fieldString += `
+      deleted_at: ColumnType<Date, string | undefined, never>\n
+    `
+  }
+
   const hidden = JSON.stringify(getHiddenAttributes(model.attributes))
   const fillable = JSON.stringify(getFillableAttributes(model.attributes))
 
   return `import type { ColumnType, Generated, Insertable, Selectable, Updateable } from 'kysely'
     import { db } from '@stacksjs/database'
     import { sql } from '@stacksjs/database'
+    import { dispatch } from '@stacksjs/events'
     import { generateTwoFactorSecret } from '@stacksjs/auth'
     import { verifyTwoFactorCode } from '@stacksjs/auth'
     ${relationImports}
@@ -918,9 +1074,6 @@ async function generateModelString(
     export interface ${formattedTableName}Table {
       id: Generated<number>
      ${fieldString}
-      created_at: ColumnType<Date, string | undefined, never>
-      updated_at: ColumnType<Date, string | undefined, never>
-      deleted_at: ColumnType<Date, string | undefined, never>
     }
 
     interface ${modelName}Response {
@@ -950,16 +1103,15 @@ async function generateModelString(
       offset?: number
       page?: number
     }
-  
+
     export class ${modelName}Model {
-      private ${formattedModelName}: Partial<${modelName}Type> | null
       private hidden = ${hidden}
       private fillable = ${fillable}
+      private softDeletes = ${useSoftDeletes}
       protected query: any
       protected hasSelect: boolean
       ${declareFields}
       constructor(${formattedModelName}: Partial<${modelName}Type> | null) {
-        this.${formattedModelName} = ${formattedModelName}
         ${constructorFields}
 
         this.query = db.selectFrom('${tableName}')
@@ -979,8 +1131,8 @@ async function generateModelString(
 
         if (!model)
           return undefined
-        
-        return this.parseResult(this)
+
+        return this.parseResult(new ${modelName}Model(model))
       }
 
       // Method to find a ${modelName} by ID
@@ -988,7 +1140,7 @@ async function generateModelString(
         let query = db.selectFrom('${tableName}').where('id', '=', id)
 
         const instance = new this(null)
-        
+
         if (fields)
           query = query.select(fields)
         else
@@ -1002,18 +1154,34 @@ async function generateModelString(
         return instance.parseResult(new this(model))
       }
 
-      static async findOrFail(id: number, fields?: (keyof ${modelName}Type)[]): Promise<${modelName}Model> {
+      static async all(): Promise<${modelName}Model[]> {
+        let query = db.selectFrom('${tableName}').selectAll()
+
+        const instance = new this(null)
+
+        if (instance.softDeletes) {
+          query = query.where('deleted_at', 'is', null)
+        }
+
+        const results = await query.execute();
+
+        return results.map(modelItem => instance.parseResult(new ${modelName}Model(modelItem)));
+      }
+
+
+      static async findOrFail(id: number): Promise<${modelName}Model> {
         let query = db.selectFrom('${tableName}').where('id', '=', id)
 
         const instance = new this(null)
 
-        if (fields)
-          query = query.select(fields)
-        else
-          query = query.selectAll()
+        if (instance.softDeletes) {
+          query = query.where('deleted_at', 'is', null);
+        }
+
+        query = query.selectAll()
 
         const model = await query.executeTakeFirst()
-       
+
         if (!model)
           throw(\`No model results found for \${id}\ \`)
 
@@ -1021,19 +1189,18 @@ async function generateModelString(
         return instance.parseResult(new this(model))
       }
 
-      static async findMany(ids: number[], fields?: (keyof ${modelName}Type)[]): Promise<${modelName}Model[]> {
+      static async findMany(ids: number[]): Promise<${modelName}Model[]> {
         let query = db.selectFrom('${tableName}').where('id', 'in', ids)
 
         const instance = new this(null)
-         
-        if (fields)
-          query = query.select(fields)
-        else
-          query = query.selectAll()
 
-        const model = await query.execute()
+        if (instance.softDeletes) {
+          query = query.where('deleted_at', 'is', null);
+        }
 
-        instance.parseResult(new ${modelName}Model(modelItem))
+        query = query.selectAll()
+
+        const model = await query.execute()
 
         return model.map(modelItem => instance.parseResult(new ${modelName}Model(modelItem)))
       }
@@ -1042,6 +1209,8 @@ async function generateModelString(
       static async fetch(criteria: Partial<${modelName}Type>, options: QueryOptions = {}): Promise<${modelName}Model[]> {
         let query = db.selectFrom('${tableName}')
 
+         const instance = new this(null)
+
         // Apply sorting from options
         if (options.sort)
           query = query.orderBy(options.sort.column, options.sort.order)
@@ -1053,35 +1222,59 @@ async function generateModelString(
         if (options.offset !== undefined)
           query = query.offset(options.offset)
 
+        if (instance.softDeletes) {
+          query = query.where('deleted_at', 'is', null);
+        }
+
         const model = await query.selectAll().execute()
         return model.map(modelItem => new ${modelName}Model(modelItem))
       }
 
       // Method to get a ${modelName} by criteria
       static async get(): Promise<${modelName}Model[]> {
-        const query = db.selectFrom('${tableName}')
+        let query = db.selectFrom('${tableName}');
 
-        const model = await query.selectAll().execute()
+        const instance = new this(null)
 
-        return model.map(modelItem => new ${modelName}Model(modelItem))
+        // Check if soft deletes are enabled
+        if (instance.softDeletes) {
+          query = query.where('deleted_at', 'is', null);
+        }
+
+        const model = await query.selectAll().execute();
+
+        return model.map(modelItem => new ${modelName}Model(modelItem));
       }
 
       // Method to get a ${modelName} by criteria
       async get(): Promise<${modelName}Model[]> {
         if (this.hasSelect) {
+
+          if (this.softDeletes) {
+            this.query = this.query.where('deleted_at', 'is', null);
+          }
+
           const model = await this.query.execute()
-    
+
           return model.map((modelItem: ${modelName}Model) => new ${modelName}Model(modelItem))
         }
-    
+
+        if (this.softDeletes) {
+          this.query = this.query.where('deleted_at', 'is', null);
+        }
+
         const model = await this.query.selectAll().execute()
-    
+
         return model.map((modelItem: ${modelName}Model) => new ${modelName}Model(modelItem))
       }
 
       static async count(): Promise<number> {
         const instance = new this(null)
 
+        if (instance.softDeletes) {
+          instance.query = instance.query.where('deleted_at', 'is', null);
+        }
+
         const results = await instance.query.selectAll().execute()
 
         return results.length
@@ -1089,6 +1282,11 @@ async function generateModelString(
 
       async count(): Promise<number> {
         if (this.hasSelect) {
+
+          if (this.softDeletes) {
+            this.query = this.query.where('deleted_at', 'is', null);
+          }
+
           const results = await this.query.execute()
 
           return results.length
@@ -1112,7 +1310,7 @@ async function generateModelString(
           .selectAll()
           .orderBy('id', 'asc') // Assuming 'id' is used for cursor-based pagination
           .limit((options.limit ?? 10) + 1) // Fetch one extra record
-          .offset((options.page - 1) * (options.limit ?? 10))
+          .offset(((options.page ?? 1) - 1) * (options.limit ?? 10)) // Ensure options.page is not undefined
           .execute()
 
         let nextCursor = null
@@ -1148,14 +1346,33 @@ async function generateModelString(
           .values(filteredValues)
           .executeTakeFirstOrThrow()
 
-        return await find(Number(result.insertId)) as ${modelName}Model
+        const model = await find(Number(result.insertId)) as ${modelName}Model
+
+        ${mittCreateStatement}
+
+        return model
       }
 
       // Method to remove a ${modelName}
       static async remove(id: number): Promise<void> {
-        await db.deleteFrom('${tableName}')
+        const instance = new this(null)
+
+        const model = await instance.find(id)
+
+       if (instance.softDeletes) {
+        await db.updateTable('${tableName}')
+          .set({
+            deleted_at: sql.raw('CURRENT_TIMESTAMP')
+          })
           .where('id', '=', id)
-          .execute()
+          .execute();
+        } else {
+          await db.deleteFrom('${tableName}')
+            .where('id', '=', id)
+            .execute();
+        }
+
+        ${mittDeleteStatement}
       }
 
       where(...args: (string | number | boolean | undefined | null)[]): ${modelName}Model {
@@ -1181,9 +1398,9 @@ async function generateModelString(
         let column: any
         let operator: any
         let value: any
-  
+
         const instance = new this(null)
-  
+
         if (args.length === 2) {
           [column, value] = args
           operator = '='
@@ -1192,9 +1409,9 @@ async function generateModelString(
         } else {
             throw new Error("Invalid number of arguments")
         }
-  
+
         instance.query = instance.query.where(column, operator, value)
-  
+
         return instance
       }
 
@@ -1202,9 +1419,9 @@ async function generateModelString(
 
       static whereIn(column: keyof ${modelName}Type, values: any[]): ${modelName}Model {
         const instance = new this(null)
-  
+
         instance.query = instance.query.where(column, 'in', values)
-  
+
         return instance
       }
 
@@ -1214,16 +1431,16 @@ async function generateModelString(
         if (! model) {
           return undefined
         }
-        
-        return new ${modelName}Model(model)
+
+        return this.parseResult(new ${modelName}Model(model))
       }
 
       async exists(): Promise<boolean> {
         const model = await this.query.selectAll().executeTakeFirst()
-        
+
         return model !== null || model !== undefined
       }
-  
+
       static async first(): Promise<${modelName}Type | undefined> {
         return await db.selectFrom('${tableName}')
           .selectAll()
@@ -1239,29 +1456,29 @@ async function generateModelString(
 
       static orderBy(column: keyof ${modelName}Type, order: 'asc' | 'desc'): ${modelName}Model {
         const instance = new this(null)
-  
+
         instance.query = instance.orderBy(column, order)
-  
+
         return instance
       }
-  
+
       orderBy(column: keyof ${modelName}Type, order: 'asc' | 'desc'): ${modelName}Model {
         this.query = this.query.orderBy(column, order)
-  
+
         return this
       }
 
       static orderByDesc(column: keyof ${modelName}Type): ${modelName}Model {
         const instance = new this(null)
-  
+
         instance.query = instance.query.orderBy(column, 'desc')
-  
+
         return instance
       }
-  
+
       orderByDesc(column: keyof ${modelName}Type): ${modelName}Model {
         this.query = this.orderBy(column, 'desc')
-  
+
         return this
       }
 
@@ -1280,23 +1497,27 @@ async function generateModelString(
       }
 
       // Method to update the ${tableName} instance
-      async update(${formattedModelName}: ${modelName}Update): Promise<${modelName}Model | null> {
+      async update(${formattedModelName}: ${modelName}Update): Promise<${modelName}Model | undefined> {
         if (this.id === undefined)
           throw new Error('${modelName} ID is undefined')
 
-        const filteredValues = Object.keys(new${modelName})
+        const filteredValues = Object.keys(${formattedModelName})
             .filter(key => this.fillable.includes(key))
             .reduce((obj, key) => {
-                obj[key] = new${modelName}[key];
+                obj[key] = ${formattedModelName}[key]
                 return obj;
             }, {});
-  
+
         await db.updateTable('${tableName}')
           .set(filteredValues)
           .where('id', '=', this.id)
           .executeTakeFirst()
-  
-          return await this.find(Number(this.id))
+
+        const model = this.find(Number(this.id))
+
+        ${mittUpdateStatement}
+
+        return model
       }
 
       // Method to save (insert or update) the ${formattedModelName} instance
@@ -1316,43 +1537,57 @@ async function generateModelString(
         }
       }
 
-      // Method to delete the ${formattedModelName} instance
+      // Method to delete (soft delete) the ${formattedModelName} instance
       async delete(): Promise<void> {
-        if (this.id === undefined)
-          throw new Error('${modelName} ID is undefined')
-        
-        await db.deleteFrom('${tableName}')
-          .where('id', '=', this.id)
-          .execute()
+          if (this.id === undefined)
+              throw new Error('${modelName} ID is undefined');
+
+          // Check if soft deletes are enabled
+          if (this.softDeletes) {
+              // Update the deleted_at column with the current timestamp
+              await db.updateTable('${tableName}')
+                  .set({
+                      deleted_at: sql.raw('CURRENT_TIMESTAMP')
+                  })
+                  .where('id', '=', this.id)
+                  .execute();
+          } else {
+              // Perform a hard delete
+              await db.deleteFrom('${tableName}')
+                .where('id', '=', this.id)
+                .execute();
+          }
+
+          ${mittDeleteStatement}
       }
 
       ${relationMethods}
 
       distinct(column: keyof ${modelName}Type): ${modelName}Model {
         this.query = this.query.distinctOn(column)
-    
+
         return this
       }
-    
+
       static distinct(column: keyof ${modelName}Type): ${modelName}Model {
         const instance = new this(null)
-    
+
         instance.query = instance.query.distinctOn(column)
-    
+
         return instance
       }
-    
+
       join(table: string, firstCol: string, secondCol: string): ${modelName}Model {
         this.query = this.query.innerJoin(table, firstCol, secondCol)
-    
+
         return this
       }
-    
+
       static join(table: string, firstCol: string, secondCol: string): ${modelName}Model {
         const instance = new this(null)
-    
+
         instance.query = instance.query.innerJoin(table, firstCol, secondCol)
-    
+
         return instance
       }
 
@@ -1361,7 +1596,7 @@ async function generateModelString(
       }
 
       toJSON() {
-        const output: Partial<${modelName}Type> = { ...this.${formattedModelName} }
+        const output: Partial<${modelName}Type> = ${jsonFields}
 
         this.hidden.forEach((attr) => {
           if (attr in output)
@@ -1373,10 +1608,15 @@ async function generateModelString(
         return output as ${modelName}
       }
 
-      parseResult(model: any): ${modelName}Model {
+      parseResult(model: ${modelName}Model): ${modelName}Model {
+        delete model['query']
+        delete model['fillable']
+        delete model['two_factor_secret']
+        delete model['hasSelect']
+        delete model['softDeletes']
+
         for (const hiddenAttribute of this.hidden) {
           delete model[hiddenAttribute]
-           delete model.${formattedModelName}[hiddenAttribute]
         }
 
         return model
@@ -1385,7 +1625,7 @@ async function generateModelString(
       ${twoFactorStatements}
     }
 
-    async function find(id: number, fields?: (keyof ${modelName}Type)[]): Promise<${modelName}Model | null> {
+    async function find(id: number): Promise<${modelName}Model | null> {
       let query = db.selectFrom('${tableName}').where('id', '=', id)
 
       if (fields) query = query.select(fields)
@@ -1421,7 +1661,7 @@ async function generateModelString(
         .where('id', '=', id)
         .execute()
     }
-    
+
     ${whereFunctionStatements}
 
     const ${modelName} = ${modelName}Model