@stacksjs/database 0.59.11 → 0.61.0

package/src/migrations.ts

@@ -1,73 +1,172 @@
-import { path as p } from '@stacksjs/path'
-import { log } from '@stacksjs/cli'
+import { dim, italic, log } from '@stacksjs/cli'
+import { database } from '@stacksjs/config'
+import { err, ok } from '@stacksjs/error-handling'
+import { extractFieldsFromModel } from '@stacksjs/orm'
+import { path } from '@stacksjs/path'
+import { fs, glob } from '@stacksjs/storage'
+import type { Attribute, Attributes } from '@stacksjs/types'
+import { $ } from 'bun'
+import { FileMigrationProvider, Migrator } from 'kysely'
+import { generateMysqlMigration, resetMysqlDatabase } from './drivers'
+import { generatePostgresMigration, resetPostgresDatabase } from './drivers'
+import { generateSqliteMigration, resetSqliteDatabase } from './drivers'
+import { db } from './utils'
 
-// import { storage } from '@stacksjs/storage'
-// import type { Model, SchemaOptions } from '@stacksjs/types'
-// import { titleCase } from '@stacksjs/strings'
+const driver = database.default || ''
 
-// const { fs } = storage
+export const migrator = new Migrator({
+  db,
 
-// function readModelsFromFolder(folderPath: string): Promise<Model[]> {
-//   return new Promise((resolve, reject) => {
-//     const models: Model[] = []
+  provider: new FileMigrationProvider({
+    fs,
+    path,
+    // This needs to be an absolute path.
+    migrationFolder: path.userMigrationsPath(),
+  }),
 
-//     fs.readdir(folderPath, (err, files) => {
-//       if (err)
-//         reject(err)
+  migrationTableName: database.migrations,
+  migrationLockTableName: database.migrationLocks,
+})
 
-//       const promises = files
-//         .filter(file => file.endsWith('.ts'))
-//         .map((file) => {
-//           const filePath = `${folderPath}/${file}`
+// const migratorForeign = new Migrator({
+//   db,
 
-//           return import(filePath).then((data) => {
-//             models.push({
-//               name: data.default.name,
-//               fields: data.default.fields,
-//             })
-//           })
-//         })
+//   provider: new FileMigrationProvider({
+//     fs,
+//     path,
+//     // This needs to be an absolute path.
+//     migrationFolder: path.userMigrationsPath('foreign'),
+//   }),
+// })
 
-//       Promise.all(promises)
-//         .then(() => resolve(models))
-//         .catch(err => reject(err))
-//     })
-//   })
-// }
+export async function runDatabaseMigration() {
+  try {
+    log.info('Migrating database...')
 
-// async function migrate(path: string, options: SchemaOptions): Promise<void> {
-//   const models = await readModelsFromFolder(projectPath('app/Models'))
+    const { error, results } = await migrator.migrateToLatest()
 
-//   generatePrismaSchema(models, path, options)
-// }
+    if (error) {
+      log.error(error)
+      return err(error)
+    }
+
+    if (results?.length === 0) {
+      log.success('No new migrations were executed')
+      return ok('No new migrations were executed')
+    }
+
+    if (results) return ok(results)
+
+    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
-  down: string
 }
 
-export function generateMigrationFile(options: MigrationOptions) {
-  const { name, up, down } = options
-
-  const timestamp = new Date().getTime().toString()
-  const fileName = `${timestamp}-${name}.ts`
-  const filePath = p.frameworkPath(`database/migrations/${fileName}`)
-  const fileContent = `
-    import { Migration } from '@stacksjs/database'
-
-    export default new Migration({
-      name: '${name}',
-      up: \`
-        ${up}
-      \`,
-      down: \`
-        ${down}
-      \`,
-    })
-  `
-  // TODO: use Bun.write
-  fs.writeFileSync(filePath, fileContent)
-
-  log.info(`Created migration file: ${fileName}`)
+export async function resetDatabase() {
+  if (driver === 'sqlite') return resetSqliteDatabase()
+
+  if (driver === 'mysql') return resetMysqlDatabase()
+
+  if (driver === 'postgres') return resetPostgresDatabase()
+
+  throw new Error('Unsupported database driver in resetDatabase')
+}
+
+export async function generateMigrations() {
+  try {
+    log.info('Generating migrations...')
+
+    const modelFiles = glob.sync(path.userModelsPath('*.ts'))
+
+    for (const file of modelFiles) {
+      log.debug('Generating migration for:', file)
+      await generateMigration(file)
+    }
+
+    log.success('Migrations generated')
+    return ok('Migrations generated')
+  } catch (error) {
+    return err(error)
+  }
+}
+
+export async function generateMigration(modelPath: string) {
+  if (driver === 'sqlite') generateSqliteMigration(modelPath)
+
+  if (driver === 'mysql') generateMysqlMigration(modelPath)
+
+  if (driver === 'postgres') generatePostgresMigration(modelPath)
+}
+
+export async function getExecutedMigrations() {
+  try {
+    // @ts-expect-error the migrations table is not typed yet
+    return await db.selectFrom('migrations').select('name').execute()
+  } catch (error) {
+    return []
+  }
+}
+
+export async function haveModelFieldsChangedSinceLastMigration(modelPath: string) {
+  log.debug(`haveModelFieldsChangedSinceLastMigration for model: ${modelPath}`)
+
+  // const model = await import(modelPath)
+  // const tableName = model.default.table
+  // const lastMigration = await lastMigrationDate()
+
+  // now that we know the date, we need to check the git history for changes to the model file since that date
+  const cmd = ``
+  const gitHistory = await $`${cmd}`.text()
+
+  // if there are updates, then we need to check whether
+  // the updates include the any updates to the model
+  // fields that would require a migration
+
+  return !!gitHistory
+}
+
+export async function lastMigration() {
+  try {
+    // @ts-expect-error the migrations table is not typed yet
+    return await db.selectFrom('migrations').selectAll().orderBy('timestamp', 'desc').limit(1).execute()
+  } catch (error) {
+    console.error('Failed to get last migration:', error)
+    return { error }
+  }
+}
+
+export async function lastMigrationDate(): Promise<string | undefined> {
+  try {
+    // @ts-expect-error the migrations table is not typed yet
+    return (await db.selectFrom('migrations').select('timestamp').orderBy('timestamp', 'desc').limit(1).execute())[0]
+      .timestamp
+  } catch (error) {
+    console.error('Failed to get last migration date:', error)
+    return undefined
+  }
+}
+
+// This is a placeholder function. You need to implement the logic to
+// read the last migration file and extract the fields that were modified.
+export async function getLastMigrationFields(modelName: string): Promise<Attribute> {
+  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 getCurrentMigrationFields(modelPath: string): Promise<Attribute | undefined> {
+  return extractFieldsFromModel(modelPath)
 }

package/src/schema.ts

@@ -1,11 +1,14 @@
+import { log } from '@stacksjs/logging'
 import { Table } from './table'
 
-export class Schema {
-  static async createTable(tableName: string, callback: (table: Table) => void): Promise<void> {
+export const Schema = {
+  async createTable(tableName: string, callback: (table: Table) => void): Promise<void> {
     const table = new Table()
+
     callback(table)
+
     table.execute() // Simulate the execution of the table creation
-    // eslint-disable-next-line no-console
-    console.log(`Table "${tableName}" created.`)
-  }
+
+    log.success(`Table "${tableName}" created.`)
+  },
 }

package/src/seeder.ts

@@ -1,79 +1,169 @@
-// import { MysqlDialect, QueryBuilder, createPool } from '@stacksjs/query-builder'
-// import { filesystem } from '@stacksjs/storage'
-// import type { Model } from '@stacksjs/types'
-// import { projectPath } from '@stacksjs/path'
-// import { database as config } from '@stacksjs/config'
-
-// const { fs } = filesystem
-
-// function readModels(folderPath: string): Promise<Model[]> {
-//   return new Promise((resolve, reject) => {
-//     const models: Model[] = []
-
-//     fs.readdir(folderPath, (err, files) => {
-//       if (err)
-//         reject(err)
-
-//       const promises = files
-//         .filter(file => file.endsWith('.ts'))
-//         .map((file) => {
-//           const filePath = `${folderPath}/${file}`
-
-//           return import(filePath).then((data) => {
-//             models.push({
-//               name: data.default.name,
-//               fields: data.default.fields,
-//               useSeed: data.default.useSeed,
-//             })
-//           })
-//         })
-
-//       Promise.all(promises)
-//         .then(() => resolve(models))
-//         .catch(err => reject(err))
-//     })
-//   })
-// }
-
-async function seed() {
-  // const db = new QueryBuilder({
-  //   dialect: new MysqlDialect({
-  //     pool: createPool({
-  //       database: config.database,
-  //       host: config.host,
-  //       password: config.password,
-  //       user: config.username,
-  //     }),
-  //   }),
-  // })
-
-  // const models = await readModels(projectPath('app/Models'))
-
-  // const queries = models.flatMap((model) => {
-  //   const { seedable, fields } = model
-
-  //   if (!seedable)
-  //     return []
-
-  //   const count = typeof seedable === 'boolean' ? 10 : seedable.count
-
-  //   const records: Record<string, any>[] = []
-  //   for (let i = 0; i < count; i++) {
-  //     const record: Record<string, any> = {}
-  //     Object.entries(fields).forEach(([name, field]) => {
-  //       if (field.factory)
-  //         record[name] = field.factory()
-  //     })
-  //     records.push(record)
-  //   }
-
-  //     return model
-  //   // return db.insertInto('users').values(records).build(sql`RETURNING *`)
-  // })
-
-  // const { rows } = await db.transaction().execute()
-
-  // return rows
+import { italic, log } from '@stacksjs/cli'
+import { db } from '@stacksjs/database'
+import { modelTableName } from '@stacksjs/orm'
+import { path } from '@stacksjs/path'
+import { fs, glob } from '@stacksjs/storage'
+import { 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) {
+  if (model?.traits?.useSeeder === false || model?.traits?.seedable === false) {
+    log.info(`Skipping seeding for ${italic(name)}`)
+    return
+  }
+
+  if (!model) model = (await import(path.userModelsPath(name))) as Model
+
+  const tableName = await modelTableName(model)
+  const seedCount =
+    typeof model.traits?.useSeeder === 'object' && model.traits?.useSeeder?.count ? model.traits.useSeeder.count : 10
+
+  log.info(`Seeding ${seedCount} records into ${italic(tableName)}`)
+
+  const records = []
+  const otherRelations = await fetchOtherModelRelations(model)
+
+  log.debug(otherRelations)
+
+  for (let i = 0; i < seedCount; i++) {
+    const record: any = {}
+
+    for (const fieldName in model.attributes) {
+      const field = model.attributes[fieldName]
+      // Use the factory function if available, otherwise leave the field undefined
+      record[fieldName] = field?.factory ? field.factory() : undefined
+    }
+
+    if (otherRelations?.length) {
+      for (let j = 0; j < otherRelations.length; j++) {
+        const relationElement = otherRelations[j] as RelationConfig
+
+        record[relationElement?.foreignKey] = await seedModelRelation(relationElement?.relationModel as string)
+      }
+    }
+
+    records.push(record)
+  }
+
+  // @ts-expect-error todo: we can improve this in the future
+  await db.insertInto(tableName).values(records).execute()
 }
 
-export { seed }
+async function seedModelRelation(modelName: string): Promise<BigInt | number> {
+  const modelInstance = (await import(path.userModelsPath(modelName))).default
+
+  if (!modelInstance) return 1
+
+  const record: any = {}
+  const table = modelInstance.table
+
+  for (const fieldName in modelInstance.attributes) {
+    const field = modelInstance.attributes[fieldName]
+    // Use the factory function if available, otherwise leave the field undefined
+    record[fieldName] = field?.factory ? field.factory() : undefined
+  }
+
+  const data = await db.insertInto(table).values(record).executeTakeFirstOrThrow()
+
+  return data.insertId || 1
+}
+
+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
+}
+
+function hasRelations(obj: any, key: string): boolean {
+  return key in obj
+}
+
+export async function seed() {
+  // TODO: need to check other databases too
+  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()
+
+    // then, generate the migrations
+    await generateMigrations()
+
+    // 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')
+  if (fs.existsSync(customSeederPath)) {
+    log.info('Custom seeder found')
+    await import(customSeederPath)
+  }
+
+  // otherwise, seed all models
+  const modelsDir = path.userModelsPath()
+  const modelFiles = fs.readdirSync(modelsDir).filter((file) => file.endsWith('.ts'))
+
+  for (const file of modelFiles) {
+    const modelPath = path.join(modelsDir, file)
+    const model = await import(modelPath)
+    await seedModel(file, model.default)
+  }
+}

package/src/table.ts

@@ -1,15 +1,19 @@
+import { log } from '@stacksjs/logging'
 import { Column } from './column'
 
 export class Table {
   private columns: Column[] = []
 
   increments(name: string): Column {
-    const column = new Column(name, 'integer', { primaryKey: true, autoIncrement: true })
+    const column = new Column(name, 'integer', {
+      primaryKey: true,
+      autoIncrement: true,
+    })
     this.columns.push(column)
     return column
   }
 
-  string(name: string, varchar: number = 255): Column {
+  string(name: string, varchar = 255): Column {
     const column = new Column(name, `varchar(${varchar})`)
     this.columns.push(column)
     return column
@@ -22,8 +26,7 @@ export class Table {
 
   // Method to simulate the execution of the schema definition
   execute(): void {
-    // eslint-disable-next-line no-console
-    console.log(`Creating table with columns: ${this.columns.map(col => col.name).join(', ')}`)
-    // Here you would normally execute the SQL commands to create the table and columns in the database
+    log.info(`Creating table with columns: ${this.columns.map((col) => col.name).join(', ')}`)
+    // run kysely mirgration
   }
 }

package/src/types.ts

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

package/src/utils.ts

@@ -1,3 +1,52 @@
-import { sql } from 'kysely'
+import { database } from '@stacksjs/config'
+import { log } from '@stacksjs/logging'
+import type { Database } from '@stacksjs/orm'
+import { Kysely, MysqlDialect, PostgresDialect, sql } from 'kysely'
+import { BunWorkerDialect } from 'kysely-bun-worker'
+import { createPool } from 'mysql2'
+import { Pool } from 'pg'
+
+export function getDialect() {
+  const driver = database.default ?? 'sqlite'
+
+  log.debug(`Using database driver: ${driver}`)
+
+  if (driver === 'sqlite') {
+    const path = database.connections?.sqlite.database ?? 'database/stacks.sqlite'
+    return new BunWorkerDialect({
+      url: path,
+    })
+  }
+
+  if (driver === 'mysql') {
+    return new MysqlDialect({
+      pool: createPool({
+        database: database.connections?.mysql?.name ?? 'stacks',
+        host: database.connections?.mysql?.host ?? '127.0.0.1',
+        user: database.connections?.mysql?.username ?? 'root',
+        password: database.connections?.mysql?.password ?? '',
+        port: database.connections?.mysql?.port ?? 3306,
+      }),
+    })
+  }
+
+  if (driver === 'postgres') {
+    return new PostgresDialect({
+      pool: new Pool({
+        database: database.connections?.postgres?.name ?? 'stacks',
+        host: database.connections?.postgres?.host ?? '127.0.0.1',
+        user: database.connections?.postgres?.username ?? '',
+        password: database.connections?.postgres?.password ?? '',
+        port: database.connections?.postgres?.port ?? 5432,
+      }),
+    })
+  }
+
+  throw new Error(`Unsupported driver: ${driver}`)
+}
 
 export const now = sql`now()`
+
+export const db = new Kysely<Database>({
+  dialect: getDialect(),
+})

package/dist/column.d.ts

@@ -1,18 +0,0 @@
-interface Options {
-    notNull?: boolean;
-    default?: any;
-    primaryKey?: boolean;
-    autoIncrement?: boolean;
-}
-type ColumnType = 'integer' | 'varchar' | 'timestamp';
-export declare class Column {
-    name: string;
-    type: ColumnType;
-    options: Options;
-    constructor(name: string, type: ColumnType, options?: Options);
-    notNullable(): this;
-    defaultTo(value: any): this;
-    primary(): this;
-    autoIncrement(): this;
-}
-export {};

package/dist/index.d.ts

@@ -1,19 +0,0 @@
-import { Kysely } from 'kysely';
-import type { ColumnType, Generated } from 'kysely';
-export * from './schema';
-export * from './migrations';
-export * from './types';
-export * from './utils';
-export interface UsersTable {
-    id: Generated<number>;
-    name: string;
-    email: string;
-    password: string;
-    created_at: ColumnType<Date, string | undefined, never>;
-    deleted_at: ColumnType<Date, string | undefined, never>;
-}
-export interface Database {
-    users: UsersTable;
-}
-export declare const db: Kysely<Database>;
-export declare const dbDialect: any;

package/dist/migrations.d.ts

@@ -1,6 +0,0 @@
-export interface MigrationOptions {
-    name: string;
-    up: string;
-    down: string;
-}
-export declare function generateMigrationFile(options: MigrationOptions): void;

package/dist/schema.d.ts

@@ -1,4 +0,0 @@
-import { Table } from './table';
-export declare class Schema {
-    static createTable(tableName: string, callback: (table: Table) => void): Promise<void>;
-}

package/dist/table.d.ts

@@ -1,8 +0,0 @@
-import { Column } from './column';
-export declare class Table {
-    private columns;
-    increments(name: string): Column;
-    string(name: string, varchar?: number): Column;
-    timestamps(): void;
-    execute(): void;
-}

package/dist/types.d.ts

@@ -1 +0,0 @@
-export { Kysely as Migration } from 'kysely';

package/dist/utils.d.ts

@@ -1 +0,0 @@
-export declare const now: import("kysely").RawBuilder<unknown>;