terrier-engine 4.52.6 → 4.52.7

package/data-dive/plots/dive-plot-traces.ts

@@ -1,16 +1,16 @@
-import {MarkerStyle, PlotTrace, TraceType, YAxisName} from "tuff-plot/trace"
+import { MarkerStyle, PlotTrace, TraceType, YAxisName } from "tuff-plot/trace"
 import { PartTag } from "tuff-core/parts"
-import {ModalPart} from "../../terrier/modals"
+import { ModalPart } from "../../terrier/modals"
 import Ids from "../../terrier/ids"
-import {DivePlotEditorState} from "./dive-plot-editor"
-import {TerrierFormFields} from "../../terrier/forms"
-import {UnpersistedDdDivePlot} from "../gen/models"
-import {SelectOptions} from "tuff-core/forms"
-import Queries, {Query, QueryResult} from "../queries/queries"
-import {Logger} from "tuff-core/logging"
+import { DivePlotEditorState } from "./dive-plot-editor"
+import { TerrierFormFields } from "../../terrier/forms"
+import { UnpersistedDdDivePlot } from "../gen/models"
+import { SelectOptions } from "tuff-core/forms"
+import Queries, { Query, QueryResult } from "../queries/queries"
+import { Logger } from "tuff-core/logging"
 import Columns from "../queries/columns"
 import Messages from "tuff-core/messages"
-import DivePlotStyles, {DivePlotTraceStyle, TraceStyleFields} from "./dive-plot-styles"
+import DivePlotStyles, { DivePlotTraceStyle, TraceStyleFields } from "./dive-plot-styles"
 import TerrierPart from "../../terrier/parts/terrier-part"
 
 const log = new Logger("DivePlotTraces")
@@ -86,7 +86,7 @@ export class DivePlotTraceEditor extends ModalPart<DivePlotTraceEditorState> {
 
         this.queries = this.state.dive.query_data?.queries || []
         this.queryOptions = this.queries.map(query => {
-            return {value: query.id, title: query.name}
+            return { value: query.id, title: query.name }
         }) || []
 
         this.trace.query_id ||= this.queries.at(0)?.id || ''
@@ -100,13 +100,13 @@ export class DivePlotTraceEditor extends ModalPart<DivePlotTraceEditorState> {
         this.addAction({
             title: "Save",
             icon: "glyp-checkmark",
-            click: {key: this.saveKey}
+            click: { key: this.saveKey }
         })
 
         this.addAction({
             title: "Delete",
             icon: "glyp-delete",
-            click: {key: this.deleteKey},
+            click: { key: this.deleteKey },
             classes: ['alert']
         }, 'secondary')
 
@@ -133,9 +133,9 @@ export class DivePlotTraceEditor extends ModalPart<DivePlotTraceEditorState> {
         this.axisOptions = []
         if (query) {
             log.info(`Computing axis options for query`, query)
-            Queries.eachColumn(query, (table, column) => {
+            for (const { table, column } of Queries.columns(query)) {
                 this.axisOptions.push(Columns.computeSelectName(table, column))
-            })
+            }
         }
         else {
             log.warn(`No query with id ${queryId}`)
@@ -180,7 +180,7 @@ export class DivePlotTraceEditor extends ModalPart<DivePlotTraceEditorState> {
 
     async save() {
         const data = await this.fields.serialize()
-        this.trace = {...this.trace, ...data}
+        this.trace = { ...this.trace, ...data }
         this.trace.style = await this.styleFields.serialize()
         log.info("Saving plot trace", this.trace)
         this.state.onSave(this.trace)
@@ -224,9 +224,9 @@ export class DivePlotTraceRow extends TerrierPart<DivePlotTraceRowState> {
                 // style
                 content.div('.style', stylePreview => {
                     DivePlotStyles.renderPreview(stylePreview, style, this.state.index)
-                }).data({tooltip: `${style.colorName} ${style.strokeWidthName} ${style.strokeDasharrayName}`})
+                }).data({ tooltip: `${style.colorName} ${style.strokeWidthName} ${style.strokeDasharrayName}` })
             })
-        }).emitClick(editKey, {id: trace.id})
+        }).emitClick(editKey, { id: trace.id })
     }
 
 }

package/data-dive/queries/column-order-modal.ts

@@ -1,11 +1,11 @@
 import Arrays from "tuff-core/arrays"
 import { PartTag } from "tuff-core/parts"
-import {ModalPart} from "../../terrier/modals"
+import { ModalPart } from "../../terrier/modals"
 import Columns from "./columns"
-import Queries, {Query} from "./queries"
+import Queries, { Query } from "./queries"
 import Messages from "tuff-core/messages"
 import SortablePlugin from "tuff-sortable/sortable-plugin"
-import {Logger} from "tuff-core/logging"
+import { Logger } from "tuff-core/logging"
 
 const log = new Logger("ColumnOrderModal")
 
@@ -26,7 +26,7 @@ export default class ColumnOrderModal extends ModalPart<ColumnOrderState> {
         this.addAction({
             title: "Apply",
             icon: "glyp-checkmark",
-            click: {key: this.submitKey}
+            click: { key: this.submitKey }
         })
 
         this.onClick(this.submitKey, _ => {
@@ -36,25 +36,7 @@ export default class ColumnOrderModal extends ModalPart<ColumnOrderState> {
 
         // initialize the columns from the query, if present
         const query = this.state.query
-        const initialColumns = new Set<string>() // keep track of the initial columns
-        if (query.columns?.length) {
-            this.columns = query.columns
-            this.columns.forEach(c => {
-                initialColumns.add(c)
-            })
-        }
-
-        // ensure that all columns in the query are represented, regardless of whether they're stored
-        Queries.eachColumn(query, (table, col) => {
-            const name = Columns.computeSelectName(table, col)
-            if (!this.columns.includes(name)) {
-                this.columns.push(name)
-                initialColumns.delete(name)
-            }
-        })
-
-        // remove any of the initial columns that aren't in the query anymore
-        Arrays.deleteIf(this.columns, (c) => initialColumns.has(c))
+        if (query.columns?.length) this.columns = Array.from(query.columns)
 
         // make the list sortable
         this.makePlugin(SortablePlugin, {
@@ -72,7 +54,7 @@ export default class ColumnOrderModal extends ModalPart<ColumnOrderState> {
             container.p().text("Drag and drop the columns to change their order:")
             container.div(".dive-column-sort-zone", zone => {
                 for (const col of this.columns) {
-                    zone.div(".column").data({column: col}).text(col)
+                    zone.div(".column").data({ column: col }).text(col)
                 }
             })
         })

package/data-dive/queries/columns.ts

@@ -1,18 +1,18 @@
-import {PartTag} from "tuff-core/parts"
-import {ColumnDef, ModelDef, SchemaDef} from "../../terrier/schema"
-import {TableRef, TableView} from "./tables"
-import {Logger} from "tuff-core/logging"
-import Forms, {FormFields, SelectOptions} from "tuff-core/forms"
+import { PartTag } from "tuff-core/parts"
+import { ColumnDef, ModelDef, SchemaDef } from "../../terrier/schema"
+import { TableRef, TableView } from "./tables"
+import { Logger } from "tuff-core/logging"
+import Forms, { FormFields, SelectOptions } from "tuff-core/forms"
 import Objects from "tuff-core/objects"
-import {ModalPart} from "../../terrier/modals"
-import {Dropdown} from "../../terrier/dropdowns"
+import { ModalPart } from "../../terrier/modals"
+import { Dropdown } from "../../terrier/dropdowns"
 import DiveEditor from "../dives/dive-editor"
 import Messages from "tuff-core/messages"
 import Arrays from "tuff-core/arrays"
 import Dom from "tuff-core/dom"
-import Validation, {ColumnValidationError} from "./validation"
-import Queries, {Query} from "./queries"
-import {TerrierFormFields} from "../../terrier/forms"
+import Validation, { ColumnValidationError } from "./validation"
+import Queries, { Query } from "./queries"
+import { TerrierFormFields } from "../../terrier/forms"
 import TerrierPart from "../../terrier/parts/terrier-part"
 
 const log = new Logger("Columns")
@@ -115,7 +115,7 @@ export type ColumnsEditorState = {
 const saveKey = Messages.untypedKey()
 const addKey = Messages.untypedKey()
 const addSingleKey = Messages.typedKey<{ name: string }>()
-const removeKey = Messages.typedKey<{id: string}>()
+const removeKey = Messages.typedKey<{ id: string }>()
 const valueChangedKey = Messages.untypedKey()
 
 /**
@@ -131,11 +131,11 @@ export class ColumnsEditorModal extends ModalPart<ColumnsEditorState> {
     tableFields!: FormFields<TableRef>
 
 
-    async init () {
+    async init() {
         this.table = this.state.tableView.table
         this.modelDef = this.state.tableView.modelDef
 
-        this.tableFields = new FormFields(this, {...this.table})
+        this.tableFields = new FormFields(this, { ...this.table })
 
         // initialize the columns states
         const columns: ColumnRef[] = this.table.columns || []
@@ -149,13 +149,13 @@ export class ColumnsEditorModal extends ModalPart<ColumnsEditorState> {
         this.addAction({
             title: 'Apply',
             icon: 'glyp-checkmark',
-            click: {key: saveKey}
+            click: { key: saveKey }
         }, 'primary')
 
         this.addAction({
             title: 'Add Columns',
             icon: 'glyp-plus',
-            click: {key: addKey}
+            click: { key: addKey }
         }, 'secondary')
 
         this.onClick(saveKey, _ => {
@@ -171,7 +171,7 @@ export class ColumnsEditorModal extends ModalPart<ColumnsEditorState> {
         })
 
         this.onClick(addKey, m => {
-            this.toggleDropdown(SelectColumnsDropdown, {editor: this as ColumnsEditorModal}, m.event.target)
+            this.toggleDropdown(SelectColumnsDropdown, { editor: this as ColumnsEditorModal }, m.event.target)
         })
 
         this.onChange(valueChangedKey, m => {
@@ -189,7 +189,7 @@ export class ColumnsEditorModal extends ModalPart<ColumnsEditorState> {
 
     addEditor(col: ColumnRef) {
         this.columnCount += 1
-        const state = {schema: this.state.schema, columnsEditor: this, id: `column-${this.columnCount}`, column: col}
+        const state = { schema: this.state.schema, columnsEditor: this, id: `column-${this.columnCount}`, column: col }
         this.columnEditors[state.id] = this.makePart(ColumnEditor, state)
     }
 
@@ -227,10 +227,10 @@ export class ColumnsEditorModal extends ModalPart<ColumnsEditorState> {
         // the table of column editors
         parent.div('.dd-columns-editor-table', table => {
             table.div('.dd-editor-header', header => {
-                header.div('.name').label({text: "Name"})
-                header.div('.alias').label({text: "Alias"})
-                header.div('.function').label({text: "Function"})
-                header.div('.group-by').label({text: "Group By?"})
+                header.div('.name').label({ text: "Name" })
+                header.div('.alias').label({ text: "Alias" })
+                header.div('.function').label({ text: "Function" })
+                header.div('.group-by').label({ text: "Group By?" })
             })
             table.div('dd-editor-row-container', container => {
                 for (const id of Object.keys(this.columnEditors)) {
@@ -261,7 +261,7 @@ export class ColumnsEditorModal extends ModalPart<ColumnsEditorState> {
                             tr.td('.description').text(colDef.metadata?.description || '')
                             tr.td().a('.add-column.tt-button.secondary.circle.compact.inline', a => {
                                 a.i('.glyp-plus')
-                            }).emitClick(addSingleKey, {name: colDef.name})
+                            }).emitClick(addSingleKey, { name: colDef.name })
                         })
                     }
                 })
@@ -288,12 +288,12 @@ export class ColumnsEditorModal extends ModalPart<ColumnsEditorState> {
         // make a deep copy of the query and update this table's columns and settings
         this.table._id = this.id // we need this to identify the table after the deep copy
         const query = Objects.deepCopy(this.state.query)
-        Queries.eachTable(query, table => {
-            if (table._id == this.id) {
-                table.columns = columns
-                table.prefix = tableData.prefix
-            }
-        })
+        const tables = Queries.tables(query).
+            filter(table => table._id == this.id)
+        for (const table of tables) {
+            table.columns = columns
+            table.prefix = tableData.prefix
+        }
 
         // validate the temporary query
         log.info(`Validating temporary query with column changes`, query)
@@ -358,10 +358,10 @@ class ColumnEditor extends TerrierPart<ColumnState> {
 
     render(parent: PartTag) {
         parent.div('.name', col => {
-            col.div('.tt-readonly-field', {text: this.columnRef.name})
+            col.div('.tt-readonly-field', { text: this.columnRef.name })
         })
         parent.div('.alias', col => {
-            this.fields.textInput(col, "alias", {placeholder: "Alias"})
+            this.fields.textInput(col, "alias", { placeholder: "Alias" })
                 .emitChange(valueChangedKey)
         })
         parent.div('.function', col => {
@@ -375,7 +375,7 @@ class ColumnEditor extends TerrierPart<ColumnState> {
         parent.div('.actions', actions => {
             actions.a(a => {
                 a.i('.glyp-close')
-            }).emitClick(removeKey, {id: this.state.id})
+            }).emitClick(removeKey, { id: this.state.id })
         })
         if (this.columnRef.errors?.length) {
             for (const error of this.columnRef.errors) {
@@ -387,7 +387,7 @@ class ColumnEditor extends TerrierPart<ColumnState> {
     async serialize() {
         return await this.fields.serialize()
     }
-    
+
 }
 
 
@@ -406,7 +406,7 @@ type SelectableColumn = {
 /**
  * Shows a dropdown that allows the user to select one or more columns from the given model.
  */
-class SelectColumnsDropdown extends Dropdown<{editor: ColumnsEditorModal}> {
+class SelectColumnsDropdown extends Dropdown<{ editor: ColumnsEditorModal }> {
 
     addAllKey = Messages.untypedKey()
     addKey = Messages.typedKey<ColumnRef>()
@@ -431,9 +431,11 @@ class SelectColumnsDropdown extends Dropdown<{editor: ColumnsEditorModal}> {
             const description = colDef.metadata?.description || ''
             return {
                 def: colDef,
-                ref: {name: colDef.name},
+                ref: { name: colDef.name },
                 included,
-                sortOrder, description}
+                sortOrder,
+                description
+            }
         })
         this.columns = Arrays.sortBy(this.columns, 'sortOrder')
 
@@ -527,7 +529,7 @@ class SelectColumnsDropdown extends Dropdown<{editor: ColumnsEditorModal}> {
 
         parent.a('.primary', a => {
             a.i('.glyp-check_all')
-            a.span({text: "Add All"})
+            a.span({ text: "Add All" })
         }).emitClick(this.addAllKey)
     }
 

package/data-dive/queries/queries.ts

@@ -1,18 +1,18 @@
 import { Filter } from "./filters"
-import {TableRef} from "./tables"
-import api, {ApiResponse} from "../../terrier/api"
-import {PartTag} from "tuff-core/parts"
-import {TableCellTag} from "tuff-core/html"
+import { TableRef } from "./tables"
+import api, { ApiResponse } from "../../terrier/api"
+import { PartTag } from "tuff-core/parts"
+import { TableCellTag } from "tuff-core/html"
 import dayjs from "dayjs"
 import QueryEditor from "./query-editor"
 import TerrierPart from "../../terrier/parts/terrier-part"
-import Schema, {ModelDef, SchemaDef} from "../../terrier/schema"
-import {Logger} from "tuff-core/logging"
+import Schema, { ModelDef, SchemaDef } from "../../terrier/schema"
+import { Logger } from "tuff-core/logging"
 import * as inflection from "inflection"
 import Messages from "tuff-core/messages"
 import Strings from "tuff-core/strings"
 import Arrays from "tuff-core/arrays"
-import {ColumnRef} from "./columns"
+import { ColumnRef } from "./columns"
 import Ids from "../../terrier/ids";
 import Objects from "tuff-core/objects";
 
@@ -42,74 +42,46 @@ export type Query = {
 // Utilities
 ////////////////////////////////////////////////////////////////////////////////
 
-type TableFunction = (table: TableRef) => any
+function* childTables(table: TableRef): Generator<TableRef, void, void> {
+    if (!table.joins) return
 
-function eachChildTable(table: TableRef, fn: TableFunction) {
-    if (!table.joins) {
-        return
-    }
     for (const joinedTable of Object.values(table.joins)) {
-        fn(joinedTable)
-        eachChildTable(joinedTable, fn)
+        yield joinedTable
+        yield* childTables(joinedTable)
     }
 }
 
-/**
- * Recursively iterates through each table reference in the query and evaluates the function.
- * @param query
- * @param fn
- */
-function eachTable(query: Query, fn: TableFunction) {
-    fn(query.from)
-    eachChildTable(query.from, fn)
+function* tables(query: Query): Generator<TableRef, void, void> {
+    yield query.from
+    yield* childTables(query.from)
 }
 
-export type ColumnFunction = (table: TableRef, col: ColumnRef) => any
+function* tableColumns(table: TableRef): Generator<{ table: TableRef, column: ColumnRef }, void, void> {
+    if (table.columns)
+        for (const column of table.columns)
+            yield { table, column }
 
-function eachColumnForTable(table: TableRef, fn: ColumnFunction) {
-    if (table.columns) {
-        for (const col of table.columns) {
-            fn(table, col)
-        }
-    }
-    if (table.joins) {
-        for (const joinedTable of Object.values(table.joins)) {
-            eachColumnForTable(joinedTable, fn)
-        }
-    }
+    if (table.joins)
+        for (const joinedTable of Object.values(table.joins))
+            yield* tableColumns(joinedTable)
 }
 
-/**
- * Recursively iterates over all columns in a query.
- * @param query
- * @param fn a function to evaluate for each column in the query
- */
-function eachColumn(query: Query, fn: ColumnFunction) {
-    eachColumnForTable(query.from, fn)
+function columns(query: Query) {
+    return tableColumns(query.from)
 }
 
-export type FilterFunction = (table: TableRef, filter: Filter) => any
+function* tableFilters(table: TableRef): Generator<{ table: TableRef, filter: Filter }, void, void> {
+    if (table.filters)
+        for (const filter of table.filters)
+            yield ({ table, filter })
 
-function eachFilterForTable(table: TableRef, fn: FilterFunction) {
-    if (table.filters) {
-        for (const filter of table.filters) {
-            fn(table, filter)
-        }
-    }
-    if (table.joins) {
-        for (const joinedTable of Object.values(table.joins)) {
-            eachFilterForTable(joinedTable, fn)
-        }
-    }
+    if (table.joins)
+        for (const joinedTable of Object.values(table.joins))
+            yield* tableFilters(joinedTable)
 }
 
-/**
- * Recursively iterates over all filters in the query and executes the given function for each.
- * @param query
- * @param fn a function to evaluate on each filter
- */
-function eachFilter(query: Query, fn: FilterFunction) {
-    eachFilterForTable(query.from, fn)
+function filters(query: Query) {
+    return tableFilters(query.from)
 }
 
 /**
@@ -122,9 +94,8 @@ function duplicate(query: Query): Query {
     newQuery.id = Ids.makeUuid()
 
     // filters need new IDs, otherwise they won't be able to be set differently than the original query's filters
-    eachFilter(newQuery, (_, filter) => {
-        filter.id = Ids.makeUuid()
-    })
+    filters(query)
+        .forEach(({ filter }) => filter.id = Ids.makeUuid())
 
     return newQuery
 }
@@ -151,7 +122,7 @@ export type QueryServerValidation = ApiResponse & {
  * @param query
  */
 async function validate(query: Query): Promise<QueryServerValidation> {
-    return await api.post<QueryServerValidation>("/data_dive/validate_query.json", {query})
+    return await api.post<QueryServerValidation>("/data_dive/validate_query.json", { query })
 }
 
 
@@ -184,7 +155,7 @@ export type QueryResult = ApiResponse & {
  * @param query
  */
 async function preview(query: Query): Promise<QueryResult> {
-    return await api.post<QueryResult>("/data_dive/preview_query.json", {query})
+    return await api.post<QueryResult>("/data_dive/preview_query.json", { query })
 }
 
 
@@ -211,15 +182,15 @@ function renderCell(td: TableCellTag, col: QueryResultColumn, val: any): any {
             return td.div('.dollars').text(`\$${dollars}`)
         case 'cents':
             const cents = parseInt(val)
-            const d = (cents/100.0).toFixed(2)
+            const d = (cents / 100.0).toFixed(2)
             return td.div('.dollars').text(`\$${d}`)
         case 'string':
             if (col.select_name.endsWith('id')) {
                 const id = val.toString()
                 td.a('.id')
-                    .data({tooltip: id})
-                    .text(`...${id.substring(id.length-6)}`)
-                    .emitClick(QueryEditor.copyToClipboardKey, {value: id})
+                    .data({ tooltip: id })
+                    .text(`...${id.substring(id.length - 6)}`)
+                    .emitClick(QueryEditor.copyToClipboardKey, { value: id })
             }
             else {
                 td.text(val.toString())
@@ -307,8 +278,8 @@ export class QueryModelPicker extends TerrierPart<QueryModelPickerState> {
 
     renderModelOption(parent: PartTag, model: ModelDef) {
         parent.label('.model-option', label => {
-            label.input({type: 'radio', name: `new-query-model-${this.id}`, value: model.name})
-                .emitChange(this.pickedKey, {model: model.name})
+            label.input({ type: 'radio', name: `new-query-model-${this.id}`, value: model.name })
+                .emitChange(this.pickedKey, { model: model.name })
             label.div(col => {
                 const name = inflection.pluralize(Strings.titleize(model.name))
                 col.div('.name').text(name)
@@ -364,10 +335,16 @@ const Queries = {
     eachColumn,
     eachTable,
     eachFilter,
+    childTables,
+    tables,
+    tableColumns,
+    columns,
+    tableFilters,
+    filters,
     duplicate,
     validate,
     preview,
     renderPreview
 }
 
-export default Queries
+export default Queries

package/data-dive/queries/query-editor.ts

@@ -1,17 +1,18 @@
-import {PartTag} from "tuff-core/parts"
-import Queries, {Query, QueryResult, QueryServerValidation} from "./queries"
-import Tables, {FromTableView} from "./tables"
-import {Logger} from "tuff-core/logging"
-import QueryForm, {QuerySettings, QuerySettingsColumns} from "./query-form"
-import DiveEditor, {DiveEditorState} from "../dives/dive-editor"
+import { PartTag } from "tuff-core/parts"
+import Queries, { Query, QueryResult, QueryServerValidation } from "./queries"
+import Tables, { FromTableView } from "./tables"
+import { Logger } from "tuff-core/logging"
+import QueryForm, { QuerySettings, QuerySettingsColumns } from "./query-form"
+import DiveEditor, { DiveEditorState } from "../dives/dive-editor"
 import Objects from "tuff-core/objects"
 import Html from "tuff-core/html"
 import ContentPart from "../../terrier/parts/content-part"
-import {TabContainerPart} from "../../terrier/tabs"
+import { TabContainerPart } from "../../terrier/tabs"
 import Messages from "tuff-core/messages"
-import Validation, {QueryClientValidation} from "./validation"
+import Validation, { QueryClientValidation } from "./validation"
 import ColumnOrderModal from "./column-order-modal"
 import RowOrderModal from "./row-order-modal"
+import Columns from "./columns"
 
 const log = new Logger("QueryEditor")
 
@@ -32,7 +33,7 @@ class SettingsPart extends ContentPart<SubEditorState> {
     form!: QueryForm
 
     async init() {
-        this.form = this.makePart(QueryForm, {query: Objects.slice(this.state.query, ...QuerySettingsColumns)})
+        this.form = this.makePart(QueryForm, { query: Objects.slice(this.state.query, ...QuerySettingsColumns) })
     }
 
 
@@ -48,8 +49,8 @@ class SettingsPart extends ContentPart<SubEditorState> {
             })
             row.a('.alert.tt-flex', a => {
                 a.i('.glyp-delete')
-                a.span({text: "Delete"})
-            }).emitClick(DiveEditor.deleteQueryKey, {id: this.state.query.id})
+                a.span({ text: "Delete" })
+            }).emitClick(DiveEditor.deleteQueryKey, { id: this.state.query.id })
         })
     }
 
@@ -68,9 +69,11 @@ class SortingPart extends ContentPart<SubEditorState> {
     async init() {
         this.onClick(this.sortColumnsKey, _ => {
             log.info("Sorting columns")
+            this.state.query.columns = Array.from(Queries.tableColumns(this.state.query.from)).
+                map(({ table, column }) => Columns.computeSelectName(table, column))
             this.app.showModal(ColumnOrderModal, {
                 query: this.state.query,
-                onSorted: (newColumns) =>  {
+                onSorted: (newColumns) => {
                     this.state.query.columns = newColumns
                     this.state.editor.dirty()
                     this.emitMessage(DiveEditor.diveChangedKey, {})
@@ -82,7 +85,7 @@ class SortingPart extends ContentPart<SubEditorState> {
             log.info("Sorting rows")
             this.app.showModal(RowOrderModal, {
                 query: this.state.query,
-                onSorted: (newOrderBys) =>  {
+                onSorted: (newOrderBys) => {
                     log.info(`New row sort order`, newOrderBys)
                     this.state.query.order_by = newOrderBys
                     this.state.editor.dirty()
@@ -170,7 +173,7 @@ class SqlPart extends ContentPart<SubEditorState> {
                 })
             }
             else {
-                row.div({text: 'SQL Goes Here'})
+                row.div({ text: 'SQL Goes Here' })
             }
         })
     }
@@ -266,12 +269,12 @@ export default class QueryEditor extends ContentPart<QueryEditorState> {
 
         log.info("Initializing query editor", query)
 
-        this.tabs = this.makePart(TabContainerPart, {side: 'left'})
-        this.settingsPart = this.tabs.upsertTab({key: 'settings', title: 'Settings', icon: 'glyp-settings'},
-            SettingsPart, {editor: this, query})
+        this.tabs = this.makePart(TabContainerPart, { side: 'left' })
+        this.settingsPart = this.tabs.upsertTab({ key: 'settings', title: 'Settings', icon: 'glyp-settings' },
+            SettingsPart, { editor: this, query })
 
-        this.sortingPart = this.tabs.upsertTab({key: 'sorting', title: 'Sorting', icon: 'glyp-sort'},
-            SortingPart, {editor: this, query})
+        this.sortingPart = this.tabs.upsertTab({ key: 'sorting', title: 'Sorting', icon: 'glyp-sort' },
+            SortingPart, { editor: this, query })
 
 
         this.listenMessage(QueryForm.settingsChangedKey, m => {
@@ -279,13 +282,13 @@ export default class QueryEditor extends ContentPart<QueryEditorState> {
             this.updateSettings(m.data)
         })
 
-        this.sqlPart = this.tabs.upsertTab({key: 'sql', title: 'SQL', icon: 'glyp-code'},
-            SqlPart, {editor: this, query})
+        this.sqlPart = this.tabs.upsertTab({ key: 'sql', title: 'SQL', icon: 'glyp-code' },
+            SqlPart, { editor: this, query })
 
-        this.previewPart = this.tabs.upsertTab({key: 'preview', title: 'Preview', icon: 'glyp-table', classes: ['no-padding'], click: {key: this.updatePreviewKey}},
-            PreviewPart, {editor: this, query})
+        this.previewPart = this.tabs.upsertTab({ key: 'preview', title: 'Preview', icon: 'glyp-table', classes: ['no-padding'], click: { key: this.updatePreviewKey } },
+            PreviewPart, { editor: this, query })
 
-        this.tableEditor = this.makePart(FromTableView, {schema: this.state.schema, queryEditor: this, table: this.state.query.from})
+        this.tableEditor = this.makePart(FromTableView, { schema: this.state.schema, queryEditor: this, table: this.state.query.from })
 
         this.listenMessage(Tables.updatedKey, m => {
             log.info(`Table ${m.data.model} updated`, m.data)
@@ -300,7 +303,7 @@ export default class QueryEditor extends ContentPart<QueryEditorState> {
         this.onClick(QueryEditor.copyToClipboardKey, async m => {
             log.info(`Copy value to clipboard: ${m.data.value}`)
             await navigator.clipboard.writeText(m.data.value)
-            this.showToast(`Copied '${m.data.value}' to clipboard`, {color: 'primary'})
+            this.showToast(`Copied '${m.data.value}' to clipboard`, { color: 'primary' })
         })
 
         this.validate().then()
@@ -341,4 +344,4 @@ export default class QueryEditor extends ContentPart<QueryEditorState> {
     }
 
     static readonly copyToClipboardKey = Messages.typedKey<{ value: string }>()
-}
+}

package/data-dive/queries/row-order-modal.ts

@@ -1,10 +1,10 @@
-import {ModalPart} from "../../terrier/modals"
+import { ModalPart } from "../../terrier/modals"
 import Columns from "./columns"
-import Queries, {OrderBy, Query} from "./queries"
+import Queries, { OrderBy, Query } from "./queries"
 import Messages from "tuff-core/messages"
-import {PartTag} from "tuff-core/parts"
-import {optionsForSelect, SelectOption} from "tuff-core/forms"
-import {Logger} from "tuff-core/logging"
+import { PartTag } from "tuff-core/parts"
+import { optionsForSelect, SelectOption } from "tuff-core/forms"
+import { Logger } from "tuff-core/logging"
 import Forms from "../../terrier/forms"
 import SortablePlugin from "tuff-sortable/sortable-plugin";
 
@@ -22,7 +22,7 @@ export default class RowOrderModal extends ModalPart<RowOrderState> {
     changedKey = Messages.untypedKey()
     orderBys: OrderBy[] = []
     columnOptions: SelectOption[] = []
-    removeClauseKey = Messages.typedKey<{index: number}>()
+    removeClauseKey = Messages.typedKey<{ index: number }>()
 
     async init() {
         this.setTitle("Row Order")
@@ -31,7 +31,7 @@ export default class RowOrderModal extends ModalPart<RowOrderState> {
         this.addAction({
             title: "Apply",
             icon: "glyp-checkmark",
-            click: {key: this.submitKey}
+            click: { key: this.submitKey }
         })
 
         this.onClick(this.submitKey, _ => {
@@ -42,7 +42,7 @@ export default class RowOrderModal extends ModalPart<RowOrderState> {
         this.addAction({
             title: "New Clause",
             icon: "glyp-plus",
-            click: {key: this.newClauseKey}
+            click: { key: this.newClauseKey }
         }, 'secondary')
 
         this.onClick(this.newClauseKey, _ => {
@@ -56,11 +56,12 @@ export default class RowOrderModal extends ModalPart<RowOrderState> {
         // collect the column options
         const query = this.state.query
         const existingColumns = new Set<string>()
-        Queries.eachColumn(query, (table, col) => {
-            const name = Columns.computeSelectName(table, col)
+        for (const { table, column } of Queries.columns(query)) {
+            const name = Columns.computeSelectName(table, column)
             existingColumns.add(name)
-            this.columnOptions.push({title: name, value: name})
-        })
+            this.columnOptions.push({ title: name, value: name })
+
+        }
 
         // initialize the order-bys from the query, if present
         if (query.order_by?.length) {
@@ -88,7 +89,7 @@ export default class RowOrderModal extends ModalPart<RowOrderState> {
     }
 
     addClause() {
-        this.orderBys.push({column: this.columnOptions[0]?.value || '', dir: 'asc'})
+        this.orderBys.push({ column: this.columnOptions[0]?.value || '', dir: 'asc' })
         log.info(`Added a line, orderBys is now ${this.orderBys.length} long`, this.orderBys)
         this.dirty()
     }
@@ -107,7 +108,7 @@ export default class RowOrderModal extends ModalPart<RowOrderState> {
             this.element.querySelectorAll<HTMLElement>(".order-by").forEach(line => {
                 const column = line.querySelector<HTMLSelectElement>("select.column")?.value!!
                 const dir = Forms.getRadioValue(line, "input.dir") || "asc"
-                this.orderBys.push({column, dir})
+                this.orderBys.push({ column, dir })
             })
             log.info("Serialized", this.orderBys)
         }
@@ -119,9 +120,9 @@ export default class RowOrderModal extends ModalPart<RowOrderState> {
             container.div(".dive-row-sort-zone", zone => {
                 let index = 0 // for making unique radio names
                 for (const orderBy of this.orderBys) {
-                    zone.div(".order-by", {data: {index: index.toString()}}, line => {
+                    zone.div(".order-by", { data: { index: index.toString() } }, line => {
                         line.a(".drag.glyp-navicon")
-                            .data({tooltip: "Re-order this clause"})
+                            .data({ tooltip: "Re-order this clause" })
                         line.select('.column', colSelect => {
                             optionsForSelect(colSelect, this.columnOptions, orderBy.column)
                         }).emitChange(this.changedKey)
@@ -144,8 +145,8 @@ export default class RowOrderModal extends ModalPart<RowOrderState> {
                             label.span().text("descending")
                         })
                         line.a(".remove.glyp-close")
-                            .data({tooltip: "Remove this clause"})
-                            .emitClick(this.removeClauseKey, {index})
+                            .data({ tooltip: "Remove this clause" })
+                            .emitClick(this.removeClauseKey, { index })
                     })
                     index += 1
                 }

package/data-dive/queries/tables.ts

@@ -1,18 +1,18 @@
-import {PartTag} from "tuff-core/parts"
-import Schema, {BelongsToDef, ModelDef, SchemaDef} from "../../terrier/schema"
+import { PartTag } from "tuff-core/parts"
+import Schema, { BelongsToDef, ModelDef, SchemaDef } from "../../terrier/schema"
 import * as inflection from "inflection"
-import Filters, {Filter, FilterInput, FiltersEditorModal} from "./filters"
-import Columns, {ColumnRef, ColumnsEditorModal} from "./columns"
-import {Logger} from "tuff-core/logging"
+import Filters, { Filter, FilterInput, FiltersEditorModal } from "./filters"
+import Columns, { ColumnRef, ColumnsEditorModal } from "./columns"
+import { Logger } from "tuff-core/logging"
 import ContentPart from "../../terrier/parts/content-part"
-import {ActionsDropdown} from "../../terrier/dropdowns"
-import {ModalPart} from "../../terrier/modals"
+import { ActionsDropdown } from "../../terrier/dropdowns"
+import { ModalPart } from "../../terrier/modals"
 import TerrierFormPart from "../../terrier/parts/terrier-form-part"
 import DiveEditor from "../dives/dive-editor"
 import Messages from "tuff-core/messages"
 import Arrays from "tuff-core/arrays"
 import QueryEditor from "./query-editor"
-import {Query} from "./queries";
+import { Query } from "./queries";
 
 const log = new Logger("Tables")
 
@@ -85,7 +85,7 @@ export class TableView<T extends TableRef> extends ContentPart<{ schema: SchemaD
     editColumnsKey = Messages.untypedKey()
     editFiltersKey = Messages.untypedKey()
     newJoinedKey = Messages.untypedKey()
-    createJoinedKey = Messages.typedKey<{name: string}>()
+    createJoinedKey = Messages.typedKey<{ name: string }>()
 
     async init() {
         this.schema = this.state.schema
@@ -102,12 +102,12 @@ export class TableView<T extends TableRef> extends ContentPart<{ schema: SchemaD
 
         this.onClick(this.editColumnsKey, _ => {
             log.info(`Edit ${this.displayName} Columns`)
-            this.app.showModal(ColumnsEditorModal, {schema: this.schema, query: this.query, tableView: this as TableView<TableRef>})
+            this.app.showModal(ColumnsEditorModal, { schema: this.schema, query: this.query, tableView: this as TableView<TableRef> })
         })
 
         this.onClick(this.editFiltersKey, _ => {
             log.info(`Edit ${this.displayName} Filters`)
-            this.app.showModal(FiltersEditorModal, {schema: this.schema, tableView: this as TableView<TableRef>})
+            this.app.showModal(FiltersEditorModal, { schema: this.schema, tableView: this as TableView<TableRef> })
         })
 
         // show the new join dropdown
@@ -127,19 +127,19 @@ export class TableView<T extends TableRef> extends ContentPart<{ schema: SchemaD
                 const common = model.metadata?.visibility == 'common' ? '0' : '1'
                 return `${common}${bt.name}`
             })
-            .map(bt => {
-                const model = this.schema.models[bt.model]
-                const isCommon = model.metadata?.visibility == 'common'
-                // put a border between the common and uncommon
-                const classes = showingCommon && !isCommon ? ['border-top'] : []
-                showingCommon = isCommon
-                return {
-                    title: Schema.belongsToDisplay(bt),
-                    subtitle: model.metadata?.description,
-                    classes,
-                    click: {key: this.createJoinedKey, data: {name: bt.name}}
-                }
-            })
+                .map(bt => {
+                    const model = this.schema.models[bt.model]
+                    const isCommon = model.metadata?.visibility == 'common'
+                    // put a border between the common and uncommon
+                    const classes = showingCommon && !isCommon ? ['border-top'] : []
+                    showingCommon = isCommon
+                    return {
+                        title: Schema.belongsToDisplay(bt),
+                        subtitle: model.metadata?.description,
+                        classes,
+                        click: { key: this.createJoinedKey, data: { name: bt.name } }
+                    }
+                })
 
 
             // don't show the dropdown if there are no more belongs-tos left
@@ -147,7 +147,7 @@ export class TableView<T extends TableRef> extends ContentPart<{ schema: SchemaD
                 this.toggleDropdown(ActionsDropdown, actions, m.event.target)
             }
             else {
-                this.showToast(`No more possible joins for ${this.displayName}`, {color: 'pending'})
+                this.showToast(`No more possible joins for ${this.displayName}`, { color: 'pending' })
             }
         })
 
@@ -170,13 +170,13 @@ export class TableView<T extends TableRef> extends ContentPart<{ schema: SchemaD
                         this.dirty()
                     }
                 }
-                this.app.showModal(JoinedTableEditorModal, {table, belongsTo, callback, parentTable: this.state.table as TableRef})
+                this.app.showModal(JoinedTableEditorModal, { table, belongsTo, callback, parentTable: this.state.table as TableRef })
             }
         })
     }
 
     addJoinedPart(joinedTable: JoinedTableRef) {
-        const state = {schema: this.schema, queryEditor: this.state.queryEditor, table: joinedTable}
+        const state = { schema: this.schema, queryEditor: this.state.queryEditor, table: joinedTable }
         const part = this.makePart(JoinedTableView, state)
         part.parentView = this
         this.joinParts[joinedTable.belongs_to] = part
@@ -241,8 +241,8 @@ export class TableView<T extends TableRef> extends ContentPart<{ schema: SchemaD
                 panel.a('.dd-hint.joins.arrow-top.glyp-hint', hint => {
                     hint.div('.title').text("Join More Tables")
                 })
-                .emitClick(this.newJoinedKey)
-                .data({tooltip: "Include data from other tables that are related to this one"})
+                    .emitClick(this.newJoinedKey)
+                    .data({ tooltip: "Include data from other tables that are related to this one" })
             }
         })
 
@@ -252,7 +252,7 @@ export class TableView<T extends TableRef> extends ContentPart<{ schema: SchemaD
         parent.section(section => {
             section.div('.title', title => {
                 title.i(".glyp-columns")
-                title.span({text: "Columns"})
+                title.span({ text: "Columns" })
                 if (this.table.prefix?.length) {
                     title.span('.prefix').text(`${this.table.prefix}*`)
                 }
@@ -285,7 +285,7 @@ export class TableView<T extends TableRef> extends ContentPart<{ schema: SchemaD
         parent.section('.filters', section => {
             section.div('.title', title => {
                 title.i(".glyp-filter")
-                title.span({text: "Filters"})
+                title.span({ text: "Filters" })
             })
             if (this.table.filters?.length) {
                 for (const filter of this.table.filters) {
@@ -439,7 +439,7 @@ class JoinedTableEditorModal extends ModalPart<JoinedTableEditorState> {
         this.addAction({
             title: "Apply",
             icon: 'glyp-checkmark',
-            click: {key: this.applyKey}
+            click: { key: this.applyKey }
         }, 'primary')
 
         this.onClick(this.applyKey, async _ => {
@@ -455,7 +455,7 @@ class JoinedTableEditorModal extends ModalPart<JoinedTableEditorState> {
             this.addAction({
                 title: "Delete",
                 icon: "glyp-delete",
-                click: {key: this.deleteKey},
+                click: { key: this.deleteKey },
                 classes: ['alert']
             }, 'secondary')
 
@@ -483,4 +483,4 @@ const Tables = {
     computeFilterInputs
 }
 
-export default Tables
+export default Tables

package/data-dive/queries/validation.ts

@@ -1,6 +1,6 @@
-import Queries, {Query} from "./queries"
-import Columns, {ColumnRef} from "./columns"
-import {TableRef} from "./tables"
+import Queries, { Query } from "./queries"
+import Columns, { ColumnRef } from "./columns"
+import { TableRef } from "./tables"
 
 export type ColumnValidationError = {
     message: string
@@ -24,7 +24,7 @@ function validateQuery(query: Query): QueryClientValidation {
     }
 
     function addColumnError(col: ColumnRef, message: string) {
-        const error = {message}
+        const error = { message }
         col.errors ||= []
         col.errors.push(error)
         validation.columns.push(error)
@@ -35,40 +35,41 @@ function validateQuery(query: Query): QueryClientValidation {
     const aggCols: ColumnRef[] = [] // keep track of columns with an aggregate function
     let isGrouped = false
     const groupedTables: Set<TableRef> = new Set()
-    Queries.eachColumn(query, (table, col) => {
+    for (const { table, column } of Queries.columns(query)) {
         // clear the errors
-        col.errors = undefined
+        column.errors = undefined
 
         // determine if there's an aggregate function
-        if (col.function?.length && Columns.functionType(col.function) == 'aggregate') {
-            aggCols.push(col)
+        if (column.function?.length && Columns.functionType(column.function) == 'aggregate') {
+            aggCols.push(column)
         }
 
         // determine if there's a _group by_ in the query
-        if (col.grouped) {
+        if (column.grouped) {
             isGrouped = true
-            if (col.name == 'id') {
+            if (column.name == 'id') {
                 // ungrouped columns on this table are okay
                 groupedTables.add(table)
             }
         }
 
         // each select name should only be used once
-        const selectName = Columns.computeSelectName(table, col)
+        const selectName = Columns.computeSelectName(table, column)
         if (usedNames.has(selectName)) {
-            addColumnError(col, `<strong>${selectName}</strong> has already been selected for a different column`)
+            addColumnError(column, `<strong>${selectName}</strong> has already been selected for a different column`)
         }
         usedNames.add(selectName)
-    })
+    }
 
     if (isGrouped) {
         // if the query is grouped, ensure that all other column refs
         // are either grouped, have an aggregate function, or are on a grouped table
-        Queries.eachColumn(query, (table, col) => {
-            if (!col.grouped && Columns.functionType(col.function) != 'aggregate' && !groupedTables.has(table)) {
-                addColumnError(col, `<strong>${col.name}</strong> must be grouped or have an aggregate function`)
-            }
-        })
+        const columns = Queries.columns(query)
+            .filter(({ table, column }) =>
+                !column.grouped && Columns.functionType(column.function) != 'aggregate' && !groupedTables.has(table))
+        for (const { column } of columns) {
+            addColumnError(column, `<strong>${column.name}</strong> must be grouped or have an aggregate function`)
+        }
     }
     else if (aggCols.length) {
         // if the query isn't grouped, aggregate functions are an error

package/package.json

@@ -4,7 +4,7 @@
   "files": [
     "*"
   ],
-  "version": "4.52.6",
+  "version": "4.52.7",
   "repository": {
     "type": "git",
     "url": "https://github.com/Terrier-Tech/terrier-engine"

package/terrier/modals.ts

@@ -1,6 +1,6 @@
-import {Logger} from "tuff-core/logging"
+import { Logger } from "tuff-core/logging"
 import TerrierPart from "./parts/terrier-part"
-import {PartConstructor, PartTag} from "tuff-core/parts"
+import { PartConstructor, PartTag } from "tuff-core/parts"
 import ContentPart from "./parts/content-part"
 import Messages from "tuff-core/messages"
 
@@ -27,13 +27,13 @@ export abstract class ModalPart<TState> extends ContentPart<TState> {
         this.emitMessage(modalPopKey, {}, { scope: 'bubble' })
     }
 
-    render(parent: PartTag)  {
+    render(parent: PartTag) {
         parent.div('.modal-header', header => {
             if (this._icon) {
                 this.theme.renderIcon(header, this._icon, 'secondary')
             }
-            header.h2({text: this._title || 'Call setTitle()'})
-            this.theme.renderActions(header, this.getActions('tertiary'), {defaultClass: 'secondary'})
+            header.h2({ text: this._title || 'Call setTitle()' })
+            this.theme.renderActions(header, this.getActions('tertiary'), { defaultClass: 'secondary' })
             header.a('.close-modal', closeButton => {
                 this.theme.renderCloseIcon(closeButton)
             }).emitClick(modalPopKey)
@@ -165,7 +165,7 @@ export class ModalStackPart extends TerrierPart<{}> {
         if (this.displayClass == 'show') {
             classes.push(this.displayClass)
         }
-        parent.div('.tt-modal-stack', {classes}, stack => {
+        parent.div('.tt-modal-stack', { classes }, stack => {
             stack.div('.modal-container', container => {
                 this.eachChild(part => {
                     container.part(part)