chore: remove restriction on new field kinds being used with legacy mode (#9769)

* chore: remove restriction on new field kinds being used with legacy mode

* chore: cleanup types

* fix

* fix test

* fix docs

Author: runspired

packages/core-types/src/schema/fields.ts

@@ -0,0 +1,70 @@
+import { resourceSchema } from './fields';
+
+// @ts-expect-error attribute field should result in an invalid schema
+// unless marked legacy
+resourceSchema({
+  type: 'user',
+  identity: { name: 'id', kind: '@id' },
+  fields: [
+    {
+      name: 'name',
+      kind: 'attribute',
+    },
+  ],
+});
+resourceSchema({
+  legacy: true,
+  type: 'user',
+  identity: { name: 'id', kind: '@id' },
+  fields: [
+    {
+      name: 'name',
+      kind: 'attribute',
+    },
+  ],
+});
+
+// @ts-expect-error relationship field should result in an invalid schema
+// unless marked legacy or linksMode
+resourceSchema({
+  type: 'user',
+  identity: { name: 'id', kind: '@id' },
+  fields: [
+    {
+      name: 'friends',
+      kind: 'hasMany',
+      type: 'user',
+      options: { async: false, inverse: null },
+    },
+  ],
+});
+resourceSchema({
+  legacy: true,
+  type: 'user',
+  identity: { name: 'id', kind: '@id' },
+  fields: [
+    {
+      name: 'friends',
+      kind: 'hasMany',
+      type: 'user',
+      options: { async: false, inverse: null },
+    },
+  ],
+});
+resourceSchema({
+  type: 'user',
+  identity: { name: 'id', kind: '@id' },
+  fields: [
+    {
+      name: 'friends',
+      kind: 'hasMany',
+      type: 'user',
+      options: {
+        async: false,
+        inverse: null,
+        linksMode: true,
+        resetOnRemoteUpdate: false,
+      },
+    },
+  ],
+});

packages/core-types/src/schema/fields.type-test.ts

@@ -31,7 +31,7 @@ import type {
   CollectionField,
   FieldSchema,
   LegacyHasManyField,
-  LegacyRelationshipSchema,
+  LegacyRelationshipField,
   ResourceField,
 } from '@warp-drive/core-types/schema/fields';
 import type {
@@ -505,6 +505,9 @@ export default class JSONAPICache implements Cache {
       const store = this._capabilities._store;
       const attrs = this._capabilities.schema.fields(identifier);
       attrs.forEach((attr, key) => {
+        if (attr.kind === 'alias') {
+          return;
+        }
         if (key in attributes && attributes[key] !== undefined) {
           return;
         }
@@ -1817,6 +1820,8 @@ function getDefaultValue(
   identifier: StableRecordIdentifier,
   store: Store
 ): Value | undefined {
+  assert(`AliasFields should not be directly accessed from the cache`, schema?.kind !== 'alias');
+
   const options = schema?.options;
 
   if (!schema || (!options && !schema.type)) {
@@ -1989,7 +1994,7 @@ function setupRelationships(
   }
 }
 
-function isRelationship(field: FieldSchema): field is LegacyRelationshipSchema | CollectionField | ResourceField {
+function isRelationship(field: FieldSchema): field is LegacyRelationshipField | CollectionField | ResourceField {
   const { kind } = field;
   return kind === 'hasMany' || kind === 'belongsTo' || kind === 'resource' || kind === 'collection';
 }

packages/json-api/src/-private/cache.ts

@@ -7,7 +7,10 @@ import { DEBUG } from '@warp-drive/build-config/env';
 import { assert } from '@warp-drive/build-config/macros';
 import type { StableRecordIdentifier } from '@warp-drive/core-types';
 import type { StableExistingRecordIdentifier } from '@warp-drive/core-types/identifier';
-import type { LegacyRelationshipSchema as RelationshipSchema } from '@warp-drive/core-types/schema/fields';
+import type {
+  LegacyRelationshipField as RelationshipSchema,
+  LegacyRelationshipSchema as RelationshipSchema,
+} from '@warp-drive/core-types/schema/fields';
 import type { ExistingResourceObject, JsonApiDocument } from '@warp-drive/core-types/spec/json-api-raw';
 
 import { upgradeStore } from '../-private';

packages/legacy-compat/src/legacy-network-handler/legacy-data-fetch.ts

@@ -10,7 +10,7 @@ import { DEBUG, TESTING } from '@warp-drive/build-config/env';
 import { assert } from '@warp-drive/build-config/macros';
 import type { StableExistingRecordIdentifier, StableRecordIdentifier } from '@warp-drive/core-types/identifier';
 import type { ImmutableRequestInfo } from '@warp-drive/core-types/request';
-import type { LegacyRelationshipSchema as RelationshipSchema } from '@warp-drive/core-types/schema/fields';
+import type { LegacyRelationshipField as RelationshipSchema } from '@warp-drive/core-types/schema/fields';
 import type { SingleResourceDataDocument } from '@warp-drive/core-types/spec/document';
 import type { ApiError } from '@warp-drive/core-types/spec/error';
 import type {

packages/legacy-compat/src/legacy-network-handler/legacy-network-handler.ts

@@ -4,7 +4,7 @@
 import type Store from '@ember-data/store';
 import type { CollectionRecordArray } from '@ember-data/store/-private';
 import type { ModelSchema } from '@ember-data/store/types';
-import type { LegacyRelationshipSchema as RelationshipSchema } from '@warp-drive/core-types/schema/fields';
+import type { LegacyRelationshipField as RelationshipSchema } from '@warp-drive/core-types/schema/fields';
 
 import type { Snapshot } from './snapshot';
 import type { SnapshotRecordArray } from './snapshot-record-array';

packages/legacy-compat/src/legacy-network-handler/minimum-adapter-interface.ts

@@ -16,7 +16,7 @@ import type { ChangedAttributesHash } from '@warp-drive/core-types/cache';
 import type { CollectionRelationship } from '@warp-drive/core-types/cache/relationship';
 import type { Value } from '@warp-drive/core-types/json/raw';
 import type { TypedRecordInstance, TypeFromInstance } from '@warp-drive/core-types/record';
-import type { LegacyAttributeField, LegacyRelationshipSchema } from '@warp-drive/core-types/schema/fields';
+import type { LegacyAttributeField, LegacyRelationshipField } from '@warp-drive/core-types/schema/fields';
 
 import { upgradeStore } from '../-private';
 import type { SerializerOptions } from './minimum-serializer-interface';
@@ -532,7 +532,7 @@ export class Snapshot<R = unknown> {
     @param {Object} [binding] the value to which the callback's `this` should be bound
     @public
   */
-  eachRelationship(callback: (key: string, meta: LegacyRelationshipSchema) => void, binding?: unknown): void {
+  eachRelationship(callback: (key: string, meta: LegacyRelationshipField) => void, binding?: unknown): void {
     const fields = this._store.schema.fields(this.identifier);
     fields.forEach((field, key) => {
       if (field.kind === 'belongsTo' || field.kind === 'hasMany') {

packages/legacy-compat/src/legacy-network-handler/snapshot.ts

@@ -116,6 +116,17 @@ if (DEBUG) {
           assert(assertionMessage, isPolymorphic);
         }
       }
+
+      if (meta) {
+        assert(
+          `Expected the schema for the field ${parentDefinition.inverseKey} on ${addedIdentifier.type} to be for a legacy relationship`,
+          meta.kind === 'belongsTo' || meta.kind === 'hasMany'
+        );
+        assert(
+          `The schema for the relationship '${parentDefinition.inverseKey}' on '${addedIdentifier.type}' type does not implement '${parentDefinition.type}' and thus cannot be assigned to the '${parentDefinition.key}' relationship in '${parentIdentifier.type}'. The definition should specify 'as: "${parentDefinition.type}"' in options.`,
+          meta?.options?.as === parentDefinition.type
+        );
+      }
     }
   };
 }

packages/model/src/-private/debug/assert-polymorphic-type.ts

@@ -22,7 +22,7 @@ import { DEBUG } from '@warp-drive/build-config/env';
 import { assert } from '@warp-drive/build-config/macros';
 import type { StableRecordIdentifier } from '@warp-drive/core-types';
 import type { Cache, ChangedAttributesHash } from '@warp-drive/core-types/cache';
-import type { LegacyAttributeField, LegacyRelationshipSchema } from '@warp-drive/core-types/schema/fields';
+import type { LegacyAttributeField, LegacyRelationshipField } from '@warp-drive/core-types/schema/fields';
 import { RecordStore } from '@warp-drive/core-types/symbols';
 
 import { Errors } from './errors';
@@ -1060,17 +1060,13 @@ class Model extends EmberObject implements MinimalLegacyRecord {
    @param {any} binding the value to which the callback's `this` should be bound
    */
   eachRelationship<T>(
-    callback: (
-      this: NoInfer<T> | undefined,
-      key: MaybeRelationshipFields<this>,
-      meta: LegacyRelationshipSchema
-    ) => void,
+    callback: (this: NoInfer<T> | undefined, key: MaybeRelationshipFields<this>, meta: LegacyRelationshipField) => void,
     binding?: T
   ): void {
     (this.constructor as typeof Model).eachRelationship<T, this>(callback, binding);
   }
 
-  relationshipFor(name: string): LegacyRelationshipSchema | undefined {
+  relationshipFor(name: string): LegacyRelationshipField | undefined {
     return (this.constructor as typeof Model).relationshipsByName.get(name);
   }
 
@@ -1199,7 +1195,7 @@ class Model extends EmberObject implements MinimalLegacyRecord {
   }
 
   @computeOnce
-  static get inverseMap(): Record<string, LegacyRelationshipSchema | null> {
+  static get inverseMap(): Record<string, LegacyRelationshipField | null> {
     if (DEPRECATE_EARLY_STATIC) {
       deprecate(
         `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
@@ -1217,7 +1213,7 @@ class Model extends EmberObject implements MinimalLegacyRecord {
         this.modelName
       );
     }
-    return Object.create(null) as Record<string, LegacyRelationshipSchema | null>;
+    return Object.create(null) as Record<string, LegacyRelationshipField | null>;
   }
 
   /**
@@ -1253,7 +1249,7 @@ class Model extends EmberObject implements MinimalLegacyRecord {
    @param {Store} store
    @return {Object} the inverse relationship, or null
    */
-  static inverseFor(name: string, store: Store): LegacyRelationshipSchema | null {
+  static inverseFor(name: string, store: Store): LegacyRelationshipField | null {
     if (DEPRECATE_EARLY_STATIC) {
       deprecate(
         `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
@@ -1282,7 +1278,7 @@ class Model extends EmberObject implements MinimalLegacyRecord {
   }
 
   //Calculate the inverse, ignoring the cache
-  static _findInverseFor(name: string, store: Store): LegacyRelationshipSchema | null {
+  static _findInverseFor(name: string, store: Store): LegacyRelationshipField | null {
     if (DEPRECATE_EARLY_STATIC) {
       deprecate(
         `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
@@ -1384,7 +1380,7 @@ class Model extends EmberObject implements MinimalLegacyRecord {
    */
 
   @computeOnce
-  static get relationships(): Map<string, LegacyRelationshipSchema[]> {
+  static get relationships(): Map<string, LegacyRelationshipField[]> {
     if (DEPRECATE_EARLY_STATIC) {
       deprecate(
         `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
@@ -1403,7 +1399,7 @@ class Model extends EmberObject implements MinimalLegacyRecord {
       );
     }
 
-    const map = new Map<string, LegacyRelationshipSchema[]>();
+    const map = new Map<string, LegacyRelationshipField[]>();
     const relationshipsByName = this.relationshipsByName;
 
     // Loop through each computed property on the class
@@ -1597,7 +1593,7 @@ class Model extends EmberObject implements MinimalLegacyRecord {
    @readOnly
    */
   @computeOnce
-  static get relationshipsByName(): Map<string, LegacyRelationshipSchema> {
+  static get relationshipsByName(): Map<string, LegacyRelationshipField> {
     if (DEPRECATE_EARLY_STATIC) {
       deprecate(
         `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
@@ -1630,7 +1626,7 @@ class Model extends EmberObject implements MinimalLegacyRecord {
   }
 
   @computeOnce
-  static get relationshipsObject(): Record<string, LegacyRelationshipSchema> {
+  static get relationshipsObject(): Record<string, LegacyRelationshipField> {
     if (DEPRECATE_EARLY_STATIC) {
       deprecate(
         `Accessing schema information on Models without looking up the model via the store is deprecated. Use store.modelFor (or better Snapshots or the store.getSchemaDefinitionService() apis) instead.`,
@@ -1649,7 +1645,7 @@ class Model extends EmberObject implements MinimalLegacyRecord {
       );
     }
 
-    const relationships = Object.create(null) as Record<string, LegacyRelationshipSchema>;
+    const relationships = Object.create(null) as Record<string, LegacyRelationshipField>;
     const modelName = this.modelName;
     this.eachComputedProperty((name: string, meta: unknown) => {
       if (!isRelationshipSchema(meta)) {
@@ -1760,7 +1756,7 @@ class Model extends EmberObject implements MinimalLegacyRecord {
     callback: (
       this: T | undefined,
       key: MaybeRelationshipFields<Schema>,
-      relationship: LegacyRelationshipSchema
+      relationship: LegacyRelationshipField
     ) => void,
     binding?: T
   ): void {
@@ -1833,7 +1829,7 @@ class Model extends EmberObject implements MinimalLegacyRecord {
    * @deprecated
    */
   static determineRelationshipType(
-    knownSide: LegacyRelationshipSchema,
+    knownSide: LegacyRelationshipField,
     store: Store
   ): 'oneToOne' | 'oneToMany' | 'manyToOne' | 'manyToMany' | 'oneToNone' | 'manyToNone' {
     if (DEPRECATE_EARLY_STATIC) {
@@ -2302,7 +2298,7 @@ if (DEBUG) {
 
 export { Model };
 
-function isRelationshipSchema(meta: unknown): meta is LegacyRelationshipSchema {
+function isRelationshipSchema(meta: unknown): meta is LegacyRelationshipField {
   const hasKind = typeof meta === 'object' && meta !== null && 'kind' in meta && 'options' in meta;
   return hasKind && (meta.kind === 'hasMany' || meta.kind === 'belongsTo');
 }
@@ -2315,7 +2311,7 @@ function findPossibleInverses(
   Klass: typeof Model,
   inverseType: typeof Model,
   name: string,
-  relationshipsSoFar?: LegacyRelationshipSchema[]
+  relationshipsSoFar?: LegacyRelationshipField[]
 ) {
   const possibleRelationships = relationshipsSoFar || [];
 
@@ -2372,8 +2368,8 @@ function legacyFindInverseFor(Klass: typeof Model, name: string, store: Store) {
 
   let fieldOnInverse: string | null | undefined;
   let inverseKind: 'belongsTo' | 'hasMany';
-  let inverseRelationship: LegacyRelationshipSchema | undefined;
-  let inverseOptions: LegacyRelationshipSchema['options'] | undefined;
+  let inverseRelationship: LegacyRelationshipField | undefined;
+  let inverseOptions: LegacyRelationshipField['options'] | undefined;
   const inverseSchema = Klass.typeForRelationship(name, store);
   assert(`No model was found for '${relationship.type}'`, inverseSchema);
 

packages/model/src/-private/model.ts

@@ -3,7 +3,7 @@ import { expectTypeOf } from 'expect-type';
 
 import Store from '@ember-data/store';
 import type { RelatedCollection as ManyArray } from '@ember-data/store/-private';
-import type { LegacyAttributeField, LegacyRelationshipSchema } from '@warp-drive/core-types/schema/fields';
+import type { LegacyAttributeField, LegacyRelationshipField } from '@warp-drive/core-types/schema/fields';
 import { Type } from '@warp-drive/core-types/symbols';
 
 import { attr } from './attr';
@@ -189,7 +189,7 @@ user.eachAttribute((key, meta) => {
 });
 user.eachRelationship((key, meta) => {
   expectTypeOf(key).toEqualTypeOf<'twin' | 'enemies' | 'friends'>();
-  expectTypeOf(meta).toEqualTypeOf<LegacyRelationshipSchema>();
+  expectTypeOf(meta).toEqualTypeOf<LegacyRelationshipField>();
 });
 
 branded.eachAttribute((key, meta) => {
@@ -199,7 +199,7 @@ branded.eachAttribute((key, meta) => {
 
 branded.eachRelationship((key, meta) => {
   expectTypeOf(key).toEqualTypeOf<'bestFriend' | 'twin' | 'enemies' | 'friends'>();
-  expectTypeOf(meta).toEqualTypeOf<LegacyRelationshipSchema>();
+  expectTypeOf(meta).toEqualTypeOf<LegacyRelationshipField>();
 });
 
 // this ensures that `serialize` can be overridden

packages/model/src/-private/model.type-test.ts

@@ -4,7 +4,7 @@ import type Store from '@ember-data/store';
 import type { NotificationType } from '@ember-data/store';
 import { assert } from '@warp-drive/build-config/macros';
 import type { StableRecordIdentifier } from '@warp-drive/core-types';
-import type { LegacyRelationshipSchema as RelationshipSchema } from '@warp-drive/core-types/schema/fields';
+import type { LegacyRelationshipField as RelationshipSchema } from '@warp-drive/core-types/schema/fields';
 
 import { LEGACY_SUPPORT } from './legacy-relationships-support';
 import type { Model } from './model';