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

This reverts commit 3fd81bf.

Author: runspired

packages/schema-record/src/-private/record.ts

@@ -316,18 +316,30 @@ export class SchemaRecord {
             return lastValue;
           }
           case 'field':
+            assert(
+              `SchemaRecord.${field.name} is not available in legacy mode because it has type '${field.kind}'`,
+              !target[Legacy]
+            );
             entangleSignal(signals, receiver, field.name);
             return computeField(schema, cache, target, identifier, field, propArray, IS_EDITABLE);
           case 'attribute':
             entangleSignal(signals, receiver, field.name);
             return computeAttribute(cache, identifier, prop as string, IS_EDITABLE);
           case 'resource':
+            assert(
+              `SchemaRecord.${field.name} is not available in legacy mode because it has type '${field.kind}'`,
+              !target[Legacy]
+            );
             entangleSignal(signals, receiver, field.name);
             return computeResource(store, cache, target, identifier, field, prop as string, IS_EDITABLE);
           case 'derived':
             return computeDerivation(schema, receiver as unknown as SchemaRecord, identifier, field, prop as string);
           case 'schema-array':
           case 'array':
+            assert(
+              `SchemaRecord.${field.name} is not available in legacy mode because it has type '${field.kind}'`,
+              !target[Legacy]
+            );
             entangleSignal(signals, receiver, field.name);
             return computeArray(
               store,
@@ -341,9 +353,17 @@ export class SchemaRecord {
               Mode[Legacy]
             );
           case 'object':
+            assert(
+              `SchemaRecord.${field.name} is not available in legacy mode because it has type '${field.kind}'`,
+              !target[Legacy]
+            );
             entangleSignal(signals, receiver, field.name);
             return computeObject(schema, cache, target, identifier, field, propArray, Mode[Editable], Mode[Legacy]);
           case 'schema-object':
+            assert(
+              `SchemaRecord.${field.name} is not available in legacy mode because it has type '${field.kind}'`,
+              !target[Legacy]
+            );
             entangleSignal(signals, receiver, field.name);
             // run transform, then use that value as the object to manage
             return computeSchemaObject(

tests/warp-drive__schema-record/tests/legacy/legacy-mode-activation-test.ts

@@ -178,6 +178,145 @@ module('Legacy Mode', function (hooks) {
     assert.strictEqual(record.constructor.name, 'Record<user>', 'it has a useful constructor name');
   });
 
+  test('records not in legacy mode can access values with type "field"', function (assert) {
+    const store = this.owner.lookup('service:store') as Store;
+    const { schema } = store;
+    registerDerivations(schema);
+
+    schema.registerResource(
+      withDefaults({
+        type: 'user',
+        fields: [
+          {
+            name: 'name',
+            kind: 'field',
+          },
+        ],
+      })
+    );
+
+    const record = store.push<User>({
+      data: {
+        type: 'user',
+        id: '1',
+        attributes: { name: 'Rey Pupatine' },
+      },
+    });
+
+    assert.false(record[Legacy], 'record is NOT in legacy mode');
+    assert.strictEqual(record.$type, 'user', '$type is accessible');
+
+    assert.strictEqual(record.name, 'Rey Pupatine', 'can access name field');
+  });
+
+  test('records in legacy mode cannot access values with type "field"', function (assert) {
+    const store = this.owner.lookup('service:store') as Store;
+    const { schema } = store;
+    registerLegacyDerivations(schema);
+
+    schema.registerResource(
+      withLegacyFields({
+        type: 'user',
+        fields: [
+          {
+            name: 'name',
+            kind: 'field',
+          },
+        ],
+      })
+    );
+
+    const record = store.push<User>({
+      data: {
+        type: 'user',
+        id: '1',
+        attributes: { name: 'Rey Pupatine' },
+      },
+    });
+
+    assert.true(record[Legacy], 'record is in legacy mode');
+
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+      record.name;
+      assert.ok(false, 'record.name should throw');
+    } catch (e) {
+      assert.strictEqual(
+        (e as Error).message,
+        "SchemaRecord.name is not available in legacy mode because it has type 'field'",
+        'record.name throws'
+      );
+    }
+  });
+
+  test('records in legacy mode cannot access resources', function (assert) {
+    const store = this.owner.lookup('service:store') as Store;
+    const { schema } = store;
+    registerLegacyDerivations(schema);
+
+    schema.registerResource(
+      withLegacyFields({
+        type: 'user',
+        fields: [
+          {
+            name: 'name',
+            type: null,
+            kind: 'attribute',
+          },
+          {
+            name: 'bestFriend',
+            type: 'user',
+            kind: 'resource',
+            options: { inverse: 'bestFriend', async: true },
+          },
+        ],
+      })
+    );
+
+    const record = store.push<User>({
+      data: {
+        type: 'user',
+        id: '1',
+        attributes: {
+          name: 'Chris',
+        },
+        relationships: {
+          bestFriend: {
+            data: { type: 'user', id: '2' },
+          },
+        },
+      },
+      included: [
+        {
+          type: 'user',
+          id: '2',
+          attributes: {
+            name: 'Rey',
+          },
+          relationships: {
+            bestFriend: {
+              data: { type: 'user', id: '1' },
+            },
+          },
+        },
+      ],
+    });
+
+    assert.true(record[Legacy], 'record is in legacy mode');
+
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+      record.bestFriend;
+      assert.ok(false, 'record.bestFriend should throw');
+    } catch (e) {
+      assert.strictEqual(
+        (e as Error).message,
+        "SchemaRecord.bestFriend is not available in legacy mode because it has type 'resource'",
+        'record.bestFriend throws'
+      );
+    }
+  });
+
   test('we can access errors', function (assert) {
     const store = this.owner.lookup('service:store') as Store;
     const { schema } = store;