terrier-engine 4.41.2 → 4.44.0

package/data-dive/dives/dive-editor.ts

@@ -416,6 +416,7 @@ class DuplicateQueryModal extends ModalPart<DuplicateQueryState> {
         this.state.editor.queryTabs.showTab(query.id)
         this.pop()
         this.app.successToast("Duplicated Query", 'glyp-copy')
+        this.emitMessage(DiveEditor.diveChangedKey, {})
     }
 
     renderContent(parent: PartTag): void {

package/data-dive/dives/dive-runs.ts

@@ -1,3 +1,4 @@
+import Arrays from "tuff-core/arrays"
 import {ModalPart} from "../../terrier/modals"
 import {PartTag} from "tuff-core/parts"
 import {DdDive, DdDiveRun, UnpersistedDdDiveRun} from "../gen/models"
@@ -191,8 +192,12 @@ export class DiveRunModal extends ModalPart<{dive: DdDive }> {
             col.div('.tt-flex.collapsible.gap.tt-form', row => {
                 // inputs
                 row.div('.tt-flex.column.dd-dive-run-inputs', col => {
-                    for (const filter of this.filters) {
-                        this.renderInput(col, filter)
+                    const filtersByQuery = Arrays.groupBy(this.filters, 'query_name')
+                    for (const queryName of Object.keys(filtersByQuery).sort()) {
+                        col.h3(".glyp-data_dive_query").text(queryName)
+                        for (const filter of filtersByQuery[queryName]) {
+                            this.renderInput(col, filter)
+                        }
                     }
                 })
 

package/data-dive/dives/dives.ts

@@ -61,7 +61,7 @@ async function list(): Promise<DiveListResult> {
 function computeFilterInputs(schema: SchemaDef, dive: DdDive): FilterInput[] {
     const filters: Record<string, FilterInput> = {}
     for (const query of dive.query_data?.queries || []) {
-        Tables.computeFilterInputs(schema, query.from, filters)
+        Tables.computeFilterInputs(schema, query, query.from, filters)
     }
     return Object.values(filters)
 }

package/data-dive/queries/filters.ts

@@ -1,6 +1,7 @@
 import {PartTag} from "tuff-core/parts"
 import Dates, {DateLiteral, VirtualDatePeriod, VirtualDateRange} from "./dates"
 import {ColumnDef, ModelDef, SchemaDef} from "../../terrier/schema"
+import { Query } from "./queries"
 import {TableRef, TableView} from "./tables"
 import {Logger} from "tuff-core/logging"
 import * as inflection from "inflection"
@@ -683,6 +684,7 @@ class AddFilterDropdown extends Dropdown<{modelDef: ModelDef, callback: AddFilte
 ////////////////////////////////////////////////////////////////////////////////
 
 export type FilterInput = Filter & {
+    query_name: string
     input_name: string
     input_value: string
     possible_values?: string[]
@@ -694,12 +696,12 @@ export type FilterInput = Filter & {
  * @param table
  * @param filter
  */
-function toInput(schema: SchemaDef, table: TableRef, filter: Filter): FilterInput {
+function toInput(schema: SchemaDef, query: Query, table: TableRef, filter: Filter): FilterInput {
     if (!filter.id?.length) {
         filter.id = Ids.makeRandom(8)
     }
     const name = `${table.model}.${filter.column}`
-    const filterInput: FilterInput = {...filter, input_name: name, input_value: ''}
+    const filterInput: FilterInput = {...filter, query_name: query.name, input_name: name, input_value: ''}
     switch (filter.filter_type) {
         case 'inclusion':
             const modelDef = schema.models[table.model]

package/data-dive/queries/queries.ts

@@ -1,3 +1,4 @@
+import { Filter } from "./filters"
 import {TableRef} from "./tables"
 import api, {ApiResponse} from "../../terrier/api"
 import {PartTag} from "tuff-core/parts"
@@ -63,7 +64,7 @@ function eachTable(query: Query, fn: TableFunction) {
     eachChildTable(query.from, fn)
 }
 
-type ColumnFunction = (table: TableRef, col: ColumnRef) => any
+export type ColumnFunction = (table: TableRef, col: ColumnRef) => any
 
 function eachColumnForTable(table: TableRef, fn: ColumnFunction) {
     if (table.columns) {
@@ -87,14 +88,44 @@ function eachColumn(query: Query, fn: ColumnFunction) {
     eachColumnForTable(query.from, fn)
 }
 
+export type FilterFunction = (table: TableRef, filter: Filter) => any
+
+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)
+        }
+    }
+}
+
 /**
- * Duplicates a query, including all of the nested data structures.
+ * 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)
+}
+
+/**
+ * Duplicates a query, including all the nested data structures.
  * @param query the query to duplicate
  * @return a completely new query
  */
 function duplicate(query: Query): Query {
     const newQuery = Objects.deepCopy(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()
+    })
+
     return newQuery
 }
 
@@ -332,6 +363,7 @@ export class QueryModelPicker extends TerrierPart<QueryModelPickerState> {
 const Queries = {
     eachColumn,
     eachTable,
+    eachFilter,
     duplicate,
     validate,
     preview,

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

@@ -1,4 +1,5 @@
 import {ModalPart} from "../../terrier/modals"
+import Columns from "./columns"
 import Queries, {OrderBy, Query} from "./queries"
 import Messages from "tuff-core/messages"
 import {PartTag} from "tuff-core/parts"
@@ -54,15 +55,19 @@ export default class RowOrderModal extends ModalPart<RowOrderState> {
 
         // collect the column options
         const query = this.state.query
-        Queries.eachColumn(query, (_, col) => {
-            this.columnOptions.push({title: col.name, value: col.name})
+        const existingColumns = new Set<string>()
+        Queries.eachColumn(query, (table, col) => {
+            const name = Columns.computeSelectName(table, col)
+            existingColumns.add(name)
+            this.columnOptions.push({title: name, value: name})
         })
 
-        // initialize the order=bys from the query, if present
+        // initialize the order-bys from the query, if present
         if (query.order_by?.length) {
-            this.orderBys = query.order_by
+            // filter out columns that are no longer present in the query
+            this.orderBys = query.order_by.filter(ob => existingColumns.has(ob.column))
         }
-        else {
+        if (!query.order_by?.length) { // this isn't an else because the previous clause might've resulted in no columns
             // start with something by default
             this.addClause()
         }

package/data-dive/queries/tables.ts

@@ -47,22 +47,19 @@ const updatedKey = Messages.typedKey<TableRef>()
 ////////////////////////////////////////////////////////////////////////////////
 
 /**
- * Recursively collect  s all of the filters for this and all joined tables.
- * Only keep one (the last one traversed) per table/column combination.
- * This means that some filters may clobber others, but I think it will yield
- * the desired result most of the time.
+ * Recursively collects all the filters for this and all joined tables.
  * @param schema
  * @param table
  * @param filters
  */
-function computeFilterInputs(schema: SchemaDef, table: TableRef, filters: Record<string, FilterInput>) {
+function computeFilterInputs(schema: SchemaDef, query: Query, table: TableRef, filters: Record<string, FilterInput>) {
     for (const f of table.filters || []) {
-        const fi = Filters.toInput(schema, table, f)
+        const fi = Filters.toInput(schema, query, table, f)
         filters[fi.id] = fi
     }
     if (table.joins) {
         for (const j of Object.values(table.joins)) {
-            computeFilterInputs(schema, j, filters)
+            computeFilterInputs(schema, query, j, filters)
         }
     }
 }

package/package.json

@@ -4,7 +4,7 @@
   "files": [
     "*"
   ],
-  "version": "4.41.2",
+  "version": "4.44.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/Terrier-Tech/terrier-engine"
@@ -20,18 +20,19 @@
     "inflection": "^2.0.1",
     "mime-types": "^2.1.35",
     "tuff-core": "latest",
-    "tuff-plot": "^0.3.0",
+    "tuff-plot": "latest",
     "tuff-sortable": "latest",
     "turbolinks": "^5.2.0"
   },
   "devDependencies": {
     "@types/mime-types": "^2.1.4",
-    "@types/node": "^18.16.3",
+    "@types/node": "^22.9.0",
     "glyphs2font": "^1.2.4",
     "prettier": "^2.8.8",
     "svgo": "^3.0.2",
-    "vite": "^5.4.8",
+    "typescript": "^5.6.3",
+    "vite": "^5.4.11",
     "vite-plugin-ruby": "^5.1.0",
-    "vitest": "^0.31.1"
+    "vitest": "^2.1.5"
   }
 }

package/terrier/app.ts

@@ -1,5 +1,5 @@
 import {Logger} from "tuff-core/logging"
-import {Part, PartConstructor, PartParent} from "tuff-core/parts"
+import {Part, PartConstructor} from "tuff-core/parts"
 import TerrierPart from "./parts/terrier-part"
 import Tooltips from "./tooltips"
 import Lightbox from "./lightbox"
@@ -48,8 +48,8 @@ export abstract class TerrierApp<TState> extends TerrierPart<TState> {
     /// Overlays
 
     addOverlay<OverlayType extends Part<StateType>, StateType extends {}>(
-        constructor: { new(p: PartParent, id: string, state: StateType): OverlayType; },
-        state: StateType,
+        constructor: PartConstructor<OverlayType, StateType>,
+        state: NoInfer<StateType>,
         type: OverlayLayerType
     ) {
         return this.overlayPart.pushLayer(constructor, state, type)
@@ -85,7 +85,7 @@ export abstract class TerrierApp<TState> extends TerrierPart<TState> {
 
     showModal<ModalType extends ModalPart<StateType>, StateType>(
         constructor: PartConstructor<ModalType, StateType>,
-        state: StateType
+        state: NoInfer<StateType>
     ): ModalType {
         const modalStack = this.overlayPart.getOrCreateLayer(ModalStackPart, {}, 'modal')
         const modal = modalStack.pushModal(constructor, state)

package/terrier/lightbox.ts

@@ -70,14 +70,14 @@ class LightboxPart extends Part<LightboxState> {
     }
 
     update(_elem: HTMLElement) {
-        setTimeout(_ => {
+        setTimeout(() => {
             _elem.classList.add('active') // start css fade in
         }, 10)
     }
 
     close() {
         this.element?.classList.remove('active')
-        setTimeout(_ => {
+        setTimeout(() => {
             this.state.app.removeOverlay(this.state)
         }, 500)
     }

package/terrier/modals.ts

@@ -147,7 +147,10 @@ export class ModalStackPart extends TerrierPart<{}> {
      * @param constructor the modal class
      * @param state the modal's state
      */
-    pushModal<StateType>(constructor: PartConstructor<ModalPart<StateType>, StateType>, state: StateType): ModalPart<StateType> {
+    pushModal<ModalType extends ModalPart<StateType>, StateType>(
+        constructor: PartConstructor<ModalType, StateType>,
+        state: NoInfer<StateType>
+    ): ModalPart<StateType> {
         log.info(`Making modal`, constructor.name)
         const modal = this.makePart(constructor, state)
         this.modals.push(modal)

package/terrier/overlays.ts

@@ -33,7 +33,7 @@ export class OverlayPart extends Part<NoState> {
      */
     pushLayer<PartType extends Part<StateType>, StateType extends {}>(
         constructor: PartConstructor<PartType, StateType>,
-        state: StateType,
+        state: NoInfer<StateType>,
         type: OverlayLayerType
     ): PartType {
         this.layerStates.push({partClass: constructor, partState: state, type})
@@ -50,7 +50,7 @@ export class OverlayPart extends Part<NoState> {
      */
     getOrCreateLayer<PartType extends Part<StateType>, StateType extends {}>(
         constructor: PartConstructor<PartType, StateType>,
-        state: StateType,
+        state: NoInfer<StateType>,
         type: OverlayLayerType
     ): PartType {
         const layers = this.getCollectionParts('layers')

package/terrier/parts/terrier-part.ts

@@ -1,4 +1,4 @@
-import {Part, PartParent, PartTag} from "tuff-core/parts"
+import { Part, PartConstructor, PartTag } from "tuff-core/parts"
 import {TerrierApp} from "../app"
 import Loading from "../loading"
 import Theme, {IconName} from "../theme"
@@ -171,8 +171,8 @@ export default abstract class TerrierPart<TState> extends Part<TState> {
      * @param target the target element around which to show the dropdown
      */
     makeDropdown<DropdownType extends Dropdown<DropdownStateType>, DropdownStateType extends {}>(
-        constructor: { new(p: PartParent, id: string, state: DropdownStateType): DropdownType; },
-        state: DropdownStateType,
+        constructor: PartConstructor<DropdownType, DropdownStateType>,
+        state: NoInfer<DropdownStateType>,
         target: EventTarget | null) {
         const dropdown = this.app.addOverlay(constructor, state, 'dropdown')
         dropdown.parentPart = this
@@ -193,8 +193,8 @@ export default abstract class TerrierPart<TState> extends Part<TState> {
      * @param target the target element around which to show the dropdown
      */
     toggleDropdown<DropdownType extends Dropdown<DropdownStateType>, DropdownStateType extends {}>(
-        constructor: { new(p: PartParent, id: string, state: DropdownStateType): DropdownType; },
-        state: DropdownStateType,
+        constructor: PartConstructor<DropdownType, DropdownStateType>,
+        state: NoInfer<DropdownStateType>,
         target: EventTarget | null) {
         if (target && target instanceof HTMLElement && target == this.app.lastDropdownTarget) {
             this.clearDropdowns()

package/tsconfig.json

@@ -8,7 +8,7 @@
       "ESNext",
       "DOM"
     ],
-    "moduleResolution" : "Node",
+    "moduleResolution" : "bundler",
     "strict" : true,
     "sourceMap" : true,
     "resolveJsonModule" : true,