terrier-engine 4.67.10 → 4.67.13

package/tmp/dist/data-dive/queries/validation.ts

@@ -1,104 +0,0 @@
-import Queries, { Query } from "./queries"
-import Columns, { ColumnRef } from "./columns"
-import { TableRef } from "./tables"
-
-export type ColumnValidationError = {
-    message: string
-}
-
-export type QueryClientValidation = {
-    columns: ColumnValidationError[]
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Query Validation
-////////////////////////////////////////////////////////////////////////////////
-
-/**
- * Validates that a query will produce valid SQL.
- */
-function validateQuery(query: Query): QueryClientValidation {
-
-    const validation: QueryClientValidation = {
-        columns: []
-    }
-
-    function addColumnError(col: ColumnRef, message: string) {
-        const error = { message }
-        col.errors ||= []
-        col.errors.push(error)
-        validation.columns.push(error)
-    }
-
-    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()
-    for (const { table, column } of Queries.columns(query)) {
-        // clear the errors
-        column.errors = undefined
-
-        // determine if there's an aggregate function
-        if (column.function?.length && Columns.functionType(column.function) == 'aggregate') {
-            aggCols.push(column)
-        }
-
-        // determine if there's a _group by_ in the query
-        if (column.grouped) {
-            isGrouped = true
-            if (column.name == 'id') {
-                // ungrouped columns on this table are okay
-                groupedTables.add(table)
-            }
-        }
-
-        // check raw
-        if (column.ref_type == 'raw') {
-            if (!column.name?.length) {
-                addColumnError(column, "Raw selects must be named")
-            }
-            if (!column.raw?.length) {
-                addColumnError(column, "Missing raw SQL")
-            }
-        }
-
-        // each select name should only be used once
-        const selectName = Columns.computeSelectName(table, column)
-        if (usedNames.has(selectName)) {
-            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
-        const columns = Queries.columns(query)
-            .filter(({ table, column }) =>
-                !column.grouped && Columns.functionType(column.function) != 'aggregate' &&
-                !groupedTables.has(table) &&
-                'raw' != column.ref_type)
-        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
-        aggCols.forEach(col => {
-            addColumnError(col, `<strong>${col.name}</strong> has an aggregate function but the query isn't grouped`)
-        })
-    }
-
-    return validation
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-// Export
-////////////////////////////////////////////////////////////////////////////////
-
-const Validation = {
-    validateQuery
-}
-export default Validation

package/tmp/dist/package.json

@@ -1,38 +0,0 @@
-{
-  "name": "terrier-engine",
-  "type": "module",
-  "files": [
-    "*"
-  ],
-  "version": "4.67.10",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Terrier-Tech/terrier-engine"
-  },
-  "license": "MIT",
-  "scripts": {
-    "check": "tsc -p app/frontend --noEmit",
-    "test": "vitest"
-  },
-  "dependencies": {
-    "@types/turbolinks": "^5.2.0",
-    "dayjs": "^1.11.7",
-    "inflection": "^2.0.1",
-    "mime-types": "^2.1.35",
-    "tuff-core": "latest",
-    "tuff-plot": "latest",
-    "tuff-sortable": "latest",
-    "turbolinks": "^5.2.0"
-  },
-  "devDependencies": {
-    "@types/mime-types": "^2.1.4",
-    "@types/node": "^22.9.0",
-    "glyphs2font": "^1.2.4",
-    "prettier": "^2.8.8",
-    "svgo": "^3.0.2",
-    "typescript": "^5.6.3",
-    "vite": "^5.4.19",
-    "vite-plugin-ruby": "^5.1.1",
-    "vitest": "^2.1.9"
-  }
-}

package/tmp/dist/terrier/README.md

@@ -1,3 +0,0 @@
-# Terrier Engine
-
-This package is meant to be used in conjunction with the [Terrier Rails Engine](https://github.com/Terrier-Tech/terrier-engine).

package/tmp/dist/terrier/api-subscriber.ts

@@ -1,439 +0,0 @@
-import Api, {ApiResponse, noArgListener, Streamer} from "./api"
-import {LogEntry} from "./logging"
-import dayjs from "dayjs"
-import duration from "dayjs/plugin/duration"
-import {Logger} from "tuff-core/logging";
-
-dayjs.extend(duration)
-
-/** Configuration for ApiSubscribers */
-export type SubscriptionOptions = {
-    /** If true, retry the subscription after it is cancelled */
-    keepAlive?: boolean
-}
-
-/** Options specific to Subscribers that use GET HTTP requests */
-export type GetSubscriberOptions = {
-    /** If true, keys in the params object will be snakified before being sent to the server */
-    snakifyKeys?: boolean
-}
-
-/** Parameters to send with the subscription request */
-export type SubscriptionParams = Record<string, unknown>
-
-export type SubscriptionEventHandlers<TResult> = {
-    onResult: resultListener<TResult>[]
-    onError: errorListener[]
-    onLog: logListener[]
-}
-
-export type SubscriptionLifecycleHandlers = {
-    onSubscribe: noArgListener[]
-    onUnsubscribe: noArgListener[]
-    onClose: closeListener[]
-}
-
-type resultListener<TResult> = (result: ResultEvent<TResult>) => boolean
-type errorListener = (result: ErrorEvent) => boolean
-type logListener = (log: LogEvent) => void
-type closeListener = (reason?: string) => void
-
-
-type BaseSubscriptionEvent = {
-    _type: '_result' | '_error' | '_log' | '_close' | undefined
-}
-
-export type SubscriptionEvent<TResult> = BaseSubscriptionEvent & (ResultEvent<TResult> | ErrorEvent | LogEvent | CloseEvent)
-
-/** Type of result events from a subscription */
-export type ResultEvent<TResult> = BaseSubscriptionEvent & { _type: '_result' | undefined } & TResult
-
-/** Type of error events from a subscription */
-export type ErrorEvent = BaseSubscriptionEvent & { _type: '_error' } & {
-    prefix?: string
-    message: string
-    backtrace: string[]
-}
-
-/** Type of log events from a subscription */
-export type LogEvent = BaseSubscriptionEvent & { _type: '_log' } & LogEntry
-
-export type CloseEvent = BaseSubscriptionEvent & { _type: '_close' }
-
-/**
- * An abstraction over the process of receiving continuous updates from the server.
- * This allows client code to specify a dependency on continuous updates of a particular type without needing
- * to care about how those updates are fulfilled.
- *
- * Behind the scenes, this could be handled by pulling from the client (PollingSubscriber),
- * pushing from the server (CableSubscriber), or a hybrid of the two (StreamingSubscriber).
- *
- * Subclasses are responsible for implementing the process of initiating and finalizing the subscription and
- * passing events to the appropriate handlers.
- *
- * Each subclass is responsible for providing a constructor with whatever dependencies are required, but all subclasses
- * must implement `params` and `options` properties and handle them appropriately.
- */
-export abstract class ApiSubscriber<TResult, TParams extends SubscriptionParams, TOptions extends SubscriptionOptions = SubscriptionOptions> {
-
-    protected isSubscribed: boolean = false
-
-    protected eventHandlers: SubscriptionEventHandlers<TResult> = { onResult: [], onError: [], onLog: [] }
-    protected lifecycleHandlers: SubscriptionLifecycleHandlers = { onSubscribe: [], onUnsubscribe: [], onClose: [] }
-    protected otherHandlers: Record<string, ((event: unknown) => boolean | void)[]> = {}
-
-    /**
-     * @param params   parameters sent with subscription requests to customize server-side behavior
-     * @param options  options that customize client-side behavior of the subscriber
-     * @param logger
-     * @protected
-     */
-    protected constructor(public params: TParams, public options?: TOptions, public logger?: Logger) {
-        this.options ??= {} as TOptions
-        this.logger ??= new Logger(this.constructor.name)
-    }
-
-    // Handler registration
-
-    /** Register a handler for a custom event type */
-    public on<EventType>(eventType: string, handler: (event: EventType) => boolean | void): this {
-        if (eventType in ['_result', '_error', '_log', '_close']) {
-            throw new Error(`${eventType} is a reserved handler type. Please use a different type or use the appropriate handler registration function.`)
-        }
-
-        this.otherHandlers[eventType] ??= []
-        this.otherHandlers[eventType].push(handler as (event: unknown) => boolean | void)
-        return this
-    }
-
-    /** Register a handler for the default result type of this subscriber */
-    public onResult(handler: (result: ResultEvent<TResult>) => boolean): this {
-        this.eventHandlers.onResult.push(handler)
-        return this
-    }
-
-    /** Register a handler for error events */
-    public onError(handler: (error: ErrorEvent) => boolean): this {
-        this.eventHandlers.onError.push(handler)
-        return this
-    }
-
-    /** Register a handler for log events */
-    public onLog(handler: (logEntry: LogEvent) => void): this {
-        this.eventHandlers.onLog.push(handler)
-        return this
-    }
-
-    /** Register a handler to be notified when this subscriber is subscribed */
-    public onSubscribe(handler: () => void): this {
-        return this.onLifecycle('onSubscribe', handler)
-    }
-
-    /** Register a handler to be notified when this subscriber is manually unsubscribed */
-    public onUnsubscribe(handler: () => void): this {
-        return this.onLifecycle('onUnsubscribe', handler)
-    }
-
-    /** Register a handler to be notified when the publisher source of this subscriber closes the subscription */
-    public onClose(handler: () => void): this {
-        return this.onLifecycle('onClose', handler)
-    }
-
-    /** utility to register a generic lifecycle handler */
-    protected onLifecycle(key: keyof SubscriptionLifecycleHandlers, handler: noArgListener): this
-    protected onLifecycle(key: 'onClose', handler: (reason?: string) => void): this
-    protected onLifecycle(key: keyof SubscriptionLifecycleHandlers, handler: noArgListener | ((reason?: string) => void)): this {
-        this.lifecycleHandlers[key].push(handler)
-        return this
-    }
-
-    // Start or stop subscription
-
-    /**
-     * Starts the subscription. Calling this after the subscription has already been started has no effect
-     */
-    public subscribe(): this {
-        if (this.isSubscribed) return this
-        this.subscribeImpl()
-        this.isSubscribed = true
-        this.notifyLifecycle('onSubscribe')
-        return this
-    }
-
-    /** Stops the subscription and closes the connection. */
-    public unsubscribe(): void {
-        if (!this.isSubscribed) return
-        this.unsubscribeImpl()
-        this.isSubscribed = false
-        this.notifyLifecycle('onUnsubscribe')
-    }
-
-    // Modify subscription params
-
-    /** Update the params of this subscriber. Depending on the implementation, this may restart the subscription. */
-    public abstract updateParams(newParams: TParams): void
-
-    // Internal
-
-    protected close() {
-        this.isSubscribed = false
-    }
-
-    /** Call the handlers for the given lifecycle event */
-    protected notifyLifecycle(key: keyof SubscriptionLifecycleHandlers): void
-    protected notifyLifecycle(key: 'onClose', reason: string | undefined): void
-    protected notifyLifecycle(key: keyof SubscriptionLifecycleHandlers, reason: string | undefined = undefined): void {
-        this.logNotification(key, reason)
-        if (key == 'onClose') {
-            this.lifecycleHandlers[key].forEach(handler => handler(reason))
-        } else {
-            this.lifecycleHandlers[key].forEach(handler => handler())
-        }
-    }
-
-    protected notifyResult(event: ResultEvent<TResult>) {
-        this.logNotification('_result', event)
-        const shouldContinue = this.eventHandlers.onResult
-            .map(handler => handler(event))
-            .every(b => b)
-        if (!shouldContinue) this.unsubscribe()
-    }
-
-    protected notifyError(event: ErrorEvent) {
-        this.logNotification('_error', event)
-        const shouldContinue = this.eventHandlers.onError
-            .map(handler => handler(event))
-            .every(b => b)
-        if (!shouldContinue) this.unsubscribe()
-    }
-
-    protected notifyLog(event: LogEvent) {
-        this.logNotification('_log', event)
-        this.eventHandlers.onLog.forEach(handler => handler(event))
-    }
-
-    protected notifyOther(key: string, event: any) {
-        this.logNotification(key, event)
-        const shouldContinue = this.otherHandlers[key]
-            .map(handler => handler(event) !== false)
-            .every(b => b)
-        if (!shouldContinue) this.unsubscribe()
-    }
-
-    protected logNotification(key: string, event: any) {
-        if (event === undefined) {
-            this.logger?.debug('notify', key)
-        } else {
-            this.logger?.debug('notify', key, event)
-        }
-    }
-
-    /** Subclasses implement this method to start the subscription */
-    protected abstract subscribeImpl(): void
-
-    /** Subclasses implement this method to end the subscription */
-    protected abstract unsubscribeImpl(): void
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Polling Subscriber
-////////////////////////////////////////////////////////////////////////////////
-
-type PollingResponse<TResult> = (ApiResponse & SubscriptionEvent<TResult>) | { events: SubscriptionEvent<TResult>[] }
-
-/**
- * An implementation of ApiSubscriber that uses polling to periodically make a request to the server
- */
-export class PollingSubscriber<TResult, TParams extends SubscriptionParams> extends ApiSubscriber<TResult, TParams, (SubscriptionOptions & GetSubscriberOptions)> {
-
-    // used to ensure we only schedule one interval at a time and allows for cancellation.
-    private timeoutHandle: NodeJS.Timeout | null = null
-
-    /**
-     * @param url the url to make a request to.
-     * @param params params to use to make the request.
-     * @param interval the interval on which to poll. Either a number of milliseconds or a dayjs Duration.
-     * @param options extra subscription options
-     * @param logger a specific logger to use
-     */
-    constructor(
-        public url: string,
-        public interval: number | duration.Duration,
-        params: TParams,
-        options?: (SubscriptionOptions & GetSubscriberOptions),
-        logger?: Logger
-    ) {
-        super(params, options, logger)
-    }
-
-    subscribeImpl() {
-        if (this.timeoutHandle) return
-        this.makeRequest()
-    }
-
-    unsubscribeImpl() {
-        this.clearTimeout()
-    }
-
-    updateParams(newParams: TParams) {
-        this.params = newParams
-        this.makeRequest()
-    }
-
-    private makeRequest() {
-        this.clearTimeout()
-        this.request().then(response => {
-            if ('events' in response) {
-                for (const event of response.events) {
-                   this.handleEvent(event)
-                }
-            } else {
-                if (response.status == 'error') response._type = '_error'
-                this.handleEvent(response)
-            }
-
-            this.startTimeout()
-        })
-    }
-
-    protected async request(): Promise<PollingResponse<TResult>> {
-        const params = Api.objectToQueryParams(this.params, this.options?.snakifyKeys)
-
-        // Add _polling param so that the server-side can adjust behavior based on whether it is being polled or requested normally.
-        params._polling = true.toString()
-        const result = await Api.get<PollingResponse<TResult>>(this.url, params);
-        this.logger?.debug("polling request", params, result)
-        return result
-    }
-
-    protected handleEvent(event: SubscriptionEvent<TResult>) {
-        switch (event._type) {
-            case '_result':
-            case undefined:
-                this.notifyResult(event)
-                break
-            case '_error':
-                this.notifyError(event)
-                break
-            case '_log':
-                this.notifyLog(event)
-                break
-            case '_close':
-                this.notifyLifecycle('onClose')
-                this.close()
-                break
-            default:
-                const otherEvent = event as any
-                this.notifyOther(otherEvent._type, otherEvent)
-        }
-    }
-
-    protected clearTimeout() {
-        if (this.timeoutHandle) {
-            clearTimeout(this.timeoutHandle)
-            this.timeoutHandle = null
-        }
-    }
-
-    protected startTimeout() {
-        if (!this.isSubscribed) return
-        if (this.timeoutHandle) return
-        const intervalMs = (dayjs.isDuration(this.interval)) ? this.interval.asMilliseconds() : this.interval
-
-        this.logger?.debug("polling in", intervalMs, "milliseconds")
-
-        this.timeoutHandle = setTimeout(this.makeRequest.bind(this), intervalMs)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Action Cable Subscriber
-////////////////////////////////////////////////////////////////////////////////
-
-/**
- * An ApiSubscriber that uses ActionCable to get pushed results from the server.
- * Not implemented yet
- */
-export class CableSubscriber<TResult, TParams extends SubscriptionParams> extends ApiSubscriber<TResult, TParams> {
-
-    constructor(
-        public channelName: string,
-        params: TParams,
-        options?: SubscriptionOptions,
-        logger?: Logger,
-    ) {
-        throw new Error("Method not implemented.")
-        super(params, options, logger)
-    }
-
-    public updateParams(_newParams: TParams): void {
-        throw new Error("Method not implemented.")
-    }
-    protected subscribeImpl(): void {
-        throw new Error("Method not implemented.")
-    }
-    protected unsubscribeImpl(): void {
-        throw new Error("Method not implemented.")
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Event Stream Subscriber
-////////////////////////////////////////////////////////////////////////////////
-
-export class StreamingSubscriber<TResult, TParams extends SubscriptionParams> extends ApiSubscriber<TResult, TParams, (SubscriptionOptions & GetSubscriberOptions)> {
-
-    private streamer?: Streamer
-
-    constructor(
-        public url: string,
-        params: TParams,
-        options?: (SubscriptionOptions & GetSubscriberOptions),
-        logger?: Logger
-    ) {
-        super(params, options, logger)
-    }
-
-    public on<EventType>(eventType: string, handler: (event: EventType) => boolean | void): this {
-        if (!(eventType in this.otherHandlers) && this.streamer) {
-            this.listenOther(eventType, this.streamer)
-        }
-        return super.on(eventType, handler)
-    }
-
-    public updateParams(newParams: TParams): void {
-        this.unsubscribeImpl()
-        this.params = newParams
-        this.subscribeImpl()
-    }
-
-    protected subscribeImpl(): void {
-        const params = Api.objectToQueryParams(this.params, this.options?.snakifyKeys)
-        const paramsString = new URLSearchParams(params).toString()
-        const streamer = new Streamer(`${this.url}?${paramsString}`, this.options ?? {})
-
-        streamer
-            .on<ResultEvent<TResult>>('_result', this.notifyResult.bind(this))
-            .on<ErrorEvent>('_error', this.notifyError.bind(this))
-            .on<LogEvent>('_log', this.notifyLog.bind(this))
-            .onClose(() => {
-                this.close()
-                this.notifyLifecycle('onClose')
-            })
-
-        Object.keys(this.otherHandlers).forEach(key => {
-            this.listenOther(key, streamer)
-        })
-
-        this.streamer = streamer
-    }
-
-    protected unsubscribeImpl(): void {
-        this.streamer?.sse.close()
-        this.streamer = undefined
-    }
-
-    protected listenOther(key: string, streamer: Streamer) {
-        streamer.on(key, (event) => this.notifyOther(key, event))
-    }
-}