crate: Add withReleaseTracks support for findHasMany

Author: eth3lbert

app/adapters/crate.js

@@ -5,6 +5,34 @@ const BULK_REQUEST_GROUP_SIZE = 10;
 export default class CrateAdapter extends ApplicationAdapter {
   coalesceFindRequests = true;
 
+  async findHasMany(store, snapshot, url, relationship) {
+    if (relationship.key === 'versions') {
+      let { adapterOptions } = snapshot;
+      let data;
+      if (adapterOptions?.withReleaseTracks === true) {
+        data = { include: 'release_tracks' };
+      }
+      return this.ajax(url, 'GET', { data }).then(resp => {
+        let crate = store.peekRecord('crate', snapshot.id);
+        if (resp.meta) {
+          let payload = {
+            crate: {
+              id: snapshot.id,
+              versions_meta: {
+                ...crate.versions_meta,
+                ...resp.meta,
+              },
+            },
+          };
+          store.pushPayload(payload);
+        }
+        return resp;
+      });
+    }
+
+    return super.findHasMany(store, snapshot, url, relationship);
+  }
+
   findRecord(store, type, id, snapshot) {
     let { include } = snapshot;
     // This ensures `crate.versions` are always fetched from another request.

app/models/crate.js

@@ -146,9 +146,18 @@ export default class Crate extends Model {
     return [...(teams ?? []), ...(users ?? [])];
   });
 
-  loadVersionsTask = task(async ({ reload = false } = {}) => {
+  /**
+   * @param {Object} [Options]
+   * @param {bool} [Options.reload]
+   * @param {bool} [Options.withReleaseTracks] - default: true if it has not yet been loaded else false
+   **/
+  loadVersionsTask = task(async ({ reload = false, withReleaseTracks } = {}) => {
     let versionsRef = this.hasMany('versions');
-    let fut = reload === true ? versionsRef.reload() : versionsRef.load();
+    let opts = { adapterOptions: { withReleaseTracks } };
+    if (opts.adapterOptions.withReleaseTracks == null) {
+      opts.adapterOptions.withReleaseTracks = this?.versions_meta?.release_tracks == null;
+    }
+    let fut = reload === true ? versionsRef.reload(opts) : versionsRef.load(opts);
     return (await fut) ?? [];
   });
 }

tests/adapters/crate-test.js

@@ -39,4 +39,27 @@ module('Adapter | crate', function (hooks) {
     await versionsRef.load();
     assert.deepEqual(versionsRef.ids(), [version.id]);
   });
+
+  test('findHasMany `versions` with `release_tracks` meta', async function (assert) {
+    let crate = this.server.create('crate', { name: 'foo' });
+    this.server.create('version', { crate, num: '0.0.1' });
+    this.server.create('version', { crate, num: '0.1.0' });
+    this.server.create('version', { crate, num: '1.0.0' });
+
+    let store = this.owner.lookup('service:store');
+
+    let foo = await store.findRecord('crate', 'foo');
+    assert.strictEqual(foo?.name, 'foo');
+    assert.strictEqual(foo?.versions_map?.release_tracks, undefined);
+
+    // load `versions` without `release_tracks` meta included
+    let versionsRef = foo.hasMany('versions');
+    await versionsRef.load();
+    assert.strictEqual(foo?.versions_meta?.release_tracks, undefined);
+
+    // reload `versions` with `release_tracks` meta included
+    let resp = await versionsRef.reload({ adapterOptions: { withReleaseTracks: true } });
+    let { meta } = resp;
+    assert.deepEqual(foo?.versions_meta?.release_tracks, meta.release_tracks);
+  });
 });