@_linked/core 2.12.0 → 2.13.0

package/lib/cjs/queries/SelectQuery.js

@@ -1,761 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetSize = exports.QueryPrimitiveSet = exports.QueryPrimitive = exports.QueryShape = exports.QueryShapeSet = exports.evaluateSortCallback = exports.processWhereClause = exports.BoundComponent = exports.QueryBuilderObject = void 0;
-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 xsd_js_1 = require("../ontologies/xsd.js");
-const ProxiedPathBuilder_js_1 = require("./ProxiedPathBuilder.js");
-const FieldSet_js_1 = require("./FieldSet.js");
-const PropertyPath_js_1 = require("./PropertyPath.js");
-const ExpressionNode_js_1 = require("../expressions/ExpressionNode.js");
-const QueryContext_js_1 = require("./QueryContext.js");
-/**
- * String keys the query-shape proxy must let through *without* treating them as
- * a property access — promise-awaiting (`then`), React (`$$typeof`), and common
- * serializer/object-protocol probes. Everything else that isn't a decorated
- * property is a genuine misuse and throws. (Symbol keys always pass through.)
- */
-const INTEROP_PASSTHROUGH_KEYS = new Set([
-    'then',
-    '$$typeof',
-    'toJSON',
-    'toString',
-    'valueOf',
-    'constructor',
-    'asymmetricMatch', // jest matchers probe this
-    'nodeType', // some DOM/serializer probes
-]);
-const isSameRef = (a, b) => !!a && !!b && a.id === b.id;
-/**
- * ###################################
- * ####  QUERY BUILDING CLASSES   ####
- * ###################################
- */
-class QueryBuilderObject {
-    constructor(property, subject) {
-        this.property = property;
-        this.subject = subject;
-        //is null by default to avoid warnings when trying to access wherePath when its undefined
-        this.wherePath = null;
-    }
-    /**
-     * Create a Query Builder Object based on the requested PropertyShape
-     */
-    static generatePathValue(
-    // originalValue: AccessorReturnValue,
-    property, subject) {
-        let datatype = property.datatype;
-        let valueShape = property.valueShape;
-        let singleValue = property.maxCount <= 1;
-        if (datatype) {
-            if (singleValue) {
-                if (isSameRef(datatype, xsd_js_1.xsd.integer)) {
-                    return wrapWithExpressionProxy(new QueryPrimitive(0, property, subject));
-                }
-                else if (isSameRef(datatype, xsd_js_1.xsd.boolean)) {
-                    return wrapWithExpressionProxy(new QueryPrimitive(false, property, subject));
-                }
-                else if (isSameRef(datatype, xsd_js_1.xsd.dateTime) ||
-                    isSameRef(datatype, xsd_js_1.xsd.date)) {
-                    return wrapWithExpressionProxy(new QueryPrimitive(new Date(), property, subject));
-                }
-                else if (isSameRef(datatype, xsd_js_1.xsd.string)) {
-                    return wrapWithExpressionProxy(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 QueryPrimitive('', property, subject),
-                ]);
-            }
-        }
-        if (valueShape) {
-            const shapeClass = (0, ShapeClass_js_1.getShapeClass)(valueShape);
-            if (!shapeClass) {
-                //TODO: getShapeClassAsync -> which will lazy load the shape class
-                // but Im not sure if that's even possible with dynamic import paths, that are only known at runtime
-                //UPDATE: we should not need to load shapeclasses. We just need to be able to access shapes.
-                // but the problem remains that the ImageObject shape needs to be available, but thats easier, as its data
-                throw new Error(`Shape class not found for ${valueShape.id}`);
-            }
-            const shapeValue = new shapeClass();
-            if (singleValue) {
-                return QueryShape.create(shapeValue, property, subject);
-            }
-            else {
-                return QueryShapeSet.create(new ShapeSet_js_1.ShapeSet([shapeValue]), property, subject);
-            }
-        }
-        //no value shape and no data type.
-        //Lets look at the node kind
-        if (isSameRef(property.nodeKind, shacl_js_1.shacl.Literal) ||
-            isSameRef(property.nodeKind, shacl_js_1.shacl.BlankNodeOrLiteral)) {
-            if (singleValue) {
-                //default to string if no datatype is set
-                return wrapWithExpressionProxy(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 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}`);
-    }
-    getOriginalValue() {
-        return this.originalValue;
-    }
-    getPropertyStep() {
-        return {
-            property: this.property,
-            where: this.wherePath,
-        };
-    }
-    preloadFor(component) {
-        return new BoundComponent(component, this);
-    }
-    /**
-     * Pagination is applied to a nested *select*, not to a bare traversal — use
-     * `p.friends.select(f => f.name).limit(n)`. Calling `.limit()` directly on a
-     * traversal would silently do nothing, so we fail loudly instead.
-     * (Top-level result pagination lives on the outer query builder.)
-     */
-    limit(lim) {
-        throw new Error(`.limit(${lim}) is not supported directly on a traversal — use ` +
-            '.select(...).limit(n) on the nested collection (single-subject queries only).');
-    }
-    /**
-     * Returns the path of properties that were requested to reach this value
-     */
-    getPropertyPath(currentPath) {
-        var _a;
-        let path = currentPath || [];
-        //add the step of this object to the beginning of the path (so that the next parent will always before the current item)
-        if (this.property || this.wherePath) {
-            path.unshift(this.getPropertyStep());
-        }
-        if (this.subject) {
-            return this.subject.getPropertyPath(path);
-        }
-        //when query context is used as the first step, then the first step is just a pointer to the subject it represents
-        if ((_a = this.originalValue) === null || _a === void 0 ? void 0 : _a.__queryContextId) {
-            path.unshift(convertQueryContext(this));
-        }
-        return path;
-    }
-}
-exports.QueryBuilderObject = QueryBuilderObject;
-class BoundComponent extends QueryBuilderObject {
-    constructor(originalValue, source) {
-        super(null, null);
-        this.originalValue = originalValue;
-        this.source = source;
-    }
-}
-exports.BoundComponent = BoundComponent;
-/**
- * Converts query context to a ShapeReferenceValue
- */
-const convertQueryContext = (shape) => {
-    return {
-        id: shape.originalValue.__queryContextId,
-        shape: {
-            id: shape.originalValue.nodeShape.id,
-        },
-    };
-};
-const processWhereClause = (validation, shape) => {
-    if (validation instanceof Function) {
-        if (!shape) {
-            throw new Error('Cannot process where clause without shape');
-        }
-        const proxy = (0, ProxiedPathBuilder_js_1.createProxiedPathBuilder)(shape);
-        const result = validation(proxy);
-        if ((0, ExpressionNode_js_1.isExpressionNode)(result)) {
-            return { expressionNode: result };
-        }
-        if ((0, ExpressionNode_js_1.isExistsCondition)(result)) {
-            return { existsCondition: result };
-        }
-        throw new Error('WHERE callback must return ExpressionNode or ExistsCondition');
-    }
-    else if ((0, ExpressionNode_js_1.isExpressionNode)(validation)) {
-        return { expressionNode: validation };
-    }
-    else if ((0, ExpressionNode_js_1.isExistsCondition)(validation)) {
-        return { existsCondition: validation };
-    }
-    else {
-        throw new Error('WHERE clause must be ExpressionNode, ExistsCondition, or a callback');
-    }
-};
-exports.processWhereClause = processWhereClause;
-// ---------------------------------------------------------------------------
-// Expression method proxy for QueryPrimitive
-// ---------------------------------------------------------------------------
-const EXPRESSION_METHODS = new Set([
-    'plus', 'minus', 'times', 'divide', 'abs', 'round', 'ceil', 'floor', 'power',
-    'equals', 'eq', 'neq', 'notEquals', 'gt', 'greaterThan', 'gte', 'greaterThanOrEqual',
-    'lt', 'lessThan', 'lte', 'lessThanOrEqual', 'oneOf', 'notOneOf',
-    'concat', 'contains', 'startsWith', 'endsWith', 'substr', 'before', 'after',
-    'replace', 'ucase', 'lcase', 'strlen', 'encodeForUri', 'matches',
-    'year', 'month', 'day', 'hours', 'minutes', 'seconds', 'timezone', 'tz',
-    'and', 'or', 'not',
-    'isDefined', 'isNotDefined', 'defaultTo',
-    'lang', 'datatype', 'str', 'iri', 'isIri', 'isLiteral', 'isBlank', 'isNumeric',
-    'md5', 'sha256', 'sha512',
-]);
-/**
- * Convert a QueryBuilderObject to a traced ExpressionNode by extracting its
- * property path segments and creating a property expression reference.
- * This is the bridge between the query proxy world and the expression IR world.
- */
-function toExpressionNode(qbo) {
-    // Check if this is a query context reference. We carry the context *name*
-    // (not the resolved id): it serializes as `{@ctx}` and is resolved by `lower()`.
-    const contextName = findContextName(qbo);
-    if (contextName) {
-        const segments = FieldSet_js_1.FieldSet.collectPropertySegments(qbo);
-        if (segments.length > 0) {
-            // Context property access (e.g. getQueryContext('user').name) → context_property_expr
-            const lastSegment = segments[segments.length - 1].id;
-            const ir = { kind: 'context_property_expr', contextName, property: lastSegment };
-            return new ExpressionNode_js_1.ExpressionNode(ir);
-        }
-        // Context root reference (e.g. getQueryContext('user')) → reference_expr
-        const ir = { kind: 'reference_expr', contextName };
-        return new ExpressionNode_js_1.ExpressionNode(ir);
-    }
-    const segments = FieldSet_js_1.FieldSet.collectPropertySegments(qbo);
-    if (segments.length === 0) {
-        // Root shape or entity reference — produce alias expression (the entity itself)
-        return (0, ExpressionNode_js_1.tracedAliasExpression)([]);
-    }
-    const segmentIds = segments.map((s) => s.id);
-    return (0, ExpressionNode_js_1.tracedPropertyExpression)(segmentIds);
-}
-/** Walk up the QueryBuilderObject chain to find a query context *name* (for `{@ctx}`). */
-function findContextName(qbo) {
-    var _a;
-    let current = qbo;
-    while (current) {
-        if (current instanceof QueryShape && ((_a = current.originalValue) === null || _a === void 0 ? void 0 : _a.__queryContextName)) {
-            return current.originalValue.__queryContextName;
-        }
-        current = current.subject;
-    }
-    return undefined;
-}
-/**
- * A wrapper for inline `.where()` on primitives that produces alias-based expressions.
- * When `p.hobby.where(h => h.equals('Jogging'))` is called, `h` should reference
- * the hobby variable itself (alias), not traverse to a sub-property.
- */
-class InlineWhereProxy extends QueryBuilderObject {
-    constructor(source) {
-        super(source.property, source.subject);
-        this.source = source;
-    }
-    equals(otherValue) {
-        // Empty traversal = "the current alias" — resolved by lowering
-        // against the property's own alias scope
-        const self = (0, ExpressionNode_js_1.tracedAliasExpression)([]);
-        return self.eq(otherValue);
-    }
-}
-/**
- * Wrap a QueryPrimitive in a Proxy that intercepts expression method calls.
- * When an expression method (e.g., `.plus()`, `.gt()`, `.equals()`) is accessed,
- * creates a traced ExpressionNode based on the QueryPrimitive's property path.
- */
-function wrapWithExpressionProxy(qp) {
-    return new Proxy(qp, {
-        get(target, key, receiver) {
-            if (typeof key === 'string' && EXPRESSION_METHODS.has(key)) {
-                const segments = FieldSet_js_1.FieldSet.collectPropertySegments(target);
-                // Only intercept if we have valid property segments to trace
-                if (segments.length > 0) {
-                    // Use toExpressionNode so a context property as the *self* of an
-                    // expression (e.g. getQueryContext('user').name.equals(x)) becomes a
-                    // context_property_expr, not a root-entity property_expr.
-                    const baseNode = toExpressionNode(target);
-                    return (...args) => {
-                        // Convert QueryBuilderObject arguments to ExpressionNode
-                        const convertedArgs = args.map((arg) => { var _a; return arg instanceof QueryBuilderObject ? ((_a = toExpressionNode(arg)) !== null && _a !== void 0 ? _a : arg) : arg; });
-                        return baseNode[key](...convertedArgs);
-                    };
-                }
-            }
-            return Reflect.get(target, key, receiver);
-        },
-    });
-}
-/**
- * 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)));
-            }
-        }
-    }
-    // The DSL callback carries a single direction for all its paths; per-path
-    // directions come from the wire form (deserializeSortByPath).
-    return { paths, directions: paths.map(() => direction) };
-};
-exports.evaluateSortCallback = evaluateSortCallback;
-class QueryShapeSet extends QueryBuilderObject {
-    constructor(_originalValue, property, subject) {
-        super(property, subject);
-        this.originalValue = _originalValue;
-        //Note that QueryShapeSet intentionally does not store the _originalValue shape set, because it manipulates this.queryShapes
-        // and then recreates the original shape set when getOriginalValue() is called
-        this.queryShapes = new CoreSet_js_1.CoreSet(_originalValue === null || _originalValue === void 0 ? void 0 : _originalValue.map((shape) => QueryShape.create(shape, property, subject)));
-    }
-    static create(originalValue, property, subject) {
-        let instance = new QueryShapeSet(originalValue, property, subject);
-        let proxy = this.proxifyShapeSet(instance);
-        return proxy;
-    }
-    static proxifyShapeSet(queryShapeSet) {
-        let originalShapeSet = queryShapeSet.getOriginalValue();
-        queryShapeSet.proxy = new Proxy(queryShapeSet, {
-            get(target, key, receiver) {
-                var _a, _b;
-                //if the key is a string
-                if (typeof key === 'string') {
-                    //if this is a get method that is implemented by the QueryShapeSet, then use that
-                    if (key in queryShapeSet) {
-                        //if it's a function, then bind it to the queryShape and return it so it can be called
-                        if (typeof queryShapeSet[key] === 'function') {
-                            return target[key].bind(target);
-                        }
-                        //if it's a get method, then return that
-                        //NOTE: we may not need this if we don't use any get methods in QueryValue classes?
-                        return queryShapeSet[key];
-                    }
-                    //if not, then a method/accessor was called that likely fits with the methods of the original SHAPE of the items in the shape set
-                    //As in Shape.friends.name -> key would be name, which is requested from (each item in!) a ShapeSet of Shapes
-                    //So here we find back the shape that all items have in common, and then find the property shape that matches the key
-                    //NOTE: this will only work if the key corresponds with an accessor in the shape that uses a @linkedProperty decorator
-                    let leastSpecificShape = queryShapeSet
-                        .getOriginalValue()
-                        .getLeastSpecificShape();
-                    let valueShape = leastSpecificShape ? leastSpecificShape.shape : null;
-                    if (!valueShape && ((_a = queryShapeSet.property) === null || _a === void 0 ? void 0 : _a.valueShape)) {
-                        const shapeClass = (0, ShapeClass_js_1.getShapeClass)(queryShapeSet.property.valueShape);
-                        valueShape = shapeClass === null || shapeClass === void 0 ? void 0 : shapeClass.shape;
-                    }
-                    let propertyShape = valueShape === null || valueShape === void 0 ? void 0 : valueShape.getPropertyShapes(true).find((propertyShape) => propertyShape.label === key);
-                    //if the property shape is found
-                    if (propertyShape) {
-                        return queryShapeSet.callPropertyShapeAccessor(propertyShape);
-                    }
-                    else if (
-                    //else if a genuine collection method of the ShapeSet is called
-                    //(.forEach()/.map()/… — including symbol methods like iteration)
-                    originalShapeSet[key] &&
-                        typeof originalShapeSet[key] === 'function') {
-                        //then return that method and bind the original value as 'this'
-                        return originalShapeSet[key].bind(originalShapeSet);
-                    }
-                    else if (typeof key === 'string' && !INTEROP_PASSTHROUGH_KEYS.has(key)) {
-                        // Same policy as the single-node proxy: an undecorated string key
-                        // is a genuine misuse (it would silently return a broken path over
-                        // the set → silently-wrong results). Throw. Interop/framework keys
-                        // and symbols pass through.
-                        throw new Error(`${(_b = valueShape === null || valueShape === void 0 ? void 0 : valueShape.label) !== null && _b !== void 0 ? _b : 'shape'}.${key} is accessed in a query, but it does not have a @linkedProperty decorator. Queries can only access decorated get/set methods (@objectProperty / @literalProperty).`);
-                    }
-                }
-                //otherwise return the value of the property on the original shape
-                return originalShapeSet[key];
-            },
-        });
-        return queryShapeSet.proxy;
-    }
-    as(shape) {
-        //if the shape is not the same as the original value, then we need to create a new query shape
-        if (!shape.shape.equals(this.originalValue.getLeastSpecificShape().shape)) {
-            let newOriginal = new ShapeSet_js_1.ShapeSet(this.originalValue.map((existing) => {
-                const instance = new shape();
-                if (existing === null || existing === void 0 ? void 0 : existing.id) {
-                    instance.id = existing.id;
-                }
-                return instance;
-            }));
-            return QueryShapeSet.create(newOriginal, this.property, this.subject);
-        }
-        // else return this
-        return this;
-    }
-    add(item) {
-        this.queryShapes.add(item);
-    }
-    concat(other) {
-        if (other) {
-            if (other instanceof QueryShapeSet) {
-                other.queryShapes.forEach(this.queryShapes.add.bind(this.queryShapes));
-            }
-            else {
-                throw new Error('Unknown type: ' + other);
-            }
-        }
-        return this;
-    }
-    getOriginalValue() {
-        return new ShapeSet_js_1.ShapeSet(this.queryShapes.map((shape) => {
-            return shape.originalValue;
-        }));
-    }
-    callPropertyShapeAccessor(propertyShape) {
-        //call the get method for that property shape on each item in the shape set
-        //and return the result as a new shape set
-        let result; //QueryValueSetOfSets;
-        //if we expect the accessor to return a Primitive (string,number,boolean,Date)
-        if (isSameRef(propertyShape.nodeKind, shacl_js_1.shacl.Literal)) {
-            //then return a Set of QueryPrimitives
-            result = new QueryPrimitiveSet(null, propertyShape, this);
-        }
-        else {
-            // result = QueryValueSetOfSets.create(propertyShape, this); //QueryShapeSet.create(null, propertyShape, this);
-            result = QueryShapeSet.create(null, propertyShape, this);
-        }
-        let expectSingleValues = typeof propertyShape.maxCount === 'number' && propertyShape.maxCount <= 1;
-        this.queryShapes.forEach((shape) => {
-            //access the propertyShapes accessor,
-            // since the shape should already be converted to a QueryShape, the result is a QueryValue also
-            let shapeQueryValue = shape[propertyShape.label];
-            //only add results if something was actually returned, if the property is not defined for this shape the result can be undefined
-            if (shapeQueryValue) {
-                if (expectSingleValues) {
-                    result.add(shapeQueryValue);
-                }
-                else {
-                    //if each of the shapes in a set return a new shapeset for the request accessor
-                    //then we merge all the returned values into a single shapeset
-                    result.concat(shapeQueryValue);
-                }
-            }
-        });
-        return result;
-    }
-    //countable?, resultKey?: string
-    size() {
-        //when count() is called we want to count the number of items in the entire query path
-        return new SetSize(this); //countable, resultKey
-    }
-    // get testItem() {}
-    where(validation) {
-        if (this.getPropertyPath().some((step) => step.where)) {
-            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 = (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) {
-        const leastSpecificShape = this.getOriginalValue().getLeastSpecificShape();
-        const parentSegments = FieldSet_js_1.FieldSet.collectPropertySegments(this);
-        const fs = FieldSet_js_1.FieldSet.forSubSelect(leastSpecificShape, subQueryFn, parentSegments, this);
-        return fs;
-    }
-    selectAll() {
-        let leastSpecificShape = this.getOriginalValue().getLeastSpecificShape();
-        const propertyLabels = leastSpecificShape.shape
-            .getUniquePropertyShapes()
-            .map((propertyShape) => propertyShape.label);
-        return this.select((shape) => propertyLabels.map((label) => shape[label]));
-    }
-    some(validation) {
-        const predicate = this.buildPredicateExpression(validation);
-        const pathSegmentIds = FieldSet_js_1.FieldSet.collectPropertySegments(this).map(s => s.id);
-        return new ExpressionNode_js_1.ExistsCondition(pathSegmentIds, predicate, false);
-    }
-    every(validation) {
-        // every(fn) = NOT EXISTS(path WHERE NOT(fn))
-        const predicate = this.buildPredicateExpression(validation);
-        const pathSegmentIds = FieldSet_js_1.FieldSet.collectPropertySegments(this).map(s => s.id);
-        return new ExpressionNode_js_1.ExistsCondition(pathSegmentIds, predicate.not(), true);
-    }
-    none(validation) {
-        // none(fn) = NOT EXISTS(path WHERE fn) = some(fn).not()
-        const predicate = this.buildPredicateExpression(validation);
-        const pathSegmentIds = FieldSet_js_1.FieldSet.collectPropertySegments(this).map(s => s.id);
-        return new ExpressionNode_js_1.ExistsCondition(pathSegmentIds, predicate, true);
-    }
-    buildPredicateExpression(validation) {
-        const leastSpecificShape = this.getOriginalValue().getLeastSpecificShape();
-        if (validation instanceof Function) {
-            const proxy = (0, ProxiedPathBuilder_js_1.createProxiedPathBuilder)(leastSpecificShape);
-            const result = validation(proxy);
-            if ((0, ExpressionNode_js_1.isExpressionNode)(result)) {
-                return result;
-            }
-            throw new Error('Validation callback must return an ExpressionNode or ExistsCondition');
-        }
-        if ((0, ExpressionNode_js_1.isExpressionNode)(validation)) {
-            return validation;
-        }
-        throw new Error('Expected a callback or ExpressionNode for some/every/none');
-    }
-}
-exports.QueryShapeSet = QueryShapeSet;
-class QueryShape extends QueryBuilderObject {
-    constructor(originalValue, property, subject) {
-        super(property, subject);
-        this.originalValue = originalValue;
-    }
-    get id() {
-        return (this.originalValue.__queryContextId ||
-            this.originalValue['id']);
-    }
-    static create(original, property, subject) {
-        let instance = new QueryShape(original, property, subject);
-        let proxy = this.proxifyQueryShape(instance);
-        return proxy;
-    }
-    static proxifyQueryShape(queryShape) {
-        let originalShape = queryShape.originalValue;
-        queryShape.proxy = new Proxy(queryShape, {
-            get(target, key, receiver) {
-                //if the key is a string
-                if (typeof key === 'string') {
-                    //if this is a get method that is implemented by the QueryShape, then use that
-                    if (key in queryShape) {
-                        //if it's a function, then bind it to the queryShape and return it so it can be called
-                        if (typeof queryShape[key] === 'function') {
-                            return target[key].bind(target);
-                        }
-                        //if it's a get method, then return that
-                        //NOTE: we may not need this if we don't use any get methods in QueryValue classes?
-                        return queryShape[key];
-                    }
-                    //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 = (0, ShapeClass_js_1.getPropertyShapeByLabel)(originalShape.constructor, key);
-                    if (propertyShape) {
-                        return QueryBuilderObject.generatePathValue(propertyShape, target);
-                    }
-                }
-                // A string key that is neither a QueryShape member nor a decorated
-                // property is a genuine misuse: it would silently return the raw value
-                // and the query would run with a broken path (silently-wrong results).
-                // Throw. Symbols and framework/interop keys pass through untouched so
-                // promise-awaiting, React, and serializers can still introspect the proxy.
-                if (typeof key === 'string' && !INTEROP_PASSTHROUGH_KEYS.has(key)) {
-                    throw new Error(`${originalShape.constructor.name}.${key} is accessed in a query, but it does not have a @linkedProperty decorator. Queries can only access decorated get/set methods (@objectProperty / @literalProperty).`);
-                }
-                return originalShape[key];
-            },
-        });
-        return queryShape.proxy;
-    }
-    as(shape) {
-        //if the shape is not the same as the original value, then we need to create a new query shape
-        if (!shape.shape.equals(this.originalValue.nodeShape)) {
-            let newOriginal = new shape();
-            if (this.originalValue.id) {
-                newOriginal.id = this.originalValue.id;
-            }
-            return QueryShape.create(newOriginal, this.property, this.subject);
-        }
-        return this;
-    }
-    equals(otherValue) {
-        const self = toExpressionNode(this);
-        // An unresolved query-context reference (`getQueryContext('user')` before it
-        // is set) carries no `.id` yet — keep it as a `{@ctx}` ref, resolved at lower.
-        if (otherValue instanceof QueryContext_js_1.PendingQueryContext) {
-            return self.eq(otherValue);
-        }
-        //validate the value is formed correctly
-        if (!otherValue.id) {
-            throw Error(`Invalid value for .equals(). ${JSON.stringify(otherValue)}`);
-        }
-        const arg = otherValue instanceof QueryBuilderObject
-            ? toExpressionNode(otherValue)
-            : otherValue;
-        return self.eq(arg);
-    }
-    oneOf(values) {
-        return toExpressionNode(this).oneOf(values.map((v) => (v instanceof QueryBuilderObject ? toExpressionNode(v) : v)));
-    }
-    notOneOf(values) {
-        return toExpressionNode(this).notOneOf(values.map((v) => (v instanceof QueryBuilderObject ? toExpressionNode(v) : v)));
-    }
-    select(subQueryFn) {
-        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, this);
-        return fs;
-    }
-    selectAll() {
-        let leastSpecificShape = (0, ShapeClass_js_1.getShapeClass)(this.getOriginalValue().nodeShape.id);
-        const propertyLabels = leastSpecificShape.shape
-            .getUniquePropertyShapes()
-            .map((propertyShape) => propertyShape.label);
-        return this.select((shape) => propertyLabels.map((label) => shape[label]));
-    }
-}
-exports.QueryShape = QueryShape;
-/**
- * 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) {
-        super(property, subject);
-        this.originalValue = originalValue;
-        this.property = property;
-        this.subject = subject;
-    }
-    equals(otherValue) {
-        const self = toExpressionNode(this);
-        const arg = otherValue instanceof QueryBuilderObject
-            ? toExpressionNode(otherValue)
-            : otherValue;
-        return self.eq(arg);
-    }
-    oneOf(values) {
-        return toExpressionNode(this).oneOf(values.map((v) => (v instanceof QueryBuilderObject ? toExpressionNode(v) : v)));
-    }
-    notOneOf(values) {
-        return toExpressionNode(this).notOneOf(values.map((v) => (v instanceof QueryBuilderObject ? toExpressionNode(v) : v)));
-    }
-    where(validation) {
-        // For inline where on a primitive (p.hobby.where(h => h.equals(...))),
-        // pass a clone that produces alias expressions (the bound value itself)
-        // rather than property traversals
-        const selfAsAlias = new InlineWhereProxy(this);
-        this.wherePath = (0, exports.processWhereClause)(validation, selfAsAlias);
-        //return this because after Shape.friends.where() we can call other methods of Shape.friends
-        return this;
-    }
-}
-exports.QueryPrimitive = QueryPrimitive;
-class QueryPrimitiveSet extends QueryBuilderObject {
-    constructor(originalValue, property, subject, items) {
-        super(property, subject);
-        this.originalValue = originalValue;
-        this.property = property;
-        this.subject = subject;
-        this.contents = new CoreSet_js_1.CoreSet(items);
-    }
-    add(item) {
-        this.contents.add(item);
-    }
-    values() {
-        return [...this.contents.values()];
-    }
-    //this is needed because we extend CoreSet which has a createNew method but does not expect the constructor to have arguments
-    createNew(...args) {
-        return new this.constructor(this.property, this.subject, ...args);
-    }
-    //TODO: see if we can merge these methods of QueryPrimitive and QueryPrimitiveSet
-    // so that they're only defined once
-    equals(other) {
-        return toExpressionNode(this).eq(other);
-    }
-    getPropertyStep() {
-        if (this.contents.size > 1) {
-            throw new Error('This should never happen? Not implemented: get property path for a QueryPrimitiveSet with multiple values');
-        }
-        return this.contents.first().getPropertyStep();
-    }
-    getPropertyPath() {
-        if (this.contents.size > 1) {
-            throw new Error('This should never happen? Not implemented: get property path for a QueryPrimitiveSet with multiple values');
-        }
-        //here we let the first item in the set return its property path, because all items will be the same
-        //however, sometimes the path goes through the subject of this SET rather than the individual items (which have an individual shape as subject)
-        //so we pass the subject of this set so it can be used
-        let first = this.contents.first();
-        if (first) {
-            first.subject.wherePath =
-                first.subject.wherePath || this.subject.wherePath;
-            return first.getPropertyPath();
-        }
-        else {
-            console.warn(`QueryPrimitiveSet without items. From ${this.subject.getOriginalValue().nodeShape.label}.${this.property.label}.  What to return as property path?`);
-            return this.subject.getPropertyPath();
-        }
-    }
-    //countable, resultKey?: string
-    size() {
-        return new SetSize(this);
-        //countable, resultKey
-    }
-}
-exports.QueryPrimitiveSet = QueryPrimitiveSet;
-class SetSize extends QueryPrimitive {
-    constructor(subject, countable, label) {
-        super();
-        this.subject = subject;
-        this.countable = countable;
-        this.label = label;
-    }
-    // Build an aggregate_expr(count, …) ExpressionNode for the counted property.
-    toCountExpr() {
-        const countedSegments = FieldSet_js_1.FieldSet.collectPropertySegments(this.subject);
-        const countedIds = countedSegments.map((s) => s.id);
-        const countedNode = (0, ExpressionNode_js_1.tracedPropertyExpression)(countedIds);
-        return new ExpressionNode_js_1.ExpressionNode({ kind: 'aggregate_expr', name: 'count', args: [countedNode.ir] }, countedNode._refs);
-    }
-    // Comparisons on the count (lowered to a HAVING clause on COUNT(…)).
-    equals(v) { return this.toCountExpr().eq(v); }
-    eq(v) { return this.toCountExpr().eq(v); }
-    neq(v) { return this.toCountExpr().neq(v); }
-    notEquals(v) { return this.toCountExpr().neq(v); }
-    gt(v) { return this.toCountExpr().gt(v); }
-    greaterThan(v) { return this.toCountExpr().gt(v); }
-    gte(v) { return this.toCountExpr().gte(v); }
-    greaterThanOrEqual(v) { return this.toCountExpr().gte(v); }
-    lt(v) { return this.toCountExpr().lt(v); }
-    lessThan(v) { return this.toCountExpr().lt(v); }
-    lte(v) { return this.toCountExpr().lte(v); }
-    lessThanOrEqual(v) { return this.toCountExpr().lte(v); }
-    as(label) {
-        this.label = label;
-        return this;
-    }
-    getPropertyPath() {
-        //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,
-        };
-        //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;
-        }
-        return [self];
-    }
-}
-exports.SetSize = SetSize;
-//# sourceMappingURL=SelectQuery.js.map