@warp-drive-mirror/core 5.9.0-alpha.18 → 5.9.0-alpha.19

package/declarations/index.d.ts

@@ -39,8 +39,17 @@ export interface StoreSetupOptions<T extends Cache = Cache> {
 	* The request handlers to use. {@link Fetch} will automatically
 	* be added to the end of the handler chain and {@link CacheHandler}
 	* will automatically be added as the cache handler.
+	*
+	* May also be given as a function that receives the {@link Store} instance
+	* and returns the handlers to use. This is useful when a handler needs
+	* access to the store (e.g. to look up its owner for injections) or when
+	* the set of handlers should be decided lazily (e.g. based on a feature
+	* flag service that may not be ready until after the store is constructed).
+	*
+	* The function is invoked lazily, the first time the store's `requestManager`
+	* is accessed, and only once per store instance.
 	*/
-	handlers?: Handler[];
+	handlers?: Handler[] | ((store: Store) => Handler[]);
 	/**
 	* Schemas describing the structure of your resource data.
 	*

package/dist/graph/-private.js

@@ -753,7 +753,7 @@ if (macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG)) {
       errors.set('type', ` <---- should be '${definition.inverseType}'`);
     }
     if (definition.inverseKind !== meta.kind) {
-      errors.set('type', ` <---- should be '${definition.inverseKind}'`);
+      errors.set('kind', ` <---- should be '${definition.inverseKind}'`);
     }
     if (definition.inverseIsAsync !== meta.options.async) {
       errors.set('async', ` <---- should be ${definition.inverseIsAsync}`);
@@ -764,7 +764,12 @@ if (macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG)) {
     if (definition.key !== meta.options.inverse) {
       errors.set('inverse', ` <---- should be '${definition.key}'`);
     }
-    if (definition.type !== meta.options.as) {
+    // `as` is only meaningful when `definition` itself is polymorphic (i.e. it
+    // points at an abstract type that `meta` is expected to implement). When
+    // `definition` isn't polymorphic, there's no abstract type for `meta` to
+    // declare `as` against, so `meta.options.as` is correctly absent - that's
+    // not an error to report.
+    if (definition.isPolymorphic && definition.type !== meta.options.as) {
       errors.set('as', ` <---- should be '${definition.type}'`);
     }
     return errors;
@@ -803,18 +808,6 @@ if (macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG)) {
 
 `;
   }
-  function metaFrom(definition) {
-    return {
-      name: definition.key,
-      type: definition.type,
-      kind: definition.kind,
-      options: {
-        async: definition.isAsync,
-        polymorphic: definition.isPolymorphic,
-        inverse: definition.inverseKey
-      }
-    };
-  }
   function inverseMetaFrom(definition) {
     return {
       name: definition.inverseKey,
@@ -857,15 +850,18 @@ if (macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG)) {
     });
   }
   assertInheritedSchema = function assertInheritedSchema(definition, type) {
-    const meta1 = metaFrom(definition);
+    // `definition` is the only source of truth we have here - there is no
+    // second, independently-declared schema available to diff it against.
+    // That means the only thing we can actually verify is internal: does
+    // `definition`'s own resolved inverse agree that this relationship is
+    // polymorphic? Every other field of `meta2` below (name/type/kind/async/
+    // inverse) is derived directly from `definition` itself, so comparing
+    // them back to `definition` can never disagree - only the polymorphic
+    // flag is independently meaningful, because `definitionWithPolymorphic`
+    // asserts what it *should* be rather than mirroring what it already is.
     const meta2 = inverseMetaFrom(definition);
-    const errors1 = validateSchema(inverseDefinition(definition), meta1);
     const errors2 = validateSchema(definitionWithPolymorphic(definition), meta2);
-    if (errors2.size === 0 && errors1.size > 0) {
-      throw new Error(`The schema for the relationship '${type}.${definition.key}' is not configured to satisfy '${definition.inverseType}' and thus cannot utilize the '${definition.inverseType}.${definition.key}' relationship to connect with '${definition.type}.${definition.inverseKey}'\n\nIf using this relationship in a polymorphic manner is desired, the relationships schema definition for '${type}' should include:${printSchema(meta1, errors1)}`);
-    } else if (errors1.size > 0) {
-      throw new Error(`The schema for the relationship '${type}.${definition.key}' is not configured to satisfy '${definition.inverseType}' and thus cannot utilize the '${definition.inverseType}.${definition.key}' relationship to connect with '${definition.type}.${definition.inverseKey}'\n\nIf using this relationship in a polymorphic manner is desired, the relationships schema definition for '${type}' should include:${printSchema(meta1, errors1)} and the relationships schema definition for '${definition.type}' should include:${printSchema(meta2, errors2)}`);
-    } else if (errors2.size > 0) {
+    if (errors2.size > 0) {
       throw new Error(`The schema for the relationship '${type}.${definition.key}' satisfies '${definition.inverseType}' but cannot utilize the '${definition.inverseType}.${definition.key}' relationship to connect with '${definition.type}.${definition.inverseKey}' because that relationship is not polymorphic.\n\nIf using this relationship in a polymorphic manner is desired, the relationships schema definition for '${definition.type}' should include:${printSchema(meta2, errors2)}`);
     }
   };

package/dist/{index-BoY6aNE5.js → index-LI2ckwf9.js}

@@ -8362,6 +8362,9 @@ class ReactiveResource {
         if (prop === Destroy || prop === Checkout) {
           return true;
         }
+        if (prop === identityField?.name) {
+          return true;
+        }
         return fields.has(prop);
       },
       getOwnPropertyDescriptor(target, prop) {
@@ -9112,6 +9115,90 @@ function registerDerivations(schema) {
   schema.registerDerivation(fromIdentity);
   schema.registerDerivation(_constructor);
 }
+
+/**
+ * A relationship field capable of declaring `options.as`, marking it as a
+ * concrete implementation of an abstract polymorphic type.
+ */
+
+/**
+ * A relationship field contributed to an abstract type's schema, along with
+ * the name of the type that contributed it (either a concrete implementer,
+ * via `options.as`, or the abstract type's own schema), for use in assertion
+ * messages when two contributions disagree on shape.
+ */
+
+/**
+ * Reduces a field to a plain object with a fixed key order, covering every
+ * option any relationship-implementer field can declare, so two fields can
+ * be compared for exact equality via `JSON.stringify` regardless of the key
+ * order the schema author happened to write them in.
+ *
+ * `options.as` is included and is *not* special-cased: every contributor to
+ * a given field name on an abstract type - including the abstract type's
+ * own schema, if it has one - is expected to declare `as` equal to that
+ * abstract type's own name. This is redundant/self-referential for the
+ * abstract type's own schema, but required for consistency: relationship
+ * resolution elsewhere (e.g. `inverse` name-matching) does not itself
+ * validate `as`, so a field with a missing or incorrect `as` can otherwise
+ * be silently pulled into a relationship it never declared it implements.
+ */
+function comparableAbstractFieldShape(field) {
+  const {
+    kind,
+    name,
+    type,
+    sourceKey,
+    options
+  } = field;
+  return {
+    kind,
+    name,
+    type,
+    sourceKey,
+    options: {
+      as: options?.as,
+      async: options?.async,
+      inverse: options?.inverse,
+      polymorphic: options?.polymorphic,
+      linksMode: options?.linksMode,
+      resetOnRemoteUpdate: options?.resetOnRemoteUpdate,
+      arrayExtensions: options?.arrayExtensions
+    }
+  };
+}
+
+/**
+ * Asserts that two contributions to the same field name on an abstract
+ * polymorphic type - whether from two different concrete implementers, or
+ * from an implementer and the abstract type's own schema - declare an
+ * identical shape: `kind`, `type`, and every option, including `as` (which
+ * every contributor, the abstract type's own schema included, must declare
+ * equal to `abstractType`). A mismatch here (e.g. one implementer's field
+ * being a `hasMany` while another's is a `belongsTo`, the two disagreeing on
+ * `inverse`/`async`/`polymorphic`, or one omitting or misdeclaring `as`)
+ * cannot be resolved by picking one side arbitrarily, since that would
+ * silently leave whichever side lost the mismatch pointing at a relationship
+ * whose true shape differs from what its own schema declared.
+ */
+function assertConsistentAbstractFieldShape(abstractType, fieldName, existing, incoming) {
+  // This function exists solely to support the `assert()` call below - there
+  // is no other work here with an effect in production. Since `assert()`'s
+  // own babel-macro stripping only removes the call expression itself, not
+  // the (comparatively expensive, involving `JSON.stringify`) computation of
+  // its arguments, guard the whole body so none of it survives in production
+  // builds, matching how `assertPolymorphicType`/`assertInheritedSchema` and
+  // their call sites are gated in `assert-polymorphic-type.ts`.
+  if (macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG)) {
+    const existingShape = comparableAbstractFieldShape(existing.field);
+    const incomingShape = comparableAbstractFieldShape(incoming.field);
+    macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
+      if (!test) {
+        throw new Error(`Expected the relationship '${fieldName}' on the abstract polymorphic type '${abstractType}' to be declared identically everywhere it is implemented (including 'options.as', which every contributor - the abstract type's own schema included - must declare equal to '${abstractType}'), but '${existing.source}' declares it as:\n\n${JSON.stringify(existingShape, null, 2)}\n\nwhile '${incoming.source}' declares it as:\n\n${JSON.stringify(incomingShape, null, 2)}\n\nAll concrete implementers of an abstract type - and the abstract type's own schema, if it has one - must declare an identical shape for any relationship field they share.`);
+      }
+    })(JSON.stringify(existingShape) === JSON.stringify(incomingShape)) : {};
+  }
+}
 /**
  * Wraps a derivation in a new function with Derivation signature but that looks
  * up the value in the cache before recomputing.
@@ -9151,6 +9238,18 @@ class SchemaService {
 
   /** @internal */
 
+  /**
+   * Tracks, per abstract type, the relationship fields that concrete
+   * implementers have contributed via `options.as`, along with the type
+   * that contributed each one (for assertion messages). This is
+   * independent of whatever schema (synthesized or user-registered)
+   * currently occupies `_schemas` for that type, so that these fields
+   * survive regardless of the order in which the abstract type's
+   * implementers and its own (optional) concrete schema are registered.
+   *
+   * @internal
+   */
+
   /** @internal */
 
   /** @internal */
@@ -9162,6 +9261,7 @@ class SchemaService {
     this._derivations = new Map();
     this._traits = new Map();
     this._modes = new Map();
+    this._abstractImplementerFields = new Map();
     this._extensions = {
       object: new Map(),
       array: new Map()
@@ -9257,6 +9357,7 @@ class SchemaService {
     const fields = new Map();
     const relationships = {};
     const attributes = {};
+    const abstractImplementations = [];
     for (const field of schema.fields) {
       macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG) ? (test => {
         if (!test) {
@@ -9270,6 +9371,31 @@ class SchemaService {
         attributes[field.name] = field;
       } else if (field.kind === 'belongsTo' || field.kind === 'hasMany') {
         relationships[field.name] = field;
+        if (field.options?.as) {
+          abstractImplementations.push(field);
+        }
+      }
+    }
+
+    // This type may already be known as an abstract polymorphic type,
+    // implemented by other concrete types via `options.as`, from before it
+    // ever had a schema of its own (see `_registerAbstractTypeImplementation`).
+    // Carry those previously-contributed fields forward so that registering
+    // a "real" schema for the type - whenever that happens to occur - never
+    // erases the relationships its implementers depend on.
+    const implementerFields = this._abstractImplementerFields.get(schema.type);
+    if (implementerFields) {
+      for (const [name, contribution] of implementerFields) {
+        const ownField = fields.get(name);
+        if (!ownField) {
+          fields.set(name, contribution.field);
+          relationships[name] = contribution.field;
+        } else if (macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG)) {
+          assertConsistentAbstractFieldShape(schema.type, name, contribution, {
+            field: ownField,
+            source: schema.type
+          });
+        }
       }
     }
     const cacheFields = null;
@@ -9288,6 +9414,101 @@ class SchemaService {
       internalSchema.cacheFields = getCacheFields(internalSchema);
     }
     this._schemas.set(schema.type, internalSchema);
+
+    // A relationship field's `as` option marks it as a valid concrete
+    // implementer of an abstract polymorphic type (e.g. `as: 'commentable'`).
+    // That abstract type may never be given its own schema by the user - it
+    // may exist only to be implemented by concrete types like this one - or
+    // it may already have (or later receive) a schema of its own, e.g. if it
+    // turns out to also be a real, directly-resolvable resource. Either way,
+    // ensure it has a schema with this field present, so that it behaves
+    // like any other registered resource (`hasResource`, `fields`, etc.)
+    // instead of requiring special-casing wherever abstract relationship
+    // types are resolved.
+    for (const field of abstractImplementations) {
+      this._registerAbstractTypeImplementation(field, schema.type);
+    }
+  }
+
+  /** @internal */
+  _registerAbstractTypeImplementation(field, implementer) {
+    const abstractType = field.options.as;
+    let implementerFields = this._abstractImplementerFields.get(abstractType);
+    if (!implementerFields) {
+      implementerFields = new Map();
+      this._abstractImplementerFields.set(abstractType, implementerFields);
+    }
+
+    // Unlike the original approach this replaced, `as` is *not* stripped here:
+    // the field as synthesized onto the abstract type's own schema keeps
+    // `options.as === abstractType`, redundant/self-referential as that is.
+    // This keeps every contributor - implementers and the abstract type's
+    // own schema alike - declaring the same thing, which is what
+    // `assertConsistentAbstractFieldShape` checks, and it is also what lets
+    // `assertPolymorphicType` (which reads a field's declared `as` off
+    // whatever `schema.fields()` serves for its type) correctly permit the
+    // abstract type itself to be pushed directly into this relationship.
+    const abstractField = {
+      ...field
+    };
+    const contribution = {
+      field: abstractField,
+      source: implementer
+    };
+
+    // all concrete implementations of an abstract type are required to
+    // share the same shape for the field that implements it, so the first
+    // one registered is as good a canonical source as any - but a later,
+    // differently-shaped one is almost certainly a mistake rather than an
+    // intentional override, so we catch it rather than silently ignoring it.
+    const existingImplementer = implementerFields.get(field.name);
+    if (existingImplementer) {
+      if (macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG)) {
+        assertConsistentAbstractFieldShape(abstractType, field.name, existingImplementer, contribution);
+      }
+      return;
+    }
+    implementerFields.set(field.name, contribution);
+    let abstractSchema = this._schemas.get(abstractType);
+    if (!abstractSchema) {
+      abstractSchema = {
+        original: {
+          legacy: true,
+          identity: {
+            kind: '@id',
+            name: 'id'
+          },
+          type: abstractType,
+          fields: []
+        },
+        finalized: true,
+        fields: new Map(),
+        cacheFields: new Map(),
+        relationships: {},
+        attributes: {},
+        traits: new Set()
+      };
+      this._schemas.set(abstractType, abstractSchema);
+    }
+    const existingAbstractField = abstractSchema.fields.get(field.name);
+    if (existingAbstractField) {
+      if (macroCondition(getGlobalConfig().WarpDriveMirror.env.DEBUG)) {
+        assertConsistentAbstractFieldShape(abstractType, field.name, {
+          field: existingAbstractField,
+          source: abstractType
+        }, contribution);
+      }
+      return;
+    }
+    abstractSchema.fields.set(field.name, abstractField);
+    abstractSchema.relationships[field.name] = abstractField;
+
+    // If the schema is mid-finalization (traits pending), finalizeResource
+    // will recompute cacheFields from the current `fields` map anyway; avoid
+    // doing so prematurely from a partially-resolved set of fields.
+    if (abstractSchema.finalized) {
+      abstractSchema.cacheFields = getCacheFields(abstractSchema);
+    }
   }
 
   /**
@@ -10019,7 +10240,29 @@ globalThis.setWarpDriveIsMaybeMirage = setIsMaybeMirage;
  */
 function useRecommendedStore(options, StoreKlass = Store) {
   return class AppStore extends StoreKlass {
-    requestManager = new RequestManager().use([...(options.handlers ?? []), Fetch]).useCache(CacheHandler);
+    constructor(createArgs) {
+      super(createArgs);
+      // installed via defineProperty (rather than a class field/accessor) so that
+      // this lazy override of the inherited `requestManager` field does not
+      // conflict with the documented pattern of assigning it directly on
+      // consumer-authored Store subclasses. The setter preserves the ability
+      // to replace `requestManager` outright after construction.
+      let requestManager;
+      Object.defineProperty(this, 'requestManager', {
+        configurable: true,
+        enumerable: true,
+        get: () => {
+          if (!requestManager) {
+            const handlers = typeof options.handlers === 'function' ? options.handlers(this) : options.handlers ?? [];
+            requestManager = new RequestManager().use([...handlers, Fetch]).useCache(CacheHandler);
+          }
+          return requestManager;
+        },
+        set: value => {
+          requestManager = value;
+        }
+      });
+    }
     lifetimes = options.policy ?? new DefaultCachePolicy({
       apiCacheHardExpires: 15 * 60 * 1000,
       // 15 minutes

package/dist/index.js

@@ -1,4 +1,4 @@
-export { C as CacheHandler, F as Fetch, z as RequestManager, S as Store, r as cacheKeyFor, r as recordIdentifierFor, E as setIdentifierForgetMethod, B as setIdentifierGenerationMethod, G as setIdentifierResetMethod, D as setIdentifierUpdateMethod, H as setKeyInfoForResource, s as storeFor, A as useRecommendedStore } from "./index-BoY6aNE5.js";
+export { C as CacheHandler, F as Fetch, z as RequestManager, S as Store, r as cacheKeyFor, r as recordIdentifierFor, E as setIdentifierForgetMethod, B as setIdentifierGenerationMethod, G as setIdentifierResetMethod, D as setIdentifierUpdateMethod, H as setKeyInfoForResource, s as storeFor, A as useRecommendedStore } from "./index-LI2ckwf9.js";
 import "./symbols-3C1OkYtZ.js";
 import "./configure-BMxnD2RJ.js";
 import '@embroider/macros';

package/dist/reactive.js

@@ -1,4 +1,4 @@
-export { u as SchemaService, p as checkout, y as commit, v as fromIdentity, q as instantiateRecord, x as registerDerivations, t as teardownRecord, w as withDefaults } from "./index-BoY6aNE5.js";
+export { u as SchemaService, p as checkout, y as commit, v as fromIdentity, q as instantiateRecord, x as registerDerivations, t as teardownRecord, w as withDefaults } from "./index-LI2ckwf9.js";
 export { C as Checkout } from "./symbols-3C1OkYtZ.js";
 export { h as createRequestSubscription, j as getPromiseState, i as getRequestState } from "./configure-BMxnD2RJ.js";
 import '@embroider/macros';

package/dist/store/-private.js

@@ -1 +1 @@
-export { C as CacheHandler, R as RecordArrayManager, S as Store, k as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, h as assertPrivateCapabilities, d as assertPrivateStore, b as coerceId, c as constructResource, l as createLegacyManyArray, e as ensureStringId, f as fastPush, g as isPrivateStore, a as isRequestKey, i as isResourceKey, m as log, o as logGroup, r as recordIdentifierFor, j as setRecordIdentifier, s as storeFor } from "../index-BoY6aNE5.js";
+export { C as CacheHandler, R as RecordArrayManager, S as Store, k as StoreMap, _ as _clearCaches, n as _deprecatingNormalize, h as assertPrivateCapabilities, d as assertPrivateStore, b as coerceId, c as constructResource, l as createLegacyManyArray, e as ensureStringId, f as fastPush, g as isPrivateStore, a as isRequestKey, i as isResourceKey, m as log, o as logGroup, r as recordIdentifierFor, j as setRecordIdentifier, s as storeFor } from "../index-LI2ckwf9.js";

package/dist/types/-private.js

@@ -1,6 +1,6 @@
 import { macroCondition, getGlobalConfig } from '@embroider/macros';
 const name = "@warp-drive-mirror/core";
-const version = "5.9.0-alpha.18";
+const version = "5.9.0-alpha.19";
 
 // in testing mode, we utilize globals to ensure only one copy exists of
 // these maps, due to bugs in ember-auto-import

package/dist/unpkg/dev/graph/-private.js

@@ -753,7 +753,7 @@ let assertInheritedSchema;
       errors.set('type', ` <---- should be '${definition.inverseType}'`);
     }
     if (definition.inverseKind !== meta.kind) {
-      errors.set('type', ` <---- should be '${definition.inverseKind}'`);
+      errors.set('kind', ` <---- should be '${definition.inverseKind}'`);
     }
     if (definition.inverseIsAsync !== meta.options.async) {
       errors.set('async', ` <---- should be ${definition.inverseIsAsync}`);
@@ -764,7 +764,12 @@ let assertInheritedSchema;
     if (definition.key !== meta.options.inverse) {
       errors.set('inverse', ` <---- should be '${definition.key}'`);
     }
-    if (definition.type !== meta.options.as) {
+    // `as` is only meaningful when `definition` itself is polymorphic (i.e. it
+    // points at an abstract type that `meta` is expected to implement). When
+    // `definition` isn't polymorphic, there's no abstract type for `meta` to
+    // declare `as` against, so `meta.options.as` is correctly absent - that's
+    // not an error to report.
+    if (definition.isPolymorphic && definition.type !== meta.options.as) {
       errors.set('as', ` <---- should be '${definition.type}'`);
     }
     return errors;
@@ -803,18 +808,6 @@ let assertInheritedSchema;
 
 `;
   }
-  function metaFrom(definition) {
-    return {
-      name: definition.key,
-      type: definition.type,
-      kind: definition.kind,
-      options: {
-        async: definition.isAsync,
-        polymorphic: definition.isPolymorphic,
-        inverse: definition.inverseKey
-      }
-    };
-  }
   function inverseMetaFrom(definition) {
     return {
       name: definition.inverseKey,
@@ -857,15 +850,18 @@ let assertInheritedSchema;
     });
   }
   assertInheritedSchema = function assertInheritedSchema(definition, type) {
-    const meta1 = metaFrom(definition);
+    // `definition` is the only source of truth we have here - there is no
+    // second, independently-declared schema available to diff it against.
+    // That means the only thing we can actually verify is internal: does
+    // `definition`'s own resolved inverse agree that this relationship is
+    // polymorphic? Every other field of `meta2` below (name/type/kind/async/
+    // inverse) is derived directly from `definition` itself, so comparing
+    // them back to `definition` can never disagree - only the polymorphic
+    // flag is independently meaningful, because `definitionWithPolymorphic`
+    // asserts what it *should* be rather than mirroring what it already is.
     const meta2 = inverseMetaFrom(definition);
-    const errors1 = validateSchema(inverseDefinition(definition), meta1);
     const errors2 = validateSchema(definitionWithPolymorphic(definition), meta2);
-    if (errors2.size === 0 && errors1.size > 0) {
-      throw new Error(`The schema for the relationship '${type}.${definition.key}' is not configured to satisfy '${definition.inverseType}' and thus cannot utilize the '${definition.inverseType}.${definition.key}' relationship to connect with '${definition.type}.${definition.inverseKey}'\n\nIf using this relationship in a polymorphic manner is desired, the relationships schema definition for '${type}' should include:${printSchema(meta1, errors1)}`);
-    } else if (errors1.size > 0) {
-      throw new Error(`The schema for the relationship '${type}.${definition.key}' is not configured to satisfy '${definition.inverseType}' and thus cannot utilize the '${definition.inverseType}.${definition.key}' relationship to connect with '${definition.type}.${definition.inverseKey}'\n\nIf using this relationship in a polymorphic manner is desired, the relationships schema definition for '${type}' should include:${printSchema(meta1, errors1)} and the relationships schema definition for '${definition.type}' should include:${printSchema(meta2, errors2)}`);
-    } else if (errors2.size > 0) {
+    if (errors2.size > 0) {
       throw new Error(`The schema for the relationship '${type}.${definition.key}' satisfies '${definition.inverseType}' but cannot utilize the '${definition.inverseType}.${definition.key}' relationship to connect with '${definition.type}.${definition.inverseKey}' because that relationship is not polymorphic.\n\nIf using this relationship in a polymorphic manner is desired, the relationships schema definition for '${definition.type}' should include:${printSchema(meta2, errors2)}`);
     }
   };