@stacksjs/database 0.64.6 → 0.65.0

package/src/seeder.ts

@@ -1,15 +1,12 @@
+import type { Model, RelationConfig } from '@stacksjs/types'
 import { italic, log } from '@stacksjs/cli'
 import { db } from '@stacksjs/database'
-import { modelTableName } from '@stacksjs/orm'
-import { getModelName, getTableName } from '@stacksjs/orm'
+import { fetchOtherModelRelations, modelTableName } from '@stacksjs/orm'
 import { path } from '@stacksjs/path'
-import { makeHash } from '@stacksjs/security'
-import { fs, glob } from '@stacksjs/storage'
-import { plural, singular, snakeCase } from '@stacksjs/strings'
-import type { Model, RelationConfig } from '@stacksjs/types'
-import { isString } from '@stacksjs/validation'
 
-import { generateMigrations, resetDatabase, runDatabaseMigration } from './migrations'
+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) {
@@ -17,11 +14,12 @@ async function seedModel(name: string, model?: Model) {
     return
   }
 
-  if (!model) model = (await import(path.userModelsPath(name))) as Model
+  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
+  const seedCount
+    = typeof model.traits?.useSeeder === 'object' && model.traits?.useSeeder?.count ? model.traits.useSeeder.count : 10
 
   log.info(`Seeding ${seedCount} records into ${italic(tableName)}`)
 
@@ -68,7 +66,8 @@ async function seedPivotRelation(relation: RelationConfig): Promise<any> {
   const modelInstance = (await import(path.userModelsPath(relation?.model))).default
   const relationModelInstance = (await import(path.userModelsPath(relation?.relationModel))).default
 
-  if (!relationModelInstance) return 1
+  if (!relationModelInstance)
+    return 1
 
   const relationModelTable = relationModelInstance.table
   const relationTable = relation.table
@@ -102,13 +101,15 @@ async function seedPivotRelation(relation: RelationConfig): Promise<any> {
   pivotRecord[foreignKey] = relationData
   pivotRecord[modelKey] = modelData
 
-  if (pivotTable) await db.insertInto(pivotTable).values(pivotRecord).executeTakeFirstOrThrow()
+  if (pivotTable)
+    await db.insertInto(pivotTable).values(pivotRecord).executeTakeFirstOrThrow()
 }
 
-async function seedModelRelation(modelName: string): Promise<BigInt | number> {
+async function seedModelRelation(modelName: string): Promise<bigint | number> {
   const modelInstance = (await import(path.userModelsPath(modelName))).default
 
-  if (!modelInstance) return 1
+  if (!modelInstance)
+    return 1
 
   const record: any = {}
   const table = modelInstance.table
@@ -128,87 +129,6 @@ async function seedModelRelation(modelName: string): Promise<BigInt | number> {
   return data.insertId || 1
 }
 
-export async function getRelations(model: Model, modelPath: string): Promise<RelationConfig[]> {
-  const relationsArray = ['hasOne', 'hasMany', 'belongsToMany', 'hasOneThrough']
-  const relationships = []
-
-  const modelName = getModelName(model, modelPath)
-  const tableName = getTableName(model, modelPath)
-
-  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 = modelName?.toLowerCase()
-
-        relationships.push({
-          relationship: relation,
-          model: relationModel,
-          table: modelRelation.table,
-          relationModel: modelName,
-          relationTable: tableName,
-          foreignKey: relationInstance.foreignKey || `${formattedModelName}_id`,
-          relationName: relationInstance.relationName,
-          throughModel: relationInstance.through,
-          throughForeignKey: relationInstance.throughForeignKey,
-          pivotTable: relationInstance?.pivotTable || getPivotTableName(formattedModelName || '', modelRelation.table),
-        })
-      }
-    }
-  }
-
-  return relationships
-}
-
-function getPivotTableName(formattedModelName: string, modelRelationTable: string): string {
-  // Create an array of the model names
-  const models = [formattedModelName, modelRelationTable]
-
-  // Sort the array alphabetically
-  models.sort()
-
-  models[0] = singular(models[0] || '')
-  models[1] = plural(models[1] || '')
-
-  // Join the sorted array with an underscore
-  const pivotTableName = models.join('_')
-
-  return pivotTableName
-}
-
-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, modelFileElement)
-
-    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')
@@ -236,7 +156,7 @@ export async function seed() {
 
   // otherwise, seed all models
   const modelsDir = path.userModelsPath()
-  const modelFiles = fs.readdirSync(modelsDir).filter((file) => file.endsWith('.ts'))
+  const modelFiles = fs.readdirSync(modelsDir).filter(file => file.endsWith('.ts'))
 
   for (const file of modelFiles) {
     const modelPath = path.join(modelsDir, file)

package/src/table.ts

@@ -26,7 +26,7 @@ export class Table {
 
   // Method to simulate the execution of the schema definition
   execute(): void {
-    log.info(`Creating table with columns: ${this.columns.map((col) => col.name).join(', ')}`)
+    log.info(`Creating table with columns: ${this.columns.map(col => col.name).join(', ')}`)
     // run kysely mirgration
   }
 }

package/src/types.ts

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

package/src/utils.ts

@@ -1,29 +1,34 @@
-import { database } from '@stacksjs/config'
-import { log } from '@stacksjs/logging'
 import type { Database } from '@stacksjs/orm'
-import { plural, snakeCase } from '@stacksjs/strings'
-import type { Model } from '@stacksjs/types'
+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'
 
-export function getDialect() {
+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 path = database.connections?.sqlite.database ?? 'database/stacks.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: path,
+      url: dbPath,
     })
   }
 
   if (driver === 'mysql') {
     return new MysqlDialect({
       pool: createPool({
-        database: database.connections?.mysql?.name ?? 'stacks',
+        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 ?? '',
@@ -33,9 +38,12 @@ export function getDialect() {
   }
 
   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: database.connections?.postgres?.name ?? 'stacks',
+        database: finalPgDbName, // Use modified pgDbName
         host: database.connections?.postgres?.host ?? '127.0.0.1',
         user: database.connections?.postgres?.username ?? '',
         password: database.connections?.postgres?.password ?? '',
@@ -47,8 +55,8 @@ export function getDialect() {
   throw new Error(`Unsupported driver: ${driver}`)
 }
 
-export const now = sql`now()`
+export const now: RawBuilder<any> = sql`now()`
 
-export const db = new Kysely<Database>({
+export const db: Kysely<Database> = new Kysely<Database>({
   dialect: getDialect(),
 })