@cardstack/boxel-cli 0.13.0-unstable.4 → 0.13.0-unstable.5

package/bundled-test-harness/assets/realm-querying-test-Cj1ekZ0H.js

@@ -1,1067 +0,0 @@
-import { s as __toESM } from "./chunk-Rp0pCe6z.js";
-import { Br as testRealmURL } from "./runtime-common-BTaLJEw-.js";
-import { a as RealmPaths } from "./paths-C9-NYXnM.js";
-import { D as baseRRI, w as baseCardRef } from "./constants-Icc0nFW-.js";
-import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
-import { F as setupLocalIndexing, L as setupRealmCacheTeardown, M as setupCardLogs, P as setupIntegrationTestRealm, V as testModuleRRI, Z as withCachedRealmSetup, lt as setupRenderingTest, t as setupMockMatrix } from "./mock-matrix-Dd8k0DNa.js";
-import { r as getService } from "./dist-CPfIHBla.js";
-import { t as searchCardsForTest } from "./search-cards-DxcB56HL.js";
-//#region tests/integration/realm-querying-test.gts
-var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
-var paths = new RealmPaths(new URL(testRealmURL));
-var loader;
-(0, import_qunit.module)(`Integration | realm querying`, function(hooks) {
-	setupRenderingTest(hooks);
-	hooks.beforeEach(function() {
-		loader = getService("loader-service").loader;
-	});
-	setupLocalIndexing(hooks);
-	let mockMatrixUtils = setupMockMatrix(hooks);
-	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
-	const sampleCards = {
-		"card-1.json": { data: {
-			type: "card",
-			attributes: {
-				cardTitle: "Card 1",
-				cardDescription: "Sample post",
-				author: {
-					firstName: "Cardy",
-					lastName: "Stackington Jr. III"
-				},
-				views: 0
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("article"),
-				name: "Article"
-			} }
-		} },
-		"card-2.json": { data: {
-			type: "card",
-			attributes: {
-				author: {
-					firstName: "Cardy",
-					lastName: "Jones"
-				},
-				editions: 10,
-				pubDate: "2023-09-01"
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("book"),
-				name: "Book"
-			} }
-		} },
-		"cards/1.json": { data: {
-			type: "card",
-			attributes: {
-				cardTitle: "Card 1",
-				cardDescription: "Sample post",
-				author: {
-					firstName: "Carl",
-					lastName: "Stack",
-					posts: 1
-				},
-				createdAt: new Date(2022, 7, 1),
-				views: 10
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("post"),
-				name: "Post"
-			} }
-		} },
-		"cards/2.json": { data: {
-			type: "card",
-			attributes: {
-				cardTitle: "Card 2",
-				cardDescription: "Sample post",
-				author: {
-					firstName: "Carl",
-					lastName: "Deck",
-					posts: 3
-				},
-				createdAt: new Date(2022, 7, 22),
-				views: 5
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("article"),
-				name: "Article"
-			} }
-		} },
-		"books/1.json": { data: {
-			type: "card",
-			attributes: {
-				author: {
-					firstName: "Mango",
-					lastName: "Abdel-Rahman"
-				},
-				editions: 10,
-				pubDate: "2022-07-01"
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("book"),
-				name: "Book"
-			} }
-		} },
-		"books/2.json": { data: {
-			type: "card",
-			attributes: {
-				author: {
-					firstName: "Van Gogh",
-					lastName: "Abdel-Rahman"
-				},
-				editions: 3,
-				pubDate: "2023-08-01"
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("book"),
-				name: "Book"
-			} }
-		} },
-		"books/3.json": { data: {
-			type: "card",
-			attributes: {
-				author: {
-					firstName: "Jackie",
-					lastName: "Aguilar"
-				},
-				editions: 200,
-				pubDate: "2022-08-01"
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("book"),
-				name: "Book"
-			} }
-		} },
-		"spec-1.json": { data: {
-			type: "card",
-			attributes: {
-				cardTitle: "Post",
-				cardDescription: "A card that represents a blog post",
-				specType: "card",
-				ref: {
-					module: testModuleRRI("post"),
-					name: "Post"
-				}
-			},
-			meta: { adoptsFrom: {
-				module: baseRRI("spec"),
-				name: "Spec"
-			} }
-		} },
-		"spec-2.json": { data: {
-			type: "card",
-			attributes: {
-				cardTitle: "Article",
-				cardDescription: "A card that represents an online article ",
-				specType: "card",
-				ref: {
-					module: testModuleRRI("article"),
-					name: "Article"
-				}
-			},
-			meta: { adoptsFrom: {
-				module: baseRRI("spec"),
-				name: "Spec"
-			} }
-		} },
-		"event-1.json": { data: {
-			type: "card",
-			attributes: {
-				cardTitle: "Mango's Birthday",
-				venue: "Dog Park",
-				date: "2024-10-30"
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("event"),
-				name: "Event"
-			} }
-		} },
-		"event-2.json": { data: {
-			type: "card",
-			attributes: {
-				cardTitle: "Van Gogh's Birthday",
-				venue: "Backyard",
-				date: "2024-11-19"
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("event"),
-				name: "Event"
-			} }
-		} },
-		"mango.json": { data: {
-			type: "card",
-			attributes: {
-				firstName: "Mango",
-				numberOfTreats: ["one", "two"]
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("dog"),
-				name: "Dog"
-			} }
-		} },
-		"ringo.json": { data: {
-			type: "card",
-			attributes: {
-				firstName: "Ringo",
-				numberOfTreats: ["three", "five"]
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("dog"),
-				name: "Dog"
-			} }
-		} },
-		"vangogh.json": { data: {
-			type: "card",
-			attributes: {
-				firstName: "Van Gogh",
-				numberOfTreats: ["two", "nine"]
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("dog"),
-				name: "Dog"
-			} }
-		} },
-		"friend1.json": { data: {
-			type: "card",
-			attributes: { firstName: "Hassan" },
-			relationships: { friend: { links: { self: `${paths.url}friend2` } } },
-			meta: { adoptsFrom: {
-				module: testModuleRRI("friend"),
-				name: "Friend"
-			} }
-		} },
-		"friend2.json": { data: {
-			type: "card",
-			attributes: { firstName: "Mango" },
-			relationships: { friend: { links: { self: null } } },
-			meta: { adoptsFrom: {
-				module: testModuleRRI("friend"),
-				name: "Friend"
-			} }
-		} },
-		"booking1.json": { data: {
-			type: "card",
-			attributes: {
-				hosts: [{ firstName: "Arthur" }, {
-					firstName: "Ed",
-					lastName: "Faulkner"
-				}],
-				sponsors: ["Sony", "Nintendo"],
-				posts: [{
-					cardTitle: "post 1",
-					author: {
-						firstName: "A",
-						lastName: null,
-						posts: 10
-					},
-					views: 16
-				}]
-			},
-			relationships: {},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("booking"),
-				name: "Booking"
-			} }
-		} },
-		"booking2.json": { data: {
-			type: "card",
-			attributes: {
-				hosts: [{
-					firstName: "Arthur",
-					lastName: "Faulkner"
-				}],
-				sponsors: null,
-				posts: [
-					{
-						cardTitle: "post 1",
-						author: {
-							firstName: "A",
-							lastName: "B",
-							posts: 5
-						},
-						views: 10
-					},
-					{
-						cardTitle: "post 2",
-						author: {
-							firstName: "C",
-							lastName: "D",
-							posts: 11
-						},
-						views: 13
-					},
-					{
-						cardTitle: "post 2",
-						author: {
-							firstName: "C",
-							lastName: "D",
-							posts: 2
-						},
-						views: 0
-					}
-				]
-			},
-			relationships: {},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("booking"),
-				name: "Booking"
-			} }
-		} },
-		"person-card1.json": { data: {
-			type: "card",
-			attributes: {
-				firstName: "Person",
-				lastName: "Card 1"
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("person"),
-				name: "Person"
-			} }
-		} },
-		"person-card2.json": { data: {
-			type: "card",
-			attributes: {
-				firstName: "Person",
-				lastName: "Card 2"
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("person"),
-				name: "Person"
-			} }
-		} },
-		"larry.json": { data: {
-			type: "card",
-			attributes: { firstName: "Larry" },
-			relationships: {
-				"friends.0": { links: { self: "./missing" } },
-				"friends.1": { links: { self: "./empty" } }
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("friends"),
-				name: "Friends"
-			} }
-		} },
-		"missing.json": { data: {
-			type: "card",
-			attributes: { firstName: "Missing" },
-			meta: { adoptsFrom: {
-				module: testModuleRRI("friends"),
-				name: "Friends"
-			} }
-		} },
-		"empty.json": { data: {
-			type: "card",
-			attributes: { firstName: "Empty" },
-			relationships: { "friends.0": { links: { self: null } } },
-			meta: { adoptsFrom: {
-				module: testModuleRRI("friends"),
-				name: "Friends"
-			} }
-		} },
-		"bob.json": { data: {
-			type: "card",
-			attributes: {
-				stringField: "Bob",
-				stringArrayField: [
-					"blue",
-					"tree",
-					"carrot"
-				]
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("type-examples"),
-				name: "TypeExamples"
-			} }
-		} },
-		"alicia.json": { data: {
-			type: "card",
-			attributes: {
-				stringField: "Alicia",
-				stringArrayField: null
-			},
-			meta: { adoptsFrom: {
-				module: testModuleRRI("type-examples"),
-				name: "TypeExamples"
-			} }
-		} },
-		"margaret.json": { data: {
-			type: "card",
-			attributes: { stringField: "Margaret" },
-			meta: { adoptsFrom: {
-				module: testModuleRRI("type-examples"),
-				name: "TypeExamples"
-			} }
-		} },
-		"noname.json": { data: {
-			type: "card",
-			attributes: { stringArrayField: ["happy", "green"] },
-			meta: { adoptsFrom: {
-				module: testModuleRRI("type-examples"),
-				name: "TypeExamples"
-			} }
-		} }
-	};
-	let queryEngine;
-	setupRealmCacheTeardown(hooks);
-	hooks.beforeEach(async function() {
-		let { realm } = await withCachedRealmSetup(async () => setupIntegrationTestRealm({
-			mockMatrixUtils,
-			contents: {
-				...sampleCards,
-				"files/sample.txt": "Hello world",
-				"files/sample.md": "Hello markdown",
-				"file-query-card-instance.json": { data: {
-					type: "card",
-					attributes: { nameFilter: "" },
-					meta: { adoptsFrom: {
-						module: testModuleRRI("file-query-card"),
-						name: "FileQueryCard"
-					} }
-				} }
-			}
-		}));
-		queryEngine = realm.realmIndexQueryEngine;
-	});
-	(0, import_qunit.test)(`can search for cards by using the 'eq' filter`, async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("post"),
-				name: "Post"
-			},
-			eq: {
-				cardTitle: "Card 1",
-				cardDescription: "Sample post"
-			}
-		} });
-		assert.deepEqual(matching.map((m) => m.id), [`${paths.url}card-1`, `${paths.url}cards/1`]);
-	});
-	(0, import_qunit.test)(`can use 'eq' to find empty values`, async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("booking"),
-				name: "Booking"
-			},
-			eq: { "posts.author.lastName": null }
-		} });
-		assert.deepEqual(matching.map((m) => m.id), [`${testRealmURL}booking1`]);
-	});
-	(0, import_qunit.test)(`can use 'eq' to find missing values`, async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("type-examples"),
-				name: "TypeExamples"
-			},
-			eq: { stringField: null }
-		} });
-		assert.deepEqual(matching.map((m) => m.id), [`${testRealmURL}noname`]);
-	});
-	(0, import_qunit.test)(`can use 'eq' to find empty containsMany field and missing containsMany field`, async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("type-examples"),
-				name: "TypeExamples"
-			},
-			eq: { stringArrayField: null }
-		} });
-		assert.deepEqual(matching.map((m) => m.id), [`${testRealmURL}alicia`, `${testRealmURL}margaret`]);
-	});
-	(0, import_qunit.test)(`can use 'eq' to find empty linksToMany field and missing linksToMany field`, async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("friends"),
-				name: "Friends"
-			},
-			eq: { friends: null }
-		} });
-		assert.deepEqual(matching.map((m) => m.id), [`${testRealmURL}empty`, `${testRealmURL}missing`]);
-	});
-	(0, import_qunit.test)(`can use 'eq' to find empty linksTo field`, async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("friend"),
-				name: "Friend"
-			},
-			every: [{ eq: { firstName: "Mango" } }, { eq: { friend: null } }]
-		} });
-		assert.deepEqual(matching.map((m) => m.id), [`${testRealmURL}friend2`]);
-	});
-	(0, import_qunit.test)(`can search for cards by using a computed field`, async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("post"),
-				name: "Post"
-			},
-			eq: { "author.fullName": "Carl Stack" }
-		} });
-		assert.deepEqual(matching.map((m) => m.id), [`${paths.url}cards/1`]);
-	});
-	(0, import_qunit.test)("can search for cards by using a linksTo field", async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("friend"),
-				name: "Friend"
-			},
-			eq: { "friend.firstName": "Mango" }
-		} });
-		assert.deepEqual(matching.map((m) => m.id), [`${paths.url}friend1`]);
-	});
-	(0, import_qunit.test)(`can search for cards that have code-ref queryableValue`, async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: baseRRI("spec"),
-				name: "Spec"
-			},
-			eq: { ref: {
-				module: testModuleRRI("post"),
-				name: "Post"
-			} }
-		} });
-		assert.deepEqual(matching.map((m) => m.id), [`${paths.url}spec-1`]);
-	});
-	(0, import_qunit.test)("can search for file-meta entries by FileDef type", async function(assert) {
-		let fileDefRef = {
-			module: baseRRI("card-api"),
-			name: "FileDef"
-		};
-		let fileEntry = (await searchCardsForTest(queryEngine, { filter: { type: fileDefRef } })).data.find((entry) => entry.id === `${testRealmURL}files/sample.txt`);
-		assert.ok(fileEntry, "file-meta entry is returned");
-		assert.strictEqual(fileEntry?.type, "file-meta", "search results include file-meta resource");
-	});
-	(0, import_qunit.test)("can search for file-meta entries by url", async function(assert) {
-		let fileDefRef = {
-			module: baseRRI("card-api"),
-			name: "FileDef"
-		};
-		let targetUrl = `${testRealmURL}files/sample.txt`;
-		let result = await searchCardsForTest(queryEngine, { filter: {
-			on: fileDefRef,
-			eq: { url: targetUrl }
-		} });
-		assert.deepEqual(result.data.map((entry) => entry.id), [targetUrl], "filters file-meta entries by url");
-		assert.strictEqual(result.data[0]?.type, "file-meta", "url filter returns file-meta resource");
-	});
-	(0, import_qunit.test)("can search for file-meta entries by FileDef subclass type", async function(assert) {
-		let markdownRef = {
-			module: baseRRI("markdown-file-def"),
-			name: "MarkdownDef"
-		};
-		let result = await searchCardsForTest(queryEngine, { filter: { type: markdownRef } });
-		assert.ok(result.data.some((entry) => entry.id === `${testRealmURL}files/sample.md`), "returns file-meta entries for subclass FileDef type");
-	});
-	(0, import_qunit.test)("can combine multiple filters", async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("post"),
-				name: "Post"
-			},
-			every: [{ eq: { cardTitle: "Card 1" } }, { not: { eq: { "author.firstName": "Cardy" } } }]
-		} });
-		assert.strictEqual(matching.length, 1);
-		assert.strictEqual(matching[0]?.id, `${testRealmURL}cards/1`);
-	});
-	(0, import_qunit.test)("can handle a filter with double negatives", async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("post"),
-				name: "Post"
-			},
-			not: { not: { not: { eq: { "author.firstName": "Carl" } } } }
-		} });
-		assert.deepEqual(matching.map((m) => m.id), [`${paths.url}card-1`]);
-	});
-	(0, import_qunit.test)("can filter by card type", async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: { type: {
-			module: testModuleRRI("article"),
-			name: "Article"
-		} } });
-		assert.deepEqual(matching.map((m) => m.id), [`${paths.url}card-1`, `${paths.url}cards/2`], "found cards of type Article");
-		matching = (await searchCardsForTest(queryEngine, { filter: { type: {
-			module: testModuleRRI("post"),
-			name: "Post"
-		} } })).data;
-		assert.deepEqual(matching.map((m) => m.id), [
-			`${paths.url}card-1`,
-			`${paths.url}cards/1`,
-			`${paths.url}cards/2`
-		], "found cards of type Post");
-	});
-	(0, import_qunit.test)(`can filter on a card's own fields using range`, async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("post"),
-				name: "Post"
-			},
-			range: {
-				views: {
-					lte: 10,
-					gt: 5
-				},
-				"author.posts": { gte: 1 }
-			}
-		} });
-		assert.deepEqual(matching.map((m) => m.id), [`${paths.url}cards/1`]);
-	});
-	(0, import_qunit.test)(`can filter on a nested field inside a containsMany using 'range'`, async function(assert) {
-		{
-			let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-				on: {
-					module: testModuleRRI("booking"),
-					name: "Booking"
-				},
-				range: {
-					"posts.views": {
-						gt: 10,
-						lte: 16
-					},
-					"posts.author.posts": {
-						gte: 5,
-						lt: 10
-					}
-				}
-			} });
-			assert.deepEqual(matching.map((m) => m.id), [`${paths.url}booking2`]);
-		}
-		{
-			let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-				on: {
-					module: testModuleRRI("booking"),
-					name: "Booking"
-				},
-				range: { "posts.views": { lte: 0 } }
-			} });
-			assert.deepEqual(matching.map((m) => m.id), [`${paths.url}booking2`]);
-		}
-	});
-	(0, import_qunit.test)("can use an eq filter with a date field", async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("event"),
-				name: "Event"
-			},
-			eq: { date: "2024-10-30" }
-		} });
-		assert.deepEqual(matching.map((m) => m.id), [`${paths.url}event-1`]);
-	});
-	(0, import_qunit.test)(`can filter on a nested field using 'eq'`, async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("post"),
-				name: "Post"
-			},
-			eq: { "author.firstName": "Carl" }
-		} });
-		assert.deepEqual(matching.map((m) => m.id), [`${paths.url}cards/1`, `${paths.url}cards/2`]);
-	});
-	(0, import_qunit.test)(`can filter on a nested field inside a containsMany using 'eq'`, async function(assert) {
-		{
-			let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-				on: {
-					module: testModuleRRI("booking"),
-					name: "Booking"
-				},
-				eq: { "hosts.firstName": "Arthur" }
-			} });
-			assert.deepEqual(matching.map((m) => m.id), [`${paths.url}booking1`, `${paths.url}booking2`], "eq on hosts.firstName");
-		}
-		{
-			let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-				on: {
-					module: testModuleRRI("booking"),
-					name: "Booking"
-				},
-				eq: { "hosts.firstName": null }
-			} });
-			assert.strictEqual(matching.length, 0, "eq on null hosts.firstName");
-		}
-		{
-			let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-				on: {
-					module: testModuleRRI("booking"),
-					name: "Booking"
-				},
-				eq: {
-					"posts.author.firstName": "A",
-					"posts.author.lastName": "B"
-				}
-			} });
-			assert.deepEqual(matching.map((m) => m.id), [`${paths.url}booking2`], "eq on posts.author.firstName and posts.author.lastName");
-		}
-		{
-			let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-				on: {
-					module: testModuleRRI("booking"),
-					name: "Booking"
-				},
-				eq: {
-					"hosts.firstName": "Arthur",
-					"posts.author.lastName": null
-				}
-			} });
-			assert.deepEqual(matching.map((m) => m.id), [`${paths.url}booking1`], "eq on hosts.firstName, posts.author.firstName, and null posts.author.lastName");
-		}
-	});
-	(0, import_qunit.test)(`can filter on an array of primitive fields inside a containsMany using 'eq'`, async function(assert) {
-		{
-			let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-				on: {
-					module: testModuleRRI("booking"),
-					name: "Booking"
-				},
-				eq: { sponsors: "Nintendo" }
-			} });
-			assert.deepEqual(matching.map((m) => m.id), [`${paths.url}booking1`], "eq on sponsors");
-		}
-		{
-			let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-				on: {
-					module: testModuleRRI("booking"),
-					name: "Booking"
-				},
-				eq: { sponsors: "Playstation" }
-			} });
-			assert.strictEqual(matching.length, 0, "eq on nonexisting value in sponsors");
-		}
-		{
-			let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-				on: {
-					module: testModuleRRI("booking"),
-					name: "Booking"
-				},
-				eq: {
-					"hosts.firstName": "Arthur",
-					sponsors: null
-				}
-			} });
-			assert.deepEqual(matching.map((m) => m.id), [`${paths.url}booking2`], "eq on hosts.firstName and null sponsors");
-		}
-	});
-	(0, import_qunit.test)("can negate a filter", async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("article"),
-				name: "Article"
-			},
-			not: { eq: { "author.firstName": "Carl" } }
-		} });
-		assert.deepEqual(matching.map((m) => m.id), [`${testRealmURL}card-1`]);
-	});
-	(0, import_qunit.test)("can combine multiple types", async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: { any: [{
-			on: {
-				module: testModuleRRI("article"),
-				name: "Article"
-			},
-			eq: { "author.firstName": "Cardy" }
-		}, {
-			on: {
-				module: testModuleRRI("book"),
-				name: "Book"
-			},
-			eq: { "author.firstName": "Cardy" }
-		}] } });
-		assert.deepEqual(matching.map((m) => m.id), [`${paths.url}card-1`, `${paths.url}card-2`]);
-	});
-	(0, import_qunit.test)("can sort in alphabetical order", async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, {
-			sort: [{
-				by: "author.lastName",
-				on: {
-					module: testModuleRRI("article"),
-					name: "Article"
-				}
-			}],
-			filter: { type: {
-				module: testModuleRRI("article"),
-				name: "Article"
-			} }
-		});
-		assert.deepEqual(matching.map((m) => m.id), [`${paths.url}cards/2`, `${paths.url}card-1`]);
-	});
-	(0, import_qunit.test)("can sort in reverse alphabetical order", async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, {
-			sort: [{
-				by: "author.firstName",
-				on: {
-					module: testModuleRRI("article"),
-					name: "Article"
-				},
-				direction: "desc"
-			}],
-			filter: { type: {
-				module: testModuleRRI("post"),
-				name: "Post"
-			} }
-		});
-		assert.deepEqual(matching.map((m) => m.id), [
-			`${paths.url}cards/1`,
-			`${paths.url}cards/2`,
-			`${paths.url}card-1`
-		]);
-	});
-	(0, import_qunit.test)("can sort by card display name (card type shown in the interface)", async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, {
-			filter: { type: baseCardRef },
-			sort: [{
-				on: baseCardRef,
-				by: "_cardType"
-			}]
-		});
-		assert.deepEqual(matching.map((m) => m.id), [
-			`${paths.url}card-1`,
-			`${paths.url}cards/2`,
-			`${paths.url}books/1`,
-			`${paths.url}books/2`,
-			`${paths.url}books/3`,
-			`${paths.url}card-2`,
-			`${paths.url}booking1`,
-			`${paths.url}booking2`,
-			`${paths.url}mango`,
-			`${paths.url}ringo`,
-			`${paths.url}vangogh`,
-			`${paths.url}event-1`,
-			`${paths.url}event-2`,
-			`${paths.url}file-query-card-instance`,
-			`${paths.url}friend1`,
-			`${paths.url}friend2`,
-			`${paths.url}empty`,
-			`${paths.url}larry`,
-			`${paths.url}missing`,
-			`${paths.url}person-card1`,
-			`${paths.url}person-card2`,
-			`${paths.url}cards/1`,
-			`${paths.url}spec-1`,
-			`${paths.url}spec-2`,
-			`${paths.url}alicia`,
-			`${paths.url}bob`,
-			`${paths.url}margaret`,
-			`${paths.url}noname`
-		]);
-	});
-	(0, import_qunit.test)("can sort by multiple string field conditions in given directions", async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, {
-			sort: [{
-				by: "author.lastName",
-				on: {
-					module: testModuleRRI("book"),
-					name: "Book"
-				},
-				direction: "asc"
-			}, {
-				by: "author.firstName",
-				on: {
-					module: testModuleRRI("book"),
-					name: "Book"
-				},
-				direction: "desc"
-			}],
-			filter: { type: {
-				module: testModuleRRI("book"),
-				name: "Book"
-			} }
-		});
-		assert.deepEqual(matching.map((m) => m.id), [
-			`${paths.url}books/2`,
-			`${paths.url}books/1`,
-			`${paths.url}books/3`,
-			`${paths.url}card-2`
-		]);
-	});
-	(0, import_qunit.test)("can sort by number value", async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, {
-			sort: [{
-				by: "editions",
-				on: {
-					module: testModuleRRI("book"),
-					name: "Book"
-				}
-			}, {
-				by: "author.lastName",
-				on: {
-					module: testModuleRRI("book"),
-					name: "Book"
-				}
-			}],
-			filter: { type: {
-				module: testModuleRRI("book"),
-				name: "Book"
-			} }
-		});
-		assert.deepEqual(matching.map((m) => m.id), [
-			`${paths.url}books/2`,
-			`${paths.url}books/1`,
-			`${paths.url}card-2`,
-			`${paths.url}books/3`
-		]);
-	});
-	(0, import_qunit.test)("can sort by date", async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, {
-			sort: [{
-				by: "pubDate",
-				on: {
-					module: testModuleRRI("book"),
-					name: "Book"
-				}
-			}],
-			filter: { type: {
-				module: testModuleRRI("book"),
-				name: "Book"
-			} }
-		});
-		assert.deepEqual(matching.map((m) => m.id), [
-			`${paths.url}books/1`,
-			`${paths.url}books/3`,
-			`${paths.url}books/2`,
-			`${paths.url}card-2`
-		]);
-	});
-	(0, import_qunit.test)("can sort by mixed field types", async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, {
-			sort: [{
-				by: "editions",
-				on: {
-					module: testModuleRRI("book"),
-					name: "Book"
-				},
-				direction: "desc"
-			}, {
-				by: "author.lastName",
-				on: {
-					module: testModuleRRI("book"),
-					name: "Book"
-				}
-			}],
-			filter: { type: {
-				module: testModuleRRI("book"),
-				name: "Book"
-			} }
-		});
-		assert.deepEqual(matching.map((m) => m.id), [
-			`${paths.url}books/3`,
-			`${paths.url}books/1`,
-			`${paths.url}card-2`,
-			`${paths.url}books/2`
-		]);
-	});
-	(0, import_qunit.test)(`can sort on multiple paths in combination with 'any' filter`, async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, {
-			sort: [{
-				by: "author.lastName",
-				on: {
-					module: testModuleRRI("book"),
-					name: "Book"
-				}
-			}, {
-				by: "author.firstName",
-				on: {
-					module: testModuleRRI("book"),
-					name: "Book"
-				},
-				direction: "desc"
-			}],
-			filter: { any: [{ type: {
-				module: testModuleRRI("book"),
-				name: "Book"
-			} }, { type: {
-				module: testModuleRRI("article"),
-				name: "Article"
-			} }] }
-		});
-		assert.deepEqual(matching.map((m) => m.id), [
-			`${paths.url}books/2`,
-			`${paths.url}books/1`,
-			`${paths.url}books/3`,
-			`${paths.url}cards/2`,
-			`${paths.url}card-2`,
-			`${paths.url}card-1`
-		]);
-	});
-	(0, import_qunit.test)(`can sort on multiple paths in combination with 'every' filter`, async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, {
-			sort: [{
-				by: "author.firstName",
-				on: {
-					module: testModuleRRI("book"),
-					name: "Book"
-				},
-				direction: "desc"
-			}],
-			filter: { every: [{
-				on: {
-					module: testModuleRRI("book"),
-					name: "Book"
-				},
-				not: { eq: { "author.lastName": "Aguilar" } }
-			}, {
-				on: {
-					module: testModuleRRI("book"),
-					name: "Book"
-				},
-				eq: { editions: 10 }
-			}] }
-		});
-		assert.deepEqual(matching.map((m) => m.id), [`${paths.url}books/1`, `${paths.url}card-2`]);
-	});
-	(0, import_qunit.test)(`can search for cards by using the 'contains' filter`, async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: { contains: { cardTitle: "ca" } } });
-		assert.strictEqual(matching.length, 6);
-		assert.deepEqual(matching.map((m) => m.id), [
-			`${paths.url}card-1`,
-			`${paths.url}cards/1`,
-			`${paths.url}cards/2`,
-			`${paths.url}file-query-card-instance`,
-			`${paths.url}person-card1`,
-			`${paths.url}person-card2`
-		]);
-	});
-	(0, import_qunit.test)(`can search on specific card by using 'contains' filter`, async function(assert) {
-		let { data: personMatchingByTitle } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("person"),
-				name: "Person"
-			},
-			contains: { cardTitle: "ca" }
-		} });
-		assert.strictEqual(personMatchingByTitle.length, 2);
-		assert.deepEqual(personMatchingByTitle.map((m) => m.id), [`${paths.url}person-card1`, `${paths.url}person-card2`]);
-		let { data: dogMatchingByFirstName } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("dog"),
-				name: "Dog"
-			},
-			contains: { firstName: "go" }
-		} });
-		assert.strictEqual(dogMatchingByFirstName.length, 3);
-		assert.deepEqual(dogMatchingByFirstName.map((m) => m.id), [
-			`${paths.url}mango`,
-			`${paths.url}ringo`,
-			`${paths.url}vangogh`
-		]);
-	});
-	(0, import_qunit.test)(`can use 'contains' filter to find 'null' values`, async function(assert) {
-		let { data: matching } = await searchCardsForTest(queryEngine, { filter: {
-			on: {
-				module: testModuleRRI("dog"),
-				name: "Dog"
-			},
-			contains: { cardTitle: null }
-		} });
-		assert.strictEqual(matching.length, 3);
-	});
-	(0, import_qunit.test)("query field with linksToMany(FileDef) populates file-meta relationships", async function(assert) {
-		let result = await queryEngine.cardDocument(new URL(`${testRealmURL}file-query-card-instance`), { loadLinks: true });
-		assert.strictEqual(result?.type, "doc", "result is a doc");
-		let { data } = result.doc;
-		let relationships = data.relationships ?? {};
-		let matchingFiles = relationships["matchingFiles"];
-		assert.ok(matchingFiles, "matchingFiles relationship exists");
-		assert.ok(Array.isArray(matchingFiles?.data), "matchingFiles has a data array");
-		assert.ok((matchingFiles?.data?.length ?? 0) >= 2, "matchingFiles contains at least 2 file results");
-		for (let entry of matchingFiles?.data ?? []) assert.strictEqual(entry.type, "file-meta", `relationship data entry ${entry.id} has type file-meta`);
-		let indexedKeys = Object.keys(relationships).filter((k) => k.startsWith("matchingFiles."));
-		assert.ok(indexedKeys.length >= 2, "individual file relationships are present");
-		for (let key of indexedKeys) {
-			let rel = relationships[key];
-			assert.strictEqual(rel?.data?.type, "file-meta", `${key} relationship data has type file-meta`);
-		}
-	});
-});
-//#endregion