chore: make return types explicit

Author: runspired

packages/model/src/-private/legacy-relationships-support.ts

@@ -27,6 +27,7 @@ import type { CollectionRelationship } from '@warp-drive/core-types/cache/relati
 import type { LocalRelationshipOperation } from '@warp-drive/core-types/graph';
 import type { CollectionResourceRelationship, SingleResourceRelationship } from '@warp-drive/core-types/spec/raw';
 
+import type { ManyArray } from '../-private';
 import RelatedCollection from './many-array';
 import type { MinimalLegacyRecord } from './model-methods';
 import type { BelongsToProxyCreateArgs, BelongsToProxyMeta } from './promise-belongs-to';
@@ -298,11 +299,11 @@ export class LegacySupport {
     assert('hasMany only works with the @ember-data/json-api package');
   }
 
-  reloadHasMany(key: string, options?: BaseFinderOptions) {
+  reloadHasMany<T>(key: string, options?: BaseFinderOptions): Promise<ManyArray<T>> | PromiseManyArray<T> {
     if (HAS_JSON_API_PACKAGE) {
       const loadingPromise = this._relationshipPromisesCache[key];
       if (loadingPromise) {
-        return loadingPromise;
+        return loadingPromise as Promise<ManyArray<T>>;
       }
       const relationship = this.graph.get(this.identifier, key) as CollectionEdge;
       const { definition, state } = relationship;
@@ -313,10 +314,10 @@ export class LegacySupport {
       const promise = this.fetchAsyncHasMany(key, relationship, manyArray, options);
 
       if (this._relationshipProxyCache[key]) {
-        return this._updatePromiseProxyFor('hasMany', key, { promise });
+        return this._updatePromiseProxyFor('hasMany', key, { promise }) as PromiseManyArray<T>;
       }
 
-      return promise;
+      return promise as Promise<ManyArray<T>>;
     }
     assert(`hasMany only works with the @ember-data/json-api package`);
   }
@@ -388,7 +389,9 @@ export class LegacySupport {
     return promiseProxy;
   }
 
-  referenceFor(kind: string | null, name: string) {
+  referenceFor(kind: 'belongsTo', name: string): BelongsToReference;
+  referenceFor(kind: 'hasMany', name: string): HasManyReference;
+  referenceFor(kind: 'belongsTo' | 'hasMany', name: string) {
     let reference = this.references[name];
 
     if (!reference) {

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

@@ -390,10 +390,10 @@ export default class RelatedCollection<T = unknown> extends RecordArray<T> {
   /**
     Reloads all of the records in the manyArray. If the manyArray
     holds a relationship that was originally fetched using a links url
-    Ember Data will revisit the original links url to repopulate the
+    EmberData will revisit the original links url to repopulate the
     relationship.
 
-    If the manyArray holds the result of a `store.query()` reload will
+    If the ManyArray holds the result of a `store.query()` reload will
     re-run the original query.
 
     Example
@@ -409,9 +409,9 @@ export default class RelatedCollection<T = unknown> extends RecordArray<T> {
     @method reload
     @public
   */
-  reload(options?: BaseFinderOptions) {
+  reload(options?: BaseFinderOptions): Promise<this> {
     // TODO this is odd, we don't ask the store for anything else like this?
-    return this._manager.reloadHasMany(this.key, options);
+    return this._manager.reloadHasMany<T>(this.key, options) as Promise<this>;
   }
 
   /**

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

@@ -13,6 +13,8 @@ import { RecordStore } from '@warp-drive/core-types/symbols';
 import type Errors from './errors';
 import { lookupLegacySupport } from './legacy-relationships-support';
 import type RecordState from './record-state';
+import type BelongsToReference from './references/belongs-to';
+import type HasManyReference from './references/has-many';
 
 export interface MinimalLegacyRecord {
   errors: Errors;
@@ -51,11 +53,11 @@ export function unloadRecord(this: MinimalLegacyRecord) {
   this[RecordStore].unloadRecord(this);
 }
 
-export function belongsTo(this: MinimalLegacyRecord, prop: string) {
+export function belongsTo(this: MinimalLegacyRecord, prop: string): BelongsToReference {
   return lookupLegacySupport(this).referenceFor('belongsTo', prop);
 }
 
-export function hasMany(this: MinimalLegacyRecord, prop: string) {
+export function hasMany(this: MinimalLegacyRecord, prop: string): HasManyReference {
   return lookupLegacySupport(this).referenceFor('hasMany', prop);
 }
 

packages/model/src/-private/references/has-many.ts

@@ -743,11 +743,11 @@ export default class HasManyReference<
    @param {Object} options the options to pass in.
    @return {Promise} a promise that resolves with the ManyArray in this has-many relationship.
    */
-  reload(options?: BaseFinderOptions) {
+  reload(options?: BaseFinderOptions): Promise<ManyArray<Related>> {
     const support: LegacySupport = (LEGACY_SUPPORT as Map<StableRecordIdentifier, LegacySupport>).get(
       this.___identifier
     )!;
-    return support.reloadHasMany(this.key, options);
+    return support.reloadHasMany(this.key, options) as Promise<ManyArray<Related>>;
   }
 }
 defineSignal(HasManyReference.prototype, '_ref', 0);