477 lines
16 KiB
Go
477 lines
16 KiB
Go
package ui
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/gdamore/tcell/v2"
|
|
"github.com/rivo/tview"
|
|
|
|
"git.warky.dev/wdevs/relspecgo/pkg/models"
|
|
)
|
|
|
|
// objectLocation identifies where a new object is created: a schema, and for indexes also a table.
|
|
type objectLocation struct {
|
|
label string
|
|
schemaIndex int
|
|
tableIndex int
|
|
}
|
|
|
|
// objectRow is one existing object shown in an object list.
|
|
type objectRow struct {
|
|
cells []string
|
|
schemaIndex int
|
|
tableIndex int
|
|
at int // position within the schema slice (views, sequences, scripts)
|
|
name string // map key (indexes)
|
|
}
|
|
|
|
// objectKind describes how a kind of schema object is listed and edited.
|
|
type objectKind struct {
|
|
page string
|
|
title string
|
|
singular string
|
|
headers []string
|
|
rows func() []objectRow
|
|
locations func() []objectLocation
|
|
// buildForm adds the editable fields to the form for row (nil when creating) and
|
|
// returns a function that validates and saves the values at the given location.
|
|
buildForm func(form *tview.Form, row *objectRow) func(loc objectLocation) error
|
|
remove func(row objectRow) bool
|
|
}
|
|
|
|
func (se *SchemaEditor) schemaLocations() []objectLocation {
|
|
locs := make([]objectLocation, 0, len(se.db.Schemas))
|
|
for si, s := range se.db.Schemas {
|
|
locs = append(locs, objectLocation{label: s.Name, schemaIndex: si, tableIndex: -1})
|
|
}
|
|
return locs
|
|
}
|
|
|
|
func (se *SchemaEditor) tableLocations() []objectLocation {
|
|
locs := make([]objectLocation, 0)
|
|
for si, s := range se.db.Schemas {
|
|
for ti, t := range s.Tables {
|
|
locs = append(locs, objectLocation{label: s.Name + "." + t.Name, schemaIndex: si, tableIndex: ti})
|
|
}
|
|
}
|
|
return locs
|
|
}
|
|
|
|
func (se *SchemaEditor) indexKind() objectKind {
|
|
return objectKind{
|
|
page: "indexes",
|
|
title: "Manage Indexes",
|
|
singular: "Index",
|
|
headers: []string{"Name", "Schema", "Table", "Type", "Unique", "Columns"},
|
|
locations: se.tableLocations,
|
|
rows: func() []objectRow {
|
|
var rows []objectRow
|
|
for si, s := range se.db.Schemas {
|
|
for ti, t := range s.Tables {
|
|
for _, name := range sortedKeys(t.Indexes) {
|
|
idx := t.Indexes[name]
|
|
rows = append(rows, objectRow{
|
|
cells: []string{idx.Name, s.Name, t.Name, idx.Type, strconv.FormatBool(idx.Unique), strings.Join(idx.Columns, ",")},
|
|
schemaIndex: si, tableIndex: ti, name: name,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
return rows
|
|
},
|
|
buildForm: func(form *tview.Form, row *objectRow) func(objectLocation) error {
|
|
idx := models.InitIndex("", "", "")
|
|
idx.Type = "btree"
|
|
if row != nil {
|
|
idx = se.db.Schemas[row.schemaIndex].Tables[row.tableIndex].Indexes[row.name]
|
|
}
|
|
name, columns, typ, where := idx.Name, strings.Join(idx.Columns, ", "), idx.Type, idx.Where
|
|
unique := idx.Unique
|
|
form.AddInputField("Name", name, 40, nil, func(v string) { name = v })
|
|
form.AddInputField("Columns (comma separated)", columns, 50, nil, func(v string) { columns = v })
|
|
form.AddInputField("Type", typ, 20, nil, func(v string) { typ = v })
|
|
form.AddCheckbox("Unique", unique, func(v bool) { unique = v })
|
|
form.AddInputField("Where", where, 50, nil, func(v string) { where = v })
|
|
return func(loc objectLocation) error {
|
|
oldName := ""
|
|
if row != nil {
|
|
oldName = row.name
|
|
}
|
|
next := *idx
|
|
next.Name, next.Columns, next.Type, next.Unique, next.Where = name, splitList(columns), typ, unique, where
|
|
return se.SaveIndex(loc.schemaIndex, loc.tableIndex, oldName, &next)
|
|
}
|
|
},
|
|
remove: func(r objectRow) bool { return se.DeleteIndex(r.schemaIndex, r.tableIndex, r.name) },
|
|
}
|
|
}
|
|
|
|
func (se *SchemaEditor) viewKind() objectKind {
|
|
return objectKind{
|
|
page: "views",
|
|
title: "Manage Views",
|
|
singular: "View",
|
|
headers: []string{"Name", "Schema", "Description"},
|
|
locations: se.schemaLocations,
|
|
rows: func() []objectRow {
|
|
var rows []objectRow
|
|
for si, s := range se.db.Schemas {
|
|
for i, v := range s.Views {
|
|
rows = append(rows, objectRow{cells: []string{v.Name, s.Name, v.Description}, schemaIndex: si, at: i})
|
|
}
|
|
}
|
|
return rows
|
|
},
|
|
buildForm: func(form *tview.Form, row *objectRow) func(objectLocation) error {
|
|
view := models.InitView("", "")
|
|
at := -1
|
|
if row != nil {
|
|
view, at = se.db.Schemas[row.schemaIndex].Views[row.at], row.at
|
|
}
|
|
name, desc, def := view.Name, view.Description, view.Definition
|
|
form.AddInputField("Name", name, 40, nil, func(v string) { name = v })
|
|
form.AddInputField("Description", desc, 50, nil, func(v string) { desc = v })
|
|
form.AddTextArea("Definition (SQL)", def, 60, 8, 0, func(v string) { def = v })
|
|
return func(loc objectLocation) error {
|
|
next := *view
|
|
next.Name, next.Description, next.Definition = name, desc, def
|
|
return se.SaveView(loc.schemaIndex, at, &next)
|
|
}
|
|
},
|
|
remove: func(r objectRow) bool { return se.DeleteView(r.schemaIndex, r.at) },
|
|
}
|
|
}
|
|
|
|
func (se *SchemaEditor) sequenceKind() objectKind {
|
|
return objectKind{
|
|
page: "sequences",
|
|
title: "Manage Sequences",
|
|
singular: "Sequence",
|
|
headers: []string{"Name", "Schema", "Start", "Increment", "Cycle", "Description"},
|
|
locations: se.schemaLocations,
|
|
rows: func() []objectRow {
|
|
var rows []objectRow
|
|
for si, s := range se.db.Schemas {
|
|
for i, q := range s.Sequences {
|
|
rows = append(rows, objectRow{
|
|
cells: []string{q.Name, s.Name, strconv.FormatInt(q.StartValue, 10), strconv.FormatInt(q.IncrementBy, 10), strconv.FormatBool(q.Cycle), q.Description}, schemaIndex: si, at: i,
|
|
})
|
|
}
|
|
}
|
|
return rows
|
|
},
|
|
buildForm: func(form *tview.Form, row *objectRow) func(objectLocation) error {
|
|
seq := models.InitSequence("", "")
|
|
at := -1
|
|
if row != nil {
|
|
seq, at = se.db.Schemas[row.schemaIndex].Sequences[row.at], row.at
|
|
}
|
|
name, desc := seq.Name, seq.Description
|
|
start, incr := strconv.FormatInt(seq.StartValue, 10), strconv.FormatInt(seq.IncrementBy, 10)
|
|
minV, maxV := strconv.FormatInt(seq.MinValue, 10), strconv.FormatInt(seq.MaxValue, 10)
|
|
cycle := seq.Cycle
|
|
form.AddInputField("Name", name, 40, nil, func(v string) { name = v })
|
|
form.AddInputField("Description", desc, 50, nil, func(v string) { desc = v })
|
|
form.AddInputField("Start", start, 20, nil, func(v string) { start = v })
|
|
form.AddInputField("Increment", incr, 20, nil, func(v string) { incr = v })
|
|
form.AddInputField("Min (0 = none)", minV, 20, nil, func(v string) { minV = v })
|
|
form.AddInputField("Max (0 = none)", maxV, 20, nil, func(v string) { maxV = v })
|
|
form.AddCheckbox("Cycle", cycle, func(v bool) { cycle = v })
|
|
return func(loc objectLocation) error {
|
|
next := *seq
|
|
next.Name, next.Description, next.Cycle = name, desc, cycle
|
|
for _, f := range []struct {
|
|
label string
|
|
text string
|
|
dst *int64
|
|
}{{"start", start, &next.StartValue}, {"increment", incr, &next.IncrementBy}, {"min", minV, &next.MinValue}, {"max", maxV, &next.MaxValue}} {
|
|
n, err := strconv.ParseInt(strings.TrimSpace(f.text), 10, 64)
|
|
if err != nil {
|
|
return fmt.Errorf("%s must be an integer", f.label)
|
|
}
|
|
*f.dst = n
|
|
}
|
|
return se.SaveSequence(loc.schemaIndex, at, &next)
|
|
}
|
|
},
|
|
remove: func(r objectRow) bool { return se.DeleteSequence(r.schemaIndex, r.at) },
|
|
}
|
|
}
|
|
|
|
func (se *SchemaEditor) scriptKind() objectKind {
|
|
return objectKind{
|
|
page: "scripts",
|
|
title: "Manage Scripts",
|
|
singular: "Script",
|
|
headers: []string{"Name", "Schema", "Version", "Priority", "Description"},
|
|
locations: se.schemaLocations,
|
|
rows: func() []objectRow {
|
|
var rows []objectRow
|
|
for si, s := range se.db.Schemas {
|
|
for i, sc := range s.Scripts {
|
|
rows = append(rows, objectRow{cells: []string{sc.Name, s.Name, sc.Version, strconv.Itoa(sc.Priority), sc.Description}, schemaIndex: si, at: i})
|
|
}
|
|
}
|
|
return rows
|
|
},
|
|
buildForm: func(form *tview.Form, row *objectRow) func(objectLocation) error {
|
|
script := models.InitScript("")
|
|
at := -1
|
|
if row != nil {
|
|
script, at = se.db.Schemas[row.schemaIndex].Scripts[row.at], row.at
|
|
}
|
|
name, desc, version, sql, rollback := script.Name, script.Description, script.Version, script.SQL, script.Rollback
|
|
priority, runAfter := strconv.Itoa(script.Priority), strings.Join(script.RunAfter, ", ")
|
|
form.AddInputField("Name", name, 40, nil, func(v string) { name = v })
|
|
form.AddInputField("Description", desc, 50, nil, func(v string) { desc = v })
|
|
form.AddInputField("Version", version, 20, nil, func(v string) { version = v })
|
|
form.AddInputField("Priority", priority, 10, nil, func(v string) { priority = v })
|
|
form.AddInputField("Run after (comma separated)", runAfter, 50, nil, func(v string) { runAfter = v })
|
|
form.AddTextArea("SQL", sql, 60, 8, 0, func(v string) { sql = v })
|
|
form.AddTextArea("Rollback SQL", rollback, 60, 4, 0, func(v string) { rollback = v })
|
|
return func(loc objectLocation) error {
|
|
prio, err := strconv.Atoi(strings.TrimSpace(priority))
|
|
if err != nil {
|
|
return fmt.Errorf("priority must be an integer")
|
|
}
|
|
next := *script
|
|
next.Name, next.Description, next.Version, next.Priority = name, desc, version, prio
|
|
next.RunAfter, next.SQL, next.Rollback = splitList(runAfter), sql, rollback
|
|
return se.SaveScript(loc.schemaIndex, at, &next)
|
|
}
|
|
},
|
|
remove: func(r objectRow) bool { return se.DeleteScript(r.schemaIndex, r.at) },
|
|
}
|
|
}
|
|
|
|
func sortedKeys[V any](m map[string]V) []string {
|
|
keys := make([]string, 0, len(m))
|
|
for k := range m {
|
|
keys = append(keys, k)
|
|
}
|
|
sort.Strings(keys)
|
|
return keys
|
|
}
|
|
|
|
// showObjectList displays all objects of a kind across schemas.
|
|
func (se *SchemaEditor) showObjectList(k objectKind) {
|
|
flex := tview.NewFlex().SetDirection(tview.FlexRow)
|
|
title := tview.NewTextView().SetText("[::b]" + k.title).SetDynamicColors(true).SetTextAlign(tview.AlignCenter)
|
|
|
|
table := tview.NewTable().SetBorders(true).SetSelectable(true, false).SetFixed(1, 0)
|
|
for i, h := range k.headers {
|
|
table.SetCell(0, i, tview.NewTableCell(h).SetTextColor(tcell.ColorYellow).SetSelectable(false).SetAlign(tview.AlignLeft))
|
|
}
|
|
rows := k.rows()
|
|
for r, row := range rows {
|
|
for c, text := range row.cells {
|
|
table.SetCell(r+1, c, tview.NewTableCell(text).SetSelectable(true))
|
|
}
|
|
}
|
|
table.SetTitle(" " + k.title[len("Manage "):] + " ").SetBorder(true).SetTitleAlign(tview.AlignLeft)
|
|
|
|
back := func() {
|
|
se.pages.SwitchToPage("main")
|
|
se.pages.RemovePage(k.page)
|
|
}
|
|
btnNew := tview.NewButton("New " + k.singular + " [n]").SetSelectedFunc(func() { se.showObjectForm(k, nil) })
|
|
btnBack := tview.NewButton("Back [b]").SetSelectedFunc(back)
|
|
btnNew.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
|
|
switch event.Key() {
|
|
case tcell.KeyBacktab:
|
|
se.app.SetFocus(table)
|
|
return nil
|
|
case tcell.KeyTab:
|
|
se.app.SetFocus(btnBack)
|
|
return nil
|
|
}
|
|
return event
|
|
})
|
|
btnBack.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
|
|
switch event.Key() {
|
|
case tcell.KeyBacktab:
|
|
se.app.SetFocus(btnNew)
|
|
return nil
|
|
case tcell.KeyTab:
|
|
se.app.SetFocus(table)
|
|
return nil
|
|
}
|
|
return event
|
|
})
|
|
btnFlex := tview.NewFlex().AddItem(btnNew, 0, 1, true).AddItem(btnBack, 0, 1, false)
|
|
|
|
table.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
|
|
switch {
|
|
case event.Key() == tcell.KeyEscape, event.Rune() == 'b':
|
|
back()
|
|
return nil
|
|
case event.Key() == tcell.KeyTab:
|
|
se.app.SetFocus(btnNew)
|
|
return nil
|
|
case event.Key() == tcell.KeyEnter:
|
|
if row, _ := table.GetSelection(); row > 0 && row <= len(rows) {
|
|
se.showObjectForm(k, &rows[row-1])
|
|
return nil
|
|
}
|
|
case event.Rune() == 'n':
|
|
se.showObjectForm(k, nil)
|
|
return nil
|
|
}
|
|
return event
|
|
})
|
|
|
|
flex.AddItem(title, 1, 0, false).AddItem(table, 0, 1, true).AddItem(btnFlex, 1, 0, false)
|
|
se.pages.AddPage(k.page, flex, true, true)
|
|
}
|
|
|
|
// showObjectForm shows the create (row == nil) or edit form for an object.
|
|
func (se *SchemaEditor) showObjectForm(k objectKind, row *objectRow) {
|
|
formPage := k.page + "-form"
|
|
form := tview.NewForm()
|
|
errView := tview.NewTextView().SetDynamicColors(true)
|
|
|
|
locs := k.locations()
|
|
loc := objectLocation{schemaIndex: -1, tableIndex: -1}
|
|
switch {
|
|
case row != nil:
|
|
loc = objectLocation{schemaIndex: row.schemaIndex, tableIndex: row.tableIndex}
|
|
case len(locs) > 0:
|
|
loc = locs[0]
|
|
labels := make([]string, len(locs))
|
|
for i, l := range locs {
|
|
labels[i] = l.label
|
|
}
|
|
form.AddDropDown("Location", labels, 0, func(_ string, i int) { loc = locs[i] })
|
|
}
|
|
|
|
save := k.buildForm(form, row)
|
|
|
|
closeForm := func() {
|
|
se.pages.RemovePage(formPage)
|
|
se.pages.RemovePage(k.page)
|
|
se.showObjectList(k)
|
|
}
|
|
form.AddButton("Save", func() {
|
|
if err := save(loc); err != nil {
|
|
errView.SetText("[red]" + tview.Escape(err.Error()))
|
|
return
|
|
}
|
|
closeForm()
|
|
})
|
|
if row != nil {
|
|
form.AddButton("Delete", func() {
|
|
modal := tview.NewModal().
|
|
SetText(fmt.Sprintf("Delete %s '%s'? This action cannot be undone.", strings.ToLower(k.singular), row.cells[0])).
|
|
AddButtons([]string{"Cancel", "Delete"}).
|
|
SetDoneFunc(func(_ int, label string) {
|
|
se.pages.RemovePage(formPage + "-delete")
|
|
if label == "Delete" {
|
|
k.remove(*row)
|
|
closeForm()
|
|
}
|
|
})
|
|
se.pages.AddAndSwitchToPage(formPage+"-delete", modal, true)
|
|
})
|
|
}
|
|
form.AddButton("Back", closeForm)
|
|
|
|
verb := "New"
|
|
if row != nil {
|
|
verb = "Edit"
|
|
}
|
|
form.SetBorder(true).SetTitle(" " + verb + " " + k.singular + " ").SetTitleAlign(tview.AlignLeft)
|
|
form.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
|
|
if event.Key() == tcell.KeyEscape {
|
|
se.showExitConfirmation(formPage, k.page)
|
|
return nil
|
|
}
|
|
return event
|
|
})
|
|
|
|
if len(locs) == 0 && row == nil {
|
|
errView.SetText("[red]No schema/table available. Create one first.")
|
|
}
|
|
flex := tview.NewFlex().SetDirection(tview.FlexRow).AddItem(form, 0, 1, true).AddItem(errView, 1, 0, false)
|
|
se.pages.AddPage(formPage, flex, true, true)
|
|
}
|
|
|
|
// showDomainTables lists the tables assigned to a domain and allows assigning/unassigning.
|
|
func (se *SchemaEditor) showDomainTables(domainIndex int) {
|
|
if domainIndex < 0 || domainIndex >= len(se.db.Domains) {
|
|
return
|
|
}
|
|
domain := se.db.Domains[domainIndex]
|
|
page := "domain-tables"
|
|
list := tview.NewList().ShowSecondaryText(true)
|
|
refresh := func() {
|
|
se.pages.RemovePage(page)
|
|
se.showDomainTables(domainIndex)
|
|
}
|
|
|
|
for _, dt := range domain.Tables {
|
|
dt := dt
|
|
list.AddItem(dt.SchemaName+"."+dt.TableName, "Enter to remove from domain", 0, func() {
|
|
se.UnassignTableFromDomain(domainIndex, dt.SchemaName, dt.TableName)
|
|
refresh()
|
|
})
|
|
}
|
|
list.AddItem("[Assign Table]", "Add a table to this domain", 'a', func() {
|
|
se.showAssignDomainTable(domainIndex, refresh)
|
|
})
|
|
list.AddItem("[Back]", "Return to domain", 'b', func() {
|
|
se.pages.RemovePage(page)
|
|
})
|
|
list.SetBorder(true).SetTitle(" Domain " + domain.Name + " - Tables ").SetTitleAlign(tview.AlignLeft)
|
|
list.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
|
|
if event.Key() == tcell.KeyEscape {
|
|
se.pages.RemovePage(page)
|
|
return nil
|
|
}
|
|
return event
|
|
})
|
|
se.pages.AddPage(page, list, true, true)
|
|
}
|
|
|
|
// showAssignDomainTable shows a form to pick a table not yet in the domain.
|
|
func (se *SchemaEditor) showAssignDomainTable(domainIndex int, done func()) {
|
|
page := "assign-domain-table"
|
|
domain := se.db.Domains[domainIndex]
|
|
var options []string
|
|
var refs []models.DomainTable
|
|
for _, s := range se.db.Schemas {
|
|
for _, t := range s.Tables {
|
|
taken := false
|
|
for _, dt := range domain.Tables {
|
|
taken = taken || (dt.SchemaName == s.Name && dt.TableName == t.Name)
|
|
}
|
|
if !taken {
|
|
options = append(options, s.Name+"."+t.Name)
|
|
refs = append(refs, models.DomainTable{SchemaName: s.Name, TableName: t.Name})
|
|
}
|
|
}
|
|
}
|
|
form := tview.NewForm()
|
|
selected := 0
|
|
form.AddDropDown("Table", options, 0, func(_ string, i int) { selected = i })
|
|
form.AddButton("Assign", func() {
|
|
if len(refs) > 0 {
|
|
_ = se.AssignTableToDomain(domainIndex, refs[selected].SchemaName, refs[selected].TableName)
|
|
}
|
|
se.pages.RemovePage(page)
|
|
done()
|
|
})
|
|
form.AddButton("Back", func() { se.pages.RemovePage(page) })
|
|
form.SetBorder(true).SetTitle(" Assign Table ").SetTitleAlign(tview.AlignLeft)
|
|
form.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
|
|
if event.Key() == tcell.KeyEscape {
|
|
se.pages.RemovePage(page)
|
|
return nil
|
|
}
|
|
return event
|
|
})
|
|
se.pages.AddPage(page, form, true, true)
|
|
}
|