chore: wip

Author: glennmichael123

bun.lockb

@@ -1,86 +1,3 @@
-import User from '../../../../../../app/Models/User'
-
-export interface ModelElement {
-  field: string
-  default: string | number | boolean | Date | undefined | null
-  unique: boolean
-  fieldArray: FieldArrayElement[]
-}
-
-export interface FieldArrayElement {
-  entity: string
-  charValue?: string | null
-  // Add other properties as needed
-}
-const rules: string[] = []
-
-async function extractModelRule() {
-  const modelFile = Bun.file('../../../../../app/Models/User.ts') // Assuming Bun is imported properly
-
-  const code = await modelFile.text()
-
-  const regex = /rule:.*$/gm
-
-  let match: RegExpExecArray | null
-  match = regex.exec(code)
-  while (match !== null) {
-    rules.push(match[0])
-    match = regex.exec(code)
-  }
-}
-
-await extractModelRule()
-
-// TODO: we can improve this type
-const fields: Record<string, any> = User.fields
-const fieldKeys = Object.keys(fields)
-
-const input: ModelElement[] = fieldKeys.map((field, index) => {
-  const fieldExist = fields[field]
-  let defaultValue = null
-  let uniqueValue = false
-
-  if (fieldExist) {
-    defaultValue = fieldExist.default || null
-    uniqueValue = fieldExist.unique || false
-  }
-
-  return {
-    field,
-    default: defaultValue,
-    unique: uniqueValue,
-    fieldArray: parseRule(rules[index] ?? ''),
-  }
-})
-
-function parseRule(rule: string): FieldArrayElement[] {
-  const parts = rule.split('rule: validator.')
-
-  if (parts.length !== 2)
-    return []
-
-  if (!parts[1])
-    parts[1] = ''
-
-  const extractedString = parts[1].replace(/,/g, '')
-
-  if (!extractedString)
-    return []
-
-  const extractedParts = extractedString.split('.')
-  const regex = /\(([^)]+)\)/
-
-  return extractedParts.map((input) => {
-    const match = regex.exec(input)
-    const value = match ? match[1] : null
-    const field = input.replace(regex, '').replace(/\(|\)/g, '')
-    return { entity: field, charValue: value }
-  })
-}
-
-const modelEntity: ModelElement[] = input
-
-// You can now use the modelEntity array with type safety.
 
 const fieldAssociation: { [key: string]: { [key: string]: string } } = {
   mysql: {
@@ -99,13 +16,4 @@ const fieldAssociation: { [key: string]: { [key: string]: string } } = {
   },
 }
 
-const fieldEntity = [
-  'maxLength',
-]
-
-const excludeFieldEntity = [
-  'minLength',
-  'enum',
-]
-
-export { fieldEntity, fieldAssociation, modelEntity, excludeFieldEntity }
+export { fieldAssociation}

database/migrations/1711346999980-create-subscribers-table.ts

@@ -1,66 +1,59 @@
-// import { generateMigrationFile } from '@stacksjs/database'
-import User from '../../../../../../app/Models/User'
-import { fieldAssociation, modelEntity } from './fields'
-
-const file = Bun.file('user-migration.ts')
-const writer = file.writer()
-
-const driver = 'sqlite'
-
-writer.write('import { db, sql, Database } from \'@stacksjs/database\'\n')
-writer.write('\n')
-writer.write('export async function up(db: Database<any>) {\n')
-
-writer.write('  await db.schema\n')
-writer.write(`    .createTable('${User.table}')\n`)
-
-writer.write('    .addColumn(\'id\', \'integer\', (col) => col.primaryKey())\n')
-
-for (let modelIndex = 0; modelIndex < modelEntity.length; modelIndex++) {
-  const modelElement = modelEntity[modelIndex]
-
-  if (!modelElement)
-    continue
-
-  let entity = ''
-  let characteristic = ''
-
-  const isNullablePresent = modelElement.fieldArray.some(item => item.entity === 'nullable')
-
-  if (modelElement.default)
-    characteristic += `.defaultTo('${modelElement.default.toString()}')`
-
-  if (modelElement.unique)
-    characteristic += '.unique()'
-
-  if (!isNullablePresent)
-    characteristic += '.notNull()'
-
-  for (let fieldIndex = 0; fieldIndex < modelElement.fieldArray.length; fieldIndex++) {
-    const fieldArrayElement = modelElement.fieldArray[fieldIndex]
-
-    if (!fieldArrayElement)
-      continue
-
-    if (!fieldAssociation[driver])
-      continue
-
-    if (fieldAssociation[driver][fieldArrayElement.entity])
-      entity += `${fieldAssociation[driver][fieldArrayElement.entity]}`
+import { Attributes } from "@stacksjs/types"
+
+export async function createTableMigration(modelPath: string) {
+  
+  log.debug('createTableMigration modelPath:', modelPath)
+
+  const model = await import(modelPath)
+  const tableName = model.default.table
+
+  const fields = model.default.attributes
+  const useTimestamps = model.default?.traits?.useTimestamps ?? model.default?.traits?.timestampable
+  const useSoftDeletes = model.default?.traits?.useSoftDeletes ?? model.default?.traits?.softDeletable
+
+  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`
+
+  for (const [fieldName, options] of Object.entries(fields)) {
+    const fieldOptions = options as Attributes
+    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`
+  }
 
-    // fieldEntity.forEach((entityField) => {
-    //   if (fieldArrayElement.entity === entityField)
-    //     entity += `(${fieldArrayElement.charValue})`
-    // })
+  // 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`
   }
 
-  writer.write(`    .addColumn('${modelElement.field}', '${entity}', (col) => col${characteristic})\n`)
-}
+  // Append deleted_at column if useSoftDeletes is true
+  if (useSoftDeletes)
+    migrationContent += `    .addColumn('deleted_at', 'timestamp')\n`
+
+  migrationContent += `    .execute()\n`
+  migrationContent += `}\n`
 
-writer.write('    .addColumn(\'created_at\', \'timestamp\', (col) => col.defaultTo(sql`CURRENT_TIMESTAMP`).notNull())\n')
-writer.write('    .execute()\n')
-writer.write('}\n\n')
+  const timestamp = new Date().getTime().toString()
+  const migrationFileName = `${timestamp}-create-${tableName}-table.ts`
+  const migrationFilePath = path.userMigrationsPath(migrationFileName)
 
-writer.write('process.exit(0)\n')
+  // Assuming fs.writeFileSync is available or use an equivalent method
+  Bun.write(migrationFilePath, migrationContent)
 
-await writer.end()
+  log.success(`Created migration: ${migrationFileName}`)
+}

database/migrations/1711346999981-create-users-table.ts

@@ -0,0 +1,14 @@
+import process from 'node:process'
+import { log } from '@stacksjs/logging'
+import { resetDatabase, runDatabaseMigration } from '@stacksjs/database'
+
+// this is run and checks whether new created or update migrations need to be generated
+const result = await resetDatabase()
+
+if (result?.isErr()) {
+  console.error(result.error)
+  log.error('[stacks] generateMigrations failed', result.error)
+  process.exit(1)
+}
+
+process.exit(0)

storage/framework/core/actions/src/database/fields.ts

@@ -35,6 +35,26 @@ export function migrate(buddy: CLI) {
       process.exit(ExitCode.Success)
     })
 
+  buddy
+    .command('migrate:fresh', descriptions.migrate)
+    .option('-d, --diff', 'Show the SQL that would be run', { default: false })
+    .option('-p, --project', descriptions.project, { default: false })
+    .option('--verbose', descriptions.verbose, { default: false })
+    .action(async (options: MigrateOptions) => {
+      log.debug('Running `buddy migrate:fresh` ...', options)
+
+      const perf = await intro('buddy migrate:fresh')
+      const result = await runAction(Action.MigrateFresh, options)
+
+      if (result.isErr()) {
+        await outro('While running the migrate command, there was an issue', { startTime: perf, useSeconds: true }, result.error)
+        process.exit()
+      }
+
+      await outro(`All tables dropped successfully`, { startTime: perf, useSeconds: true })
+      process.exit(ExitCode.Success)
+    })
+
   buddy
     .command('migrate:dns', descriptions.migrate)
     .option('-p, --project', descriptions.project, { default: false })