@fibery/query-utils 1.1.0

package/LICENSE

@@ -0,0 +1,214 @@
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC
+LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM
+CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and
+documentation distributed under this Agreement, and
+
+b) in the case of each subsequent Contributor:
+
+i) changes to the Program, and
+
+ii) additions to the Program;
+
+where such changes and/or additions to the Program originate from and are
+distributed by that particular Contributor. A Contribution 'originates' from
+a Contributor if it was added to the Program by such Contributor itself or
+anyone acting on such Contributor's behalf. Contributions do not include
+additions to the Program which: (i) are separate modules of software
+distributed in conjunction with the Program under their own license
+agreement, and (ii) are not derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which are
+necessarily infringed by the use or sale of its Contribution alone or when
+combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this
+Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement,
+including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants
+Recipient a non-exclusive, worldwide, royalty-free copyright license to
+reproduce, prepare derivative works of, publicly display, publicly perform,
+distribute and sublicense the Contribution of such Contributor, if any, and
+such derivative works, in source code and object code form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby grants
+Recipient a non-exclusive, worldwide, royalty-free patent license under
+Licensed Patents to make, use, sell, offer to sell, import and otherwise
+transfer the Contribution of such Contributor, if any, in source code and
+object code form.  This patent license shall apply to the combination of the
+Contribution and the Program if, at the time the Contribution is added by the
+Contributor, such addition of the Contribution causes such combination to be
+covered by the Licensed Patents. The patent license shall not apply to any
+other combinations which include the Contribution. No hardware per se is
+licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the licenses
+to its Contributions set forth herein, no assurances are provided by any
+Contributor that the Program does not infringe the patent or other
+intellectual property rights of any other entity. Each Contributor disclaims
+any liability to Recipient for claims brought by any other entity based on
+infringement of intellectual property rights or otherwise. As a condition to
+exercising the rights and licenses granted hereunder, each Recipient hereby
+assumes sole responsibility to secure any other intellectual property rights
+needed, if any. For example, if a third party patent license is required to
+allow Recipient to distribute the Program, it is Recipient's responsibility
+to acquire that license before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has sufficient
+copyright rights in its Contribution, if any, to grant the copyright license
+set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under
+its own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+
+b) its license agreement:
+
+i) effectively disclaims on behalf of all Contributors all warranties and
+conditions, express and implied, including warranties or conditions of title
+and non-infringement, and implied warranties or conditions of merchantability
+and fitness for a particular purpose;
+
+ii) effectively excludes on behalf of all Contributors all liability for
+damages, including direct, indirect, special, incidental and consequential
+damages, such as lost profits;
+
+iii) states that any provisions which differ from this Agreement are offered
+by that Contributor alone and not by any other party; and
+
+iv) states that source code for the Program is available from such
+Contributor, and informs licensees how to obtain it in a reasonable manner on
+or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+
+b) a copy of this Agreement must be included with each copy of the Program.
+
+Contributors may not remove or alter any copyright notices contained within
+the Program.
+
+Each Contributor must identify itself as the originator of its Contribution,
+if any, in a manner that reasonably allows subsequent Recipients to identify
+the originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with
+respect to end users, business partners and the like. While this license is
+intended to facilitate the commercial use of the Program, the Contributor who
+includes the Program in a commercial product offering should do so in a
+manner which does not create potential liability for other Contributors.
+Therefore, if a Contributor includes the Program in a commercial product
+offering, such Contributor ("Commercial Contributor") hereby agrees to defend
+and indemnify every other Contributor ("Indemnified Contributor") against any
+losses, damages and costs (collectively "Losses") arising from claims,
+lawsuits and other legal actions brought by a third party against the
+Indemnified Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program in
+a commercial product offering.  The obligations in this section do not apply
+to any claims or Losses relating to any actual or alleged intellectual
+property infringement. In order to qualify, an Indemnified Contributor must:
+a) promptly notify the Commercial Contributor in writing of such claim, and
+b) allow the Commercial Contributor to control, and cooperate with the
+Commercial Contributor in, the defense and any related settlement
+negotiations. The Indemnified Contributor may participate in any such claim
+at its own expense.
+
+For example, a Contributor might include the Program in a commercial product
+offering, Product X. That Contributor is then a Commercial Contributor. If
+that Commercial Contributor then makes performance claims, or offers
+warranties related to Product X, those performance claims and warranties are
+such Commercial Contributor's responsibility alone. Under this section, the
+Commercial Contributor would have to defend claims against the other
+Contributors related to those performance claims and warranties, and if a
+court requires any other Contributor to pay any damages as a result, the
+Commercial Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON
+AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER
+EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR
+CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A
+PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the
+appropriateness of using and distributing the Program and assumes all risks
+associated with its exercise of rights under this Agreement , including but
+not limited to the risks and costs of program errors, compliance with
+applicable laws, damage to or loss of data, programs or equipment, and
+unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
+CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION
+LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
+EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY
+OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of the
+remainder of the terms of this Agreement, and without further action by the
+parties hereto, such provision shall be reformed to the minimum extent
+necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+(excluding combinations of the Program with other software or hardware)
+infringes such Recipient's patent(s), then such Recipient's rights granted
+under Section 2(b) shall terminate as of the date such litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to
+comply with any of the material terms or conditions of this Agreement and
+does not cure such failure in a reasonable period of time after becoming
+aware of such noncompliance. If all Recipient's rights under this Agreement
+terminate, Recipient agrees to cease use and distribution of the Program as
+soon as reasonably practicable. However, Recipient's obligations under this
+Agreement and any licenses granted by Recipient relating to the Program shall
+continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in
+order to avoid inconsistency the Agreement is copyrighted and may only be
+modified in the following manner. The Agreement Steward reserves the right to
+publish new versions (including revisions) of this Agreement from time to
+time. No one other than the Agreement Steward has the right to modify this
+Agreement. The Eclipse Foundation is the initial Agreement Steward. The
+Eclipse Foundation may assign the responsibility to serve as the Agreement
+Steward to a suitable separate entity. Each new version of the Agreement will
+be given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program
+(including its Contributions) under the new version. Except as expressly
+stated in Sections 2(a) and 2(b) above, Recipient receives no rights or
+licenses to the intellectual property of any Contributor under this
+Agreement, whether expressly, by implication, estoppel or otherwise. All
+rights in the Program not expressly granted under this Agreement are
+reserved.
+
+This Agreement is governed by the laws of the State of New York and the
+intellectual property laws of the United States of America. No party to this
+Agreement will bring a legal action under this Agreement more than one year
+after the cause of action arose. Each party waives its rights to a jury trial
+in any resulting litigation.

package/lib/index.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/errors.d.ts

@@ -0,0 +1,4 @@
+import { $TSFixMe } from "./tsfixme";
+export declare class NotImplementedError extends Error {
+    constructor(value: $TSFixMe, itemType?: string);
+}

package/lib/src/errors.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotImplementedError = void 0;
+const stringify = (x) => {
+    if (x === undefined) {
+        return "undefined";
+    }
+    return JSON.stringify(x);
+};
+class NotImplementedError extends Error {
+    constructor(value, itemType) {
+        super([`"${stringify(value)}"`, itemType, "is not implemented"].filter((x) => x !== undefined).join(" "));
+    }
+}
+exports.NotImplementedError = NotImplementedError;

package/lib/src/query.d.ts

@@ -0,0 +1,43 @@
+import { Expression, OrderBy } from "@fibery/expression-utils/src/types";
+import { FieldObject, TypeObject } from "@fibery/schema";
+import { $TSFixMe } from "./tsfixme";
+import { FiberyObject } from "./types";
+export declare const extractReferenceField: (expression: Expression) => string;
+export declare const getRangeValue: (object: FiberyObject, expression: Expression) => any;
+export declare const extractSingleFieldFromExpression: (expression: Expression) => string;
+export declare function extractFieldObjectFromExpression({ expression, typeObject, }: {
+    expression: Expression | null | undefined;
+    typeObject: TypeObject;
+}): FieldObject | null;
+export declare const warnAboutNonProcessedKeys: (location: string, rest: Record<string, unknown>) => void;
+export declare const getValueByFieldExpression: (object: $TSFixMe, path: Expression) => any;
+export declare const parseMultiFieldValue: ({ multiFieldValue, multiFieldObject, }: {
+    multiFieldValue?: Record<string, unknown> | null;
+    multiFieldObject: FieldObject;
+}) => {
+    value: any;
+    typeObject: TypeObject;
+} | null;
+export declare const calculateDefaultOrderBy: ({ typeObject }: {
+    typeObject: TypeObject;
+}) => OrderBy | undefined;
+export declare const calculateOrderByForRequest: ({ orderByFromMeta, typeObject, }: {
+    orderByFromMeta?: OrderBy;
+    typeObject: TypeObject;
+}) => OrderBy | undefined;
+export declare const calculateOrderByRankOrName: ({ typeObject }: {
+    typeObject: TypeObject;
+}) => OrderBy | (string | string[])[][] | undefined;
+export declare const calculateSortObjectsFn: ({ typeObject }: {
+    typeObject: TypeObject;
+}) => {
+    <T>(value: T): T;
+    (): undefined;
+} | ((objects: $TSFixMe) => any[]);
+export declare const extractSingleField: (expression: Expression) => string;
+export declare const getQuerySelectForExpression: ({ typeObject, expression, selectsByTypeLookup, }: {
+    typeObject: TypeObject;
+    expression: Expression;
+    selectsByTypeLookup?: Record<string, $TSFixMe>;
+}) => any;
+export declare const getOrderBySelect: (orderBy: OrderBy | undefined | null, typeObject: TypeObject) => any;

package/lib/src/query.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrderBySelect = exports.getQuerySelectForExpression = exports.extractSingleField = exports.calculateSortObjectsFn = exports.calculateOrderByRankOrName = exports.calculateOrderByForRequest = exports.calculateDefaultOrderBy = exports.parseMultiFieldValue = exports.getValueByFieldExpression = exports.warnAboutNonProcessedKeys = exports.extractSingleFieldFromExpression = exports.getRangeValue = exports.extractReferenceField = void 0;
+exports.extractFieldObjectFromExpression = extractFieldObjectFromExpression;
+const utils_1 = require("@fibery/expression-utils/src/utils");
+const trace_1 = require("@fibery/helpers/utils/trace");
+const array_1 = require("@fibery/helpers/utils/array");
+const lodash_1 = __importDefault(require("lodash"));
+const memoize_one_1 = __importDefault(require("memoize-one"));
+const errors_1 = require("./errors");
+const select_1 = require("./select");
+const extractReferenceField = (expression) => {
+    (0, trace_1.assert)((0, utils_1.isFieldExpression)(expression));
+    return (0, array_1.single)(expression);
+};
+exports.extractReferenceField = extractReferenceField;
+const getRangeValue = (object, expression) => {
+    (0, trace_1.assert)((0, utils_1.isFunctionCallExpression)(expression));
+    const [op, path] = expression;
+    const range = (0, exports.getValueByFieldExpression)(object, path);
+    if (!range) {
+        return range;
+    }
+    switch (op) {
+        case "q/start":
+            return range.start;
+        case "q/end":
+            return range.end;
+        default:
+            throw new Error(`Invalid operation ${op} in expression ${expression}`);
+    }
+};
+exports.getRangeValue = getRangeValue;
+const extractSingleFieldFromExpression = (expression) => {
+    (0, utils_1.assertIsValidExpression)(expression);
+    if ((0, utils_1.isFunctionCallExpression)(expression) && (0, utils_1.isDateRangeFunctionExpression)(expression)) {
+        const [, plainPathExpression] = expression;
+        (0, trace_1.assert)((0, utils_1.isFieldExpression)(plainPathExpression));
+        return (0, array_1.single)(plainPathExpression);
+    }
+    else {
+        (0, trace_1.assert)((0, utils_1.isFieldExpression)(expression));
+        return (0, array_1.single)(expression);
+    }
+};
+exports.extractSingleFieldFromExpression = extractSingleFieldFromExpression;
+function extractFieldObjectFromExpression({ expression, typeObject, }) {
+    if (!expression) {
+        return null;
+    }
+    const field = (0, exports.extractSingleFieldFromExpression)(expression);
+    return typeObject.fieldObjectsByName[field];
+}
+const warnAboutNonProcessedKeys = (location, rest) => {
+    const nonProcessedKeys = Object.keys(rest);
+    if (nonProcessedKeys.length > 0) {
+        // temporary ignore filter key
+        if (nonProcessedKeys[0] === "filter") {
+            return;
+        }
+        // eslint-disable-next-line no-console
+        console.warn(`${location} contains non-processed params: ${nonProcessedKeys}`);
+    }
+};
+exports.warnAboutNonProcessedKeys = warnAboutNonProcessedKeys;
+const getValueByFieldExpression = (object, path) => {
+    // TODO: review types. According to Expression it might be nested array but looks like we ignore it everywhere
+    return path.reduce((memo, key) => {
+        if (memo === undefined) {
+            return undefined;
+        }
+        if (memo === null) {
+            return null;
+        }
+        return memo[key];
+    }, object);
+};
+exports.getValueByFieldExpression = getValueByFieldExpression;
+const parseMultiFieldValueInner = (multiFieldValue) => {
+    if (!multiFieldValue) {
+        return multiFieldValue;
+    }
+    const firstNotNullValue = Object.entries(multiFieldValue).find(([key]) => multiFieldValue[key] !== null);
+    if (!firstNotNullValue) {
+        return null;
+    }
+    return { type: firstNotNullValue[0], value: firstNotNullValue[1] };
+};
+const parseMultiFieldValue = ({ multiFieldValue, multiFieldObject, }) => {
+    const parsed = parseMultiFieldValueInner(multiFieldValue);
+    if (!parsed) {
+        return null;
+    }
+    const multiRelatedFieldObject = multiFieldObject.multiRelatedFieldObjects.find((f) => f.holderType === parsed.type);
+    if (!multiRelatedFieldObject) {
+        return null;
+    }
+    return { value: parsed.value, typeObject: multiRelatedFieldObject.holderTypeObject };
+};
+exports.parseMultiFieldValue = parseMultiFieldValue;
+const calculateDefaultOrderBy = ({ typeObject }) => {
+    return typeObject.rankFieldObject === null ? undefined : [[[typeObject.rankField], "q/asc"]];
+};
+exports.calculateDefaultOrderBy = calculateDefaultOrderBy;
+const calculateOrderByForRequest = ({ orderByFromMeta, typeObject, }) => {
+    const defaultOrderBy = (0, exports.calculateDefaultOrderBy)({ typeObject });
+    if (!orderByFromMeta) {
+        return defaultOrderBy;
+    }
+    else {
+        // When installing an app, we create a view with meta with explicit sorting by rank.
+        // Let's not add defaultOrderBy in this case, it will be just a duplicate.
+        if (defaultOrderBy && !lodash_1.default.isEqual(orderByFromMeta, defaultOrderBy)) {
+            return orderByFromMeta.concat(defaultOrderBy);
+        }
+        else {
+            return orderByFromMeta;
+        }
+    }
+};
+exports.calculateOrderByForRequest = calculateOrderByForRequest;
+const calculateOrderByRankOrName = ({ typeObject }) => {
+    if (typeObject.isEnum) {
+        return (0, exports.calculateDefaultOrderBy)({ typeObject });
+    }
+    else if (typeObject.titleField) {
+        return [[[typeObject.titleField], "q/asc"]];
+    }
+    else {
+        return undefined;
+    }
+};
+exports.calculateOrderByRankOrName = calculateOrderByRankOrName;
+const makeSortByRankFn = (0, memoize_one_1.default)((rankField) => {
+    return (objects) => lodash_1.default.sortBy(objects, (object) => object[rankField]);
+});
+const calculateSortObjectsFn = ({ typeObject }) => {
+    return typeObject.rankFieldObject === null ? lodash_1.default.identity : makeSortByRankFn(typeObject.rankField);
+};
+exports.calculateSortObjectsFn = calculateSortObjectsFn;
+const extractSingleField = (expression) => {
+    (0, trace_1.assert)(lodash_1.default.last(expression) === "fibery/id", "not supported:", { expression });
+    return (0, array_1.single)(expression.slice(0, -1));
+};
+exports.extractSingleField = extractSingleField;
+const getQuerySelectForExpression = ({ typeObject, expression, selectsByTypeLookup = {}, }) => {
+    const root = {};
+    const acc = { currentNode: root, currentTypeObject: typeObject };
+    expression.reduce((acc, field) => {
+        if (!acc) {
+            return null;
+        }
+        const { currentNode, currentTypeObject } = acc;
+        const fieldObject = currentTypeObject.fieldObjectsByName[field];
+        if (fieldObject.kind === ":field/reference") {
+            currentNode[field] =
+                selectsByTypeLookup[fieldObject.type] || (0, select_1.toSelectMapClause)([fieldObject.typeObject.idField]);
+            return {
+                currentNode: currentNode[field],
+                currentTypeObject: fieldObject.typeObject,
+            };
+        }
+        else if (fieldObject.kind === ":field/basic") {
+            currentNode[field] = fieldObject.name;
+            return null;
+        }
+        else {
+            throw new errors_1.NotImplementedError(fieldObject.kind);
+        }
+    }, acc);
+    return (0, select_1.denormalizeSelect)(root);
+};
+exports.getQuerySelectForExpression = getQuerySelectForExpression;
+const getOrderBySelect = (orderBy, typeObject) => {
+    if (!orderBy) {
+        return {};
+    }
+    (0, trace_1.assert)(orderBy.every(lodash_1.default.isArray), `Order By should be an array of ordering expressions`);
+    const selects = orderBy
+        .map((ordering) => {
+        const orderingExpression = ordering[0];
+        return (0, exports.getQuerySelectForExpression)({
+            typeObject,
+            expression: (0, utils_1.isDateRangeFunctionExpression)(orderingExpression)
+                ? orderingExpression[1]
+                : orderingExpression,
+        });
+    })
+        // always include rank, as it is used for card creation, see `calculateNewCardRank`.
+        .concat(typeObject.rankFieldObject ? [{ [typeObject.rankFieldObject.name]: [typeObject.rankFieldObject.name] }] : []);
+    return (0, select_1.mergeDenormalizedSelects)(selects);
+};
+exports.getOrderBySelect = getOrderBySelect;

package/lib/src/select.d.ts

@@ -0,0 +1,107 @@
+import { Expression } from "@fibery/expression-utils/src/types";
+import _ from "lodash";
+import { Schema } from "@fibery/schema";
+import { FiberyObject, Query, Select } from "./types";
+import { $TSFixMe } from "./tsfixme";
+export declare const isDynamicSelectLhs: (field: string) => boolean;
+export declare const isDynamicSelectRhs: (rhs: Expression) => boolean;
+export declare const isSelectForMultiFieldKey = "_isSelectForMultiField_";
+export declare function normalizeSelectInPath(path: Expression, value: $TSFixMe): $TSFixMe;
+export declare const normalizeSelect: (denormalizedSelect: $TSFixMe) => any;
+export declare function denormalizeSelectInPath(path: Expression, value: $TSFixMe): $TSFixMe;
+export declare const denormalizeSelect: (normalizedSelect: $TSFixMe) => any;
+export declare function mergeDenormalizedSelects(denormalizedSelects: $TSFixMe[]): any;
+export declare const annotateNormalizedSelect: (normalizedSelect: Select) => ({
+    lhs: {
+        value: string;
+        isDynamicSelect: boolean;
+    };
+    rhs: {
+        value: any;
+        isDynamicSelect: boolean;
+        isQueryExpression: boolean;
+        isPlainObject: boolean;
+    };
+} | null)[];
+export declare const pickSelectedFields: (objects: FiberyObject[], normalizedSelect: Select) => {
+    object: any;
+    holes: unknown[];
+}[];
+export declare const toSelectMapClause: (simpleFields: string[]) => _.Dictionary<string | number | ((separator?: string) => string) | (() => ArrayIterator<string>) | {
+    [x: number]: boolean | undefined;
+    length?: boolean | undefined;
+    toString?: boolean | undefined;
+    toLocaleString?: boolean | undefined;
+    pop?: boolean | undefined;
+    push?: boolean | undefined;
+    concat?: boolean | undefined;
+    join?: boolean | undefined;
+    reverse?: boolean | undefined;
+    shift?: boolean | undefined;
+    slice?: boolean | undefined;
+    sort?: boolean | undefined;
+    splice?: boolean | undefined;
+    unshift?: boolean | undefined;
+    indexOf?: boolean | undefined;
+    lastIndexOf?: boolean | undefined;
+    every?: boolean | undefined;
+    some?: boolean | undefined;
+    forEach?: boolean | undefined;
+    map?: boolean | undefined;
+    filter?: boolean | undefined;
+    reduce?: boolean | undefined;
+    reduceRight?: boolean | undefined;
+    find?: boolean | undefined;
+    findIndex?: boolean | undefined;
+    fill?: boolean | undefined;
+    copyWithin?: boolean | undefined;
+    entries?: boolean | undefined;
+    keys?: boolean | undefined;
+    values?: boolean | undefined;
+    includes?: boolean | undefined;
+    flatMap?: boolean | undefined;
+    flat?: boolean | undefined;
+    at?: boolean | undefined;
+    findLast?: boolean | undefined;
+    findLastIndex?: boolean | undefined;
+    toReversed?: boolean | undefined;
+    toSorted?: boolean | undefined;
+    toSpliced?: boolean | undefined;
+    with?: boolean | undefined;
+    [Symbol.iterator]?: boolean | undefined;
+    readonly [Symbol.unscopables]?: boolean | undefined;
+} | (() => string) | {
+    (): string;
+    (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
+} | (() => string | undefined) | ((...items: string[]) => number) | {
+    (...items: ConcatArray<string>[]): string[];
+    (...items: (string | ConcatArray<string>)[]): string[];
+} | (() => string[]) | (() => string | undefined) | ((start?: number, end?: number) => string[]) | ((compareFn?: ((a: string, b: string) => number) | undefined) => string[]) | {
+    (start: number, deleteCount?: number): string[];
+    (start: number, deleteCount: number, ...items: string[]): string[];
+} | ((...items: string[]) => number) | ((searchElement: string, fromIndex?: number) => number) | ((searchElement: string, fromIndex?: number) => number) | {
+    <S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): this is S[];
+    (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): boolean;
+} | ((predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any) => boolean) | ((callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void) | (<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any) => U[]) | {
+    <S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[];
+    (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string[];
+} | {
+    (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
+    (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
+    <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U;
+} | {
+    (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
+    (callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
+    <U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U;
+} | {
+    <S extends string>(predicate: (value: string, index: number, obj: string[]) => value is S, thisArg?: any): S | undefined;
+    (predicate: (value: string, index: number, obj: string[]) => unknown, thisArg?: any): string | undefined;
+} | ((predicate: (value: string, index: number, obj: string[]) => unknown, thisArg?: any) => number) | ((value: string, start?: number, end?: number) => string[]) | ((target: number, start: number, end?: number) => string[]) | (() => ArrayIterator<[number, string]>) | (() => ArrayIterator<number>) | (() => ArrayIterator<string>) | ((searchElement: string, fromIndex?: number) => boolean) | (<U, This = undefined>(callback: (this: This, value: string, index: number, array: string[]) => U | readonly U[], thisArg?: This | undefined) => U[]) | (<A, D extends number = 1>(this: A, depth?: D | undefined) => FlatArray<A, D>[]) | ((index: number) => string | undefined) | {
+    <S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S | undefined;
+    (predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string | undefined;
+} | ((predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any) => number) | (() => string[]) | ((compareFn?: ((a: string, b: string) => number) | undefined) => string[]) | {
+    (start: number, deleteCount: number, ...items: string[]): string[];
+    (start: number, deleteCount?: number): string[];
+} | ((index: number, value: string) => string[])>;
+export declare function calculateSelectedTypes(schema: Schema, query: Query): Set<string>;
+export declare function calculateSelectedTypesFromQueries(schema: Schema, queries: Query[]): Set<string>;

package/lib/src/select.js

@@ -0,0 +1,300 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSelectMapClause = exports.pickSelectedFields = exports.annotateNormalizedSelect = exports.denormalizeSelect = exports.normalizeSelect = exports.isSelectForMultiFieldKey = exports.isDynamicSelectRhs = exports.isDynamicSelectLhs = void 0;
+exports.normalizeSelectInPath = normalizeSelectInPath;
+exports.denormalizeSelectInPath = denormalizeSelectInPath;
+exports.mergeDenormalizedSelects = mergeDenormalizedSelects;
+exports.calculateSelectedTypes = calculateSelectedTypes;
+exports.calculateSelectedTypesFromQueries = calculateSelectedTypesFromQueries;
+const utils_1 = require("@fibery/expression-utils/src/utils");
+const trace_1 = require("@fibery/helpers/utils/trace");
+const lodash_1 = __importDefault(require("lodash"));
+const errors_1 = require("./errors");
+const implicitSubQueryFromTag = null;
+const isDynamicSelectLhs = (field) => field.startsWith("?");
+exports.isDynamicSelectLhs = isDynamicSelectLhs;
+const isDynamicSelectRhs = (rhs) => (0, utils_1.isVariableExpression)(rhs) || (0, utils_1.isBinaryExpression)(rhs) || (0, utils_1.isNaryExpression)(rhs) || (0, utils_1.isFunctionCallExpression)(rhs);
+exports.isDynamicSelectRhs = isDynamicSelectRhs;
+// During select normalization, we remove path. We usually rely on select structure and don't have schema on our hands.
+// So it's impossible to understand if this is multi-field or usual field. That's why we add this meta-info to normalized select.
+// It is removed during de-normalization and should be ignored in various utils methods.
+exports.isSelectForMultiFieldKey = "_isSelectForMultiField_";
+function normalizeSelectInPath(path, value) {
+    if (!lodash_1.default.isArray(path)) {
+        throw new Error("path must be array");
+    }
+    if (lodash_1.default.isPlainObject(value)) {
+        if ((0, utils_1.isQueryExpression)(value)) {
+            if (lodash_1.default.isEqual(lodash_1.default.flatten(value["q/from"]), path)) {
+                return {
+                    ...value,
+                    "q/select": (0, exports.normalizeSelect)(value["q/select"]),
+                    "q/from": implicitSubQueryFromTag,
+                };
+            }
+            else {
+                throw new Error(`strict array select invariant: ${JSON.stringify({
+                    actual: value["q/from"],
+                    expected: path,
+                })}`);
+            }
+        }
+        let hasMultiFieldAccess = false;
+        const normalized = lodash_1.default.mapValues(value, (value, key) => {
+            if (key === exports.isSelectForMultiFieldKey) {
+                return value;
+            }
+            if ((0, utils_1.isMultiFieldExpression)(value)) {
+                hasMultiFieldAccess = true;
+                return normalizeSelectInPath(path.concat([key]), lodash_1.default.flatten(value));
+            }
+            else {
+                return normalizeSelectInPath(path.concat([key]), value);
+            }
+        });
+        if (hasMultiFieldAccess) {
+            return { ...normalized, [exports.isSelectForMultiFieldKey]: true };
+        }
+        else {
+            return normalized;
+        }
+    }
+    if (lodash_1.default.isArray(value)) {
+        if (path.length > 0 && (0, exports.isDynamicSelectLhs)(lodash_1.default.last(path)) && (0, exports.isDynamicSelectRhs)(value)) {
+            return value;
+        }
+        if (lodash_1.default.isEqual(value, path)) {
+            return lodash_1.default.last(value);
+        }
+        else {
+            throw new Error(`strict array select invariant: ${JSON.stringify({
+                actual: value,
+                expected: path,
+            })}`);
+        }
+    }
+    if (lodash_1.default.isString(value)) {
+        return value;
+    }
+    throw new Error(`denormalizedSelect invariant: ${JSON.stringify({ path, value })}`);
+}
+const normalizeSelect = (denormalizedSelect) => {
+    if (!lodash_1.default.isPlainObject(denormalizedSelect)) {
+        throw new Error("denormalizedSelect must be an object");
+    }
+    return normalizeSelectInPath([], denormalizedSelect);
+};
+exports.normalizeSelect = normalizeSelect;
+function denormalizeSelectInPath(path, value) {
+    if (!lodash_1.default.isArray(path)) {
+        throw new Error("path must be array");
+    }
+    if (lodash_1.default.isPlainObject(value)) {
+        if ((0, utils_1.isQueryExpression)(value)) {
+            if (value["q/from"] === implicitSubQueryFromTag) {
+                return {
+                    ...value,
+                    "q/select": (0, exports.denormalizeSelect)(value["q/select"]),
+                    "q/from": path,
+                };
+            }
+            else {
+                const details = JSON.stringify({
+                    actual: value["q/from"],
+                    expected: implicitSubQueryFromTag,
+                });
+                throw new Error(`strict array select invariant: ${details}`);
+            }
+        }
+        const denormalized = lodash_1.default.mapValues(value, (val, key) => {
+            if (key === exports.isSelectForMultiFieldKey) {
+                return key;
+            }
+            else if (value[exports.isSelectForMultiFieldKey]) {
+                return denormalizeSelectInPath([path, key], val);
+            }
+            else {
+                return denormalizeSelectInPath(path.concat([key]), val);
+            }
+        });
+        return lodash_1.default.omit(denormalized, exports.isSelectForMultiFieldKey);
+    }
+    if (path.length > 0 && (0, exports.isDynamicSelectLhs)(lodash_1.default.last(path)) && (0, exports.isDynamicSelectRhs)(value)) {
+        return value;
+    }
+    if (lodash_1.default.isString(value)) {
+        if (lodash_1.default.last(path) === value) {
+            return path;
+        }
+        else {
+            throw new Error(`strict select invariant: ${path[0]} !== ${value}`);
+        }
+    }
+    throw new Error("normalizedSelect invariant");
+}
+const denormalizeSelect = (normalizedSelect) => denormalizeSelectInPath([], normalizedSelect);
+exports.denormalizeSelect = denormalizeSelect;
+function mergeNormalizedSelects(normalizedSelects) {
+    return normalizedSelects.reduce((result, normalizedSelect) => {
+        Object.entries(normalizedSelect).forEach(([key, value]) => {
+            if (key in result) {
+                if (value !== result[key]) {
+                    if (lodash_1.default.isPlainObject(value) && lodash_1.default.isPlainObject(result[key])) {
+                        result[key] = mergeNormalizedSelects([value, result[key]]);
+                    }
+                    else if (key === "q/limit" && (value === "q/no-limit" || result[key] === "q/no-limit")) {
+                        result[key] = "q/no-limit";
+                    }
+                    else if (key === "q/limit" && lodash_1.default.isNumber(value) && lodash_1.default.isNumber(result[key])) {
+                        result[key] = value > result[key] ? value : result[key];
+                    }
+                    else if (!lodash_1.default.isArray(value) || !lodash_1.default.isEqual(value, result[key])) {
+                        throw new Error(`merge selects invariant. ${JSON.stringify(value)} ${JSON.stringify(result[key])}`);
+                    }
+                }
+            }
+            else {
+                result[key] = value;
+            }
+        });
+        return result;
+    }, {});
+}
+function mergeDenormalizedSelects(denormalizedSelects) {
+    const normalizedSelects = denormalizedSelects.map((denormalizedSelect) => (0, exports.normalizeSelect)(denormalizedSelect));
+    const normalizedSelect = mergeNormalizedSelects(normalizedSelects);
+    return (0, exports.denormalizeSelect)(normalizedSelect);
+}
+const addHole = function (holesByPath, path, lhs, rhs) {
+    if (!holesByPath[path]) {
+        holesByPath[path] = { path, normalizedSelect: {} };
+    }
+    holesByPath[path].normalizedSelect[lhs] = rhs;
+};
+const annotateNormalizedSelect = (normalizedSelect) => Object.entries(normalizedSelect)
+    .map(([lhs, rhs]) => {
+    if (lhs === exports.isSelectForMultiFieldKey) {
+        return null;
+    }
+    const rhsIsPlainObject = lodash_1.default.isPlainObject(rhs);
+    return {
+        lhs: {
+            value: lhs,
+            isDynamicSelect: (0, exports.isDynamicSelectLhs)(lhs),
+        },
+        rhs: {
+            value: rhs,
+            isDynamicSelect: (0, exports.isDynamicSelectRhs)(rhs),
+            isQueryExpression: (0, utils_1.isQueryExpression)(rhs),
+            isPlainObject: rhsIsPlainObject,
+        },
+    };
+})
+    .filter(Boolean);
+exports.annotateNormalizedSelect = annotateNormalizedSelect;
+const pickAndTrack = function (input, annotatedNormalizedSelect, path, holesByPath) {
+    const output = {};
+    for (const annotatedItem of annotatedNormalizedSelect) {
+        const lhs = annotatedItem.lhs.value;
+        const rhs = annotatedItem.rhs.value;
+        const value = input[lhs];
+        if (value === undefined && !rhs[exports.isSelectForMultiFieldKey]) {
+            addHole(holesByPath, path, lhs, rhs);
+        }
+        else if (value === null) {
+            output[lhs] = value;
+        }
+        else {
+            if (lhs === rhs) {
+                output[lhs] = value;
+            }
+            else if (annotatedItem.rhs.isPlainObject) {
+                if (annotatedItem.rhs.isQueryExpression) {
+                    (0, trace_1.assert)(Array.isArray(value));
+                    // In case when normalizr schema does not contain a collection field, nothing will happen with normalized ids.
+                    // See "denormalizeAndPickFields for unknown collection items" test.
+                    // So we will get "Tasks": ["id1", "id2"], instead of denormalized objects.
+                    // In this case we do not want to make holes and even include something in denormalized object.
+                    // As schema was changed, data in component should be re-queried with new schema.
+                    if (value.length === 0 || !value.every((x) => typeof x === "string")) {
+                        output[lhs] = value.map((item, index) => pickAndTrack(item, (0, exports.annotateNormalizedSelect)(rhs["q/select"]), path.concat([lhs, index]), holesByPath));
+                    }
+                }
+                else if (value instanceof Object && value.constructor === Object) {
+                    output[lhs] = pickAndTrack(value, (0, exports.annotateNormalizedSelect)(rhs), path.concat(lhs), holesByPath);
+                }
+            }
+            else if (annotatedItem.lhs.isDynamicSelect && annotatedItem.rhs.isDynamicSelect) {
+                output[lhs] = value;
+            }
+            else {
+                throw new errors_1.NotImplementedError({ lhs, rhs }, "select");
+            }
+        }
+    }
+    return output;
+};
+const pickSelectedFields = (objects, normalizedSelect) => {
+    const annotatedNormalizedSelect = (0, exports.annotateNormalizedSelect)(normalizedSelect);
+    return objects.map((object) => {
+        const holesByPath = {};
+        return {
+            object: pickAndTrack(object, annotatedNormalizedSelect, [], holesByPath),
+            holes: Object.values(holesByPath),
+        };
+    });
+};
+exports.pickSelectedFields = pickSelectedFields;
+const toSelectMapClause = (simpleFields) => {
+    (0, trace_1.assert)(lodash_1.default.isArray(simpleFields), "toSelectMapClause works with arrays");
+    return lodash_1.default.keyBy(simpleFields, lodash_1.default.identity);
+};
+exports.toSelectMapClause = toSelectMapClause;
+function collectSelectTypes(typeObject, normalizedSelect, resultSet) {
+    for (const [field, rhs] of Object.entries(normalizedSelect)) {
+        if ((0, exports.isDynamicSelectLhs)(field) || field === exports.isSelectForMultiFieldKey) {
+            continue;
+        }
+        const fieldObject = typeObject.fieldObjectsByName[field];
+        if (!fieldObject) {
+            continue;
+        }
+        const fieldTypeObject = fieldObject.typeObject;
+        if (!fieldTypeObject.isPrimitive) {
+            if (fieldObject.isMultiField) {
+                for (const [typeForMulti, rhsForMulti] of Object.entries(rhs)) {
+                    const fieldObjectForMulti = fieldObject.multiRelatedFieldObjects.find((f) => f.holderTypeObject.name === typeForMulti);
+                    if (fieldObjectForMulti) {
+                        resultSet.add(fieldObjectForMulti.holderTypeObject.name);
+                        collectSelectTypes(fieldObjectForMulti.holderTypeObject, rhsForMulti, resultSet);
+                    }
+                }
+            }
+            else {
+                resultSet.add(fieldTypeObject.name);
+                if (lodash_1.default.isPlainObject(rhs)) {
+                    if (Object.hasOwn(rhs, "q/from") && lodash_1.default.isPlainObject(rhs["q/select"])) {
+                        collectSelectTypes(fieldTypeObject, rhs["q/select"], resultSet);
+                    }
+                    else {
+                        collectSelectTypes(fieldTypeObject, rhs, resultSet);
+                    }
+                }
+            }
+        }
+    }
+}
+function calculateSelectedTypes(schema, query) {
+    const { "q/from": type, "q/select": select } = query;
+    const normalizedSelect = (0, exports.normalizeSelect)(select);
+    const typeObject = schema.typeObjectsByName[type];
+    const resultSet = new Set([type]);
+    collectSelectTypes(typeObject, normalizedSelect, resultSet);
+    return resultSet;
+}
+function calculateSelectedTypesFromQueries(schema, queries) {
+    return new Set(lodash_1.default.flatMap(queries, (query) => [...calculateSelectedTypes(schema, query)]));
+}

package/lib/src/tsfixme.d.ts

@@ -0,0 +1 @@
+export type $TSFixMe = any;

package/lib/src/tsfixme.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/types.d.ts

@@ -0,0 +1,34 @@
+import { $TSFixMe } from "./tsfixme";
+export type Ref = {
+    "fibery/id": string;
+};
+type NestedArray<T> = Array<T | NestedArray<T>>;
+export type Expression = NestedArray<string>;
+type SelectPart = Record<string, Expression>;
+export type Select = SelectPart | Record<string, SelectPart>;
+export type OrderBy = Array<[Expression, string]>;
+export type Query = {
+    "q/from": string;
+    "q/select"?: Select;
+    "q/offset"?: number;
+    "q/order-by"?: OrderBy;
+    "q/limit"?: number | "q/no-limit";
+    "q/where"?: NestedArray<unknown>;
+};
+export type QueryLimit = number | "q/no-limit";
+export type SubQuery = {
+    "q/from": Expression;
+    "q/select"?: Select;
+    "q/offset"?: number;
+    "q/order-by"?: OrderBy;
+    "q/limit"?: QueryLimit;
+    "q/where"?: NestedArray<unknown>;
+};
+export type Params = Record<string, Expression | null>;
+export interface Request {
+    query: Query;
+    params: Params;
+}
+export type Response = Record<string, $TSFixMe>[];
+export type FiberyObject = Record<string, unknown>;
+export {};

package/lib/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@fibery/query-utils",
+  "version": "1.1.0",
+  "description": "Construct, normalize and denormalize Fibery core queries",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "files": [
+    "./lib"
+  ],
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./src/*": {
+      "types": "./lib/src/*.d.ts",
+      "default": "./lib/src/*.js"
+    }
+  },
+  "fiberyDevExports": {
+    ".": "./index.ts",
+    "./src/*": "./src/*"
+  },
+  "private": false,
+  "dependencies": {
+    "lodash": "4.17.21",
+    "memoize-one": "6.0.0",
+    "moment": "2.29.4",
+    "uuid": "11.1.0",
+    "@fibery/expression-utils": "9.6.0",
+    "@fibery/helpers": "1.4.0"
+  },
+  "devDependencies": {
+    "@babel/core": "7.28.5",
+    "@swc/jest": "0.2.39",
+    "@types/lodash": "4.14.172",
+    "jest": "30.2.0",
+    "jest-junit": "16.0.0",
+    "typescript": "5.9.3",
+    "@fibery/babel-preset": "7.4.1",
+    "@fibery/eslint-config": "8.6.2",
+    "@fibery/schema": "10.2.12"
+  },
+  "peerDependencies": {
+    "@fibery/schema": "10.2.12"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "collectCoverageFrom": [
+      "src/**/*.{js,jsx,ts,tsx}",
+      "!src/**/*.d.ts"
+    ],
+    "coverageReporters": [
+      "text",
+      "cobertura"
+    ],
+    "testPathIgnorePatterns": [
+      "<rootDir>[/\\\\](build|docs|node_modules|scripts)[/\\\\]"
+    ],
+    "transform": {
+      "^.+\\.(js|jsx|ts|tsx)$": [
+        "@swc/jest",
+        {
+          "jsc": {
+            "parser": {
+              "syntax": "typescript",
+              "tsx": true,
+              "decorators": true,
+              "dynamicImport": true
+            },
+            "transform": {
+              "react": {
+                "runtime": "automatic"
+              }
+            }
+          }
+        }
+      ]
+    },
+    "testEnvironmentOptions": {
+      "url": "http://localhost"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf lib && pnpm exec tsc --project tsconfig.build.json",
+    "test": "jest",
+    "test:ci": "jest --reporters=default --reporters=jest-junit",
+    "test:coverage": "jest --coverage --coverageDirectory=${JEST_COVERAGE_RESULT_DIR:-$(pwd)}/coverage/formulas --reporters=default --reporters=jest-junit",
+    "lint": "eslint ."
+  }
+}