@_linked/core 1.2.1 → 2.0.0-next.20260310082533

package/lib/esm/queries/SelectQuery.js

@@ -3,10 +3,10 @@ import { ShapeSet } from '../collections/ShapeSet.js';
 import { shacl } from '../ontologies/shacl.js';
 import { CoreSet } from '../collections/CoreSet.js';
 import { getPropertyShapeByLabel, getShapeClass } from '../utils/ShapeClass.js';
-import { QueryFactory } from './QueryFactory.js';
 import { xsd } from '../ontologies/xsd.js';
-import { buildSelectQuery, } from './IRPipeline.js';
-import { QueryParser } from './QueryParser.js';
+import { createProxiedPathBuilder } from './ProxiedPathBuilder.js';
+import { FieldSet } from './FieldSet.js';
+import { PropertyPath } from './PropertyPath.js';
 const isSameRef = (a, b) => !!a && !!b && a.id === b.id;
 export var WhereMethods;
 (function (WhereMethods) {
@@ -43,16 +43,16 @@ export 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);
@@ -91,23 +91,23 @@ export class QueryBuilderObject {
         if (datatype) {
             if (singleValue) {
                 if (isSameRef(datatype, xsd.integer)) {
-                    return new QueryNumber(0, property, subject);
+                    return new QueryPrimitive(0, property, subject);
                 }
                 else if (isSameRef(datatype, xsd.boolean)) {
-                    return new QueryBoolean(false, property, subject);
+                    return new QueryPrimitive(false, property, subject);
                 }
                 else if (isSameRef(datatype, xsd.dateTime) ||
                     isSameRef(datatype, xsd.date)) {
-                    return new QueryDate(new Date(), property, subject);
+                    return new QueryPrimitive(new Date(), property, subject);
                 }
                 else if (isSameRef(datatype, 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),
                 ]);
             }
         }
@@ -134,30 +134,17 @@ export class QueryBuilderObject {
             isSameRef(property.nodeKind, 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')
@@ -165,7 +152,7 @@ export class QueryBuilderObject {
         if (endValue instanceof QueryPrimitiveSet) {
             return new 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;
@@ -199,7 +186,6 @@ export class QueryBuilderObject {
         return new BoundComponent(component, this);
     }
     limit(lim) {
-        console.log(lim);
     }
     /**
      * Returns the path of properties that were requested to reach this value
@@ -227,45 +213,6 @@ export 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;
-    }
 }
 /**
  * Converts query context to a ShapeReferenceValue
@@ -278,17 +225,40 @@ const convertQueryContext = (shape) => {
         },
     };
 };
-const processWhereClause = (validation, shape) => {
+export const processWhereClause = (validation, shape) => {
     if (validation instanceof Function) {
         if (!shape) {
             throw new Error('Cannot process where clause without shape');
         }
-        return new LinkedWhereQuery(shape, validation).getWherePath();
+        const proxy = createProxiedPathBuilder(shape);
+        const evaluation = validation(proxy);
+        return evaluation.getWherePath();
     }
     else {
         return validation.getWherePath();
     }
 };
+/**
+ * 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().
+ */
+export const evaluateSortCallback = (shape, sortFn, direction = 'ASC') => {
+    const proxy = createProxiedPathBuilder(shape);
+    const response = sortFn(proxy);
+    const nodeShape = shape.shape;
+    const paths = [];
+    if (response instanceof QueryBuilderObject || response instanceof QueryPrimitiveSet) {
+        paths.push(new PropertyPath(nodeShape, FieldSet.collectPropertySegments(response)));
+    }
+    else if (Array.isArray(response)) {
+        for (const item of response) {
+            if (item instanceof QueryBuilderObject) {
+                paths.push(new PropertyPath(nodeShape, FieldSet.collectPropertySegments(item)));
+            }
+        }
+    }
+    return { paths, direction };
+};
 export class QueryShapeSet extends QueryBuilderObject {
     constructor(_originalValue, property, subject) {
         super(property, subject);
@@ -344,8 +314,6 @@ export 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,10 +420,10 @@ export class QueryShapeSet extends QueryBuilderObject {
         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.collectPropertySegments(this);
+        const fs = FieldSet.forSubSelect(leastSpecificShape, subQueryFn, parentSegments);
+        return fs;
     }
     selectAll() {
         let leastSpecificShape = this.getOriginalValue().getLeastSpecificShape();
@@ -487,12 +455,6 @@ export 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);
@@ -517,27 +479,9 @@ export 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 = 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') {
@@ -547,8 +491,6 @@ export 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];
             },
@@ -564,18 +506,16 @@ export 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 = getShapeClass(this.getOriginalValue().nodeShape.id);
-        let subQuery = new SelectQueryFactory(leastSpecificShape, subQueryFn);
-        subQuery.parentQueryPath = this.getPropertyPath();
-        return subQuery;
+        const leastSpecificShape = getShapeClass(this.getOriginalValue().nodeShape.id);
+        const parentSegments = FieldSet.collectPropertySegments(this);
+        const fs = FieldSet.forSubSelect(leastSpecificShape, subQueryFn, parentSegments);
+        return fs;
     }
     selectAll() {
         let leastSpecificShape = getShapeClass(this.getOriginalValue().nodeShape.id);
@@ -651,8 +591,11 @@ export class 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.
  */
 export class QueryPrimitive extends QueryBuilderObject {
     constructor(originalValue, property, subject) {
@@ -667,21 +610,11 @@ export class QueryPrimitive extends QueryBuilderObject {
     }
     where(validation) {
         // let nodeShape = this.subject.getOriginalValue().nodeShape;
-        this.wherePath = processWhereClause(validation, new QueryString(''));
+        this.wherePath = processWhereClause(validation, new QueryPrimitive(''));
         //return this because after Shape.friends.where() we can call other methods of Shape.friends
         return this;
     }
 }
-//@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
-export class QueryString extends QueryPrimitive {
-}
-export class QueryDate extends QueryPrimitive {
-}
-export class QueryNumber extends QueryPrimitive {
-}
-export class QueryBoolean extends QueryPrimitive {
-}
 export class QueryPrimitiveSet extends QueryBuilderObject {
     constructor(originalValue, property, subject, items) {
         super(property, subject);
@@ -700,7 +633,7 @@ export 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]);
@@ -735,358 +668,7 @@ export class QueryPrimitiveSet extends QueryBuilderObject {
         //countable, resultKey
     }
 }
-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
-export var onQueriesReady = (callback) => {
-    if (!documentLoaded) {
-        callbackStack.push(callback);
-    }
-    else {
-        callback();
-    }
-};
-export class SelectQueryFactory extends 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 QueryParser.selectQuery(this);
-    }
-    /**
-     * 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 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;
-    }
-}
-export class SetSize extends QueryNumber {
+export class SetSize extends QueryPrimitive {
     constructor(subject, countable, label) {
         super();
         this.subject = subject;
@@ -1098,57 +680,21 @@ export 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];
-        // }
-    }
-}
-/**
- * A sub query that is used to filter results
- * i.e p.friends.where(f => //LinkedWhereQuery here)
- */
-export class LinkedWhereQuery extends SelectQueryFactory {
-    getResponse() {
-        return this.traceResponse;
-    }
-    getWherePath() {
-        return this.traceResponse.getWherePath();
     }
 }
 //# sourceMappingURL=SelectQuery.js.map