add tests for record iteration

Author: runspired

internal-tooling/src/tasks/sync-scripts.ts

@@ -135,6 +135,15 @@ export async function main() {
     // ensure that the package.json scripts are up to date with defaults
     /////////////////////////////////////////////////////////////////////
 
+    if (project.isTest) {
+      if (!('private' in project.pkg)) {
+        project.pkg.private = true;
+        project.isPrivate = true;
+        pkgEdited = true;
+        log(`\t\t🔧 Added private flag to package.json`);
+      }
+    }
+
     if (!project.isPrivate) {
       if (!project.pkg.scripts) {
         project.pkg.scripts = {};

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

@@ -72,6 +72,17 @@ function isPathMatch(a: string[], b: string[]) {
   return a.length === b.length && a.every((v, i) => v === b[i]);
 }
 
+function isNonEnumerableProp(prop: string | number | symbol) {
+  return (
+    prop === 'constructor' ||
+    prop === 'prototype' ||
+    prop === '__proto__' ||
+    prop === 'toString' ||
+    prop === 'toJSON' ||
+    prop === 'toHTML'
+  );
+}
+
 const Editables = new WeakMap<SchemaRecord, SchemaRecord>();
 export class SchemaRecord {
   declare [RecordStore]: Store;
@@ -124,7 +135,12 @@ export class SchemaRecord {
 
     const proxy = new Proxy(this, {
       ownKeys() {
-        return Array.from(fields.keys());
+        const identityKey = identityField?.name;
+        const keys = Array.from(fields.keys());
+        if (identityKey) {
+          keys.unshift(identityKey);
+        }
+        return keys;
       },
 
       has(target: SchemaRecord, prop: string | number | symbol) {
@@ -135,10 +151,17 @@ export class SchemaRecord {
       },
 
       getOwnPropertyDescriptor(target, prop) {
-        if (!fields.has(prop as string)) {
-          throw new Error(`No field named ${String(prop)} on ${identifier.type}`);
-        }
         const schemaForField = prop === identityField?.name ? identityField : fields.get(prop as string)!;
+        assert(`No field named ${String(prop)} on ${identifier.type}`, schemaForField);
+
+        if (isNonEnumerableProp(prop)) {
+          return {
+            writable: false,
+            enumerable: false,
+            configurable: true,
+          };
+        }
+
         switch (schemaForField.kind) {
           case 'derived':
             return {
@@ -248,6 +271,19 @@ export class SchemaRecord {
 
           if (prop === Symbol.toPrimitive) return () => null;
 
+          if (prop === Symbol.iterator) {
+            let fn = BoundFns.get(Symbol.iterator);
+            if (!fn) {
+              fn = function* () {
+                for (const key in receiver) {
+                  yield [key, receiver[key as keyof typeof receiver]];
+                }
+              };
+              BoundFns.set(Symbol.iterator, fn);
+            }
+            return fn;
+          }
+
           if (prop === 'constructor') {
             return SchemaRecord;
           }

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

@@ -55,6 +55,10 @@ function _constructor(record: SchemaRecord) {
 
   return (state._constructor = state._constructor || {
     name: `SchemaRecord<${recordIdentifierFor(record).type}>`,
+    get modelName() {
+      assert(`record.constructor.modelName is not available outside of legacy mode`, false);
+      return undefined;
+    },
   });
 }
 _constructor[Type] = '@constructor';
@@ -65,7 +69,12 @@ _constructor[Type] = '@constructor';
  */
 export function withDefaults(schema: WithPartial<ResourceSchema, 'identity'>): ResourceSchema {
   schema.identity = schema.identity || DefaultIdentityField;
-  schema.fields.push(TypeField, ConstructorField);
+
+  // because fields gets iterated in definition order,
+  // we add TypeField to the beginning so that it will
+  // appear right next to the identity field
+  schema.fields.unshift(TypeField);
+  schema.fields.push(ConstructorField);
   return schema as ResourceSchema;
 }
 

tests/warp-drive__schema-record/package.json

@@ -18,8 +18,9 @@
     "build:tests": "IS_TESTING=true EMBER_CLI_TEST_COMMAND=true ember build --output-path=dist-test --suppress-sizes",
     "lint": "eslint . --quiet --cache --cache-strategy=content",
     "check:types": "glint",
-    "start": "ember test --test-port=0 --serve --no-launch",
-    "test": "ember test --test-port=0 --path=dist-test"
+    "start": "bun run build:tests --watch",
+    "test": "ember test --test-port=0 --path=dist-test",
+    "test:start": "bun run test --serve --no-launch"
   },
   "devDependencies": {
     "@babel/core": "^7.26.9",

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

@@ -135,8 +135,8 @@ module('Legacy Mode', function (hooks) {
     } catch (e) {
       assert.strictEqual(
         (e as Error).message,
-        'Cannot access record.constructor.modelName on non-Legacy Schema Records.',
-        'record.constructor.modelName throws'
+        'record.constructor.modelName is not available outside of legacy mode',
+        `record.constructor.modelName throws: ${(e as Error).message}`
       );
     }
     assert.strictEqual(record.constructor.name, 'SchemaRecord<user>', 'it has a useful constructor name');