@_linked/core 1.3.0 → 2.0.0-next.20260310085832

package/lib/cjs/queries/SelectQuery.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LinkedWhereQuery = exports.SetSize = exports.SelectQueryFactory = exports.onQueriesReady = exports.QueryPrimitiveSet = exports.QueryBoolean = exports.QueryNumber = exports.QueryDate = exports.QueryString = exports.QueryPrimitive = exports.Evaluation = exports.QueryShape = exports.QueryShapeSet = exports.BoundComponent = exports.QueryBuilderObject = exports.isWhereEvaluationPath = exports.WhereMethods = void 0;
+exports.SetSize = exports.QueryPrimitiveSet = exports.QueryPrimitive = exports.Evaluation = exports.QueryShape = exports.QueryShapeSet = exports.evaluateSortCallback = exports.processWhereClause = exports.BoundComponent = exports.QueryBuilderObject = exports.isWhereEvaluationPath = exports.WhereMethods = void 0;
 const Shape_js_1 = require("../shapes/Shape.js");
 const ShapeSet_js_1 = require("../collections/ShapeSet.js");
 const shacl_js_1 = require("../ontologies/shacl.js");
 const CoreSet_js_1 = require("../collections/CoreSet.js");
 const ShapeClass_js_1 = require("../utils/ShapeClass.js");
-const QueryFactory_js_1 = require("./QueryFactory.js");
 const xsd_js_1 = require("../ontologies/xsd.js");
-const IRPipeline_js_1 = require("./IRPipeline.js");
-const queryDispatch_js_1 = require("./queryDispatch.js");
+const ProxiedPathBuilder_js_1 = require("./ProxiedPathBuilder.js");
+const FieldSet_js_1 = require("./FieldSet.js");
+const PropertyPath_js_1 = require("./PropertyPath.js");
 const isSameRef = (a, b) => !!a && !!b && a.id === b.id;
 var WhereMethods;
 (function (WhereMethods) {
@@ -47,16 +47,16 @@ class QueryBuilderObject {
             return QueryShapeSet.create(originalValue, property, subject);
         }
         else if (typeof originalValue === 'string') {
-            return new QueryString(originalValue, property, subject);
+            return new QueryPrimitive(originalValue, property, subject);
         }
         else if (typeof originalValue === 'number') {
-            return new QueryNumber(originalValue, property, subject);
+            return new QueryPrimitive(originalValue, property, subject);
         }
         else if (typeof originalValue === 'boolean') {
-            return new QueryBoolean(originalValue, property, subject);
+            return new QueryPrimitive(originalValue, property, subject);
         }
         else if (originalValue instanceof Date) {
-            return new QueryDate(originalValue, property, subject);
+            return new QueryPrimitive(originalValue, property, subject);
         }
         else if (Array.isArray(originalValue)) {
             return new QueryPrimitiveSet(originalValue, property, subject);
@@ -95,23 +95,23 @@ class QueryBuilderObject {
         if (datatype) {
             if (singleValue) {
                 if (isSameRef(datatype, xsd_js_1.xsd.integer)) {
-                    return new QueryNumber(0, property, subject);
+                    return new QueryPrimitive(0, property, subject);
                 }
                 else if (isSameRef(datatype, xsd_js_1.xsd.boolean)) {
-                    return new QueryBoolean(false, property, subject);
+                    return new QueryPrimitive(false, property, subject);
                 }
                 else if (isSameRef(datatype, xsd_js_1.xsd.dateTime) ||
                     isSameRef(datatype, xsd_js_1.xsd.date)) {
-                    return new QueryDate(new Date(), property, subject);
+                    return new QueryPrimitive(new Date(), property, subject);
                 }
                 else if (isSameRef(datatype, xsd_js_1.xsd.string)) {
-                    return new QueryString('', property, subject);
+                    return new QueryPrimitive('', property, subject);
                 }
             }
             else {
                 //TODO review this, do we need property & subject in both of these? currently yes, but why
                 return new QueryPrimitiveSet([''], property, subject, [
-                    new QueryString('', property, subject),
+                    new QueryPrimitive('', property, subject),
                 ]);
             }
         }
@@ -138,30 +138,17 @@ class QueryBuilderObject {
             isSameRef(property.nodeKind, shacl_js_1.shacl.BlankNodeOrLiteral)) {
             if (singleValue) {
                 //default to string if no datatype is set
-                return new QueryString('', property, subject);
+                return new QueryPrimitive('', property, subject);
             }
             else {
                 //TODO review this, do we need property & subject in both of these? currently yes, but why
                 return new QueryPrimitiveSet([''], property, subject, [
-                    new QueryString('', property, subject),
+                    new QueryPrimitive('', property, subject),
                 ]);
             }
         }
         //if an object is expected and no value shape is set, then warn
         throw Error(`No shape set for objectProperty ${property.parentNodeShape.label}.${property.label}`);
-        // //and use a generic shape
-        // const shapeValue = new (Shape as any)(new TestNode(path));
-        // if (singleValue) {
-        //   return QueryShape.create(shapeValue, property, subject);
-        // } else {
-        //   //check if shapeValue is iterable
-        //   if (!(Symbol.iterator in Object(shapeValue))) {
-        //     throw new Error(
-        //       `Property ${property.parentNodeShape.label}.${property.label} is not marked as single value (maxCount:1), but the value is not iterable`,
-        //     );
-        //   }
-        //   return QueryShapeSet.create(new ShapeSet(shapeValue), property, subject);
-        // }
     }
     static getOriginalSource(endValue) {
         if (typeof endValue === 'undefined')
@@ -169,7 +156,7 @@ class QueryBuilderObject {
         if (endValue instanceof QueryPrimitiveSet) {
             return new ShapeSet_js_1.ShapeSet(endValue.contents.map((endValue) => this.getOriginalSource(endValue)));
         }
-        if (endValue instanceof QueryString) {
+        if (endValue instanceof QueryPrimitive) {
             return endValue.subject
                 ? this.getOriginalSource(endValue.subject)
                 : endValue.originalValue;
@@ -203,7 +190,6 @@ class QueryBuilderObject {
         return new BoundComponent(component, this);
     }
     limit(lim) {
-        console.log(lim);
     }
     /**
      * Returns the path of properties that were requested to reach this value
@@ -232,45 +218,6 @@ class BoundComponent extends QueryBuilderObject {
         this.originalValue = originalValue;
         this.source = source;
     }
-    getParentQueryFactory() {
-        let parentQuery = this.originalValue.query;
-        if (parentQuery instanceof SelectQueryFactory) {
-            return parentQuery;
-        }
-        if (typeof parentQuery === 'object') {
-            if (Object.keys(parentQuery).length > 1) {
-                throw new Error('Only one key is allowed to map a query to a property for linkedSetComponents');
-            }
-            for (let key in parentQuery) {
-                if (parentQuery[key] instanceof SelectQueryFactory) {
-                    return parentQuery[key];
-                }
-                throw new Error('Unknown value type for query object. Keep to this format: {propName: Shape.query(s => ...)}');
-            }
-        }
-        throw new Error('Unknown data query type. Expected a SelectQueryFactory (from Shape.query()) or an object with 1 key whose value is a SelectQueryFactory');
-    }
-    getPropertyPath() {
-        let sourcePath = this.source.getPropertyPath();
-        let requestQuery = this.getParentQueryFactory();
-        let compSelectQuery = requestQuery.getQueryPaths();
-        if (Array.isArray(sourcePath)) {
-            if (Array.isArray(compSelectQuery)) {
-                // QueryPath[] — unwrap single-element arrays for compact representation
-                const unwrapped = compSelectQuery.length === 1
-                    ? Array.isArray(compSelectQuery[0]) && compSelectQuery[0].length === 1
-                        ? compSelectQuery[0][0]
-                        : compSelectQuery[0]
-                    : compSelectQuery;
-                sourcePath.push(unwrapped);
-            }
-            else {
-                // CustomQueryObject
-                sourcePath.push(compSelectQuery);
-            }
-        }
-        return sourcePath;
-    }
 }
 exports.BoundComponent = BoundComponent;
 /**
@@ -289,12 +236,37 @@ const processWhereClause = (validation, shape) => {
         if (!shape) {
             throw new Error('Cannot process where clause without shape');
         }
-        return new LinkedWhereQuery(shape, validation).getWherePath();
+        const proxy = (0, ProxiedPathBuilder_js_1.createProxiedPathBuilder)(shape);
+        const evaluation = validation(proxy);
+        return evaluation.getWherePath();
     }
     else {
         return validation.getWherePath();
     }
 };
+exports.processWhereClause = processWhereClause;
+/**
+ * Evaluate a sort callback through the proxy and extract a SortByPath.
+ * This is a standalone helper that replaces the need for the former SelectQueryFactory.sortBy().
+ */
+const evaluateSortCallback = (shape, sortFn, direction = 'ASC') => {
+    const proxy = (0, ProxiedPathBuilder_js_1.createProxiedPathBuilder)(shape);
+    const response = sortFn(proxy);
+    const nodeShape = shape.shape;
+    const paths = [];
+    if (response instanceof QueryBuilderObject || response instanceof QueryPrimitiveSet) {
+        paths.push(new PropertyPath_js_1.PropertyPath(nodeShape, FieldSet_js_1.FieldSet.collectPropertySegments(response)));
+    }
+    else if (Array.isArray(response)) {
+        for (const item of response) {
+            if (item instanceof QueryBuilderObject) {
+                paths.push(new PropertyPath_js_1.PropertyPath(nodeShape, FieldSet_js_1.FieldSet.collectPropertySegments(item)));
+            }
+        }
+    }
+    return { paths, direction };
+};
+exports.evaluateSortCallback = evaluateSortCallback;
 class QueryShapeSet extends QueryBuilderObject {
     constructor(_originalValue, property, subject) {
         super(property, subject);
@@ -350,8 +322,6 @@ class QueryShapeSet extends QueryBuilderObject {
                         return originalShapeSet[key].bind(originalShapeSet);
                     }
                     else if (key !== 'then' && key !== '$$typeof') {
-                        //TODO: there is a strange bug with "then" being called, only for queries that access ShapeSets (multi value props), but I'm not sure where it comes from
-                        //hiding the warning for now in that case as it doesn't seem to affect the results
                         console.warn('Could not find property shape for key ' +
                             key +
                             ' on shape ' +
@@ -452,16 +422,16 @@ class QueryShapeSet extends QueryBuilderObject {
             throw new Error('You cannot call where() from within a where() clause. Consider using some() or every() instead');
         }
         let leastSpecificShape = this.getOriginalValue().getLeastSpecificShape();
-        this.wherePath = processWhereClause(validation, leastSpecificShape);
+        this.wherePath = (0, exports.processWhereClause)(validation, leastSpecificShape);
         //return this.proxy because after Shape.friends.where() we can call other methods of Shape.friends
         //and for that we need the proxy
         return this.proxy;
     }
     select(subQueryFn) {
-        let leastSpecificShape = this.getOriginalValue().getLeastSpecificShape();
-        let subQuery = new SelectQueryFactory(leastSpecificShape, subQueryFn);
-        subQuery.parentQueryPath = this.getPropertyPath();
-        return subQuery;
+        const leastSpecificShape = this.getOriginalValue().getLeastSpecificShape();
+        const parentSegments = FieldSet_js_1.FieldSet.collectPropertySegments(this);
+        const fs = FieldSet_js_1.FieldSet.forSubSelect(leastSpecificShape, subQueryFn, parentSegments);
+        return fs;
     }
     selectAll() {
         let leastSpecificShape = this.getOriginalValue().getLeastSpecificShape();
@@ -480,7 +450,7 @@ class QueryShapeSet extends QueryBuilderObject {
         let leastSpecificShape = this.getOriginalValue().getLeastSpecificShape();
         //do we need to store this here? or are we accessing the evaluation and then going backwards?
         //in that case just pass it to the evaluation and don't use this.wherePath
-        let wherePath = processWhereClause(validation, leastSpecificShape);
+        let wherePath = (0, exports.processWhereClause)(validation, leastSpecificShape);
         return new SetEvaluation(this, method, [wherePath]);
     }
 }
@@ -494,12 +464,6 @@ class QueryShape extends QueryBuilderObject {
         return (this.originalValue.__queryContextId ||
             this.originalValue['id']);
     }
-    // where(validation: WhereClause<S>): this {
-    //   let nodeShape = this.originalValue.nodeShape;
-    //   this.wherePath = processWhereClause(validation, nodeShape);
-    //   //return this because after Shape.friends.where() we can call other methods of Shape.friends
-    //   return this.proxy;
-    // }
     static create(original, property, subject) {
         let instance = new QueryShape(original, property, subject);
         let proxy = this.proxifyQueryShape(instance);
@@ -524,27 +488,9 @@ class QueryShape extends QueryBuilderObject {
                     //if not, then a method/accessor of the original shape was called
                     //then check if we have indexed any property shapes with that name for this shapes NodeShape
                     //NOTE: this will only work with a @linkedProperty decorator
-                    // let propertyShape = originalShape.nodeShape
-                    //   .getPropertyShapes()
-                    //   .find((propertyShape) => propertyShape.label === key);
                     let propertyShape = (0, ShapeClass_js_1.getPropertyShapeByLabel)(originalShape.constructor, key);
                     if (propertyShape) {
-                        //generate the query shape based on the property shape
-                        // let nodeValue;
-                        // if(propertyShape.maxCount <= 1) {
-                        //   nodeValue = new TestNode(propertyShape.path);
-                        // } else {
-                        //   nodeValue = new NodeSet(new TestNode(propertyShape.path));
-                        // }
                         return QueryBuilderObject.generatePathValue(propertyShape, target);
-                        //get the value of the property from the original shape
-                        // let value = originalShape[key];
-                        // //convert the value into a query value
-                        // return QueryBuilderObject.convertOriginal(
-                        //   value,
-                        //   propertyShape,
-                        //   queryShape,
-                        // );
                     }
                 }
                 if (key !== 'then' && key !== '$$typeof') {
@@ -554,8 +500,6 @@ class QueryShape extends QueryBuilderObject {
                     //https://stackoverflow.com/a/49725198/977206
                     const stackLines = stack.split('\n').slice(1); //remove the "Error" line
                     console.warn(`${originalShape.constructor.name}.${key.toString()} is accessed in a query, but it does not have a @linkedProperty decorator. Queries can only access decorated get/set methods. ${stackLines.join('\n')}`);
-                    // } else {
-                    //   console.error('Proxy is accessed like a promise');
                 }
                 return originalShape[key];
             },
@@ -571,18 +515,16 @@ class QueryShape extends QueryBuilderObject {
             }
             return QueryShape.create(newOriginal, this.property, this.subject);
         }
-        // else return this
         return this;
-        // return this.proxy;
     }
     equals(otherValue) {
         return new Evaluation(this, WhereMethods.EQUALS, [otherValue]);
     }
     select(subQueryFn) {
-        let leastSpecificShape = (0, ShapeClass_js_1.getShapeClass)(this.getOriginalValue().nodeShape.id);
-        let subQuery = new SelectQueryFactory(leastSpecificShape, subQueryFn);
-        subQuery.parentQueryPath = this.getPropertyPath();
-        return subQuery;
+        const leastSpecificShape = (0, ShapeClass_js_1.getShapeClass)(this.getOriginalValue().nodeShape.id);
+        const parentSegments = FieldSet_js_1.FieldSet.collectPropertySegments(this);
+        const fs = FieldSet_js_1.FieldSet.forSubSelect(leastSpecificShape, subQueryFn, parentSegments);
+        return fs;
     }
     selectAll() {
         let leastSpecificShape = (0, ShapeClass_js_1.getShapeClass)(this.getOriginalValue().nodeShape.id);
@@ -645,13 +587,13 @@ class Evaluation {
     }
     and(subQuery) {
         this._andOr.push({
-            and: processWhereClause(subQuery),
+            and: (0, exports.processWhereClause)(subQuery),
         });
         return this;
     }
     or(subQuery) {
         this._andOr.push({
-            or: processWhereClause(subQuery),
+            or: (0, exports.processWhereClause)(subQuery),
         });
         return this;
     }
@@ -660,8 +602,11 @@ exports.Evaluation = Evaluation;
 class SetEvaluation extends Evaluation {
 }
 /**
- * The class that is used for when JS primitives are converted to a QueryValue
- * This is extended by QueryString, QueryNumber, QueryBoolean, etc
+ * Concrete query wrapper for JS primitive values (string, number, boolean, Date).
+ *
+ * Replaces the former abstract class + subclasses (QueryString, QueryNumber,
+ * QueryBoolean, QueryDate) — the type parameter T carries the primitive type,
+ * so separate subclasses are unnecessary.
  */
 class QueryPrimitive extends QueryBuilderObject {
     constructor(originalValue, property, subject) {
@@ -676,26 +621,12 @@ class QueryPrimitive extends QueryBuilderObject {
     }
     where(validation) {
         // let nodeShape = this.subject.getOriginalValue().nodeShape;
-        this.wherePath = processWhereClause(validation, new QueryString(''));
+        this.wherePath = (0, exports.processWhereClause)(validation, new QueryPrimitive(''));
         //return this because after Shape.friends.where() we can call other methods of Shape.friends
         return this;
     }
 }
 exports.QueryPrimitive = QueryPrimitive;
-//@TODO: QueryString, QueryNumber, QueryBoolean, QueryDate can all be replaced with QueryPrimitive, and we can infer the original type, no need for these extra classes
-//UPDATE some of this has started. Query response to result conversion is using QueryPrimitive only
-class QueryString extends QueryPrimitive {
-}
-exports.QueryString = QueryString;
-class QueryDate extends QueryPrimitive {
-}
-exports.QueryDate = QueryDate;
-class QueryNumber extends QueryPrimitive {
-}
-exports.QueryNumber = QueryNumber;
-class QueryBoolean extends QueryPrimitive {
-}
-exports.QueryBoolean = QueryBoolean;
 class QueryPrimitiveSet extends QueryBuilderObject {
     constructor(originalValue, property, subject, items) {
         super(property, subject);
@@ -714,7 +645,7 @@ class QueryPrimitiveSet extends QueryBuilderObject {
     createNew(...args) {
         return new this.constructor(this.property, this.subject, ...args);
     }
-    //TODO: see if we can merge these methods of QueryString and QueryPrimitiveSet and soon other things like QueryNumber
+    //TODO: see if we can merge these methods of QueryPrimitive and QueryPrimitiveSet
     // so that they're only defined once
     equals(other) {
         return new Evaluation(this, WhereMethods.EQUALS, [other]);
@@ -750,360 +681,7 @@ class QueryPrimitiveSet extends QueryBuilderObject {
     }
 }
 exports.QueryPrimitiveSet = QueryPrimitiveSet;
-let documentLoaded = false;
-let callbackStack = [];
-const docReady = () => {
-    documentLoaded = true;
-    callbackStack.forEach((callback) => callback());
-    callbackStack = [];
-};
-if (typeof document === 'undefined' || document.readyState !== 'loading') {
-    docReady();
-}
-else {
-    documentLoaded = false;
-    document.addEventListener('DOMContentLoaded', () => () => {
-        docReady();
-    });
-    setTimeout(() => {
-        if (!documentLoaded) {
-            console.warn('⚠️ Forcing init after timeout');
-            docReady();
-        }
-    }, 3500);
-}
-//only continue to parse the query if the document is ready, and all shapes from initial bundles are loaded
-var onQueriesReady = (callback) => {
-    if (!documentLoaded) {
-        callbackStack.push(callback);
-    }
-    else {
-        callback();
-    }
-};
-exports.onQueriesReady = onQueriesReady;
-class SelectQueryFactory extends QueryFactory_js_1.QueryFactory {
-    constructor(shape, queryBuildFn, subject) {
-        super();
-        this.shape = shape;
-        this.queryBuildFn = queryBuildFn;
-        this.subject = subject;
-        let promise, resolve, reject;
-        promise = new Promise((res, rej) => {
-            resolve = res;
-            reject = rej;
-        });
-        this.initPromise = { promise, resolve, reject, complete: false };
-        //only continue to parse the query if the document is ready, and all shapes from initial bundles are loaded
-        if (typeof document === 'undefined' || document.readyState !== 'loading') {
-            this.init();
-        }
-        else {
-            document.addEventListener('DOMContentLoaded', () => this.init());
-            setTimeout(() => {
-                if (!this.initPromise.complete) {
-                    console.warn('⚠️ Forcing init after timeout');
-                    this.init();
-                }
-            }, 3500);
-        }
-    }
-    setLimit(limit) {
-        this.limit = limit;
-    }
-    getLimit() {
-        return this.limit;
-    }
-    setOffset(offset) {
-        this.offset = offset;
-    }
-    getOffset() {
-        return this.offset;
-    }
-    setSubject(subject) {
-        this.subject = subject;
-        return this;
-    }
-    where(validation) {
-        this.wherePath = processWhereClause(validation, this.shape);
-        return this;
-    }
-    exec() {
-        return (0, queryDispatch_js_1.getQueryDispatch)().selectQuery(this.build());
-    }
-    /**
-     * Returns the raw pipeline input for this query.
-     * Used internally by build() and by test helpers that need
-     * to feed factory state into individual pipeline stages.
-     */
-    toRawInput() {
-        const input = {
-            select: this.getQueryPaths(),
-            subject: this.getSubject(),
-            limit: this.limit,
-            offset: this.offset,
-            shape: this.shape,
-            sortBy: this.getSortByPath(),
-            singleResult: this.singleResult ||
-                !!(this.subject &&
-                    ('id' in this.subject || 'id' in this.subject)),
-        };
-        if (this.wherePath) {
-            input.where = this.wherePath;
-        }
-        return input;
-    }
-    build() {
-        return (0, IRPipeline_js_1.buildSelectQuery)(this.toRawInput());
-    }
-    getSubject() {
-        var _a, _b;
-        //if the subject is a QueryShape which comes from query context
-        //then it will carry a query context id and we convert it to a node reference
-        //NOTE: its important to access originalValue instead of .node directly because QueryShape.node may be undefined
-        if ((_b = (_a = this.subject) === null || _a === void 0 ? void 0 : _a.originalValue) === null || _b === void 0 ? void 0 : _b.__queryContextId) {
-            return convertQueryContext(this.subject);
-        }
-        // }
-        return this.subject;
-    }
-    /**
-     * Returns an array of query paths
-     * A single query can request multiple things in multiple "query paths" (For example this is using 2 paths: Shape.select(p => [p.name, p.friends.name]))
-     * Each query path is returned as array of the property paths requested, with potential where clauses (together called a QueryStep)
-     */
-    getQueryPaths(response = this.traceResponse) {
-        let queryPaths = [];
-        let queryObject;
-        //if the trace response is an array, then multiple paths were requested
-        if (response instanceof QueryBuilderObject ||
-            response instanceof QueryPrimitiveSet) {
-            //if it's a single value, then only one path was requested, and we can add it directly
-            queryPaths.push(response.getPropertyPath());
-        }
-        else if (Array.isArray(response) || response instanceof Set) {
-            response.forEach((endValue) => {
-                if (endValue instanceof QueryBuilderObject) {
-                    queryPaths.push(endValue.getPropertyPath());
-                }
-                else if (endValue instanceof SelectQueryFactory) {
-                    queryPaths.push(endValue.getQueryPaths());
-                }
-            });
-        }
-        else if (response instanceof Evaluation) {
-            queryPaths.push(response.getWherePath());
-        }
-        else if (response instanceof SelectQueryFactory) {
-            queryPaths.push(response.getQueryPaths());
-        }
-        else if (!response) {
-            //that's totally fine. For example Person.select().where(p => p.name.equals('John'))
-            //will return all persons with the name John, but no properties are selected for these persons
-        }
-        //if it's an object
-        else if (typeof response === 'object') {
-            queryObject = {};
-            //then loop over all the keys
-            Object.getOwnPropertyNames(response).forEach((key) => {
-                //and add the property paths for each key
-                const value = response[key];
-                //TODO: we could potentially make Evaluation extend QueryValue, and rename getPropertyPath to something more generic,
-                //that way we can simplify the code perhaps? Or would we loose type clarity? (QueryStep is the generic one for QueryValue, and Evaluation can just return WherePath right?)
-                if (value instanceof QueryBuilderObject ||
-                    value instanceof QueryPrimitiveSet) {
-                    queryObject[key] = value.getPropertyPath();
-                }
-                else if (value instanceof Evaluation) {
-                    queryObject[key] = value.getWherePath();
-                }
-                else {
-                    throw Error('Unknown trace response type for key ' + key);
-                }
-            });
-        }
-        else {
-            throw Error('Unknown trace response type');
-        }
-        if (this.parentQueryPath) {
-            queryPaths = this.parentQueryPath.concat([
-                queryObject || queryPaths,
-            ]);
-            //reset the variable so it doesn't get used again below
-            queryObject = null;
-        }
-        return queryObject || queryPaths;
-    }
-    isValidSetResult(qResults) {
-        return qResults.every((qResult) => {
-            return this.isValidResult(qResult);
-        });
-    }
-    isValidResult(qResult) {
-        let select = this.getQueryPaths();
-        if (Array.isArray(select)) {
-            return this.isValidQueryPathsResult(qResult, select);
-        }
-        else if (typeof select === 'object') {
-            return this.isValidCustomObjectResult(qResult, select);
-        }
-    }
-    clone() {
-        return new SelectQueryFactory(this.shape, this.queryBuildFn, this.subject);
-    }
-    /**
-     * Makes a clone of the query template, sets the subject and executes the query
-     * @param subject
-     */
-    execFor(subject) {
-        //TODO: Differentiate between the result of Shape.query and the internal query in Shape.select?
-        // so that Shape.query can never be executed. Its just a template
-        return this.clone().setSubject(subject).exec();
-    }
-    patchResultPromise(p) {
-        let pAdjusted = p;
-        p['where'] = (validation) => {
-            // preventExec();
-            this.where(validation);
-            return pAdjusted;
-        };
-        p['limit'] = (lim) => {
-            this.setLimit(lim);
-            return pAdjusted;
-        };
-        p['sortBy'] = (sortFn, direction = 'ASC') => {
-            this.sortBy(sortFn, direction);
-            return pAdjusted;
-        };
-        p['one'] = () => {
-            this.setLimit(1);
-            this.singleResult = true;
-            return pAdjusted;
-        };
-        return p;
-    }
-    sortBy(sortFn, direction) {
-        let queryShape = this.getQueryShape();
-        if (sortFn) {
-            this.sortResponse = sortFn(queryShape, this);
-            this.sortDirection = direction;
-        }
-        return this;
-    }
-    init() {
-        let queryShape = this.getQueryShape();
-        if (this.queryBuildFn) {
-            let queryResponse = this.queryBuildFn(queryShape, this);
-            this.traceResponse = queryResponse;
-        }
-        this.initPromise.resolve(this.traceResponse);
-        this.initPromise.complete = true;
-    }
-    initialized() {
-        return this.initPromise.promise;
-    }
-    /**
-     * Returns the dummy shape instance who's properties can be accessed freely inside a queryBuildFn
-     * It is used to trace the properties that are accessed in the queryBuildFn
-     * @private
-     */
-    getQueryShape() {
-        let queryShape;
-        //if the given class already extends QueryValue
-        if (this.shape instanceof QueryBuilderObject) {
-            //then we're likely dealing with QueryPrimitives (end values like strings)
-            //and we can use the given query value directly for the query evaluation
-            queryShape = this.shape;
-        }
-        else {
-            //else a shape class is given, and we need to create a dummy node to apply and trace the query
-            let dummyShape = new this.shape();
-            queryShape = QueryShape.create(dummyShape);
-        }
-        return queryShape;
-    }
-    getSortByPath() {
-        if (!this.sortResponse)
-            return null;
-        //TODO: we should put more restrictions on sortBy and getting query paths from the response
-        // currently it reuses much of the select logic, but for example using .where() should probably not be allowed in a sortBy function?
-        return {
-            paths: this.getQueryPaths(this.sortResponse),
-            direction: this.sortDirection,
-        };
-    }
-    isValidQueryPathsResult(qResult, select) {
-        return select.every((path) => {
-            return this.isValidQueryPathResult(qResult, path);
-        });
-    }
-    isValidQueryPathResult(qResult, path, nameOverwrite) {
-        if (Array.isArray(path)) {
-            return this.isValidQueryStepResult(qResult, path[0], path.splice(1), nameOverwrite);
-        }
-        else {
-            if (path.firstPath) {
-                return this.isValidQueryPathResult(qResult, path.firstPath);
-            }
-            else if (path.path) {
-                return this.isValidQueryPathResult(qResult, path.path);
-            }
-        }
-    }
-    isValidQueryStepResult(qResult, step, restPath = [], nameOverwrite) {
-        if (!qResult) {
-            return false;
-        }
-        if (step.property) {
-            //if a name overwrite is given we check if that key exists instead of the property label
-            //this happens with custom objects: for the first property step, the named key will be the accessKey used in the result instead of the first property label.
-            //e.g. {title:item.name} in a query will result in a "title" key in the result, not "name"
-            const accessKey = nameOverwrite || step.property.label;
-            //also check if this property needs to have a value (minCount > 0), if not it can be empty and undefined
-            // if (!qResult.hasOwnProperty(accessKey) && (step as PropertyQueryStep).property.minCount > 0) {
-            //the key must be in the object. If there is no value then it should be null (or undefined, but null works better with JSON.stringify, as it keeps the key. Whilst undefined keys get removed)
-            if (!qResult.hasOwnProperty(accessKey)) {
-                return false;
-            }
-            if (restPath.length > 0) {
-                return this.isValidQueryStepResult(qResult[accessKey], restPath[0], restPath.splice(1));
-            }
-            return true;
-        }
-        else if (step.count) {
-            return this.isValidQueryStepResult(qResult, step.count[0]);
-        }
-        else if (Array.isArray(step)) {
-            return step.every((subStep) => {
-                return this.isValidQueryPathResult(qResult, subStep);
-            });
-        }
-        else if (typeof step === 'object') {
-            if (Array.isArray(qResult)) {
-                return qResult.every((singleResult) => {
-                    return this.isValidQueryStepResult(singleResult, step);
-                });
-            }
-            return this.isValidCustomObjectResult(qResult, step);
-        }
-    }
-    isValidCustomObjectResult(qResult, step) {
-        //for custom objects, all keys need to be defined, even if the value is undefined
-        for (let key in step) {
-            if (!qResult.hasOwnProperty(key)) {
-                return false;
-            }
-            let path = step[key];
-            if (!this.isValidQueryPathResult(qResult, path, key)) {
-                return false;
-            }
-            // return this.isValidQueryPathResult(qResult[key], path);
-        }
-        return true;
-    }
-}
-exports.SelectQueryFactory = SelectQueryFactory;
-class SetSize extends QueryNumber {
+class SetSize extends QueryPrimitive {
     constructor(subject, countable, label) {
         super();
         this.subject = subject;
@@ -1115,59 +693,22 @@ class SetSize extends QueryNumber {
         return this;
     }
     getPropertyPath() {
-        //if a countable argument was given
-        // if (this.countable) {
-        //then creating the count step is straightforward
-        // let countablePath = this.countable.getPropertyPath();
-        // if (countablePath.some((step) => Array.isArray(step))) {
-        //   throw new Error(
-        //     'Cannot count a diverging path. Provide one path of properties to count',
-        //   );
-        // }
-        // let self: CountStep = {
-        //   count: this.countable?.getPropertyPath(),
-        //   label: this.label,
-        // };
-        // //and we can add the count step to the path of the subject
-        // let parent = this.subject.getPropertyPath();
-        // parent.push(self);
-        // return parent;
-        // } else {
-        //if nothing to count was given as an argument,
-        //then we just count the last property in the path
-        //also, we use the label of the last property as the label of the count step
+        //count the last property in the path
+        //use the label of the last property as the label of the count step
         let countable = this.subject.getPropertyStep();
         let self = {
             count: [countable],
-            label: this.label || this.subject.property.label, //the default is property name + 'Size', i.e., friendsSize
-            //numFriends
-            // label: this.label || 'num'+this.subject.property.label[0].toUpperCase()+this.subject.property.label.slice(1),//the default is property name + 'Size', i.e., friendsSize
+            label: this.label || this.subject.property.label,
         };
-        //in that case we request the path of the subject of the subject (the parent of the parent)
-        //and add the CountStep to that path
-        //since we already used the subject as the thing that's counted.
+        //request the path of the subject's subject (the parent of the parent)
+        //and add the SizeStep to that path, since we already used the subject as the thing that's counted
         if (this.subject.subject) {
             let path = this.subject.subject.getPropertyPath();
             path.push(self);
             return path;
         }
-        //if there is no parent of a parent, then we just return the count step as the whole path
         return [self];
-        // }
     }
 }
 exports.SetSize = SetSize;
-/**
- * A sub query that is used to filter results
- * i.e p.friends.where(f => //LinkedWhereQuery here)
- */
-class LinkedWhereQuery extends SelectQueryFactory {
-    getResponse() {
-        return this.traceResponse;
-    }
-    getWherePath() {
-        return this.traceResponse.getWherePath();
-    }
-}
-exports.LinkedWhereQuery = LinkedWhereQuery;
 //# sourceMappingURL=SelectQuery.js.map