@stacksjs/database 0.62.0 → 0.63.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/database",
   "type": "module",
-  "version": "0.62.0",
+  "version": "0.63.0",
   "description": "The Stacks database integration.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -71,14 +71,14 @@
     "kysely-bun-worker": "^0.6.2"
   },
   "optionalDependencies": {
-    "mysql2": "^3.10.2"
+    "mysql2": "^3.11.0"
   },
   "devDependencies": {
     "@stacksjs/development": "latest",
     "@types/tar": "^6.1.13",
-    "debug": "^4.3.5",
+    "debug": "^4.3.6",
     "mkdirp": "^3.0.1",
     "q": "^1.5.1",
-    "tar": "^7.4.0"
+    "tar": "^7.4.3"
   }
 }

package/src/drivers/index.ts

@@ -240,7 +240,8 @@ export async function getPivotTables(
 ): Promise<{ table: string; firstForeignKey: string | undefined; secondForeignKey: string | undefined }[]> {
   const pivotTable = []
 
-  const modelName = getTableName(model, modelPath)
+  const tableName = getTableName(model, modelPath)
+
   let firstForeignKey = ''
   let secondForeignKey = ''
   let table = ''
@@ -256,22 +257,21 @@ export async function getPivotTables(
         }
 
         const modelRelation = (await import(modelRelationPath)).default
-        const formattedModelName = modelName.toLowerCase()
+        const formattedTableName = tableName.toLowerCase()
 
         const modelRelationTable = getTableName(modelRelation, modelRelationPath)
-        const modelRelationModelName = getModelName(modelRelation, modelRelationPath)
+        // const modelRelationModelName = getModelName(modelRelation, modelRelationPath)
 
         if (typeof belongsToManyRelation === 'string') {
-          firstForeignKey = `${singular(modelName.toLowerCase())}_${model.primaryKey}`
-          secondForeignKey = `${singular(modelRelationModelName.toLowerCase())}_${model.primaryKey}`
-          table = getPivotTableName(formattedModelName, modelRelationTable)
+          firstForeignKey = `${singular(tableName.toLowerCase())}_${model.primaryKey}`
+          secondForeignKey = `${singular(modelRelationTable)}_${model.primaryKey}`
+          table = getPivotTableName(formattedTableName, modelRelationTable)
         } else {
           firstForeignKey =
-            belongsToManyRelation.firstForeignKey || `${singular(modelName.toLowerCase())}_${model.primaryKey}`
+            belongsToManyRelation.firstForeignKey || `${singular(tableName.toLowerCase())}_${model.primaryKey}`
           secondForeignKey =
-            belongsToManyRelation.secondForeignKey ||
-            `${singular(modelRelationModelName.toLowerCase())}_${model.primaryKey}`
-          table = belongsToManyRelation?.pivotTable || getPivotTableName(formattedModelName, modelRelationTable)
+            belongsToManyRelation.secondForeignKey || `${singular(modelRelationTable)}_${model.primaryKey}`
+          table = belongsToManyRelation?.pivotTable || getPivotTableName(formattedTableName, modelRelationTable)
         }
 
         pivotTable.push({
@@ -296,6 +296,7 @@ function getPivotTableName(formattedModelName: string, modelRelationTable: strin
   models.sort()
 
   models[0] = singular(models[0] || '')
+  models[1] = plural(models[1] || '')
 
   // Join the sorted array with an underscore
   const pivotTableName = models.join('_')
@@ -350,7 +351,7 @@ export function findDifferingKeys(obj1: any, obj2: any): { key: string; max: num
   const differingKeys: { key: string; max: number; min: number }[] = []
 
   for (const key in obj1) {
-    if (obj1.hasOwnProperty(key) && obj2.hasOwnProperty(key)) {
+    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)
 

package/src/drivers/mysql.ts

@@ -67,20 +67,20 @@ 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...')
+  // 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'))
+  //   // 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...')
+  //   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}`))
-      }
-    }
-  }
+  //     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)
@@ -177,7 +177,7 @@ async function createTableMigration(modelPath: string) {
   // 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`
+    migrationContent += `    .addColumn('updated_at', 'timestamp', col => col.notNull().defaultTo(sql.raw('CURRENT_TIMESTAMP')))\n`
   }
 
   // Append deleted_at column if useSoftDeletes is true

package/src/drivers/sqlite.ts

@@ -120,14 +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 useTimestamps = model?.traits?.useTimestamps ?? model?.traits?.timestampable ?? true
   const useSoftDeletes = model?.traits?.useSoftDeletes ?? model?.traits?.softDeletable ?? false
 
@@ -140,24 +143,29 @@ async function createTableMigration(modelPath: string): Promise<void> {
 
   for (const [fieldName, options] of arrangeColumns(model.attributes)) {
     const fieldOptions = options as Attribute
-    const columnType = mapFieldTypeToColumnType(fieldOptions.validations?.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.validations?.rule?.required) {
+    if (fieldOptions.unique || fieldOptions?.required) {
       migrationContent += `, col => col`
       if (fieldOptions.unique) migrationContent += `.unique()`
-      if (fieldOptions.validations?.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`
     }
   }
@@ -178,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)}`)
@@ -208,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}`)
@@ -222,12 +228,15 @@ export async function createAlterTableMigration(modelPath: string) {
   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 changes = pluckChanges(Object.keys(lastFields), Object.keys(currentFields))
 
   const fieldsToAdd = changes?.added || []
@@ -237,7 +246,6 @@ export async function createAlterTableMigration(modelPath: string) {
   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
@@ -273,6 +281,7 @@ export async function createAlterTableMigration(modelPath: string) {
 
     migrationContent += `)\n\n`
   }
+
   // Remove fields that no longer exist
   for (const fieldName of fieldsToRemove) migrationContent += `    .dropColumn('${fieldName}')\n`
 
@@ -286,8 +295,6 @@ export async function createAlterTableMigration(modelPath: string) {
     migrationContent += reArrangeColumns(model.attributes, tableName)
   }
 
-  migrationContent += `    .execute();\n`
-
   migrationContent += `}\n`
 
   const timestamp = new Date().getTime().toString()
@@ -299,25 +306,25 @@ export async function createAlterTableMigration(modelPath: string) {
 
     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)
+function reArrangeColumns(attributes: Attributes | undefined, tableName: string): string {
+  const fields = arrangeColumns(attributes)
+  let migrationContent = ''
 
-      if (previousField) {
-        migrationContent += `await sql\`
-          ALTER TABLE ${tableName}
-          MODIFY COLUMN ${fieldNameFormatted} VARCHAR(255) NOT NULL AFTER ${snakeCase(previousField)};
-        \`.execute(db)\n\n`
-      }
+  let previousField = ''
+  for (const [fieldName, options] of fields) {
+    const fieldNameFormatted = snakeCase(fieldName)
 
-      previousField = fieldNameFormatted
+    if (previousField) {
+      migrationContent += `await sql\`
+        ALTER TABLE ${tableName}
+        MODIFY COLUMN ${fieldNameFormatted} VARCHAR(255) NOT NULL AFTER ${snakeCase(previousField)};
+      \`.execute(db)\n\n`
     }
 
-    return migrationContent
+    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 { singular, 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,8 +28,6 @@ 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 = {}
 
@@ -35,13 +36,19 @@ async function seedModel(name: string, model?: Model) {
       const field = model.attributes[fieldName]
 
       // Use the factory function if available, otherwise leave the field undefined
-      record[formattedFieldName] = 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)
       }
     }
@@ -53,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
 
@@ -65,7 +117,10 @@ async function seedModelRelation(modelName: string): Promise<BigInt | number> {
     const formattedFieldName = snakeCase(fieldName)
     const field = modelInstance.attributes[fieldName]
     // Use the factory function if available, otherwise leave the field undefined
-    record[formattedFieldName] = 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()
@@ -73,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]) {
@@ -88,18 +146,18 @@ 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 || '',
+          relationName: relationInstance.relationName,
+          throughModel: relationInstance.through,
+          throughForeignKey: relationInstance.throughForeignKey,
           pivotTable: relationInstance?.pivotTable || getPivotTableName(formattedModelName || '', modelRelation.table),
         })
       }
@@ -117,6 +175,7 @@ function getPivotTableName(formattedModelName: string, modelRelationTable: strin
   models.sort()
 
   models[0] = singular(models[0] || '')
+  models[1] = plural(models[1] || '')
 
   // Join the sorted array with an underscore
   const pivotTableName = models.join('_')
@@ -134,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
 
@@ -152,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'