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

package/LICENSE.md

@@ -0,0 +1,136 @@
+Deephaven Data Labs is dedicated to developing Deephaven's software in the open
+and is making software available under the following licenses:
+
+- **Deephaven Open Source** is made available under the Apache 2.0 License
+- **Deephaven Community** is provided under a source-available license, the
+Deephaven Community License Agreement
+
+To request a commercial license for software or uses not covered by these
+licenses or to ask any license-related question, please contact us at:
+[license@deephaven.io](mailto:license@deephaven.io)
+
+
+# Deephaven Community License Agreement Version 1.0
+
+1. **ACCEPTANCE.** This Deephaven Community License Agreement is entered into by
+and between Deephaven Data Labs LLC, a Delaware Limited Liability Company, with
+an address of 2800 Niagara Lane North, Plymouth, MN 55447 ("Deephaven") and
+“You” (a) in your individual capacity, or (b) on behalf of your company if you
+are licensing the Software for a company for which or with which you work. By
+using the Software, You agree to all of the terms and conditions in this
+Deephaven Community License Agreement (the "Agreement").
+
+2. **THE SOFTWARE.** The "Software" means the version of the Deephaven Community
+Software provided to the original licensee with this Agreement. The Software may
+include third party owned code. Each third party module is subject to the terms
+of its respective license; the details of which can be found in the notices
+served at [https://github.com/deephaven/deephaven-core](https://github.com/deephaven/deephaven-core).
+Since licensees may contribute back to the Software as provided for in Section
+3(b), the Software may include any such contributions.
+
+3. **GRANT OF LICENSE.** Subject to the terms and conditions of this Agreement,
+Deephaven hereby grants You a royalty-free, worldwide, non-exclusive,
+non-transferable license to the Software (the "License"), subject, in all of the
+cases, to applicable laws and regulations, but not for the Prohibited Use (as
+provided for in Section 4), solely as follows:
+
+   - a. **Internal Use.** A license to use, copy, compile, and install the
+Software for Your internal use;
+
+   - b. **Derivative Works.** A license to (i) prepare, develop, compile, and test
+Derivative Works of the Software, (ii) use Your Derivative Works for Your
+internal use solely as expressly permitted in Section 3(a), and (iii) distribute
+Your Derivative Works back to Deephaven under a separate Deephaven Contributor
+Agreement for potential incorporation into the Software at Deephaven's sole
+discretion. A "Derivative Work" means any work that (A) is based on or derived
+from the Software including any modifications to the Software, or (B) meets the
+definition of derivative work under the United States Copyright Act of 1976, 17
+U.S.C. Section 101; and
+
+   - c. **Distribution and redistribution.** A license to distribute or
+redistribute the Software and Your Derivative Works, and copies of the Software
+and Your Derivative Works, to customers and other third parties for their use
+pursuant to this Agreement subject to the prohibitions in Section 4 and
+Agreement requirement as provided for in Section 5.
+
+4. **PROHIBITED USE.** Notwithstanding any provision of this Agreement to the
+contrary, the original licensee is prohibited from using, distributing, or
+deploying the Software or Derivative Works in such a way that a third party
+(including any recipient under Section 3(c)) can, directly or indirectly
+through the original licensee, its agents, its technology, or solutions made
+available to them, add, define, redefine, or modify the schema for any input
+tables (including source tables, or other input objects) that the Software or
+Derivative Works access. For clarification, every recipient of the Software or
+Derivative Works after the original licensee of the Software is prohibited from
+adding, defining, redefining, or modifying the schema for any input tables
+(including source tables, or other input objects) that the Software or
+Derivative Works access. This prohibition in no way affects the ability of a
+third party to add, define, redefine, or modify the schema of output tables
+(including output tables that are interim or derived). Further, this
+prohibition in no way affects the ability of a third party to add, define,
+redefine, or modify data (as opposed to schema), nor does it cause You to be
+limited in any capacity for Your internal use as permitted in Section 3(a). If
+You have any questions on this prohibition, please contact us at:
+[license@deephaven.io](mailto:license@deephaven.io)
+
+5. **AGREEMENT.** If You distribute the Software, whether directly, as a copy,
+or via Your Derivative Works you must provide recipients a copy of this
+Agreement (which will bind each recipient directly) and You must ensure that all
+copyright, patent, trademark, and attribution notices from the Software are
+retained.
+
+6. **AFFILIATES.** You may permit Your affiliates to exercise the License,
+provided that such exercise must be solely for Your benefit and/or the benefit
+of Your affiliate, and You shall be responsible for all acts and omissions of
+such affiliates in connection with such exercise of the License, including but
+not limited to breach of any terms of this Agreement.
+
+7. **SUBLICENSE.** The License is sublicensable only to Your third-party
+subcontractors and contractors performing services on Your or Your affiliates'
+behalf, subject to the terms and conditions of this Agreement. The License is
+not sublicensable to any other third party nor is it further sublicensable. You
+shall be responsible for all acts and omissions of such subcontractor and
+contractors in connection with such exercise of the sublicense, including but
+not limited to breach of any terms of this Agreement.
+
+8. **PATENTS.** Rights to use the Software do not give You any right to
+implement or use Deephaven's patents independently of the permitted use of the
+Software.
+
+9. **RESERVATION OF RIGHTS.** Deephaven reserves all rights not granted in this
+Agreement. You have no right to use Deephaven trade names, trademarks, service
+marks, or product names except as required for reasonable and customary use in
+describing the origin of the Software.
+
+10. **DISCLAIMER OF WARRANTY.** THE SOFTWARE IS LICENSED ON AN "AS IS" BASIS
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND. DEEPHAVEN DISCLAIMS ALL
+WARRANTIES, EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OF
+TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+You are solely responsible for determining the appropriateness of using,
+distributing or redistributing the Software and Derivative Works and assume all
+risks associated with Your exercise of the License.
+
+11. **INDEMNIFICATION.** If You distribute or redistribute the Software or
+Derivative Works, You agree to defend on request, and indemnify, Deephaven and
+its affiliates, officers, directors, employees and agents from and against any
+and all losses, damages, liabilities, claims, costs and expenses (including
+reasonable attorney’s fees and expenses) incurred or arising from the
+exploitation of the Software or Derivative Works.
+
+12. **LIMITATION OF LIABILITY.** THE LICENSE IS GRANTED FOR NO FEE. IN NO EVENT
+AND UNDER NO LEGAL THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), CONTRACT, OR
+OTHERWISE, SHALL DEEPHAVEN BE LIABLE FOR ANY DAMAGES ARISING OUT OF OR AS A
+RESULT OF THIS AGREEMENT, INCLUDING ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL,
+OR CONSEQUENTIAL DAMAGES (INCLUDING BUT NOT LIMITED TO DAMAGES FOR LOSS OF
+GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR LOSS OR CORRUPTION
+OF DATA), EVEN IF DEEPHAVEN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+13. **TERMINATION.** The License will automatically terminate if You violate the
+use rights or prohibitions in this Agreement.
+
+14. **GOVERNING LAW.** This Agreement will be interpreted, construed and
+enforced in all respects in accordance with the laws of the State of Delaware,
+USA without reference to its choice of law rules to the contrary.
+
+
+# END OF AGREEMENT

package/dist/DraftQuery.d.ts

@@ -0,0 +1,137 @@
+import type { EditableQueryInfo, TypeSpecificFields } from '@deephaven-enterprise/jsapi-types';
+import QueryScheduler from './QueryScheduler';
+export type ScriptDraftQuery = IDraftQuery & {
+    scriptLanguage: string;
+};
+/**
+ * TypeScript `type` aliases have implicit index signatures, but `interface`
+ * types do not. It is important that all of the types composed into `IDraftQuery`
+ * are `type` aliases so that the index signature is implicitly included. Otherwise,
+ * it causes issues upstream where `Record<string, unknown>` generics are expected.
+ * e.g. `WorkspaceStorageItem<IDraftQuery>`
+ */
+export type IDraftQuery = EditableQueryInfo & {
+    isClientSide: boolean;
+    draftOwner: string;
+};
+export type DraftQueryConstructorObject = Partial<IDraftQuery> & Pick<IDraftQuery, 'name' | 'owner' | 'draftOwner' | 'dbServerName'>;
+/**
+ * A Draft Query is a client side object that contains mutable data for a Peristent Query along with some metadata.
+ */
+export declare class DraftQuery implements IDraftQuery {
+    static NO_SERIAL: null;
+    static INVALID_SCRIPT_PATH: string;
+    static RESTART_MODE: Readonly<{
+        ADMIN: 1;
+        ADMIN_AND_VIEWERS: 2;
+        ADMIN_AND_VIEWERS_WHEN_DOWN: 4;
+    }>;
+    static FIELDS: Readonly<{
+        readonly SERIAL: "serial";
+        readonly NAME: "name";
+        readonly OWNER: "owner";
+        readonly TYPE: "type";
+        readonly ENABLED: "enabled";
+        readonly ENABLED_GC_LOGS: "enableGcLogs";
+        readonly ENV_VARS: "envVars";
+        readonly HEAP_SIZE: "heapSize";
+        readonly ADDITIONAL_MEMORY: "additionalMemory";
+        readonly DATA_MEMORY_RATIO: "dataMemoryRatio";
+        readonly JVM_ARGS: "jvmArgs";
+        readonly EXTRA_CLASSPATHS: "extraClasspaths";
+        readonly JVM_PROFILE: "jvmProfile";
+        readonly DB_SERVER_NAME: "dbServerName";
+        readonly SCRIPT_CODE: "scriptCode";
+        readonly SCRIPT_LANGUAGE: "scriptLanguage";
+        readonly SCRIPT_PATH: "scriptPath";
+        readonly ADMIN_GROUPS: "adminGroups";
+        readonly VIEWER_GROUPS: "viewerGroups";
+        readonly RESTART_USERS: "restartUsers";
+        readonly SCHEDULER: "scheduler";
+        readonly TIMEOUT: "timeout";
+        readonly WORKER_KIND: "workerKind";
+        readonly KUBERNETES_CONTROL: "kubernetesControl";
+        readonly PYTHON_CONTROL: "pythonControl";
+        readonly GENERIC_WORKER_CONTROL: "genericWorkerControl";
+        readonly TYPE_SPECIFIC_FIELDS: "typeSpecificFields";
+        readonly REPLICA_COUNT: "replicaCount";
+        readonly SPARE_COUNT: "spareCount";
+        readonly ASSIGNMENT_POLICY: "assignmentPolicy";
+        readonly ASSIGNMENT_POLICY_PARAMS: "assignmentPolicyParams";
+    }>;
+    /**
+     * Checks if a serial id from the server is actually a draft id
+     *
+     * @param serial
+     */
+    static isDraftId(serial: string): boolean;
+    /**
+     * Removes the draft markings from a client side serial and returns the draft id.
+     *
+     * @param serial a serial that contains a draft id
+     */
+    static serialToDraftId(serial: string): string;
+    constructor({ isClientSide, draftOwner, serial, name, owner, type, enabled, enableGcLogs, envVars, heapSize, additionalMemory, dataMemoryRatio, jvmArgs, extraClasspaths, jvmProfile, dbServerName, scriptLanguage, scriptPath, scriptCode, scheduling, adminGroups, viewerGroups, restartUsers, timeout, workerKind, kubernetesControl, pythonControl, genericWorkerControl, typeSpecificFields, replicaCount, spareCount, assignmentPolicy, assignmentPolicyParams, }: DraftQueryConstructorObject);
+    id: string;
+    isModified: boolean;
+    isClientSide: boolean;
+    draftOwner: string;
+    serial: string | null;
+    name: string;
+    owner: string;
+    type: string;
+    enabled: boolean;
+    enableGcLogs: boolean;
+    envVars: string;
+    heapSize: number;
+    additionalMemory: number;
+    dataMemoryRatio: number;
+    jvmArgs: string;
+    extraClasspaths: string;
+    jvmProfile: string;
+    dbServerName: string;
+    scriptLanguage: string | null;
+    scriptPath: string | null;
+    scriptCode: string;
+    scheduling: readonly string[];
+    adminGroups: readonly string[];
+    viewerGroups: readonly string[];
+    restartUsers: number;
+    timeout: number;
+    scheduler: QueryScheduler;
+    kubernetesControl?: string | null;
+    pythonControl?: string | null;
+    genericWorkerControl?: string | null;
+    /**
+     * Should be the name (not title) of the workerKind
+     * The server gives null if it should be the default
+     * Not sure if the value will be set if the PQ is from pre-vermilion and the customer upgrades
+     * Treat both null and undefined as server default (not necessarily 1st option in the UI)
+     */
+    workerKind: string | null | undefined;
+    typeSpecificFields: TypeSpecificFields | null;
+    replicaCount: number;
+    spareCount: number;
+    assignmentPolicy: string | null;
+    assignmentPolicyParams: string | null;
+    updateSchedule(): void;
+    /**
+     * Creates a deep copy of this draft query.
+     *
+     * @param id the id for the copy
+     * @returns a copy of this draft query
+     */
+    deepCopy(id?: string | null): DraftQuery;
+    /**
+     * Saves a Draft Query into an Editable Query.
+     *
+     * @param editableQuery the Editable Query from the Server
+     */
+    saveDraftToQuery(editableQuery: Partial<EditableQueryInfo>): void;
+    toEditableQueryInfo(): {
+        serial: string | null;
+    };
+    toRowMap(queryTypes: Map<string, string>): Map<string, string>;
+    formatIdForSerialColumn(): string;
+}
+export default DraftQuery;

package/dist/DraftQuery.js

@@ -0,0 +1,208 @@
+/* eslint-disable no-param-reassign */
+import shortid from 'shortid';
+import QueryColumns from './QueryColumns';
+import QueryScheduler from './QueryScheduler';
+import { QueryType } from './QueryType';
+const DRAFT_SERIAL_PREFIX = 'Draft ID: ';
+/**
+ * A Draft Query is a client side object that contains mutable data for a Peristent Query along with some metadata.
+ */
+export class DraftQuery {
+    /**
+     * Checks if a serial id from the server is actually a draft id
+     *
+     * @param serial
+     */
+    static isDraftId(serial) {
+        return serial === null || serial === void 0 ? void 0 : serial.startsWith(DRAFT_SERIAL_PREFIX);
+    }
+    /**
+     * Removes the draft markings from a client side serial and returns the draft id.
+     *
+     * @param serial a serial that contains a draft id
+     */
+    static serialToDraftId(serial) {
+        // Remove the 'Draft ID: ' marking
+        return serial === null || serial === void 0 ? void 0 : serial.substring(DRAFT_SERIAL_PREFIX.length);
+    }
+    constructor({ isClientSide = false, draftOwner, serial = DraftQuery.NO_SERIAL, name, owner, type = QueryType.SCRIPT, enabled = true, enableGcLogs = true, envVars = '', heapSize = 4.0, additionalMemory = 0.0, dataMemoryRatio = 0.25, jvmArgs = '', extraClasspaths = '', jvmProfile = 'Default', dbServerName, scriptLanguage = 'Groovy', scriptPath = null, scriptCode = '', scheduling, adminGroups = [], viewerGroups = [], restartUsers = DraftQuery.RESTART_MODE.ADMIN, timeout = 0, workerKind, kubernetesControl, pythonControl, genericWorkerControl, typeSpecificFields = null, replicaCount = 1, spareCount = 0, assignmentPolicy = null, assignmentPolicyParams = null, }) {
+        this.scheduling = [];
+        // Meta Data
+        this.id = shortid.generate();
+        this.isModified = false;
+        this.isClientSide = isClientSide;
+        this.draftOwner = draftOwner;
+        // Query Data
+        this.serial = serial;
+        this.name = name;
+        this.owner = owner;
+        this.type = type;
+        this.enabled = enabled;
+        this.enableGcLogs = enableGcLogs;
+        this.envVars = envVars;
+        this.heapSize = heapSize;
+        this.replicaCount = replicaCount;
+        this.spareCount = spareCount;
+        this.additionalMemory = additionalMemory;
+        this.dataMemoryRatio = dataMemoryRatio;
+        this.jvmArgs = jvmArgs;
+        this.extraClasspaths = extraClasspaths;
+        this.jvmProfile = jvmProfile;
+        this.dbServerName = dbServerName;
+        this.scriptLanguage = scriptLanguage;
+        this.scriptPath = scriptPath;
+        this.scriptCode = scriptCode;
+        this.adminGroups = adminGroups;
+        this.viewerGroups = viewerGroups;
+        this.restartUsers = restartUsers;
+        this.timeout = timeout;
+        this.workerKind = workerKind;
+        this.kubernetesControl = kubernetesControl;
+        this.pythonControl = pythonControl;
+        this.genericWorkerControl = genericWorkerControl;
+        this.replicaCount = replicaCount;
+        this.spareCount = spareCount;
+        this.assignmentPolicy = assignmentPolicy;
+        this.assignmentPolicyParams = assignmentPolicyParams;
+        // The scheduling array is parsed into a scheduler object
+        this.scheduling = [];
+        this.scheduler = new QueryScheduler(scheduling);
+        this.typeSpecificFields = typeSpecificFields;
+    }
+    updateSchedule() {
+        if (this.scheduler != null) {
+            this.scheduling = this.scheduler.toStringArray();
+        }
+    }
+    /**
+     * Creates a deep copy of this draft query.
+     *
+     * @param id the id for the copy
+     * @returns a copy of this draft query
+     */
+    deepCopy(id) {
+        const copy = new DraftQuery(this);
+        // Use the given id if defined, otherwise keep the generated one from the constructor
+        if (id != null) {
+            copy.id = id;
+        }
+        copy.adminGroups = this.adminGroups.slice();
+        copy.viewerGroups = this.viewerGroups.slice();
+        copy.scheduler = this.scheduler.deepCopy();
+        return copy;
+    }
+    /**
+     * Saves a Draft Query into an Editable Query.
+     *
+     * @param editableQuery the Editable Query from the Server
+     */
+    saveDraftToQuery(editableQuery) {
+        var _a, _b;
+        editableQuery.name = this.name;
+        editableQuery.owner = this.owner;
+        editableQuery.type = this.type;
+        editableQuery.enabled = this.enabled;
+        editableQuery.enableGcLogs = this.enableGcLogs;
+        editableQuery.envVars = this.envVars;
+        editableQuery.heapSize = this.heapSize;
+        editableQuery.dataMemoryRatio = this.dataMemoryRatio;
+        editableQuery.additionalMemory = this.additionalMemory;
+        editableQuery.jvmArgs = this.jvmArgs;
+        editableQuery.extraClasspaths = this.extraClasspaths;
+        editableQuery.jvmProfile = this.jvmProfile;
+        editableQuery.dbServerName = this.dbServerName;
+        editableQuery.scriptLanguage = this.scriptLanguage;
+        editableQuery.scriptPath = (_a = this.scriptPath) !== null && _a !== void 0 ? _a : undefined;
+        editableQuery.scriptCode = this.scriptCode;
+        editableQuery.scheduling = this.scheduler.toStringArray();
+        editableQuery.adminGroups = this.adminGroups;
+        editableQuery.viewerGroups = this.viewerGroups;
+        editableQuery.restartUsers = this.restartUsers;
+        editableQuery.timeout = this.timeout;
+        editableQuery.workerKind = (_b = this.workerKind) !== null && _b !== void 0 ? _b : undefined;
+        editableQuery.kubernetesControl = this.kubernetesControl;
+        editableQuery.pythonControl = this.pythonControl;
+        editableQuery.genericWorkerControl = this.genericWorkerControl;
+        editableQuery.typeSpecificFields = this.typeSpecificFields;
+        editableQuery.replicaCount = this.replicaCount;
+        editableQuery.spareCount = this.spareCount;
+        editableQuery.assignmentPolicy = this.assignmentPolicy;
+        editableQuery.assignmentPolicyParams = this.assignmentPolicyParams;
+    }
+    toEditableQueryInfo() {
+        const editableQuery = { serial: this.serial };
+        this.saveDraftToQuery(editableQuery);
+        return editableQuery;
+    }
+    toRowMap(queryTypes) {
+        var _a, _b, _c, _d, _e, _f;
+        const row = new Map();
+        // Note there are holes in this map which will show up as blank cells in the table
+        // Also note that not every piece of data is displayed in the table
+        row.set(QueryColumns.NAME.name, `Draft, ${this.name}`);
+        row.set(QueryColumns.OWNER.name, this.owner);
+        row.set(QueryColumns.STATUS.name, 'Draft');
+        row.set(QueryColumns.QUERY_TYPE.name, queryTypes.get(this.type));
+        row.set(QueryColumns.ENABLED.name, this.enabled.toString());
+        row.set(QueryColumns.HEAP_SIZE.name, (_b = (_a = this.heapSize) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : '');
+        row.set(QueryColumns.ADDITIONAL_MEMORY.name, (_d = (_c = this.additionalMemory) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : '');
+        row.set(QueryColumns.DATA_RATIO.name, (_f = (_e = this.dataMemoryRatio) === null || _e === void 0 ? void 0 : _e.toString()) !== null && _f !== void 0 ? _f : '');
+        row.set(QueryColumns.LANGUAGE.name, this.scriptLanguage);
+        row.set(QueryColumns.JVM_PROFILE.name, this.jvmProfile);
+        row.set(QueryColumns.DB_SERVER_NAME.name, this.dbServerName);
+        const adminGroupsString = this.adminGroups.length > 0 ? `[${this.adminGroups.toString()}]` : '';
+        row.set(QueryColumns.ADMIN_GROUPS.name, adminGroupsString);
+        const viewerGroupsString = this.viewerGroups.length > 0 ? `[${this.viewerGroups.toString()}]` : '';
+        row.set(QueryColumns.VIEWER_GROUPS.name, viewerGroupsString);
+        // Draft queries have a null serial
+        // This puts the draft ID in the serial column so that keyed selection will work
+        row.set(QueryColumns.SERIAL.name, this.formatIdForSerialColumn());
+        row.set(QueryColumns.ID.name, this.id);
+        row.set(QueryColumns.PARENT_ID.name, null);
+        return row;
+    }
+    formatIdForSerialColumn() {
+        return `${DRAFT_SERIAL_PREFIX}${this.id}`;
+    }
+}
+DraftQuery.NO_SERIAL = null;
+DraftQuery.INVALID_SCRIPT_PATH = '';
+DraftQuery.RESTART_MODE = Object.freeze({
+    ADMIN: 1,
+    ADMIN_AND_VIEWERS: 2,
+    ADMIN_AND_VIEWERS_WHEN_DOWN: 4,
+});
+DraftQuery.FIELDS = Object.freeze({
+    SERIAL: 'serial',
+    NAME: 'name',
+    OWNER: 'owner',
+    TYPE: 'type',
+    ENABLED: 'enabled',
+    ENABLED_GC_LOGS: 'enableGcLogs',
+    ENV_VARS: 'envVars',
+    HEAP_SIZE: 'heapSize',
+    ADDITIONAL_MEMORY: 'additionalMemory',
+    DATA_MEMORY_RATIO: 'dataMemoryRatio',
+    JVM_ARGS: 'jvmArgs',
+    EXTRA_CLASSPATHS: 'extraClasspaths',
+    JVM_PROFILE: 'jvmProfile',
+    DB_SERVER_NAME: 'dbServerName',
+    SCRIPT_CODE: 'scriptCode',
+    SCRIPT_LANGUAGE: 'scriptLanguage',
+    SCRIPT_PATH: 'scriptPath',
+    ADMIN_GROUPS: 'adminGroups',
+    VIEWER_GROUPS: 'viewerGroups',
+    RESTART_USERS: 'restartUsers',
+    SCHEDULER: 'scheduler',
+    TIMEOUT: 'timeout',
+    WORKER_KIND: 'workerKind',
+    KUBERNETES_CONTROL: 'kubernetesControl',
+    PYTHON_CONTROL: 'pythonControl',
+    GENERIC_WORKER_CONTROL: 'genericWorkerControl',
+    TYPE_SPECIFIC_FIELDS: 'typeSpecificFields',
+    REPLICA_COUNT: 'replicaCount',
+    SPARE_COUNT: 'spareCount',
+    ASSIGNMENT_POLICY: `assignmentPolicy`,
+    ASSIGNMENT_POLICY_PARAMS: `assignmentPolicyParams`,
+});
+export default DraftQuery;