chore: wip

Author: glennmichael123

app/Models/Subscriber.ts

@@ -19,6 +19,10 @@ export default {
   belongsTo: {
     model: 'User',
   },
+  belongsToMany: {
+    model: 'User',
+    pivotTable: 'user_subscribers',
+  },
 
   attributes: {
     subscribed: {

app/Models/User.ts

@@ -42,11 +42,9 @@ export default {
 
     // useUuid: true, // defaults to false
   },
-  hasOne: {
-    model: 'Subscriber',
-  },
-  hasMany: {
+  belongsToMany: {
     model: 'Subscriber',
+    pivotTable: 'user_subscribers',
   },
 
   attributes: {

database/migrations/1712833548699-create-subscribers-table.ts

@@ -18,6 +18,17 @@ export async function resetMysqlDatabase() {
   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 userModelPath = await import(userModel)
+
+    const pivotTable = await getPivotTable(userModelPath)
+
+    if (pivotTable)
+      await db.schema.dropTable(pivotTable).ifExists().execute()
+  }
+
   if (modelFiles.length) {
     for (const modelFile of modelFiles) {
       if (modelFile.endsWith('.ts')) {
@@ -108,12 +119,30 @@ export async function generateMysqlMigration(modelPath: string) {
     await createTableMigration(modelPath)
 }
 
+async function getPivotTable(model: any): Promise<string> {
+  if ('belongsToMany' in model.default) {
+    const modelRelationPath = path.userModelsPath(`${model.default.belongsToMany.model}.ts`)
+
+    const modelRelation = await import(modelRelationPath)
+
+    const formattedModelName = model.default.name.toLowerCase()
+
+    const pivotTable = model.default.belongsToMany?.pivotTable || `${formattedModelName}_${modelRelation.default.table}`
+
+    return pivotTable
+  }
+
+  return ''
+}
+
 async function createTableMigration(modelPath: string) {
   log.debug('createTableMigration modelPath:', modelPath)
 
   const model = await import(modelPath)
   const tableName = model.default.table
 
+  await createPivotTableMigration(model)
+
   const fields = model.default.attributes
   const useTimestamps = model.default?.traits?.useTimestamps ?? model.default?.traits?.timestampable
   const useSoftDeletes = model.default?.traits?.useSoftDeletes ?? model.default?.traits?.softDeletable
@@ -166,6 +195,33 @@ async function createTableMigration(modelPath: string) {
   log.success(`Created migration: ${migrationFileName}`)
 }
 
+async function createPivotTableMigration(model: any) {
+  const pivotTable = await getPivotTable(model)
+
+  if (!pivotTable)
+    return
+
+  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('${pivotTable}')\n`
+  migrationContent += `    .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())\n`
+  migrationContent += `    .addColumn('user_id', 'integer')\n`
+  migrationContent += `    .addColumn('subscriber_id', 'integer')\n`
+  migrationContent += `    .execute()\n`
+  migrationContent += `    }\n`
+
+  const timestamp = new Date().getTime().toString()
+  const migrationFileName = `${timestamp}-create-${pivotTable}-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: ${migrationFileName}`)
+}
+
 export async function createAlterTableMigration(modelPath: string) {
   // eslint-disable-next-line no-console
   console.log('createAlterTableMigration')

database/migrations/1712833548712-create-users-table.ts

@@ -43,7 +43,7 @@ async function initiateModelGeneration(): Promise<void> {
 }
 
 async function getRelations(model: any) {
-  const relationsArray = ['hasOne', 'belongsTo', 'hasMany']
+  const relationsArray = ['hasOne', 'belongsTo', 'hasMany', 'belongsToMany']
 
   const relationships = []
 
@@ -53,8 +53,15 @@ async function getRelations(model: any) {
 
       const modelRelation = await import(modelRelationPath)
 
-      // const formattedRelations = model.default[relation].toLowerCase()
-      relationships.push({ relationship: relation, model: model.default[relation].model, table: modelRelation.default.table })
+      const formattedModelName = model.default.name.toLowerCase()
+
+      relationships.push({
+        relationship: relation,
+        model: model.default[relation].model,
+        table: modelRelation.default.table,
+        foreignKey: model.default[relation].foreignKey || `${formattedModelName}_id`,
+        pivotTable: model.default[relation]?.pivotTable || `${formattedModelName}_${modelRelation.default.table}`,
+      })
     }
   }
 
@@ -229,8 +236,11 @@ async function generateModelString(tableName: string, model: any, attributes: Mo
 
   for (const relation of relations) {
     const modelRelation = relation.model
+    const foreignKeyRelation = relation.foreignKey
     const tableRelation = relation.table
+    const pivotTableRelation = relation.pivotTable
     const formattedModelRelation = modelRelation.toLowerCase()
+    const capitalizeTableRelation = tableRelation.charAt(0).toUpperCase() + tableRelation.slice(1)
 
     const relationType = getRelationType(relation.relationship)
     const relationCount = getRelationCount(relation.relationship)
@@ -242,7 +252,7 @@ async function generateModelString(tableName: string, model: any, attributes: Mo
           throw new Error('Relation Error!')
 
         const results = await db.selectFrom('${tableRelation}')
-          .where('${formattedModelName}_id', '=', this.${formattedModelName}.id)
+          .where('${foreignKeyRelation}', '=', this.${formattedModelName}.id)
           .selectAll()
           .execute()
 
@@ -257,7 +267,7 @@ async function generateModelString(tableName: string, model: any, attributes: Mo
           throw new Error('Relation Error!')
 
         const model = await db.selectFrom('${tableRelation}')
-        .where('${formattedModelName}_id', '=', this.${formattedModelName}.id)
+        .where('${foreignKeyRelation}', '=', this.${formattedModelName}.id)
         .selectAll()
         .executeTakeFirst()
 
@@ -268,14 +278,14 @@ async function generateModelString(tableName: string, model: any, attributes: Mo
       }\n\n`
     }
 
-    if (relationType === 'belongsType') {
+    if (relationType === 'belongsType' && !relationCount) {
       relationMethods += `
       async ${formattedModelRelation}() {
-        if (this.${formattedModelName}.${formattedModelRelation}_id === undefined)
+        if (this.${foreignKeyRelation} === undefined)
           throw new Error('Relation Error!')
 
         const model = await db.selectFrom('${tableRelation}')
-        .where('id', '=', this.${formattedModelName}.${formattedModelRelation}_id)
+        .where('id', '=', ${foreignKeyRelation})
         .selectAll()
         .executeTakeFirst()
 
@@ -285,6 +295,23 @@ async function generateModelString(tableName: string, model: any, attributes: Mo
         return new ${modelRelation}.modelInstance(model)
       }\n\n`
     }
+
+    if (relationType === 'belongsType' && relationCount === 'many') {
+      const pivotTable = pivotTableRelation || tableRelation
+
+      relationMethods += `
+      async ${formattedModelName}${capitalizeTableRelation}() {
+        if (this.${formattedModelName}.id === undefined)
+          throw new Error('Relation Error!')
+        
+        const results = await db.selectFrom('${pivotTable}')
+          .where('${foreignKeyRelation}', '=', this.${formattedModelName}.id)
+          .selectAll()
+          .execute()
+
+          return results
+      }\n\n`
+    }
   }
 
   for (const attribute of attributes)

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

@@ -73,7 +73,12 @@ export interface ModelOptions extends Base {
     model: string // should be typed as ModelName
     foreignKey?: string
   } // belongsTo: 'User'
-  belongsToMany: object
+  belongsToMany: {
+    model: string
+    firstForeignKey?: string
+    secondForeignKey?: string
+    pivotTable?: string
+  }
   hasThrough: {
     model: string // should be typed as ModelName
     through: string

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

@@ -16,7 +16,13 @@ export default {
   },
 
   // relationships
-  belongsTo: 'User',
+  belongsTo: {
+    model: 'User',
+  },
+  belongsToMany: {
+    model: 'User',
+    pivotTable: 'user_subscribers',
+  },
 
   attributes: {
     subscribed: {
@@ -27,13 +33,12 @@ export default {
 
       factory: () => faker.datatype.boolean(),
     },
+
     user_id: {
       validator: {
         rule: schema.number(),
         message: '',
       },
-
-      factory: () => faker.datatype.boolean(),
     },
   },
 } satisfies Model

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

@@ -42,6 +42,10 @@ export default {
 
     // useUuid: true, // defaults to false
   },
+  belongsToMany: {
+    model: 'Subscriber',
+    pivotTable: 'user_subscribers',
+  },
 
   attributes: {
     name: {