@stacksjs/database 0.59.11 → 0.61.1

package/src/drivers/postgres.ts

@@ -0,0 +1,277 @@
+import { italic, log } from '@stacksjs/cli'
+import { db } from '@stacksjs/database'
+import { ok } from '@stacksjs/error-handling'
+import { modelTableName } from '@stacksjs/orm'
+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,
+} from '.'
+
+export async function resetPostgresDatabase() {
+  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 userModelPath = await import(userModel)
+
+    const pivotTables = await getPivotTables(userModelPath)
+
+    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 generatePostgresMigration(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)
+
+  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', 'serial', (col) => col.primaryKey())\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').notNull()
+      ) \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: any) {
+  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 += `import { sql } from '@stacksjs/database'\n\n`
+    migrationContent += `export async function up(db: Database<any>) {\n`
+    migrationContent += `  await db.schema\n`
+    migrationContent += `    .createTable('${pivotTable.table}')\n`
+    migrationContent += `    .addColumn('id', 'serial', (col) => col.primaryKey())\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}-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 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
+
+  // 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)
+
+    const tableName = await modelTableName(model)
+
+    tables.push(tableName)
+  }
+
+  return tables
+}

package/src/drivers/sqlite.ts

@@ -0,0 +1,257 @@
+import { italic, log } from '@stacksjs/cli'
+import { db } from '@stacksjs/database'
+import { ok } from '@stacksjs/error-handling'
+import { modelTableName } from '@stacksjs/orm'
+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,
+} from '.'
+
+export async function resetSqliteDatabase() {
+  const dbPath = path.userDatabasePath('stacks.sqlite')
+
+  if (fs.existsSync(dbPath)) await Bun.$`rm ${dbPath}`
+
+  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 pivotTables = await getPivotTables(userModelPath)
+
+    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 generateSqliteMigration(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.debug(`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)
+
+  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 = 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').notNull()
+      ) \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)}`)
+}

package/src/index.ts

@@ -1,67 +1,5 @@
-// export * from './seeder''
-import { Kysely, MysqlDialect } from 'kysely'
-import { createPool } from 'mysql2'
-import type { ColumnType, Generated } from 'kysely'
-import { BunWorkerDialect } from './kysely-bun-worker'
-
 export * from './schema'
 export * from './migrations'
+export * from './seeder'
 export * from './types'
 export * from './utils'
-
-// const driver = config.database.default
-const driver = 'mysql'
-
-// const dbName = config.database.name
-
-export interface UsersTable {
-  // Columns that are generated by the database should be marked
-  // using the `Generated` type. This way they are automatically
-  // made optional in inserts and updates.
-  id: Generated<number>
-
-  name: string
-  email: string
-
-  // If the column is nullable in the database, make its type nullable.
-  // Don't use optional properties. Optionality is always determined
-  // automatically by Kysely.
-  password: string
-
-  // You can specify a different type for each operation (select, insert and
-  // update) using the `ColumnType<SelectType, InsertType, UpdateType>`
-  // wrapper. Here we define a column `created_at` that is selected as
-  // a `Date`, can optionally be provided as a `string` in inserts and
-  // can never be updated:
-  created_at: ColumnType<Date, string | undefined, never>
-  deleted_at: ColumnType<Date, string | undefined, never>
-}
-
-export interface Database {
-  users: UsersTable
-}
-
-let dialect
-
-if (driver === 'sqlite') {
-  dialect = new BunWorkerDialect({
-    url: 'stacks.sqlite',
-  })
-}
-else {
-  dialect = new MysqlDialect({
-    pool: createPool({
-      database: 'stacks',
-      host: '127.0.0.1',
-      user: 'root',
-      password: '',
-      port: 3306,
-    }),
-  })
-}
-
-export const db = new Kysely<Database>({
-  dialect,
-})
-
-export const dbDialect = dialect