@stacksjs/database 0.61.24 → 0.62.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/database",
   "type": "module",
-  "version": "0.61.24",
+  "version": "0.62.0",
   "description": "The Stacks database integration.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -57,7 +57,7 @@
     "@stacksjs/storage": "latest",
     "@stacksjs/strings": "latest",
     "@stacksjs/utils": "latest",
-    "kysely-bun-worker": "^0.6.1"
+    "kysely-bun-worker": "^0.6.2"
   },
   "dependencies": {
     "@stacksjs/cli": "latest",
@@ -68,10 +68,10 @@
     "@stacksjs/storage": "latest",
     "@stacksjs/strings": "latest",
     "@stacksjs/utils": "latest",
-    "kysely-bun-worker": "^0.6.1"
+    "kysely-bun-worker": "^0.6.2"
   },
   "optionalDependencies": {
-    "mysql2": "^3.10.0"
+    "mysql2": "^3.10.2"
   },
   "devDependencies": {
     "@stacksjs/development": "latest",
@@ -79,6 +79,6 @@
     "debug": "^4.3.5",
     "mkdirp": "^3.0.1",
     "q": "^1.5.1",
-    "tar": "^7.2.0"
+    "tar": "^7.4.0"
   }
 }

package/src/drivers/index.ts

@@ -3,7 +3,7 @@ import { db } from '@stacksjs/database'
 import { getModelName, getTableName } from '@stacksjs/orm'
 import { path } from '@stacksjs/path'
 import { fs, glob } from '@stacksjs/storage'
-import { plural, snakeCase } from '@stacksjs/strings'
+import { plural, singular, snakeCase } from '@stacksjs/strings'
 import type { Attributes, Model, RelationConfig, VineType } from '@stacksjs/types'
 import { isString } from '@stacksjs/validation'
 
@@ -11,6 +11,11 @@ export * from './mysql'
 export * from './postgres'
 export * from './sqlite'
 
+interface Range {
+  min: number
+  max: number
+}
+
 export async function getLastMigrationFields(modelName: string): Promise<Attributes> {
   const oldModelPath = path.frameworkPath(`database/models/${modelName}`)
   const model = (await import(oldModelPath)).default as Model
@@ -116,6 +121,34 @@ export function prepareTextColumnType(rule: VineType) {
   return `'${columnType}'`
 }
 
+export function findCharacterLength(rule: VineType): { min: number; max: number } | undefined {
+  const result: any = {}
+
+  // Find min and max length validations
+  const minLengthValidation = rule.validations.find((v: any) => v.options?.min !== undefined)
+  const maxLengthValidation = rule.validations.find((v: any) => v.options?.max !== undefined)
+
+  if (minLengthValidation === undefined || maxLengthValidation === undefined) {
+    return undefined
+  }
+
+  for (const key of ['min', 'max']) {
+    if (maxLengthValidation.options[key] === undefined && minLengthValidation.options[key] === undefined) continue
+
+    result.max = maxLengthValidation.options[key]
+    result.min = minLengthValidation.options[key]
+  }
+
+  // if (minLengthValidation.options[key] !== maxLengthValidation.options[key]) {
+  //   result[key] = maxLengthValidation.options[key];
+  // }
+  return result
+}
+
+export function compareRanges(range1: Range, range2: Range): boolean {
+  return range1.min === range2.min && range1.max === range2.max
+}
+
 export async function checkPivotMigration(dynamicPart: string): Promise<boolean> {
   const files = await fs.readdir(path.userMigrationsPath())
 
@@ -147,7 +180,6 @@ export async function getRelations(model: Model, modelPath: string): Promise<Rel
         const modelRelationPath = path.userModelsPath(`${relationModel}.ts`)
         const modelRelation = (await import(modelRelationPath)).default
 
-
         const modelName = getModelName(model, modelPath)
         const formattedModelName = modelName.toLowerCase()
         const tableName = getTableName(model, modelPath)
@@ -164,7 +196,7 @@ export async function getRelations(model: Model, modelPath: string): Promise<Rel
           relationName: relationInstance.relationName || '',
           throughModel: relationInstance.through || '',
           throughForeignKey: relationInstance.throughForeignKey || '',
-          pivotTable: relationInstance?.pivotTable || `${formattedModelName}_${modelRelationTable}`,
+          pivotTable: relationInstance?.pivotTable || getPivotTableName(formattedModelName, modelRelationTable),
         })
       }
     }
@@ -204,31 +236,48 @@ export async function fetchOtherModelRelations(model: Model, modelPath: string):
 
 export async function getPivotTables(
   model: Model,
-  modelPath: string
+  modelPath: string,
 ): Promise<{ table: string; firstForeignKey: string | undefined; secondForeignKey: string | undefined }[]> {
   const pivotTable = []
 
   const modelName = getTableName(model, modelPath)
+  let firstForeignKey = ''
+  let secondForeignKey = ''
+  let table = ''
+  let modelRelationPath = ''
 
   if (model.belongsToMany) {
     if ('belongsToMany' in model) {
       for (const belongsToManyRelation of model.belongsToMany) {
-        const modelRelationPath = path.userModelsPath(`${belongsToManyRelation}.ts`)
+        if (typeof belongsToManyRelation === 'string') {
+          modelRelationPath = path.userModelsPath(`${belongsToManyRelation}.ts`)
+        } else {
+          modelRelationPath = path.userModelsPath(`${belongsToManyRelation.model}.ts`)
+        }
+
         const modelRelation = (await import(modelRelationPath)).default
         const formattedModelName = modelName.toLowerCase()
 
         const modelRelationTable = getTableName(modelRelation, modelRelationPath)
         const modelRelationModelName = getModelName(modelRelation, modelRelationPath)
 
-        const firstForeignKey =
-          belongsToManyRelation.firstForeignKey || `${modelName.toLowerCase()}_${model.primaryKey}`
-        const secondForeignKey =
-          belongsToManyRelation.secondForeignKey || `${modelRelationModelName.toLowerCase()}_${model.primaryKey}`
+        if (typeof belongsToManyRelation === 'string') {
+          firstForeignKey = `${singular(modelName.toLowerCase())}_${model.primaryKey}`
+          secondForeignKey = `${singular(modelRelationModelName.toLowerCase())}_${model.primaryKey}`
+          table = getPivotTableName(formattedModelName, modelRelationTable)
+        } else {
+          firstForeignKey =
+            belongsToManyRelation.firstForeignKey || `${singular(modelName.toLowerCase())}_${model.primaryKey}`
+          secondForeignKey =
+            belongsToManyRelation.secondForeignKey ||
+            `${singular(modelRelationModelName.toLowerCase())}_${model.primaryKey}`
+          table = belongsToManyRelation?.pivotTable || getPivotTableName(formattedModelName, modelRelationTable)
+        }
 
         pivotTable.push({
-          table: belongsToManyRelation?.pivotTable || `${formattedModelName}_${modelRelationTable}`,
-          firstForeignKey: firstForeignKey,
-          secondForeignKey: secondForeignKey,
+          table,
+          firstForeignKey,
+          secondForeignKey,
         })
       }
 
@@ -239,6 +288,82 @@ export async function getPivotTables(
   return []
 }
 
+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
 }
+
+export function pluckChanges(array1: string[], array2: string[]): { added: string[]; removed: string[] } | null {
+  const removed = array1.filter((item) => !array2.includes(item))
+  const added = array2.filter((item) => !array1.includes(item))
+
+  if (removed.length === 0 && added.length === 0) {
+    return null
+  }
+
+  return { added, removed }
+}
+
+export function arrangeColumns(attributes: Attributes | undefined) {
+  if (!attributes) return []
+
+  const entries = Object.entries(attributes)
+
+  entries.sort(([keyA, valueA], [keyB, valueB]) => {
+    const orderA = valueA.order ?? Number.POSITIVE_INFINITY
+    const orderB = valueB.order ?? Number.POSITIVE_INFINITY
+    return orderA - orderB
+  })
+
+  return entries
+}
+
+export function isArrayEqual(arr1: (number | undefined)[], arr2: (number | undefined)[]): boolean {
+  if (!arr1 || !arr2) {
+    return false
+  }
+
+  if (arr1.length !== arr2.length) return false
+
+  for (let i = 0; i < arr1.length; i++) {
+    if (arr1[i] !== arr2[i]) return false
+  }
+
+  return true
+}
+
+export function findDifferingKeys(obj1: any, obj2: any): { key: string; max: number; min: number }[] {
+  const differingKeys: { key: string; max: number; min: number }[] = []
+
+  for (const key in obj1) {
+    if (obj1.hasOwnProperty(key) && obj2.hasOwnProperty(key)) {
+      const lastCharacterLength = findCharacterLength(obj1[key].validation.rule)
+      const latestCharacterLength = findCharacterLength(obj2[key].validation.rule)
+
+      if (lastCharacterLength !== undefined && latestCharacterLength !== undefined) {
+        if (
+          lastCharacterLength.max !== latestCharacterLength.max ||
+          lastCharacterLength.min !== latestCharacterLength.min
+        ) {
+          differingKeys.push({ key, max: latestCharacterLength.max, min: latestCharacterLength.min })
+        }
+      }
+    }
+  }
+
+  return differingKeys
+}

package/src/drivers/mysql.ts

@@ -1,18 +1,24 @@
 import { italic, log } from '@stacksjs/cli'
 import { db } from '@stacksjs/database'
 import { ok } from '@stacksjs/error-handling'
+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,
+  findCharacterLength,
+  findDifferingKeys,
   getLastMigrationFields,
   getPivotTables,
   hasTableBeenMigrated,
+  isArrayEqual,
   mapFieldTypeToColumnType,
+  pluckChanges,
 } from '.'
-import { getModelName, getTableName } from '@stacksjs/orm'
 
 export async function resetMysqlDatabase() {
   const tables = await fetchMysqlTables()
@@ -124,11 +130,11 @@ async function createTableMigration(modelPath: string) {
   const model = (await import(modelPath)).default as Model
   const tableName = await getTableName(model, modelPath)
 
-  await createPivotTableMigration(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
 
@@ -139,22 +145,27 @@ async function createTableMigration(modelPath: string) {
   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) =>
@@ -179,7 +190,6 @@ async function createTableMigration(modelPath: string) {
   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)}`)
@@ -209,7 +219,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}`)
@@ -222,6 +231,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
@@ -230,35 +240,97 @@ 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
 }
 
 export async function fetchMysqlTables(): Promise<string[]> {

package/src/drivers/postgres.ts

@@ -4,14 +4,17 @@ import { ok } from '@stacksjs/error-handling'
 import { getTableName } from '@stacksjs/orm'
 import { path } from '@stacksjs/path'
 import { fs, glob } from '@stacksjs/storage'
-import type { Attribute, Model } from '@stacksjs/types'
+import { snakeCase } from '@stacksjs/strings'
+import type { Attribute, Attributes, Model } from '@stacksjs/types'
 import {
+  arrangeColumns,
   checkPivotMigration,
   fetchOtherModelRelations,
   getLastMigrationFields,
   getPivotTables,
   hasTableBeenMigrated,
   mapFieldTypeToColumnType,
+  pluckChanges,
 } from '.'
 
 export async function resetPostgresDatabase() {
@@ -128,7 +131,6 @@ async function createTableMigration(modelPath: string) {
   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
 
@@ -139,16 +141,17 @@ async function createTableMigration(modelPath: string) {
   migrationContent += `    .createTable('${tableName}')\n`
   migrationContent += `    .addColumn('id', 'serial', (col) => col.primaryKey())\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.validations?.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.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 += ``
     }
 
@@ -227,11 +230,13 @@ export async function createAlterTableMigration(modelPath: string) {
   // For simplicity, this is not implemented here
   const lastMigrationFields = await getLastMigrationFields(modelName)
   const lastFields = lastMigrationFields ?? {}
-  const currentFields = model.attributes
+  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`
@@ -241,7 +246,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.validator?.rule)
+    const columnType = mapFieldTypeToColumnType(options.validations?.rule)
     migrationContent += `    .addColumn('${fieldName}', '${columnType}')\n`
   }