@_linked/core 2.11.1 → 2.12.0-next.20260706124424

package/lib/esm/test-helpers/query-fixtures.js

@@ -1,602 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { linkedShape } from '../package';
-import { literalProperty, objectProperty } from '../shapes/SHACL';
-import { Shape } from '../shapes/Shape';
-import { Expr } from '../expressions/Expr';
-import { xsd } from '../ontologies/xsd';
-import { ShapeSet } from '../collections/ShapeSet';
-import { getQueryContext } from '../queries/QueryContext';
-import { DeleteBuilder } from '../queries/DeleteBuilder';
-const tmpPropBase = 'linked://tmp/props/';
-const tmpTypeBase = 'linked://tmp/types/';
-export const tmpEntityBase = 'linked://tmp/entities/';
-const prop = (suffix) => ({
-    id: `${tmpPropBase}${suffix}`,
-});
-const type = (suffix) => ({
-    id: `${tmpTypeBase}${suffix}`,
-});
-const entity = (suffix) => ({
-    id: `${tmpEntityBase}${suffix}`,
-});
-export const name = prop('name');
-export const hobby = prop('hobby');
-export const nickName = prop('nickName');
-export const bestFriend = prop('bestFriend');
-export const hasFriend = prop('hasFriend');
-export const birthDate = prop('birthDate');
-export const isRealPerson = prop('isRealPerson');
-export const hasPet = prop('hasPet');
-export const guardDogLevel = prop('guardDogLevel');
-export const pluralTestProp = prop('pluralTestProp');
-export const personClass = type('Person');
-export const employeeClass = type('Employee');
-export const petClass = type('Pet');
-export const dogClass = type('Dog');
-export const employeeName = prop('employeeName');
-export const employeeDepartment = prop('employeeDepartment');
-let Pet = class Pet extends Shape {
-    get bestFriend() {
-        return null;
-    }
-};
-Pet.targetClass = petClass;
-__decorate([
-    objectProperty({ path: bestFriend, maxCount: 1, shape: Pet }),
-    __metadata("design:type", Pet),
-    __metadata("design:paramtypes", [])
-], Pet.prototype, "bestFriend", null);
-Pet = __decorate([
-    linkedShape
-], Pet);
-export { Pet };
-let Dog = class Dog extends Pet {
-    get guardDogLevel() {
-        return null;
-    }
-};
-Dog.targetClass = dogClass;
-__decorate([
-    literalProperty({ path: guardDogLevel, maxCount: 1, datatype: xsd.integer }),
-    __metadata("design:type", Number),
-    __metadata("design:paramtypes", [])
-], Dog.prototype, "guardDogLevel", null);
-Dog = __decorate([
-    linkedShape
-], Dog);
-export { Dog };
-let Person = class Person extends Shape {
-    get name() {
-        return '';
-    }
-    get hobby() {
-        return '';
-    }
-    get nickNames() {
-        return [];
-    }
-    get birthDate() {
-        return null;
-    }
-    get isRealPerson() {
-        return null;
-    }
-    get bestFriend() {
-        return null;
-    }
-    get friends() {
-        return null;
-    }
-    get pets() {
-        return null;
-    }
-    get firstPet() {
-        return null;
-    }
-    get pluralTestProp() {
-        return null;
-    }
-};
-Person.targetClass = personClass;
-__decorate([
-    literalProperty({ path: name, maxCount: 1 }),
-    __metadata("design:type", String),
-    __metadata("design:paramtypes", [])
-], Person.prototype, "name", null);
-__decorate([
-    literalProperty({ path: hobby, maxCount: 1 }),
-    __metadata("design:type", String),
-    __metadata("design:paramtypes", [])
-], Person.prototype, "hobby", null);
-__decorate([
-    literalProperty({ path: nickName }),
-    __metadata("design:type", Array),
-    __metadata("design:paramtypes", [])
-], Person.prototype, "nickNames", null);
-__decorate([
-    literalProperty({ path: birthDate, datatype: xsd.dateTime, maxCount: 1 }),
-    __metadata("design:type", Date),
-    __metadata("design:paramtypes", [])
-], Person.prototype, "birthDate", null);
-__decorate([
-    literalProperty({ path: isRealPerson, datatype: xsd.boolean, maxCount: 1 }),
-    __metadata("design:type", Boolean),
-    __metadata("design:paramtypes", [])
-], Person.prototype, "isRealPerson", null);
-__decorate([
-    objectProperty({ path: bestFriend, maxCount: 1, shape: Person }),
-    __metadata("design:type", Person),
-    __metadata("design:paramtypes", [])
-], Person.prototype, "bestFriend", null);
-__decorate([
-    objectProperty({ path: hasFriend, shape: Person }),
-    __metadata("design:type", ShapeSet),
-    __metadata("design:paramtypes", [])
-], Person.prototype, "friends", null);
-__decorate([
-    objectProperty({ path: hasPet, shape: Pet }),
-    __metadata("design:type", ShapeSet),
-    __metadata("design:paramtypes", [])
-], Person.prototype, "pets", null);
-__decorate([
-    objectProperty({ path: hasPet, maxCount: 1, shape: Pet }),
-    __metadata("design:type", Pet),
-    __metadata("design:paramtypes", [])
-], Person.prototype, "firstPet", null);
-__decorate([
-    objectProperty({ path: pluralTestProp, shape: Person }),
-    __metadata("design:type", ShapeSet),
-    __metadata("design:paramtypes", [])
-], Person.prototype, "pluralTestProp", null);
-Person = __decorate([
-    linkedShape
-], Person);
-export { Person };
-export const metricClass = type('Metric');
-export const metricScore = prop('metricScore');
-export const metricRating = prop('metricRating');
-export const metricViews = prop('metricViews');
-export const metricCount = prop('metricCount');
-export const metricJoinedOn = prop('metricJoinedOn');
-export const metricScores = prop('metricScores');
-/**
- * Datatype-coverage shape: one single-valued field per numeric/date xsd type,
- * plus a multi-valued numeric field (scores) for array coercion/dedup/ordering.
- */
-let Metric = class Metric extends Shape {
-    get score() {
-        return null;
-    }
-    get rating() {
-        return null;
-    }
-    get views() {
-        return null;
-    }
-    get count() {
-        return null;
-    }
-    get joinedOn() {
-        return null;
-    }
-    get scores() {
-        return [];
-    }
-};
-Metric.targetClass = metricClass;
-__decorate([
-    literalProperty({ path: metricScore, maxCount: 1, datatype: xsd.decimal }),
-    __metadata("design:type", Number),
-    __metadata("design:paramtypes", [])
-], Metric.prototype, "score", null);
-__decorate([
-    literalProperty({ path: metricRating, maxCount: 1, datatype: xsd.double }),
-    __metadata("design:type", Number),
-    __metadata("design:paramtypes", [])
-], Metric.prototype, "rating", null);
-__decorate([
-    literalProperty({ path: metricViews, maxCount: 1, datatype: xsd.long }),
-    __metadata("design:type", Number),
-    __metadata("design:paramtypes", [])
-], Metric.prototype, "views", null);
-__decorate([
-    literalProperty({ path: metricCount, maxCount: 1, datatype: xsd.integer }),
-    __metadata("design:type", Number),
-    __metadata("design:paramtypes", [])
-], Metric.prototype, "count", null);
-__decorate([
-    literalProperty({ path: metricJoinedOn, maxCount: 1, datatype: xsd.date }),
-    __metadata("design:type", Date),
-    __metadata("design:paramtypes", [])
-], Metric.prototype, "joinedOn", null);
-__decorate([
-    literalProperty({ path: metricScores, datatype: xsd.decimal }),
-    __metadata("design:type", Array),
-    __metadata("design:paramtypes", [])
-], Metric.prototype, "scores", null);
-Metric = __decorate([
-    linkedShape
-], Metric);
-export { Metric };
-/**
- * Property-path coverage shape. Uses complex decorator paths (sequence,
- * alternative, inverse, transitive) so Shape.select(...) lowers them end-to-end.
- * Paths use explicit raw IRIs; seed data is keyed on those same IRIs.
- */
-const PP = 'linked://pp/';
-export const pathNodeClass = { id: `${PP}Node` };
-let PathNode = class PathNode extends Shape {
-    // sequence: knows / name → the name of who this node knows
-    get friendName() {
-        return '';
-    }
-    // alternative: email | phone
-    get contact() {
-        return [];
-    }
-    // inverse + sequence: ^knows / name → name of who knows this node
-    get knownByName() {
-        return '';
-    }
-    // transitive sequence: manages+ / name → names of all transitive reports
-    get reportNames() {
-        return [];
-    }
-    // zeroOrMore: knows* / name → self + all transitively-known names
-    get knowsChainNames() {
-        return [];
-    }
-    // zeroOrOne: knows? / name → self + directly-known name
-    get maybeKnownNames() {
-        return [];
-    }
-};
-PathNode.targetClass = pathNodeClass;
-__decorate([
-    literalProperty({ path: { seq: [{ id: `${PP}knows` }, { id: `${PP}name` }] }, maxCount: 1 }),
-    __metadata("design:type", String),
-    __metadata("design:paramtypes", [])
-], PathNode.prototype, "friendName", null);
-__decorate([
-    literalProperty({ path: { alt: [{ id: `${PP}email` }, { id: `${PP}phone` }] } }),
-    __metadata("design:type", Array),
-    __metadata("design:paramtypes", [])
-], PathNode.prototype, "contact", null);
-__decorate([
-    literalProperty({ path: { seq: [{ inv: { id: `${PP}knows` } }, { id: `${PP}name` }] }, maxCount: 1 }),
-    __metadata("design:type", String),
-    __metadata("design:paramtypes", [])
-], PathNode.prototype, "knownByName", null);
-__decorate([
-    literalProperty({ path: { seq: [{ oneOrMore: { id: `${PP}manages` } }, { id: `${PP}name` }] } }),
-    __metadata("design:type", Array),
-    __metadata("design:paramtypes", [])
-], PathNode.prototype, "reportNames", null);
-__decorate([
-    literalProperty({ path: { seq: [{ zeroOrMore: { id: `${PP}knows` } }, { id: `${PP}name` }] } }),
-    __metadata("design:type", Array),
-    __metadata("design:paramtypes", [])
-], PathNode.prototype, "knowsChainNames", null);
-__decorate([
-    literalProperty({ path: { seq: [{ zeroOrOne: { id: `${PP}knows` } }, { id: `${PP}name` }] } }),
-    __metadata("design:type", Array),
-    __metadata("design:paramtypes", [])
-], PathNode.prototype, "maybeKnownNames", null);
-PathNode = __decorate([
-    linkedShape
-], PathNode);
-export { PathNode };
-let Employee = class Employee extends Person {
-    get name() {
-        return '';
-    }
-    get bestFriend() {
-        return null;
-    }
-    get department() {
-        return '';
-    }
-};
-Employee.targetClass = employeeClass;
-__decorate([
-    literalProperty({ path: employeeName, maxCount: 1 }),
-    __metadata("design:type", String),
-    __metadata("design:paramtypes", [])
-], Employee.prototype, "name", null);
-__decorate([
-    objectProperty({ path: bestFriend, maxCount: 1, shape: Employee }),
-    __metadata("design:type", Employee),
-    __metadata("design:paramtypes", [])
-], Employee.prototype, "bestFriend", null);
-__decorate([
-    literalProperty({ path: employeeDepartment, maxCount: 1 }),
-    __metadata("design:type", String),
-    __metadata("design:paramtypes", [])
-], Employee.prototype, "department", null);
-Employee = __decorate([
-    linkedShape
-], Employee);
-export { Employee };
-import { QueryBuilder } from '../queries/QueryBuilder';
-import { FieldSet } from '../queries/FieldSet';
-const componentLike = { query: Person.select((p) => ({ name: p.name })) };
-const componentFieldSet = FieldSet.for(Person.shape, ['name']);
-const componentLikeWithFieldSet = { query: componentFieldSet, fields: componentFieldSet };
-const updateSimple = { hobby: 'Chess' };
-const updateOverwriteSet = { friends: [entity('p2')] };
-const updateUnsetSingleUndefined = { hobby: undefined };
-const updateUnsetSingleNull = { hobby: null };
-const updateOverwriteNested = {
-    bestFriend: { name: 'Bestie' },
-};
-const updatePassIdReferences = {
-    bestFriend: entity('p2'),
-};
-const updateAddRemoveMulti = {
-    friends: { add: [entity('p2')], remove: [entity('p3')] },
-};
-const updateRemoveMulti = {
-    friends: { remove: [entity('p2')] },
-};
-const updateAddRemoveSame = {
-    friends: { add: [entity('p2')], remove: [entity('p3')] },
-};
-const updateUnsetMultiUndefined = { friends: undefined };
-const updateNestedWithPredefinedId = {
-    bestFriend: { id: `${tmpEntityBase}p3-best-friend`, name: 'Bestie' },
-};
-const updateBirthDate = {
-    birthDate: new Date('2020-01-01'),
-};
-export const queryFactories = {
-    selectName: () => Person.select((p) => p.name),
-    selectFriends: () => Person.select((p) => p.friends),
-    selectBirthDate: () => Person.select((p) => p.birthDate),
-    selectIsRealPerson: () => Person.select((p) => p.isRealPerson),
-    selectById: () => Person.select((p) => p.name).for(entity('p1')),
-    selectByIdReference: () => Person.select((p) => p.name).for(entity('p1')),
-    selectNonExisting: () => Person.select((p) => p.name).for({ id: 'https://does.not/exist' }),
-    selectUndefinedOnly: () => Person.select((p) => [p.hobby, p.bestFriend]).for(entity('p3')),
-    selectFriendsName: () => Person.select((p) => p.friends.name),
-    selectNestedFriendsName: () => Person.select((p) => p.friends.friends.name),
-    selectMultiplePaths: () => Person.select((p) => [p.name, p.friends, p.bestFriend.name]),
-    selectBestFriendName: () => Person.select((p) => p.bestFriend.name),
-    selectBestFriendOnly: () => Person.select((p) => p.bestFriend),
-    selectDeepNested: () => Person.select((p) => p.friends.bestFriend.bestFriend.name),
-    whereFriendsNameEquals: () => Person.select((p) => p.friends.where((f) => f.name.equals('Moa'))),
-    whereFriendsNameEqualsChained: () => Person.select((p) => p.friends.where((f) => f.name.equals('Moa')).name),
-    whereBestFriendEquals: () => Person.select().where((p) => p.bestFriend.equals(entity('p3'))),
-    whereHobbyEquals: () => Person.select((p) => p.hobby.where((h) => h.equals('Jogging'))),
-    whereAnd: () => Person.select((p) => p.friends.where((f) => f.name.equals('Moa').and(f.hobby.equals('Jogging')))),
-    whereOr: () => Person.select((p) => p.friends.where((f) => f.name.equals('Jinx').or(f.hobby.equals('Jogging')))),
-    selectAllProperties: () => Person.selectAll(),
-    selectAll: () => Person.select(),
-    selectWhereNameSemmy: () => Person.select().where((p) => p.name.equals('Semmy')),
-    whereAndOrAnd: () => Person.select((p) => p.friends.where((f) => f.name.equals('Jinx').or(f.hobby.equals('Jogging')).and(f.name.equals('Moa')))),
-    whereAndOrAndNested: () => Person.select((p) => p.friends.where((f) => f.name.equals('Jinx').or(f.hobby.equals('Jogging').and(f.name.equals('Moa'))))),
-    whereSomeImplicit: () => Person.select().where((p) => p.friends.name.equals('Moa')),
-    whereSomeExplicit: () => Person.select().where((p) => p.friends.some((f) => f.name.equals('Moa'))),
-    whereEvery: () => Person.select().where((p) => p.friends.every((f) => f.name.equals('Moa').or(f.name.equals('Jinx')))),
-    whereNone: () => Person.select((p) => p.name).where((p) => p.friends.none((f) => f.hobby.equals('Chess'))),
-    whereSomeNot: () => Person.select((p) => p.name).where((p) => p.friends.some((f) => f.hobby.equals('Chess')).not()),
-    whereEqualsNot: () => Person.select((p) => p.name).where((p) => p.name.equals('Alice').not()),
-    whereNoneAndEquals: () => Person.select((p) => p.name).where((p) => p.friends.none((f) => f.hobby.equals('Chess')).and(p.name.equals('Bob'))),
-    whereNeq: () => Person.select((p) => p.name).where(((p) => p.name.neq('Alice'))),
-    // Unbound-tolerant functions in a where-filter: their arguments must not be
-    // inner-joined, or the fallback/untaken branch can never match
-    whereExprDefaultTo: () => Person.select().where(((p) => p.hobby.defaultTo('none').equals('none'))),
-    whereExprIfThen: () => Person.select().where(((p) => Expr.ifThen(p.name.equals('Quinn'), 'quinn', p.hobby.str()).equals('quinn'))),
-    whereExprNot: () => Person.select((p) => p.name).where((p) => Expr.not(p.name.equals('Alice').and(p.hobby.equals('Chess')))),
-    whereSequences: () => Person.select().where((p) => p.friends
-        .some((f) => f.name.equals('Jinx'))
-        .and(p.name.equals('Semmy'))),
-    outerWhere: () => Person.select((p) => p.friends).where((p) => p.name.equals('Semmy')),
-    whereWithContext: () => Person.select((p) => p.name).where((p) => p.bestFriend.equals(getQueryContext('user'))),
-    whereWithContextPath: () => Person.select((p) => p.name).where((p) => {
-        const userName = getQueryContext('user').name;
-        return p.friends.some((f) => f.name.equals(userName));
-    }),
-    countFriends: () => Person.select((p) => p.friends.size()),
-    countNestedFriends: () => Person.select((p) => p.friends.friends.size()),
-    countLabel: () => Person.select((p) => p.friends.select((f) => ({ numFriends: f.friends.size() }))),
-    nestedObjectProperty: () => Person.select((p) => p.friends.bestFriend),
-    nestedObjectPropertySingle: () => Person.select((p) => p.friends.bestFriend),
-    subSelectSingleProp: () => Person.select((p) => p.bestFriend.select((f) => ({ name: f.name }))),
-    subSelectPluralCustom: () => Person.select((p) => p.friends.select((f) => ({ name: f.name, hobby: f.hobby }))),
-    doubleNestedSubSelect: () => Person.select((p) => p.friends.select((p2) => p2.bestFriend.select((p3) => ({ name: p3.name })))),
-    subSelectAllProperties: () => Person.select((p) => p.friends.selectAll()),
-    subSelectAllPropertiesSingle: () => Person.select((p) => p.bestFriend.selectAll()),
-    subSelectAllPrimitives: () => Person.select((p) => p.bestFriend.select((f) => [f.name, f.birthDate, f.isRealPerson])),
-    customResultEqualsBoolean: () => Person.select((p) => ({ isBestFriend: p.bestFriend.equals(entity('p3')) })),
-    customResultNumFriends: () => Person.select((p) => ({ numFriends: p.friends.size() })),
-    countEquals: () => Person.select().where((p) => p.friends.size().equals(2)),
-    subSelectArray: () => Person.select((p) => p.friends.select((f) => [f.name, f.hobby])),
-    selectShapeSetAs: () => Person.select((p) => p.pets.as(Dog).guardDogLevel),
-    selectNonExistingMultiple: () => Person.select((p) => [p.bestFriend, p.friends]),
-    selectShapeAs: () => Person.select((p) => p.firstPet.as(Dog).guardDogLevel),
-    selectOne: () => Person.select((p) => p.name).where((p) => p.equals(entity('p1'))).one(),
-    nestedQueries2: () => Person.select((p) => [
-        p.friends.select((p2) => [
-            p2.firstPet,
-            p2.bestFriend.select((p3) => ({ name: p3.name })),
-        ]),
-    ]),
-    pluralFilteredNestedSubSelect: () => Person.select((p) => p.pluralTestProp
-        .where((pp) => pp.name.equals('Moa'))
-        .select((pp) => [
-        pp.name,
-        pp.friends.select((f) => [f.name, f.hobby]),
-    ])),
-    // A filtered sub-select nested INSIDE another filtered sub-select
-    nestedFilteredSubSelects: () => Person.select((p) => p.pluralTestProp
-        .where((pp) => pp.name.equals('Moa'))
-        .select((pp) => [
-        pp.name,
-        pp.friends
-            .where((f) => f.name.equals('Jinx'))
-            .select((f) => [f.name, f.hobby]),
-    ])),
-    selectDuplicatePaths: () => Person.select((p) => [
-        p.bestFriend.name,
-        p.bestFriend.hobby,
-        p.bestFriend.isRealPerson,
-    ]),
-    outerWhereLimit: () => Person.select((p) => p.name)
-        .where((p) => p.name.equals('Semmy').or(p.name.equals('Moa')))
-        .limit(1),
-    outerWhereDifferentPropsOr: () => Person.select((p) => [p.name, p.hobby])
-        .where((p) => p.name.equals('Jinx').or(p.hobby.equals('Jogging'))),
-    sortByAsc: () => Person.select((p) => p.name).orderBy((p) => p.name),
-    sortByDesc: () => Person.select((p) => p.name).orderBy((p) => p.name, 'DESC'),
-    updateSimple: (() => Person.update(updateSimple).for(entity('p1'))),
-    createSimple: (() => Person.create({ name: 'Test Create', hobby: 'Chess' })),
-    createWithFriends: (() => Person.create({
-        name: 'Test Create',
-        friends: [entity('p2'), { name: 'New Friend' }],
-    })),
-    createWithFixedId: (() => Person.create({
-        __id: `${tmpEntityBase}fixed-id`,
-        name: 'Fixed',
-        bestFriend: entity('fixed-id-2'),
-    })),
-    deleteSingle: () => Person.delete(entity('to-delete')),
-    deleteSingleRef: () => Person.delete(entity('to-delete')),
-    deleteMultiple: () => Person.delete([entity('to-delete-1'), entity('to-delete-2')]),
-    deleteMultipleFull: () => Person.delete([entity('to-delete-1'), entity('to-delete-2')]),
-    updateOverwriteSet: (() => Person.update(updateOverwriteSet).for(entity('p1'))),
-    updateUnsetSingleUndefined: (() => Person.update(updateUnsetSingleUndefined).for(entity('p1'))),
-    updateUnsetSingleNull: (() => Person.update(updateUnsetSingleNull).for(entity('p1'))),
-    updateOverwriteNested: (() => Person.update(updateOverwriteNested).for(entity('p1'))),
-    updatePassIdReferences: (() => Person.update(updatePassIdReferences).for(entity('p1'))),
-    updateAddRemoveMulti: (() => Person.update(updateAddRemoveMulti).for(entity('p1'))),
-    updateRemoveMulti: (() => Person.update(updateRemoveMulti).for(entity('p1'))),
-    updateAddRemoveSame: (() => Person.update(updateAddRemoveSame).for(entity('p1'))),
-    updateUnsetMultiUndefined: (() => Person.update(updateUnsetMultiUndefined).for(entity('p1'))),
-    updateNestedWithPredefinedId: (() => Person.update(updateNestedWithPredefinedId).for(entity('p1'))),
-    updateBirthDate: (() => Person.update(updateBirthDate).for(entity('p1'))),
-    preloadBestFriend: () => Person.select((p) => p.bestFriend.preloadFor(componentLike)),
-    preloadBestFriendWithFieldSet: () => Person.select((p) => p.bestFriend.preloadFor(componentLikeWithFieldSet)),
-    queryBuilderPreload: () => QueryBuilder.from(Person).select((p) => [p.name]).preload('bestFriend', componentLike),
-    selectAllEmployeeProperties: () => Employee.selectAll(),
-    // --- Deep nesting boundary tests (Phase 12 validation) ---
-    // Triple-nested sub-selects: 3 levels of .select()
-    tripleNestedSubSelect: () => Person.select((p) => p.friends.select((f) => f.bestFriend.select((bf) => bf.friends.select((ff) => ({ name: ff.name, hobby: ff.hobby }))))),
-    // Double nested: singular → plural
-    doubleNestedSingularPlural: () => Person.select((p) => p.bestFriend.select((bf) => bf.friends.select((f) => ({ name: f.name, hobby: f.hobby })))),
-    // Double nested: plural → singular
-    doubleNestedPluralSingular: () => Person.select((p) => p.friends.select((f) => f.bestFriend.select((bf) => ({ name: bf.name, isReal: bf.isRealPerson })))),
-    // Sub-select returning array of paths (not custom object)
-    subSelectArrayOfPaths: () => Person.select((p) => p.friends.select((f) => [f.name, f.hobby, f.birthDate])),
-    // Sub-select on singular returning array of paths
-    subSelectSingularArrayPaths: () => Person.select((p) => p.bestFriend.select((bf) => [bf.name, bf.hobby, bf.isRealPerson])),
-    // Sub-select with count in custom object
-    subSelectWithCount: () => Person.select((p) => p.friends.select((f) => ({
-        name: f.name,
-        numFriends: f.friends.size(),
-    }))),
-    // Mixed: plain path + sub-select in array
-    mixedPathAndSubSelect: () => Person.select((p) => [
-        p.name,
-        p.friends.select((f) => ({ name: f.name, hobby: f.hobby })),
-    ]),
-    // Multiple sub-selects in array
-    multipleSubSelectsInArray: () => Person.select((p) => [
-        p.friends.select((f) => ({ name: f.name })),
-        p.bestFriend.select((bf) => ({ hobby: bf.hobby })),
-    ]),
-    // Sub-select + one() unwrap
-    subSelectWithOne: () => Person.select((p) => p.friends.select((f) => ({ name: f.name, hobby: f.hobby })))
-        .where((p) => p.equals(entity('p1')))
-        .one(),
-    // selectAll() on sub-select plural
-    subSelectAllPlural: () => Person.select((p) => p.friends.selectAll()),
-    // selectAll() on sub-select singular
-    subSelectAllSingular: () => Person.select((p) => p.bestFriend.selectAll()),
-    // Employee sub-select (inheritance)
-    employeeSubSelect: () => Employee.select((e) => e.bestFriend.select((bf) => ({ name: bf.name, dept: bf.department }))),
-    // --- MINUS pattern tests ---
-    // Exclude by shape type
-    minusShape: () => Person.select((p) => p.name).minus(Employee),
-    // Exclude by condition
-    minusCondition: () => Person.select((p) => p.name).minus((p) => p.hobby.equals('Chess')),
-    // Chained MINUS — two separate MINUS blocks
-    minusChained: () => Person.select((p) => p.name).minus(Employee).minus((p) => p.hobby.equals('Chess')),
-    // MINUS multi-property — exclude where ALL listed properties exist
-    minusMultiProperty: () => Person.select((p) => p.name).minus((p) => [p.hobby, p.nickNames]),
-    // MINUS nested path — exclude where nested property path exists
-    minusNestedPath: () => Person.select((p) => p.name).minus((p) => [p.bestFriend.name]),
-    // MINUS mixed — flat + nested in one call
-    minusMixed: () => Person.select((p) => p.name).minus((p) => [p.hobby, p.bestFriend.name]),
-    // MINUS single property existence (no array, returns raw QBO)
-    minusSingleProperty: () => Person.select((p) => p.name).minus((p) => p.hobby),
-    // --- Bulk delete tests ---
-    // Delete all instances of a shape
-    deleteAll: () => Person.deleteAll(),
-    // Delete with where condition
-    deleteWhere: () => Person.deleteWhere((p) => p.hobby.equals('Chess')),
-    // Builder-chain equivalents for equivalence testing
-    deleteAllBuilder: () => DeleteBuilder.from(Person).all(),
-    deleteWhereBuilder: () => DeleteBuilder.from(Person).where((p) => p.hobby.equals('Chess')),
-    // --- Conditional update tests ---
-    // Update all instances
-    updateForAll: () => Person.update({ hobby: 'Chess' }).forAll(),
-    // Update with where condition
-    updateWhere: () => Person.update({ hobby: 'Archived' }).where((p) => p.hobby.equals('Chess')),
-    // --- Computed expression tests ---
-    // Simple expression: string length
-    exprStrlen: () => Person.select((p) => p.name.strlen()),
-    // Expression with custom key
-    exprCustomKey: () => Person.select((p) => ({ nameLen: p.name.strlen() })),
-    // Expression on nested path
-    exprNestedPath: () => Person.select((p) => p.bestFriend.name.ucase()),
-    // Multiple expressions in array
-    exprMultiple: () => Person.select((p) => [
-        p.name,
-        p.name.strlen(),
-    ]),
-    // --- Mutation expression tests ---
-    // Functional callback update with expression
-    updateExprCallback: () => Dog.update((p) => ({ guardDogLevel: p.guardDogLevel.plus(1) })).for(entity('d1')),
-    // Expression in update with Expr.now()
-    updateExprNow: () => {
-        const { Expr } = require('../expressions/Expr');
-        return Person.update({ birthDate: Expr.now() }).for(entity('p1'));
-    },
-    // --- Traversal expression mutation tests ---
-    // Multi-segment expression ref: p.bestFriend.name.ucase()
-    updateExprTraversal: () => Person.update((p) => ({ hobby: p.bestFriend.name.ucase() })).for(entity('p1')),
-    // Shared traversal: two fields referencing same intermediate (p.bestFriend)
-    updateExprSharedTraversal: () => Person.update((p) => ({
-        name: p.bestFriend.name.ucase(),
-        hobby: p.bestFriend.hobby.lcase(),
-    })).for(entity('p1')),
-    // --- Expression-based WHERE filter tests (Phase 8) ---
-    // Expression WHERE: STRLEN filter
-    whereExprStrlen: () => Person.select((p) => ({ name: p.name })).where(((p) => p.name.strlen().gt(5))),
-    // Expression WHERE: arithmetic
-    whereExprArithmetic: () => Person.select((p) => ({ name: p.name })).where(((p) => p.name.strlen().plus(10).lt(100))),
-    // Expression WHERE: AND chaining on ExpressionNode
-    whereExprAndChain: () => Person.select((p) => ({ name: p.name })).where(((p) => p.name.strlen().gt(5).and(p.name.strlen().lt(20)))),
-    // Expression WHERE: mixed Evaluation .and() with ExpressionNode
-    whereExprMixed: () => Person.select((p) => ({ name: p.name })).where((p) => p.name.equals('Bob').and(p.name.strlen().gt(3))),
-    // Expression WHERE on UpdateBuilder
-    whereExprUpdateBuilder: () => Person.update({ hobby: 'Archived' }).where(((p) => p.name.strlen().gt(3))),
-    // Expression WHERE on DeleteBuilder
-    whereExprDeleteBuilder: () => DeleteBuilder.from(Person).where(((p) => p.name.strlen().gt(3))),
-    // Expression WHERE with nested path traversal
-    whereExprNestedPath: () => Person.select((p) => ({ name: p.name })).where(((p) => p.bestFriend.name.strlen().gt(3))),
-    // Expression WHERE combined with expression projection
-    whereExprWithProjection: () => Person.select((p) => ({
-        name: p.name,
-        nameLen: p.name.strlen(),
-    })).where(((p) => p.name.strlen().gt(2))),
-};
-//# sourceMappingURL=query-fixtures.js.map