@stacksjs/database 0.61.24 → 0.63.0

package/src/drivers/sqlite.ts

@@ -1,17 +1,22 @@
 import { italic, log } from '@stacksjs/cli'
 import { db } from '@stacksjs/database'
 import { ok } from '@stacksjs/error-handling'
-import { getTableName, getModelName } from '@stacksjs/orm'
+import { getModelName, getTableName } from '@stacksjs/orm'
 import { path } from '@stacksjs/path'
 import { fs, glob } from '@stacksjs/storage'
+import { snakeCase } from '@stacksjs/strings'
 import type { Attribute, Attributes, Model } from '@stacksjs/types'
 import {
+  arrangeColumns,
   checkPivotMigration,
   fetchOtherModelRelations,
+  findDifferingKeys,
   getLastMigrationFields,
   getPivotTables,
   hasTableBeenMigrated,
+  isArrayEqual,
   mapFieldTypeToColumnType,
+  pluckChanges,
 } from '.'
 
 export async function resetSqliteDatabase() {
@@ -115,15 +120,17 @@ export async function generateSqliteMigration(modelPath: string) {
   else await createTableMigration(modelPath)
 }
 
-async function createTableMigration(modelPath: string): Promise<void> {
+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 twoFactorEnabled = model.traits?.useAuth?.useTwoFactor
+
   await createPivotTableMigration(model, modelPath)
   const otherModelRelations = await fetchOtherModelRelations(model, modelPath)
-  const fields = model.attributes
+
   const useTimestamps = model?.traits?.useTimestamps ?? model?.traits?.timestampable ?? true
   const useSoftDeletes = model?.traits?.useSoftDeletes ?? model?.traits?.softDeletable ?? false
 
@@ -134,26 +141,31 @@ async function createTableMigration(modelPath: string): Promise<void> {
   migrationContent += `    .createTable('${tableName}')\n`
   migrationContent += `    .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())\n`
 
-  for (const [fieldName, options] of Object.entries(fields)) {
+  for (const [fieldName, options] of arrangeColumns(model.attributes)) {
     const fieldOptions = options as Attribute
-    const columnType = mapFieldTypeToColumnType(fieldOptions.validator?.rule)
-    migrationContent += `    .addColumn('${fieldName}', '${columnType}'`
+    const fieldNameFormatted = snakeCase(fieldName)
+    const columnType = mapFieldTypeToColumnType(fieldOptions.validation?.rule)
+    migrationContent += `    .addColumn('${fieldNameFormatted}', ${columnType}`
 
     // Check if there are configurations that require the lambda function
-    if (fieldOptions.unique || fieldOptions.validator?.rule?.required) {
+    if (fieldOptions.unique || fieldOptions?.required) {
       migrationContent += `, col => col`
       if (fieldOptions.unique) migrationContent += `.unique()`
-      if (fieldOptions.validator?.rule?.required) migrationContent += `.notNull()`
+      if (fieldOptions?.required) migrationContent += `.notNull()`
       migrationContent += ``
     }
 
     migrationContent += `)\n`
   }
 
+  if (false !== twoFactorEnabled && twoFactorEnabled) {
+    migrationContent += `    .addColumn('two_factor_secret', 'varchar(255)')\n`
+  }
+
   if (otherModelRelations?.length) {
     for (const modelRelation of otherModelRelations) {
       migrationContent += `    .addColumn('${modelRelation.foreignKey}', 'integer', (col) =>
-        col.references('${modelRelation.relationTable}.id').onDelete('cascade').notNull()
+        col.references('${modelRelation.relationTable}.id').onDelete('cascade')
       ) \n`
     }
   }
@@ -174,7 +186,6 @@ async function createTableMigration(modelPath: string): Promise<void> {
   const migrationFileName = `${timestamp}-create-${tableName}-table.ts`
   const migrationFilePath = path.userMigrationsPath(migrationFileName)
 
-  // Assuming fs.writeFileSync is available or use an equivalent method
   Bun.write(migrationFilePath, migrationContent)
 
   log.success(`Created migration: ${italic(migrationFileName)}`)
@@ -204,7 +215,6 @@ async function createPivotTableMigration(model: Model, modelPath: string) {
     const migrationFileName = `${timestamp}-create-${pivotTable.table}-table.ts`
     const migrationFilePath = path.userMigrationsPath(migrationFileName)
 
-    // Assuming fs.writeFileSync is available or use an equivalent method
     Bun.write(migrationFilePath, migrationContent)
 
     log.success(`Created pivot migration: ${migrationFileName}`)
@@ -217,6 +227,7 @@ export async function createAlterTableMigration(modelPath: string) {
   const model = (await import(modelPath)).default as Model
   const modelName = getModelName(model, modelPath)
   const tableName = await getTableName(model, modelPath)
+  let hasChanged = false
 
   // Assuming you have a function to get the fields from the last migration
   // For simplicity, this is not implemented here
@@ -225,33 +236,95 @@ export async function createAlterTableMigration(modelPath: string) {
   const currentFields = model.attributes as Attributes
 
   // Determine fields to add and remove
-  const fieldsToAdd = Object.keys(currentFields)
-  const fieldsToRemove = Object.keys(lastFields)
+
+  const changes = pluckChanges(Object.keys(lastFields), Object.keys(currentFields))
+
+  const fieldsToAdd = changes?.added || []
+
+  const fieldsToRemove = changes?.removed || []
 
   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`
-  migrationContent += `  await db.schema.alterTable('${tableName}')\n`
+
+  if (fieldsToAdd.length || fieldsToRemove.length) {
+    hasChanged = true
+    migrationContent += `  await db.schema.alterTable('${tableName}')\n`
+  }
+
+  const fieldValidations = findDifferingKeys(lastFields, currentFields)
+
+  for (const fieldValidation of fieldValidations) {
+    hasChanged = true
+    const fieldNameFormatted = snakeCase(fieldValidation.key)
+    migrationContent += `await sql\`
+        ALTER TABLE ${tableName}
+        MODIFY COLUMN ${fieldNameFormatted} VARCHAR(${fieldValidation.max})
+      \`.execute(db)\n\n`
+  }
 
   // Add new fields
   for (const fieldName of fieldsToAdd) {
     const options = currentFields[fieldName] as Attribute
-    const columnType = mapFieldTypeToColumnType(options.validator?.rule)
-    migrationContent += `    .addColumn('${fieldName}', '${columnType}')\n`
+    const columnType = mapFieldTypeToColumnType(options.validation?.rule)
+    const formattedFieldName = snakeCase(fieldName)
+
+    migrationContent += `    .addColumn('${formattedFieldName}', ${columnType}`
+
+    // 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()`
+      migrationContent += ``
+    }
+
+    migrationContent += `)\n\n`
   }
 
   // Remove fields that no longer exist
   for (const fieldName of fieldsToRemove) migrationContent += `    .dropColumn('${fieldName}')\n`
 
-  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)
+
+  if (!isArrayEqual(lastFieldOrder, currentFieldOrder)) {
+    hasChanged = true
+    migrationContent += reArrangeColumns(model.attributes, tableName)
+  }
+
   migrationContent += `}\n`
 
   const timestamp = new Date().getTime().toString()
   const migrationFileName = `${timestamp}-update-${tableName}-table.ts`
   const migrationFilePath = path.userMigrationsPath(migrationFileName)
 
-  // Assuming fs.writeFileSync is available or use an equivalent method
-  Bun.write(migrationFilePath, migrationContent)
+  if (hasChanged) {
+    Bun.write(migrationFilePath, migrationContent)
 
-  log.success(`Created migration: ${italic(migrationFileName)}`)
+    log.success(`Created migration: ${italic(migrationFileName)}`)
+  }
+}
+
+function reArrangeColumns(attributes: Attributes | undefined, tableName: string): string {
+  const fields = arrangeColumns(attributes)
+  let migrationContent = ''
+
+  let previousField = ''
+  for (const [fieldName, options] of fields) {
+    const fieldNameFormatted = snakeCase(fieldName)
+
+    if (previousField) {
+      migrationContent += `await sql\`
+        ALTER TABLE ${tableName}
+        MODIFY COLUMN ${fieldNameFormatted} VARCHAR(255) NOT NULL AFTER ${snakeCase(previousField)};
+      \`.execute(db)\n\n`
+    }
+
+    previousField = fieldNameFormatted
+  }
+
+  return migrationContent
 }

package/src/migrations.ts

@@ -88,6 +88,7 @@ export async function generateMigrations() {
 
     for (const file of modelFiles) {
       log.debug('Generating migration for:', file)
+
       await generateMigration(file)
     }
 
@@ -99,11 +100,11 @@ export async function generateMigrations() {
 }
 
 export async function generateMigration(modelPath: string) {
-  if (driver === 'sqlite') generateSqliteMigration(modelPath)
+  if (driver === 'sqlite') await generateSqliteMigration(modelPath)
 
-  if (driver === 'mysql') generateMysqlMigration(modelPath)
+  if (driver === 'mysql') await generateMysqlMigration(modelPath)
 
-  if (driver === 'postgres') generatePostgresMigration(modelPath)
+  if (driver === 'postgres') await generatePostgresMigration(modelPath)
 }
 
 export async function getExecutedMigrations() {

package/src/seeder.ts

@@ -1,11 +1,14 @@
 import { italic, log } from '@stacksjs/cli'
 import { db } from '@stacksjs/database'
 import { modelTableName } from '@stacksjs/orm'
+import { getModelName, getTableName } from '@stacksjs/orm'
 import { path } from '@stacksjs/path'
+import { makeHash } from '@stacksjs/security'
 import { fs, glob } from '@stacksjs/storage'
-import { snakeCase } from '@stacksjs/strings'
+import { plural, singular, snakeCase } from '@stacksjs/strings'
 import type { Model, RelationConfig } from '@stacksjs/types'
 import { isString } from '@stacksjs/validation'
+
 import { generateMigrations, resetDatabase, runDatabaseMigration } from './migrations'
 
 async function seedModel(name: string, model?: Model) {
@@ -25,21 +28,27 @@ async function seedModel(name: string, model?: Model) {
   const records = []
   const otherRelations = await fetchOtherModelRelations(model)
 
-  log.debug(otherRelations)
-
   for (let i = 0; i < seedCount; i++) {
     const record: any = {}
 
     for (const fieldName in model.attributes) {
+      const formattedFieldName = snakeCase(fieldName)
       const field = model.attributes[fieldName]
+
       // Use the factory function if available, otherwise leave the field undefined
-      record[fieldName] = field?.factory ? field.factory() : undefined
+      if (formattedFieldName === 'password')
+        record[formattedFieldName] = field?.factory ? await makeHash('Test@123', { algorithm: 'bcrypt' }) : undefined
+      else record[formattedFieldName] = field?.factory ? field.factory() : undefined
     }
 
     if (otherRelations?.length) {
       for (let j = 0; j < otherRelations.length; j++) {
         const relationElement = otherRelations[j] as RelationConfig
 
+        if (relationElement.relationship === 'belongsToMany') {
+          await seedPivotRelation(relationElement)
+        }
+
         record[relationElement?.foreignKey] = await seedModelRelation(relationElement?.relationModel as string)
       }
     }
@@ -51,6 +60,51 @@ async function seedModel(name: string, model?: Model) {
   await db.insertInto(tableName).values(records).execute()
 }
 
+async function seedPivotRelation(relation: RelationConfig): Promise<any> {
+  const record: any = {}
+  const record2: any = {}
+  const pivotRecord: any = {}
+
+  const modelInstance = (await import(path.userModelsPath(relation?.model))).default
+  const relationModelInstance = (await import(path.userModelsPath(relation?.relationModel))).default
+
+  if (!relationModelInstance) return 1
+
+  const relationModelTable = relationModelInstance.table
+  const relationTable = relation.table
+  const pivotTable = relation.pivotTable
+  const modelKey = `${singular(relationTable)}_id`
+  const foreignKey = relation.foreignKey
+
+  for (const fieldName in relationModelInstance.attributes) {
+    const formattedFieldName = snakeCase(fieldName)
+    const field = relationModelInstance.attributes[fieldName]
+    // Use the factory function if available, otherwise leave the field undefined
+    if (formattedFieldName === 'password')
+      record[formattedFieldName] = field?.factory ? await makeHash('Test@123', { algorithm: 'bcrypt' }) : undefined
+    else record[formattedFieldName] = field?.factory ? field.factory() : undefined
+  }
+
+  for (const fieldName in modelInstance.attributes) {
+    const formattedFieldName = snakeCase(fieldName)
+    const field = modelInstance.attributes[fieldName]
+    // Use the factory function if available, otherwise leave the field undefined
+    if (formattedFieldName === 'password')
+      record2[formattedFieldName] = field?.factory ? await makeHash('Test@123', { algorithm: 'bcrypt' }) : undefined
+    else record2[formattedFieldName] = field?.factory ? field.factory() : undefined
+  }
+
+  const data = await db.insertInto(relationModelTable).values(record).executeTakeFirstOrThrow()
+  const data2 = await db.insertInto(relationTable).values(record2).executeTakeFirstOrThrow()
+  const relationData = data.insertId || 1
+  const modelData = data2.insertId || 1
+
+  pivotRecord[foreignKey] = relationData
+  pivotRecord[modelKey] = modelData
+
+  if (pivotTable) await db.insertInto(pivotTable).values(pivotRecord).executeTakeFirstOrThrow()
+}
+
 async function seedModelRelation(modelName: string): Promise<BigInt | number> {
   const modelInstance = (await import(path.userModelsPath(modelName))).default
 
@@ -60,9 +114,13 @@ async function seedModelRelation(modelName: string): Promise<BigInt | number> {
   const table = modelInstance.table
 
   for (const fieldName in modelInstance.attributes) {
+    const formattedFieldName = snakeCase(fieldName)
     const field = modelInstance.attributes[fieldName]
     // Use the factory function if available, otherwise leave the field undefined
-    record[fieldName] = field?.factory ? field.factory() : undefined
+
+    if (formattedFieldName === 'password')
+      record[formattedFieldName] = field?.factory ? await makeHash(field.factory(), { algorithm: 'bcrypt' }) : undefined
+    else record[formattedFieldName] = field?.factory ? field.factory() : undefined
   }
 
   const data = await db.insertInto(table).values(record).executeTakeFirstOrThrow()
@@ -70,10 +128,13 @@ async function seedModelRelation(modelName: string): Promise<BigInt | number> {
   return data.insertId || 1
 }
 
-export async function getRelations(model: Model): Promise<RelationConfig[]> {
+export async function getRelations(model: Model, modelPath: string): Promise<RelationConfig[]> {
   const relationsArray = ['hasOne', 'hasMany', 'belongsToMany', 'hasOneThrough']
   const relationships = []
 
+  const modelName = getModelName(model, modelPath)
+  const tableName = getTableName(model, modelPath)
+
   for (const relation of relationsArray) {
     if (hasRelations(model, relation)) {
       for (const relationInstance of model[relation]) {
@@ -85,19 +146,19 @@ export async function getRelations(model: Model): Promise<RelationConfig[]> {
 
         const modelRelationPath = path.userModelsPath(`${relationModel}.ts`)
         const modelRelation = (await import(modelRelationPath)).default
-        const formattedModelName = model.name?.toLowerCase()
+        const formattedModelName = modelName?.toLowerCase()
 
         relationships.push({
           relationship: relation,
           model: relationModel,
           table: modelRelation.table,
-          relationModel: model.name,
-          relationTable: model.table,
+          relationModel: modelName,
+          relationTable: tableName,
           foreignKey: relationInstance.foreignKey || `${formattedModelName}_id`,
-          relationName: relationInstance.relationName || '',
-          throughModel: relationInstance.through || '',
-          throughForeignKey: relationInstance.throughForeignKey || '',
-          pivotTable: relationInstance?.pivotTable || `${formattedModelName}_${modelRelation.table}`,
+          relationName: relationInstance.relationName,
+          throughModel: relationInstance.through,
+          throughForeignKey: relationInstance.throughForeignKey,
+          pivotTable: relationInstance?.pivotTable || getPivotTableName(formattedModelName || '', modelRelation.table),
         })
       }
     }
@@ -106,6 +167,22 @@ export async function getRelations(model: Model): Promise<RelationConfig[]> {
   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] || '')
+  models[1] = plural(models[1] || '')
+
+  // Join the sorted array with an underscore
+  const pivotTableName = models.join('_')
+
+  return pivotTableName
+}
+
 export async function fetchOtherModelRelations(model: Model): Promise<RelationConfig[]> {
   const modelFiles = glob.sync(path.userModelsPath('*.ts'))
   const modelRelations = []
@@ -116,7 +193,7 @@ export async function fetchOtherModelRelations(model: Model): Promise<RelationCo
 
     if (model.name === modelFile.default.name) continue
 
-    const relations = await getRelations(modelFile.default)
+    const relations = await getRelations(modelFile.default, modelFileElement)
 
     if (!relations.length) continue
 
@@ -134,21 +211,21 @@ function hasRelations(obj: any, key: string): boolean {
 
 export async function seed() {
   // TODO: need to check other databases too
-  const dbPath = path.userDatabasePath('stacks.sqlite')
+  // const dbPath = path.userDatabasePath('stacks.sqlite')
 
-  if (!fs.existsSync(dbPath)) {
-    log.warn('No database found, configuring it...')
-    // first, ensure the database is reset
-    await resetDatabase()
+  // if (!fs.existsSync(dbPath)) {
+  //   log.warn('No database found, configuring it...')
+  //   // first, ensure the database is reset
+  //   await resetDatabase()
 
-    // then, generate the migrations
-    await generateMigrations()
+  //   // then, generate the migrations
+  //   await generateMigrations()
 
-    // finally, migrate the database
-    await runDatabaseMigration()
-  } else {
-    log.debug('Database configured...')
-  }
+  //   // finally, migrate the database
+  //   await runDatabaseMigration()
+  // } else {
+  //   log.debug('Database configured...')
+  // }
 
   // if a custom seeder exists, use it instead
   const customSeederPath = path.userDatabasePath('seeder.ts')

package/src/utils.ts

@@ -1,6 +1,8 @@
 import { database } from '@stacksjs/config'
 import { log } from '@stacksjs/logging'
 import type { Database } from '@stacksjs/orm'
+import { plural, snakeCase } from '@stacksjs/strings'
+import type { Model } from '@stacksjs/types'
 import { Kysely, MysqlDialect, PostgresDialect, sql } from 'kysely'
 import { BunWorkerDialect } from 'kysely-bun-worker'
 import { createPool } from 'mysql2'