chore: wip

Author: glennmichael123

app/Models/Post.ts

@@ -32,11 +32,5 @@ export default {
 
       factory: () => faker.datatype.string(),
     },
-    subscriber_id: {
-      validator: {
-        rule: schema.number(),
-        message: '',
-      },
-    },
   },
 } satisfies Model

app/Models/Subscriber.ts

@@ -25,13 +25,6 @@ export default {
 
       factory: () => faker.datatype.boolean(),
     },
-
-    user_id: {
-      validator: {
-        rule: schema.number(),
-        message: '',
-      },
-    },
   },
 
   dashboard: {

app/Models/User.ts

@@ -40,10 +40,15 @@ export default {
     // useUuid: true, // defaults to false
   },
 
-  hasOneThrough: [
+  hasMany: [
     {
       model: Post,
-      through: Subscriber,
+    },
+  ],
+
+  hasOne: [
+    {
+      model: Subscriber,
     },
   ],
 

config/database.ts

@@ -13,7 +13,7 @@ export default {
 
   connections: {
     sqlite: {
-      database: env.DB_DATABASE || 'database/stacks.sqlite',
+      database: env.DB_DATABASE || 'stacks',
       prefix: '',
     },
 

storage/framework/core/actions/src/database/mysql.ts

@@ -3,7 +3,7 @@ import { db } from '@stacksjs/database'
 import { ok } from '@stacksjs/error-handling'
 import { path } from '@stacksjs/path'
 import { fs, glob } from '@stacksjs/storage'
-import type { Attributes } from '@stacksjs/types'
+import type { Attributes, ModelDefault, RelationConfig } from '@stacksjs/types'
 import { checkPivotMigration, getLastMigrationFields, hasTableBeenMigrated, mapFieldTypeToColumnType } from '.'
 
 export async function resetMysqlDatabase() {
@@ -15,8 +15,11 @@ export async function resetMysqlDatabase() {
   await db.schema.dropTable('migration_locks').ifExists().execute()
 
   const files = await fs.readdir(path.userMigrationsPath())
+  const filesForeign = await fs.readdir(path.userMigrationsPath('foreign'))
   const modelFiles = await fs.readdir(path.frameworkPath('database/models'))
 
+  console.log(filesForeign)
+
   const userModelFiles = glob.sync(path.userModelsPath('*.ts'))
 
   for (const userModel of userModelFiles) {
@@ -37,6 +40,14 @@ export async function resetMysqlDatabase() {
     }
   }
 
+  if (filesForeign.length) {
+    for (const foreignFile of filesForeign) {
+      const foreignPath = path.userMigrationsPath(`foreign/${foreignFile}`)
+
+      if (fs.existsSync(foreignPath)) await Bun.$`rm ${foreignPath}`
+    }
+  }
+
   if (files.length) {
     for (const file of files) {
       if (file.endsWith('.ts')) {
@@ -70,6 +81,7 @@ export async function generateMysqlMigration(modelPath: string) {
   }
 
   const model = await import(modelPath)
+
   const fileName = path.basename(modelPath)
   const tableName = model.default.table
 
@@ -107,10 +119,49 @@ export async function generateMysqlMigration(modelPath: string) {
 
   log.debug(`Has ${tableName} been migrated? ${hasBeenMigrated}`)
 
+  await createForeignKeysMigration(model)
+
   if (haveFieldsChanged) await createAlterTableMigration(modelPath)
   else await createTableMigration(modelPath)
 }
 
+
+
+async function getRelations(model: ModelDefault): Promise<RelationConfig[]> {
+  const relationsArray = ['hasOne', 'belongsTo', 'hasMany', 'belongsToMany', 'hasOneThrough']
+
+  const relationships = []
+
+  for (const relation of relationsArray) {
+    if (hasRelations(model.default, relation)) {
+      for (const relationInstance of model.default[relation]) {
+        const modelRelationPath = path.userModelsPath(`${relationInstance.model.name}.ts`)
+
+        const modelRelation = await import(modelRelationPath)
+
+        const formattedModelName = model.default.name.toLowerCase()
+
+        relationships.push({
+          relationship: relation,
+          model: relationInstance.model.name,
+          table: modelRelation.default.table,
+          foreignKey: relationInstance.foreignKey || `${formattedModelName}_id`,
+          relationName: relationInstance.relationName || '',
+          throughModel: relationInstance.through || '',
+          throughForeignKey: relationInstance.throughForeignKey || '',
+          pivotTable: relationInstance?.pivotTable || `${formattedModelName}_${modelRelation.default.table}`,
+        })
+      }
+    }
+  }
+
+  return relationships
+}
+
+function hasRelations(obj: any, key: string): boolean {
+  return key in obj
+}
+
 async function getPivotTables(
   model: any,
 ): Promise<{ table: string; firstForeignKey: string; secondForeignKey: string }[]> {
@@ -141,7 +192,7 @@ async function createTableMigration(modelPath: string) {
 
   const model = await import(modelPath)
   const tableName = model.default.table
-
+  
   await createPivotTableMigration(model)
 
   const fields = model.default.attributes
@@ -193,7 +244,7 @@ async function createTableMigration(modelPath: string) {
   log.success(`Created migration: ${migrationFileName}`)
 }
 
-async function createPivotTableMigration(model: any) {
+async function createPivotTableMigration(model: ModelDefault) {
   const pivotTables = await getPivotTables(model)
 
   if (!pivotTables.length) return
@@ -224,6 +275,28 @@ async function createPivotTableMigration(model: any) {
   }
 }
 
+async function createForeignKeysMigration(model: ModelDefault) {
+  const relations = await getRelations(model)
+
+
+  for (const relation of relations) {
+    let migrationContent = `import type { Database } from '@stacksjs/database'\n`
+    migrationContent += `export async function up(db: Database<any>) {\n`
+    migrationContent += `  await db.schema\n`
+    migrationContent += `    .alterTable('${relation.table}')\n`
+
+    migrationContent += `    .addColumn('${relation.foreignKey}', 'integer')\n`
+    migrationContent += `    .execute()\n`
+    migrationContent += `    }\n`
+
+    const timestamp = new Date().getTime().toString()
+    const migrationFileName = `${timestamp}-create-${relation.table}-foreign-table.ts`
+    const migrationFilePath = path.userMigrationsPath(`foreign/${migrationFileName}`)
+
+    Bun.write(migrationFilePath, migrationContent)
+  }
+}
+
 export async function createAlterTableMigration(modelPath: string) {
   console.log('createAlterTableMigration')
 

storage/framework/core/actions/src/migrate/database.ts

@@ -1,5 +1,5 @@
 import process from 'node:process'
-import { generateMigrations, runDatabaseMigration } from '@stacksjs/database'
+import { generateMigrations, runDatabaseMigration, runDatabaseMigrationForeign } from '@stacksjs/database'
 import { log } from '@stacksjs/logging'
 
 // this is run and checks whether new created or update migrations need to be generated
@@ -13,10 +13,19 @@ if (result?.isErr()) {
 
 const result2 = await runDatabaseMigration()
 
+
 if (result2.isErr()) {
   log.error('runDatabaseMigration failed')
   log.error(result2.error)
   process.exit(1)
 }
 
+const result3 = await runDatabaseMigrationForeign()
+
+if (result3.isErr()) {
+  log.error('runDatabaseMigration failed')
+  log.error(result3.error)
+  process.exit(1)
+}
+
 process.exit(0)

storage/framework/core/actions/src/orm/generate-model.ts

@@ -1,6 +1,6 @@
 import { path } from '@stacksjs/path'
 import { fs, glob } from '@stacksjs/storage'
-import type { ModelOptions } from '@stacksjs/types'
+import type { ModelDefault, RelationConfig } from '@stacksjs/types'
 
 export interface FieldArrayElement {
   entity: string
@@ -15,10 +15,6 @@ export interface ModelElement {
   fieldArray: FieldArrayElement | null
 }
 
-interface ModelDefault {
-  default: ModelOptions
-}
-
 await initiateModelGeneration()
 await setKyselyTypes()
 
@@ -145,7 +141,7 @@ async function initiateModelGeneration(): Promise<void> {
   }
 }
 
-async function getRelations(model: ModelDefault): Promise<any[]> {
+async function getRelations(model: ModelDefault): Promise<RelationConfig[]> {
   const relationsArray = ['hasOne', 'belongsTo', 'hasMany', 'belongsToMany', 'hasOneThrough']
 
   const relationships = []

storage/framework/core/database/src/migrations.ts

@@ -28,6 +28,17 @@ export const migrator = new Migrator({
   migrationLockTableName: database.migrationLocks,
 })
 
+const migratorForeign = new Migrator({
+  db,
+
+  provider: new FileMigrationProvider({
+    fs,
+    path,
+    // This needs to be an absolute path.
+    migrationFolder: path.userMigrationsPath('foreign'),
+  }),
+})
+
 export async function runDatabaseMigration() {
   try {
     log.info('Migrating database...')
@@ -61,6 +72,39 @@ export async function runDatabaseMigration() {
   }
 }
 
+export async function runDatabaseMigrationForeign() {
+  try {
+    log.info('Migrating database...')
+
+    const migration = await migratorForeign.migrateToLatest()
+
+    if (migration.error) {
+      log.error(migration.error)
+      return err(migration.error)
+    }
+
+    if (migration.results?.length === 0) {
+      log.success('No new migrations were executed')
+      return ok('No new migrations were executed')
+    }
+
+    if (migration.results) {
+      migration.results.forEach(({ migrationName }) => {
+        console.log(italic(`${dim(`   - Migration Name:`)} ${migrationName}`))
+      })
+
+      log.success('Database migrated successfully.')
+      return ok(migration)
+    }
+
+    log.success('Database migration completed with no new migrations.')
+    return ok('Database migration completed with no new migrations.')
+  } catch (error) {
+    console.error('Migration failed:', error)
+    return err(error)
+  }
+}
+
 export interface MigrationOptions {
   name: string
   up: string

storage/framework/core/database/src/types.ts

@@ -1 +1,3 @@
 export { Kysely as Database } from 'kysely'
+
+export { sql } from 'kysely'

storage/framework/core/types/src/model.ts

@@ -117,3 +117,19 @@ export interface Attributes {
 }
 
 export type Model = Partial<ModelOptions>
+
+
+export interface ModelDefault {
+  default: ModelOptions
+}
+
+export interface RelationConfig {
+  relationship: string;
+  model: string;
+  table: string;
+  foreignKey: string;
+  relationName: string;
+  throughModel: string;
+  throughForeignKey: string;
+  pivotTable: string;
+}