@stacksjs/database 0.64.5 → 0.65.0

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@stacksjs/database",
   "type": "module",
-  "version": "0.64.5",
+  "version": "0.65.0",
   "description": "The Stacks database integration.",
   "author": "Chris Breuer",
+  "contributors": ["Chris Breuer <chris@stacksjs.org>"],
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
   "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/database#readme",
@@ -36,37 +37,30 @@
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "contributors": [
-    "Chris Breuer <chris@stacksjs.org>"
-  ],
-  "files": [
-    "README.md",
-    "dist",
-    "src"
-  ],
+  "files": ["README.md", "dist", "src"],
   "scripts": {
-    "build": "bun --bun build.ts",
-    "typecheck": "bun --bun tsc --noEmit",
+    "build": "bun build.ts",
+    "typecheck": "bun tsc --noEmit",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@stacksjs/cli": "latest",
-    "@stacksjs/config": "latest",
-    "@stacksjs/faker": "latest",
-    "@stacksjs/path": "latest",
-    "@stacksjs/query-builder": "latest",
-    "@stacksjs/storage": "latest",
-    "@stacksjs/strings": "latest",
-    "@stacksjs/utils": "latest",
+    "@stacksjs/cli": "0.64.6",
+    "@stacksjs/config": "0.64.6",
+    "@stacksjs/faker": "0.64.6",
+    "@stacksjs/path": "0.64.6",
+    "@stacksjs/query-builder": "0.64.6",
+    "@stacksjs/storage": "0.64.6",
+    "@stacksjs/strings": "0.64.6",
+    "@stacksjs/utils": "0.64.6",
     "kysely-bun-worker": "^0.6.3"
   },
   "optionalDependencies": {
-    "mysql2": "^3.11.0"
+    "mysql2": "^3.11.3"
   },
   "devDependencies": {
-    "@stacksjs/development": "latest",
+    "@stacksjs/development": "0.64.6",
     "@types/tar": "^6.1.13",
-    "debug": "^4.3.6",
+    "debug": "^4.3.7",
     "mkdirp": "^3.0.1",
     "q": "^1.5.1",
     "tar": "^7.4.3"

package/src/drivers/index.ts

@@ -1,11 +1,11 @@
+import type { Attribute, Attributes, Model, VineType } from '@stacksjs/types'
 import { log } from '@stacksjs/cli'
 import { db } from '@stacksjs/database'
-import { getModelName, getTableName } from '@stacksjs/orm'
+import { handleError } from '@stacksjs/error-handling'
+import { getTableName } from '@stacksjs/orm'
 import { path } from '@stacksjs/path'
-import { fs, glob } from '@stacksjs/storage'
-import { plural, singular, snakeCase } from '@stacksjs/strings'
-import type { Attributes, Model, RelationConfig, VineType } from '@stacksjs/types'
-import { isString } from '@stacksjs/validation'
+import { fs, globSync } from '@stacksjs/storage'
+import { plural, snakeCase } from '@stacksjs/strings'
 
 export * from './mysql'
 export * from './postgres'
@@ -21,8 +21,9 @@ export async function getLastMigrationFields(modelName: string): Promise<Attribu
   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
+  if (typeof model.attributes === 'object')
+    fields = model.attributes
+  else fields = JSON.parse(model.attributes || '{}') as Attributes
 
   return fields
 }
@@ -35,18 +36,21 @@ export async function modelTableName(model: Model | string): Promise<string> {
   return model.table ?? snakeCase(plural(model?.name || ''))
 }
 
-export async function hasTableBeenMigrated(tableName: string) {
+export async function hasTableBeenMigrated(tableName: string): Promise<boolean> {
   log.debug(`hasTableBeenMigrated for table: ${tableName}`)
 
   const results = await getExecutedMigrations()
 
-  return results.some((migration) => migration.name.includes(tableName))
+  return results.some(migration => migration.name.includes(tableName))
 }
 
-export async function getExecutedMigrations() {
+export async function getExecutedMigrations(): Promise<{ name: string }[]> {
   try {
     return await db.selectFrom('migrations').select('name').execute()
-  } catch (error) {
+  }
+
+  catch (error) {
+    handleError(error, { shouldExitProcess: false })
     return []
   }
 }
@@ -55,13 +59,17 @@ function hasFunction(rule: VineType, functionName: string): boolean {
   return typeof rule[functionName] === 'function'
 }
 
-export function mapFieldTypeToColumnType(rule: VineType): string {
+export function mapFieldTypeToColumnType(rule: VineType, driver = 'mysql'): string {
   if (hasFunction(rule, 'getChoices')) {
+    if (driver === 'sqlite') {
+      return `'text'`
+    }
+
     // Condition checker if an attribute is enum, could not think any conditions atm
     const enumChoices = rule.getChoices() as string[]
 
     // Convert each string value to its corresponding string structure
-    const enumStructure = enumChoices.map((value) => `'${value}'`).join(', ')
+    const enumStructure = enumChoices.map(value => `'${value}'`).join(', ')
 
     // Construct the ENUM definition
     const enumDefinition = `sql\`enum(${enumStructure})\``
@@ -73,11 +81,12 @@ export function mapFieldTypeToColumnType(rule: VineType): string {
     // Default column type for strings
     return prepareTextColumnType(rule)
 
-  if (rule[Symbol.for('schema_name')].includes('number')) return `'integer'`
-
-  if (rule[Symbol.for('schema_name')].includes('boolean')) return `'boolean'`
-
-  if (rule[Symbol.for('schema_name')].includes('date')) return `'date'`
+  if (rule[Symbol.for('schema_name')].includes('number'))
+    return `'integer'`
+  if (rule[Symbol.for('schema_name')].includes('boolean'))
+    return `'boolean'`
+  if (rule[Symbol.for('schema_name')].includes('date'))
+    return `'date'`
 
   // need to now handle all other types
 
@@ -116,12 +125,13 @@ export function prepareTextColumnType(rule: VineType) {
 
   // If there's only a min length validation and no max, consider using text
   // This is a simplistic approach; adjust based on your actual requirements
-  if (minLengthValidation && !maxLengthValidation) columnType = 'text'
+  if (minLengthValidation && !maxLengthValidation)
+    columnType = 'text'
 
   return `'${columnType}'`
 }
 
-export function findCharacterLength(rule: VineType): { min: number; max: number } | undefined {
+export function findCharacterLength(rule: VineType): { min: number, max: number } | undefined {
   const result: any = {}
 
   // Find min and max length validations
@@ -133,7 +143,8 @@ export function findCharacterLength(rule: VineType): { min: number; max: number
   }
 
   for (const key of ['min', 'max']) {
-    if (maxLengthValidation.options[key] === undefined && minLengthValidation.options[key] === undefined) continue
+    if (maxLengthValidation.options[key] === undefined && minLengthValidation.options[key] === undefined)
+      continue
 
     result.max = maxLengthValidation.options[key]
     result.min = minLengthValidation.options[key]
@@ -164,147 +175,9 @@ export async function checkPivotMigration(dynamicPart: string): Promise<boolean>
   })
 }
 
-export async function getRelations(model: Model, modelPath: string): 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)
-        const modelRelation = (await import(modelRelationPath)).default
-        const modelName = getModelName(model, modelPath)
-        const formattedModelName = modelName.toLowerCase()
-        const tableName = getTableName(model, modelPath)
-        const modelRelationTable = getModelName(modelRelation, modelRelationPath)
-
-        relationships.push({
-          relationship: relation,
-          model: relationModel,
-          table: modelRelationTable,
-          relationModel: modelName,
-          relationTable: tableName,
-          foreignKey: relationInstance.foreignKey || `${formattedModelName}_id`,
-          relationName: relationInstance.relationName || '',
-          throughModel: relationInstance.through || '',
-          throughForeignKey: relationInstance.throughForeignKey || '',
-          pivotTable: relationInstance?.pivotTable || getPivotTableName(formattedModelName, modelRelationTable),
-        })
-      }
-    }
-  }
-
-  return relationships
-}
-
-export async function fetchOtherModelRelations(model: Model, modelPath: string): 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)).default as Model
-    const tableName = getTableName(model, modelPath)
-    const modelName = getModelName(model, modelPath)
-    const modelFileName = getTableName(modelFile, modelFileElement)
-
-    if (tableName === modelFileName) continue
-
-    const relations = await getRelations(modelFile, modelFileElement)
-
-    if (!relations.length) continue
-
-    const relation = relations.find((relation) => relation.model === modelName)
-
-    if (relation) modelRelations.push(relation)
-  }
-
-  return modelRelations
-}
-
-export async function getPivotTables(
-  model: Model,
-  modelPath: string,
-): Promise<{ table: string; firstForeignKey: string | undefined; secondForeignKey: string | undefined }[]> {
-  const pivotTable = []
-
-  const tableName = getTableName(model, modelPath)
-
-  let firstForeignKey = ''
-  let secondForeignKey = ''
-  let table = ''
-  let modelRelationPath = ''
-
-  if (model.belongsToMany) {
-    if ('belongsToMany' in model) {
-      for (const belongsToManyRelation of model.belongsToMany) {
-        if (typeof belongsToManyRelation === 'string') {
-          modelRelationPath = path.userModelsPath(`${belongsToManyRelation}.ts`)
-        } else {
-          modelRelationPath = path.userModelsPath(`${belongsToManyRelation.model}.ts`)
-        }
-
-        const modelRelation = (await import(modelRelationPath)).default
-        const formattedTableName = tableName.toLowerCase()
-
-        const modelRelationTable = getTableName(modelRelation, modelRelationPath)
-        // const modelRelationModelName = getModelName(modelRelation, modelRelationPath)
-
-        if (typeof belongsToManyRelation === 'string') {
-          firstForeignKey = `${singular(tableName.toLowerCase())}_${model.primaryKey}`
-          secondForeignKey = `${singular(modelRelationTable)}_${model.primaryKey}`
-          table = getPivotTableName(formattedTableName, modelRelationTable)
-        } else {
-          firstForeignKey =
-            belongsToManyRelation.firstForeignKey || `${singular(tableName.toLowerCase())}_${model.primaryKey}`
-          secondForeignKey =
-            belongsToManyRelation.secondForeignKey || `${singular(modelRelationTable)}_${model.primaryKey}`
-          table = belongsToManyRelation?.pivotTable || getPivotTableName(formattedTableName, modelRelationTable)
-        }
-
-        pivotTable.push({
-          table,
-          firstForeignKey,
-          secondForeignKey,
-        })
-      }
-
-      return pivotTable
-    }
-  }
-
-  return []
-}
-
-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
-}
-
-function hasRelations(obj: any, key: string): boolean {
-  return key in obj
-}
-
-export function pluckChanges(array1: string[], array2: string[]): { added: string[]; removed: string[] } | null {
-  const removed = array1.filter((item) => !array2.includes(item))
-  const added = array2.filter((item) => !array1.includes(item))
+export function pluckChanges(array1: string[], array2: string[]): { added: string[], removed: string[] } | null {
+  const removed = array1.filter(item => !array2.includes(item))
+  const added = array2.filter(item => !array1.includes(item))
 
   if (removed.length === 0 && added.length === 0) {
     return null
@@ -313,18 +186,22 @@ export function pluckChanges(array1: string[], array2: string[]): { added: strin
   return { added, removed }
 }
 
-export function arrangeColumns(attributes: Attributes | undefined) {
-  if (!attributes) return []
+export function arrangeColumns(attributes: Attributes | undefined): Array<[string, Attribute]> {
+  if (!attributes)
+    return []
 
   const entries = Object.entries(attributes)
 
+  // Sort the entries based on the 'order' property
+
+  // eslint-disable-next-line unused-imports/no-unused-vars
   entries.sort(([keyA, valueA], [keyB, valueB]) => {
     const orderA = valueA.order ?? Number.POSITIVE_INFINITY
     const orderB = valueB.order ?? Number.POSITIVE_INFINITY
     return orderA - orderB
   })
 
-  return entries
+  return entries // Return the sorted key-value pairs
 }
 
 export function isArrayEqual(arr1: (number | undefined)[], arr2: (number | undefined)[]): boolean {
@@ -332,17 +209,19 @@ export function isArrayEqual(arr1: (number | undefined)[], arr2: (number | undef
     return false
   }
 
-  if (arr1.length !== arr2.length) return false
+  if (arr1.length !== arr2.length)
+    return false
 
   for (let i = 0; i < arr1.length; i++) {
-    if (arr1[i] !== arr2[i]) return false
+    if (arr1[i] !== arr2[i])
+      return false
   }
 
   return true
 }
 
-export function findDifferingKeys(obj1: any, obj2: any): { key: string; max: number; min: number }[] {
-  const differingKeys: { key: string; max: number; min: number }[] = []
+export function findDifferingKeys(obj1: any, obj2: any): { key: string, max: number, min: number }[] {
+  const differingKeys: { key: string, max: number, min: number }[] = []
 
   for (const key in obj1) {
     if (Object.prototype.hasOwnProperty.call(obj1, key) && Object.prototype.hasOwnProperty.call(obj2, key)) {
@@ -351,8 +230,8 @@ export function findDifferingKeys(obj1: any, obj2: any): { key: string; max: num
 
       if (lastCharacterLength !== undefined && latestCharacterLength !== undefined) {
         if (
-          lastCharacterLength.max !== latestCharacterLength.max ||
-          lastCharacterLength.min !== latestCharacterLength.min
+          lastCharacterLength.max !== latestCharacterLength.max
+          || lastCharacterLength.min !== latestCharacterLength.min
         ) {
           differingKeys.push({ key, max: latestCharacterLength.max, min: latestCharacterLength.min })
         }
@@ -362,3 +241,18 @@ export function findDifferingKeys(obj1: any, obj2: any): { key: string; max: num
 
   return differingKeys
 }
+
+export async function fetchTables(): Promise<string[]> {
+  const modelFiles = globSync(path.userModelsPath('*.ts'), { absolute: true })
+
+  const tables: string[] = []
+
+  for (const modelPath of modelFiles) {
+    const model = (await import(modelPath)).default as Model
+    const tableName = getTableName(model, modelPath)
+
+    tables.push(tableName)
+  }
+
+  return tables
+}