@jskit-ai/http-runtime 0.1.56 → 0.1.57

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   "packageVersion": 1,
   "packageId": "@jskit-ai/http-runtime",
-  "version": "0.1.56",
+  "version": "0.1.57",
   "kind": "runtime",
   "dependsOn": [],
   "capabilities": {
@@ -67,7 +67,7 @@ export default Object.freeze({
   "mutations": {
     "dependencies": {
       "runtime": {
-        "@jskit-ai/kernel": "0.1.57"
+        "@jskit-ai/kernel": "0.1.58"
       },
       "dev": {}
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/http-runtime",
-  "version": "0.1.56",
+  "version": "0.1.57",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -18,7 +18,7 @@
     "./shared/validators/operationValidation": "./src/shared/validators/operationValidation.js"
   },
   "dependencies": {
-    "@jskit-ai/kernel": "0.1.57",
+    "@jskit-ai/kernel": "0.1.58",
     "json-rest-schema": "1.x.x"
   }
 }

package/src/shared/clientRuntime/jsonApiResourceTransport.js

@@ -36,7 +36,21 @@ function normalizeJsonApiClientTransport(transport = null) {
     responseKind: normalizeText(transport?.responseKind, {
       fallback: "record"
     }).toLowerCase(),
-    includeBodyId: transport?.includeBodyId === true
+    includeBodyId: transport?.includeBodyId === true,
+    lookupContainerKey: normalizeText(transport?.lookupContainerKey, {
+      fallback: "lookups"
+    }),
+    lookupFieldMap: Object.freeze(
+      Object.fromEntries(
+        Object.entries(normalizeObject(transport?.lookupFieldMap))
+          .map(([relationshipName, fieldKey]) => [
+            normalizeText(relationshipName),
+            normalizeText(fieldKey)
+          ])
+          .filter(([relationshipName, fieldKey]) => relationshipName && fieldKey)
+          .sort(([left], [right]) => left.localeCompare(right))
+      )
+    )
   });
 }
 
@@ -84,12 +98,119 @@ function encodeJsonApiResourceQuery(query, transport = null) {
   });
 }
 
-function simplifyResourceObject(resource = {}) {
+function resolveRelationshipFieldKey(relationshipName = "", lookupFieldMap = null) {
+  const normalizedRelationshipName = normalizeText(relationshipName);
+  const explicitFieldKey = normalizeText(lookupFieldMap?.[normalizedRelationshipName]);
+  if (explicitFieldKey) {
+    return explicitFieldKey;
+  }
+
+  return normalizedRelationshipName ? `${normalizedRelationshipName}Id` : "";
+}
+
+function createIncludedResourceIndex(document = {}) {
+  const index = new Map();
+
+  for (const resource of normalizeArray(document?.included)) {
+    const type = normalizeText(resource?.type);
+    const id = normalizeText(resource?.id);
+    if (!type || !id) {
+      continue;
+    }
+
+    index.set(`${type}:${id}`, resource);
+  }
+
+  return index;
+}
+
+function simplifyRelationshipResource(linkage = {}, options = {}) {
+  const normalizedLinkage = isRecord(linkage) ? normalizeObject(linkage) : {};
+  const type = normalizeText(normalizedLinkage.type);
+  const id = normalizeText(normalizedLinkage.id);
+  if (!type || !id) {
+    return null;
+  }
+
+  const resourceKey = `${type}:${id}`;
+  const includedResource = options.includedResourceIndex?.get(resourceKey);
+  if (!includedResource) {
+    return {
+      id
+    };
+  }
+
+  return simplifyResourceObject(includedResource, options);
+}
+
+function simplifyResourceObject(resource = {}, options = {}) {
   const normalizedResource = isRecord(resource) ? normalizeObject(resource) : {};
-  return {
+  const simplified = {
     id: normalizedResource.id == null ? "" : String(normalizedResource.id),
     ...(normalizeObject(normalizedResource.attributes))
   };
+  const lookupContainerKey = normalizeText(options.lookupContainerKey, {
+    fallback: "lookups"
+  });
+  const lookupFieldMap = options.lookupFieldMap || null;
+  const resourceKey = `${normalizeText(normalizedResource.type)}:${normalizeText(normalizedResource.id)}`;
+  if (resourceKey && options.inFlightKeys?.has(resourceKey)) {
+    return simplified;
+  }
+  if (resourceKey && options.resourceCache?.has(resourceKey)) {
+    return options.resourceCache.get(resourceKey);
+  }
+
+  if (resourceKey) {
+    options.inFlightKeys?.add(resourceKey);
+  }
+
+  const lookups = {};
+  for (const [relationshipName, relationshipValue] of Object.entries(normalizeObject(normalizedResource.relationships))) {
+    const relationshipData = relationshipValue?.data;
+    if (Array.isArray(relationshipData)) {
+      const items = relationshipData
+        .map((entry) =>
+          simplifyRelationshipResource(entry, {
+            ...options,
+            lookupFieldMap: null
+          })
+        )
+        .filter(Boolean);
+      if (items.length > 0) {
+        lookups[relationshipName] = items;
+      }
+      continue;
+    }
+
+    const fieldKey = resolveRelationshipFieldKey(relationshipName, lookupFieldMap);
+    if (!Object.hasOwn(simplified, fieldKey)) {
+      simplified[fieldKey] = relationshipData?.id == null ? null : String(relationshipData.id);
+    }
+
+    const lookupRecord = relationshipData == null
+      ? null
+      : simplifyRelationshipResource(relationshipData, {
+          ...options,
+          lookupFieldMap: null
+        });
+    if (lookupRecord) {
+      lookups[fieldKey] = lookupRecord;
+      if (relationshipName !== fieldKey) {
+        lookups[relationshipName] = lookupRecord;
+      }
+    }
+  }
+
+  if (Object.keys(lookups).length > 0) {
+    simplified[lookupContainerKey] = lookups;
+  }
+  if (resourceKey) {
+    options.inFlightKeys?.delete(resourceKey);
+    options.resourceCache?.set(resourceKey, simplified);
+  }
+
+  return simplified;
 }
 
 function assertPrimaryDataType(resource = {}, expectedType = "") {
@@ -122,6 +243,13 @@ function decodeJsonApiResourceResponse(payload, transport = null) {
   }
 
   const document = normalizeJsonApiDocument(payload);
+  const simplifyOptions = {
+    lookupContainerKey: normalizedTransport.lookupContainerKey,
+    lookupFieldMap: normalizedTransport.lookupFieldMap,
+    includedResourceIndex: createIncludedResourceIndex(document),
+    resourceCache: new Map(),
+    inFlightKeys: new Set()
+  };
   if (document.kind === "unknown") {
     throw new Error("Expected JSON:API response document.");
   }
@@ -136,7 +264,7 @@ function decodeJsonApiResourceResponse(payload, transport = null) {
     }
 
     return {
-      items: document.data.map((entry) => simplifyResourceObject(entry)),
+      items: document.data.map((entry) => simplifyResourceObject(entry, simplifyOptions)),
       ...resolveCollectionPageMeta(document)
     };
   }
@@ -158,7 +286,7 @@ function decodeJsonApiResourceResponse(payload, transport = null) {
       assertPrimaryDataType(document.data, normalizedTransport.responseType);
     }
 
-    return document.data == null ? null : simplifyResourceObject(document.data);
+    return document.data == null ? null : simplifyResourceObject(document.data, simplifyOptions);
   }
 
   if (document.kind !== "resource") {
@@ -169,7 +297,7 @@ function decodeJsonApiResourceResponse(payload, transport = null) {
     assertPrimaryDataType(document.data, normalizedTransport.responseType);
   }
 
-  return document.data == null ? null : simplifyResourceObject(document.data);
+  return document.data == null ? null : simplifyResourceObject(document.data, simplifyOptions);
 }
 
 function decodeJsonApiErrorFieldErrors(payload = {}) {

package/src/shared/validators/jsonApiRouteTransport.js

@@ -54,6 +54,54 @@ const JSON_API_META_SCHEMA = Object.freeze({
   additionalProperties: true
 });
 
+const JSON_API_RESOURCE_IDENTIFIER_SCHEMA = Object.freeze({
+  type: "object",
+  additionalProperties: false,
+  required: ["type", "id"],
+  properties: {
+    type: { type: "string", minLength: 1 },
+    id: JSON_API_ID_SCHEMA
+  }
+});
+
+const JSON_API_RELATIONSHIP_OBJECT_SCHEMA = Object.freeze({
+  type: "object",
+  additionalProperties: false,
+  required: ["data"],
+  properties: {
+    data: {
+      anyOf: [
+        JSON_API_RESOURCE_IDENTIFIER_SCHEMA,
+        {
+          type: "array",
+          items: JSON_API_RESOURCE_IDENTIFIER_SCHEMA
+        },
+        { type: "null" }
+      ]
+    }
+  }
+});
+
+const JSON_API_INCLUDED_RESOURCE_SCHEMA = Object.freeze({
+  type: "object",
+  additionalProperties: false,
+  required: ["type", "id"],
+  properties: {
+    type: { type: "string", minLength: 1 },
+    id: JSON_API_ID_SCHEMA,
+    attributes: {
+      type: "object",
+      additionalProperties: true
+    },
+    relationships: {
+      type: "object",
+      additionalProperties: JSON_API_RELATIONSHIP_OBJECT_SCHEMA
+    },
+    links: JSON_API_LINKS_SCHEMA,
+    meta: JSON_API_META_SCHEMA
+  }
+});
+
 const JSON_API_ERROR_OBJECT_SCHEMA = Object.freeze({
   type: "object",
   additionalProperties: false,
@@ -120,7 +168,8 @@ function resolveRouteTypes(value = {}) {
 function resolveEmbeddedAttributesTransportSchema(definition, {
   context = "JSON:API resource",
   defaultMode = "replace",
-  removeId = false
+  removeId = false,
+  removeKeys = []
 } = {}) {
   const transportSchema = resolveSchemaTransportSchemaDefinition(definition, {
     context,
@@ -136,13 +185,35 @@ function resolveEmbeddedAttributesTransportSchema(definition, {
   const nextProperties = {
     ...properties
   };
+  const excludedKeys = new Set(
+    normalizeArray(removeKeys)
+      .map((entry) => String(entry || "").trim())
+      .filter(Boolean)
+  );
 
   if (removeId) {
-    delete nextProperties.id;
+    excludedKeys.add("id");
+  }
+
+  for (const key of excludedKeys) {
+    delete nextProperties[key];
   }
 
+  const schemaFieldDefinitions = (() => {
+    const fieldDefinitions = definition?.schema?.getFieldDefinitions?.();
+    return isRecord(fieldDefinitions) ? fieldDefinitions : {};
+  })();
+
   const required = Array.isArray(sourceSchema.required)
-    ? sourceSchema.required.filter((entry) => String(entry || "").trim() && (!removeId || entry !== "id"))
+    ? sourceSchema.required.filter((entry) => {
+        const normalizedEntry = String(entry || "").trim();
+        if (!normalizedEntry || excludedKeys.has(normalizedEntry)) {
+          return false;
+        }
+
+        const fieldDefinition = normalizeObject(schemaFieldDefinitions[normalizedEntry]);
+        return fieldDefinition.nullable !== true;
+      })
     : [];
 
   const attributeSchema = {
@@ -160,18 +231,124 @@ function resolveEmbeddedAttributesTransportSchema(definition, {
   return createEmbeddableTransportSchemaDocument(attributeSchema, `${normalizeText(context, { fallback: "JsonApiAttributes" }).replace(/[^a-z0-9]+/gi, "_")}`);
 }
 
+function normalizeRelationshipSchemaEntries(entries = []) {
+  const normalizedEntries = [];
+
+  for (const entry of normalizeArray(entries)) {
+    const source = normalizeObject(entry);
+    const relationshipName = normalizeText(source.relationshipName || source.name);
+    const relationshipType = normalizeText(source.relationshipType || source.type);
+    const attributeKey = normalizeText(source.attributeKey || source.fieldKey);
+    if (!relationshipName) {
+      continue;
+    }
+
+    normalizedEntries.push(Object.freeze({
+      relationshipName,
+      relationshipType,
+      attributeKey,
+      required: source.required === true,
+      nullable: source.nullable === true
+    }));
+  }
+
+  return Object.freeze(normalizedEntries);
+}
+
+function createJsonApiRelationshipDataSchema(relationshipType = "", {
+  nullable = false
+} = {}) {
+  const normalizedRelationshipType = normalizeText(relationshipType);
+  const resourceIdentifierSchema = normalizedRelationshipType
+    ? {
+        type: "object",
+        additionalProperties: false,
+        required: ["type", "id"],
+        properties: {
+          type: { const: normalizedRelationshipType },
+          id: JSON_API_ID_SCHEMA
+        }
+      }
+    : JSON_API_RESOURCE_IDENTIFIER_SCHEMA;
+
+  return {
+    anyOf: nullable
+      ? [
+          resourceIdentifierSchema,
+          { type: "null" }
+        ]
+      : [resourceIdentifierSchema]
+  };
+}
+
+function createJsonApiRelationshipsTransportSchema(entries = [], {
+  includeRequired = false
+} = {}) {
+  const relationshipEntries = normalizeRelationshipSchemaEntries(entries);
+  if (relationshipEntries.length < 1) {
+    return null;
+  }
+
+  const properties = {};
+  const required = [];
+
+  for (const entry of relationshipEntries) {
+    properties[entry.relationshipName] = {
+      type: "object",
+      additionalProperties: false,
+      required: ["data"],
+      properties: {
+        data: createJsonApiRelationshipDataSchema(entry.relationshipType, {
+          nullable: entry.nullable
+        })
+      }
+    };
+
+    if (includeRequired && entry.required) {
+      required.push(entry.relationshipName);
+    }
+  }
+
+  const schema = {
+    type: "object",
+    additionalProperties: false,
+    properties
+  };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+
+  return Object.freeze({
+    schema,
+    entries: relationshipEntries
+  });
+}
+
 function createJsonApiResourceObjectTransportSchema({
   type = "",
   attributes,
   requireId = true,
   includeLinks = false,
-  includeMeta = false
+  includeMeta = false,
+  excludeAttributeKeys = [],
+  relationshipEntries = [],
+  relationshipMembersRequired = false
 } = {}) {
   const normalizedType = resolveRouteType(type);
+  const relationshipsTransport = createJsonApiRelationshipsTransportSchema(relationshipEntries, {
+    includeRequired: relationshipMembersRequired
+  });
+  const relationFieldKeys = relationshipsTransport
+    ? relationshipsTransport.entries.map((entry) => entry.attributeKey).filter(Boolean)
+    : [];
   const embeddedAttributes = resolveEmbeddedAttributesTransportSchema(attributes, {
     context: `${normalizedType} resource attributes`,
     defaultMode: "replace",
-    removeId: true
+    removeId: true,
+    removeKeys: [
+      ...normalizeArray(excludeAttributeKeys),
+      ...relationFieldKeys,
+    ]
   });
 
   const properties = {
@@ -187,6 +364,10 @@ function createJsonApiResourceObjectTransportSchema({
     required.push("id");
   }
 
+  if (relationshipsTransport) {
+    properties.relationships = relationshipsTransport.schema;
+  }
+
   if (includeLinks) {
     properties.links = JSON_API_LINKS_SCHEMA;
   }
@@ -201,19 +382,25 @@ function createJsonApiResourceObjectTransportSchema({
       required,
       properties
     },
-    definitions: embeddedAttributes.definitions
+    definitions: embeddedAttributes.definitions,
+    hasRelationships: Boolean(relationshipsTransport)
   };
 }
 
 function createJsonApiResourceRequestBodyTransportSchema({
   type = "",
   attributes,
-  requireId = false
+  requireId = false,
+  excludeAttributeKeys = [],
+  relationshipEntries = []
 } = {}) {
   const resourceTransport = createJsonApiResourceObjectTransportSchema({
     type,
     attributes,
-    requireId
+    requireId,
+    excludeAttributeKeys,
+    relationshipEntries,
+    relationshipMembersRequired: true
   });
   const embeddedResource = createEmbeddableTransportSchemaDocument(
     {
@@ -260,7 +447,9 @@ function createJsonApiResourceSuccessTransportSchema({
   kind = "record",
   includeLinks = false,
   includeMeta = false,
-  includeIncluded = false
+  includeIncluded = false,
+  excludeAttributeKeys = [],
+  relationshipEntries = []
 } = {}) {
   const normalizedKind = String(kind || "record").trim().toLowerCase();
   if (!["record", "nullable-record", "collection", "meta"].includes(normalizedKind)) {
@@ -276,7 +465,9 @@ function createJsonApiResourceSuccessTransportSchema({
   const resourceTransport = createJsonApiResourceObjectTransportSchema({
     type,
     attributes,
-    requireId: true
+    requireId: true,
+    excludeAttributeKeys,
+    relationshipEntries
   });
   const embeddedResource = createEmbeddableTransportSchemaDocument(
     {
@@ -308,10 +499,10 @@ function createJsonApiResourceSuccessTransportSchema({
     documentProperties.data = embeddedResource.schema;
   }
 
-  if (includeIncluded) {
+  if (includeIncluded || resourceTransport.hasRelationships) {
     documentProperties.included = {
       type: "array",
-      items: embeddedResource.schema
+      items: JSON_API_INCLUDED_RESOURCE_SCHEMA
     };
   }
   if (includeLinks) {
@@ -692,6 +883,10 @@ function createJsonApiResourceRouteContract({
   includeValidation400 = false,
   allowBodyId = false,
   pointerPrefix = "/data/attributes",
+  bodyAttributeExcludeKeys = [],
+  outputAttributeExcludeKeys = [],
+  bodyRelationshipEntries = [],
+  outputRelationshipEntries = [],
   getRecordType = null,
   getRecordId = null,
   getRecordAttributes = null,
@@ -747,7 +942,9 @@ function createJsonApiResourceRouteContract({
     fastifySchema.body = createJsonApiResourceRequestBodyTransportSchema({
       type: normalizedRequestType,
       attributes: body,
-      requireId: allowBodyId
+      requireId: allowBodyId,
+      excludeAttributeKeys: bodyAttributeExcludeKeys,
+      relationshipEntries: bodyRelationshipEntries
     });
   }
   if (query) {
@@ -777,7 +974,9 @@ function createJsonApiResourceRouteContract({
         kind: normalizedOutputKind,
         includeLinks: typeof getDocumentLinks === "function",
         includeMeta: typeof getDocumentMeta === "function" || normalizedOutputKind === "collection",
-        includeIncluded: typeof getIncluded === "function"
+        includeIncluded: typeof getIncluded === "function",
+        excludeAttributeKeys: outputAttributeExcludeKeys,
+        relationshipEntries: outputRelationshipEntries
       })
     );
   }

package/test/client.test.js

@@ -148,6 +148,173 @@ test("request encodes and decodes json:api resource transport for records", asyn
   );
 });
 
+test("request decodes json:api relationship includes into JSKIT lookups and foreign-key fields", async () => {
+  const fetchImpl = async () =>
+    mockResponse({
+      contentType: "application/vnd.api+json",
+      data: {
+        data: {
+          type: "pets",
+          id: "729900",
+          attributes: {
+            name: "Daisy"
+          },
+          relationships: {
+            contact: {
+              data: {
+                type: "contacts",
+                id: "552252"
+              }
+            },
+            breed: {
+              data: {
+                type: "breeds",
+                id: "2"
+              }
+            }
+          }
+        },
+        included: [
+          {
+            type: "contacts",
+            id: "552252",
+            attributes: {
+              firstName: "Serena",
+              lastName: "Ellison"
+            }
+          },
+          {
+            type: "breeds",
+            id: "2",
+            attributes: {
+              name: "Cavoodle"
+            }
+          }
+        ]
+      }
+    });
+
+  const client = createHttpClient({ fetchImpl });
+  const payload = await client.request("/api/pets/729900", {
+    method: "GET",
+    transport: {
+      kind: "jsonapi-resource",
+      responseType: "pets",
+      responseKind: "record",
+      lookupFieldMap: {
+        contact: "contactId",
+        breed: "breedId"
+      }
+    }
+  });
+
+  assert.deepEqual(payload, {
+    id: "729900",
+    name: "Daisy",
+    contactId: "552252",
+    breedId: "2",
+    lookups: {
+      contactId: {
+        id: "552252",
+        firstName: "Serena",
+        lastName: "Ellison"
+      },
+      contact: {
+        id: "552252",
+        firstName: "Serena",
+        lastName: "Ellison"
+      },
+      breedId: {
+        id: "2",
+        name: "Cavoodle"
+      },
+      breed: {
+        id: "2",
+        name: "Cavoodle"
+      }
+    }
+  });
+});
+
+test("request recursively decodes nested included relationships for collection-style lookups", async () => {
+  const fetchImpl = async () =>
+    mockResponse({
+      contentType: "application/vnd.api+json",
+      data: {
+        data: {
+          type: "contacts",
+          id: "552252",
+          attributes: {
+            firstName: "Serena",
+            lastName: "Ellison"
+          },
+          relationships: {
+            pets: {
+              data: [
+                {
+                  type: "pets",
+                  id: "729900"
+                }
+              ]
+            }
+          }
+        },
+        included: [
+          {
+            type: "pets",
+            id: "729900",
+            attributes: {
+              name: "Daisy"
+            },
+            relationships: {
+              breed: {
+                data: {
+                  type: "breeds",
+                  id: "2"
+                }
+              }
+            }
+          },
+          {
+            type: "breeds",
+            id: "2",
+            attributes: {
+              name: "Cavoodle"
+            }
+          }
+        ]
+      }
+    });
+
+  const client = createHttpClient({ fetchImpl });
+  const payload = await client.request("/api/contacts/552252", {
+    method: "GET",
+    transport: {
+      kind: "jsonapi-resource",
+      responseType: "contacts",
+      responseKind: "record"
+    }
+  });
+
+  assert.deepEqual(payload.lookups?.pets, [
+    {
+      id: "729900",
+      name: "Daisy",
+      breedId: "2",
+      lookups: {
+        breedId: {
+          id: "2",
+          name: "Cavoodle"
+        },
+        breed: {
+          id: "2",
+          name: "Cavoodle"
+        }
+      }
+    }
+  ]);
+});
+
 test("request decodes json:api collection responses into JSKIT paged-list shape", async () => {
   const fetchImpl = async () =>
     mockResponse({

package/test/jsonApiRouteTransport.test.js

@@ -302,6 +302,76 @@ test("createJsonApiResourceRouteTransport passes through tagged JSON:API documen
   assert.deepEqual(transport.response(returnJsonApiDocument(document)), document);
 });
 
+test("createJsonApiResourceRouteContract models explicit relationship-backed output fields as relationships", () => {
+  const contract = createJsonApiResourceRouteContract({
+    responseType: "availabilities",
+    output: {
+      schema: createSchema({
+        id: {
+          type: "string",
+          required: true,
+          minLength: 1
+        },
+        serviceId: {
+          type: "string",
+          required: true,
+          nullable: true,
+          belongsTo: "services",
+          as: "service"
+        },
+        name: {
+          type: "string",
+          required: true,
+          minLength: 1
+        },
+        deletedAt: {
+          type: "string",
+          required: true,
+          nullable: true
+        },
+        lookups: {
+          type: "object",
+          required: false
+        }
+      }),
+      mode: "replace"
+    },
+    outputKind: "record",
+    outputAttributeExcludeKeys: ["lookups"],
+    outputRelationshipEntries: [
+      {
+        attributeKey: "serviceId",
+        relationshipName: "service",
+        relationshipType: "services",
+        nullable: true
+      }
+    ]
+  });
+
+  const resourceSchema = contract.responses["200"].transportSchema.definitions.availabilitiesSuccessResource;
+  const attributesSchemaRef = resourceSchema.properties.attributes.allOf[0].$ref;
+  const attributesSchemaName = attributesSchemaRef.replace("#/definitions/", "");
+  const attributesSchema = contract.responses["200"].transportSchema.definitions[attributesSchemaName];
+
+  assert.deepEqual(resourceSchema.required, ["type", "attributes", "id"]);
+  assert.ok(Object.hasOwn(resourceSchema.properties, "relationships"));
+  assert.equal(attributesSchema.required.includes("serviceId"), false);
+  assert.equal(attributesSchema.required.includes("deletedAt"), false);
+  assert.equal(attributesSchema.required.includes("lookups"), false);
+  assert.equal(Object.hasOwn(attributesSchema.properties, "serviceId"), false);
+  assert.equal(Object.hasOwn(attributesSchema.properties, "deletedAt"), true);
+  assert.equal(Object.hasOwn(attributesSchema.properties, "lookups"), false);
+  assert.equal(
+    Array.isArray(resourceSchema.properties.relationships.required),
+    false
+  );
+  assert.equal(
+    resourceSchema.properties.relationships.properties.service.properties.data.anyOf[1].type,
+    "null"
+  );
+  assert.ok(Object.hasOwn(contract.responses["200"].transportSchema.properties, "included"));
+});
+
 test("createJsonApiResourceRouteTransport wraps tagged meta results for meta routes", () => {
   const contract = createJsonApiResourceRouteContract({
     requestType: "password-changes",