@stacksjs/database 0.66.0 → 0.67.0

package/src/column.ts

@@ -1,36 +0,0 @@
-interface Options {
-  notNull?: boolean
-  default?: any
-  primaryKey?: boolean
-  autoIncrement?: boolean
-}
-
-type ColumnType = 'integer' | 'varchar' | 'timestamp' | `varchar(${number})`
-
-export class Column {
-  constructor(
-    public name: string,
-    public type: ColumnType,
-    public options: Options = {},
-  ) {}
-
-  notNullable(): this {
-    this.options.notNull = true
-    return this
-  }
-
-  defaultTo(value: any): this {
-    this.options.default = value
-    return this
-  }
-
-  primary(): this {
-    this.options.primaryKey = true
-    return this
-  }
-
-  autoIncrement(): this {
-    this.options.autoIncrement = true
-    return this
-  }
-}

package/src/drivers/index.ts

@@ -1,258 +0,0 @@
-import type { Attribute, Attributes, Model, VineType } from '@stacksjs/types'
-import { log } from '@stacksjs/cli'
-import { db } from '@stacksjs/database'
-import { handleError } from '@stacksjs/error-handling'
-import { getTableName } from '@stacksjs/orm'
-import { path } from '@stacksjs/path'
-import { fs, globSync } from '@stacksjs/storage'
-import { plural, snakeCase } from '@stacksjs/strings'
-
-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
-  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 modelTableName(model: Model | string): Promise<string> {
-  if (typeof model === 'string') {
-    model = (await import(model)).default as Model
-  }
-
-  return model.table ?? snakeCase(plural(model?.name || ''))
-}
-
-export async function hasTableBeenMigrated(tableName: string): Promise<boolean> {
-  log.debug(`hasTableBeenMigrated for table: ${tableName}`)
-
-  const results = await getExecutedMigrations()
-
-  return results.some(migration => migration.name.includes(tableName))
-}
-
-export async function getExecutedMigrations(): Promise<{ name: string }[]> {
-  try {
-    return await db.selectFrom('migrations').select('name').execute()
-  }
-
-  catch (error) {
-    handleError(error, { shouldExitProcess: false })
-    return []
-  }
-}
-
-function hasFunction(rule: VineType, functionName: string): boolean {
-  return typeof rule[functionName] === 'function'
-}
-
-export function mapFieldTypeToColumnType(rule: VineType, driver = 'mysql'): string {
-  if (hasFunction(rule, 'getChoices')) {
-    if (driver === 'sqlite') {
-      return `'text'`
-    }
-
-    // Condition checker if an attribute is enum, could not think any conditions atm
-    const enumChoices = rule.getChoices() as string[]
-
-    // Convert each string value to its corresponding string structure
-    const enumStructure = enumChoices.map(value => `'${value}'`).join(', ')
-
-    // Construct the ENUM definition
-    const enumDefinition = `sql\`enum(${enumStructure})\``
-
-    return enumDefinition
-  }
-
-  if (rule[Symbol.for('schema_name')].includes('string'))
-    // Default column type for strings
-    return prepareTextColumnType(rule)
-
-  if (rule[Symbol.for('schema_name')].includes('number'))
-    return `'integer'`
-  if (rule[Symbol.for('schema_name')].includes('boolean'))
-    return `'boolean'`
-  if (rule[Symbol.for('schema_name')].includes('date'))
-    return `'date'`
-
-  // need to now handle all other types
-
-  // Add cases for other types as needed, similar to the original function
-  switch (rule) {
-    case 'integer':
-      return `'int'`
-    case 'boolean':
-      return `'boolean'`
-    case 'date':
-      return `'date'`
-    case 'datetime':
-      return `'timestamp'`
-    case 'float':
-      return `'float'`
-    case 'decimal':
-      return `'decimal'`
-    default:
-      return `'text'` // Fallback for unknown types
-  }
-}
-
-export function prepareTextColumnType(rule: VineType) {
-  let columnType = 'varchar(255)'
-
-  // 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 there's a max length validation, adjust the column type accordingly
-  if (maxLengthValidation) {
-    const maxLength = maxLengthValidation.options.max
-
-    columnType = `varchar(${maxLength})`
-  }
-
-  // If there's only a min length validation and no max, consider using text
-  // This is a simplistic approach; adjust based on your actual requirements
-  if (minLengthValidation && !maxLengthValidation)
-    columnType = 'text'
-
-  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())
-
-  return files.some((migrationFile) => {
-    // Escape special characters in the dynamic part to ensure it's treated as a literal string
-    const escapedDynamicPart = dynamicPart.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-
-    // Construct the regular expression pattern dynamically
-    const pattern = new RegExp(`(-${escapedDynamicPart}-)`)
-
-    // Test if the input string matches the pattern
-    return pattern.test(migrationFile)
-  })
-}
-
-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): Array<[string, Attribute]> {
-  if (!attributes)
-    return []
-
-  const entries = Object.entries(attributes)
-
-  // Sort the entries based on the 'order' property
-
-  // eslint-disable-next-line unused-imports/no-unused-vars
-  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 // Return the sorted key-value pairs
-}
-
-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 (Object.prototype.hasOwnProperty.call(obj1, key) && Object.prototype.hasOwnProperty.call(obj2, 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
-}
-
-export async function fetchTables(): Promise<string[]> {
-  const modelFiles = globSync(path.userModelsPath('*.ts'), { absolute: true })
-
-  const tables: string[] = []
-
-  for (const modelPath of modelFiles) {
-    const model = (await import(modelPath)).default as Model
-    const tableName = getTableName(model, modelPath)
-
-    tables.push(tableName)
-  }
-
-  return tables
-}

package/src/drivers/mysql.ts

@@ -1,389 +0,0 @@
-import type { Attribute, Attributes, Model } from '@stacksjs/types'
-import { italic, log } from '@stacksjs/cli'
-import { db } from '@stacksjs/database'
-import { type Ok, ok } from '@stacksjs/error-handling'
-import { fetchOtherModelRelations, getModelName, getPivotTables, getTableName } from '@stacksjs/orm'
-import { path } from '@stacksjs/path'
-
-import { fs, globSync } from '@stacksjs/storage'
-import { snakeCase } from '@stacksjs/strings'
-import {
-  arrangeColumns,
-  checkPivotMigration,
-  fetchTables,
-  findDifferingKeys,
-  getLastMigrationFields,
-  hasTableBeenMigrated,
-  isArrayEqual,
-  mapFieldTypeToColumnType,
-  pluckChanges,
-} from '.'
-
-export async function resetMysqlDatabase(): Promise<Ok<string, never>> {
-  const tables = await fetchTables()
-
-  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('migrations').ifExists().execute()
-
-  const files = await fs.readdir(path.userMigrationsPath())
-  const modelFiles = await fs.readdir(path.frameworkPath('database/models'))
-  const userModelFiles = globSync([path.userModelsPath('*.ts')], { absolute: true })
-
-  for (const userModel of userModelFiles) {
-    const model = (await import(userModel)).default as Model
-    const pivotTables = await getPivotTables(model, userModel)
-
-    for (const pivotTable of pivotTables) await db.schema.dropTable(pivotTable.table).ifExists().execute()
-  }
-
-  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 (files.length) {
-    for (const file of files) {
-      if (file.endsWith('.ts')) {
-        const migrationPath = path.userMigrationsPath(`${file}`)
-
-        if (fs.existsSync(migrationPath))
-          await Bun.$`rm ${migrationPath}`
-      }
-    }
-  }
-
-  return ok('All tables dropped successfully!')
-}
-
-export async function generateMysqlMigration(modelPath: string): Promise<void> {
-  // check if any files are in the database folder
-  // 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...')
-
-  //   // 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...')
-
-  //     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)
-  const tableName = getTableName(model, modelPath)
-
-  const fieldsString = JSON.stringify(model.attributes, null, 2) // Pretty print the JSON
-  const copiedModelPath = path.frameworkPath(`database/models/${fileName}`)
-
-  let haveFieldsChanged = false
-
-  // if the file exists, we need to check if the fields have changed
-  if (fs.existsSync(copiedModelPath)) {
-    log.info(`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
-    }
-
-    haveFieldsChanged = true
-    log.debug(`Fields have changed for ${tableName}`)
-  }
-  else {
-    log.debug(`Fields have not been generated for ${tableName}`)
-  }
-
-  // store the fields of the model to a file
-  await Bun.$`cp ${modelPath} ${copiedModelPath}`
-
-  // if the fields have changed, we need to create a new update migration
-  // if the fields have not changed, we need to migrate the table
-
-  // we need to check if this tableName has already been migrated
-  const hasBeenMigrated = await hasTableBeenMigrated(tableName as string)
-
-  log.debug(`Has ${tableName} been migrated? ${hasBeenMigrated}`)
-
-  if (haveFieldsChanged)
-    await createAlterTableMigration(modelPath)
-  else await createTableMigration(modelPath)
-}
-
-async function createTableMigration(modelPath: string): Promise<void> {
-  log.debug('createTableMigration modelPath:', modelPath)
-
-  const model = (await import(modelPath)).default as Model
-  const tableName = getTableName(model, modelPath)
-
-  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)
-
-  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`
-  migrationContent += `  await db.schema\n`
-  migrationContent += `    .createTable('${tableName}')\n`
-  migrationContent += `    .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())\n`
-
-  for (const [fieldName, options] of arrangeColumns(model.attributes)) {
-    const fieldOptions = options as Attribute
-    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?.required) {
-      migrationContent += `, col => col`
-      if (fieldOptions.unique)
-        migrationContent += `.unique()`
-      if (fieldOptions?.required)
-        migrationContent += `.notNull()`
-      migrationContent += ``
-    }
-
-    migrationContent += `)\n`
-  }
-
-  if (twoFactorEnabled !== false && 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')
-      ) \n`
-    }
-  }
-
-  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`
-  }
-
-  // Append deleted_at column if useSoftDeletes is true
-  if (useSoftDeletes)
-    migrationContent += `    .addColumn('deleted_at', 'timestamp')\n`
-
-  migrationContent += `    .execute()\n`
-  migrationContent += `}\n`
-
-  const timestamp = new Date().getTime().toString()
-  const migrationFileName = `${timestamp}-create-${tableName}-table.ts`
-  const migrationFilePath = path.userMigrationsPath(migrationFileName)
-
-  // eslint-disable-next-line no-console
-  console.log(migrationFilePath)
-
-  Bun.write(migrationFilePath, migrationContent)
-
-  log.success(`Created migration: ${italic(migrationFileName)}`)
-}
-
-async function createPasskeyMigration() {
-  const hasBeenMigrated = await hasTableBeenMigrated('users')
-
-  if (hasBeenMigrated)
-    return
-
-  let migrationContent = `import type { Database } from '@stacksjs/database'\n`
-  migrationContent += `export async function up(db: Database<any>) {\n`
-  migrationContent += `  await db.schema\n`
-  migrationContent += `    .createTable('passkeys')\n`
-  migrationContent += `    .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())\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('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 createPivotTableMigration(model: Model, modelPath: string): Promise<void> {
-  const pivotTables = await getPivotTables(model, modelPath)
-
-  if (!pivotTables.length)
-    return
-
-  for (const pivotTable of pivotTables) {
-    const hasBeenMigrated = await checkPivotMigration(pivotTable.table)
-
-    if (hasBeenMigrated)
-      return
-
-    let migrationContent = `import type { Database } from '@stacksjs/database'\n`
-    migrationContent += `export async function up(db: Database<any>) {\n`
-    migrationContent += `  await db.schema\n`
-    migrationContent += `    .createTable('${pivotTable.table}')\n`
-    migrationContent += `    .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())\n`
-    migrationContent += `    .addColumn('${pivotTable.firstForeignKey}', 'integer')\n`
-    migrationContent += `    .addColumn('${pivotTable.secondForeignKey}', 'integer')\n`
-    migrationContent += `    .execute()\n`
-    migrationContent += `    }\n`
-
-    const timestamp = new Date().getTime().toString()
-    const migrationFileName = `${timestamp}-create-${pivotTable.table}-table.ts`
-
-    const migrationFilePath = path.userMigrationsPath(migrationFileName)
-
-    Bun.write(migrationFilePath, migrationContent)
-
-    log.success(`Created pivot migration: ${migrationFileName}`)
-  }
-}
-
-export async function createAlterTableMigration(modelPath: string): Promise<void> {
-  const model = (await import(modelPath)).default as Model
-  const modelName = getModelName(model, modelPath)
-  const tableName = 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 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`
-
-  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.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 += `}\n`
-
-  const timestamp = new Date().getTime().toString()
-  const migrationFileName = `${timestamp}-update-${tableName}-table.ts`
-  const migrationFilePath = path.userMigrationsPath(migrationFileName)
-
-  if (hasChanged) {
-    Bun.write(migrationFilePath, migrationContent)
-
-    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] 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
-}