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

package/bundled-test-harness/assets/ai-function-generation-test-Dj6WzKkh.js

@@ -0,0 +1,1176 @@
+import { s as __toESM } from "./chunk-Rp0pCe6z.js";
+import { r as initializeDeferredDecorator, t as decorateFieldV2 } from "./runtime--fcdnjmJ-BoCBNIsz.js";
+import { i as generateJsonSchemaForCardType, r as basicMappings } from "./ai-BFUROO-8.js";
+import { t as require_qunit } from "./qunit-C-Foo4Nd.js";
+import { F as setupLocalIndexing, I as setupOnSave, M as setupCardLogs, lt as setupRenderingTest } from "./mock-matrix-FjsXmU7-.js";
+import { r as getService } from "./dist-CPfIHBla.js";
+//#region tests/unit/ai-function-generation-test.ts
+var import_qunit = /* @__PURE__ */ __toESM(require_qunit());
+var cardApi;
+var string;
+var number;
+var biginteger;
+var date;
+var datetime;
+var boolean;
+var enumModule;
+var primitive;
+var mappings;
+var loader;
+(0, import_qunit.module)("Unit | ai-function-generation-test", function(hooks) {
+	setupRenderingTest(hooks);
+	hooks.beforeEach(function() {
+		loader = getService("loader-service").loader;
+	});
+	hooks.beforeEach(async function() {
+		cardApi = await loader.import("@cardstack/base/card-api");
+		primitive = cardApi.primitive;
+		string = await loader.import("@cardstack/base/string");
+		number = await loader.import("@cardstack/base/number");
+		biginteger = await loader.import("@cardstack/base/big-integer");
+		date = await loader.import("@cardstack/base/date");
+		datetime = await loader.import("@cardstack/base/datetime");
+		boolean = await loader.import("@cardstack/base/boolean");
+		enumModule = await loader.import("@cardstack/base/enum");
+		mappings = await basicMappings(loader);
+	});
+	setupLocalIndexing(hooks);
+	setupOnSave(hooks);
+	setupCardLogs(hooks, async () => await loader.import("@cardstack/base/card-api"));
+	const cardDefAttributesProperties = { cardInfo: {
+		properties: {
+			summary: { type: "string" },
+			notes: { type: "string" },
+			cardThumbnailURL: { type: "string" },
+			name: { type: "string" }
+		},
+		type: "object"
+	} };
+	const linkedRelationship = {
+		type: "object",
+		properties: { links: {
+			type: "object",
+			properties: { self: { type: "string" } },
+			required: ["self"]
+		} },
+		required: ["links"]
+	};
+	const linksToManyRelationship = {
+		type: "object",
+		properties: { links: {
+			type: "object",
+			properties: { self: { type: "string" } },
+			required: ["self"]
+		} },
+		required: ["links"]
+	};
+	const cardDefRelationshipsProperties = {
+		"cardInfo.cardThumbnail": linkedRelationship,
+		"cardInfo.theme": linkedRelationship
+	};
+	const cardDefRelationships = {
+		type: "object",
+		properties: cardDefRelationshipsProperties
+	};
+	(0, import_qunit.test)(`generates a simple compliant schema for basic types`, async function(assert) {
+		let { field, contains, CardDef } = cardApi;
+		let { default: StringField } = string;
+		let { default: NumberField } = number;
+		let { default: BooleanField } = boolean;
+		let { default: DateField } = date;
+		let { default: DateTimeField } = datetime;
+		let { default: BigIntegerField } = biginteger;
+		class BasicCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "stringField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#stringField = (initializeDeferredDecorator(this, "stringField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "numberField", [field], function() {
+					return contains(NumberField);
+				});
+			}
+			#numberField = (initializeDeferredDecorator(this, "numberField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "booleanField", [field], function() {
+					return contains(BooleanField);
+				});
+			}
+			#booleanField = (initializeDeferredDecorator(this, "booleanField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "dateField", [field], function() {
+					return contains(DateField);
+				});
+			}
+			#dateField = (initializeDeferredDecorator(this, "dateField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "dateTimeField", [field], function() {
+					return contains(DateTimeField);
+				});
+			}
+			#dateTimeField = (initializeDeferredDecorator(this, "dateTimeField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "bigIntegerField", [field], function() {
+					return contains(BigIntegerField);
+				});
+			}
+			#bigIntegerField = (initializeDeferredDecorator(this, "bigIntegerField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(BasicCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					stringField: { type: "string" },
+					numberField: { type: "number" },
+					booleanField: { type: "boolean" },
+					dateField: {
+						type: "string",
+						format: "date"
+					},
+					dateTimeField: {
+						type: "string",
+						format: "date-time"
+					},
+					bigIntegerField: {
+						type: "string",
+						pattern: "^-?[0-9]+$"
+					}
+				}
+			},
+			relationships: cardDefRelationships
+		});
+	});
+	(0, import_qunit.test)(`the query schema declares every filter operator and the relevance sort key`, async function(assert) {
+		let { SearchEntriesInput } = await loader.import("@cardstack/base/commands/search-entry-result");
+		let query = generateJsonSchemaForCardType(SearchEntriesInput, cardApi, mappings).attributes.properties.query;
+		assert.deepEqual(Object.keys(query.properties.filter.properties).sort(), [
+			"any",
+			"contains",
+			"eq",
+			"every",
+			"in",
+			"matches",
+			"not",
+			"on",
+			"range",
+			"type"
+		], "every operator the query grammar accepts is declared");
+		assert.strictEqual(query.properties.filter.properties.matches.type, "string", "matches takes a search string");
+		assert.ok(query.properties.filter.description.includes("at most one operator"), "the filter description states the one-operator rule");
+		assert.ok(query.properties.sort.items.properties.by.description.includes("_matchRelevance"), "the sort key description names _matchRelevance");
+	});
+	(0, import_qunit.test)(`surfaces enumField options as JSON-Schema enum values`, async function(assert) {
+		let { field, contains, CardDef } = cardApi;
+		let { default: StringField } = string;
+		let { default: enumField } = enumModule;
+		const sizeOptions = [{
+			value: "small",
+			label: "Small"
+		}, {
+			value: "large",
+			label: "Large"
+		}];
+		const SizeField = enumField(StringField, { options: sizeOptions });
+		const ShadeField = enumField(StringField, { options: ["light", "dark"] });
+		const DynamicField = enumField(StringField, { options: function() {
+			return sizeOptions;
+		} });
+		class TestCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "size", [field], function() {
+					return contains(SizeField);
+				});
+			}
+			#size = (initializeDeferredDecorator(this, "size"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "shade", [field], function() {
+					return contains(ShadeField);
+				});
+			}
+			#shade = (initializeDeferredDecorator(this, "shade"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "dynamic", [field], function() {
+					return contains(DynamicField);
+				});
+			}
+			#dynamic = (initializeDeferredDecorator(this, "dynamic"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					size: {
+						type: "string",
+						enum: ["small", "large"]
+					},
+					shade: {
+						type: "string",
+						enum: ["light", "dark"]
+					},
+					dynamic: { type: "string" }
+				}
+			},
+			relationships: cardDefRelationships
+		});
+	});
+	(0, import_qunit.test)(`surfaces defaultOptions as description hint (not enum constraint) for function-form enumField config`, async function(assert) {
+		let { field, contains, CardDef } = cardApi;
+		let { default: StringField } = string;
+		let { default: enumField } = enumModule;
+		const richOptions = [{
+			value: "critical",
+			label: "Critical"
+		}, {
+			value: "high",
+			label: "High"
+		}];
+		const RichDefaultField = enumField(StringField, {
+			options: function() {
+				return richOptions;
+			},
+			defaultOptions: richOptions
+		});
+		const BareDefaultField = enumField(StringField, {
+			options: function() {
+				return ["a", "b"];
+			},
+			defaultOptions: ["a", "b"]
+		});
+		const EmptyDefaultField = enumField(StringField, {
+			options: function() {
+				return [];
+			},
+			defaultOptions: []
+		});
+		class TestCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "richDefault", [field], function() {
+					return contains(RichDefaultField);
+				});
+			}
+			#richDefault = (initializeDeferredDecorator(this, "richDefault"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "bareDefault", [field], function() {
+					return contains(BareDefaultField);
+				});
+			}
+			#bareDefault = (initializeDeferredDecorator(this, "bareDefault"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "emptyDefault", [field], function() {
+					return contains(EmptyDefaultField);
+				});
+			}
+			#emptyDefault = (initializeDeferredDecorator(this, "emptyDefault"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					richDefault: {
+						type: "string",
+						description: "Typical values: \"critical\", \"high\"",
+						examples: ["critical", "high"]
+					},
+					bareDefault: {
+						type: "string",
+						description: "Typical values: \"a\", \"b\"",
+						examples: ["a", "b"]
+					},
+					emptyDefault: { type: "string" }
+				}
+			},
+			relationships: cardDefRelationships
+		});
+	});
+	(0, import_qunit.test)(`ignores defaultOptions when options is a static array (emits hard enum, not hint)`, async function(assert) {
+		let { field, contains, CardDef } = cardApi;
+		let { default: StringField } = string;
+		let { default: enumField } = enumModule;
+		const StaticWithDefault = enumField(StringField, {
+			options: ["x", "y"],
+			defaultOptions: ["x", "y"]
+		});
+		class TestCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "staticWithDefault", [field], function() {
+					return contains(StaticWithDefault);
+				});
+			}
+			#staticWithDefault = (initializeDeferredDecorator(this, "staticWithDefault"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					staticWithDefault: {
+						type: "string",
+						enum: ["x", "y"]
+					}
+				}
+			},
+			relationships: cardDefRelationships
+		});
+	});
+	(0, import_qunit.test)(`omits enum for function-form enumField config with no defaultOptions`, async function(assert) {
+		let { field, contains, CardDef } = cardApi;
+		let { default: StringField } = string;
+		let { default: enumField } = enumModule;
+		const NoDefaultField = enumField(StringField, { options: function() {
+			return ["x", "y"];
+		} });
+		class TestCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "noDefault", [field], function() {
+					return contains(NoDefaultField);
+				});
+			}
+			#noDefault = (initializeDeferredDecorator(this, "noDefault"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					noDefault: { type: "string" }
+				}
+			},
+			relationships: cardDefRelationships
+		});
+	});
+	(0, import_qunit.test)(`generates a simple compliant schema for nested types`, async function(assert) {
+		let { field, contains, linksTo, linksToMany, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class InnerCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class InternalField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCard", [field], function() {
+					return linksTo(InnerCard);
+				});
+			}
+			#linkedCard = (initializeDeferredDecorator(this, "linkedCard"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCards", [field], function() {
+					return linksToMany(InnerCard);
+				});
+			}
+			#linkedCards = (initializeDeferredDecorator(this, "linkedCards"), void 0);
+		}
+		class BasicCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "containerField", [field], function() {
+					return contains(InternalField);
+				});
+			}
+			#containerField = (initializeDeferredDecorator(this, "containerField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(BasicCard, cardApi, mappings);
+		const links = {
+			type: "object",
+			properties: { self: { type: "string" } },
+			required: ["self"]
+		};
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					containerField: {
+						type: "object",
+						properties: { innerStringField: { type: "string" } }
+					}
+				}
+			},
+			relationships: {
+				type: "object",
+				properties: {
+					"containerField.linkedCard": {
+						type: "object",
+						properties: { links },
+						required: ["links"]
+					},
+					"containerField.linkedCards": {
+						type: "array",
+						items: {
+							type: "object",
+							properties: { links },
+							required: ["links"]
+						}
+					},
+					...cardDefRelationshipsProperties
+				}
+			}
+		});
+	});
+	(0, import_qunit.test)(`should support contains many`, async function(assert) {
+		let { field, contains, containsMany, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class InternalField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return containsMany(StringField);
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+		}
+		class TestCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "containerField", [field], function() {
+					return contains(InternalField);
+				});
+			}
+			#containerField = (initializeDeferredDecorator(this, "containerField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					containerField: {
+						type: "object",
+						properties: { innerStringField: {
+							type: "array",
+							items: { type: "string" }
+						} }
+					}
+				}
+			},
+			relationships: cardDefRelationships
+		});
+	});
+	(0, import_qunit.test)(`should support linksTo`, async function(assert) {
+		let { field, contains, linksTo, CardDef } = cardApi;
+		let { default: StringField } = string;
+		class OtherCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+		}
+		class TestCard extends CardDef {
+			static displayName = "TestCard";
+			static {
+				decorateFieldV2(this.prototype, "linkedCard", [field], function() {
+					return linksTo(OtherCard);
+				});
+			}
+			#linkedCard = (initializeDeferredDecorator(this, "linkedCard"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "simpleField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#simpleField = (initializeDeferredDecorator(this, "simpleField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCard2", [field], function() {
+					return linksTo(OtherCard);
+				});
+			}
+			#linkedCard2 = (initializeDeferredDecorator(this, "linkedCard2"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		let attributes = {
+			type: "object",
+			properties: {
+				simpleField: { type: "string" },
+				...cardDefAttributesProperties
+			}
+		};
+		let relationships = {
+			type: "object",
+			properties: {
+				linkedCard: linkedRelationship,
+				linkedCard2: linkedRelationship,
+				...cardDefRelationshipsProperties
+			}
+		};
+		assert.deepEqual(schema, {
+			attributes,
+			relationships
+		});
+	});
+	(0, import_qunit.test)(`should support linksToMany`, async function(assert) {
+		let { field, contains, linksToMany, CardDef } = cardApi;
+		let { default: StringField } = string;
+		class OtherCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+		}
+		class TestCard extends CardDef {
+			static displayName = "TestCard";
+			static {
+				decorateFieldV2(this.prototype, "simpleField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#simpleField = (initializeDeferredDecorator(this, "simpleField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCards", [field], function() {
+					return linksToMany(OtherCard);
+				});
+			}
+			#linkedCards = (initializeDeferredDecorator(this, "linkedCards"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		let attributes = {
+			type: "object",
+			properties: {
+				simpleField: { type: "string" },
+				...cardDefAttributesProperties
+			}
+		};
+		let relationships = {
+			type: "object",
+			properties: {
+				linkedCards: {
+					type: "array",
+					items: linksToManyRelationship
+				},
+				...cardDefRelationshipsProperties
+			}
+		};
+		assert.deepEqual(schema, {
+			attributes,
+			relationships
+		});
+	});
+	(0, import_qunit.test)(`supports deeply nested fields`, async function(assert) {
+		let { field, contains, linksTo, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class PetCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class FriendField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "pet", [field], function() {
+					return linksTo(PetCard);
+				});
+			}
+			#pet = (initializeDeferredDecorator(this, "pet"), void 0);
+		}
+		class ChildField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "friend", [field], function() {
+					return contains(FriendField);
+				});
+			}
+			#friend = (initializeDeferredDecorator(this, "friend"), void 0);
+		}
+		class ParentCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "child", [field], function() {
+					return contains(ChildField);
+				});
+			}
+			#child = (initializeDeferredDecorator(this, "child"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(ParentCard, cardApi, mappings);
+		let attributes = {
+			type: "object",
+			properties: {
+				...cardDefAttributesProperties,
+				name: { type: "string" },
+				child: {
+					type: "object",
+					properties: {
+						name: { type: "string" },
+						friend: {
+							type: "object",
+							properties: { name: { type: "string" } }
+						}
+					}
+				}
+			}
+		};
+		let relationships = {
+			type: "object",
+			properties: {
+				"child.friend.pet": linkedRelationship,
+				...cardDefRelationshipsProperties
+			}
+		};
+		assert.deepEqual(schema, {
+			attributes,
+			relationships
+		});
+	});
+	(0, import_qunit.test)(`generates correct schema for nested linksTo and linksToMany fields`, async function(assert) {
+		let { field, contains, linksTo, linksToMany, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class Country extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class TravelGoal extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "goalTitle", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#goalTitle = (initializeDeferredDecorator(this, "goalTitle"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "country", [field], function() {
+					return linksTo(Country);
+				});
+			}
+			#country = (initializeDeferredDecorator(this, "country"), void 0);
+		}
+		class Traveler extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "countryOfOrigin", [field], function() {
+					return linksTo(Country);
+				});
+			}
+			#countryOfOrigin = (initializeDeferredDecorator(this, "countryOfOrigin"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "countriesVisited", [field], function() {
+					return linksToMany(Country);
+				});
+			}
+			#countriesVisited = (initializeDeferredDecorator(this, "countriesVisited"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "nextTravelGoal", [field], function() {
+					return contains(TravelGoal);
+				});
+			}
+			#nextTravelGoal = (initializeDeferredDecorator(this, "nextTravelGoal"), void 0);
+		}
+		class TripInfo extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "traveler", [field], function() {
+					return contains(Traveler);
+				});
+			}
+			#traveler = (initializeDeferredDecorator(this, "traveler"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TripInfo, cardApi, mappings);
+		const links = {
+			type: "object",
+			properties: { self: { type: "string" } },
+			required: ["self"]
+		};
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					traveler: {
+						type: "object",
+						properties: {
+							name: { type: "string" },
+							nextTravelGoal: {
+								type: "object",
+								properties: { goalTitle: { type: "string" } }
+							}
+						}
+					}
+				}
+			},
+			relationships: {
+				type: "object",
+				properties: {
+					...cardDefRelationshipsProperties,
+					"traveler.countryOfOrigin": {
+						type: "object",
+						properties: { links },
+						required: ["links"]
+					},
+					"traveler.countriesVisited": {
+						type: "array",
+						items: {
+							type: "object",
+							properties: { links },
+							required: ["links"]
+						}
+					},
+					"traveler.nextTravelGoal.country": {
+						type: "object",
+						properties: { links },
+						required: ["links"]
+					}
+				}
+			}
+		});
+	});
+	(0, import_qunit.test)(`skips over fields that can't be recognised`, async function(assert) {
+		assert.expect(2);
+		let { field, contains, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class NewField extends FieldDef {
+			static displayName = "NewField";
+			static [primitive] = void 0;
+		}
+		class TestCard extends CardDef {
+			static displayName = "TestCard";
+			static {
+				decorateFieldV2(this.prototype, "keepField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#keepField = (initializeDeferredDecorator(this, "keepField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "skipField", [field], function() {
+					return contains(NewField);
+				});
+			}
+			#skipField = (initializeDeferredDecorator(this, "skipField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					keepField: { type: "string" }
+				}
+			},
+			relationships: cardDefRelationships
+		});
+		try {
+			generateJsonSchemaForCardType(TestCard, cardApi, mappings, { strict: true });
+		} catch (error) {
+			assert.strictEqual(error.message, "No schema found for field 'skipField'. Ensure the field type is defined in the mappings.", "Expected an error to be thrown about the missing field");
+		}
+	});
+	(0, import_qunit.test)(`handles subclasses`, async function(assert) {
+		let { field, contains, CardDef } = cardApi;
+		let { default: StringField } = string;
+		class NewField extends StringField {
+			static displayName = "NewField";
+		}
+		class TestCard extends CardDef {
+			static displayName = "TestCard";
+			static {
+				decorateFieldV2(this.prototype, "keepField", [field], function() {
+					return contains(NewField);
+				});
+			}
+			#keepField = (initializeDeferredDecorator(this, "keepField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					keepField: { type: "string" }
+				}
+			},
+			relationships: cardDefRelationships
+		});
+	});
+	(0, import_qunit.test)(`handles subclasses within nested fields`, async function(assert) {
+		let { field, contains, containsMany, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class NewField extends StringField {
+			static displayName = "NewField";
+		}
+		class ContainingField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "keepField", [field], function() {
+					return containsMany(NewField);
+				});
+			}
+			#keepField = (initializeDeferredDecorator(this, "keepField"), void 0);
+		}
+		class TestCard extends CardDef {
+			static displayName = "TestCard";
+			static {
+				decorateFieldV2(this.prototype, "containingField", [field], function() {
+					return contains(ContainingField);
+				});
+			}
+			#containingField = (initializeDeferredDecorator(this, "containingField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					containingField: {
+						type: "object",
+						properties: { keepField: {
+							type: "array",
+							items: { type: "string" }
+						} }
+					}
+				}
+			},
+			relationships: cardDefRelationships
+		});
+	});
+	(0, import_qunit.test)(`supports descriptions on fields`, async function(assert) {
+		let { field, contains, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class InternalField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+		}
+		class BasicCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "containerField", [field], function() {
+					return contains(InternalField, { description: "Desc #1" });
+				});
+			}
+			#containerField = (initializeDeferredDecorator(this, "containerField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(BasicCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					containerField: {
+						type: "object",
+						description: "Desc #1",
+						properties: { innerStringField: { type: "string" } }
+					}
+				}
+			},
+			relationships: cardDefRelationships
+		});
+	});
+	(0, import_qunit.test)(`supports descriptions on nested fields`, async function(assert) {
+		let { field, contains, linksTo, linksToMany, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class InnerCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "name", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#name = (initializeDeferredDecorator(this, "name"), void 0);
+		}
+		class InternalField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return contains(StringField, { description: "Desc #2" });
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCard", [field], function() {
+					return linksTo(InnerCard, { description: "Desc #3" });
+				});
+			}
+			#linkedCard = (initializeDeferredDecorator(this, "linkedCard"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCard2", [field], function() {
+					return linksTo(InnerCard);
+				});
+			}
+			#linkedCard2 = (initializeDeferredDecorator(this, "linkedCard2"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCards", [field], function() {
+					return linksToMany(InnerCard, { description: "Desc #4" });
+				});
+			}
+			#linkedCards = (initializeDeferredDecorator(this, "linkedCards"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCards2", [field], function() {
+					return linksToMany(InnerCard);
+				});
+			}
+			#linkedCards2 = (initializeDeferredDecorator(this, "linkedCards2"), void 0);
+		}
+		class BasicCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "containerField", [field], function() {
+					return contains(InternalField, { description: "Desc #1" });
+				});
+			}
+			#containerField = (initializeDeferredDecorator(this, "containerField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(BasicCard, cardApi, mappings);
+		const links = {
+			type: "object",
+			properties: { self: { type: "string" } },
+			required: ["self"]
+		};
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					containerField: {
+						type: "object",
+						description: "Desc #1",
+						properties: { innerStringField: {
+							type: "string",
+							description: "Desc #2"
+						} }
+					}
+				}
+			},
+			relationships: {
+				type: "object",
+				properties: {
+					"containerField.linkedCard": {
+						type: "object",
+						description: "Desc #3",
+						properties: { links },
+						required: ["links"]
+					},
+					"containerField.linkedCard2": {
+						type: "object",
+						properties: { links },
+						required: ["links"]
+					},
+					"containerField.linkedCards": {
+						type: "array",
+						description: "Desc #4",
+						items: {
+							type: "object",
+							properties: { links },
+							required: ["links"]
+						}
+					},
+					"containerField.linkedCards2": {
+						type: "array",
+						items: {
+							type: "object",
+							properties: { links },
+							required: ["links"]
+						}
+					},
+					...cardDefRelationshipsProperties
+				}
+			}
+		});
+	});
+	(0, import_qunit.test)(`supports descriptions in linksTo`, async function(assert) {
+		let { field, contains, linksTo, CardDef } = cardApi;
+		let { default: StringField } = string;
+		class OtherCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+		}
+		class TestCard extends CardDef {
+			static displayName = "TestCard";
+			static {
+				decorateFieldV2(this.prototype, "linkedCard", [field], function() {
+					return linksTo(OtherCard);
+				});
+			}
+			#linkedCard = (initializeDeferredDecorator(this, "linkedCard"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "simpleField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#simpleField = (initializeDeferredDecorator(this, "simpleField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCard2", [field], function() {
+					return linksTo(OtherCard, { description: "linked card" });
+				});
+			}
+			#linkedCard2 = (initializeDeferredDecorator(this, "linkedCard2"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		let attributes = {
+			type: "object",
+			properties: {
+				simpleField: { type: "string" },
+				...cardDefAttributesProperties
+			}
+		};
+		let relationships = {
+			type: "object",
+			properties: {
+				linkedCard: {
+					type: "object",
+					properties: { links: {
+						type: "object",
+						properties: { self: { type: "string" } },
+						required: ["self"]
+					} },
+					required: ["links"]
+				},
+				linkedCard2: {
+					type: "object",
+					description: "linked card",
+					properties: { links: {
+						type: "object",
+						properties: { self: { type: "string" } },
+						required: ["self"]
+					} },
+					required: ["links"]
+				},
+				...cardDefRelationshipsProperties
+			}
+		};
+		assert.deepEqual(schema, {
+			attributes,
+			relationships
+		});
+	});
+	(0, import_qunit.test)(`supports descriptions in linksToMany`, async function(assert) {
+		let { field, contains, linksToMany, CardDef } = cardApi;
+		let { default: StringField } = string;
+		class OtherCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+		}
+		class TestCard extends CardDef {
+			static displayName = "TestCard";
+			static {
+				decorateFieldV2(this.prototype, "simpleField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#simpleField = (initializeDeferredDecorator(this, "simpleField"), void 0);
+			static {
+				decorateFieldV2(this.prototype, "linkedCards", [field], function() {
+					return linksToMany(OtherCard, { description: "linked cards" });
+				});
+			}
+			#linkedCards = (initializeDeferredDecorator(this, "linkedCards"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(TestCard, cardApi, mappings);
+		let attributes = {
+			type: "object",
+			properties: {
+				simpleField: { type: "string" },
+				...cardDefAttributesProperties
+			}
+		};
+		let relationships = {
+			type: "object",
+			properties: {
+				linkedCards: {
+					type: "array",
+					description: "linked cards",
+					items: {
+						type: "object",
+						properties: { links: {
+							type: "object",
+							properties: { self: { type: "string" } },
+							required: ["self"]
+						} },
+						required: ["links"]
+					}
+				},
+				...cardDefRelationshipsProperties
+			}
+		};
+		assert.deepEqual(schema, {
+			attributes,
+			relationships
+		});
+	});
+	(0, import_qunit.test)(`supports descriptions on containsMany fields`, async function(assert) {
+		let { field, contains, containsMany, CardDef, FieldDef } = cardApi;
+		let { default: StringField } = string;
+		class InternalField extends FieldDef {
+			static {
+				decorateFieldV2(this.prototype, "innerStringField", [field], function() {
+					return contains(StringField);
+				});
+			}
+			#innerStringField = (initializeDeferredDecorator(this, "innerStringField"), void 0);
+		}
+		class BasicCard extends CardDef {
+			static {
+				decorateFieldV2(this.prototype, "containerField", [field], function() {
+					return containsMany(InternalField, { description: "Desc #1" });
+				});
+			}
+			#containerField = (initializeDeferredDecorator(this, "containerField"), void 0);
+		}
+		let schema = generateJsonSchemaForCardType(BasicCard, cardApi, mappings);
+		assert.deepEqual(schema, {
+			attributes: {
+				type: "object",
+				properties: {
+					...cardDefAttributesProperties,
+					containerField: {
+						type: "array",
+						description: "Desc #1",
+						items: {
+							type: "object",
+							properties: { innerStringField: { type: "string" } }
+						}
+					}
+				}
+			},
+			relationships: cardDefRelationships
+		});
+	});
+});
+//#endregion