@stacksjs/database 0.61.24 → 0.62.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() {
@@ -123,7 +128,6 @@ async function createTableMigration(modelPath: string): Promise<void> {
 
   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,16 +138,16 @@ 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)
+    const columnType = mapFieldTypeToColumnType(fieldOptions.validations?.rule)
     migrationContent += `    .addColumn('${fieldName}', '${columnType}'`
 
     // Check if there are configurations that require the lambda function
-    if (fieldOptions.unique || fieldOptions.validator?.rule?.required) {
+    if (fieldOptions.unique || fieldOptions.validations?.rule?.required) {
       migrationContent += `, col => col`
       if (fieldOptions.unique) migrationContent += `.unique()`
-      if (fieldOptions.validator?.rule?.required) migrationContent += `.notNull()`
+      if (fieldOptions.validations?.rule?.required) migrationContent += `.notNull()`
       migrationContent += ``
     }
 
@@ -217,41 +221,103 @@ 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
   const lastMigrationFields = await getLastMigrationFields(modelName)
   const lastFields = lastMigrationFields ?? {}
   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`
 
+  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 += `    .execute();\n`
+
   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/seeder.ts

@@ -3,7 +3,7 @@ import { db } from '@stacksjs/database'
 import { modelTableName } from '@stacksjs/orm'
 import { path } from '@stacksjs/path'
 import { fs, glob } from '@stacksjs/storage'
-import { snakeCase } from '@stacksjs/strings'
+import { singular, snakeCase } from '@stacksjs/strings'
 import type { Model, RelationConfig } from '@stacksjs/types'
 import { isString } from '@stacksjs/validation'
 import { generateMigrations, resetDatabase, runDatabaseMigration } from './migrations'
@@ -31,9 +31,11 @@ async function seedModel(name: string, model?: Model) {
     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
+      record[formattedFieldName] = field?.factory ? field.factory() : undefined
     }
 
     if (otherRelations?.length) {
@@ -60,9 +62,10 @@ 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
+    record[formattedFieldName] = field?.factory ? field.factory() : undefined
   }
 
   const data = await db.insertInto(table).values(record).executeTakeFirstOrThrow()
@@ -97,7 +100,7 @@ export async function getRelations(model: Model): Promise<RelationConfig[]> {
           relationName: relationInstance.relationName || '',
           throughModel: relationInstance.through || '',
           throughForeignKey: relationInstance.throughForeignKey || '',
-          pivotTable: relationInstance?.pivotTable || `${formattedModelName}_${modelRelation.table}`,
+          pivotTable: relationInstance?.pivotTable || getPivotTableName(formattedModelName || '', modelRelation.table),
         })
       }
     }
@@ -106,6 +109,21 @@ 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] || '')
+
+  // 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 = []