@stacksjs/actions 0.61.24 → 0.63.0

package/src/orm/generate-model.ts

@@ -1,10 +1,11 @@
 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 } from '@stacksjs/strings'
-import type { Model, RelationConfig } from '@stacksjs/types'
-import { isString, isBoolean } from '@stacksjs/validation'
-import { getModelName, getTableName} from '@stacksjs/orm'
+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,12 +37,14 @@ 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) {
           for (let i = 0; i < middlewares.length; i++) {
             middlewareString += `'${middlewares[i]}'`
-  
+
             if (i < middlewares.length - 1) {
               middlewareString += ','
             }
@@ -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 = ''
 
-          if (apiRoute === 'index')
-            routeString += `await route.get('${tableName}', 'Actions/${modelName}IndexOrmAction')${middlewareString}\n\n`
+            await writeOrmActions(apiRoute as string, modelName)
 
-          if (apiRoute === 'store')
-            routeString += `await route.post('${tableName}', 'Actions/${modelName}StoreOrmAction')${middlewareString}\n\n`
+            path = `${apiRoutes[apiRoute]}.ts`
 
-          if (apiRoute === 'update')
-            routeString += `await route.patch('${tableName}/{id}', 'Actions/${modelName}UpdateOrmAction')${middlewareString}\n\n`
+            if (!path.includes('/')) {
+              path = await lookupFile(path)
+            }
+
+            if (!path) {
+              throw { message: 'Action Not Found!' }
+            }
 
-          if (apiRoute === 'show')
-            routeString += `await route.get('${tableName}/{id}', 'Actions/${modelName}ShowOrmAction')${middlewareString}\n\n`
+            if (apiRoute === 'index') routeString += `await route.get('${uri}', '${path}')\n\n`
 
-          if (apiRoute === 'destroy')
-            routeString += `await route.delete('${tableName}/{id}', 'Actions/${modelName}DestroyOrmAction')${middlewareString}\n\n`
+            if (apiRoute === 'show') routeString += `await route.get('${uri}/{id}', '${path}')\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}'`
 
@@ -103,59 +137,157 @@ async function writeModelNames() {
   }
 }
 
-async function writeModelRequests() {
+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`
+
+  typeString += `interface ValidationType {
+    rule: VineType;
+    message: { [key: string]: string };
+  }\n\n`
+
+  typeString += `interface ValidationField {
+    [key: string]: string | ValidationType;
+    validation: ValidationType;
+  }\n\n`
+
+  typeString += `interface CustomAttributes {
+    [key: string]: ValidationField
+  }\n\n`
 
   for (let i = 0; i < modelFiles.length; i++) {
+    let fieldStringType = ``
     let fieldString = ``
     let fieldStringInt = ``
-    let fileString = `import { Request } from '@stacksjs/router'\nimport { validateField } from '@stacksjs/validation'\nimport type { RequestInstance } from '@stacksjs/types'\n\n`
+    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`
+    fieldStringInt += `public id = 1\n`
+    fieldStringType += `'id' |`
+    let keyCounter = 0
+    let keyCounterForeign = 0
+
+    const otherModelRelations = await fetchOtherModelRelations(model, modelName)
+
     for (const attribute of attributes) {
+      const entity = attribute.fieldArray?.entity === 'enum' ? 'string[]' : attribute.fieldArray?.entity
       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
+      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++
+    }
+
+    for (const otherModel of otherModelRelations) {
+      fieldString += ` ${otherModel.foreignKey}: number\n     `
+
+      if (keyCounter >= attributes.length - 1) fieldStringType += ' |'
+
+      fieldStringType += `'${otherModel.foreignKey}'`
+
+      // if (keyCounterForeign < otherModelRelations.length - 1)
+      //   fieldStringType += ' |'
+
+      fieldStringInt += `public ${otherModel.foreignKey} = 0\n`
+      keyCounterForeign++
+    }
+
+    if (useTimestamps) {
+      fieldStringInt += `public created_at = ''
+        public updated_at = ''
+      `
+    }
+
+    if (useSoftDeletes) {
+      fieldStringInt += `
+        public deleted_at = ''
+      `
+    }
+
+    fieldString += `created_at?: string
+      updated_at?: string
+      deleted_at?: string`
 
     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}`
+
+    if (i < modelFiles.length - 1) importTypesString += ` | `
+
+    fileString += `import type { ${importTypes} } from '../types/requests'\n\n`
+
+    fileString += `interface ValidationType {
+      rule: VineType;
+      message: { [key: string]: string };
+    }\n\n`
+
+    fileString += `interface ValidationField {
+      [key: string]: string | ValidationType;
+      validation: ValidationType;
+    }\n\n`
+
+    fileString += `interface CustomAttributes {
+      [key: string]: ValidationField
+    }`
 
-    fileString += `export interface ${modelName}RequestType extends RequestInstance{
-      validate(): void
+    const types = `export interface ${modelName}RequestType extends Request {
+      validate(attributes?: CustomAttributes): void
+      get(key: ${fieldStringType}): string | number | undefined;
       ${fieldString}
     }\n\n`
-    
-    fileString += `export class ${modelName}Request extends Request implements ${modelName}RequestType  {
+
+    typeString += `interface RequestData${modelName} {
+      ${fieldString}
+    }\n`
+
+    typeString += types
+
+    fileString += `export class ${modelName}Request extends Request implements ${modelName}RequestType {
       ${fieldStringInt}
-      public validate(): void {
-        validateField('${modelName}', this.all())
+      public async validate(attributes?: CustomAttributes): Promise<void> {
+        if (attributes === undefined || attributes === null) {
+          await validateField('${modelName}', this.all())
+        } else {
+          await customValidate(attributes, this.all())
+        }
+
       }
     }
-    
-    export const ${modelLowerCase}Request = new ${modelName}Request()
+
+    export const request = new ${modelName}Request()
     `
 
     const writer = requestFile.writer()
 
     writer.write(fileString)
   }
+
+  typeString += `export type ModelRequest = ${importTypesString}`
+
+  const requestWrite = requestD.writer()
+
+  requestWrite.write(typeString)
 }
 
 async function writeOrmActions(apiRoute: string, modelName: String): Promise<void> {
@@ -166,8 +298,7 @@ async function writeOrmActions(apiRoute: string, modelName: String): Promise<voi
 
   let handleString = ``
 
-
-  actionString += ` import type { ${modelName}RequestType } from '../../requests/${modelName}Request'\n\n`
+  actionString += `  import type { ${modelName}RequestType } from '../../types/requests'\n\n`
 
   if (apiRoute === 'index') {
     handleString += `async handle(request: ${modelName}RequestType) {
@@ -181,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'
@@ -203,6 +334,7 @@ async function writeOrmActions(apiRoute: string, modelName: String): Promise<voi
 
   if (apiRoute === 'store') {
     handleString += `async handle(request: ${modelName}RequestType) {
+        await request.validate()
         const model = await ${modelName}.create(request.all())
 
         return model
@@ -213,6 +345,8 @@ 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))
@@ -231,34 +365,37 @@ 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 deleteExistingModelRequests()
+  await deleteExistingModelRequest(modelStringFile)
+  await deleteExistingOrmRoute()
 
   await writeModelNames()
-  await writeModelRequests()
+  await writeModelRequest()
 
   const modelFiles = glob.sync(path.userModelsPath('*.ts'))
 
   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)
 
@@ -296,7 +433,9 @@ async function getRelations(model: Model, modelName: string): Promise<RelationCo
           relationName: relationInstance.relationName || '',
           throughModel: relationInstance.through || '',
           throughForeignKey: relationInstance.throughForeignKey || '',
-          pivotTable: relationInstance?.pivotTable || `${formattedModelName}_${modelRelation.table}`,
+          pivotTable:
+            relationInstance?.pivotTable ||
+            getPivotTableName(plural(formattedModelName), plural(modelRelation.table || '')),
         })
       }
     }
@@ -305,47 +444,95 @@ async function getRelations(model: Model, modelName: string): Promise<RelationCo
   return relationships
 }
 
+function getPivotTableName(formattedModelName: string, modelRelationTable: string): string {
+  // Create an array of the model names
+  const models = [formattedModelName, modelRelationTable]
+
+  // Sort the array alphabetically
+  models.sort()
+
+  models[0] = singular(models[0] || '')
+
+  // Join the sorted array with an underscore
+  const pivotTableName = models.join('_')
+
+  return pivotTableName
+}
+
 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}`
   }
+}
 
-  const typePath = path.projectStoragePath(`framework/core/orm/src/generated/types.ts`)
+async function deleteExistingOrmActions(modelStringFile?: string) {
+  const routes = path.frameworkPath(`orm/routes`)
+  if (fs.existsSync(routes)) await Bun.$`rm ${routes}`
 
-  if (fs.existsSync(typePath)) await Bun.$`rm ${typePath}`
-}
+  if (modelStringFile) {
+    const ormPath = path.builtUserActionsPath(`src/${modelStringFile}.ts`)
 
-async function deleteExistingOrmActions() {
-  const ormPaths = glob.sync(path.projectStoragePath(`framework/orm/Actions/*.ts`))
-  const routes = path.projectStoragePath(`framework/orm/routes`)
+    if (fs.existsSync(ormPath)) await Bun.$`rm ${ormPath}`
+
+    return
+  }
+
+  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 deleteExistingModelRequests() {
-  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}`
   }
 }
 
+async function deleteExistingOrmRoute() {
+  const ormRoute = path.projectStoragePath('framework/orm/routes.ts')
+
+  if (fs.existsSync(ormRoute)) await Bun.$`rm ${ormRoute}`
+}
+
 async function setKyselyTypes() {
   let text = ``
   const modelFiles = glob.sync(path.userModelsPath('*.ts'))
@@ -369,7 +556,7 @@ async function setKyselyTypes() {
     const model = (await import(modelFile)).default as Model
     const modelName = getModelName(model, modelFile)
     const pivotTables = await getPivotTables(model, modelName)
-    
+
     for (const pivotTable of pivotTables) {
       const words = pivotTable.table.split('_')
 
@@ -402,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()
 
@@ -413,7 +600,10 @@ async function setKyselyTypes() {
 
 async function extractFields(model: Model, modelFile: string): Promise<ModelElement[]> {
   // TODO: we can improve this type
-  const fields: Record<string, any> = model.attributes
+  let fields: Record<string, any> | undefined = model.attributes
+
+  if (!fields) fields = {}
+
   const fieldKeys = Object.keys(fields)
 
   const rules: string[] = []
@@ -504,7 +694,7 @@ function getRelationCount(relation: string): string {
 
 async function getPivotTables(
   model: Model,
-  modelName: string
+  modelName: string,
 ): Promise<{ table: string; firstForeignKey?: string; secondForeignKey?: string }[]> {
   const pivotTable = []
 
@@ -515,8 +705,7 @@ async function getPivotTables(
       const modelRelation = (await import(modelRelationPath)).default as Model
       const formattedModelName = modelName.toLowerCase()
 
-      const firstForeignKey =
-        belongsToManyRelation.firstForeignKey || `${modelName.toLowerCase()}_${model.primaryKey}`
+      const firstForeignKey = belongsToManyRelation.firstForeignKey || `${modelName.toLowerCase()}_${model.primaryKey}`
       const secondForeignKey =
         belongsToManyRelation.secondForeignKey || `${modelRelation.name?.toLowerCase()}_${model.primaryKey}`
 
@@ -540,7 +729,7 @@ export async function fetchOtherModelRelations(model: Model, modelName: string):
   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
 
     const otherModelName = getModelName(modelFile, modelFileElement)
@@ -557,13 +746,49 @@ export async function fetchOtherModelRelations(model: Model, modelName: string):
   return modelRelations
 }
 
-async function generateModelString(tableName: string, modelName: string, model: Model, attributes: ModelElement[]): Promise<string> {
+function getHiddenAttributes(attributes: Attributes | undefined): string[] {
+  if (attributes === undefined) return []
+
+  return Object.keys(attributes).filter((key) => {
+    if (attributes === undefined) return false
+
+    return attributes[key]?.hidden === true
+  })
+}
+
+function getFillableAttributes(attributes: Attributes | undefined): string[] {
+  if (attributes === undefined) return []
+
+  return Object.keys(attributes)
+    .filter((key) => {
+      if (attributes === undefined) return false
+
+      return attributes[key]?.fillable === true
+    })
+    .map((attribute) => snakeCase(attribute))
+}
+
+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
 
   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)
 
@@ -571,13 +796,37 @@ async function generateModelString(tableName: string, modelName: string, model:
     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
     const tableRelation = relation.table || ''
     const pivotTableRelation = relation.pivotTable
     const formattedModelRelation = modelRelation.toLowerCase()
-    const capitalizeTableRelation = tableRelation.charAt(0).toUpperCase() + tableRelation.slice(1)
 
     const relationType = getRelationType(relation.relationship)
     const relationCount = getRelationCount(relation.relationship)
@@ -586,27 +835,28 @@ async function generateModelString(tableName: string, modelName: string, model:
       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`
 
       relationMethods += `
       async ${relationName}() {
-        if (this.${formattedModelName}.id === undefined)
+        if (this.id === undefined)
           throw new Error('Relation Error!')
 
         const firstModel = await db.selectFrom('${throughTableRelation}')
-        .where('${foreignKeyRelation}', '=', this.${formattedModelName}.id)
-        .selectAll()
-        .executeTakeFirst()
+          .where('${foreignKeyRelation}', '=', this.id)
+          .selectAll()
+          .executeTakeFirst()
 
         if (! firstModel)
           throw new Error('Model Relation Not Found!')
 
-        const finalModel = await db.selectFrom('${tableRelation}')
-        .where('${foreignKeyThroughRelation}', '=', firstModel.id)
-        .selectAll()
-        .executeTakeFirst()
+        const finalModel = ${modelRelation}
+          .where('${foreignKeyThroughRelation}', '=', firstModel.id)
+          .first()
 
         return new ${modelRelation}.modelInstance(finalModel)
       }\n\n`
@@ -617,11 +867,11 @@ async function generateModelString(tableName: string, modelName: string, model:
 
       relationMethods += `
       async ${relationName}() {
-        if (this.${formattedModelName}.id === undefined)
+        if (this.id === undefined)
           throw new Error('Relation Error!')
 
         const results = await db.selectFrom('${tableRelation}')
-          .where('${foreignKeyRelation}', '=', this.${formattedModelName}.id)
+          .where('${foreignKeyRelation}', '=', this.id)
           .selectAll()
           .execute()
 
@@ -633,18 +883,16 @@ async function generateModelString(tableName: string, modelName: string, model:
       const relationName = relation.relationName || formattedModelRelation
       relationMethods += `
       async ${relationName}() {
-        if (this.${formattedModelName}.id === undefined)
+        if (this.id === undefined)
           throw new Error('Relation Error!')
 
-        const model = await db.selectFrom('${tableRelation}')
-        .where('${foreignKeyRelation}', '=', this.${formattedModelName}.id)
-        .selectAll()
-        .executeTakeFirst()
+        const model = ${modelRelation}
+        .where('${foreignKeyRelation}', '=', this.id).first()
 
         if (! model)
           throw new Error('Model Relation Not Found!')
 
-        return new ${modelRelation}.modelInstance(model)
+        return model
       }\n\n`
     }
 
@@ -656,47 +904,168 @@ async function generateModelString(tableName: string, modelName: string, model:
         if (this.${foreignKeyRelation} === undefined)
           throw new Error('Relation Error!')
 
-        const model = await db.selectFrom('${tableRelation}')
-        .where('id', '=', ${foreignKeyRelation})
-        .selectAll()
-        .executeTakeFirst()
+        const model = await ${modelRelation}
+          .where('id', '=', ${foreignKeyRelation})
+          .first()
 
         if (! model)
           throw new Error('Model Relation Not Found!')
 
-        return new ${modelRelation}.modelInstance(model)
+        return model
       }\n\n`
     }
 
     if (relationType === 'belongsType' && relationCount === 'many') {
       const pivotTable = pivotTableRelation || tableRelation
-      const relationName = relation.relationName || formattedModelName + capitalizeTableRelation
+      const relationName = relation.relationName || formattedModelName + plural(pascalCase(modelRelation))
 
       relationMethods += `
       async ${relationName}() {
-        if (this.${formattedModelName}.id === undefined)
+        if (this.id === undefined)
           throw new Error('Relation Error!')
 
         const results = await db.selectFrom('${pivotTable}')
-          .where('${foreignKeyRelation}', '=', this.${formattedModelName}.id)
+          .where('${foreignKeyRelation}', '=', this.id)
           .selectAll()
           .execute()
 
-          return results
+          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
       }\n\n`
     }
   }
 
-  for (const attribute of attributes) fieldString += ` ${attribute.field}: ${attribute.fieldArray?.entity}\n     `
+  declareFields += `public id: number | undefined \n   `
+
+  constructorFields += `this.id = ${formattedModelName}?.id\n   `
+
+  const useTwoFactor = model.traits?.useAuth?.useTwoFactor
+
+  if (useTwoFactor) {
+    declareFields += `public two_factor_secret: string | undefined \n`
+    constructorFields += `this.two_factor_secret = ${formattedModelName}?.two_factor_secret\n   `
+
+    twoFactorStatements += `
+      async generateTwoFactorForModel() {
+        const secret = generateTwoFactorSecret()
+
+        await this.update({ 'two_factor_secret': secret })
+      }
+
+      verifyTwoFactorCode(code: string): boolean {
+        if (! this.${formattedModelName}) return false
+
+        const modelTwoFactorSecret = this.${formattedModelName}.two_factor_secret
+        const isValid = verifyTwoFactorCode(code, modelTwoFactorSecret)
+
+        return isValid
+      }
+    `
+  }
+
+  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 ${snakeCase(attribute.field)}: ${entity} | undefined \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`
+
+    whereFunctionStatements += `export async function where${pascalCase(attribute.field)}(value: string | number | boolean | undefined | null): Promise<${modelName}Model[]> {
+        const query = db.selectFrom('${tableName}').where('${attribute.field}', '=', value)
+
+        const results = await query.execute()
+
+        return results.map(modelItem => new ${modelName}Model(modelItem))
+      } \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) fieldString += ` ${otherModelRelation.foreignKey}: number \n`
+  for (const otherModelRelation of otherModelRelations) {
+    fieldString += ` ${otherModelRelation.foreignKey}: number \n`
+
+    declareFields += `public ${otherModelRelation.foreignKey}: number | undefined \n   `
+
+    constructorFields += `this.${otherModelRelation.foreignKey} = ${formattedModelName}?.${otherModelRelation.foreignKey}\n   `
+  }
+
+  if (useTwoFactor) {
+    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 type { Result } from '@stacksjs/error-handling'
-    import { err, handleError, ok } from '@stacksjs/error-handling'
     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}
     // import { Kysely, MysqlDialect, PostgresDialect } from 'kysely'
     // import { Pool } from 'pg'
@@ -705,9 +1074,6 @@ async function generateModelString(tableName: string, modelName: string, model:
     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 {
@@ -739,16 +1105,21 @@ async function generateModelString(tableName: string, modelName: string, model:
     }
 
     export class ${modelName}Model {
-      private ${formattedModelName}: Partial<${modelName}Type>
-      private results: Partial<${modelName}Type>[]
-      private hidden = ['password'] // TODO: this hidden functionality needs to be implemented still
-
-      constructor(${formattedModelName}: Partial<${modelName}Type>) {
-        this.${formattedModelName} = ${formattedModelName}
+      private hidden = ${hidden}
+      private fillable = ${fillable}
+      private softDeletes = ${useSoftDeletes}
+      protected query: any
+      protected hasSelect: boolean
+      ${declareFields}
+      constructor(${formattedModelName}: Partial<${modelName}Type> | null) {
+        ${constructorFields}
+
+        this.query = db.selectFrom('${tableName}')
+        this.hasSelect = false
       }
 
-      // Method to find a ${formattedModelName} by ID
-      static async find(id: number, fields?: (keyof ${modelName}Type)[]): Promise<${modelName}Model> {
+      // Method to find a ${modelName} by ID
+      async find(id: number, fields?: (keyof ${modelName}Type)[]): Promise<${modelName}Model | undefined> {
         let query = db.selectFrom('${tableName}').where('id', '=', id)
 
         if (fields)
@@ -759,14 +1130,17 @@ async function generateModelString(tableName: string, modelName: string, model:
         const model = await query.executeTakeFirst()
 
         if (!model)
-          return null
+          return undefined
 
-        return new ${modelName}Model(model)
+        return this.parseResult(new ${modelName}Model(model))
       }
 
-      static async findOrFail(id: number, fields?: (keyof ${modelName}Type)[]): Promise<${modelName}Model> {
+      // Method to find a ${modelName} by ID
+      static async find(id: number, fields?: (keyof ${modelName}Type)[]): Promise<${modelName}Model | undefined> {
         let query = db.selectFrom('${tableName}').where('id', '=', id)
 
+        const instance = new this(null)
+
         if (fields)
           query = query.select(fields)
         else
@@ -774,29 +1148,69 @@ async function generateModelString(tableName: string, modelName: string, model:
 
         const model = await query.executeTakeFirst()
 
+        if (!model)
+          return undefined
+
+        return instance.parseResult(new this(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 (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}\ \`)
 
-        return new ${modelName}Model(model)
+
+        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)
 
-        if (fields)
-          query = query.select(fields)
-        else
-          query = query.selectAll()
+        const instance = new this(null)
+
+        if (instance.softDeletes) {
+          query = query.where('deleted_at', 'is', null);
+        }
+
+        query = query.selectAll()
 
         const model = await query.execute()
 
-        return model.map(modelItem => new ${modelName}Model(modelItem))
+        return model.map(modelItem => instance.parseResult(new ${modelName}Model(modelItem)))
       }
 
-      // Method to get a ${formattedModelName} by criteria
-      static async get(criteria: Partial<${modelName}Type>, options: QueryOptions = {}): Promise<${modelName}Model[]> {
+      // Method to get a ${modelName} by criteria
+      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)
@@ -808,12 +1222,83 @@ async function generateModelString(tableName: string, modelName: string, model:
         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[]> {
+        let query = db.selectFrom('${tableName}');
+
+        const instance = new this(null)
+
+        // 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
+      }
+
+      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
+        }
+
+        const results = await this.query.selectAll().execute()
+
+        return results.length
+      }
+
       // Method to get all ${tableName}
-      static async all(options: QueryOptions = { limit: 10, offset: 0, page: 1 }): Promise<${modelName}Response> {
+      static async paginate(options: QueryOptions = { limit: 10, offset: 0, page: 1 }): Promise<${modelName}Response> {
         const totalRecordsResult = await db.selectFrom('${tableName}')
           .select(db.fn.count('id').as('total')) // Use 'id' or another actual column name
           .executeTakeFirst()
@@ -825,7 +1310,7 @@ async function generateModelString(tableName: string, modelName: string, model:
           .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
@@ -844,24 +1329,53 @@ async function generateModelString(tableName: string, modelName: string, model:
       }
 
       // Method to create a new ${formattedModelName}
-      static async create(new${modelName}: New${modelName}): Promise<${modelName}Model> {
+      static async create(new${modelName}: New${modelName}): Promise<${modelName}Model | undefined> {
+        const instance = new this(null)
+        const filteredValues = Object.keys(new${modelName})
+          .filter(key => instance.fillable.includes(key))
+          .reduce((obj: any, key) => {
+              obj[key] = new${modelName}[key];
+              return obj
+          }, {})
+
+        if (Object.keys(filteredValues).length === 0) {
+          return undefined
+        }
+
         const result = await db.insertInto('${tableName}')
-          .values(new${modelName})
+          .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 ${formattedModelName}
-      static async remove(id: number): Promise<${modelName}Model> {
-        const model = await db.deleteFrom('${tableName}')
+      // Method to remove a ${modelName}
+      static async remove(id: number): Promise<void> {
+        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)
-          .executeTakeFirstOrThrow()
+          .execute();
+        } else {
+          await db.deleteFrom('${tableName}')
+            .where('id', '=', id)
+            .execute();
+        }
 
-        return new ${modelName}Model(model)
+        ${mittDeleteStatement}
       }
 
-      async where(...args: (string | number)[]): Promise<${modelName}Type[]> {
+      where(...args: (string | number | boolean | undefined | null)[]): ${modelName}Model {
         let column: any
         let operator: any
         let value: any
@@ -875,135 +1389,135 @@ async function generateModelString(tableName: string, modelName: string, model:
             throw new Error("Invalid number of arguments")
         }
 
-        let query = db.selectFrom('${tableName}')
-
-        query = query.where(column, operator, value)
+        this.query = this.query.where(column, operator, value)
 
-        return await query.selectAll().execute()
+        return this
       }
 
-      async whereIs(criteria: Partial<${modelName}Type>, options: QueryOptions = {}) {
-        let query = db.selectFrom('${tableName}')
-
-        // Existing criteria checks
-        if (criteria.id)
-          query = query.where('id', '=', criteria.id) // Kysely is immutable, we must re-assign
+      static where(...args: (string | number | boolean | undefined | null)[]): ${modelName}Model {
+        let column: any
+        let operator: any
+        let value: any
 
-        if (criteria.email)
-          query = query.where('email', '=', criteria.email)
+        const instance = new this(null)
 
-        if (criteria.name !== undefined) {
-          query = query.where(
-            'name',
-            criteria.name === null ? 'is' : '=',
-            criteria.name,
-          )
+        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")
         }
 
-        if (criteria.password)
-          query = query.where('password', '=', criteria.password)
-
-        if (criteria.created_at)
-          query = query.where('created_at', '=', criteria.created_at)
-
-        if (criteria.updated_at)
-          query = query.where('updated_at', '=', criteria.updated_at)
+        instance.query = instance.query.where(column, operator, value)
 
-        if (criteria.deleted_at)
-          query = query.where('deleted_at', '=', criteria.deleted_at)
+        return instance
+      }
 
-        // Apply sorting from options
-        if (options.sort)
-          query = query.orderBy(options.sort.column, options.sort.order)
+       ${whereStatements}
 
-        // Apply pagination from options
-        if (options.limit !== undefined)
-          query = query.limit(options.limit)
+      static whereIn(column: keyof ${modelName}Type, values: any[]): ${modelName}Model {
+        const instance = new this(null)
 
-        if (options.offset !== undefined)
-          query = query.offset(options.offset)
+        instance.query = instance.query.where(column, 'in', values)
 
-        return await query.selectAll().execute()
+        return instance
       }
 
-      async whereIn(column: keyof ${modelName}Type, values: any[], options: QueryOptions = {}): Promise<${modelName}Type[]> {
-
-        let query = db.selectFrom('${tableName}')
-
-        query = query.where(column, 'in', values)
+      async first(): Promise<${modelName}Model | undefined> {
+        const model = await this.query.selectAll().executeTakeFirst()
 
-        // Apply sorting from options
-        if (options.sort)
-          query = query.orderBy(options.sort.column, options.sort.order)
+        if (! model) {
+          return undefined
+        }
 
-        // Apply pagination from options
-        if (options.limit !== undefined)
-          query = query.limit(options.limit)
+        return this.parseResult(new ${modelName}Model(model))
+      }
 
-        if (options.offset !== undefined)
-          query = query.offset(options.offset)
+      async exists(): Promise<boolean> {
+        const model = await this.query.selectAll().executeTakeFirst()
 
-        return await query.selectAll().execute()
+        return model !== null || model !== undefined
       }
 
-      async first(): Promise<${modelName}Type> {
+      static async first(): Promise<${modelName}Type | undefined> {
         return await db.selectFrom('${tableName}')
           .selectAll()
           .executeTakeFirst()
       }
 
-      async last(): Promise<${modelName}Type> {
+      async last(): Promise<${modelName}Type | undefined> {
         return await db.selectFrom('${tableName}')
           .selectAll()
           .orderBy('id', 'desc')
           .executeTakeFirst()
       }
 
-      async orderBy(column: keyof ${modelName}Type, order: 'asc' | 'desc'): Promise<${modelName}Type[]> {
-        return await db.selectFrom('${tableName}')
-          .selectAll()
-          .orderBy(column, order)
-          .execute()
+      static orderBy(column: keyof ${modelName}Type, order: 'asc' | 'desc'): ${modelName}Model {
+        const instance = new this(null)
+
+        instance.query = instance.orderBy(column, order)
+
+        return instance
       }
 
-      async orderByDesc(column: keyof ${modelName}Type): Promise<${modelName}Type[]> {
-        return await db.selectFrom('${tableName}')
-          .selectAll()
-          .orderBy(column, 'desc')
-          .execute()
+      orderBy(column: keyof ${modelName}Type, order: 'asc' | 'desc'): ${modelName}Model {
+        this.query = this.query.orderBy(column, order)
+
+        return this
       }
 
-      async orderByAsc(column: keyof ${modelName}Type): Promise<${modelName}Type[]> {
-        return await db.selectFrom('${tableName}')
-          .selectAll()
-          .orderBy(column, 'asc')
-          .execute()
+      static orderByDesc(column: keyof ${modelName}Type): ${modelName}Model {
+        const instance = new this(null)
+
+        instance.query = instance.query.orderBy(column, 'desc')
+
+        return instance
       }
 
-      // Method to get the ${formattedModelName} instance itself
-      self(): ${modelName}Model {
+      orderByDesc(column: keyof ${modelName}Type): ${modelName}Model {
+        this.query = this.orderBy(column, 'desc')
+
         return this
       }
 
-      // Method to get the ${formattedModelName} instance data
-      get() {
-        return this.${formattedModelName}
+      static orderByAsc(column: keyof ${modelName}Type): ${modelName}Model {
+        const instance = new this(null)
+
+        instance.query = instance.query.orderBy(column, 'desc')
+
+        return instance
+      }
+
+      orderByAsc(column: keyof ${modelName}Type): ${modelName}Model {
+        this.query = this.query.orderBy(column, 'desc')
+
+        return this
       }
 
-      // Method to update the ${formattedModelName} instance
-      async update(${formattedModelName}: ${modelName}Update): Promise<Result<${modelName}Type, Error>> {
-        if (this.${formattedModelName}.id === undefined)
-          return err(handleError('${modelName} ID is undefined'))
+      // Method to update the ${tableName} instance
+      async update(${formattedModelName}: ${modelName}Update): Promise<${modelName}Model | undefined> {
+        if (this.id === undefined)
+          throw new Error('${modelName} ID is undefined')
+
+        const filteredValues = Object.keys(${formattedModelName})
+            .filter(key => this.fillable.includes(key))
+            .reduce((obj, key) => {
+                obj[key] = ${formattedModelName}[key]
+                return obj;
+            }, {});
 
-        const updatedModel = await db.updateTable('${tableName}')
-          .set(${formattedModelName})
-          .where('id', '=', this.${formattedModelName}.id)
+        await db.updateTable('${tableName}')
+          .set(filteredValues)
+          .where('id', '=', this.id)
           .executeTakeFirst()
 
-        if (!updatedModel)
-          return err(handleError('${modelName} not found'))
+        const model = this.find(Number(this.id))
+
+        ${mittUpdateStatement}
 
-        return ok(updatedModel)
+        return model
       }
 
       // Method to save (insert or update) the ${formattedModelName} instance
@@ -1023,38 +1537,66 @@ async function generateModelString(tableName: string, modelName: string, model:
         }
       }
 
-      // Method to delete the ${formattedModelName} instance
+      // Method to delete (soft delete) the ${formattedModelName} instance
       async delete(): Promise<void> {
-        if (this.${formattedModelName}.id === undefined)
-          throw new Error('${modelName} ID is undefined')
+          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();
+          }
 
-        await db.deleteFrom('${tableName}')
-          .where('id', '=', this.${formattedModelName}.id)
-          .execute()
+          ${mittDeleteStatement}
+      }
 
-        this.${formattedModelName} = {}
+      ${relationMethods}
+
+      distinct(column: keyof ${modelName}Type): ${modelName}Model {
+        this.query = this.query.distinctOn(column)
+
+        return this
       }
 
-      // Method to refresh the ${formattedModelName} instance data from the database
-      async refresh(): Promise<void> {
-        if (this.${formattedModelName}.id === undefined)
-          throw new Error('${modelName} ID is undefined')
+      static distinct(column: keyof ${modelName}Type): ${modelName}Model {
+        const instance = new this(null)
 
-        const refreshedModel = await db.selectFrom('${tableName}')
-          .where('id', '=', this.${formattedModelName}.id)
-          .selectAll()
-          .executeTakeFirst()
+        instance.query = instance.query.distinctOn(column)
 
-        if (!refreshedModel)
-          throw new Error('${modelName} not found')
+        return instance
+      }
 
-        this.${formattedModelName} = refreshedModel
+      join(table: string, firstCol: string, secondCol: string): ${modelName}Model {
+        this.query = this.query.innerJoin(table, firstCol, secondCol)
+
+        return this
       }
 
-      ${relationMethods}
+      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
+      }
+
+      static async rawQuery(rawQuery: string): Promise<any> {
+        return await sql\`\${rawQuery}\`\.execute(db)
+      }
 
       toJSON() {
-        const output: Partial<${modelName}Type> = { ...this.${formattedModelName} }
+        const output: Partial<${modelName}Type> = ${jsonFields}
 
         this.hidden.forEach((attr) => {
           if (attr in output)
@@ -1065,259 +1607,64 @@ async function generateModelString(tableName: string, modelName: string, model:
 
         return output as ${modelName}
       }
-    }
-
-    const Model = ${modelName}Model
-
-    // starting here, ORM functions
-    export async function find(id: number, fields?: (keyof ${modelName}Type)[]) {
-      let query = db.selectFrom('${tableName}').where('id', '=', id)
 
-      if (fields)
-        query = query.select(fields)
-      else
-        query = query.selectAll()
+      parseResult(model: ${modelName}Model): ${modelName}Model {
+        delete model['query']
+        delete model['fillable']
+        delete model['two_factor_secret']
+        delete model['hasSelect']
+        delete model['softDeletes']
 
-      const model = await query.executeTakeFirst()
+        for (const hiddenAttribute of this.hidden) {
+          delete model[hiddenAttribute]
+        }
 
-      if (!model)
-        return null
+        return model
+      }
 
-      return new ${modelName}Model(model)
+      ${twoFactorStatements}
     }
 
-    export async function findOrFail(id: number, fields?: (keyof ${modelName}Type)[]) {
+    async function find(id: number): Promise<${modelName}Model | null> {
       let query = db.selectFrom('${tableName}').where('id', '=', id)
 
-      if (fields)
-        query = query.select(fields)
-      else
-        query = query.selectAll()
+      if (fields) query = query.select(fields)
+      else query = query.selectAll()
 
       const model = await query.executeTakeFirst()
 
-      if (!model)
-        throw(\`No model results found for \${id}\ \`)
+      if (!model) return null
 
       return new ${modelName}Model(model)
     }
 
-    export async function findMany(ids: number[], fields?: (keyof ${modelName}Type)[]) {
-      let query = db.selectFrom('${tableName}').where('id', 'in', ids)
-
-      if (fields)
-        query = query.select(fields)
-      else
-        query = query.selectAll()
-
-      const model = await query.execute()
+    export async function count(): Promise<number> {
+      const results = await ${modelName}Model.count()
 
-      return model.map(modelItem => new ${modelName}Model(modelItem))
-    }
-
-    export async function count(): Number {
-      const results = await db.selectFrom('${tableName}')
-        .selectAll()
-        .execute()
-
-      return results.length
-    }
-
-    export async function get(criteria: Partial<${modelName}Type>, sort: { column: keyof ${modelName}Type, order: 'asc' | 'desc' } = { column: 'created_at', order: 'desc' }) {
-      let query = db.selectFrom('${tableName}')
-
-      if (criteria.id)
-        query = query.where('id', '=', criteria.id) // Kysely is immutable, we must re-assign
-
-      if (criteria.email)
-        query = query.where('email', '=', criteria.email)
-
-      if (criteria.name !== undefined) {
-        query = query.where(
-          'name',
-          criteria.name === null ? 'is' : '=',
-          criteria.name,
-        )
-      }
-
-      if (criteria.password)
-        query = query.where('password', '=', criteria.password)
-
-      if (criteria.created_at)
-        query = query.where('created_at', '=', criteria.created_at)
-
-      if (criteria.updated_at)
-        query = query.where('updated_at', '=', criteria.updated_at)
-
-      if (criteria.deleted_at)
-        query = query.where('deleted_at', '=', criteria.deleted_at)
-
-      // Apply sorting based on the 'sort' parameter
-      query = query.orderBy(sort.column, sort.order)
-
-      return await query.selectAll().execute()
-    }
-
-    export async function all(limit: number = 10, offset: number = 0): Promise<${modelName}Type[]> {
-      return await db.selectFrom('${tableName}')
-        .selectAll()
-        .orderBy('created_at', 'desc')
-        .limit(limit)
-        .offset(offset)
-        .execute()
+      return results
     }
 
     export async function create(new${modelName}: New${modelName}): Promise<${modelName}Model> {
       const result = await db.insertInto('${tableName}')
-      .values(new${modelName})
-      .executeTakeFirstOrThrow()
+        .values(new${modelName})
+        .executeTakeFirstOrThrow()
 
-      return await find(Number(result.insertId))
+      return await find(Number(result.insertId)) as ${modelName}Model
     }
 
-    export async function first(): Promise<${modelName}Model> {
-     return await db.selectFrom('${tableName}')
-        .selectAll()
-        .executeTakeFirst()
+    export async function rawQuery(rawQuery: string): Promise<any> {
+      return await sql\`\${rawQuery}\`\.execute(db)
     }
 
-    export async function recent(limit: number): Promise<${modelName}Model[]> {
-      return await db.selectFrom('${tableName}')
-         .selectAll()
-         .limit(limit)
-         .execute()
-     }
-
-     export async function last(limit: number): Promise<${modelName}Type> {
-      return await db.selectFrom('${tableName}')
-         .selectAll()
-         .orderBy('id', 'desc')
-         .limit(limit)
-         .execute()
-     }
-
-    export async function update(id: number, ${formattedModelName}Update: ${modelName}Update) {
-      return await db.updateTable('${tableName}')
-        .set(${formattedModelName}Update)
+    export async function remove(id: number): Promise<void> {
+      await db.deleteFrom('${tableName}')
         .where('id', '=', id)
         .execute()
     }
 
-    export async function remove(id: number) {
-      return await db.deleteFrom('${tableName}')
-        .where('id', '=', id)
-        .executeTakeFirst()
-    }
-
-    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)
-
-      return await query.selectAll().execute()
-    }
-
-    export async function whereIs(
-      criteria: Partial<${modelName}Type>,
-      options: QueryOptions = {},
-    ) {
-      let query = db.selectFrom('${tableName}')
-
-      // Apply criteria
-      if (criteria.id)
-        query = query.where('id', '=', criteria.id)
-
-      if (criteria.email)
-        query = query.where('email', '=', criteria.email)
-
-      if (criteria.name !== undefined) {
-        query = query.where(
-          'name',
-          criteria.name === null ? 'is' : '=',
-          criteria.name,
-        )
-      }
-
-      if (criteria.password)
-        query = query.where('password', '=', criteria.password)
-
-      if (criteria.created_at)
-        query = query.where('created_at', '=', criteria.created_at)
-
-      if (criteria.updated_at)
-        query = query.where('updated_at', '=', criteria.updated_at)
-
-      if (criteria.deleted_at)
-        query = query.where('deleted_at', '=', criteria.deleted_at)
-
-      // Apply sorting from options
-      if (options.sort)
-        query = query.orderBy(options.sort.column, options.sort.order)
+    ${whereFunctionStatements}
 
-      // Apply pagination from options
-      if (options.limit !== undefined)
-        query = query.limit(options.limit)
-
-      if (options.offset !== undefined)
-        query = query.offset(options.offset)
-
-      return await query.selectAll().execute()
-    }
-
-    export async function whereIn(
-      column: keyof ${modelName}Type,
-      values: any[],
-      options: QueryOptions = {},
-    ) {
-      let query = db.selectFrom('${tableName}')
-
-      query = query.where(column, 'in', values)
-
-      // Apply sorting from options
-      if (options.sort)
-        query = query.orderBy(options.sort.column, options.sort.order)
-
-      // Apply pagination from options
-      if (options.limit !== undefined)
-        query = query.limit(options.limit)
-
-      if (options.offset !== undefined)
-        query = query.offset(options.offset)
-
-      return await query.selectAll().execute()
-    }
-
-    export const ${modelName} = {
-      find,
-      findOrFail,
-      findMany,
-      get,
-      count,
-      all,
-      create,
-      update,
-      remove,
-      Model,
-      first,
-      last,
-      recent,
-      where,
-      whereIn,
-      model: ${modelName}Model
-    }
+    const ${modelName} = ${modelName}Model
 
     export default ${modelName}
     `