@deephaven-enterprise/query-utils 1.20240723.62-alpha-fix-dependencies.1

package/dist/QuerySchedulerValidation.d.ts

@@ -0,0 +1,76 @@
+import { QueryScheduler } from './QueryScheduler';
+/**
+ * Validation for Query Scheduler
+ */
+export declare class QuerySchedulerValidation {
+    static VALIDATORS: Readonly<{
+        dailyDays: typeof QuerySchedulerValidation.validateDailyDays;
+        businessDays: typeof QuerySchedulerValidation.validateDailyDays;
+        months: typeof QuerySchedulerValidation.validateMonths;
+        firstBusinessDay: typeof QuerySchedulerValidation.validateMonthlyDays;
+        lastBusinessDay: typeof QuerySchedulerValidation.validateMonthlyDays;
+        specificDays: typeof QuerySchedulerValidation.validateMonthlyDays;
+        monthlyDays: typeof QuerySchedulerValidation.validateMonthlyDays;
+        dependentOnQuerySerials: typeof QuerySchedulerValidation.validateDependentOnQuerySerials;
+        schedulingDisabled: typeof QuerySchedulerValidation.validateSchedulingDisabled;
+        startTime: typeof QuerySchedulerValidation.validateStartTime;
+        stopTime: typeof QuerySchedulerValidation.validateStopTime;
+        overnight: typeof QuerySchedulerValidation.validateOvernight;
+        stopTimeDisabled: typeof QuerySchedulerValidation.validateStopTimeDisabled;
+        repeatEnabled: typeof QuerySchedulerValidation.validateRepeat;
+        temporaryDependentOnQuerySerials: typeof QuerySchedulerValidation.validateTemporaryDependentOnQuerySerials;
+        expirationTimeMillis: typeof QuerySchedulerValidation.validateExpirationTime;
+        repeatInterval: typeof QuerySchedulerValidation.validateRepeatInterval;
+        restartDelayMinutes: typeof QuerySchedulerValidation.validateRestartDelayMinutes;
+        startDateTime: typeof QuerySchedulerValidation.validateStartDateTime;
+        stopDateTime: typeof QuerySchedulerValidation.validateStopDateTime;
+    }>;
+    /**
+     * Validates a field. Returns an error message if the value is invalid. Returns null if it is valid.
+     *
+     * @param field the field to validate
+     * @param scheduler the scheduler
+     * @param timeout the timeout from query
+     * @param stopTimeRequired if a stop time is required
+     * @param dependentQuerySerials available dependent query serials, skip check if undefined
+     * @param temporaryQuerySerials available temporary query serials, skip check if undefined
+     * @return an error message for an invalid value, null if it is valid
+     */
+    static validate(field: string, scheduler: QueryScheduler, timeout?: number, stopTimeRequired?: boolean, dependentQuerySerials?: string[], temporaryQuerySerials?: string[]): string | null;
+    /**
+     * Runs all validators on a scheduler.
+     *
+     * @param scheduler the scheduler to validate
+     * @param timeout the timeout from query
+     * @param stopTimeRequired if a stop time is required
+     * @param dependentQuerySerials available dependent query serials, skip check if undefined
+     * @param temporaryQuerySerials available temporary query serials, skip check if undefined
+     * @return a map containing any errors
+     */
+    static validateAll(scheduler: QueryScheduler, timeout?: number, stopTimeRequired?: boolean, dependentQuerySerials?: string[], temporaryQuerySerials?: string[]): Map<string, string>;
+    /**
+     * Many scheduler validations involved multiple fields and are displayed in a banner.
+     * This is a helper method to get an error message to display.  Returns null if there is no error
+     * message or if the error message is for only one field.
+     *
+     * @param errorMap the map of error message from a validate all call
+     */
+    static getErrorMessage(errorMap: Map<string, string>): string | null | undefined;
+    static validateStartTime(scheduler: QueryScheduler): string | null;
+    static validateStopTime(scheduler: QueryScheduler): string | null;
+    static validateOvernight(scheduler: QueryScheduler): string | null;
+    static validateStopTimeDisabled(scheduler: QueryScheduler, timeout: number, stopTimeRequired: boolean): string | null;
+    static validateRepeat(scheduler: QueryScheduler): string | null;
+    static validateDailyDays(scheduler: QueryScheduler): string | null;
+    static validateMonthlyDays(scheduler: QueryScheduler): string | null;
+    static validateMonths(scheduler: QueryScheduler): string | null;
+    static validateDependentOnQuerySerials(scheduler: QueryScheduler, timeout: number, stopTimeRequired: boolean, dependentQuerySerials: string[]): string | null;
+    static validateSchedulingDisabled(scheduler: QueryScheduler): string | null;
+    static validateTemporaryDependentOnQuerySerials(scheduler: QueryScheduler, timeout: number, stopTimeRequired: boolean, dependentQuerySerials: string[], temporaryQuerySerials: string[]): string | null;
+    static validateExpirationTime(scheduler: QueryScheduler): string | null;
+    static validateRepeatInterval(scheduler: QueryScheduler, timeout: number): string | null;
+    static validateRestartDelayMinutes(scheduler: QueryScheduler): string | null;
+    static validateStartDateTime(scheduler: QueryScheduler): string | null;
+    static validateStopDateTime(scheduler: QueryScheduler): string | null;
+}
+export default QuerySchedulerValidation;

package/dist/QuerySchedulerValidation.js

@@ -0,0 +1,306 @@
+import { QueryScheduler } from './QueryScheduler';
+/**
+ * Validation for Query Scheduler
+ */
+export class QuerySchedulerValidation {
+    /**
+     * Validates a field. Returns an error message if the value is invalid. Returns null if it is valid.
+     *
+     * @param field the field to validate
+     * @param scheduler the scheduler
+     * @param timeout the timeout from query
+     * @param stopTimeRequired if a stop time is required
+     * @param dependentQuerySerials available dependent query serials, skip check if undefined
+     * @param temporaryQuerySerials available temporary query serials, skip check if undefined
+     * @return an error message for an invalid value, null if it is valid
+     */
+    static validate(field, scheduler, timeout = 0, stopTimeRequired = true, dependentQuerySerials, temporaryQuerySerials) {
+        // @ts-expect-error we are checking if field is a valid  key
+        const validator = QuerySchedulerValidation.VALIDATORS[field];
+        if (validator != null) {
+            return validator(scheduler, timeout, stopTimeRequired, dependentQuerySerials, temporaryQuerySerials);
+        }
+        return null;
+    }
+    /**
+     * Runs all validators on a scheduler.
+     *
+     * @param scheduler the scheduler to validate
+     * @param timeout the timeout from query
+     * @param stopTimeRequired if a stop time is required
+     * @param dependentQuerySerials available dependent query serials, skip check if undefined
+     * @param temporaryQuerySerials available temporary query serials, skip check if undefined
+     * @return a map containing any errors
+     */
+    static validateAll(scheduler, timeout = 0, stopTimeRequired = true, dependentQuerySerials, temporaryQuerySerials) {
+        const keys = Object.keys(QuerySchedulerValidation.VALIDATORS);
+        const result = new Map();
+        keys.forEach(key => {
+            const validationError = QuerySchedulerValidation.validate(key, scheduler, timeout, stopTimeRequired, dependentQuerySerials, temporaryQuerySerials);
+            if (validationError != null) {
+                result.set(key, validationError);
+            }
+        });
+        return result;
+    }
+    /**
+     * Many scheduler validations involved multiple fields and are displayed in a banner.
+     * This is a helper method to get an error message to display.  Returns null if there is no error
+     * message or if the error message is for only one field.
+     *
+     * @param errorMap the map of error message from a validate all call
+     */
+    static getErrorMessage(errorMap) {
+        if (errorMap.size === 0) {
+            return null;
+        }
+        const firstKey = errorMap.keys().next().value;
+        if (firstKey === QueryScheduler.FIELDS.MONTHS ||
+            firstKey === QueryScheduler.FIELDS.SCHEDULING_DISABLED) {
+            return null;
+        }
+        return errorMap.get(firstKey);
+    }
+    static validateStartTime(scheduler) {
+        if (scheduler.type === QueryScheduler.TYPES.CONTINUOUS ||
+            scheduler.type === QueryScheduler.TYPES.TEMPORARY ||
+            scheduler.type === QueryScheduler.TYPES.RANGE) {
+            return null;
+        }
+        const { startTime } = scheduler;
+        if (startTime === undefined) {
+            return 'Schedule must have a start time';
+        }
+        // This will check if the times have the correct order
+        return QuerySchedulerValidation.validateStopTime(scheduler);
+    }
+    static validateStopTime(scheduler) {
+        if (scheduler.type === QueryScheduler.TYPES.CONTINUOUS ||
+            scheduler.type === QueryScheduler.TYPES.TEMPORARY ||
+            scheduler.type === QueryScheduler.TYPES.RANGE) {
+            return null;
+        }
+        if (scheduler.type === QueryScheduler.TYPES.DEPENDENT &&
+            !scheduler.useMinStartTime) {
+            return null;
+        }
+        const { stopTime, stopTimeDisabled, repeatEnabled, overnight, startTime } = scheduler;
+        if (stopTime !== undefined && (!stopTimeDisabled || repeatEnabled)) {
+            if (stopTime === startTime) {
+                return 'Start time and stop time cannot be the same';
+            }
+            if (!overnight && stopTime < startTime) {
+                return 'Stop time must be later than start time or select overnight';
+            }
+            if (overnight && startTime < stopTime) {
+                return 'Stop time must be earlier than start time or deselect overnight';
+            }
+        }
+        return null;
+    }
+    static validateOvernight(scheduler) {
+        const { type, overnight, stopTimeDisabled } = scheduler;
+        if (overnight && stopTimeDisabled) {
+            return 'Overnight cannot be set if stop time is disabled';
+        }
+        if (type === QueryScheduler.TYPES.TEMPORARY && overnight) {
+            return 'Temporary schedules do not support overnight';
+        }
+        return null;
+    }
+    static validateStopTimeDisabled(scheduler, timeout, stopTimeRequired) {
+        const { type, overnight, stopTimeDisabled } = scheduler;
+        if (!stopTimeRequired && type === QueryScheduler.TYPES.CONTINUOUS) {
+            return 'Continuous schedule is not supported for this query type.  Please select a schedule type';
+        }
+        if (stopTimeRequired && type === QueryScheduler.TYPES.TEMPORARY) {
+            return 'Temporary schedule is not supported for this query type.  Please select a schedule type';
+        }
+        if (overnight && stopTimeDisabled) {
+            return 'Stop time cannot be disabled on an overnight query';
+        }
+        if (stopTimeDisabled && timeout <= 0) {
+            if (type === QueryScheduler.TYPES.CONTINUOUS) {
+                return 'Query types without an end time must have a non-zero Initialization Timeout';
+            }
+            return 'Query types without an end time must have a non-zero Max Execution Time';
+        }
+        return null;
+    }
+    static validateRepeat(scheduler) {
+        const { repeatEnabled, repeatInterval } = scheduler;
+        if (repeatEnabled && repeatInterval <= 0) {
+            return `Set repeat interval greater than 0 or disable interval repeat`;
+        }
+        return null;
+    }
+    static validateDailyDays(scheduler) {
+        const { type, schedulingDisabled, businessDays, dailyDays } = scheduler;
+        if (!schedulingDisabled) {
+            if (type === QueryScheduler.TYPES.DAILY &&
+                !businessDays &&
+                !dailyDays.includes(true)) {
+                return 'Select a day of the week or Business Days';
+            }
+        }
+        return null;
+    }
+    static validateMonthlyDays(scheduler) {
+        const { type, schedulingDisabled, monthlyDays, specificDays, firstBusinessDay, lastBusinessDay, } = scheduler;
+        if (!schedulingDisabled) {
+            if (type === QueryScheduler.TYPES.MONTHLY &&
+                !firstBusinessDay &&
+                !lastBusinessDay &&
+                (!specificDays || !monthlyDays.includes(true))) {
+                return 'Select First Business Day, Last Business Day, or at least one Specific Day';
+            }
+        }
+        return null;
+    }
+    static validateMonths(scheduler) {
+        const { type, schedulingDisabled, months } = scheduler;
+        if (!schedulingDisabled &&
+            type === QueryScheduler.TYPES.MONTHLY &&
+            !months.includes(true)) {
+            return 'Select at least one month';
+        }
+        return null;
+    }
+    static validateDependentOnQuerySerials(scheduler, timeout, stopTimeRequired, dependentQuerySerials) {
+        const { type, schedulingDisabled, dependentOnQuerySerials } = scheduler;
+        if (!schedulingDisabled && type === QueryScheduler.TYPES.DEPENDENT) {
+            if (dependentOnQuerySerials == null ||
+                dependentOnQuerySerials.length === 0) {
+                return 'Must have one dependent-on query';
+            }
+            if (dependentOnQuerySerials.includes(QueryScheduler.INVALID_SERIAL)) {
+                return 'Select a query or delete empty query dependencies';
+            }
+            if (dependentQuerySerials !== undefined &&
+                dependentOnQuerySerials.some(serial => !dependentQuerySerials.includes(serial))) {
+                return 'Select a different query or delete invalid query dependencies';
+            }
+        }
+        return null;
+    }
+    static validateSchedulingDisabled(scheduler) {
+        const { type, schedulingDisabled } = scheduler;
+        if (type === QueryScheduler.TYPES.TEMPORARY && schedulingDisabled) {
+            return 'Temporary schedules cannot be disabled';
+        }
+        return null;
+    }
+    static validateTemporaryDependentOnQuerySerials(scheduler, timeout, stopTimeRequired, dependentQuerySerials, temporaryQuerySerials) {
+        const { type, schedulingDisabled, temporaryDependentOnQuerySerials } = scheduler;
+        if (!schedulingDisabled && type === QueryScheduler.TYPES.TEMPORARY) {
+            if (temporaryDependentOnQuerySerials.includes(QueryScheduler.INVALID_SERIAL)) {
+                return 'Select temporary query or delete empty query dependencies';
+            }
+            if (temporaryQuerySerials !== undefined &&
+                temporaryDependentOnQuerySerials.some(serial => !temporaryQuerySerials.includes(serial))) {
+                return 'Select a different query or delete invalid query dependencies';
+            }
+        }
+        return null;
+    }
+    static validateExpirationTime(scheduler) {
+        const { type, schedulingDisabled, expirationTimeMillis } = scheduler;
+        if (!schedulingDisabled &&
+            type === QueryScheduler.TYPES.TEMPORARY &&
+            expirationTimeMillis <= 0) {
+            return 'Temporary schedules must have a deletion delay';
+        }
+        return null;
+    }
+    static validateRepeatInterval(scheduler, timeout) {
+        const { type, schedulingDisabled, stopTimeDisabled, repeatEnabled, repeatInterval, } = scheduler;
+        if (!schedulingDisabled &&
+            (type === QueryScheduler.TYPES.DAILY ||
+                type === QueryScheduler.TYPES.MONTHLY ||
+                type === QueryScheduler.TYPES.RANGE) &&
+            stopTimeDisabled &&
+            repeatEnabled &&
+            repeatInterval * 60 * 1000 <= timeout) {
+            return 'Max Execution Time must be less than Repeat Interval';
+        }
+        return null;
+    }
+    static validateRestartDelayMinutes(scheduler) {
+        const { restartDelayMinutes, restartErrorCount } = scheduler;
+        if (restartErrorCount > 0) {
+            if (restartDelayMinutes === null) {
+                return 'must not be empty';
+            }
+            const number = Number(restartDelayMinutes);
+            if (Number.isNaN(number)) {
+                return 'must be a number';
+            }
+            if (number < 0) {
+                return 'must not be negative';
+            }
+            if (String(restartDelayMinutes).includes('.')) {
+                return 'must be an integer';
+            }
+        }
+        return null;
+    }
+    static validateStartDateTime(scheduler) {
+        const { type, startDateTime, stopDateTime, repeatEnabled } = scheduler;
+        if (type !== QueryScheduler.TYPES.RANGE) {
+            return null;
+        }
+        if (startDateTime === null && stopDateTime === null) {
+            return 'At least one date is required';
+        }
+        if (repeatEnabled && startDateTime === null) {
+            return 'Start date is required if repeat is enabled';
+        }
+        if (startDateTime !== null && stopDateTime !== null) {
+            if (startDateTime.compare(stopDateTime) >= 0) {
+                return 'Start date must be before stop date';
+            }
+        }
+        return null;
+    }
+    static validateStopDateTime(scheduler) {
+        const { type, startDateTime, stopDateTime, repeatEnabled } = scheduler;
+        if (type !== QueryScheduler.TYPES.RANGE) {
+            return null;
+        }
+        if (startDateTime === null && stopDateTime === null) {
+            return 'At least one date is required';
+        }
+        if (repeatEnabled && stopDateTime === null) {
+            return 'Stop date is required if repeat is enabled';
+        }
+        if (startDateTime !== null && stopDateTime !== null) {
+            if (startDateTime.compare(stopDateTime) >= 0) {
+                return 'Stop date must be after start date';
+            }
+        }
+        return null;
+    }
+}
+QuerySchedulerValidation.VALIDATORS = Object.freeze({
+    [QueryScheduler.FIELDS.DAILY_DAYS]: QuerySchedulerValidation.validateDailyDays,
+    [QueryScheduler.FIELDS.BUSINESS_DAYS]: QuerySchedulerValidation.validateDailyDays,
+    [QueryScheduler.FIELDS.MONTHS]: QuerySchedulerValidation.validateMonths,
+    [QueryScheduler.FIELDS.FIRST_BUSINESS_DAY]: QuerySchedulerValidation.validateMonthlyDays,
+    [QueryScheduler.FIELDS.LAST_BUSINESS_DAY]: QuerySchedulerValidation.validateMonthlyDays,
+    [QueryScheduler.FIELDS.SPECIFIC_DAYS]: QuerySchedulerValidation.validateMonthlyDays,
+    [QueryScheduler.FIELDS.MONTHLY_DAYS]: QuerySchedulerValidation.validateMonthlyDays,
+    [QueryScheduler.FIELDS.DEPENDENT_ON_QUERY_SERIALS]: QuerySchedulerValidation.validateDependentOnQuerySerials,
+    [QueryScheduler.FIELDS.SCHEDULING_DISABLED]: QuerySchedulerValidation.validateSchedulingDisabled,
+    [QueryScheduler.FIELDS.START_TIME]: QuerySchedulerValidation.validateStartTime,
+    [QueryScheduler.FIELDS.STOP_TIME]: QuerySchedulerValidation.validateStopTime,
+    [QueryScheduler.FIELDS.OVERNIGHT]: QuerySchedulerValidation.validateOvernight,
+    [QueryScheduler.FIELDS.STOP_TIME_DISABLED]: QuerySchedulerValidation.validateStopTimeDisabled,
+    [QueryScheduler.FIELDS.REPEAT_ENABLED]: QuerySchedulerValidation.validateRepeat,
+    [QueryScheduler.FIELDS.TEMPORARY_DEPENDENT_ON_QUERY_SERIALS]: QuerySchedulerValidation.validateTemporaryDependentOnQuerySerials,
+    [QueryScheduler.FIELDS.EXPIRATION_TIME_MILLIS]: QuerySchedulerValidation.validateExpirationTime,
+    [QueryScheduler.FIELDS.REPEAT_INTERVAL]: QuerySchedulerValidation.validateRepeatInterval,
+    [QueryScheduler.FIELDS.RESTART_DELAY_MINUTES]: QuerySchedulerValidation.validateRestartDelayMinutes,
+    [QueryScheduler.FIELDS.START_DATE_TIME]: QuerySchedulerValidation.validateStartDateTime,
+    [QueryScheduler.FIELDS.STOP_DATE_TIME]: QuerySchedulerValidation.validateStopDateTime,
+});
+export default QuerySchedulerValidation;

package/dist/QueryType.d.ts

@@ -0,0 +1,12 @@
+export declare enum QueryType {
+    CSV_IMPORT = "CsvImport",
+    JDBC_IMPORT = "JdbcImport",
+    DATA_MERGE = "Merge",
+    DATA_VALIDATE = "Validate",
+    INTERACTIVE_CONSOLE = "InteractiveConsole",
+    REPLAY_SCRIPT = "ReplayScript",
+    RUN_AND_DONE = "RunAndDone",
+    RUN_AND_DONE_IMPORT = "RunAndDoneImport",
+    SCRIPT = "Script",
+    SCRIPT_MERGE_SERVER = "ScriptMergeServer"
+}

package/dist/QueryType.js

@@ -0,0 +1,13 @@
+export var QueryType;
+(function (QueryType) {
+    QueryType["CSV_IMPORT"] = "CsvImport";
+    QueryType["JDBC_IMPORT"] = "JdbcImport";
+    QueryType["DATA_MERGE"] = "Merge";
+    QueryType["DATA_VALIDATE"] = "Validate";
+    QueryType["INTERACTIVE_CONSOLE"] = "InteractiveConsole";
+    QueryType["REPLAY_SCRIPT"] = "ReplayScript";
+    QueryType["RUN_AND_DONE"] = "RunAndDone";
+    QueryType["RUN_AND_DONE_IMPORT"] = "RunAndDoneImport";
+    QueryType["SCRIPT"] = "Script";
+    QueryType["SCRIPT_MERGE_SERVER"] = "ScriptMergeServer";
+})(QueryType || (QueryType = {}));

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './DraftQuery';
+export * from './QueryColumns';
+export * from './QueryScheduler';
+export * from './QuerySchedulerValidation';
+export * from './QueryType';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './DraftQuery';
+export * from './QueryColumns';
+export * from './QueryScheduler';
+export * from './QuerySchedulerValidation';
+export * from './QueryType';

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@deephaven-enterprise/query-utils",
+  "version": "1.20240723.62-alpha-fix-dependencies.1",
+  "description": "Deephaven Enterprise Query Utils",
+  "author": "Deephaven Data Labs LLC",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "type": "module",
+  "private": false,
+  "source": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc --build"
+  },
+  "dependencies": {
+    "@deephaven/jsapi-types": "^1.0.0-dev0.34.3",
+    "@deephaven/log": "^0.95.0",
+    "@deephaven/utils": "^0.95.0",
+    "@internationalized/date": "^3.5.5",
+    "shortid": "^2.2.16"
+  },
+  "devDependencies": {
+    "@types/shortid": "^0.0.32"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}