@deephaven-enterprise/query-utils 2026.1.38 → 2026.1.39

package/dist/EditableQueryInfoUtils.d.ts

@@ -0,0 +1,19 @@
+import type { EditableQueryInfo, PlainEditableQueryInfo } from '@deephaven-enterprise/jsapi-types';
+import type DraftQuery from './DraftQuery';
+import type { ScriptDraftQuery } from './DraftQuery';
+declare const FIELDS: {
+    readonly SCRIPT_LANGUAGE: "scriptLanguage";
+    readonly SCRIPT_PATH: "scriptPath";
+    readonly SCRIPT_CODE: "scriptCode";
+};
+type QueryContentFields = Pick<EditableQueryInfo, typeof FIELDS.SCRIPT_LANGUAGE | typeof FIELDS.SCRIPT_PATH | typeof FIELDS.SCRIPT_CODE>;
+/**
+ * Check if the content fields in the given queries have different values
+ * @param queryA Query A
+ * @param queryB Query B
+ * @returns True, if the content fields don't match
+ */
+export declare function isContentChanged(queryA: QueryContentFields, queryB: QueryContentFields): boolean;
+export declare function getPlainEditableQueryInfo(query: EditableQueryInfo | PlainEditableQueryInfo): PlainEditableQueryInfo;
+export declare function isScriptDraftQuery(query: DraftQuery | ScriptDraftQuery): query is ScriptDraftQuery;
+export {};

package/dist/EditableQueryInfoUtils.js

@@ -0,0 +1,53 @@
+const FIELDS = {
+    SCRIPT_LANGUAGE: 'scriptLanguage',
+    SCRIPT_PATH: 'scriptPath',
+    SCRIPT_CODE: 'scriptCode',
+};
+/**
+ * Check if the content fields in the given queries have different values
+ * @param queryA Query A
+ * @param queryB Query B
+ * @returns True, if the content fields don't match
+ */
+export function isContentChanged(queryA, queryB) {
+    return Object.values(FIELDS).some(field => queryA[field] !== queryB[field]);
+}
+export function getPlainEditableQueryInfo(query) {
+    // Can't use a spread operator because the EditableQueryInfo JS API object uses property accessors
+    return {
+        adminGroups: [...query.adminGroups],
+        dataMemoryRatio: query.dataMemoryRatio,
+        dbServerName: query.dbServerName,
+        enabled: query.enabled,
+        enableGcLogs: query.enableGcLogs,
+        envVars: query.envVars,
+        extraClasspaths: query.extraClasspaths,
+        heapSize: query.heapSize,
+        additionalMemory: query.additionalMemory,
+        jvmArgs: query.jvmArgs,
+        jvmProfile: query.jvmProfile,
+        name: query.name,
+        owner: query.owner,
+        restartUsers: query.restartUsers,
+        scheduling: [...query.scheduling],
+        scriptLanguage: query.scriptLanguage,
+        scriptPath: query.scriptPath,
+        timeout: query.timeout,
+        type: query.type,
+        typeSpecificFields: query.typeSpecificFields == null ? null : Object.assign({}, query.typeSpecificFields),
+        viewerGroups: [...query.viewerGroups],
+        replicaCount: query.replicaCount,
+        spareCount: query.spareCount,
+        assignmentPolicy: query.assignmentPolicy,
+        assignmentPolicyParams: query.assignmentPolicyParams,
+        scriptCode: query.scriptCode,
+        serial: query.serial,
+        genericWorkerControl: query.genericWorkerControl,
+        kubernetesControl: query.kubernetesControl,
+        pythonControl: query.pythonControl,
+        workerKind: query.workerKind,
+    };
+}
+export function isScriptDraftQuery(query) {
+    return query.scriptLanguage != null;
+}

package/dist/QueryFinders.d.ts

@@ -0,0 +1,5 @@
+import type { EnterpriseClient, QueryInfo } from '@deephaven-enterprise/jsapi-types';
+export declare function findQueryByGrpcUrl(client: EnterpriseClient, grpcUrl: string): QueryInfo | undefined;
+export declare function findQueryByName(client: EnterpriseClient, queryName: string): QueryInfo | undefined;
+export declare function findQueryBySerial(client: EnterpriseClient, querySerial: string): QueryInfo | undefined;
+export declare function getQueryNameForSerial(client: EnterpriseClient, querySerial: string): string | null;

package/dist/QueryFinders.js

@@ -0,0 +1,15 @@
+export function findQueryByGrpcUrl(client, grpcUrl) {
+    return client
+        .getKnownConfigs()
+        .find(({ designated }) => (designated === null || designated === void 0 ? void 0 : designated.grpcUrl) === grpcUrl);
+}
+export function findQueryByName(client, queryName) {
+    return client.getKnownConfigs().find(({ name }) => name === queryName);
+}
+export function findQueryBySerial(client, querySerial) {
+    return client.getKnownConfigs().find(({ serial }) => serial === querySerial);
+}
+export function getQueryNameForSerial(client, querySerial) {
+    const query = findQueryBySerial(client, querySerial);
+    return query ? query.name : null;
+}

package/dist/QueryPermissions.d.ts

@@ -0,0 +1,41 @@
+import type { EnterpriseUser, QueryConfigurationType, QueryInfo, QuerySelectionPermissions } from '@deephaven-enterprise/jsapi-types';
+import DraftQuery from './DraftQuery';
+export declare const RESTART_USERS: Readonly<{
+    readonly RESTARTUSERS_ADMIN: 1;
+    readonly RESTARTUSERS_ADMINANDVIEWERS: 2;
+    readonly RESTARTUSERS_VIEWERSWHENDOWN: 4;
+}>;
+export declare const TYPE_SPECIFIC_FIELD_PARTITION_FORMULA = "PartitionFormula";
+/**
+ * Check if the user can view permissions for the query
+ * @param user User object to check if can view permissions for the query
+ * @param draftQuery The draft query object to check against
+ * @returns True if the user can view permissions for the query, false otherwise
+ */
+export declare function canViewPermissions(user: EnterpriseUser, draftQuery: DraftQuery | null): boolean;
+/**
+ * Get the query configuration types that are displayable and the user is allowed to create
+ * @param queryConfigurationTypes Query configuration types to filter
+ * @param userGroups Groups the user is in
+ * @param isSuperUser Whether the user is a super user
+ * @returns Query configuration types that are displayable and the user is allowed to create
+ */
+export declare function getDisplayableQueryTypes(queryConfigurationTypes: QueryConfigurationType[], userGroups: string[], isSuperUser?: boolean): QueryConfigurationType[];
+/**
+ * Get the user permissions for selected queries.
+ *
+ * Based on com.illumon.iris.controller.utils.PersistentQueryConfigTableUtils.SelectedQueryStates#SelectedQueryStates
+ *
+ * @param user The user to check permissions for
+ * @param selectedQueries The queries to check permissions for
+ * @returns The query permissions for the user for the selected queries
+ */
+export declare function getQuerySelectionPermissions(user: EnterpriseUser, selectedQueries: QueryInfo[]): QuerySelectionPermissions;
+/**
+ * Check if the user is allowed to create a query of this type
+ * @param queryConfigurationType Type of query configuration
+ * @param userGroups Groups the user is in
+ * @param isSuperUser Whether the user is a super user
+ * @returns True if the user is allowed to create a query of this type, false otherwise
+ */
+export declare function isAllowedQueryConfigurationType(queryConfigurationType: QueryConfigurationType | undefined, userGroups: string[], isSuperUser?: boolean): boolean;

package/dist/QueryPermissions.js

@@ -0,0 +1,148 @@
+import DraftQuery from './DraftQuery';
+import { QueryScheduler } from './QueryScheduler';
+import { checkAllReplicas, isRunningForRestart, isStoppedForPermissions, } from './QueryStateUtils';
+import { getQuerySchedulerType } from './QueryUtils';
+export const RESTART_USERS = Object.freeze({
+    RESTARTUSERS_ADMIN: 1,
+    RESTARTUSERS_ADMINANDVIEWERS: 2,
+    RESTARTUSERS_VIEWERSWHENDOWN: 4,
+});
+export const TYPE_SPECIFIC_FIELD_PARTITION_FORMULA = 'PartitionFormula';
+/**
+ * Check if the user can view permissions for the query
+ * @param user User object to check if can view permissions for the query
+ * @param draftQuery The draft query object to check against
+ * @returns True if the user can view permissions for the query, false otherwise
+ */
+export function canViewPermissions(user, draftQuery) {
+    if (draftQuery == null) {
+        return false;
+    }
+    // If they own the query or are creating a new one, permissions tab is available only if they have the share permission
+    if (draftQuery.serial === DraftQuery.NO_SERIAL ||
+        draftQuery.owner === user.operateAs) {
+        return user.permissions.canShareQueries;
+    }
+    // If it's shared with them and they're an admin, show the permissions tab
+    if (draftQuery.adminGroups.some(group => user.groups.includes(group))) {
+        return true;
+    }
+    // Otherwise, only show it if they can view the shared users
+    return user.permissions.canViewQuerySharedUsers;
+}
+/**
+ * Get the query configuration types that are displayable and the user is allowed to create
+ * @param queryConfigurationTypes Query configuration types to filter
+ * @param userGroups Groups the user is in
+ * @param isSuperUser Whether the user is a super user
+ * @returns Query configuration types that are displayable and the user is allowed to create
+ */
+export function getDisplayableQueryTypes(queryConfigurationTypes, userGroups, isSuperUser = false) {
+    return queryConfigurationTypes.filter(queryConfigurationType => queryConfigurationType.isDisplayable &&
+        isAllowedQueryConfigurationType(queryConfigurationType, userGroups, isSuperUser));
+}
+/**
+ * Get the user permissions for selected queries.
+ *
+ * Based on com.illumon.iris.controller.utils.PersistentQueryConfigTableUtils.SelectedQueryStates#SelectedQueryStates
+ *
+ * @param user The user to check permissions for
+ * @param selectedQueries The queries to check permissions for
+ * @returns The query permissions for the user for the selected queries
+ */
+export function getQuerySelectionPermissions(user, selectedQueries) {
+    const permissions = {
+        allAdmin: true,
+        allOwner: true,
+        allRestartable: true,
+        allStoppable: true,
+        allStopped: true,
+        allDisabled: true,
+        allEnabled: true,
+        allTemporary: true,
+        allImportMerge: true,
+        readOnlyUser: user.permissions.isQueryViewOnly,
+    };
+    // If there are no queries selected, then don't assume allTemporary
+    if (selectedQueries.length === 0) {
+        permissions.allTemporary = false;
+    }
+    const { isQueryManager } = user.permissions;
+    selectedQueries.forEach(query => {
+        const isOwner = query.owner === user.operateAs;
+        const isAdmin = user.permissions.isSuperUser ||
+            user.groups.includes(query.owner) ||
+            query.adminGroups.some(group => user.groups.includes(group));
+        const isViewer = query.viewerGroups.some(group => user.groups.includes(group));
+        const isVisibleToUser = isOwner || isAdmin || isViewer;
+        if (!isOwner) {
+            permissions.allOwner = false;
+        }
+        if (!isAdmin) {
+            permissions.allAdmin = false;
+        }
+        if (permissions.allTemporary &&
+            getQuerySchedulerType(query.scheduling) !== QueryScheduler.TYPES.TEMPORARY) {
+            permissions.allTemporary = false;
+        }
+        // Check if the query can be restarted based on the restartUsers setting
+        switch (query.restartUsers) {
+            case RESTART_USERS.RESTARTUSERS_ADMINANDVIEWERS:
+                permissions.allRestartable =
+                    permissions.allRestartable && (isAdmin || isViewer || isQueryManager);
+                break;
+            case RESTART_USERS.RESTARTUSERS_VIEWERSWHENDOWN:
+                if (!isAdmin && !isQueryManager) {
+                    const isRunning = checkAllReplicas(query, isRunningForRestart);
+                    permissions.allRestartable =
+                        permissions.allRestartable && !isRunning && isVisibleToUser;
+                }
+                break;
+            case RESTART_USERS.RESTARTUSERS_ADMIN:
+            default:
+                permissions.allRestartable =
+                    permissions.allRestartable && (isAdmin || isQueryManager);
+        }
+        permissions.allStoppable =
+            permissions.allStoppable && (isAdmin || isQueryManager);
+        const isStopped = checkAllReplicas(query, isStoppedForPermissions);
+        if (!isStopped) {
+            permissions.allStopped = false;
+        }
+        if (query.enabled) {
+            permissions.allDisabled = false;
+        }
+        else {
+            permissions.allEnabled = false;
+        }
+        const { typeSpecificFields } = query;
+        if (typeSpecificFields != null) {
+            const hasPartitionFormula = Object.hasOwn(typeSpecificFields, TYPE_SPECIFIC_FIELD_PARTITION_FORMULA);
+            if (!hasPartitionFormula) {
+                permissions.allImportMerge = false;
+            }
+        }
+        else {
+            permissions.allImportMerge = false;
+        }
+    });
+    return permissions;
+}
+/**
+ * Check if the user is allowed to create a query of this type
+ * @param queryConfigurationType Type of query configuration
+ * @param userGroups Groups the user is in
+ * @param isSuperUser Whether the user is a super user
+ * @returns True if the user is allowed to create a query of this type, false otherwise
+ */
+export function isAllowedQueryConfigurationType(queryConfigurationType, userGroups, isSuperUser = false) {
+    if (queryConfigurationType == null) {
+        return false;
+    }
+    if (isSuperUser) {
+        return true;
+    }
+    const { allowedGroups } = queryConfigurationType;
+    return (allowedGroups.length === 0 ||
+        allowedGroups.some(group => userGroups.includes(group)));
+}

package/dist/QueryScheduler.d.ts

@@ -1,4 +1,4 @@
-import { CalendarDateTime } from '@internationalized/date';
+import { type CalendarDateTime } from '@internationalized/date';
 /**
  * QueryScheduler is the client side equivalent of the server side class IrisScheduler.
  *

package/dist/QueryStateUtils.d.ts

@@ -0,0 +1,57 @@
+import type { dh } from '@deephaven/jsapi-types';
+import type { QueryInfo } from '@deephaven-enterprise/jsapi-types';
+import type DraftQuery from './DraftQuery';
+export type QueryInfoMap = Map<string, QueryInfo>;
+export declare const NON_RUNNING_STATUSES: Set<string>;
+/**
+ * Determines if the given draft query is a batch query
+ * @param type the type of the draft query to check
+ * @returns true if the draft query is a batch query, false otherwise
+ */
+export declare function isBatchQueryType(type: string | null | undefined): boolean;
+export declare function isEnableable(queryInfoMap: QueryInfoMap, serial: string): boolean;
+export declare function isDisableable(queryInfoMap: QueryInfoMap, serial: string): boolean;
+export declare function isRestartable(queryInfoMap: QueryInfoMap | undefined, serial: string): boolean;
+export declare function isStartable(queryInfoMap: QueryInfoMap | undefined, serial: string): boolean;
+export declare function isStoppable(queryInfoMap: QueryInfoMap | undefined, serial: string): boolean;
+export declare function isRunning(query: QueryInfo): boolean;
+export declare function isWebClient(query: QueryInfo): boolean;
+/**
+ * Check if the specified query can be restarted in it's current state.
+ * @param status the status of the query replica
+ */
+export declare function isRestartableForEdit(status: unknown): boolean;
+export declare function isRestartableForEditByRow(table?: dh.Table, row?: dh.Row): boolean;
+/**
+ * Check if the query has a pending update to be applied.  That is, that the currently
+ * running version of the query is not the latest saved configuration of the query.
+ *
+ * @param status the status field of the query replica
+ * @param configVersion the version of the query configuration
+ * @param runningVersion the currently running version of the query replica
+ * @returns true if an update is pending, false otherwise
+ */
+export declare function isQueryUpdatePending(status: unknown, configVersion: unknown, runningVersion?: unknown): boolean;
+export declare function isUpdatePendingForRow(table?: dh.Table, row?: dh.Row): boolean;
+/**
+ * Check if this query is allowed to be saved without a restart.
+ * Queries are allowed to be saved without restart as long as:
+ * - The Owner has not changed
+ * - The Admin Groups have not been removed from
+ * - The query type has not changed
+ * - The scheduler and scheduler properties have not changed
+ * - The query is not a Temporary query
+ *
+ * @param draft the draft query to compare
+ * @param queryInfo the original query to compare to
+ */
+export declare function isNoRestartAllowed(draft?: DraftQuery | null, queryInfo?: Partial<QueryInfo> | null): boolean;
+/**
+ * Checks if the query is running or executing, which means it can be restarted.
+ *
+ * @param queryStatus The status of the query to check
+ * @returns true if the query is running or executing, false otherwise
+ */
+export declare function isRunningForRestart(queryStatus: string): boolean;
+export declare function isStoppedForPermissions(queryStatus: string): boolean;
+export declare function checkAllReplicas(query: QueryInfo, statusFunction: (status: string) => boolean): boolean;

package/dist/QueryStateUtils.js

@@ -0,0 +1,187 @@
+import { QueryColumns } from './QueryColumns';
+import { QueryScheduler } from './QueryScheduler';
+import { QueryStatus } from './QueryStatus';
+import { QueryType } from './QueryType';
+import { WEB_CLIENT_DATA_CORE_CONFIG_TYPE } from './QueryUtils';
+export const NON_RUNNING_STATUSES = new Set([
+    QueryStatus.uninitialized,
+    QueryStatus.stopped,
+    QueryStatus.error,
+    QueryStatus.failed,
+    QueryStatus.disconnected,
+    QueryStatus.completed,
+    QueryStatus.none,
+]);
+/**
+ * Determines if the given draft query is a batch query
+ * @param type the type of the draft query to check
+ * @returns true if the draft query is a batch query, false otherwise
+ */
+export function isBatchQueryType(type) {
+    return (type === QueryType.RUN_AND_DONE || type === QueryType.RUN_AND_DONE_IMPORT);
+}
+export function isEnableable(queryInfoMap, serial) {
+    var _a, _b;
+    return (queryInfoMap.has(serial) && !((_b = (_a = queryInfoMap.get(serial)) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : false));
+}
+export function isDisableable(queryInfoMap, serial) {
+    var _a;
+    if (!queryInfoMap.has(serial)) {
+        return false;
+    }
+    const queryInfo = queryInfoMap.get(serial);
+    if (!queryInfo) {
+        return false;
+    }
+    return (queryInfo.enabled &&
+        // Can't disable temporary queries
+        !((_a = queryInfo.scheduling) === null || _a === void 0 ? void 0 : _a.includes(QueryScheduler.TOKENS.SCHEDULER_TYPE +
+            QueryScheduler.TOKENS.DELIMITER +
+            QueryScheduler.TYPES.TEMPORARY)));
+}
+export function isRestartable(queryInfoMap, serial) {
+    const query = queryInfoMap === null || queryInfoMap === void 0 ? void 0 : queryInfoMap.get(serial);
+    if (query == null)
+        return false;
+    return (query.enabled === true &&
+        query.type !== QueryType.INTERACTIVE_CONSOLE &&
+        query.type !== QueryType.SCHEMA_API);
+}
+export function isStartable(queryInfoMap, serial) {
+    var _a, _b;
+    const query = queryInfoMap === null || queryInfoMap === void 0 ? void 0 : queryInfoMap.get(serial);
+    return (isRestartable(queryInfoMap, serial) &&
+        query != null &&
+        NON_RUNNING_STATUSES.has((_b = (_a = query === null || query === void 0 ? void 0 : query.designated) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : QueryStatus.none));
+}
+export function isStoppable(queryInfoMap, serial) {
+    var _a, _b;
+    const query = queryInfoMap === null || queryInfoMap === void 0 ? void 0 : queryInfoMap.get(serial);
+    if (query == null)
+        return false;
+    return (query.enabled === true &&
+        ((_a = query.designated) === null || _a === void 0 ? void 0 : _a.status) !== QueryStatus.stopped &&
+        ((_b = query.designated) === null || _b === void 0 ? void 0 : _b.status) !== QueryStatus.stopping);
+}
+export function isRunning(query) {
+    var _a;
+    return ((_a = query.designated) === null || _a === void 0 ? void 0 : _a.status) === QueryStatus.running;
+}
+export function isWebClient(query) {
+    return query.type === WEB_CLIENT_DATA_CORE_CONFIG_TYPE;
+}
+/**
+ * Check if the specified query can be restarted in it's current state.
+ * @param status the status of the query replica
+ */
+export function isRestartableForEdit(status) {
+    return (status === QueryStatus.running ||
+        status === QueryStatus.initializing ||
+        status === QueryStatus.executing);
+}
+export function isRestartableForEditByRow(table, row) {
+    if (table == null || row == null) {
+        return false;
+    }
+    const status = row.get(table.findColumn(QueryColumns.STATUS.name));
+    return isRestartableForEdit(status);
+}
+/**
+ * Check if the query has a pending update to be applied.  That is, that the currently
+ * running version of the query is not the latest saved configuration of the query.
+ *
+ * @param status the status field of the query replica
+ * @param configVersion the version of the query configuration
+ * @param runningVersion the currently running version of the query replica
+ * @returns true if an update is pending, false otherwise
+ */
+export function isQueryUpdatePending(status, configVersion, runningVersion) {
+    if (runningVersion == null || configVersion == null) {
+        return false;
+    }
+    return isRestartableForEdit(status) && configVersion !== runningVersion;
+}
+export function isUpdatePendingForRow(table, row) {
+    var _a, _b;
+    if (table == null || row == null) {
+        return false;
+    }
+    const status = row.get(table.findColumn(QueryColumns.STATUS.name));
+    const currentVersion = (_a = row
+        .get(table.findColumn(QueryColumns.CURRENTLY_RUNNING_VERSION.name))) === null || _a === void 0 ? void 0 : _a.valueOf();
+    const pendingVersion = (_b = row
+        .get(table.findColumn(QueryColumns.VERSION.name))) === null || _b === void 0 ? void 0 : _b.valueOf();
+    return isQueryUpdatePending(status, pendingVersion, currentVersion);
+}
+/**
+ * Check if this query is allowed to be saved without a restart.
+ * Queries are allowed to be saved without restart as long as:
+ * - The Owner has not changed
+ * - The Admin Groups have not been removed from
+ * - The query type has not changed
+ * - The scheduler and scheduler properties have not changed
+ * - The query is not a Temporary query
+ *
+ * @param draft the draft query to compare
+ * @param queryInfo the original query to compare to
+ */
+export function isNoRestartAllowed(draft, queryInfo) {
+    var _a, _b;
+    if (!draft ||
+        !queryInfo ||
+        !draft.isModified ||
+        !isRestartableForEdit((_a = queryInfo === null || queryInfo === void 0 ? void 0 : queryInfo.designated) === null || _a === void 0 ? void 0 : _a.status)) {
+        return false;
+    }
+    const origSchedulerParams = queryInfo.scheduling;
+    const draftSchedulerParams = draft.scheduler.toStringArray();
+    if (origSchedulerParams == null ||
+        draftSchedulerParams == null ||
+        origSchedulerParams.length !== draftSchedulerParams.length) {
+        return false;
+    }
+    const newParams = new Set(draftSchedulerParams);
+    if (!origSchedulerParams.every(param => newParams.has(param))) {
+        return false;
+    }
+    if (draft.owner !== queryInfo.owner) {
+        return false;
+    }
+    if (draft.type !== queryInfo.type) {
+        return false;
+    }
+    if (draft.type === QueryScheduler.TYPES.TEMPORARY) {
+        return false;
+    }
+    const newAdmins = new Set(draft.adminGroups);
+    if (!((_b = queryInfo.adminGroups) !== null && _b !== void 0 ? _b : []).every(group => newAdmins.has(group))) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Checks if the query is running or executing, which means it can be restarted.
+ *
+ * @param queryStatus The status of the query to check
+ * @returns true if the query is running or executing, false otherwise
+ */
+export function isRunningForRestart(queryStatus) {
+    return (queryStatus === QueryStatus.running || queryStatus === QueryStatus.executing);
+}
+export function isStoppedForPermissions(queryStatus) {
+    return (queryStatus === QueryStatus.uninitialized ||
+        queryStatus === QueryStatus.stopped ||
+        queryStatus === QueryStatus.error ||
+        queryStatus === QueryStatus.failed ||
+        queryStatus === QueryStatus.disconnected ||
+        queryStatus === QueryStatus.completed ||
+        queryStatus === QueryStatus.none);
+}
+export function checkAllReplicas(query, statusFunction) {
+    var _a, _b;
+    const replicasAndSpares = [...query.replicas, ...query.spares];
+    if (replicasAndSpares.length === 0) {
+        return statusFunction((_b = (_a = query.designated) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : QueryStatus.none);
+    }
+    return replicasAndSpares.every(replica => { var _a; return statusFunction((_a = replica.status) !== null && _a !== void 0 ? _a : QueryStatus.none); });
+}

package/dist/QueryUtils.d.ts

@@ -1,11 +1,11 @@
 import type { dh } from '@deephaven/jsapi-types';
-import type { UriVariableDescriptor } from '@deephaven/jsapi-bootstrap';
-import type { EnterpriseClient, EnterpriseDhType, QueryInfo, QueryVariableDescriptor, ReplicaStatus, UserInfo } from '@deephaven-enterprise/jsapi-types';
+import type { EnterpriseClient, EnterpriseDhType, QueryConfigurationType, QueryInfo, QueryVariableDescriptor, ReplicaStatus, UserInfo } from '@deephaven-enterprise/jsapi-types';
 import { type Brand } from '@deephaven/utils';
 import DraftQuery, { type DraftQueryConstructorObject } from './DraftQuery';
 import type { CorePlusManager } from './CorePlusManager';
 export type ConsoleType = 'groovy' | 'python';
 export type QuerySerial = Brand<'QuerySerial', string>;
+export type UriVariableDescriptor = string;
 export declare const DEFAULT_TEMPORARY_QUERY_AUTO_DELETE_TIMEOUT_MS: 600000;
 export declare const DEFAULT_TEMPORARY_QUERY_TIMEOUT_MS: 60000;
 export declare const INTERACTIVE_CONSOLE_TEMPORARY_QUEUE_NAME: "InteractiveConsoleTemporaryQueue";
@@ -96,6 +96,20 @@ export declare function getQueryObjectDefinitionByName(query: QueryInfo, name: s
  * @returns Resolves to the ReplicaStatus
  */
 export declare function getWorkerForSlot(query: QueryInfo, slot?: number | null): ReplicaStatus | undefined;
+/**
+ * Parses only the scheduling type out of a QueryInfo's scheduling array.
+ * Logic is duplicated from QueryScheduler.parseBaseScheduler()
+ * @param schedulingArray Array containing scheduling data received from the server
+ * @returns The scheduler type, or undefined if not found
+ */
+export declare function getQuerySchedulerType(schedulingArray: readonly string[]): string | undefined;
+/**
+ * Check if the specified query configuration type supports community.
+ * @param queryConfigurationTypes The map of query configuration types to check against.
+ * @param type The type of query configuration to check.
+ * @returns True if the specified query configuration type supports community, false otherwise.
+ */
+export declare function hasCommunitySupport(queryConfigurationTypes: ReadonlyMap<string, QueryConfigurationType>, type: string): boolean;
 /**
  * Indicates that a table should be fetched from the WebClientTableFactoryService rather than the query scope.
  *

package/dist/QueryUtils.js

@@ -169,6 +169,30 @@ export function getWorkerForSlot(query, slot) {
     }
     return query.replicas[slot];
 }
+/**
+ * Parses only the scheduling type out of a QueryInfo's scheduling array.
+ * Logic is duplicated from QueryScheduler.parseBaseScheduler()
+ * @param schedulingArray Array containing scheduling data received from the server
+ * @returns The scheduler type, or undefined if not found
+ */
+export function getQuerySchedulerType(schedulingArray) {
+    const schedulerType = schedulingArray.find(s => s.startsWith(QueryScheduler.TOKENS.SCHEDULER_TYPE));
+    if (schedulerType == null)
+        return undefined;
+    const splitString = schedulerType.split(QueryScheduler.TOKENS.DELIMITER);
+    QueryScheduler.validateSplitLength(schedulerType, splitString, 2);
+    return splitString[1];
+}
+/**
+ * Check if the specified query configuration type supports community.
+ * @param queryConfigurationTypes The map of query configuration types to check against.
+ * @param type The type of query configuration to check.
+ * @returns True if the specified query configuration type supports community, false otherwise.
+ */
+export function hasCommunitySupport(queryConfigurationTypes, type) {
+    var _a, _b;
+    return (_b = (_a = queryConfigurationTypes.get(type)) === null || _a === void 0 ? void 0 : _a.supportsCommunity) !== null && _b !== void 0 ? _b : false;
+}
 /**
  * Indicates that a table should be fetched from the WebClientTableFactoryService rather than the query scope.
  *

package/dist/index.d.ts

@@ -1,5 +1,9 @@
 export * from './CorePlusManager';
 export * from './DraftQuery';
+export * from './EditableQueryInfoUtils';
+export * from './QueryFinders';
+export * from './QueryPermissions';
+export * from './QueryStateUtils';
 export * from './QueryColumns';
 export * from './QueryDisplayType';
 export * from './QueryScheduler';

package/dist/index.js

@@ -1,5 +1,9 @@
 export * from './CorePlusManager';
 export * from './DraftQuery';
+export * from './EditableQueryInfoUtils';
+export * from './QueryFinders';
+export * from './QueryPermissions';
+export * from './QueryStateUtils';
 export * from './QueryColumns';
 export * from './QueryDisplayType';
 export * from './QueryScheduler';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deephaven-enterprise/query-utils",
-  "version": "2026.1.38",
+  "version": "2026.1.39",
   "description": "Deephaven Enterprise Query Utils",
   "author": "Deephaven Data Labs LLC",
   "license": "SEE LICENSE IN LICENSE.md",
@@ -21,7 +21,7 @@
     "@deephaven-enterprise/jsapi-types": "file:../jsapi-types",
     "@deephaven/log": "^0.97.0",
     "@deephaven/utils": "^0.97.0",
-    "@internationalized/date": "^3.5.5",
+    "@internationalized/date": "^3.12.2",
     "nanoid": "^5.1.6"
   },
   "publishConfig": {