terrier-engine 4.46.0 → 4.50.2

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

@@ -1,14 +1,23 @@
-import {PartTag} from "tuff-core/parts"
-import DiveEditor, {DiveEditorState} from "./dive-editor"
+import { PartTag } from "tuff-core/parts"
+import { DiveEditorState } from "./dive-editor"
 import TerrierPart from "../../terrier/parts/terrier-part"
-import {RegularSchedule, RegularScheduleFields} from "../../terrier/schedules"
-import {Logger} from "tuff-core/logging"
-import {EmailListForm} from "../../terrier/emails"
-import {DdDiveRun} from "../gen/models"
+import Schedules, { RegularScheduleFields } from "../../terrier/schedules"
+import { Logger } from "tuff-core/logging"
+import { EmailListForm } from "../../terrier/emails"
+import {
+    DdDive,
+    DdDiveDistribution,
+    DdDiveRun,
+    UnpersistedDdDiveDistribution
+} from "../gen/models";
 import Db from "../dd-db"
 import dayjs from "dayjs"
 import Dates from "../queries/dates"
 import DiveRuns from "./dive-runs"
+import { ModalPart } from "../../terrier/modals"
+import { TerrierFormFields } from "../../terrier/forms"
+import Messages from "tuff-core/messages"
+import Fragments from "../../terrier/fragments"
 
 const log = new Logger("Dive Delivery")
 
@@ -17,43 +26,71 @@ const log = new Logger("Dive Delivery")
 // Delivery Form
 ////////////////////////////////////////////////////////////////////////////////
 
-export type DiveDeliverySettings = {
-    delivery_schedule: RegularSchedule
-    delivery_recipients: string[]
-}
-
-export class DiveDeliveryForm extends TerrierPart<DiveEditorState> {
+export class DiveDeliveryPanel extends TerrierPart<DiveEditorState> {
 
-    scheduleFields!: RegularScheduleFields
-    recipientsForm!: EmailListForm
+    distributions!: DdDiveDistribution[]
     deliveryList!: DiveDeliveryList
 
+    newKey = Messages.untypedKey()
+    editKey = Messages.typedKey<{id: string}>()
+    static reloadKey = Messages.untypedKey()
+
     async init() {
-        const schedule = this.state.dive.delivery_schedule || {schedule_type: 'none'}
-        this.scheduleFields = new RegularScheduleFields(this, schedule)
-        this.recipientsForm = this.makePart(EmailListForm, {emails: this.state.dive.delivery_recipients || []})
         this.deliveryList = this.makePart(DiveDeliveryList, this.state)
 
-        this.listen('datachanged', this.scheduleFields.dataChangedKey, m => {
-            log.info(`Schedule form data changed`, m.data)
-            this.emitMessage(DiveEditor.diveChangedKey, {})
+        this.listenMessage(DiveDeliveryPanel.reloadKey, _ => {
+            log.info("Reloading dive delivery panel")
+            this.reload()
+        }, {attach: 'passive'})
+
+        this.onClick(this.newKey, _ => {
+            const dist: UnpersistedDdDiveDistribution = {
+                dd_dive_id: this.state.dive.id,
+                recipients: [],
+                schedule: {
+                    schedule_type: 'daily',
+                    hour_of_day: "0"
+                }
+            }
+            this.app.showModal(DiveDistributionModal, { ...this.state, distribution: dist })
         })
-        this.listenMessage(this.recipientsForm.changedKey, m => {
-            log.info(`Recipients form data changed`, m.data)
-            this.emitMessage(DiveEditor.diveChangedKey, {})
+
+        this.onClick(this.editKey, m => {
+            const id = m.data.id
+            log.info(`Editing distribution ${id}`)
+            const dist = this.distributions.filter(d => d.id == id)[0]
+            if (dist) {
+                this.app.showModal(DiveDistributionModal, { ...this.state, distribution: dist })
+            }
+            else {
+                log.warn(`Could not find distribution ${id}`)
+            }
         })
+
+        await this.reload()
     }
 
+    async reload() {
+        this.distributions = await getDistributions(this.state.dive)
+        this.dirty()
+    }
 
     get parentClasses(): Array<string> {
         return ['tt-flex', 'column', 'gap', 'dd-dive-tool', 'tt-typography']
     }
 
     render(parent: PartTag): any {
-        parent.h3(".glyp-setup").text("Schedule")
-        this.scheduleFields.render(parent)
-        parent.h3(".glyp-users").text("Recipients")
-        parent.part(this.recipientsForm)
+        // distributions
+        parent.h3(".glyp-setup").text("Distributions")
+        parent.div('.distributions.tt-flex.column.gap', distContainer => {
+            for (const dist of this.distributions) {
+                this.renderDistribution(distContainer, dist)
+            }
+        })
+        Fragments.button(parent, this.theme, "New", "glyp-plus_outline", "secondary")
+            .emitClick(this.newKey)
+
+        // deliveries
         parent.div('.deliveries', deliveriesContainer => {
             // it looks better without the gap between the header and list
             deliveriesContainer.h3(".glyp-inbox").text("Deliveries")
@@ -61,21 +98,26 @@ export class DiveDeliveryForm extends TerrierPart<DiveEditorState> {
         })
     }
 
-    /**
-     * Serializes just the fields needed for the delivery settings.
-     */
-    async serialize(): Promise<DiveDeliverySettings> {
-        if (!this.isAttached) {
-            // it was never actually rendered
-            log.info("Skipping delivery setting serialization since it was never rendered", this)
-            const delivery_schedule = this.state.dive.delivery_schedule || {schedule_type: 'none'}
-            const delivery_recipients = this.state.dive.delivery_recipients || []
-            return {delivery_schedule, delivery_recipients}
-        }
-        const delivery_schedule = await this.scheduleFields.serializeConcrete()
-        log.info(`Serialized ${delivery_schedule.schedule_type} delivery schedule`, delivery_schedule)
-        const delivery_recipients = this.recipientsForm.state.emails
-        return {delivery_schedule, delivery_recipients}
+    renderDistribution(parent: PartTag, dist: DdDiveDistribution) {
+        parent.a('.distribution', view => {
+            // schedule
+            view.div(".schedule", scheduleView => {
+                const scheduleDesc = Schedules.describeRegular(dist.schedule)
+                scheduleView.text(scheduleDesc)
+            })
+
+            // recipients
+            view.div(".recipients", recipientsList => {
+                if (dist.recipients?.length) {
+                    dist.recipients.forEach((recipient) => {
+                        recipientsList.div(".recipient.glyp-users.with-icon").text(recipient)
+                    })
+                } else {
+                    // no recipients
+                    recipientsList.div().text("No Recipients")
+                }
+            })
+        }).emitClick(this.editKey, {id: dist.id})
     }
 
 }
@@ -132,3 +174,136 @@ class DiveDeliveryList extends TerrierPart<DiveEditorState> {
 
 }
 
+
+////////////////////////////////////////////////////////////////////////////////
+// Distribution Persistence
+////////////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * Get all distributions for the given dive.
+ * @param dive
+ */
+async function getDistributions(dive: DdDive): Promise<DdDiveDistribution[]> {
+    return await Db().query('dd_dive_distribution')
+        .where({ dd_dive_id: dive.id, _state: 0 })
+        .orderBy("created_at ASC")
+        .exec()
+}
+
+/**
+ * Soft delete a distribution.
+ * @param dist
+ */
+async function softDeleteDistribution(dist: DdDiveDistribution) {
+    dist._state = 2
+    return await Db().update('dd_dive_distribution', dist)
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Distribution Modal
+////////////////////////////////////////////////////////////////////////////////
+
+export type DiveDistributionEditorState = {
+    dive: DdDive
+    distribution: UnpersistedDdDiveDistribution
+
+}
+
+class DiveDistributionModal extends ModalPart<DiveDistributionEditorState> {
+
+    fields!: TerrierFormFields<UnpersistedDdDiveDistribution>
+    dist!: UnpersistedDdDiveDistribution
+
+    scheduleFields!: RegularScheduleFields
+    recipientsForm!: EmailListForm
+
+    saveKey = Messages.untypedKey()
+    deleteKey = Messages.untypedKey()
+
+    async init() {
+        this.dist = this.state.distribution
+
+        this.setIcon('glyp-email')
+
+        this.scheduleFields = new RegularScheduleFields(this, this.dist.schedule)
+        this.scheduleFields.showNoneOption = false
+        this.recipientsForm = this.makePart(EmailListForm, { emails: this.dist.recipients || [] })
+
+        // save
+        this.addAction({
+            title: "Save",
+            icon: "glyp-checkmark",
+            click: { key: this.saveKey }
+        })
+        this.onClick(this.saveKey, _ => {
+            log.debug("Saving distribution", this.dist)
+            this.save()
+        })
+
+        // delete
+        if (this.dist.id?.length) {
+            this.setTitle("Edit Distribution")
+            this.addAction({
+                title: "Delete",
+                icon: "glyp-delete",
+                classes: ['alert'],
+                click: { key: this.deleteKey }
+            }, 'secondary')
+        }
+        else {
+            this.setTitle("New Distribution")
+        }
+        this.onClick(this.deleteKey, async _ => {
+            if (confirm("Are you sure you want to delete this distribution?")) {
+                log.info("Deleting distribution", this.dist)
+                await softDeleteDistribution(this.dist as DdDiveDistribution)
+                this.emitMessage(DiveDeliveryPanel.reloadKey, {})
+                this.successToast("Successfully Deleted Distribution")
+                this.pop()
+            }
+        })
+    }
+
+
+    renderContent(parent: PartTag): void {
+        parent.div(".tt-flex.padded.large-gap", row => {
+            row.div('.stretch.tt-flex.column.gap', col => {
+                col.h3(".glyp-setup.text-center").text("Schedule")
+                this.scheduleFields.render(col)
+            })
+            row.div('.stretch.tt-flex.column.gap', col => {
+                col.h3(".glyp-users.text-center").text("Recipients")
+                col.part(this.recipientsForm)
+            })
+        })
+    }
+
+    async save() {
+        this.dist.recipients = this.recipientsForm.state.emails
+        if (!this.dist.recipients?.length) {
+            this.alertToast("You must set at least one recipient")
+            return
+        }
+
+        this.dist.schedule = await this.scheduleFields.serializeConcrete()
+
+        log.info("Saving distribution", this.dist)
+
+        const res = await Db().upsert('dd_dive_distribution', this.dist)
+        if (res.status == 'success') {
+            this.state.distribution = res.record
+            this.emitMessage(DiveDeliveryPanel.reloadKey, {})
+            this.successToast("Successfully Saved Distribution")
+            return this.pop()
+        }
+
+        // errors
+        log.warn("Error saving distribution", res)
+        this.alertToast(res.message)
+
+    }
+
+}
+

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

@@ -18,7 +18,7 @@ import Messages from "tuff-core/messages"
 import Arrays from "tuff-core/arrays"
 import {FormFields} from "tuff-core/forms"
 import Fragments from "../../terrier/fragments"
-import {DiveDeliveryForm} from "./dive-delivery"
+import {DiveDeliveryPanel} from "./dive-delivery"
 import DivePlotList from "../plots/dive-plot-list"
 import {DivePage} from "./dive-page"
 
@@ -40,7 +40,7 @@ export default class DiveEditor extends ContentPart<DiveEditorState> {
     queryTabs!: TabContainerPart
     settingsTabs!: TabContainerPart
 
-    deliveryForm!: DiveDeliveryForm
+    deliveryPanel!: DiveDeliveryPanel
 
     plotList!: DivePlotList
 
@@ -119,17 +119,17 @@ export default class DiveEditor extends ContentPart<DiveEditorState> {
             })
         })
 
+        this.deliveryPanel = this.settingsTabs.upsertTab({
+            key: 'delivery',
+            title: "Delivery",
+            icon: "glyp-email"
+        }, DiveDeliveryPanel, this.state)
+
         this.plotList = this.settingsTabs.upsertTab({
             key: 'plots',
             title: "Plots",
             icon: "glyp-differential"
         }, DivePlotList, this.state)
-
-        this.deliveryForm = this.settingsTabs.upsertTab({
-            key: 'delivery',
-            title: "Delivery",
-            icon: "glyp-email"
-        }, DiveDeliveryForm, this.state)
     }
 
     /**
@@ -176,12 +176,8 @@ export default class DiveEditor extends ContentPart<DiveEditorState> {
     async serialize(): Promise<DdDive> {
         const queries = this.queries
 
-        const deliverySettings = await this.deliveryForm.serialize()
-
         return {
             ...this.state.dive,
-            delivery_schedule: deliverySettings.delivery_schedule,
-            delivery_recipients: deliverySettings.delivery_recipients,
             query_data: {queries}
         }
     }
@@ -235,7 +231,7 @@ export class DiveEditorPage extends DivePage<{id: string}> {
 
         this.addAction({
             title: 'Sync to Terrier',
-            icon: 'glyp-terrier',
+            icon: 'glyp-terrier_sync',
             classes: ['terrier-record-sync'],
             data: { id: this.state.id, table: 'dd_dive', title: dive.name, direction: 'up' }
         }, 'tertiary')

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

@@ -220,7 +220,7 @@ export class DiveListPage extends DivePage<{}> {
 
         this.addAction({
             title: 'Sync from Terrier',
-            icon: 'glyp-terrier',
+            icon: 'glyp-terrier_sync',
             classes: ['terrier-record-sync'],
             data: { table: 'dd_dive', direction: 'down' }
         }, 'tertiary')

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

@@ -1,6 +1,7 @@
 import TerrierPart from "../../terrier/parts/terrier-part"
 import {Logger} from "tuff-core/logging"
 import {PartTag} from "tuff-core/parts"
+import { SheetInput } from "../../terrier/sheets"
 import {DdDive, DdDiveEnumFields, UnpersistedDdDive} from "../gen/models"
 import * as inflection from "inflection"
 import {SchemaDef} from "../../terrier/schema"
@@ -111,6 +112,7 @@ export class DiveSettingsModal extends ModalPart<DiveSettingsState> {
     modelPicker!: QueryModelPicker
     saveKey = Messages.untypedKey()
     deleteKey = Messages.untypedKey()
+    duplicateKey = Messages.untypedKey()
     isNew = true
 
     async init() {
@@ -135,12 +137,20 @@ export class DiveSettingsModal extends ModalPart<DiveSettingsState> {
             click: {key: this.saveKey}
         })
 
-        if (!this.isNew && Dives.canDelete(this.state.dive, this.state.session)) {
+        if (!this.isNew) {
+            if (Dives.canDelete(this.state.dive, this.state.session)) {
+                this.addAction({
+                    title: 'Delete',
+                    icon: 'glyp-delete',
+                    classes: ['alert'],
+                    click: {key: this.deleteKey}
+                }, 'secondary')
+            }
+
             this.addAction({
-                title: 'Delete',
-                icon: 'glyp-delete',
-                classes: ['alert'],
-                click: {key: this.deleteKey}
+                title: 'Duplicate',
+                icon: 'glyp-duplicate',
+                click: {key: this.duplicateKey}
             }, 'secondary')
         }
 
@@ -153,6 +163,23 @@ export class DiveSettingsModal extends ModalPart<DiveSettingsState> {
                 this.delete()
             })
         })
+
+        this.onClick(this.duplicateKey, async _ => {
+            const nameInput: SheetInput = {
+                type: 'text',
+                key: 'name',
+                value: this.state.dive.name + ' (Copy)',
+                label: "New Dive Name"
+            }
+            this.app.confirm({
+                title: 'Duplicate this dive?',
+                body: "Are you sure you want to duplicate this dive?",
+                icon: 'glyp-duplicate',
+                inputs: [nameInput]
+            }, () => {
+                this.duplicate(nameInput.value)
+            })
+        })
     }
 
     renderContent(parent: PartTag): void {
@@ -223,5 +250,18 @@ export class DiveSettingsModal extends ModalPart<DiveSettingsState> {
         }
     }
 
+    async duplicate(name: string) {
+        const dive = {...this.state.dive, name}
+        delete dive.id
+        const res = await Db().upsert('dd_dive', dive)
+        if (res.status == 'success') {
+            this.pop()
+            this.successToast(`Duplicated dive ${dive.name}`)
+            Nav.visit(routes.list.path({}))
+        } else {
+            this.alertToast(`Error duplicating dive: ${res.message}`)
+        }
+    }
+
 }
 

package/data-dive/gen/models.ts

@@ -1,4 +1,4 @@
-// This file was automatically generated on 2024-09-06 11:24:15 -0500, DO NOT EDIT IT MANUALLY!
+// This file was automatically generated on 2025-04-25 14:11:58 -0500, DO NOT EDIT IT MANUALLY!
 
 import { Query } from "../queries/queries"
 
@@ -35,6 +35,7 @@ export type DdDive = {
     sort_order?: number
     query_data?: { queries: Query[] }
     dive_types: string[]
+    delivery_mode?: string
     delivery_recipients?: string[]
     delivery_schedule?: RegularSchedule
     created_by?: DdUser
@@ -42,6 +43,7 @@ export type DdDive = {
     dd_dive_group?: DdDiveGroup
     dd_dive_runs?: DdDiveRun[]
     owner?: DdUser
+    dd_dive_distributions?: DdDiveDistribution[]
 }
 
 export type UnpersistedDdDive = {
@@ -63,6 +65,7 @@ export type UnpersistedDdDive = {
     sort_order?: number
     query_data?: { queries: Query[] }
     dive_types: string[]
+    delivery_mode?: string
     delivery_recipients?: string[]
     delivery_schedule?: RegularSchedule
     created_by?: DdUser
@@ -70,12 +73,53 @@ export type UnpersistedDdDive = {
     dd_dive_group?: DdDiveGroup
     dd_dive_runs?: OptionalProps<UnpersistedDdDiveRun, "dd_dive_id">[]
     owner?: DdUser
+    dd_dive_distributions?: OptionalProps<UnpersistedDdDiveDistribution, "dd_dive_id">[]
 }
 
 export const DdDiveEnumFields = {
     visibility: ["public", "private"] as const,
 }
 
+export type DdDiveDistribution = {
+    id: string
+    created_at: string
+    updated_at: string
+    _state: number
+    created_by_id?: string
+    created_by_name: string
+    extern_id?: string
+    updated_by_id?: string
+    updated_by_name?: string
+    dd_dive_id?: string
+    recipients?: string[]
+    schedule: RegularSchedule
+    notes?: string
+    created_by?: DdUser
+    updated_by?: DdUser
+    dd_dive_runs?: DdDiveRun[]
+    dd_dive?: DdDive
+}
+
+export type UnpersistedDdDiveDistribution = {
+    id?: string
+    created_at?: string
+    updated_at?: string
+    _state?: number
+    created_by_id?: string
+    created_by_name?: string
+    extern_id?: string
+    updated_by_id?: string
+    updated_by_name?: string
+    dd_dive_id?: string
+    recipients?: string[]
+    schedule: RegularSchedule
+    notes?: string
+    created_by?: DdUser
+    updated_by?: DdUser
+    dd_dive_runs?: OptionalProps<UnpersistedDdDiveRun, "dd_dive_distribution_id">[]
+    dd_dive?: DdDive
+}
+
 export type DdDiveGroup = {
     id: string
     created_at: string
@@ -171,11 +215,14 @@ export type DdDiveRun = {
     output_data?: object
     output_file_data?: Attachment | { path: string }
     status: "initial" | "running" | "success" | "error"
+    delivery_mode?: string
     delivery_recipients?: string[]
     delivery_data?: object
+    dd_dive_distribution_id?: string
     created_by?: DdUser
     updated_by?: DdUser
     dd_dive?: DdDive
+    dd_dive_distribution?: DdDiveDistribution
     output_file?: File
 }
 
@@ -194,11 +241,14 @@ export type UnpersistedDdDiveRun = {
     output_data?: object
     output_file_data?: Attachment | { path: string }
     status: "initial" | "running" | "success" | "error"
+    delivery_mode?: string
     delivery_recipients?: string[]
     delivery_data?: object
+    dd_dive_distribution_id?: string
     created_by?: DdUser
     updated_by?: DdUser
     dd_dive?: DdDive
+    dd_dive_distribution?: DdDiveDistribution
     output_file?: File
 }
 
@@ -211,6 +261,7 @@ export const DdDiveRunEnumFields = {
  */
 export type PersistedModelTypeMap = {
     dd_dive: DdDive
+    dd_dive_distribution: DdDiveDistribution
     dd_dive_group: DdDiveGroup
     dd_dive_plot: DdDivePlot
     dd_dive_run: DdDiveRun
@@ -221,6 +272,7 @@ export type PersistedModelTypeMap = {
  */
 export type UnpersistedModelTypeMap = {
     dd_dive: UnpersistedDdDive
+    dd_dive_distribution: UnpersistedDdDiveDistribution
     dd_dive_group: UnpersistedDdDiveGroup
     dd_dive_plot: UnpersistedDdDivePlot
     dd_dive_run: UnpersistedDdDiveRun
@@ -230,20 +282,22 @@ export type UnpersistedModelTypeMap = {
  * Map model names to their association names.
  */
 export type ModelIncludesMap = {
-    dd_dive: "created_by" | "dd_dive_group" | "dd_dive_runs" | "owner" | "updated_by"
+    dd_dive: "created_by" | "dd_dive_distributions" | "dd_dive_group" | "dd_dive_runs" | "owner" | "updated_by"
+    dd_dive_distribution: "created_by" | "dd_dive" | "dd_dive_runs" | "updated_by"
     dd_dive_group: "created_by" | "dd_dives" | "updated_by"
     dd_dive_plot: "created_by" | "dd_dive" | "updated_by"
-    dd_dive_run: "created_by" | "dd_dive" | "updated_by"
+    dd_dive_run: "created_by" | "dd_dive" | "dd_dive_distribution" | "updated_by"
 }
 
 /**
  * Map model names to an array of association names.
  */
 export const ModelIncludesArrayMap = {
-    dd_dive: ["created_by", "dd_dive_group", "dd_dive_runs", "owner", "updated_by"] as const,
+    dd_dive: ["created_by", "dd_dive_distributions", "dd_dive_group", "dd_dive_runs", "owner", "updated_by"] as const,
+    dd_dive_distribution: ["created_by", "dd_dive", "dd_dive_runs", "updated_by"] as const,
     dd_dive_group: ["created_by", "dd_dives", "updated_by"] as const,
     dd_dive_plot: ["created_by", "dd_dive", "updated_by"] as const,
-    dd_dive_run: ["created_by", "dd_dive", "updated_by"] as const,
+    dd_dive_run: ["created_by", "dd_dive", "dd_dive_distribution", "updated_by"] as const,
 }
 
 /**

package/data-dive/queries/columns.ts

@@ -130,12 +130,6 @@ export class ColumnsEditorModal extends ModalPart<ColumnsEditorState> {
 
     tableFields!: FormFields<TableRef>
 
-    addEditor(col: ColumnRef) {
-        this.columnCount += 1
-        const state = {schema: this.state.schema, columnsEditor: this, id: `column-${this.columnCount}`, column: col}
-        this.columnEditors[state.id] = this.makePart(ColumnEditor, state)
-    }
-
 
     async init () {
         this.table = this.state.tableView.table
@@ -173,7 +167,7 @@ export class ColumnsEditorModal extends ModalPart<ColumnsEditorState> {
         })
 
         this.onClick(addSingleKey, m => {
-            this.addColumn(m.data.name)
+            this.addColumn(m.data)
         })
 
         this.onClick(addKey, m => {
@@ -186,14 +180,28 @@ export class ColumnsEditorModal extends ModalPart<ColumnsEditorState> {
         })
     }
 
-    addColumn(col: string) {
-        const colDef = this.modelDef.columns[col]
-        log.info(`Add column ${col}`, colDef)
-        if (colDef) {
-            this.addEditor({name: colDef.name})
-            this.dirty()
+    addColumn(col: ColumnRef) {
+        log.info(`Add column ${col.name}`, col)
+        this.addEditor(col)
+        this.validate().then()
+        this.dirty()
+    }
+
+    addEditor(col: ColumnRef) {
+        this.columnCount += 1
+        const state = {schema: this.state.schema, columnsEditor: this, id: `column-${this.columnCount}`, column: col}
+        this.columnEditors[state.id] = this.makePart(ColumnEditor, state)
+    }
+
+    removeEditor(id: string) {
+        const editor = this.columnEditors[id]
+        if (editor) {
+            log.info(`Removing column ${id}`)
+            this.removeChild(editor)
+            delete this.columnEditors[id]
+            this.validate().then()
         } else {
-            alert(`Unknown column name '${col}'`)
+            log.warn(`No editor for column ${id}`)
         }
     }
 
@@ -262,18 +270,6 @@ export class ColumnsEditorModal extends ModalPart<ColumnsEditorState> {
 
     }
 
-    removeEditor(id: string) {
-        const editor = this.columnEditors[id]
-        if (editor) {
-            log.info(`Removing column ${id}`)
-            this.removeChild(editor)
-            delete this.columnEditors[id]
-        }
-        else {
-            log.warn(`No editor for column ${id}`)
-        }
-    }
-
     async serialize(): Promise<ColumnRef[]> {
         const editors = Object.values(this.columnEditors)
         return await Promise.all(editors.map(async part => {
@@ -399,8 +395,11 @@ class ColumnEditor extends TerrierPart<ColumnState> {
 // Add Column Dropdown
 ////////////////////////////////////////////////////////////////////////////////
 
-type SelectableColumn = ColumnDef & {
+type SelectableColumn = {
+    ref: ColumnRef
+    def: ColumnDef
     included: boolean
+    description: string
     sortOrder: string
 }
 
@@ -410,7 +409,7 @@ type SelectableColumn = ColumnDef & {
 class SelectColumnsDropdown extends Dropdown<{editor: ColumnsEditorModal}> {
 
     addAllKey = Messages.untypedKey()
-    addKey = Messages.typedKey<{ name: string }>()
+    addKey = Messages.typedKey<ColumnRef>()
     checked: Set<string> = new Set()
     columns!: SelectableColumn[]
     modelDef!: ModelDef
@@ -426,16 +425,39 @@ class SelectColumnsDropdown extends Dropdown<{editor: ColumnsEditorModal}> {
 
         // sort the columns by whether they're in the editor already
         const includedNames = this.state.editor.currentColumnNames
-        this.columns = Object.values(this.modelDef.columns).map(col => {
-            const included = includedNames.has(col.name)
-            const sortOrder = `${included ? '1' : '0'}${col.name}`
-            return {included, sortOrder,...col}
+        this.columns = Object.values(this.modelDef.columns).map(colDef => {
+            const included = includedNames.has(colDef.name)
+            const sortOrder = `${included ? '1' : '0'}${colDef.name}`
+            const description = colDef.metadata?.description || ''
+            return {
+                def: colDef,
+                ref: {name: colDef.name},
+                included,
+                sortOrder, description}
         })
         this.columns = Arrays.sortBy(this.columns, 'sortOrder')
 
+        // add an option for a "count" column
+        const idDef = this.modelDef.columns['id']
+        if (idDef) {
+            const countColumn: SelectableColumn = {
+                def: idDef,
+                ref: {
+                    name: idDef.name,
+                    alias: 'count',
+                    function: 'count'
+                },
+                included: false,
+                sortOrder: '',
+                description: "Count all matching rows (when grouped)"
+            }
+            this.columns = this.columns.concat([countColumn])
+        }
+
         this.onClick(this.addKey, m => {
-            log.info(`Adding column ${m.data.name}`)
-            this.state.editor.addColumn(m.data.name)
+            const colRef = m.data
+            log.info(`Adding column ${colRef.name}`)
+            this.state.editor.addColumn(colRef)
 
             // remove the link
             const link = Dom.queryAncestorClass(m.event.target as HTMLInputElement, 'column')
@@ -443,10 +465,10 @@ class SelectColumnsDropdown extends Dropdown<{editor: ColumnsEditorModal}> {
         })
 
         this.onClick(this.addAllKey, _ => {
-            // add all of the unincluded columns and close the dropdown
+            // add all the unincluded, non-function columns and close the dropdown
             for (const col of this.columns) {
-                if (!col.included) {
-                    this.state.editor.addColumn(col.name)
+                if (!col.included && !col.ref.function?.length) {
+                    this.state.editor.addColumn(col.ref)
                 }
             }
             this.clear()
@@ -459,18 +481,48 @@ class SelectColumnsDropdown extends Dropdown<{editor: ColumnsEditorModal}> {
     }
 
     renderContent(parent: PartTag) {
+        // keep track of the last column rendered to see if we need a separator
+        let lastCol: SelectableColumn | null = null
         for (const col of this.columns) {
+            const colRef = col.ref
+            const colDef = col.def
+
+            // add a separator if necessary
+            if (lastCol) {
+                if ((!lastCol.included && col.included)) {
+                    parent.div('.separator')
+                }
+                if ((!lastCol.ref.function?.length && colRef.function?.length)) {
+                    parent.div('.separator')
+                }
+            }
+
+            // the actual link
             parent.a('.column', a => {
-                a.div('.name').text(col.name)
-                a.div('.right-title').text(col.type)
+                if (colRef.function?.length) {
+                    if (colRef.function == 'count') {
+                        // no point showing the column name or type for count()
+                        a.div('.name').text("count(*)")
+                    }
+                    else {
+                        // non-count function, so show the type
+                        a.div('.name').text(`${colRef.function}(${colDef.name})`)
+                        a.div('.right-title').text(colDef.type)
+                    }
+                }
+                else {
+                    a.div('.name').text(colDef.name)
+                    a.div('.right-title').text(colDef.type)
+                }
                 if (col.included) {
                     // style the columns that are already included differently
                     a.class('inactive')
                 }
-                if (col.metadata?.description?.length) {
-                    a.div('.subtitle').text(col.metadata.description)
+                if (col.description?.length) {
+                    a.div('.subtitle').text(col.description)
                 }
-            }).emitClick(this.addKey, {name: col.name})
+            }).emitClick(this.addKey, col.ref)
+            lastCol = col
         }
 
         parent.a('.primary', a => {

package/data-dive/queries/filters.ts

@@ -31,7 +31,7 @@ type BaseFilter = {
     edit_label?: string
 }
 
-const directOperators = ['eq', 'ne', 'ilike', 'lt', 'gt', 'lte', 'gte', 'contains', 'excludes'] as const
+const directOperators = ['eq', 'ne', 'ilike', 'lt', 'gt', 'lte', 'gte', 'present', 'empty', 'contains', 'excludes', 'any'] as const
 export type DirectOperator = typeof directOperators[number]
 
 /**
@@ -45,16 +45,16 @@ function operatorOptions(colDef?: ColumnDef): SelectOptions {
         case 'text':
         case 'string':
             if (colDef?.array) {
-                operators = ['contains', 'excludes']
+                operators = ['contains', 'excludes', 'any']
             }
             else {
-                operators = ['eq', 'ne', 'ilike']
+                operators = ['eq', 'ne', 'ilike', 'present', 'empty']
             }
             break
         case 'float':
         case 'integer':
         case 'cents':
-            operators = ['eq', 'ne', 'lt', 'gt', 'lte', 'gte']
+            operators = ['eq', 'ne', 'lt', 'gt', 'lte', 'gte', 'present', 'empty']
             break
     }
     return operators.map(op => {
@@ -117,24 +117,44 @@ function operatorDisplay(op: DirectOperator): string {
             return '>'
         case 'gte':
             return '≥'
+        case 'present':
+            return "Is Present?"
+        case 'empty':
+            return "Is Empty?"
+        case 'contains':
+            return "Contains ALL of"
+        case 'excludes':
+            return "Contains NONE of"
+        case 'any':
+            return "Contains ANY of"
         default:
             return op
     }
 }
 
+/**
+ * Determine whether the given operator needs an argument.
+ * @param op
+ */
+function operatorNeedsArgument(op: DirectOperator): boolean {
+    return !(op == 'present' || op == 'empty');
+}
+
 
 function renderStatic(parent: PartTag, filter: Filter) {
     switch (filter.filter_type) {
         case 'direct':
             parent.div('.column').text(filter.column)
             parent.div('.operator').text(operatorDisplay(filter.operator))
-            switch (filter.column_type) {
-                case 'cents':
-                    parent.div('.value').text(Format.cents(filter.value))
-                    break
-                default:
-                    parent.div('.value').text(filter.value)
-                    break
+            if (operatorNeedsArgument(filter.operator)) {
+                switch (filter.column_type) {
+                    case 'cents':
+                        parent.div('.value').text(Format.cents(filter.value))
+                        break
+                    default:
+                        parent.div('.value').text(filter.value)
+                        break
+                }
             }
             break
         case 'date_range':
@@ -377,6 +397,7 @@ abstract class FilterFields<F extends BaseFilter> extends TerrierFormFields<F> {
 class DirectFilterEditor extends FilterFields<DirectFilter> {
 
     numericChangeKey = Messages.untypedKey()
+    operatorChangeKey = Messages.untypedKey()
 
     constructor(container: FilterEditorContainer, filter: DirectFilter) {
         super(container, filter)
@@ -391,6 +412,11 @@ class DirectFilterEditor extends FilterFields<DirectFilter> {
         }
         log.info(`Direct filter for ${this.columnDef?.name} initialized`, this.data)
 
+        this.part.onChange(this.operatorChangeKey, m => {
+            log.info(`Operator changed`, m)
+            this.part.dirty()
+        })
+
         // for numeric types, we use a number input and translate the
         // value back to the string value field whenever it changes
         this.part.onChange(this.numericChangeKey, m => {
@@ -411,22 +437,25 @@ class DirectFilterEditor extends FilterFields<DirectFilter> {
         parent.div('.operator', col => {
             const opts = operatorOptions(this.columnDef)
             this.select(col, 'operator', opts)
+                .emitChange(this.operatorChangeKey)
         })
         parent.div('.filter', col => {
-            switch (this.data.column_type) {
-                case 'cents':
-                    col.div('.tt-compound-field', field => {
-                        field.label().text('$')
-                        this.numberInput(field, 'numeric_value', {placeholder: "Value"})
+            if (operatorNeedsArgument(this.data.operator)) {
+                switch (this.data.column_type) {
+                    case 'cents':
+                        col.div('.tt-compound-field', field => {
+                            field.label().text('$')
+                            this.numberInput(field, 'numeric_value', { placeholder: "Value" })
+                                .emitChange(this.numericChangeKey)
+                        })
+                        break
+                    case 'number':
+                        this.numberInput(col, 'numeric_value', { placeholder: "Value" })
                             .emitChange(this.numericChangeKey)
-                    })
-                    break
-                case 'number':
-                    this.numberInput(col, 'numeric_value', {placeholder: "Value"})
-                        .emitChange(this.numericChangeKey)
-                    break
-                default:
-                    this.textInput(col, 'value', {placeholder: "Value"})
+                        break
+                    default:
+                        this.textInput(col, 'value', { placeholder: "Value" })
+                }
             }
         })
         this.renderActions(parent)

package/data-dive/queries/validation.ts

@@ -32,12 +32,18 @@ function validateQuery(query: Query): QueryClientValidation {
 
     const usedNames: Set<string> = new Set<string>()
 
+    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) => {
         // clear the errors
         col.errors = undefined
 
+        // determine if there's an aggregate function
+        if (col.function?.length && Columns.functionType(col.function) == 'aggregate') {
+            aggCols.push(col)
+        }
+
         // determine if there's a _group by_ in the query
         if (col.grouped) {
             isGrouped = true
@@ -55,15 +61,21 @@ function validateQuery(query: Query): QueryClientValidation {
         usedNames.add(selectName)
     })
 
-    // if the query is grouped, ensure that all other column refs
-    // are either grouped, have an aggregate function, or are on a grouped table
     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`)
             }
         })
     }
+    else if (aggCols.length) {
+        // if the query isn't grouped, aggregate functions are an error
+        aggCols.forEach(col => {
+            addColumnError(col, `<strong>${col.name}</strong> has an aggregate function but the query isn't grouped`)
+        })
+    }
 
     return validation
 }

package/package.json

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

package/terrier/glyps.ts

@@ -1,4 +1,4 @@
-// This file was automatically generated by glyps:compile on 04/08/25  5:24 PM, DO NOT MANUALLY EDIT!
+// This file was automatically generated by glyps:compile on 04/09/25 10:46 AM, DO NOT MANUALLY EDIT!
 
 import Strings from "tuff-core/strings"
 

package/terrier/schedules.ts

@@ -86,6 +86,11 @@ export class RegularScheduleFields extends TerrierFormFields<CombinedRegularSche
 
     scheduleTypeChangeKey = Messages.typedKey<{schedule_type: ScheduleType}>()
 
+    /**
+     * Set false to not render the 'none' option
+     */
+    showNoneOption: boolean = true
+
     constructor(part: TerrierPart<any>, data: CombinedRegularSchedule) {
         super(part, data)
 
@@ -102,11 +107,13 @@ export class RegularScheduleFields extends TerrierFormFields<CombinedRegularSche
 
     render(parent: PartTag): any {
         parent.div('.tt-flex.column.gap.regular-schedule-form.tt-form', col => {
-            col.label('.caption-size', label => {
-                this.radio(label, 'schedule_type', 'none')
-                    .emitChange(this.scheduleTypeChangeKey, {schedule_type: 'none'})
-                label.span().text("Do Not Deliver")
-            })
+            if (this.showNoneOption) {
+                col.label('.caption-size', label => {
+                    this.radio(label, 'schedule_type', 'none')
+                        .emitChange(this.scheduleTypeChangeKey, { schedule_type: 'none' })
+                    label.span().text("Do Not Deliver")
+                })
+            }
 
             col.label('.caption-size', label => {
                 this.radio(label, 'schedule_type', 'daily')

package/terrier/sheets.ts

@@ -1,3 +1,4 @@
+import { GlypName } from "./glyps"
 import {Action, IconName} from "./theme"
 import TerrierPart from "./parts/terrier-part"
 import {PartTag} from "tuff-core/parts"
@@ -8,6 +9,19 @@ import Messages from "tuff-core/messages"
 const log = new Logger('Sheets')
 
 
+////////////////////////////////////////////////////////////////////////////////
+// Inputs
+////////////////////////////////////////////////////////////////////////////////
+
+export type SheetInput = {
+    type: 'text'
+    key: string
+    value: string
+    label?: string
+    icon?: GlypName
+}
+
+
 ////////////////////////////////////////////////////////////////////////////////
 // Parts
 ////////////////////////////////////////////////////////////////////////////////
@@ -18,12 +32,18 @@ export type SheetState = {
     body: string
     primaryActions?: Action[]
     secondaryActions?: Action[]
+    inputs?: SheetInput[]
 }
 
 const clearKey = Messages.untypedKey()
 
+/**
+ * Show a little popup sheet at the bottom of the screen that's much nicer than a native alert() or confirm().
+ */
 export class Sheet<TState extends SheetState> extends TerrierPart<TState> {
 
+    inputChangedKey = Messages.typedKey<{key: string}>()
+
     /**
      * Removes itself from the DOM.
      */
@@ -36,6 +56,17 @@ export class Sheet<TState extends SheetState> extends TerrierPart<TState> {
         this.onClick(clearKey, _ => {
             this.clear()
         })
+
+        this.onChange(this.inputChangedKey, m => {
+            const key = m.data.key
+            const value = m.value
+            log.info(`Input ${key} changed to ${value}`)
+            this.state.inputs?.forEach(input => {
+                if (input.key === key) {
+                    input.value = value
+                }
+            })
+        })
     }
 
     get parentClasses(): Array<string> {
@@ -48,8 +79,11 @@ export class Sheet<TState extends SheetState> extends TerrierPart<TState> {
             .title(this.state.title)
             .icon(this.state.icon)
             .content(panel => {
-                panel.class('padded')
+                panel.class('padded', 'tt-form')
                 panel.div('.body').text(this.state.body)
+                for (const input of this.state.inputs || []) {
+                    this.renderInput(panel, input)
+                }
             })
         for (const action of this.state.primaryActions || []) {
             // if it doesn't have a click key, it must be a close button
@@ -64,12 +98,22 @@ export class Sheet<TState extends SheetState> extends TerrierPart<TState> {
         panel.render(parent)
     }
 
+    renderInput(parent: PartTag, input: SheetInput) {
+        parent.div('.tt-sheet-input', container => {
+            if (input.label?.length) {
+                container.label().text(input.label)
+            }
+            container.input({type: 'text', value: input.value})
+                .data({key: input.key})
+                .emitChange(this.inputChangedKey, {key: input.key})
+        })
+    }
+
     update(_elem: HTMLElement) {
         setTimeout(
             () => _elem.classList.add('show'),
             10
         )
-
     }
 }
 
@@ -81,7 +125,7 @@ export class Sheet<TState extends SheetState> extends TerrierPart<TState> {
 /**
  * State type for a sheet that asks the user to confirm a choice.
  */
-export type ConfirmSheetState = Pick<SheetState, 'title' | 'body' | 'icon'>
+export type ConfirmSheetState = Pick<SheetState, 'title' | 'body' | 'icon' | 'inputs'>
 
 /**
  * State type for a sheet that tells the user something with no options.