@simtlix/simfinity-core 3.5.7 → 3.5.9

package/src/runtime.js

@@ -9,6 +9,7 @@ import {
 
 import SimfinityError from './errors/simfinity.error.js';
 import InternalServerError from './errors/internal-server.error.js';
+import { ForbiddenError } from './auth/errors.js';
 import QLOperator from './const/QLOperator.js';
 import QLValue from './const/QLValue.js';
 import QLSort from './const/QLSort.js';
@@ -18,7 +19,9 @@ import { isThenable } from './auth/thenable.js';
 import {
   getFieldStorageName, getListShape, markStoredIdentity, normalizeConnectionField,
 } from './relation-storage.js';
-import './introspection.js';
+import {
+  fieldMetadataNamesFixed, fieldMetadataTypes, fixFieldMetadataNames, renameFieldMetadataTypes,
+} from './introspection.js';
 
 // Resolvers Simfinity generates. Any other resolver on a registered type when its schema is first
 // created is application code, such as a masking resolver, recorded once per type so later
@@ -34,15 +37,23 @@ const countSinkOf = (value) => {
   return typeof sink === 'function' ? sink : undefined;
 };
 // The root value arrives as parent, which resolver wrappers that forward only (parent, args,
-// context) still pass on; info.rootValue is the fallback. Without a sink the count goes to
-// context.count, where Envelop/Apollo/Yoga count plugins read it.
+// context) still pass on; info.rootValue is the fallback.
+const countSinkFor = (parent, info) => countSinkOf(parent) || (info ? countSinkOf(info.rootValue) : undefined);
+// Without a sink the count goes to context.count, where Envelop/Apollo/Yoga count plugins read it.
+// With neither, such as a graphql() call without contextValue, nothing could read a count, so the
+// count query is skipped.
+const canReportCount = (parent, info, context) => countSinkFor(parent, info) !== undefined
+  || (context !== null && (typeof context === 'object' || typeof context === 'function'));
+// Returns whether the count was stored.
 const reportCount = (parent, info, context, count) => {
-  const sink = countSinkOf(parent) || (info ? countSinkOf(info.rootValue) : undefined);
+  const sink = countSinkFor(parent, info);
   if (sink) {
     sink(count);
-    return;
+    return true;
   }
-  context.count = count;
+  // Reflect.set returns false for a frozen, sealed or read-only context, where an assignment would
+  // throw after both queries ran.
+  return Reflect.set(context, 'count', count);
 };
 const applicationResolvedFields = new WeakMap();
 const markGenerated = (resolve) => {
@@ -201,6 +212,94 @@ const GraphQLJSON = new GraphQLScalarType({
   },
 });
 
+// The type called `name` that a schema built from these roots would contain, other than through
+// `skip`, following the references GraphQLSchema collects: fields, arguments, interfaces, union
+// members and input fields. With `inputFields` false, input objects are matched by their own name
+// only, and their fields are never read.
+const findSchemaType = (roots, name, skip, { inputFields = true } = {}) => {
+  const visited = new Set();
+  const pending = [...roots];
+  while (pending.length) {
+    const type = getNamedType(pending.pop());
+    if (!type || type === skip || visited.has(type)) continue;
+    visited.add(type);
+    if (type.name === name) return type;
+    if (type instanceof GraphQLUnionType) pending.push(...type.getTypes());
+    if (type instanceof GraphQLObjectType || type instanceof GraphQLInterfaceType) {
+      pending.push(...type.getInterfaces());
+      for (const field of Object.values(type.getFields())) {
+        pending.push(field.type, ...field.args.map((arg) => arg.type));
+      }
+    }
+    if (inputFields && type instanceof GraphQLInputObjectType) {
+      for (const field of Object.values(type.getFields())) pending.push(field.type);
+    }
+  }
+  return null;
+};
+
+// Every schema contains Simfinity's field metadata types, the types of `__Field.extensions`, named
+// FieldExtensionsType and RelationType unless a clash renamed them. Returns the type of a schema built
+// from these roots that has the name of one of them, or null (#162).
+const fieldMetadataClash = (roots, options) => fieldMetadataTypes()
+  .map((own) => findSchemaType(roots, own.name, own, options)).find(Boolean) || null;
+
+// The first schema that contains the metadata types fixes their names for the process, so a later
+// schema with a type of the same name is rejected.
+const reservedTypeNameError = (clash) => new SimfinityError(
+  `Type ${clash.name} has the name of a type that Simfinity adds to every schema for __Field.extensions, `
+    + 'and a schema created earlier in this process already contains that type under this name. Rename '
+    + `${clash.name}, or create this schema first, so that Simfinity gives its types other names, such as `
+    + 'SimfinityFieldExtensionsType and SimfinityRelationType',
+  'RESERVED_TYPE_NAME',
+  500,
+);
+// The check before anything is built reads only what the output type check before it reads: output
+// types, their fields, arguments, interfaces and union members. Input objects, a registered
+// mutation's input among them, are checked by their own name, because their fields function may read
+// generated inputs (getInputType) that do not exist yet, and graphql-js keeps what it returns. A clash
+// inside an input's fields is found when the schema is constructed.
+const assertFieldMetadataNamesFree = (roots) => {
+  const clash = fieldMetadataNamesFixed() && fieldMetadataClash(roots, { inputFields: false });
+  if (clash) throw reservedTypeNameError(clash);
+};
+
+// Constructs the schema of these roots. When one of its types has the name of a field metadata type,
+// those are renamed SimfinityFieldExtensionsType and SimfinityRelationType, with a number appended
+// when the schema also has those names, in every schema the process constructs from then on. A
+// construction that fails puts the previous metadata types back, so only a schema that exists fixes
+// the names.
+const constructSchema = (query, mutation) => {
+  const roots = [query, mutation];
+  const clash = fieldMetadataClash(roots);
+  if (clash && fieldMetadataNamesFixed()) throw reservedTypeNameError(clash);
+  let names = null;
+  if (clash) {
+    const taken = (name) => findSchemaType(roots, name) !== null;
+    let suffix = '';
+    for (let n = 2; taken(`SimfinityFieldExtensionsType${suffix}`) || taken(`SimfinityRelationType${suffix}`); n += 1) {
+      suffix = String(n);
+    }
+    names = [`SimfinityFieldExtensionsType${suffix}`, `SimfinityRelationType${suffix}`];
+  }
+  const restore = names ? renameFieldMetadataTypes(...names) : null;
+  let schema;
+  try {
+    schema = new GraphQLSchema({ query, mutation });
+  } catch (error) {
+    if (restore) restore();
+    throw error;
+  }
+  fixFieldMetadataNames();
+  if (names) {
+    console.warn(`Configuration issue: the schema has a type named ${clash.name}, the name of a type that `
+      + `Simfinity adds to every schema for __Field.extensions, so Simfinity names its types ${names[0]} and `
+      + `${names[1]} in every schema this process creates from now on. Use these names in named fragments `
+      + 'and permission maps.');
+  }
+  return schema;
+};
+
 // graphql-js wraps a value thrown while resolving a field (locatedError): the wrapper has the field
 // path and repeats the thrown error's message. A thrown non-Error becomes a NonErrorThrown whose
 // message prints the value.
@@ -338,6 +437,14 @@ export const createRuntime = (adapter) => {
   const typesDict = { types: {} };
   const waitingInputType = {};
   const typesDictForUpdate = { types: {} };
+  // `added` item inputs of referenced collections by generated name, so collections that reach the
+  // same child through the same connectionField share one input type.
+  const excludedFieldInputTypes = new Map();
+  // Self-referencing collection field name -> the types whose collection inputs were built with the
+  // unqualified names OneToManyA<field> and OneToManyU<field>; type -> its self-referencing
+  // collections whose inputs are named after the type instead (see claimSelfCollectionNames).
+  const selfCollectionNameHolders = new Map();
+  const qualifiedSelfCollections = new Map();
   const registeredMutations = {};
   const middlewares = [];
 
@@ -519,13 +626,24 @@ const QLTypeAggregationExpression = new GraphQLInputObjectType({
   }),
 });
 
-const QLTypeAggregationResult = new GraphQLObjectType({
+// Aggregation results use Simfinity's JSON scalar, or the application's own scalar named JSON when
+// the schema has one, such as GraphQLJSON from graphql-scalars, so the two do not collide.
+const createAggregationResultType = (valueType) => new GraphQLObjectType({
   name: 'QLTypeAggregationResult',
   fields: () => ({
-    groupId: { type: GraphQLJSON },
-    facts: { type: GraphQLJSON },
+    groupId: { type: valueType },
+    facts: { type: valueType },
   }),
 });
+const QLTypeAggregationResult = createAggregationResultType(GraphQLJSON);
+const applicationJSONResultTypes = new WeakMap();
+const aggregationResultTypeFor = (valueType) => {
+  if (valueType === GraphQLJSON) return QLTypeAggregationResult;
+  if (!applicationJSONResultTypes.has(valueType)) {
+    applicationJSONResultTypes.set(valueType, createAggregationResultType(valueType));
+  }
+  return applicationJSONResultTypes.get(valueType);
+};
 
 const isNonNullOfType = (fieldEntryType, graphQLType) => {
   let isOfType = false;
@@ -536,6 +654,7 @@ const isNonNullOfType = (fieldEntryType, graphQLType) => {
 };
 
 const unwrapNonNull = (type) => (type instanceof GraphQLNonNull ? type.ofType : type);
+const isAbstractOutputType = (type) => type instanceof GraphQLInterfaceType || type instanceof GraphQLUnionType;
 
 const unwrapListAndNonNull = (type) => {
   let unwrapped = type;
@@ -553,89 +672,123 @@ const wrapListInputType = (itemType, listShape, preserveOuterNonNull) => {
     : listType;
 };
 
+const capitalize = (name) => name.charAt(0).toUpperCase() + name.slice(1);
+
+// A GraphQL input object needs at least one field, so a generated input that would have none is
+// left out, together with the operations, fields and mutations that would take it (#161).
+const hasInputFields = (inputType) => Object.keys(inputType.getFields()).length > 0;
+
 /**
- * Creates a new GraphQLInputObjectType with a field excluded.
+ * The `added` item input of a referenced collection: the item type's create input without the
+ * back-reference that the parent supplies. Its fields are read from the item's create input when
+ * the schema is built, so the item's input may be built after this type, as in cycles of
+ * collections. `optionalFields` lose their outer non-null wrapper. Collections that reach the same
+ * item through the same connectionField with the same prefix share one type.
  * @param {string} inputNamePrefix - The prefix for the input type name.
- * @param {GraphQLInputObjectType} originalType - The original input type.
+ * @param {GraphQLObjectType} itemType - The collection's item type.
  * @param {string} fieldToExclude - The name of the field to exclude.
- * @returns {GraphQLInputObjectType} A new input type without the specified field.
+ * @param {string} [connectionFieldName] - The declared connectionField, which names the type.
+ * @param {string[]} [optionalFields] - Fields of the item's create input that become optional.
+ * @returns {GraphQLInputObjectType} An input type without the specified field.
  */
-const createTypeWithExcludedField = (inputNamePrefix, originalType, fieldToExclude,
-  connectionFieldName = fieldToExclude) => {
-  const originalFields = originalType.getFields();
-  const newFields = Object.fromEntries(
-    Object.entries(originalFields)
-      .filter(([fieldName]) => fieldName !== fieldToExclude)
-      .map(([fieldName, field]) => [fieldName, {
-        type: field.type,
-        description: field.description,
-        defaultValue: field.defaultValue,
-      }]),
-  );
-
-  return new GraphQLInputObjectType({
-    name: `${inputNamePrefix}${originalType.name}For${connectionFieldName.charAt(0).toUpperCase() + connectionFieldName.slice(1)}`,
-    fields: newFields,
+const createTypeWithExcludedField = (inputNamePrefix, itemType, fieldToExclude,
+  connectionFieldName = fieldToExclude, optionalFields = []) => {
+  // The item's create input is `${itemType.name}Input`, so the name is the one it always had.
+  const name = `${inputNamePrefix}${itemType.name}InputFor${capitalize(connectionFieldName)}`;
+  const shared = excludedFieldInputTypes.get(name);
+  if (shared && shared.itemType === itemType && shared.fieldToExclude === fieldToExclude
+    && shared.optionalFields.join() === optionalFields.join()) {
+    return shared.type;
+  }
+  // Any other type with this name is a new one, so a real name clash still fails as before.
+  const type = new GraphQLInputObjectType({
+    name,
+    fields: () => Object.fromEntries(
+      Object.entries(getInputType(itemType).getFields())
+        .filter(([fieldName]) => fieldName !== fieldToExclude)
+        .map(([fieldName, field]) => [fieldName, {
+          type: optionalFields.includes(fieldName) ? unwrapNonNull(field.type) : field.type,
+          description: field.description,
+          defaultValue: field.defaultValue,
+        }]),
+    ),
   });
-};
-
-const createOneToManyInputType = (inputNamePrefix, fieldEntryName,
-  inputType, updateInputType, connection, itemNonNull = false) => {
-  let inputTypeForAdd = inputType;
-
-  if (connection.declaredFieldName) {
-    inputTypeForAdd = createTypeWithExcludedField(
+  if (!shared) excludedFieldInputTypes.set(name, { itemType, fieldToExclude, optionalFields, type });
+  return type;
+};
+
+// A referenced collection's operation input. The item inputs are read when the schema is built, so
+// the item type's inputs need not exist yet. `added` or `updated` is left out when its item input
+// would have no fields, such as `added` for a child whose only writable field is the back-reference;
+// `deleted` always remains. `owner` names the collection, as `Type.field`, in the warning.
+const createOneToManyInputType = (name, inputNamePrefix, itemType, connection,
+  itemNonNull = false, optionalFields = [], owner = name) => {
+  const inputTypeForAdd = connection.declaredFieldName
+    ? createTypeWithExcludedField(
       inputNamePrefix,
-      inputType,
+      itemType,
       connection.graphqlFieldName || connection.declaredFieldName,
       connection.declaredFieldName,
-    );
-  }
+      optionalFields,
+    )
+    : null;
+  const listOf = (type) => new GraphQLList(itemNonNull ? new GraphQLNonNull(type) : type);
+
+  const omittedOperation = {
+    added: () => `because ${itemType.name} has no writable fields`
+      + `${connection.declaredFieldName ? ` besides its connectionField ${connection.declaredFieldName}` : ''}; `
+      + `create ${itemType.name} records with its own mutations or a registered mutation.`,
+    updated: () => `because ${itemType.name} has no writable fields and no writable id; update `
+      + `${itemType.name} records with a registered mutation.`,
+  };
 
   return new GraphQLInputObjectType({
-    name: `OneToMany${inputNamePrefix}${fieldEntryName}`,
-    fields: () => ({
-      added: {
-        type: new GraphQLList(itemNonNull
-          ? new GraphQLNonNull(inputTypeForAdd) : inputTypeForAdd),
-      },
-      updated: {
-        type: new GraphQLList(itemNonNull
-          ? new GraphQLNonNull(updateInputType) : updateInputType),
-      },
-      deleted: {
-        type: new GraphQLList(itemNonNull ? new GraphQLNonNull(GraphQLID) : GraphQLID),
-      },
-    }),
+    name,
+    fields: () => {
+      const fields = {};
+      const itemInputs = {
+        added: inputTypeForAdd || getInputType(itemType),
+        updated: typesDictForUpdate.types[itemType.name].inputType,
+      };
+      for (const [operation, itemInput] of Object.entries(itemInputs)) {
+        if (hasInputFields(itemInput)) {
+          fields[operation] = { type: listOf(itemInput) };
+        } else {
+          warnOnce(itemType, `emptyItemInput:${owner}:${operation}`, `Configuration issue: ${owner} has no `
+            + `\`${operation}\` operation in generated inputs, ${omittedOperation[operation]()}`);
+        }
+      }
+      // Null IDs are skipped, so `deleted` accepts them whatever the collection's item nullability.
+      fields.deleted = { type: new GraphQLList(GraphQLID) };
+      return fields;
+    },
   });
 };
 
+// What graphQLListInputType returns for a list of an embedded type whose input has no fields.
+const NO_INPUT_FIELDS = Symbol('no input fields');
+
 const graphQLListInputType = (dict, fieldEntry, fieldEntryName,
   inputNamePrefix, connectionField, preserveOuterNonNull, ownerName) => {
   const listShape = getListShape(fieldEntry.type);
   if (!listShape) return null;
   const { itemType } = listShape;
 
-  if (itemType instanceof GraphQLObjectType
-    && requireRegisteredType(dict, itemType, fieldEntryName, ownerName).inputType) {
-    if (!fieldEntry.extensions || !fieldEntry.extensions.relation
-      || !fieldEntry.extensions.relation.embedded) {
-      const oneToMany = createOneToManyInputType(inputNamePrefix, fieldEntryName,
-        typesDict.types[itemType.name].inputType,
-        typesDictForUpdate.types[itemType.name].inputType,
-        normalizeConnectionField(itemType, connectionField),
-        listShape.itemNonNull);
+  if (itemType instanceof GraphQLObjectType) {
+    const registration = requireRegisteredType(dict, itemType, fieldEntryName, ownerName);
+    // A referenced collection reads its item inputs lazily, so it never waits for them.
+    if (!fieldEntry.extensions?.relation?.embedded) {
+      const oneToMany = createOneToManyInputType(`OneToMany${inputNamePrefix}${fieldEntryName}`,
+        inputNamePrefix, itemType, normalizeConnectionField(itemType, connectionField),
+        listShape.itemNonNull, [], `${ownerName}.${fieldEntryName}`);
       return preserveOuterNonNull && listShape.outerNonNull
         ? new GraphQLNonNull(oneToMany)
         : oneToMany;
     }
-    if (fieldEntry.extensions && fieldEntry.extensions.relation
-      && fieldEntry.extensions.relation.embedded) {
-      return wrapListInputType(
-        dict.types[itemType.name].inputType,
-        listShape,
-        preserveOuterNonNull,
-      );
+    if (registration.inputType) {
+      return hasInputFields(registration.inputType)
+        ? wrapListInputType(registration.inputType, listShape, preserveOuterNonNull)
+        : NO_INPUT_FIELDS;
     }
   } else if (itemType instanceof GraphQLScalarType || itemType instanceof GraphQLEnumType) {
     return wrapListInputType(itemType, listShape, preserveOuterNonNull);
@@ -643,13 +796,86 @@ const graphQLListInputType = (dict, fieldEntry, fieldEntryName,
   return null;
 };
 
-const buildInputType = (gqltype) => {
+// Writable list fields whose items are the type itself, as buildInputType selects them. Their
+// collection inputs are named OneToManyA<field> and OneToManyU<field> (see claimSelfCollectionNames).
+const selfCollectionFieldNames = (gqltype) => {
+  const hasStateMachine = !!typesDict.types[gqltype.name]?.stateMachine;
+  return Object.entries(gqltype.getFields())
+    .filter(([fieldName, field]) => !field.extensions?.readOnly
+      && !(fieldName === 'state' && hasStateMachine)
+      && getListShape(field.type)?.itemType === gqltype)
+    .map(([fieldName]) => fieldName);
+};
+
+const selfCollectionInputType = (gqltype, fieldEntryName, fieldEntry, forUpdate, selfFields) => {
+  const listShape = getListShape(fieldEntry.type);
+  const qualifier = qualifiedSelfCollections.get(gqltype)?.has(fieldEntryName) ? gqltype.name : '';
+  const kind = forUpdate ? 'U' : 'A';
+  const oneToMany = createOneToManyInputType(
+    `OneToMany${qualifier}${kind}${fieldEntryName}`,
+    kind,
+    gqltype,
+    normalizeConnectionField(gqltype, fieldEntry.extensions?.relation?.connectionField),
+    listShape.itemNonNull,
+    // Items an add mutation creates may carry their own self-referencing collections. These stay
+    // optional there, as such items had no such fields before; items added by an update keep them
+    // as the type declares them.
+    forUpdate ? [] : selfFields,
+    `${gqltype.name}.${fieldEntryName}`,
+  );
+  return !forUpdate && listShape.outerNonNull ? new GraphQLNonNull(oneToMany) : oneToMany;
+};
+
+// An embedded field, single or list, whose embedded type's create or update input has no fields is
+// left out of that input of its owner. Only the create input is empty when the type's writable fields
+// hold only ids, which create inputs leave out; generated updates still set the field then.
+const warnEmptyEmbeddedInputs = (gqltype, fieldName, embeddedTypeName, noCreate, noUpdate) => {
+  if (!noCreate && !noUpdate) return;
+  const field = `Configuration issue: ${gqltype.name}.${fieldName} `;
+  if (!noUpdate) {
+    warnOnce(gqltype, `emptyEmbeddedInput:${fieldName}`, `${field}is left out of generated create inputs, because `
+      + `the create input of its embedded type ${embeddedTypeName} would have no fields (create inputs leave out `
+      + 'ids), so generated creates cannot set it, while generated updates still can; to set it on create, use a '
+      + 'controller or a registered mutation.');
+    return;
+  }
+  const inputs = [noCreate && 'create', 'update'].filter(Boolean).join(' and ');
+  warnOnce(gqltype, `emptyEmbeddedInput:${fieldName}`, `${field}is left out of generated ${inputs} inputs, because `
+    + `its embedded type ${embeddedTypeName} has no writable fields, so generated mutations cannot set it; set it `
+    + 'in a controller or a registered mutation, and mark it readOnly to state that it is output-only.');
+};
+
+// A non-null embedded field, single or list, that generated create inputs cannot set. Generated
+// mutations that reach the owner's create input would store records without it, so such a schema is
+// rejected; one whose generated mutations cannot reach that input only leaves the field out.
+const requiredEmbeddedWithoutInputError = (gqltype, { field, embeddedTypeName }) => new SimfinityError(
+  `${gqltype.name}.${field} is non-null but its embedded type ${embeddedTypeName} has no writable fields, so `
+    + 'generated create inputs cannot set it; mark it readOnly and set it in a controller, or make it nullable',
+  'INVALID_MODEL',
+  400,
+);
+// Registration -> the non-null embedded fields its create input left out.
+const requiredFieldsWithoutCreateInput = new WeakMap();
+
+// Builds a type's create and update inputs, or returns every field whose input cannot be built yet:
+// `{ unresolvedFields: [{ field, waitsFor }] }`, where `waitsFor` names the embedded type whose
+// inputs the field waits for, and is absent when the field can have no generated input. `reachable`
+// holds the types whose inputs the generated mutations of the schema reach.
+const buildInputType = (gqltype, reachable) => {
   const argTypes = gqltype.getFields();
 
   const fieldsArgs = {};
   const fieldsArgForUpdate = {};
 
   const selfReferenceCollections = {};
+  const unresolvedFields = [];
+  const requiredWithoutCreateInput = [];
+  // Leaves a non-null embedded field without a create input out, or rejects the schema.
+  const omitRequiredEmbedded = (field, embeddedTypeName) => {
+    const omitted = { field, embeddedTypeName };
+    if (reachable.has(gqltype)) throw requiredEmbeddedWithoutInputError(gqltype, omitted);
+    requiredWithoutCreateInput.push(omitted);
+  };
 
   for (const [fieldEntryName, fieldEntry] of Object.entries(argTypes)) {
     const fieldArg = {};
@@ -684,14 +910,31 @@ const buildInputType = (gqltype) => {
             } else if (requireRegisteredType(typesDict, unwrapNonNull(fieldEntry.type), fieldEntryName,
               gqltype.name).inputType
               && typesDictForUpdate.types[fieldEntryNameValue].inputType) {
-              fieldArg.type = typesDict.types[fieldEntryNameValue].inputType;
-              fieldArgForUpdate.type = typesDictForUpdate.types[fieldEntryNameValue].inputType;
+              // Create and update inputs are decided apart: an embedded type whose only writable
+              // field is `id` has one only for updates.
+              const embeddedCreate = typesDict.types[fieldEntryNameValue].inputType;
+              const embeddedUpdate = typesDictForUpdate.types[fieldEntryNameValue].inputType;
+              if (hasInputFields(embeddedCreate)) fieldArg.type = embeddedCreate;
+              else if (fieldEntry.type instanceof GraphQLNonNull) {
+                omitRequiredEmbedded(fieldEntryName, fieldEntryNameValue);
+              }
+              if (hasInputFields(embeddedUpdate)) fieldArgForUpdate.type = embeddedUpdate;
+              warnEmptyEmbeddedInputs(gqltype, fieldEntryName, fieldEntryNameValue,
+                !fieldArg.type, !fieldArgForUpdate.type);
             } else {
-              return null;
+              unresolvedFields.push({ field: fieldEntryName, waitsFor: fieldEntryNameValue });
             }
-          } else {
+          } else if (unresolvedFields.length === 0) {
+            // Fields after one that cannot be built yet are only checked, so this logs as many times
+            // as when the build stopped at that field.
             console.warn(`Configuration issue: Field ${fieldEntryName} does not define extensions.relation`);
           }
+        } else if (isAbstractOutputType(unwrapListAndNonNull(fieldEntry.type))) {
+          // Generated inputs cannot write an interface or union value, single or in a list, so the
+          // field is output-only. readOnly fields never get here.
+          warnOnce(gqltype, `abstract:${fieldEntryName}`, `Configuration issue: ${gqltype.name}.${fieldEntryName} `
+            + 'has an interface or union type, so generated inputs leave it out and generated mutations cannot '
+            + 'set it; resolve it yourself, and mark it readOnly to state that it is output-only.');
         } else if (getListShape(fieldEntry.type)) {
           const listShape = getListShape(fieldEntry.type);
           if (listShape.itemType === gqltype) {
@@ -704,10 +947,17 @@ const buildInputType = (gqltype) => {
               fieldEntryName, `${gqltype.name}U`,
               fieldEntry.extensions?.relation?.connectionField, false, gqltype.name);
             if (listInputTypeForAdd && listInputTypeForUpdate) {
-              fieldArg.type = listInputTypeForAdd;
-              fieldArgForUpdate.type = listInputTypeForUpdate;
+              if (listInputTypeForAdd !== NO_INPUT_FIELDS) fieldArg.type = listInputTypeForAdd;
+              else if (listShape.outerNonNull) omitRequiredEmbedded(fieldEntryName, listShape.itemType.name);
+              if (listInputTypeForUpdate !== NO_INPUT_FIELDS) fieldArgForUpdate.type = listInputTypeForUpdate;
+              warnEmptyEmbeddedInputs(gqltype, fieldEntryName, listShape.itemType.name,
+                listInputTypeForAdd === NO_INPUT_FIELDS, listInputTypeForUpdate === NO_INPUT_FIELDS);
             } else {
-              return null;
+              // An object item here is embedded and its inputs are not built yet; any other item,
+              // such as a list, has no generated input.
+              unresolvedFields.push(listShape.itemType instanceof GraphQLObjectType
+                ? { field: fieldEntryName, waitsFor: listShape.itemType.name }
+                : { field: fieldEntryName });
             }
           }
         }
@@ -729,94 +979,176 @@ const buildInputType = (gqltype) => {
     }
   }
 
-  const inputTypeBody = {
+  if (unresolvedFields.length > 0) return { unresolvedFields };
+
+  // Self-referencing collections follow the other fields, as they always have. Their item inputs
+  // are read when the schema is built, after these input types exist.
+  const selfFields = Object.keys(selfReferenceCollections);
+  for (const [fieldEntryName, fieldEntry] of Object.entries(selfReferenceCollections)) {
+    fieldsArgs[fieldEntryName] = {
+      type: selfCollectionInputType(gqltype, fieldEntryName, fieldEntry, false, selfFields),
+      description: fieldEntry.description,
+    };
+    fieldsArgForUpdate[fieldEntryName] = {
+      type: selfCollectionInputType(gqltype, fieldEntryName, fieldEntry, true, selfFields),
+      description: fieldEntry.description,
+    };
+  }
+
+  const inputTypeForAdd = new GraphQLInputObjectType({
     name: `${gqltype.name}Input`,
     description: gqltype.description,
     fields: fieldsArgs,
-  };
-
-  const inputTypeBodyForUpdate = {
+  });
+  const inputTypeForUpdate = new GraphQLInputObjectType({
     name: `${gqltype.name}InputForUpdate`,
     description: gqltype.description,
     fields: fieldsArgForUpdate,
-  };
-
-  const inputTypeForAdd = new GraphQLInputObjectType(inputTypeBody);
-  const inputTypeForUpdate = new GraphQLInputObjectType(inputTypeBodyForUpdate);
-
-  const inputTypeForAddFields = inputTypeForAdd._fields();
-
-  Object.keys(selfReferenceCollections).forEach((fieldEntryName) => {
-    if (Object.prototype.hasOwnProperty.call(selfReferenceCollections, fieldEntryName)) {
-      const fieldEntry = selfReferenceCollections[fieldEntryName];
-      const listShape = getListShape(fieldEntry.type);
-      const oneToMany = createOneToManyInputType('A', fieldEntryName,
-        inputTypeForAdd, inputTypeForUpdate,
-        normalizeConnectionField(
-          gqltype,
-          fieldEntry.extensions?.relation?.connectionField,
-        ), listShape.itemNonNull);
-      inputTypeForAddFields[fieldEntryName] = {
-        type: listShape.outerNonNull ? new GraphQLNonNull(oneToMany) : oneToMany,
-        name: fieldEntryName,
-      };
-    }
-  });
-
-  inputTypeForAdd._fields = () => inputTypeForAddFields;
-
-  const inputTypeForUpdateFields = inputTypeForUpdate._fields();
-
-  Object.keys(selfReferenceCollections).forEach((fieldEntryName) => {
-    if (Object.prototype.hasOwnProperty.call(selfReferenceCollections, fieldEntryName)) {
-      const fieldEntry = selfReferenceCollections[fieldEntryName];
-      const listShape = getListShape(fieldEntry.type);
-      inputTypeForUpdateFields[fieldEntryName] = {
-        type: createOneToManyInputType('U', fieldEntryName,
-          inputTypeForAdd, inputTypeForUpdate,
-          normalizeConnectionField(
-            gqltype,
-            fieldEntry.extensions?.relation?.connectionField,
-          ), listShape.itemNonNull),
-        name: fieldEntryName,
-      };
-    }
   });
 
-  inputTypeForUpdate._fields = () => inputTypeForUpdateFields;
-
-  return { inputTypeBody: inputTypeForAdd, inputTypeBodyForUpdate: inputTypeForUpdate };
+  return {
+    inputTypeBody: inputTypeForAdd, inputTypeBodyForUpdate: inputTypeForUpdate, requiredWithoutCreateInput,
+  };
 };
 
 const getInputType = (type) => typesDict.types[type.name].inputType;
 
-const buildPendingInputTypes = (waitingForInputType) => {
+// Registered types whose generated inputs the generated mutations of this schema can reach: the
+// included endpoint types and, through their writable fields, embedded types and the items of
+// collections.
+const typesWithReachableInputs = (includedMutationTypes) => {
+  const reached = new Set();
+  const visit = (gqltype) => {
+    if (reached.has(gqltype)) return;
+    reached.add(gqltype);
+    for (const field of Object.values(gqltype.getFields())) {
+      if (field.extensions?.readOnly) continue;
+      const listShape = getListShape(field.type);
+      const target = listShape ? listShape.itemType : unwrapNonNull(field.type);
+      // A single reference is an IdInputType, so it reaches no input of its target.
+      if (target instanceof GraphQLObjectType && typesDict.types[target.name]
+        && (listShape || field.extensions?.relation?.embedded)) {
+        visit(typesDict.types[target.name].gqltype);
+      }
+    }
+  };
+  for (const type of Object.values(typesDict.types)) {
+    if (type.endpoint && !shouldNotBeIncludedInSchema(includedMutationTypes, type.gqltype)) {
+      visit(type.gqltype);
+    }
+  }
+  return reached;
+};
+
+// A self-referencing collection's inputs are OneToManyA<field> and OneToManyU<field>. When several
+// types that the generated mutations reach have one with the same field name, the first registered
+// keeps those names and the others get OneToMany<Type>A<field> and OneToMany<Type>U<field>, as other
+// collections do. Types the mutations cannot reach keep the unqualified names, as such inputs never
+// collided. Names are fixed when a type's inputs are built, at its first schema.
+// A type is qualified only when this schema also reaches an earlier type that holds the unqualified
+// names and is still the type registered under its name, since both inputs then meet in one schema,
+// which failed with a duplicate type name before such names were qualified. Otherwise, as with a
+// type registered again under the same name or after an earlier createSchema(), it keeps the
+// unqualified names.
+const claimSelfCollectionNames = (pending, includedMutationTypes) => {
+  const reachable = typesWithReachableInputs(includedMutationTypes);
+  const meets = (type) => typesDict.types[type.name]?.gqltype === type && reachable.has(type);
+  for (const { gqltype } of Object.values(pending)) {
+    if (typesDict.types[gqltype.name].inputType) continue;
+    for (const fieldName of selfCollectionFieldNames(gqltype)) {
+      if (!selfCollectionNameHolders.has(fieldName)) selfCollectionNameHolders.set(fieldName, []);
+      const holders = selfCollectionNameHolders.get(fieldName);
+      const owner = reachable.has(gqltype) && holders.find((type) => type !== gqltype && meets(type));
+      if (!owner) {
+        if (!holders.includes(gqltype)) holders.push(gqltype);
+      } else {
+        if (!qualifiedSelfCollections.has(gqltype)) qualifiedSelfCollections.set(gqltype, new Set());
+        qualifiedSelfCollections.get(gqltype).add(fieldName);
+        warnOnce(gqltype, `selfCollectionName:${fieldName}`, `Configuration issue: ${gqltype.name}.${fieldName} `
+          + `and ${owner.name}.${fieldName} are self-referencing collections with the same name, so the inputs `
+          + `of ${gqltype.name}.${fieldName} are named OneToMany${gqltype.name}A${fieldName} and `
+          + `OneToMany${gqltype.name}U${fieldName}, while ${owner.name}.${fieldName} keeps OneToManyA${fieldName} `
+          + `and OneToManyU${fieldName}. To choose which type keeps those names, register it first, or make `
+          + 'the other type unreachable from the generated mutations.');
+      }
+    }
+  }
+};
+
+// The INPUT_TYPE_UNRESOLVED message. It names every field whose input could not be built, by type:
+// the causes (lists whose items have no generated input, and embedded fields whose types contain
+// each other) and, apart from them, fields that only wait for another listed type.
+const unresolvedInputTypesMessage = (pendingTypeNames, unresolvedByType) => {
+  // Whether the inputs of type `from` wait, through embedded fields, for those of type `to`.
+  const waitsOn = (from, to, seen = new Set()) => {
+    if (from === to) return true;
+    if (seen.has(from)) return false;
+    seen.add(from);
+    return (unresolvedByType[from] || [])
+      .some(({ waitsFor }) => waitsFor !== undefined && waitsOn(waitsFor, to, seen));
+  };
+  const lists = [];
+  const cycles = [];
+  const waiting = [];
+  for (const [typeName, fields] of Object.entries(unresolvedByType)) {
+    for (const { field, waitsFor } of fields) {
+      const name = `${typeName}.${field}`;
+      if (waitsFor === undefined) lists.push(name);
+      else if (waitsOn(waitsFor, typeName)) cycles.push(name);
+      else waiting.push(`${name} waits for ${waitsFor}`);
+    }
+  }
+  const causes = [
+    lists.length > 0 && `${lists.join(', ')} (writable lists whose items have no generated input, such as lists of lists)`,
+    cycles.length > 0 && `${cycles.join(', ')} (embedded types that contain each other)`,
+  ].filter(Boolean);
+  return `Could not build input types for: ${pendingTypeNames.join(', ')}. `
+    + 'Check for circular or misconfigured relations'
+    + (causes.length > 0
+      ? `: no input can be generated for ${causes.join(' or for ')}; mark such a field readOnly.`
+      : '.')
+    + (waiting.length > 0
+      ? ` These fields only wait for another listed type and build once it does: ${waiting.join(', ')}.`
+      : '');
+};
+
+const buildPendingInputTypes = (waitingForInputType, includedMutationTypes) => {
+  claimSelfCollectionNames(waitingForInputType, includedMutationTypes);
+  // Inputs built for an earlier schema, which did not reach them, may leave out a non-null embedded
+  // field that this schema's generated mutations would need; inputs built now are checked as built.
+  const reachable = typesWithReachableInputs(includedMutationTypes);
+  for (const gqltype of reachable) {
+    const registration = typesDict.types[gqltype.name];
+    const [omitted] = (registration.inputType && requiredFieldsWithoutCreateInput.get(registration)) || [];
+    if (omitted) throw requiredEmbeddedWithoutInputError(gqltype, omitted);
+  }
   let pending = waitingForInputType;
   let previousPendingCount = Object.keys(pending).length + 1;
+  // Type name -> the fields whose input could not be built in the last pass.
+  let unresolvedFields = {};
 
   while (Object.keys(pending).length > 0) {
     const currentCount = Object.keys(pending).length;
     if (currentCount >= previousPendingCount) {
-      const unresolved = Object.keys(pending).join(', ');
-      throw new SimfinityError(
-        `Could not build input types for: ${unresolved}. Check for circular or misconfigured relations.`,
-        'INPUT_TYPE_UNRESOLVED',
-        500,
-      );
+      throw new SimfinityError(unresolvedInputTypesMessage(Object.keys(pending), unresolvedFields),
+        'INPUT_TYPE_UNRESOLVED', 500);
     }
     previousPendingCount = currentCount;
 
     const stillWaiting = {};
+    unresolvedFields = {};
     for (const [key, value] of Object.entries(pending)) {
       const { gqltype } = value;
       if (typesDict.types[gqltype.name].inputType) continue;
 
-      const result = buildInputType(gqltype);
-      if (result && result.inputTypeBody && result.inputTypeBodyForUpdate) {
+      const result = buildInputType(gqltype, reachable);
+      if (result.inputTypeBody && result.inputTypeBodyForUpdate) {
         typesDict.types[gqltype.name].inputType = result.inputTypeBody;
         typesDictForUpdate.types[gqltype.name].inputType = result.inputTypeBodyForUpdate;
+        requiredFieldsWithoutCreateInput.set(typesDict.types[gqltype.name], result.requiredWithoutCreateInput);
       } else {
         stillWaiting[key] = value;
+        unresolvedFields[gqltype.name] = result.unresolvedFields;
       }
     }
     pending = stillWaiting;
@@ -1070,7 +1402,11 @@ const onUpdateSubject = async (Model, gqltype, controller, args, session, linkTo
   if (!result) throw new SimfinityError(`${gqltype.name} ${objectId} is not valid`, 'NOT_VALID_ID', 404);
 
   if (materializedModel.collectionFields) {
-    await iterateOnCollectionFields(materializedModel, gqltype, objectId, session, context);
+    // Children link to, and are owned through, the parent's stored key, as when a new parent is
+    // saved: the client may send a spelling of the ID that the adapter accepts but does not store,
+    // such as an uppercase ObjectId or UUID. It is the key the generated collection field reads
+    // children by (`_id`, else `id`); an adapter whose update result has neither keeps the requested ID.
+    await iterateOnCollectionFields(materializedModel, gqltype, result._id ?? result.id ?? objectId, session, context);
   }
 
   if (controller && controller.onUpdated) {
@@ -1232,7 +1568,9 @@ const executeOperation = (Model, gqltype, controller, args, operation, actionFie
   );
 };
 
-const executeItemFunction = async (gqltype, collectionField, objectId, session,
+// parentKey is the parent's stored key: children are linked to it, and an updated or deleted child
+// must already store it in its connectionField.
+const executeItemFunction = async (gqltype, collectionField, parentKey, session,
   collectionFieldsList, operationType, context) => {
   const argTypes = gqltype.getFields();
   const collectionGQLType = unwrapListAndNonNull(argTypes[collectionField].type);
@@ -1246,7 +1584,7 @@ const executeItemFunction = async (gqltype, collectionField, objectId, session,
   const type = operationType === operations.UPDATE
     ? typesDictForUpdate.types[collectionGQLType.name] : typesDict.types[collectionGQLType.name];
   const linkToParent = (item) => {
-    item[connection.storageFieldName] = objectId;
+    item[connection.storageFieldName] = parentKey;
     if (item.$unset) delete item.$unset[connection.storageFieldName];
     if (item.$set) delete item.$set[connection.storageFieldName];
   };
@@ -1262,8 +1600,8 @@ const executeItemFunction = async (gqltype, collectionField, objectId, session,
       if (!child) {
         throw new SimfinityError(`${collectionGQLType.name} ${id} is not valid`, 'NOT_VALID_ID', 404);
       }
-      if (String(child[connection.storageFieldName]) !== String(objectId)) {
-        throw new SimfinityError('Child does not belong to this parent', 'FORBIDDEN', 403);
+      if (String(child[connection.storageFieldName]) !== String(parentKey)) {
+        throw new ForbiddenError('Child does not belong to this parent');
       }
     }
 
@@ -1528,39 +1866,61 @@ const resolveById = async (type, args, context, requiredId) => {
   return results[0] || null;
 };
 
+// Why a type's generated create or update input has no fields, for the warnings of buildMutation. An
+// update input also needs a writable id.
+const withoutWritableFields = (type, { noWritableId = false } = {}) => {
+  const stateField = type.gqltype.getFields().state;
+  const managedState = type.stateMachine && stateField && !stateField.extensions?.readOnly;
+  const state = managedState ? ' besides its state, which its state machine manages' : '';
+  const id = noWritableId ? `${state ? ',' : ''} and no writable id` : '';
+  return `${type.gqltype.name} has no writable fields${state}${id}`;
+};
+
 // Every generated mutation field carries extensions.simfinityMutation with its operation (and, for
 // a state-machine action, the action and its from/to states), so tools such as the MCP package can
 // classify it without guessing from its name. Extensions do not appear in SDL or introspection.
+// An input object needs a field, so a type whose create input has none gets no add mutation, and
+// one whose update input has none, which only a type without a writable id can have, gets no update
+// mutation or state machine actions either (#161).
 const buildMutation = (name, includedMutationTypes, includedCustomMutations) => {
   const rootQueryArgs = {};
   rootQueryArgs.name = name;
   rootQueryArgs.fields = {};
 
-  buildPendingInputTypes(waitingInputType);
+  buildPendingInputTypes(waitingInputType, includedMutationTypes);
 
   for (const type of Object.values(typesDict.types)) {
     if (!shouldNotBeIncludedInSchema(includedMutationTypes, type.gqltype)) {
       if (type.endpoint) {
         const argsObject = { input: { type: new GraphQLNonNull(type.inputType) } };
 
-        rootQueryArgs.fields[`add${type.simpleEntityEndpointName}`] = {
-          type: type.gqltype,
-          description: 'add',
-          args: argsObject,
-          extensions: { simfinityMutation: { typeName: type.gqltype.name, operation: operations.SAVE } },
-          async resolve(parent, args, context) {
-            const params = {
-              type,
-              args,
-              operation: operations.SAVE,
-              context,
-            };
+        if (hasInputFields(type.inputType)) {
+          rootQueryArgs.fields[`add${type.simpleEntityEndpointName}`] = {
+            type: type.gqltype,
+            description: 'add',
+            args: argsObject,
+            extensions: { simfinityMutation: { typeName: type.gqltype.name, operation: operations.SAVE } },
+            async resolve(parent, args, context) {
+              const params = {
+                type,
+                args,
+                operation: operations.SAVE,
+                context,
+              };
 
-            await executeMiddleware(params);
-            return executeOperation(type.model, type.gqltype, type.controller,
-              args.input, operations.SAVE, null, null, context, type.inputType);
-          },
-        };
+              await executeMiddleware(params);
+              return executeOperation(type.model, type.gqltype, type.controller,
+                args.input, operations.SAVE, null, null, context, type.inputType);
+            },
+          };
+        } else {
+          warnOnce(type.gqltype, 'emptyCreateInput', `Configuration issue: ${withoutWritableFields(type)}, so the `
+            + `schema has no add${type.simpleEntityEndpointName} mutation; create its records with a registered `
+            + (type.stateMachine
+              ? 'mutation, which must set the initial state (saveObject() sets it).'
+              : `mutation that takes no input or an input of its own, since getInputType(${type.gqltype.name}) `
+                + 'has no fields.'));
+        }
         rootQueryArgs.fields[`delete${type.simpleEntityEndpointName}`] = {
           type: type.gqltype,
           description: 'delete',
@@ -1585,7 +1945,12 @@ const buildMutation = (name, includedMutationTypes, includedCustomMutations) =>
 
   for (const type of Object.values(typesDictForUpdate.types)) {
     if (!shouldNotBeIncludedInSchema(includedMutationTypes, type.gqltype)) {
-      if (type.endpoint) {
+      if (type.endpoint && !hasInputFields(type.inputType)) {
+        const reason = withoutWritableFields(type, { noWritableId: true });
+        warnOnce(type.gqltype, 'emptyUpdateInput', `Configuration issue: ${reason}, so its generated update input `
+          + `would have no fields and the schema has no update${type.simpleEntityEndpointName} mutation`
+          + `${type.stateMachine ? ' and no state machine actions' : ''}.`);
+      } else if (type.endpoint) {
         const argsObject = { input: { type: new GraphQLNonNull(type.inputType) } };
         rootQueryArgs.fields[`update${type.simpleEntityEndpointName}`] = {
           type: type.gqltype,
@@ -1671,7 +2036,7 @@ const buildMutation = (name, includedMutationTypes, includedCustomMutations) =>
   return new GraphQLObjectType(rootQueryArgs);
 };
 
-const buildRootQuery = (name, includedTypes) => {
+const buildRootQuery = (name, includedTypes, aggregationResultType = QLTypeAggregationResult) => {
   const rootQueryArgs = {};
   rootQueryArgs.name = name;
   rootQueryArgs.fields = {};
@@ -1708,7 +2073,8 @@ const buildRootQuery = (name, includedTypes) => {
             await executeScope(params);
             await applyJoinedScopes(joinedScopes, params);
             const queryArgs = params.args;
-            const wantsCount = !!(queryArgs.pagination && queryArgs.pagination.count);
+            const wantsCount = !!(queryArgs.pagination && queryArgs.pagination.count)
+              && canReportCount(parent, info, context);
 
             const dataPromise = adapter.find(type.model, type.gqltype, queryArgs, null);
             const countPromise = wantsCount
@@ -1716,8 +2082,10 @@ const buildRootQuery = (name, includedTypes) => {
               : null;
 
             const [result, resultCount] = await Promise.all([dataPromise, countPromise]);
-            if (wantsCount) {
-              reportCount(parent, info, context, resultCount);
+            if (wantsCount && !reportCount(parent, info, context, resultCount)) {
+              warnOnce(runtimeIdentity, 'count-context', 'Configuration issue: the GraphQL context does not accept '
+                + 'a count property (it is frozen, sealed or has a read-only count), so pagination counts are not '
+                + 'reported; pass a fresh mutable context object for each request.');
             }
             return result;
           },
@@ -1734,7 +2102,7 @@ const buildRootQuery = (name, includedTypes) => {
         };
 
         rootQueryArgs.fields[`${type.listEntitiesEndpointName}_aggregate`] = {
-          type: new GraphQLList(QLTypeAggregationResult),
+          type: new GraphQLList(aggregationResultType),
           args: aggregateArgsObject,
           extensions: { simfinityQuery: { typeName: type.gqltype.name, operation: 'aggregate' } },
           async resolve(parent, args, context) {
@@ -1785,6 +2153,102 @@ const installIdResolver = (gqltype) => {
   if (idField && !idField.resolve) idField.resolve = markGenerated((parent) => parent._id ?? parent.id);
 };
 
+// A rendered embedded value that may hold no data: a plain object, or a hydrated record, which
+// converts itself with toObject() (MongoDB documents and their nested paths do). Promises, arrays,
+// functions and other objects, such as dates or identifiers, are values.
+const isRecordObject = (value) => {
+  if (value === null || typeof value !== 'object' || Array.isArray(value) || isThenable(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null || typeof value.toObject === 'function';
+};
+const isPlainObject = (value) => {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+
+// The members an embedded value stores. The rule below reads them instead of the value, so no getter
+// or virtual of the application runs, whatever the selection. An adapter that hydrates records
+// returns their stored data through rawEmbeddedValue (MongoDB: a nested path's raw value, a
+// subdocument's _doc); an absent stored value has no members. A plain object is read as it is.
+// Returns null for anything else, such as a record the adapter does not convert, which counts as data.
+const storedMembersOf = (value) => {
+  if (!isRecordObject(value)) return null;
+  const stored = typeof adapter.rawEmbeddedValue === 'function' ? adapter.rawEmbeddedValue(value) : value;
+  if (stored === null || stored === undefined) return {};
+  return typeof stored === 'object' && !Array.isArray(stored) && !isThenable(stored) && isPlainObject(stored)
+    ? stored : null;
+};
+
+// A stored member: an own data property, read without calling accessors. An accessor is present,
+// whatever it would return.
+const PRESENT = Symbol('present');
+const ownStoredValue = (stored, key) => {
+  const descriptor = Object.getOwnPropertyDescriptor(stored, key);
+  if (!descriptor) return undefined;
+  if (!('value' in descriptor)) return PRESENT;
+  return isObjectMember(key, descriptor.value) ? undefined : descriptor.value;
+};
+// A referenced collection stores nothing in the object. `id` reads the stored identity, `_id` before
+// `id`, as the generated entity resolver (installIdResolver) and Mongoose's id virtual do. Every other
+// member is stored under its storage name.
+const isReferencedCollection = (member) => {
+  const relation = member.extensions?.relation;
+  return Boolean(relation && !relation.embedded && getListShape(member.type));
+};
+const storedMemberValue = (stored, memberName, member) => {
+  if (isReferencedCollection(member)) return undefined;
+  const identity = memberName === 'id' ? ownStoredValue(stored, '_id') : undefined;
+  return identity ?? ownStoredValue(stored, getFieldStorageName(memberName, member));
+};
+
+// Whether stored members hold no data: every member is null or undefined, an empty list, or a
+// singular embedded object that holds no data. Any other value, a promise or an accessor included,
+// is data. An object that contains itself, which only a custom result can, holds data.
+const holdsNoData = (stored, type, ancestors = []) => !ancestors.includes(stored)
+  && Object.entries(type.getFields()).every(([memberName, member]) => {
+    const value = storedMemberValue(stored, memberName, member);
+    if (value === null || value === undefined) return true;
+    if (Array.isArray(value)) return value.length === 0;
+    const memberType = unwrapNonNull(member.type);
+    if (member.extensions?.relation?.embedded !== true || !(memberType instanceof GraphQLObjectType)) return false;
+    const nested = storedMembersOf(value);
+    return nested !== null && holdsNoData(nested, memberType, [...ancestors, stored]);
+  });
+
+// The members that count: non-null members that generated inputs accept. As on writes
+// (completeEmbeddedValue), `id` and readOnly members do not; nor do interface and union members,
+// which buildInputType leaves out; nor do referenced collections or members with an application
+// resolver, which may compute a value.
+const countsAsRequired = (type, memberName, member) => member.type instanceof GraphQLNonNull
+  && !isReferencedCollection(member) && memberName !== 'id' && !member.extensions?.readOnly
+  && !isAbstractOutputType(unwrapListAndNonNull(member.type)) && !hasApplicationResolver(type, memberName);
+const hasRequiredMember = (type) => Object.entries(type.getFields())
+  .some(([memberName, member]) => countsAsRequired(type, memberName, member));
+
+// Whether rendering such an object fails: a member that counts is null or undefined, or is a singular
+// embedded object that misses one of its own. A promise or an accessor counts as present.
+const missesRequiredMember = (stored, type) => Object.entries(type.getFields()).some(([memberName, member]) => {
+  if (!countsAsRequired(type, memberName, member)) return false;
+  const value = storedMemberValue(stored, memberName, member);
+  if (value === null || value === undefined) return true;
+  if (member.extensions?.relation?.embedded !== true || !(member.type.ofType instanceof GraphQLObjectType)) return false;
+  const nested = storedMembersOf(value);
+  return nested !== null && missesRequiredMember(nested, member.type.ofType);
+});
+
+// A type without a member that counts never reads as null, so its values are returned untouched,
+// with no member read. Reading stored members never changes the result otherwise: a value whose
+// members cannot be read, because an adapter hook or a property read throws, is returned as it is.
+const readEmbeddedObject = (value, type) => {
+  if (!(type instanceof GraphQLObjectType) || !hasRequiredMember(type)) return value;
+  try {
+    const stored = storedMembersOf(value);
+    return stored !== null && holdsNoData(stored, type) && missesRequiredMember(stored, type) ? null : value;
+  } catch {
+    return value;
+  }
+};
+
 // An adapter that hydrates stored records may render an explicitly null singular embedded object as
 // an object (MongoDB nested paths do); readEmbeddedValue returns null for it. Nullable singular
 // embedded fields of registered types, and of the embedded types they reach, read through it. The
@@ -1793,11 +2257,24 @@ const installIdResolver = (gqltype) => {
 // The value is read as graphql's default resolver reads it, so a method on the parent, such as one a
 // custom mutation result supplies, is still called; a promise it returns is read once it settles.
 // Only a field named like an Object.prototype member that reads as that member reads as null.
+// Such an adapter may also render an absent object, or store an omitted one, as an object that holds
+// nothing but its list defaults (MongoDB nested paths do). An object that holds no data and misses a
+// required member (see missesRequiredMember) cannot be rendered, so it reads as null, as an absent
+// object does on other read paths, whatever the selection. The rule reads the stored members
+// (storedMembersOf), never running a getter or virtual, and depends only on the value and its type,
+// so runtimes that share the type, with or without the hook, read the same. An object a
+// generated create or update writes does not read as null, since those writes require the members
+// counted, with one exception: Mongoose minimizes empty objects when it saves a new document, so a
+// create that writes an empty object for a required embedded member (`geo: {}`) stores that member
+// as absent. An object that holds nothing else then reads as null, as an omitted one does, except
+// where Mongoose hydrates the document (by-ID and reference reads, update responses) and the member is
+// a nested path, which it renders as `{}`. Generated models declare every embedded member as a nested
+// path except one named `type`, a single nested subdocument. PostgreSQL rejects such a create
+// (REQUIRED_VALUE).
 const readEmbeddedField = markGenerated((parent, args, context, info) => {
   const value = readOwnField(parent, args, context, info);
-  return isThenable(value)
-    ? value.then((resolved) => adapter.readEmbeddedValue(resolved))
-    : adapter.readEmbeddedValue(value);
+  const read = (resolved) => readEmbeddedObject(adapter.readEmbeddedValue(resolved), getNamedType(info.returnType));
+  return isThenable(value) ? value.then(read) : read(value);
 });
 
 const installEmbeddedValueResolvers = (gqltype, visited) => {
@@ -1860,6 +2337,20 @@ const assertCollectionConnections = () => {
 
 const getRegistrations = () => Object.values(typesDict.types);
 
+// Application types that a schema with these allowlists contains, whatever else it reaches: the
+// endpoint types of its queries and mutations, and the input and output types of its registered
+// mutations.
+const includedApplicationTypes = (includedQueryTypes, includedMutationTypes, includedCustomMutations) => [
+  ...Object.values(typesDict.types)
+    .filter((type) => type.endpoint
+      && ((type.simpleEntityEndpointName && !shouldNotBeIncludedInSchema(includedQueryTypes, type.gqltype))
+        || !shouldNotBeIncludedInSchema(includedMutationTypes, type.gqltype)))
+    .map((type) => type.gqltype),
+  ...Object.entries(registeredMutations)
+    .filter(([entry]) => !shouldNotBeIncludedInSchema(includedCustomMutations, entry))
+    .flatMap(([, { inputModel, outputModel }]) => [inputModel, outputModel].filter(Boolean)),
+];
+
 const createSchema = (includedQueryTypes, includedMutationTypes, includedCustomMutations) => {
   // Reject before models, resolvers or roots are built, so a rejected schema changes nothing.
   Object.values(typesDict.types).forEach(({ gqltype }) => validateScope(gqltype));
@@ -1867,6 +2358,11 @@ const createSchema = (includedQueryTypes, includedMutationTypes, includedCustomM
   schemaTypes.forEach(assertNotBoundElsewhere);
   schemaTypes.forEach(assertFieldsNotBoundElsewhere);
   assertCollectionConnections();
+  // An application type with the name of a field metadata type that an earlier schema fixed; one that
+  // only generated types or the fields of an input object reach is found when the schema is
+  // constructed.
+  assertFieldMetadataNamesFree(includedApplicationTypes(includedQueryTypes, includedMutationTypes,
+    includedCustomMutations));
   const referencedTypes = markReferencedTypesForModelGeneration();
   // Entities, which keep their own stored identity: connect() types and relation targets.
   Object.values(typesDict.types).forEach((typeInfo) => {
@@ -1914,17 +2410,21 @@ const createSchema = (includedQueryTypes, includedMutationTypes, includedCustomM
   const objectMemberTypes = new Set();
   Object.values(typesDict.types).forEach(({ gqltype }) => installObjectMemberResolvers(gqltype, objectMemberTypes));
 
-  const query = buildRootQuery('RootQueryType', includedQueryTypes);
+  let query = buildRootQuery('RootQueryType', includedQueryTypes);
   Object.values(typesDict.types).forEach(({ gqltype }) => {
     if (gqltype && !applicationResolvedFields.has(gqltype)) {
       applicationResolvedFields.set(gqltype, listApplicationResolvedFields(gqltype));
     }
   });
+  const mutation = buildMutation('Mutation', includedMutationTypes, includedCustomMutations);
+  // An application scalar named JSON that this schema contains also types aggregation results. Any
+  // other type named JSON still collides, and GraphQLSchema reports the duplicate name.
+  const applicationJSON = findSchemaType([query, mutation], 'JSON', QLTypeAggregationResult);
+  if (applicationJSON instanceof GraphQLScalarType) {
+    query = buildRootQuery('RootQueryType', includedQueryTypes, aggregationResultTypeFor(applicationJSON));
+  }
 
-  const schema = new GraphQLSchema({
-    query,
-    mutation: buildMutation('Mutation', includedMutationTypes, includedCustomMutations),
-  });
+  const schema = constructSchema(query, mutation);
   // Reserve reachable types whose relation fields still have no resolver, such as an unregistered
   // custom mutation result, so another runtime cannot later generate resolvers this schema executes.
   schemaTypes.forEach((type) => {
@@ -2047,6 +2547,14 @@ const autoGenerateResolvers = (gqltype) => {
   }
 };
 
+// A replaced registration builds fresh inputs. Its cached collection projections may already
+// contain fields from the previous input graph; keep those alive only in earlier schemas.
+const invalidateCollectionInputs = (gqltype) => {
+  for (const [name, cached] of excludedFieldInputTypes) {
+    if (cached.itemType.name === gqltype.name) excludedFieldInputTypes.delete(name);
+  }
+};
+
 const connect = (model, gqltype, simpleEntityEndpointName,
   listEntitiesEndpointName, controller, onModelCreated, stateMachine) => {
   const registration = {
@@ -2063,6 +2571,7 @@ const connect = (model, gqltype, simpleEntityEndpointName,
   validateScope(gqltype);
   if (adapter.validateRegistration) adapter.validateRegistration(registration);
 
+  invalidateCollectionInputs(gqltype);
   waitingInputType[gqltype.name] = {
     model,
     gqltype,
@@ -2092,6 +2601,7 @@ const addNoEndpointType = (gqltype) => {
   validateScope(gqltype);
   if (adapter.validateRegistration) adapter.validateRegistration(registration);
 
+  invalidateCollectionInputs(gqltype);
   waitingInputType[gqltype.name] = { gqltype };
   typesDict.types[gqltype.name] = registration;
   typesDictForUpdate.types[gqltype.name] = { ...typesDict.types[gqltype.name] };
@@ -2115,27 +2625,31 @@ const createArgsForQuery = (gqltype, omit = null) => {
 
     for (const [fieldEntryName, fieldEntry] of Object.entries(argTypes)) {
       if (fieldEntryName === omit) continue;
-      argsObject[fieldEntryName] = {};
+      let filterType = null;
 
       if (fieldEntry.type instanceof GraphQLScalarType
         || isNonNullOfType(fieldEntry.type, GraphQLScalarType)
         || fieldEntry.type instanceof GraphQLEnumType
         || isNonNullOfType(fieldEntry.type, GraphQLEnumType)) {
-        argsObject[fieldEntryName].type = QLFilter;
+        filterType = QLFilter;
       } else if (fieldEntry.type instanceof GraphQLObjectType
         || isNonNullOfType(fieldEntry.type, GraphQLObjectType)) {
-        argsObject[fieldEntryName].type = QLTypeFilterExpression;
+        filterType = QLTypeFilterExpression;
       } else if (getListShape(fieldEntry.type)) {
         const listOfType = getListShape(fieldEntry.type).itemType;
         if (listOfType instanceof GraphQLScalarType
           || isNonNullOfType(listOfType, GraphQLScalarType)
           || listOfType instanceof GraphQLEnumType
           || isNonNullOfType(listOfType, GraphQLEnumType)) {
-          argsObject[fieldEntryName].type = QLFilter;
+          filterType = QLFilter;
         } else {
-          argsObject[fieldEntryName].type = QLTypeFilterExpression;
+          // Includes lists of interfaces and unions, which have no generated filter either. Their
+          // argument has always been generated and is kept, so requests that send it as null stay valid.
+          filterType = QLTypeFilterExpression;
         }
       }
+      // A single interface or union field has no generated filter, so it gets no argument.
+      if (filterType) argsObject[fieldEntryName] = { type: filterType };
     }
 
     argsObject.pagination = {};