@stacksjs/database 0.64.6 → 0.65.0

package/src/drivers/sqlite.ts

@@ -1,82 +1,108 @@
+import type { Attribute, Attributes, Model } from '@stacksjs/types'
 import { italic, log } from '@stacksjs/cli'
+import { app } from '@stacksjs/config'
 import { db } from '@stacksjs/database'
-import { ok } from '@stacksjs/error-handling'
-import { getModelName, getTableName } from '@stacksjs/orm'
+import { type Ok, ok } from '@stacksjs/error-handling'
+import { fetchOtherModelRelations, getModelName, getPivotTables, getTableName } from '@stacksjs/orm'
 import { path } from '@stacksjs/path'
-import { fs, glob } from '@stacksjs/storage'
+import { fs, globSync } from '@stacksjs/storage'
 import { snakeCase } from '@stacksjs/strings'
-import type { Attribute, Attributes, Model } from '@stacksjs/types'
 import {
   arrangeColumns,
   checkPivotMigration,
-  fetchOtherModelRelations,
+  fetchTables,
   findDifferingKeys,
   getLastMigrationFields,
-  getPivotTables,
   hasTableBeenMigrated,
   isArrayEqual,
   mapFieldTypeToColumnType,
   pluckChanges,
 } from '.'
 
-export async function resetSqliteDatabase() {
-  const dbPath = path.userDatabasePath('stacks.sqlite')
+export async function resetSqliteDatabase(): Promise<Ok<string, never>> {
+  await deleteFrameworkModels()
+  await deleteMigrationFiles()
+  await dropSqliteTables()
 
-  if (fs.existsSync(dbPath)) await Bun.$`rm ${dbPath}`
+  return ok('All tables dropped successfully!')
+}
 
+export async function deleteMigrationFiles(): Promise<void> {
   const files = await fs.readdir(path.userMigrationsPath())
-  const modelFiles = await fs.readdir(path.frameworkPath('database/models'))
-
-  const userModelFiles = glob.sync(path.userModelsPath('*.ts'))
 
-  for (const userModel of userModelFiles) {
-    const userModelPath = (await import(userModel)).default
-
-    const pivotTables = await getPivotTables(userModelPath, userModel)
+  if (files.length) {
+    for (const file of files) {
+      if (file.endsWith('.ts')) {
+        const migrationPath = path.userMigrationsPath(`${file}`)
 
-    for (const pivotTable of pivotTables) await db.schema.dropTable(pivotTable.table).ifExists().execute()
+        if (fs.existsSync(migrationPath))
+          await Bun.$`rm ${migrationPath}`
+      }
+    }
   }
+}
+
+export async function deleteFrameworkModels(): Promise<void> {
+  const modelFiles = await fs.readdir(path.frameworkPath('database/models'))
 
   if (modelFiles.length) {
     for (const modelFile of modelFiles) {
       if (modelFile.endsWith('.ts')) {
         const modelPath = path.frameworkPath(`database/models/${modelFile}`)
 
-        if (fs.existsSync(modelPath)) await Bun.$`rm ${modelPath}`
+        if (fs.existsSync(modelPath))
+          await Bun.$`rm ${modelPath}`
       }
     }
   }
+}
 
-  if (files.length) {
-    for (const file of files) {
-      if (file.endsWith('.ts')) {
-        const migrationPath = path.userMigrationsPath(`${file}`)
+export async function dropSqliteTables(): Promise<void> {
+  const userModelFiles = globSync([path.userModelsPath('*.ts')], { absolute: true })
+  const tables = await fetchTables()
 
-        if (fs.existsSync(migrationPath)) await Bun.$`rm ${migrationPath}`
-      }
-    }
+  for (const table of tables) await db.schema.dropTable(table).ifExists().execute()
+  await db.schema.dropTable('migrations').ifExists().execute()
+  await db.schema.dropTable('migration_locks').ifExists().execute()
+  await db.schema.dropTable('passkeys').ifExists().execute()
+
+  for (const userModel of userModelFiles) {
+    const userModelPath = (await import(userModel)).default
+    const pivotTables = await getPivotTables(userModelPath, userModel)
+
+    for (const pivotTable of pivotTables) await db.schema.dropTable(pivotTable.table).ifExists().execute()
   }
+}
 
-  return ok('All tables dropped successfully!')
+export function fetchSqliteFile(): string {
+  if (app.env === 'testing') {
+    return fetchTestSqliteFile()
+  }
+
+  return path.userDatabasePath('stacks.sqlite')
+}
+
+export function fetchTestSqliteFile(): string {
+  return path.userDatabasePath('stacks_testing.sqlite')
 }
 
-export async function generateSqliteMigration(modelPath: string) {
+export async function generateSqliteMigration(modelPath: string): Promise<void> {
   // check if any files are in the database folder
-  const files = await fs.readdir(path.userMigrationsPath())
+  // const files = await fs.readdir(path.userMigrationsPath())
 
-  if (files.length === 0) {
-    log.debug('No migrations found in the database folder, deleting all framework/database/*.json files...')
+  // if (files.length === 0) {
+  //   log.debug('No migrations found in the database folder, deleting all framework/database/*.json files...')
 
-    // delete the *.ts files in the database/models folder
-    const modelFiles = await fs.readdir(path.frameworkPath('database/models'))
+  //   // delete the *.ts files in the database/models folder
+  //   const modelFiles = await fs.readdir(path.frameworkPath('database/models'))
 
-    if (modelFiles.length) {
-      log.debug('No existing model files in framework path...')
+  //   if (modelFiles.length) {
+  //     log.debug('No existing model files in framework path...')
 
-      for (const file of modelFiles)
-        if (file.endsWith('.ts')) await fs.unlink(path.frameworkPath(`database/models/${file}`))
-    }
-  }
+  //     for (const file of modelFiles)
+  //       if (file.endsWith('.ts')) await fs.unlink(path.frameworkPath(`database/models/${file}`))
+  //   }
+  // }
 
   const model = (await import(modelPath)).default as Model
   const fileName = path.basename(modelPath)
@@ -101,7 +127,8 @@ export async function generateSqliteMigration(modelPath: string) {
 
     haveFieldsChanged = true
     log.debug(`Fields have changed for ${tableName}`)
-  } else {
+  }
+  else {
     log.debug(`Fields have not been generated for ${tableName}`)
   }
 
@@ -116,17 +143,43 @@ export async function generateSqliteMigration(modelPath: string) {
 
   log.debug(`Has ${tableName} been migrated? ${hasBeenMigrated}`)
 
-  if (haveFieldsChanged) await createAlterTableMigration(modelPath)
+  if (haveFieldsChanged)
+    await createAlterTableMigration(modelPath)
   else await createTableMigration(modelPath)
 }
 
+export async function copyModelFiles(modelPath: string): Promise<void> {
+  const model = (await import(modelPath)).default as Model
+  const fileName = path.basename(modelPath)
+  const tableName = await getTableName(model, modelPath)
+
+  const fieldsString = JSON.stringify(model.attributes, null, 2) // Pretty print the JSON
+  const copiedModelPath = path.frameworkPath(`database/models/${fileName}`)
+
+  // if the file exists, we need to check if the fields have changed
+  if (fs.existsSync(copiedModelPath)) {
+    log.debug(`Fields have already been generated for ${tableName}`)
+
+    const previousFields = await getLastMigrationFields(fileName)
+    const previousFieldsString = JSON.stringify(previousFields, null, 2) // Convert to string for comparison
+
+    if (previousFieldsString === fieldsString) {
+      log.debug(`Fields have not changed for ${tableName}`)
+      return
+    }
+  }
+
+  // store the fields of the model to a file
+  await Bun.$`cp ${modelPath} ${copiedModelPath}`
+}
 async function createTableMigration(modelPath: string) {
   log.debug('createTableMigration modelPath:', modelPath)
 
   const model = (await import(modelPath)).default as Model
-  const tableName = await getTableName(model, modelPath)
+  const tableName = getTableName(model, modelPath)
 
-  const twoFactorEnabled = model.traits?.useAuth?.useTwoFactor
+  const twoFactorEnabled
+    = model.traits?.useAuth && typeof model.traits.useAuth !== 'boolean' ? model.traits.useAuth.useTwoFactor : false
 
   await createPivotTableMigration(model, modelPath)
   const otherModelRelations = await fetchOtherModelRelations(model, modelPath)
@@ -134,6 +187,11 @@ async function createTableMigration(modelPath: string) {
   const useTimestamps = model?.traits?.useTimestamps ?? model?.traits?.timestampable ?? true
   const useSoftDeletes = model?.traits?.useSoftDeletes ?? model?.traits?.softDeletable ?? false
 
+  const usePasskey = (typeof model.traits?.useAuth === 'object' && model.traits.useAuth.usePasskey) ?? false
+
+  if (usePasskey)
+    await createPasskeyMigration()
+
   let migrationContent = `import type { Database } from '@stacksjs/database'\n`
   migrationContent += `import { sql } from '@stacksjs/database'\n\n`
   migrationContent += `export async function up(db: Database<any>) {\n`
@@ -144,21 +202,23 @@ async function createTableMigration(modelPath: string) {
   for (const [fieldName, options] of arrangeColumns(model.attributes)) {
     const fieldOptions = options as Attribute
     const fieldNameFormatted = snakeCase(fieldName)
-    const columnType = mapFieldTypeToColumnType(fieldOptions.validation?.rule)
+    const columnType = mapFieldTypeToColumnType(fieldOptions.validation?.rule, 'sqlite')
     migrationContent += `    .addColumn('${fieldNameFormatted}', ${columnType}`
 
     // Check if there are configurations that require the lambda function
     if (fieldOptions.unique || fieldOptions?.required) {
       migrationContent += `, col => col`
-      if (fieldOptions.unique) migrationContent += `.unique()`
-      if (fieldOptions?.required) migrationContent += `.notNull()`
+      if (fieldOptions.unique)
+        migrationContent += `.unique()`
+      if (fieldOptions?.required)
+        migrationContent += `.notNull()`
       migrationContent += ``
     }
 
     migrationContent += `)\n`
   }
 
-  if (false !== twoFactorEnabled && twoFactorEnabled) {
+  if (twoFactorEnabled !== false && twoFactorEnabled) {
     migrationContent += `    .addColumn('two_factor_secret', 'varchar(255)')\n`
   }
 
@@ -170,14 +230,18 @@ async function createTableMigration(modelPath: string) {
     }
   }
 
+  if (usePasskey)
+    migrationContent += `    .addColumn('public_passkey', 'text')\n`
+
   // Append created_at and updated_at columns if useTimestamps is true
   if (useTimestamps) {
-    migrationContent += `    .addColumn('created_at', 'timestamp', col => col.notNull().defaultTo(sql.raw('CURRENT_TIMESTAMP')))\n`
-    migrationContent += `    .addColumn('updated_at', 'timestamp')\n`
+    migrationContent
+      += '    .addColumn(\'created_at\', \'timestamp\', col => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`))\n'
+    migrationContent += '    .addColumn(\'updated_at\', \'timestamp\')\n'
   }
 
-  // Append deleted_at column if useSoftDeletes is true
-  if (useSoftDeletes) migrationContent += `    .addColumn('deleted_at', 'timestamp')\n`
+  if (useSoftDeletes)
+    migrationContent += `    .addColumn('deleted_at', 'text')\n`
 
   migrationContent += `    .execute()\n`
   migrationContent += `}\n`
@@ -194,12 +258,14 @@ async function createTableMigration(modelPath: string) {
 async function createPivotTableMigration(model: Model, modelPath: string) {
   const pivotTables = await getPivotTables(model, modelPath)
 
-  if (!pivotTables.length) return
+  if (!pivotTables.length)
+    return
 
   for (const pivotTable of pivotTables) {
     const hasBeenMigrated = await checkPivotMigration(pivotTable.table)
 
-    if (hasBeenMigrated) return
+    if (hasBeenMigrated)
+      return
 
     let migrationContent = `import type { Database } from '@stacksjs/database'\n`
     migrationContent += `export async function up(db: Database<any>) {\n`
@@ -213,6 +279,7 @@ async function createPivotTableMigration(model: Model, modelPath: string) {
 
     const timestamp = new Date().getTime().toString()
     const migrationFileName = `${timestamp}-create-${pivotTable.table}-table.ts`
+
     const migrationFilePath = path.userMigrationsPath(migrationFileName)
 
     Bun.write(migrationFilePath, migrationContent)
@@ -221,12 +288,45 @@ async function createPivotTableMigration(model: Model, modelPath: string) {
   }
 }
 
-export async function createAlterTableMigration(modelPath: string) {
-  console.log('createAlterTableMigration')
+async function createPasskeyMigration() {
+  const hasBeenMigrated = await hasTableBeenMigrated('users')
+
+  if (hasBeenMigrated)
+    return
 
+  let migrationContent = `import type { Database } from '@stacksjs/database'\n import { sql } from '@stacksjs/database'\n\n`
+  migrationContent += `export async function up(db: Database<any>) {\n`
+  migrationContent += `  await db.schema\n`
+  migrationContent += `    .createTable('passkeys')\n`
+  migrationContent += `    .addColumn('id', 'text')\n`
+  migrationContent += `    .addColumn('cred_public_key', 'text')\n`
+  migrationContent += `    .addColumn('user_id', 'integer')\n`
+  migrationContent += `    .addColumn('webauthn_user_id', 'varchar(255)')\n`
+  migrationContent += `    .addColumn('counter', 'integer')\n`
+  migrationContent += `    .addColumn('device_type', 'varchar(255)')\n`
+  migrationContent += `    .addColumn('credential_type', 'varchar(255)')\n`
+  migrationContent += `    .addColumn('backup_eligible', 'boolean')\n`
+  migrationContent += `    .addColumn('backup_status', 'boolean')\n`
+  migrationContent += `    .addColumn('transports', 'varchar(255)')\n`
+  migrationContent += `    .addColumn('last_used_at', 'text')\n`
+  migrationContent += `    .addColumn('created_at', 'timestamp', col => col.notNull().defaultTo(sql.raw('CURRENT_TIMESTAMP')))\n`
+  migrationContent += `    .execute()\n`
+  migrationContent += `    }\n`
+
+  const timestamp = new Date().getTime().toString()
+  const migrationFileName = `${timestamp}-create-passkeys-table.ts`
+
+  const migrationFilePath = path.userMigrationsPath(migrationFileName)
+
+  Bun.write(migrationFilePath, migrationContent)
+
+  log.success(`Created pivot migration: ${migrationFileName}`)
+}
+
+async function createAlterTableMigration(modelPath: string) {
   const model = (await import(modelPath)).default as Model
   const modelName = getModelName(model, modelPath)
-  const tableName = await getTableName(model, modelPath)
+  const tableName = getTableName(model, modelPath)
   let hasChanged = false
 
   // Assuming you have a function to get the fields from the last migration
@@ -266,7 +366,7 @@ export async function createAlterTableMigration(modelPath: string) {
   // Add new fields
   for (const fieldName of fieldsToAdd) {
     const options = currentFields[fieldName] as Attribute
-    const columnType = mapFieldTypeToColumnType(options.validation?.rule)
+    const columnType = mapFieldTypeToColumnType(options.validation?.rule, 'sqlite')
     const formattedFieldName = snakeCase(fieldName)
 
     migrationContent += `    .addColumn('${formattedFieldName}', ${columnType}`
@@ -274,8 +374,10 @@ export async function createAlterTableMigration(modelPath: string) {
     // Check if there are configurations that require the lambda function
     if (options.unique || options?.required) {
       migrationContent += `, col => col`
-      if (options.unique) migrationContent += `.unique()`
-      if (options?.required) migrationContent += `.notNull()`
+      if (options.unique)
+        migrationContent += `.unique()`
+      if (options?.required)
+        migrationContent += `.notNull()`
       migrationContent += ``
     }
 
@@ -285,10 +387,11 @@ export async function createAlterTableMigration(modelPath: string) {
   // Remove fields that no longer exist
   for (const fieldName of fieldsToRemove) migrationContent += `    .dropColumn('${fieldName}')\n`
 
-  if (fieldsToAdd.length || fieldsToRemove.length) migrationContent += `    .execute();\n`
+  if (fieldsToAdd.length || fieldsToRemove.length)
+    migrationContent += `    .execute();\n`
 
-  const lastFieldOrder = Object.values(lastFields).map((attr) => attr.order)
-  const currentFieldOrder = Object.values(currentFields).map((attr) => attr.order)
+  const lastFieldOrder = Object.values(lastFields).map(attr => attr.order)
+  const currentFieldOrder = Object.values(currentFields).map(attr => attr.order)
 
   if (!isArrayEqual(lastFieldOrder, currentFieldOrder)) {
     hasChanged = true
@@ -313,7 +416,7 @@ function reArrangeColumns(attributes: Attributes | undefined, tableName: string)
   let migrationContent = ''
 
   let previousField = ''
-  for (const [fieldName, options] of fields) {
+  for (const [fieldName] of fields) {
     const fieldNameFormatted = snakeCase(fieldName)
 
     if (previousField) {

package/src/index.ts

@@ -1,5 +1,6 @@
-export * from './schema'
+export * from './drivers'
 export * from './migrations'
+export * from './schema'
 export * from './seeder'
 export * from './types'
 export * from './utils'

package/src/migrations.ts

@@ -1,20 +1,16 @@
-import { dim, italic, log } from '@stacksjs/cli'
+import { log } from '@stacksjs/cli'
 import { database } from '@stacksjs/config'
-import { err, ok } from '@stacksjs/error-handling'
-import { extractFieldsFromModel } from '@stacksjs/orm'
+import { type Err, err, handleError, type Ok, ok, type Result } from '@stacksjs/error-handling'
 import { path } from '@stacksjs/path'
-import { fs, glob } from '@stacksjs/storage'
-import type { Attribute, Attributes } from '@stacksjs/types'
+import { fs, globSync } from '@stacksjs/storage'
 import { $ } from 'bun'
-import { FileMigrationProvider, Migrator } from 'kysely'
-import { generateMysqlMigration, resetMysqlDatabase } from './drivers'
-import { generatePostgresMigration, resetPostgresDatabase } from './drivers'
-import { generateSqliteMigration, resetSqliteDatabase } from './drivers'
+import { FileMigrationProvider, type MigrationResult, Migrator } from 'kysely'
+import { generateMysqlMigration, generatePostgresMigration, generateSqliteMigration, resetMysqlDatabase, resetPostgresDatabase, resetSqliteDatabase } from './drivers'
 import { db } from './utils'
 
 const driver = database.default || ''
 
-export const migrator = new Migrator({
+export const migrator: Migrator = new Migrator({
   db,
 
   provider: new FileMigrationProvider({
@@ -39,15 +35,14 @@ export const migrator = new Migrator({
 //   }),
 // })
 
-export async function runDatabaseMigration() {
+export async function runDatabaseMigration(): Promise<Result<MigrationResult[] | string, Error>> {
   try {
     log.info('Migrating database...')
 
     const { error, results } = await migrator.migrateToLatest()
 
     if (error) {
-      log.error(error)
-      return err(error)
+      return err(handleError(error))
     }
 
     if (results?.length === 0) {
@@ -55,13 +50,14 @@ export async function runDatabaseMigration() {
       return ok('No new migrations were executed')
     }
 
-    if (results) return ok(results)
+    if (results)
+      return ok(results)
 
     log.success('Database migration completed with no new migrations.')
     return ok('Database migration completed with no new migrations.')
-  } catch (error) {
-    console.error('Migration failed:', error)
-    return err(error)
+  }
+  catch (error) {
+    return err(handleError('Migration failed', error))
   }
 }
 
@@ -70,21 +66,22 @@ export interface MigrationOptions {
   up: string
 }
 
-export async function resetDatabase() {
-  if (driver === 'sqlite') return resetSqliteDatabase()
-
-  if (driver === 'mysql') return resetMysqlDatabase()
-
-  if (driver === 'postgres') return resetPostgresDatabase()
+export async function resetDatabase(): Promise<Ok<string, never>> {
+  if (driver === 'sqlite')
+    return await resetSqliteDatabase()
+  if (driver === 'mysql')
+    return await resetMysqlDatabase()
+  if (driver === 'postgres')
+    return await resetPostgresDatabase()
 
   throw new Error('Unsupported database driver in resetDatabase')
 }
 
-export async function generateMigrations() {
+export async function generateMigrations(): Promise<Ok<string, never> | Err<string, any>> {
   try {
     log.info('Generating migrations...')
 
-    const modelFiles = glob.sync(path.userModelsPath('*.ts'))
+    const modelFiles = globSync([path.userModelsPath('*.ts')], { absolute: true })
 
     for (const file of modelFiles) {
       log.debug('Generating migration for:', file)
@@ -94,29 +91,24 @@ export async function generateMigrations() {
 
     log.success('Migrations generated')
     return ok('Migrations generated')
-  } catch (error) {
+  }
+  catch (error) {
     return err(error)
   }
 }
 
-export async function generateMigration(modelPath: string) {
-  if (driver === 'sqlite') await generateSqliteMigration(modelPath)
-
-  if (driver === 'mysql') await generateMysqlMigration(modelPath)
+export async function generateMigration(modelPath: string): Promise<void> {
+  if (driver === 'sqlite')
+    await generateSqliteMigration(modelPath)
 
-  if (driver === 'postgres') await generatePostgresMigration(modelPath)
-}
+  if (driver === 'mysql')
+    await generateMysqlMigration(modelPath)
 
-export async function getExecutedMigrations() {
-  try {
-    // @ts-expect-error the migrations table is not typed yet
-    return await db.selectFrom('migrations').select('name').execute()
-  } catch (error) {
-    return []
-  }
+  if (driver === 'postgres')
+    await generatePostgresMigration(modelPath)
 }
 
-export async function haveModelFieldsChangedSinceLastMigration(modelPath: string) {
+export async function haveModelFieldsChangedSinceLastMigration(modelPath: string): Promise<boolean> {
   log.debug(`haveModelFieldsChangedSinceLastMigration for model: ${modelPath}`)
 
   // const model = await import(modelPath)
@@ -134,11 +126,11 @@ export async function haveModelFieldsChangedSinceLastMigration(modelPath: string
   return !!gitHistory
 }
 
-export async function lastMigration() {
+export async function lastMigration(): Promise<any> {
   try {
-    // @ts-expect-error the migrations table is not typed yet
     return await db.selectFrom('migrations').selectAll().orderBy('timestamp', 'desc').limit(1).execute()
-  } catch (error) {
+  }
+  catch (error) {
     console.error('Failed to get last migration:', error)
     return { error }
   }
@@ -146,28 +138,13 @@ export async function lastMigration() {
 
 export async function lastMigrationDate(): Promise<string | undefined> {
   try {
-    // @ts-expect-error the migrations table is not typed yet
     return (await db.selectFrom('migrations').select('timestamp').orderBy('timestamp', 'desc').limit(1).execute())[0]
       .timestamp
-  } catch (error) {
+  }
+  catch (error) {
     console.error('Failed to get last migration date:', error)
     return undefined
   }
 }
 
-// This is a placeholder function. You need to implement the logic to
-// read the last migration file and extract the fields that were modified.
-export async function getLastMigrationFields(modelName: string): Promise<Attribute> {
-  const oldModelPath = path.frameworkPath(`database/models/${modelName}`)
-  const model = (await import(oldModelPath)).default as Model
-  let fields = {} as Attributes
-
-  if (typeof model.attributes === 'object') fields = model.attributes
-  else fields = JSON.parse(model.attributes) as Attributes
-
-  return fields
-}
-
-export async function getCurrentMigrationFields(modelPath: string): Promise<Attribute | undefined> {
-  return extractFieldsFromModel(modelPath)
-}
+export type { MigrationResult }