@stacksjs/database 0.59.11 → 0.61.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/database",
   "type": "module",
-  "version": "0.59.11",
+  "version": "0.61.1",
   "description": "The Stacks database integration.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -21,7 +21,6 @@
     "sqlite",
     "mysql",
     "postgres",
-    "planetscale",
     "bun",
     "stacks"
   ],
@@ -58,9 +57,10 @@
     "@stacksjs/storage": "latest",
     "@stacksjs/strings": "latest",
     "@stacksjs/utils": "latest",
-    "kysely-bun-worker": "^0.5.7"
+    "kysely-bun-worker": "^0.6.1"
   },
   "dependencies": {
+    "@stacksjs/cli": "latest",
     "@stacksjs/config": "latest",
     "@stacksjs/faker": "latest",
     "@stacksjs/path": "latest",
@@ -68,12 +68,17 @@
     "@stacksjs/storage": "latest",
     "@stacksjs/strings": "latest",
     "@stacksjs/utils": "latest",
-    "kysely-bun-worker": "^0.5.7"
+    "kysely-bun-worker": "^0.6.1"
   },
   "optionalDependencies": {
-    "mysql2": "^3.9.2"
+    "mysql2": "^3.9.7"
   },
   "devDependencies": {
-    "@stacksjs/development": "latest"
+    "@stacksjs/development": "latest",
+    "@types/tar": "^6.1.13",
+    "debug": "^4.3.4",
+    "mkdirp": "^3.0.1",
+    "q": "^1.5.1",
+    "tar": "^7.1.0"
   }
 }

package/src/column.ts

@@ -5,10 +5,14 @@ interface Options {
   autoIncrement?: boolean
 }
 
-type ColumnType = 'integer' | 'varchar' | 'timestamp'
+type ColumnType = 'integer' | 'varchar' | 'timestamp' | `varchar(${number})`
 
 export class Column {
-  constructor(public name: string, public type: ColumnType, public options: Options = {}) {}
+  constructor(
+    public name: string,
+    public type: ColumnType,
+    public options: Options = {},
+  ) {}
 
   notNullable(): this {
     this.options.notNull = true

package/src/drivers/index.ts

@@ -0,0 +1,226 @@
+import { log } from '@stacksjs/cli'
+import { db } from '@stacksjs/database'
+import { path } from '@stacksjs/path'
+import { fs, glob } from '@stacksjs/storage'
+import { plural, snakeCase } from '@stacksjs/strings'
+import type { Attributes, Model, RelationConfig, VineType } from '@stacksjs/types'
+import { isString } from '@stacksjs/validation'
+
+export * from './mysql'
+export * from './postgres'
+export * from './sqlite'
+
+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) {
+  log.debug(`hasTableBeenMigrated for table: ${tableName}`)
+
+  const results = await getExecutedMigrations()
+
+  return results.some((migration) => migration.name.includes(tableName))
+}
+
+export async function getExecutedMigrations() {
+  try {
+    return await db.selectFrom('migrations').select('name').execute()
+  } catch (error) {
+    return []
+  }
+}
+
+function hasFunction(rule: VineType, functionName: string): boolean {
+  return typeof rule[functionName] === 'function'
+}
+
+export function mapFieldTypeToColumnType(rule: VineType): string {
+  if (hasFunction(rule, 'getChoices')) {
+    // 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 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 async function getRelations(model: Model): Promise<RelationConfig[]> {
+  const relationsArray = ['hasOne', 'hasMany', 'belongsToMany', 'hasOneThrough']
+  const relationships = []
+
+  for (const relation of relationsArray) {
+    if (hasRelations(model, relation)) {
+      for (const relationInstance of model[relation]) {
+        let relationModel = relationInstance.model
+
+        if (isString(relationInstance)) {
+          relationModel = relationInstance
+        }
+
+        const modelRelationPath = path.userModelsPath(`${relationModel}.ts`)
+        const modelRelation = (await import(modelRelationPath)).default
+        const formattedModelName = model.name?.toLowerCase()
+
+        relationships.push({
+          relationship: relation,
+          model: relationModel,
+          table: modelRelation.table,
+          relationModel: model.name,
+          relationTable: model.table,
+          foreignKey: relationInstance.foreignKey || `${formattedModelName}_id`,
+          relationName: relationInstance.relationName || '',
+          throughModel: relationInstance.through || '',
+          throughForeignKey: relationInstance.throughForeignKey || '',
+          pivotTable: relationInstance?.pivotTable || `${formattedModelName}_${modelRelation.table}`,
+        })
+      }
+    }
+  }
+
+  return relationships
+}
+
+export async function fetchOtherModelRelations(model: Model): Promise<RelationConfig[]> {
+  const modelFiles = glob.sync(path.userModelsPath('*.ts'))
+
+  const modelRelations = []
+
+  for (let i = 0; i < modelFiles.length; i++) {
+    const modelFileElement = modelFiles[i] as string
+
+    const modelFile = await import(modelFileElement)
+
+    if (model.name === modelFile.default.name) continue
+
+    const relations = await getRelations(modelFile.default)
+
+    if (!relations.length) continue
+
+    const relation = relations.find((relation) => relation.model === model.name)
+
+    if (relation) modelRelations.push(relation)
+  }
+
+  return modelRelations
+}
+
+export async function getPivotTables(
+  model: Model,
+): Promise<{ table: string; firstForeignKey: string | undefined; secondForeignKey: string | undefined }[]> {
+  const pivotTable = []
+
+  if (model.belongsToMany && model.name) {
+    if ('belongsToMany' in model) {
+      for (const belongsToManyRelation of model.belongsToMany) {
+        const modelRelationPath = path.userModelsPath(`${belongsToManyRelation}.ts`)
+        const modelRelation = (await import(modelRelationPath)).default
+        const formattedModelName = model.name.toLowerCase()
+
+        const firstForeignKey =
+          belongsToManyRelation.firstForeignKey || `${model.name?.toLowerCase()}_${model.primaryKey}`
+        const secondForeignKey =
+          belongsToManyRelation.secondForeignKey || `${modelRelation.name?.toLowerCase()}_${model.primaryKey}`
+
+        pivotTable.push({
+          table: belongsToManyRelation?.pivotTable || `${formattedModelName}_${modelRelation.table}`,
+          firstForeignKey: firstForeignKey,
+          secondForeignKey: secondForeignKey,
+        })
+      }
+
+      return pivotTable
+    }
+  }
+
+  return []
+}
+
+function hasRelations(obj: any, key: string): boolean {
+  return key in obj
+}

package/src/drivers/mysql.ts

@@ -0,0 +1,276 @@
+import { italic, log } from '@stacksjs/cli'
+import { db } from '@stacksjs/database'
+import { ok } from '@stacksjs/error-handling'
+import { path } from '@stacksjs/path'
+import { fs, glob } from '@stacksjs/storage'
+import type { Attribute, Attributes, Model } from '@stacksjs/types'
+import {
+  checkPivotMigration,
+  fetchOtherModelRelations,
+  getLastMigrationFields,
+  getPivotTables,
+  hasTableBeenMigrated,
+  mapFieldTypeToColumnType,
+  modelTableName,
+} from '.'
+
+export async function resetMysqlDatabase() {
+  const tables = await fetchMysqlTables()
+
+  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()
+
+  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 model = (await import(userModel)).default as Model
+    const pivotTables = await getPivotTables(model)
+
+    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) {
+  // 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 = await modelTableName(model)
+
+  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) {
+  log.debug('createTableMigration modelPath:', modelPath)
+
+  const model = (await import(modelPath)).default as Model
+  const tableName = await modelTableName(model)
+
+  await createPivotTableMigration(model)
+
+  const otherModelRelations = await fetchOtherModelRelations(model)
+
+  const fields = model.attributes
+  const useTimestamps = model?.traits?.useTimestamps ?? model?.traits?.timestampable ?? true
+  const useSoftDeletes = model?.traits?.useSoftDeletes ?? model?.traits?.softDeletable ?? false
+
+  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 Object.entries(fields)) {
+    const fieldOptions = options as Attribute
+    const columnType = mapFieldTypeToColumnType(fieldOptions.validator?.rule)
+    migrationContent += `    .addColumn('${fieldName}', ${columnType}`
+
+    // Check if there are configurations that require the lambda function
+    if (fieldOptions.unique || fieldOptions.validator?.rule?.required) {
+      migrationContent += `, col => col`
+      if (fieldOptions.unique) migrationContent += `.unique()`
+      if (fieldOptions.validator?.rule?.required) migrationContent += `.notNull()`
+      migrationContent += ``
+    }
+
+    migrationContent += `)\n`
+  }
+
+  if (otherModelRelations?.length) {
+    for (const modelRelation of otherModelRelations) {
+      migrationContent += `    .addColumn('${modelRelation.foreignKey}', 'integer', (col) =>
+        col.references('${modelRelation.relationTable}.id').onDelete('cascade')
+      ) \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)
+
+  // Assuming fs.writeFileSync is available or use an equivalent method
+  Bun.write(migrationFilePath, migrationContent)
+
+  log.success(`Created migration: ${italic(migrationFileName)}`)
+}
+
+async function createPivotTableMigration(model: Model) {
+  const pivotTables = await getPivotTables(model)
+
+  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)
+
+    // Assuming fs.writeFileSync is available or use an equivalent method
+    Bun.write(migrationFilePath, migrationContent)
+
+    log.success(`Created pivot migration: ${migrationFileName}`)
+  }
+}
+
+export async function createAlterTableMigration(modelPath: string) {
+  console.log('createAlterTableMigration')
+
+  const model = (await import(modelPath)).default as Model
+  const modelName = path.basename(modelPath)
+  const tableName = await modelTableName(model)
+
+  // 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)
+
+  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`
+
+  // 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`
+  }
+
+  // Remove fields that no longer exist
+  for (const fieldName of fieldsToRemove) migrationContent += `    .dropColumn('${fieldName}')\n`
+
+  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)
+
+  log.success(`Created migration: ${italic(migrationFileName)}`)
+}
+
+export async function fetchMysqlTables(): Promise<string[]> {
+  const modelFiles = glob.sync(path.userModelsPath('*.ts'))
+  const tables: string[] = []
+
+  for (const modelPath of modelFiles) {
+    const model = (await import(modelPath)).default as Model
+    const tableName = await modelTableName(model)
+
+    tables.push(tableName)
+  }
+
+  return tables
+}