@fibery/query-utils 1.1.0 → 1.1.2

package/lib/src/query.d.ts

@@ -1,7 +1,6 @@
-import { Expression, OrderBy } from "@fibery/expression-utils/src/types";
+import { Expression, FieldExpression, FiberyObject, 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;
@@ -10,7 +9,7 @@ export declare function extractFieldObjectFromExpression({ expression, typeObjec
     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 getValueByFieldExpression: (object: $TSFixMe, path: FieldExpression) => any;
 export declare const parseMultiFieldValue: ({ multiFieldValue, multiFieldObject, }: {
     multiFieldValue?: Record<string, unknown> | null;
     multiFieldObject: FieldObject;
@@ -27,17 +26,17 @@ export declare const calculateOrderByForRequest: ({ orderByFromMeta, typeObject,
 }) => OrderBy | undefined;
 export declare const calculateOrderByRankOrName: ({ typeObject }: {
     typeObject: TypeObject;
-}) => OrderBy | (string | string[])[][] | undefined;
+}) => OrderBy | (string | "__NOTHING_INTERESTING__TitleField__"[])[][] | 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 extractSingleField: (expression: FieldExpression) => string;
 export declare const getQuerySelectForExpression: ({ typeObject, expression, selectsByTypeLookup, }: {
     typeObject: TypeObject;
-    expression: Expression;
+    expression: FieldExpression;
     selectsByTypeLookup?: Record<string, $TSFixMe>;
 }) => any;
 export declare const getOrderBySelect: (orderBy: OrderBy | undefined | null, typeObject: TypeObject) => any;

package/lib/src/query.js

@@ -8,7 +8,10 @@ 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 identity_1 = __importDefault(require("lodash/identity"));
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+const last_1 = __importDefault(require("lodash/last"));
+const sortBy_1 = __importDefault(require("lodash/sortBy"));
 const memoize_one_1 = __importDefault(require("memoize-one"));
 const errors_1 = require("./errors");
 const select_1 = require("./select");
@@ -67,7 +70,6 @@ const warnAboutNonProcessedKeys = (location, rest) => {
 };
 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;
@@ -113,7 +115,7 @@ const calculateOrderByForRequest = ({ orderByFromMeta, typeObject, }) => {
     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)) {
+        if (defaultOrderBy && !(0, isEqual_1.default)(orderByFromMeta, defaultOrderBy)) {
             return orderByFromMeta.concat(defaultOrderBy);
         }
         else {
@@ -135,14 +137,14 @@ const calculateOrderByRankOrName = ({ typeObject }) => {
 };
 exports.calculateOrderByRankOrName = calculateOrderByRankOrName;
 const makeSortByRankFn = (0, memoize_one_1.default)((rankField) => {
-    return (objects) => lodash_1.default.sortBy(objects, (object) => object[rankField]);
+    return (objects) => (0, sortBy_1.default)(objects, (object) => object[rankField]);
 });
 const calculateSortObjectsFn = ({ typeObject }) => {
-    return typeObject.rankFieldObject === null ? lodash_1.default.identity : makeSortByRankFn(typeObject.rankField);
+    return typeObject.rankFieldObject === null ? identity_1.default : makeSortByRankFn(typeObject.rankField);
 };
 exports.calculateSortObjectsFn = calculateSortObjectsFn;
 const extractSingleField = (expression) => {
-    (0, trace_1.assert)(lodash_1.default.last(expression) === "fibery/id", "not supported:", { expression });
+    (0, trace_1.assert)((0, last_1.default)(expression) === "fibery/id", "not supported:", { expression });
     return (0, array_1.single)(expression.slice(0, -1));
 };
 exports.extractSingleField = extractSingleField;
@@ -178,15 +180,15 @@ 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`);
+    (0, trace_1.assert)(orderBy.every(Array.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)
+            expression: ((0, utils_1.isDateRangeFunctionExpression)(orderingExpression)
                 ? orderingExpression[1]
-                : orderingExpression,
+                : orderingExpression),
         });
     })
         // always include rank, as it is used for card creation, see `calculateNewCardRank`.

package/lib/src/select.d.ts

@@ -1,107 +1,35 @@
-import { Expression } from "@fibery/expression-utils/src/types";
-import _ from "lodash";
+import { Expression, FiberyObject, Query, Select } from "@fibery/expression-utils/src/types";
 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 const normalizeSelect: (denormalizedSelect: Select) => Select;
 export declare function denormalizeSelectInPath(path: Expression, value: $TSFixMe): $TSFixMe;
 export declare const denormalizeSelect: (normalizedSelect: $TSFixMe) => any;
 export declare function mergeDenormalizedSelects(denormalizedSelects: $TSFixMe[]): any;
+export type PickedHole = {
+    path: Array<string | number>;
+    normalizedSelect: Select;
+};
+export type PickedFieldsResult = {
+    object: Record<string, unknown>;
+    holes: PickedHole[];
+};
 export declare const annotateNormalizedSelect: (normalizedSelect: Select) => ({
     lhs: {
         value: string;
         isDynamicSelect: boolean;
     };
     rhs: {
-        value: any;
+        value: Expression | Record<string, Expression>;
         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 const pickSelectedFields: (objects: FiberyObject[], normalizedSelect: Select) => PickedFieldsResult[];
+export declare function toSelectMapClause(simpleFields: string[]): Select;
 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

@@ -3,15 +3,26 @@ 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.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.toSelectMapClause = toSelectMapClause;
 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 flatMap_1 = __importDefault(require("lodash/flatMap"));
+const flatten_1 = __importDefault(require("lodash/flatten"));
+const identity_1 = __importDefault(require("lodash/identity"));
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+const isNumber_1 = __importDefault(require("lodash/isNumber"));
+const isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
+const isString_1 = __importDefault(require("lodash/isString"));
+const keyBy_1 = __importDefault(require("lodash/keyBy"));
+const last_1 = __importDefault(require("lodash/last"));
+const mapValues_1 = __importDefault(require("lodash/mapValues"));
+const omit_1 = __importDefault(require("lodash/omit"));
 const errors_1 = require("./errors");
 const implicitSubQueryFromTag = null;
 const isDynamicSelectLhs = (field) => field.startsWith("?");
@@ -23,12 +34,12 @@ exports.isDynamicSelectRhs = isDynamicSelectRhs;
 // 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)) {
+    if (!Array.isArray(path)) {
         throw new Error("path must be array");
     }
-    if (lodash_1.default.isPlainObject(value)) {
+    if ((0, isPlainObject_1.default)(value)) {
         if ((0, utils_1.isQueryExpression)(value)) {
-            if (lodash_1.default.isEqual(lodash_1.default.flatten(value["q/from"]), path)) {
+            if ((0, isEqual_1.default)((0, flatten_1.default)(value["q/from"]), path)) {
                 return {
                     ...value,
                     "q/select": (0, exports.normalizeSelect)(value["q/select"]),
@@ -43,13 +54,13 @@ function normalizeSelectInPath(path, value) {
             }
         }
         let hasMultiFieldAccess = false;
-        const normalized = lodash_1.default.mapValues(value, (value, key) => {
+        const normalized = (0, mapValues_1.default)(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));
+                return normalizeSelectInPath(path.concat([key]), (0, flatten_1.default)(value));
             }
             else {
                 return normalizeSelectInPath(path.concat([key]), value);
@@ -62,12 +73,12 @@ function normalizeSelectInPath(path, value) {
             return normalized;
         }
     }
-    if (lodash_1.default.isArray(value)) {
-        if (path.length > 0 && (0, exports.isDynamicSelectLhs)(lodash_1.default.last(path)) && (0, exports.isDynamicSelectRhs)(value)) {
+    if (Array.isArray(value)) {
+        if (path.length > 0 && (0, exports.isDynamicSelectLhs)((0, last_1.default)(path)) && (0, exports.isDynamicSelectRhs)(value)) {
             return value;
         }
-        if (lodash_1.default.isEqual(value, path)) {
-            return lodash_1.default.last(value);
+        if ((0, isEqual_1.default)(value, path)) {
+            return (0, last_1.default)(value);
         }
         else {
             throw new Error(`strict array select invariant: ${JSON.stringify({
@@ -76,23 +87,24 @@ function normalizeSelectInPath(path, value) {
             })}`);
         }
     }
-    if (lodash_1.default.isString(value)) {
+    if ((0, isString_1.default)(value)) {
         return value;
     }
     throw new Error(`denormalizedSelect invariant: ${JSON.stringify({ path, value })}`);
 }
+// TODO introduce normalizedSelect type (it's stricter)
 const normalizeSelect = (denormalizedSelect) => {
-    if (!lodash_1.default.isPlainObject(denormalizedSelect)) {
+    if (!(0, isPlainObject_1.default)(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)) {
+    if (!Array.isArray(path)) {
         throw new Error("path must be array");
     }
-    if (lodash_1.default.isPlainObject(value)) {
+    if ((0, isPlainObject_1.default)(value)) {
         if ((0, utils_1.isQueryExpression)(value)) {
             if (value["q/from"] === implicitSubQueryFromTag) {
                 return {
@@ -109,7 +121,7 @@ function denormalizeSelectInPath(path, value) {
                 throw new Error(`strict array select invariant: ${details}`);
             }
         }
-        const denormalized = lodash_1.default.mapValues(value, (val, key) => {
+        const denormalized = (0, mapValues_1.default)(value, (val, key) => {
             if (key === exports.isSelectForMultiFieldKey) {
                 return key;
             }
@@ -120,13 +132,13 @@ function denormalizeSelectInPath(path, value) {
                 return denormalizeSelectInPath(path.concat([key]), val);
             }
         });
-        return lodash_1.default.omit(denormalized, exports.isSelectForMultiFieldKey);
+        return (0, omit_1.default)(denormalized, exports.isSelectForMultiFieldKey);
     }
-    if (path.length > 0 && (0, exports.isDynamicSelectLhs)(lodash_1.default.last(path)) && (0, exports.isDynamicSelectRhs)(value)) {
+    if (path.length > 0 && (0, exports.isDynamicSelectLhs)((0, last_1.default)(path)) && (0, exports.isDynamicSelectRhs)(value)) {
         return value;
     }
-    if (lodash_1.default.isString(value)) {
-        if (lodash_1.default.last(path) === value) {
+    if ((0, isString_1.default)(value)) {
+        if ((0, last_1.default)(path) === value) {
             return path;
         }
         else {
@@ -142,16 +154,16 @@ function mergeNormalizedSelects(normalizedSelects) {
         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])) {
+                    if ((0, isPlainObject_1.default)(value) && (0, isPlainObject_1.default)(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])) {
+                    else if (key === "q/limit" && (0, isNumber_1.default)(value) && (0, isNumber_1.default)(result[key])) {
                         result[key] = value > result[key] ? value : result[key];
                     }
-                    else if (!lodash_1.default.isArray(value) || !lodash_1.default.isEqual(value, result[key])) {
+                    else if (!Array.isArray(value) || !(0, isEqual_1.default)(value, result[key])) {
                         throw new Error(`merge selects invariant. ${JSON.stringify(value)} ${JSON.stringify(result[key])}`);
                     }
                 }
@@ -169,17 +181,18 @@ function mergeDenormalizedSelects(denormalizedSelects) {
     return (0, exports.denormalizeSelect)(normalizedSelect);
 }
 const addHole = function (holesByPath, path, lhs, rhs) {
-    if (!holesByPath[path]) {
-        holesByPath[path] = { path, normalizedSelect: {} };
+    const key = path.join("/");
+    if (!holesByPath[key]) {
+        holesByPath[key] = { path, normalizedSelect: {} };
     }
-    holesByPath[path].normalizedSelect[lhs] = rhs;
+    holesByPath[key].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);
+    const rhsIsPlainObject = (0, isPlainObject_1.default)(rhs);
     return {
         lhs: {
             value: lhs,
@@ -248,11 +261,10 @@ const pickSelectedFields = (objects, normalizedSelect) => {
     });
 };
 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 toSelectMapClause(simpleFields) {
+    (0, trace_1.assert)(Array.isArray(simpleFields), "toSelectMapClause works with arrays");
+    return (0, keyBy_1.default)(simpleFields, identity_1.default);
+}
 function collectSelectTypes(typeObject, normalizedSelect, resultSet) {
     for (const [field, rhs] of Object.entries(normalizedSelect)) {
         if ((0, exports.isDynamicSelectLhs)(field) || field === exports.isSelectForMultiFieldKey) {
@@ -275,8 +287,8 @@ function collectSelectTypes(typeObject, normalizedSelect, 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"])) {
+                if ((0, isPlainObject_1.default)(rhs)) {
+                    if (Object.hasOwn(rhs, "q/from") && (0, isPlainObject_1.default)(rhs["q/select"])) {
                         collectSelectTypes(fieldTypeObject, rhs["q/select"], resultSet);
                     }
                     else {
@@ -296,5 +308,5 @@ function calculateSelectedTypes(schema, query) {
     return resultSet;
 }
 function calculateSelectedTypesFromQueries(schema, queries) {
-    return new Set(lodash_1.default.flatMap(queries, (query) => [...calculateSelectedTypes(schema, query)]));
+    return new Set((0, flatMap_1.default)(queries, (query) => [...calculateSelectedTypes(schema, query)]));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fibery/query-utils",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Construct, normalize and denormalize Fibery core queries",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -27,7 +27,7 @@
     "memoize-one": "6.0.0",
     "moment": "2.29.4",
     "uuid": "11.1.0",
-    "@fibery/expression-utils": "9.6.0",
+    "@fibery/expression-utils": "9.6.2",
     "@fibery/helpers": "1.4.0"
   },
   "devDependencies": {
@@ -38,11 +38,11 @@
     "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"
+    "@fibery/eslint-config": "9.0.0",
+    "@fibery/schema": "10.2.13"
   },
   "peerDependencies": {
-    "@fibery/schema": "10.2.12"
+    "@fibery/schema": "10.2.13"
   },
   "jest": {
     "testEnvironment": "node",

package/lib/src/types.d.ts

@@ -1,34 +0,0 @@
-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

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