@stacksjs/database 0.65.0 → 0.67.0

package/src/seeder.ts

@@ -1,166 +0,0 @@
-import type { Model, RelationConfig } from '@stacksjs/types'
-import { italic, log } from '@stacksjs/cli'
-import { db } from '@stacksjs/database'
-import { fetchOtherModelRelations, modelTableName } from '@stacksjs/orm'
-import { path } from '@stacksjs/path'
-
-import { makeHash } from '@stacksjs/security'
-import { fs } from '@stacksjs/storage'
-import { singular, snakeCase } from '@stacksjs/strings'
-
-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)
-
-  for (let i = 0; i < seedCount; i++) {
-    const record: any = {}
-
-    for (const fieldName in model.attributes) {
-      const formattedFieldName = snakeCase(fieldName)
-      const field = model.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
-    }
-
-    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)
-      }
-    }
-
-    records.push(record)
-  }
-
-  // @ts-expect-error todo: we can improve this in the future
-  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
-
-  if (!modelInstance)
-    return 1
-
-  const record: any = {}
-  const table = modelInstance.table
-
-  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')
-      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()
-
-  return data.insertId || 1
-}
-
-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,32 +0,0 @@
-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,
-    })
-    this.columns.push(column)
-    return column
-  }
-
-  string(name: string, varchar = 255): Column {
-    const column = new Column(name, `varchar(${varchar})`)
-    this.columns.push(column)
-    return column
-  }
-
-  timestamps(): void {
-    this.columns.push(new Column('created_at', 'timestamp'))
-    this.columns.push(new Column('updated_at', 'timestamp'))
-  }
-
-  // Method to simulate the execution of the schema definition
-  execute(): void {
-    log.info(`Creating table with columns: ${this.columns.map(col => col.name).join(', ')}`)
-    // run kysely mirgration
-  }
-}

package/src/types.ts

@@ -1,5 +0,0 @@
-export { Kysely as Database } from 'kysely'
-
-export { sql } from 'kysely'
-
-export type { Generated, Insertable, Selectable, Updateable } from 'kysely'

package/src/utils.ts

@@ -1,62 +0,0 @@
-import type { Database } from '@stacksjs/orm'
-import type { RawBuilder } from 'kysely'
-import { app, database } from '@stacksjs/config'
-import { log } from '@stacksjs/logging'
-import { path } from '@stacksjs/path'
-import { Kysely, MysqlDialect, PostgresDialect, sql } from 'kysely'
-import { BunWorkerDialect } from 'kysely-bun-worker'
-import { createPool } from 'mysql2'
-import { Pool } from 'pg'
-
-const appEnv = app.env || 'local'
-
-export function getDialect(): MysqlDialect | PostgresDialect | BunWorkerDialect {
-  const driver = database.default ?? 'sqlite'
-
-  log.debug(`Using database driver: ${driver}`)
-
-  if (driver === 'sqlite') {
-    const defaultName = appEnv !== 'testing' ? 'database/stacks.sqlite' : 'database/stacks_testing.sqlite'
-    const sqliteDbName = database.connections?.sqlite.database ?? defaultName
-    const dbPath = path.projectPath(sqliteDbName)
-
-    return new BunWorkerDialect({
-      url: dbPath,
-    })
-  }
-
-  if (driver === 'mysql') {
-    return new MysqlDialect({
-      pool: createPool({
-        database: database.connections?.mysql?.name || 'stacks', // Use modified dbName
-        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') {
-    const pgDbName = database.connections?.postgres?.name ?? 'stacks' // Default Postgres database name
-    const finalPgDbName = appEnv === 'testing' ? `${pgDbName}_testing` : pgDbName // Modify if testing
-
-    return new PostgresDialect({
-      pool: new Pool({
-        database: finalPgDbName, // Use modified pgDbName
-        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: RawBuilder<any> = sql`now()`
-
-export const db: Kysely<Database> = new Kysely<Database>({
-  dialect: getDialect(),
-})