@apollo/federation-internals 2.0.0-alpha.1 → 2.0.0-alpha.2

package/src/definitions.ts

@@ -135,23 +135,23 @@ export function isCustomScalarType(type: Type): boolean {
 }
 
 export function isIntType(type: Type): boolean {
-  return type === type.schema()?.intType();
+  return type === type.schema().intType();
 }
 
 export function isStringType(type: Type): boolean {
-  return type === type.schema()?.stringType();
+  return type === type.schema().stringType();
 }
 
 export function isFloatType(type: Type): boolean {
-  return type === type.schema()?.floatType();
+  return type === type.schema().floatType();
 }
 
 export function isBooleanType(type: Type): boolean {
-  return type === type.schema()?.booleanType();
+  return type === type.schema().booleanType();
 }
 
 export function isIDType(type: Type): boolean {
-  return type === type.schema()?.idType();
+  return type === type.schema().idType();
 }
 
 export function isObjectType(type: Type): type is ObjectType {
@@ -323,7 +323,7 @@ export class DirectiveTargetElement<T extends DirectiveTargetElement<T>> {
   ): Directive<T, TApplicationArgs> {
     let toAdd: Directive<T, TApplicationArgs>;
     if (defOrDirective instanceof Directive) {
-      if (defOrDirective.schema() && defOrDirective.schema() != this.schema()) {
+      if (defOrDirective.schema() != this.schema()) {
         throw new Error(`Cannot add directive ${defOrDirective} to ${this} as it is attached to another schema`);
       }
       toAdd = defOrDirective;
@@ -377,24 +377,41 @@ abstract class Element<TParent extends SchemaElement<any, any> | Schema | Direct
   protected _parent?: TParent;
   sourceAST?: ASTNode;
 
-  schema(): Schema | undefined {
+  schema(): Schema {
+    const schema = this.schemaInternal();
+    assert(schema, 'requested schema does not exist. Probably because the element is unattached');
+    return schema;
+  }
+
+  // this function exists because sometimes we can have an element that will be attached soon even though the current state is unattached
+  // (mainly for callbacks). Sometimes these intermediate states need to get the schema if it exists, but it may not.
+  // all external clients should use schema()
+  protected schemaInternal(): Schema | undefined {
     if (!this._parent) {
       return undefined;
     } else if (this._parent instanceof Schema) {
-      // Note: at the time of this writing, it seems like typescript type-checking breaks a bit around generics. 
+      // Note: at the time of this writing, it seems like typescript type-checking breaks a bit around generics.
       // At this point of the code, `this._parent` is typed as 'TParent & Schema', but for some reason this is
       // "not assignable to type 'Schema | undefined'" (which sounds wrong: if my type theory is not too broken,
       // 'A & B' should always be assignable to both 'A' and 'B').
       return this._parent as any;
-    } else {
-      return (this._parent as SchemaElement<any, any> | DirectiveTargetElement<any>).schema();
+    } else if (this._parent instanceof SchemaElement) {
+      return this._parent.schemaInternal();
+    } else if (this._parent instanceof DirectiveTargetElement) {
+      return this._parent.schema();
     }
+    assert(false, 'unreachable code. parent is of unknown type');
   }
 
-  get parent(): TParent | undefined {
+  get parent(): TParent {
+    assert(this._parent, 'trying to access non-existent parent');
     return this._parent;
   }
 
+  isAttached(): boolean {
+    return !!this._parent;
+  }
+
   // Accessed only through Element.prototype['setParent'] (so we don't mark it protected as an override wouldn't be properly called).
   private setParent(parent: TParent) {
     assert(!this._parent, "Cannot set parent of an already attached element");
@@ -410,10 +427,10 @@ abstract class Element<TParent extends SchemaElement<any, any> | Schema | Direct
     // Allowing to add element to a detached element would get hairy. Because that would mean that when you do attach an element,
     // you have to recurse within that element to all children elements to check whether they are attached or not and to which
     // schema. And if they aren't attached, attaching them as side-effect could be surprising (think that adding a single field
-    // to a schema could bring a whole hierachy of types and directives for instance). If they are attached, it only work if
+    // to a schema could bring a whole hierarchy of types and directives for instance). If they are attached, it only work if
     // it's to the same schema, but you have to check.
     // Overall, it's simpler to force attaching elements before you add other elements to them.
-    if (!this.schema()) {
+    if (!this.isAttached()) {
       throw error(`Cannot modify detached element ${this}`);
     }
   }
@@ -449,8 +466,8 @@ export abstract class SchemaElement<TOwnType extends SchemaElement<any, TParent>
 
   hasAppliedDirective(nameOrDefinition: string | DirectiveDefinition<any>): boolean {
     // From the type-system point of view, there is no `appliedDirectivesOf(_: string | DirectiveDefinition)` function, but rather 2 overloads, neither of
-    // which can take 'string | DirectiveDefinition', hence the need for this suprisingly looking code. And we don't really want to remove the overloading
-    // on `applieddDirectivesOf` because that would lose us the type-checking of arguments in the case where we pass a defintion (or rather, we could
+    // which can take 'string | DirectiveDefinition', hence the need for this surprisingly looking code. And we don't really want to remove the overloading
+    // on `appliedDirectivesOf` because that would lose us the type-checking of arguments in the case where we pass a definition (or rather, we could
     // preserve it, but it would make is a bit too easy to mess up calls with the 'string' argument).
     return (typeof nameOrDefinition === 'string'
       ? this.appliedDirectivesOf(nameOrDefinition)
@@ -473,9 +490,9 @@ export abstract class SchemaElement<TOwnType extends SchemaElement<any, TParent>
       let name: string;
       if (typeof nameOrDefOrDirective === 'string') {
         this.checkUpdate();
-        const def = this.schema()!.directive(nameOrDefOrDirective);
+        const def = this.schema().directive(nameOrDefOrDirective);
         if (!def) {
-          throw new GraphQLError(`Cannot apply unkown directive "@${nameOrDefOrDirective}"`);
+          throw new GraphQLError(`Cannot apply unknown directive "@${nameOrDefOrDirective}"`);
         }
         name = nameOrDefOrDirective;
       } else {
@@ -499,7 +516,7 @@ export abstract class SchemaElement<TOwnType extends SchemaElement<any, TParent>
   }
 
   protected onModification() {
-    const schema = this.schema();
+    const schema = this.schemaInternal();
     if (schema) {
       Schema.prototype['onModification'].call(schema);
     }
@@ -511,7 +528,7 @@ export abstract class SchemaElement<TOwnType extends SchemaElement<any, TParent>
 
   protected removeTypeReferenceInternal(type: BaseNamedType<any, any>) {
     // This method is a bit of a hack: we don't want to expose it and we call it from an other class, so we call it though
-    // `SchemaElement.prototype`, but we also want this to abstract as it can only be impemented by each concrete subclass.
+    // `SchemaElement.prototype`, but we also want this to abstract as it can only be implemented by each concrete subclass.
     // As we can't have both at the same time, this method just delegate to `remoteTypeReference` which is genuinely
     // abstract. This also allow to work around the typing issue that the type checker cannot tell that every BaseNamedType
     // is a NamedType (because in theory, someone could extend BaseNamedType without listing it in NamedType; but as
@@ -522,16 +539,16 @@ export abstract class SchemaElement<TOwnType extends SchemaElement<any, TParent>
   protected abstract removeTypeReference(type: NamedType): void;
 
   protected checkRemoval() {
-    if (this.isElementBuiltIn() && !Schema.prototype['canModifyBuiltIn'].call(this.schema()!)) {
+    if (this.isElementBuiltIn() && !Schema.prototype['canModifyBuiltIn'].call(this.schema())) {
       throw error(`Cannot modify built-in ${this}`);
     }
     // We allow removals even on detached element because that doesn't particularly create issues (and we happen to do such
     // removals on detached internally; though of course we could refactor the code if we wanted).
   }
 
-  protected checkUpdate(addedElement?: { schema(): Schema | undefined }) {
+  protected checkUpdate(addedElement?: { schema(): Schema, isAttached(): boolean }) {
     super.checkUpdate();
-    if (!Schema.prototype['canModifyBuiltIn'].call(this.schema()!)) {
+    if (!Schema.prototype['canModifyBuiltIn'].call(this.schema())) {
       // Ensure this element (the modified one), is not a built-in, or part of one.
       let thisElement: SchemaElement<TOwnType, any> | Schema | undefined = this;
       while (thisElement && thisElement instanceof SchemaElement) {
@@ -541,7 +558,7 @@ export abstract class SchemaElement<TOwnType extends SchemaElement<any, TParent>
         thisElement = thisElement.parent;
       }
     }
-    if (addedElement) {
+    if (addedElement && addedElement.isAttached()) {
       const thatSchema = addedElement.schema();
       if (thatSchema && thatSchema != this.schema()) {
         throw error(`Cannot add element ${addedElement} to ${this} as it is attached to another schema`);
@@ -593,7 +610,7 @@ abstract class BaseNamedType<TReferencer, TOwnType extends NamedType & NamedSche
   }
 
   *allChildElements(): Generator<NamedSchemaElement<any, TOwnType, any>, void, undefined> {
-    // Overriden by those types that do have chidrens
+    // Overriden by those types that do have children
   }
 
   extensions(): ReadonlySet<Extension<TOwnType>> {
@@ -659,7 +676,7 @@ abstract class BaseNamedType<TReferencer, TOwnType extends NamedType & NamedSche
    * reference.
    *
    * @returns an array of all the elements in the schema of this type (before the removal) that were
-   * referening this type (and have thus now an undefined reference).
+   * referencing this type (and have thus now an undefined reference).
    */
   remove(): TReferencer[] {
     if (!this._parent) {
@@ -739,7 +756,7 @@ abstract class BaseExtensionMember<TExtended extends ExtendableElement> extends
   setOfExtension(extension: Extension<TExtended> | undefined) {
     this.checkUpdate();
     // See similar comment on FieldDefinition.setOfExtension for why we have to cast.
-    if (extension && !this.parent?.extensions().has(extension as any)) {
+    if (extension && !this._parent?.extensions().has(extension as any)) {
       throw error(`Cannot set object as part of the provided extension: it is not an extension of parent ${this.parent}`);
     }
     this._extension = extension;
@@ -800,7 +817,7 @@ export class BuiltIns {
 
   onValidation(schema: Schema, unvalidatedDirectives?: string[]): GraphQLError[] {
     const errors: GraphQLError[] = [];
-    // We make sure that if any of the built-ins has been redefined, then the redifinition is
+    // We make sure that if any of the built-ins has been redefined, then the redefinition is
     // the same as the built-in one.
     for (const type of schema.builtInTypes(undefined, true)) {
       const maybeRedefined = schema.type(type.name)!;
@@ -1136,9 +1153,17 @@ export class Schema {
     return this.apiSchema;
   }
 
-  toGraphQLJSSchema(): GraphQLSchema {
+  toGraphQLJSSchema(isSubgraph: boolean = false): GraphQLSchema {
     // Obviously not super fast, but as long as we don't use this often on a hot path, that's probably ok.
-    return buildGraphqlSchemaFromAST(this.toAST());
+    if (!isSubgraph) {
+      return buildGraphqlSchemaFromAST(this.toAST());
+    }
+
+    // Some subgraphs, especially federation 1 ones, cannot be properly converted to a GraphQLSchema because they are invalid graphQL.
+    // And the main culprit is type extensions that don't have a corresponding definition. So to avoid that problem, we print
+    // up the AST without extensions. Another issue is the non graph built-ins which needs to be explicitely defined.
+    const ast = parse(printSchema(this, { ...toASTPrintOptions, mergeTypesAndExtensions: true }), { noLocation: true });
+    return buildGraphqlSchemaFromAST(ast);
   }
 
   get schemaDefinition(): SchemaDefinition {
@@ -1217,7 +1242,7 @@ export class Schema {
     if (existing && !existing.isBuiltIn) {
       throw error(`Type ${type} already exists in this schema`);
     }
-    if (type.parent) {
+    if (type.isAttached()) {
       // For convenience, let's not error out on adding an already added type.
       if (type.parent == this) {
         return type;
@@ -1302,7 +1327,7 @@ export class Schema {
     if (existing && !existing.isBuiltIn) {
       throw error(`Directive ${definition} already exists in this schema`);
     }
-    if (definition.parent) {
+    if (definition.isAttached()) {
       // For convenience, let's not error out on adding an already added directive.
       if (definition.parent == this) {
         return definition;
@@ -1398,7 +1423,7 @@ export class SchemaDefinition extends SchemaElement<SchemaDefinition, Schema>  {
     args?: TApplicationArgs
   ): Directive<SchemaDefinition, TApplicationArgs> {
     const applied = super.applyDirective(nameOrDefOrDirective, args) as Directive<SchemaDefinition, TApplicationArgs>;
-    const schema = this.schema()!;
+    const schema = this.schema();
     const coreFeatures = schema.coreFeatures;
     if (isCoreSpecDirectiveApplication(applied)) {
       if (coreFeatures) {
@@ -1428,7 +1453,7 @@ export class SchemaDefinition extends SchemaElement<SchemaDefinition, Schema>  {
     let toSet: RootType;
     if (typeof nameOrType === 'string') {
       this.checkUpdate();
-      const obj = this.schema()!.type(nameOrType);
+      const obj = this.schema().type(nameOrType);
       if (!obj) {
         throw new GraphQLError(`Cannot set schema ${rootKind} root to unknown type ${nameOrType}`);
       } else if (obj.kind != 'ObjectType') {
@@ -1542,8 +1567,8 @@ abstract class FieldBasedType<T extends (ObjectType | InterfaceType) & NamedSche
     // Note that we can only add the __typename built-in field when we're attached, because we need access to the
     // schema string type. Also, we're effectively modifying a built-in (to add the type), so we
     // need to let the schema accept it.
-    Schema.prototype['runWithBuiltInModificationAllowed'].call(this.schema()!, () => {
-      this.addField(new FieldDefinition(typenameFieldName, true), new NonNullType(this.schema()!.stringType()));
+    Schema.prototype['runWithBuiltInModificationAllowed'].call(this.schema(), () => {
+      this.addField(new FieldDefinition(typenameFieldName, true), new NonNullType(this.schema().stringType()));
     });
   }
 
@@ -1577,9 +1602,9 @@ abstract class FieldBasedType<T extends (ObjectType | InterfaceType) & NamedSche
       let itf: InterfaceType;
       if (typeof nameOrItfOrItfImpl === 'string') {
         this.checkUpdate();
-        const maybeItf = this.schema()!.type(nameOrItfOrItfImpl);
+        const maybeItf = this.schema().type(nameOrItfOrItfImpl);
         if (!maybeItf) {
-          throw new GraphQLError(`Cannot implement unkown type ${nameOrItfOrItfImpl}`);
+          throw new GraphQLError(`Cannot implement unknown type ${nameOrItfOrItfImpl}`);
         } else if (maybeItf.kind != 'InterfaceType') {
           throw new GraphQLError(`Cannot implement non-interface type ${nameOrItfOrItfImpl} (of type ${maybeItf.kind})`);
         }
@@ -1718,9 +1743,6 @@ export class ObjectType extends FieldBasedType<ObjectType, ObjectTypeReferencer>
    */
   isRootType(): boolean {
     const schema = this.schema();
-    if (!schema) {
-      return false;
-    }
     return schema.schemaDefinition.roots().some(rt => rt.type == this);
   }
 
@@ -1729,9 +1751,6 @@ export class ObjectType extends FieldBasedType<ObjectType, ObjectTypeReferencer>
    */
   isQueryRootType(): boolean {
     const schema = this.schema();
-    if (!schema) {
-      return false;
-    }
     return schema.schemaDefinition.root('query')?.type === this;
   }
 }
@@ -1773,10 +1792,10 @@ export class UnionType extends BaseNamedType<OutputTypeReferencer, UnionType> {
     // Note that we can only create the __typename built-in field when we're attached, because we need access to the
     // schema string type. Also, we're effectively modifying a built-in (to add the type), so we
     // need to let the schema accept it.
-    Schema.prototype['runWithBuiltInModificationAllowed'].call(this.schema()!, () => {
+    Schema.prototype['runWithBuiltInModificationAllowed'].call(this.schema(), () => {
       this._typenameField = new FieldDefinition(typenameFieldName, true);
       Element.prototype['setParent'].call(this._typenameField, this);
-      this._typenameField.type = new NonNullType(this.schema()!.stringType());
+      this._typenameField.type = new NonNullType(this.schema().stringType());
     });
   }
 
@@ -1805,9 +1824,9 @@ export class UnionType extends BaseNamedType<OutputTypeReferencer, UnionType> {
       let obj: ObjectType;
       if (typeof nameOrTypeOrMember === 'string') {
         this.checkUpdate();
-        const maybeObj = this.schema()!.type(nameOrTypeOrMember);
+        const maybeObj = this.schema().type(nameOrTypeOrMember);
         if (!maybeObj) {
-          throw new GraphQLError(`Cannot add unkown type ${nameOrTypeOrMember} as member of union type ${this.name}`);
+          throw new GraphQLError(`Cannot add unknown type ${nameOrTypeOrMember} as member of union type ${this.name}`);
         } else if (maybeObj.kind != 'ObjectType') {
           throw new GraphQLError(`Cannot add non-object type ${nameOrTypeOrMember} (of type ${maybeObj.kind}) as member of union type ${this.name}`);
         }
@@ -1839,7 +1858,7 @@ export class UnionType extends BaseNamedType<OutputTypeReferencer, UnionType> {
 
   /**
    * Access a field of the union by name.
-   * As the only field that can be acessed on an union is the __typename one, this method will always return undefined unless called
+   * As the only field that can be accessed on an union is the __typename one, this method will always return undefined unless called
    * on "__typename". However, this exists to allow code working on CompositeType to be more generic.
    */
   field(name: string): FieldDefinition<UnionType> | undefined {
@@ -1960,7 +1979,7 @@ export class InputObjectType extends BaseNamedType<InputTypeReferencer, InputObj
       throw error(`Field ${toAdd.name} already exists on ${this}`);
     }
     if (type && !isInputType(type)) {
-      throw error(`Invalid ouptut type ${type} for field ${toAdd.name}: input field types should be input types.`);
+      throw error(`Invalid output type ${type} for field ${toAdd.name}: input field types should be input types.`);
     }
     this._fields.set(toAdd.name, toAdd);
     this._cachedFieldsArray = undefined;
@@ -2007,10 +2026,14 @@ class BaseWrapperType<T extends Type> {
     assert(this._type, 'Cannot wrap an undefined/null type');
   }
 
-  schema(): Schema | undefined {
+  schema(): Schema {
     return this.baseType().schema();
   }
 
+  isAttached(): boolean {
+    return this.baseType().isAttached();
+  }
+
   get ofType(): T {
     return this._type;
   }
@@ -2058,7 +2081,7 @@ export class FieldDefinition<TParent extends CompositeType> extends NamedSchemaE
   }
 
   get coordinate(): string {
-    const parent = this.parent;
+    const parent = this._parent;
     return `${parent == undefined ? '<detached>' : parent.coordinate}.${this.name}`;
   }
 
@@ -2099,7 +2122,7 @@ export class FieldDefinition<TParent extends CompositeType> extends NamedSchemaE
       return existing;
     }
     if (type && !isInputType(type)) {
-      throw error(`Invalid ouptut type ${type} for argument ${toAdd.name} of ${this}: arguments should be input types.`);
+      throw error(`Invalid output type ${type} for argument ${toAdd.name} of ${this}: arguments should be input types.`);
     }
     this._args.set(toAdd.name, toAdd);
     Element.prototype['setParent'].call(toAdd, this);
@@ -2116,9 +2139,9 @@ export class FieldDefinition<TParent extends CompositeType> extends NamedSchemaE
 
   setOfExtension(extension: Extension<TParent> | undefined) {
     this.checkUpdate();
-    // It seems typscript "expand" `TParent` below into `ObjectType | Interface`, so it essentially lose the context that
+    // It seems typescript "expand" `TParent` below into `ObjectType | Interface`, so it essentially lose the context that
     // the `TParent` in `Extension<TParent>` will always match. Hence the `as any`.
-    if (extension && !this.parent?.extensions().has(extension as any)) {
+    if (extension && !this._parent?.extensions().has(extension as any)) {
       throw error(`Cannot mark field ${this.name} as part of the provided extension: it is not an extension of field parent type ${this.parent}`);
     }
     this._extension = extension;
@@ -2171,7 +2194,7 @@ export class FieldDefinition<TParent extends CompositeType> extends NamedSchemaE
 
   toString(): string {
     const args = this._args.size == 0
-      ? "" 
+      ? ""
       : '(' + this.arguments().map(arg => arg.toString()).join(', ') + ')';
     return `${this.name}${args}: ${this.type}`;
   }
@@ -2183,7 +2206,7 @@ export class InputFieldDefinition extends NamedSchemaElementWithType<InputType,
   defaultValue?: any
 
   get coordinate(): string {
-    const parent = this.parent;
+    const parent = this._parent;
     return `${parent == undefined ? '<detached>' : parent.coordinate}.${this.name}`;
   }
 
@@ -2197,9 +2220,9 @@ export class InputFieldDefinition extends NamedSchemaElementWithType<InputType,
 
   setOfExtension(extension: Extension<InputObjectType> | undefined) {
     this.checkUpdate();
-    // It seems typscript "expand" `TParent` below into `ObjectType | Interface`, so it essentially lose the context that
+    // It seems typescript "expand" `TParent` below into `ObjectType | Interface`, so it essentially lose the context that
     // the `TParent` in `Extension<TParent>` will always match. Hence the `as any`.
-    if (extension && !this.parent?.extensions().has(extension as any)) {
+    if (extension && !this._parent?.extensions().has(extension as any)) {
       throw error(`Cannot mark field ${this.name} as part of the provided extension: it is not an extension of field parent type ${this.parent}`);
     }
     this._extension = extension;
@@ -2243,7 +2266,7 @@ export class ArgumentDefinition<TParent extends FieldDefinition<any> | Directive
   }
 
   get coordinate(): string {
-    const parent = this.parent;
+    const parent = this._parent;
     return `${parent == undefined ? '<detached>' : parent.coordinate}(${this.name}:)`;
   }
 
@@ -2288,7 +2311,7 @@ export class EnumValue extends NamedSchemaElement<EnumValue, EnumType, never> {
   private _extension?: Extension<EnumType>;
 
   get coordinate(): string {
-    const parent = this.parent;
+    const parent = this._parent;
     return `${parent == undefined ? '<detached>' : parent.coordinate}.${this.name}`;
   }
 
@@ -2298,7 +2321,7 @@ export class EnumValue extends NamedSchemaElement<EnumValue, EnumType, never> {
 
   setOfExtension(extension: Extension<EnumType> | undefined) {
     this.checkUpdate();
-    if (extension && !this.parent?.extensions().has(extension)) {
+    if (extension && !this._parent?.extensions().has(extension)) {
       throw error(`Cannot mark field ${this.name} as part of the provided extension: it is not an extension of field parent type ${this.parent}`);
     }
     this._extension = extension;
@@ -2485,13 +2508,13 @@ export class Directive<
     super();
   }
 
-  schema(): Schema | undefined {
-    return this._parent?.schema();
+  schema(): Schema {
+    return this.parent.schema();
   }
 
   get definition(): DirectiveDefinition | undefined {
     const doc = this.schema();
-    return doc?.directive(this.name);
+    return doc.directive(this.name);
   }
 
   arguments(includeDefaultValues: boolean = false) : Readonly<TArgs> {
@@ -2516,7 +2539,7 @@ export class Directive<
   }
 
   private isAttachedToSchemaElement(): boolean {
-    return this.parent !== undefined && this.parent instanceof SchemaElement;
+    return this.isAttached();
   }
 
   setArguments(args: TArgs) {
@@ -2533,7 +2556,7 @@ export class Directive<
     if (entries.length !== Object.keys(expectedArgs).length) {
       return false;
     }
-    for (var [key, val] of entries) {
+    for (const [key, val] of entries) {
       if (!(key in expectedArgs)) {
         return false;
       }
@@ -2552,7 +2575,7 @@ export class Directive<
   setOfExtension(extension: Extension<any> | undefined) {
     this.checkUpdate();
     if (extension) {
-      const parent = this.parent!;
+      const parent = this.parent;
       if (parent instanceof SchemaDefinition || parent instanceof BaseNamedType) {
         if (!parent.extensions().has(extension)) {
           throw error(`Cannot mark directive ${this.name} as part of the provided extension: it is not an extension of parent ${parent}`);
@@ -2592,15 +2615,15 @@ export class Directive<
       return false;
     }
     this.onModification();
-    const coreFeatures = this.schema()?.coreFeatures;
+    const coreFeatures = this.schema().coreFeatures;
     if (coreFeatures && this.name === coreFeatures.coreItself.nameInSchema) {
       // We're removing a @core directive application, so we remove it from the list of core features. And
       // if it is @core itself, we clean all features (to avoid having things too inconsistent).
       const url = FeatureUrl.parse(this._args['feature']!);
       if (url.identity === coreFeatures.coreItself.url.identity) {
         // Note that we unmark first because the loop after that will nuke our parent.
-        Schema.prototype['unmarkAsCoreSchema'].call(this.schema()!);
-        for (const d of this.schema()!.schemaDefinition.appliedDirectivesOf(coreFeatures.coreItself.nameInSchema)) {
+        Schema.prototype['unmarkAsCoreSchema'].call(this.schema());
+        for (const d of this.schema().schemaDefinition.appliedDirectivesOf(coreFeatures.coreItself.nameInSchema)) {
           d.removeInternal();
         }
         // The loop above will already have call removeInternal on this instance, so we can return
@@ -2971,10 +2994,10 @@ function copyAppliedDirectives(source: SchemaElement<any, any>, dest: SchemaElem
 }
 
 function copyFieldDefinitionInner<P extends ObjectType | InterfaceType>(source: FieldDefinition<P>, dest: FieldDefinition<P>) {
-  const type = copyWrapperTypeOrTypeRef(source.type, dest.schema()!) as OutputType;
+  const type = copyWrapperTypeOrTypeRef(source.type, dest.schema()) as OutputType;
   dest.type = type;
   for (const arg of source.arguments()) {
-    const argType = copyWrapperTypeOrTypeRef(arg.type, dest.schema()!);
+    const argType = copyWrapperTypeOrTypeRef(arg.type, dest.schema());
     copyArgumentDefinitionInner(arg, dest.addArgument(arg.name, argType as InputType));
   }
   copyAppliedDirectives(source, dest);
@@ -2983,7 +3006,7 @@ function copyFieldDefinitionInner<P extends ObjectType | InterfaceType>(source:
 }
 
 function copyInputFieldDefinitionInner(source: InputFieldDefinition, dest: InputFieldDefinition) {
-  const type = copyWrapperTypeOrTypeRef(source.type, dest.schema()!) as InputType;
+  const type = copyWrapperTypeOrTypeRef(source.type, dest.schema()) as InputType;
   dest.type = type;
   dest.defaultValue = source.defaultValue;
   copyAppliedDirectives(source, dest);
@@ -3006,7 +3029,7 @@ function copyWrapperTypeOrTypeRef(source: Type | undefined, destParent: Schema):
 }
 
 function copyArgumentDefinitionInner<P extends FieldDefinition<any> | DirectiveDefinition>(source: ArgumentDefinition<P>, dest: ArgumentDefinition<P>) {
-  const type = copyWrapperTypeOrTypeRef(source.type, dest.schema()!) as InputType;
+  const type = copyWrapperTypeOrTypeRef(source.type, dest.schema()) as InputType;
   dest.type = type;
   dest.defaultValue = source.defaultValue;
   copyAppliedDirectives(source, dest);
@@ -3016,7 +3039,7 @@ function copyArgumentDefinitionInner<P extends FieldDefinition<any> | DirectiveD
 
 function copyDirectiveDefinitionInner(source: DirectiveDefinition, dest: DirectiveDefinition) {
   for (const arg of source.arguments()) {
-    const type = copyWrapperTypeOrTypeRef(arg.type, dest.schema()!);
+    const type = copyWrapperTypeOrTypeRef(arg.type, dest.schema());
     copyArgumentDefinitionInner(arg, dest.addArgument(arg.name, type as InputType));
   }
   dest.repeatable = source.repeatable;