for consistens naming (prefer Resource & Collection over StoreValue)

Author: usu

src/HasItems.ts src/Collection.tssrc/HasItems.ts renamed to src/Collection.ts

@@ -1,74 +1,74 @@
 import { isEntityReference } from './halHelpers'
-import LoadingStoreCollection from './LoadingStoreCollection'
-import Resource from './interfaces/Resource'
-import Collection from './interfaces/Collection'
+import LoadingCollection from './LoadingCollection'
+import ResourceInterface from './interfaces/ResourceInterface'
+import CollectionInterface from './interfaces/CollectionInterface'
 import { Link } from './interfaces/StoreData'
-import StoreValue from './StoreValue'
+import Resource from './Resource'
 
 /**
   * Filter out items that are marked as deleting (eager removal)
   */
-function filterDeleting (array: Array<Resource>): Array<Resource> {
+function filterDeleting (array: Array<ResourceInterface>): Array<ResourceInterface> {
   return array.filter(entry => !entry._meta.deleting)
 }
 
-class HasItems extends StoreValue {
+class Collection extends Resource {
   /**
      * Get items excluding ones marked as 'deleting' (eager remove)
      * The items property should always be a getter, in order to make the call to mapArrayOfEntityReferences
      * lazy, since that potentially fetches a large number of entities from the API.
      */
-  public get items (): Array<Resource> {
+  public get items (): Array<ResourceInterface> {
     return filterDeleting(this._mapArrayOfEntityReferences(this._storeData.items))
   }
 
   /**
      * Get all items including ones marked as 'deleting' (lazy remove)
      */
-  public get allItems (): Array<Resource> {
+  public get allItems (): Array<ResourceInterface> {
     return this._mapArrayOfEntityReferences(this._storeData.items)
   }
 
   /**
      * Returns a promise that resolves to the collection object, once all items have been loaded
      */
-  public $loadItems () :Promise<Collection> {
+  public $loadItems () :Promise<CollectionInterface> {
     return this._itemLoader(this._storeData.items)
   }
 
   /**
      *  Returns a promise that resolves to the collection object, once all items have been loaded
      */
-  private _itemLoader (array: Array<Link>) : Promise<Collection> {
+  private _itemLoader (array: Array<Link>) : Promise<CollectionInterface> {
     if (!this._containsUnknownEntityReference(array)) {
-      return Promise.resolve(this as unknown as Collection) // we know that this object must be of type Collection
+      return Promise.resolve(this as unknown as CollectionInterface) // we know that this object must be of type CollectionInterface
     }
 
     // eager loading of 'fetchAllUri' (e.g. parent for embedded collections)
     if (this.config.avoidNPlusOneRequests) {
-      return this.apiActions.reload(this as unknown as Collection) as Promise<Collection> // we know that reload resolves to a type Collection
+      return this.apiActions.reload(this as unknown as CollectionInterface) as Promise<CollectionInterface> // we know that reload resolves to a type CollectionInterface
 
-      // no eager loading: replace each reference (Link) with a StoreValue (Resource)
+      // no eager loading: replace each reference (Link) with a Resource (ResourceInterface)
     } else {
       const arrayWithReplacedReferences = this._replaceEntityReferences(array)
 
       return Promise.all(
         arrayWithReplacedReferences.map(entry => entry._meta.load)
-      ).then(() => this as unknown as Collection) // we know that this object must be of type Collection
+      ).then(() => this as unknown as CollectionInterface) // we know that this object must be of type CollectionInterface
     }
   }
 
   /**
      * Given an array, replaces any entity references in the array with the entity loaded from the Vuex store
      * (or from the API if necessary), and returns that as a new array. In case some of the entity references in
-     * the array have not finished loading yet, returns a LoadingStoreCollection instead.
+     * the array have not finished loading yet, returns a LoadingCollection instead.
      * @param array            possibly mixed array of values and references
      * @param fetchAllUri      URI that allows fetching all array items in a single network request, if known
      * @param fetchAllProperty property in the entity from fetchAllUri that will contain the array
-     * @returns array          the new array with replaced items, or a LoadingStoreCollection if any of the array
+     * @returns array          the new array with replaced items, or a LoadingCollection if any of the array
      *                         elements is still loading.
      */
-  private _mapArrayOfEntityReferences (array: Array<Link>): Array<Resource> {
+  private _mapArrayOfEntityReferences (array: Array<Link>): Array<ResourceInterface> {
     if (!this._containsUnknownEntityReference(array)) {
       return this._replaceEntityReferences(array)
     }
@@ -77,18 +77,18 @@ class HasItems extends StoreValue {
 
     // eager loading of 'fetchAllUri' (e.g. parent for embedded collections)
     if (this.config.avoidNPlusOneRequests) {
-      return LoadingStoreCollection.create(itemsLoaded)
+      return LoadingCollection.create(itemsLoaded)
 
-      // no eager loading: replace each reference (Link) with a StoreValue (Resource)
+      // no eager loading: replace each reference (Link) with a Resource (ResourceInterface)
     } else {
-      return LoadingStoreCollection.create(itemsLoaded, this._replaceEntityReferences(array))
+      return LoadingCollection.create(itemsLoaded, this._replaceEntityReferences(array))
     }
   }
 
   /**
-   * Replace each item in array with a proper StoreValue (or LoadingStoreValue)
+   * Replace each item in array with a proper Resource (or LoadingResource)
    */
-  private _replaceEntityReferences (array: Array<Link>): Array<Resource> {
+  private _replaceEntityReferences (array: Array<Link>): Array<ResourceInterface> {
     return array
       .filter(entry => isEntityReference(entry))
       .map(entry => this.apiActions.get(entry.href))
@@ -102,4 +102,4 @@ class HasItems extends StoreValue {
   }
 }
 
-export default HasItems
+export default Collection

src/LoadingStoreCollection.ts src/LoadingCollection.tssrc/LoadingStoreCollection.ts renamed to src/LoadingCollection.ts

@@ -1,40 +1,40 @@
-import LoadingStoreValue from './LoadingStoreValue'
-import Resource from './interfaces/Resource'
+import LoadingResource from './LoadingResource'
+import ResourceInterface from './interfaces/ResourceInterface'
 
-class LoadingStoreCollection {
+class LoadingCollection {
   /**
    * Returns a placeholder for an array that has not yet finished loading from the API. The array placeholder
    * will respond to functional calls (like .find(), .map(), etc.) with further LoadingStoreCollections or
    * LoadingStoreValues. If passed the existingContent argument, random access and .length will also work.
    * @param loadArray       Promise that resolves once the array has finished loading
    * @param existingContent optionally set the elements that are already known, for random access
    */
-  static create (loadArray: Promise<Array<Resource> | undefined>, existingContent: Array<Resource> = []): Array<Resource> {
+  static create (loadArray: Promise<Array<ResourceInterface> | undefined>, existingContent: Array<ResourceInterface> = []): Array<ResourceInterface> {
     // if Promsise resolves to undefined, provide empty array
-    // this could happen if items is accessed from a LoadingStoreValue, which resolves to a normal entity without 'items'
+    // this could happen if items is accessed from a LoadingResource, which resolves to a normal entity without 'items'
     const loadArraySafely = loadArray.then(array => array ?? [])
 
-    // proxy array function 'find' to a LoadingStoreValue (Resource)
+    // proxy array function 'find' to a LoadingResource (Resource)
     const singleResultFunctions = ['find']
     singleResultFunctions.forEach(func => {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       existingContent[func] = (...args: any[]) => {
-        const resultLoaded = loadArraySafely.then(array => array[func](...args) as Resource)
-        return new LoadingStoreValue(resultLoaded)
+        const resultLoaded = loadArraySafely.then(array => array[func](...args) as ResourceInterface)
+        return new LoadingResource(resultLoaded)
       }
     })
 
-    // proxy array functions with multiple results to a LoadingStoreCollection (Array<Resource>)
+    // proxy array functions with multiple results to a LoadingCollection (Array<ResourceInterface>)
     const arrayResultFunctions = ['map', 'flatMap', 'filter']
     arrayResultFunctions.forEach(func => {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       existingContent[func] = (...args: any[]) => {
-        const resultLoaded = loadArraySafely.then(array => array[func](...args) as Array<Resource>) // TODO: return type for .map() is not necessarily an Array<Resource>
-        return LoadingStoreCollection.create(resultLoaded)
+        const resultLoaded = loadArraySafely.then(array => array[func](...args) as Array<ResourceInterface>) // TODO: return type for .map() is not necessarily an Array<ResourceInterface>
+        return LoadingCollection.create(resultLoaded)
       }
     })
     return existingContent
   }
 }
 
-export default LoadingStoreCollection
+export default LoadingCollection

src/LoadingStoreValue.ts src/LoadingResource.tssrc/LoadingStoreValue.ts renamed to src/LoadingResource.ts

@@ -1,35 +1,35 @@
-import LoadingStoreCollection from './LoadingStoreCollection'
-import Resource from './interfaces/Resource'
-import Collection from './interfaces/Collection'
+import LoadingCollection from './LoadingCollection'
+import ResourceInterface from './interfaces/ResourceInterface'
+import CollectionInterface from './interfaces/CollectionInterface'
 
 /**
  * Creates a placeholder for an entity which has not yet finished loading from the API.
- * Such a LoadingStoreValue can safely be used in Vue components, since it will render as an empty
+ * Such a LoadingResource can safely be used in Vue components, since it will render as an empty
  * string and Vue's reactivity system will replace it with the real data once that is available.
  *
- * Accessing nested functions in a LoadingStoreValue yields another LoadingStoreValue:
- * new LoadingStoreValue(...).author().organization() // gives another LoadingStoreValue
+ * Accessing nested functions in a LoadingResource yields another LoadingResource:
+ * new LoadingResource(...).author().organization() // gives another LoadingResource
  *
- * Using a LoadingStoreValue or a property of a LoadingStoreValue in a view renders to empty strings:
- * let user = new LoadingStoreValue(...)
+ * Using a LoadingResource or a property of a LoadingResource in a view renders to empty strings:
+ * let user = new LoadingResource(...)
  * 'The "' + user + '" is called "' + user.name + '"' // gives 'The "" is called ""'
  */
-class LoadingStoreValue implements Resource {
+class LoadingResource implements ResourceInterface {
   public _meta: {
     self: string | null,
-    load: Promise<Resource>
+    load: Promise<ResourceInterface>
     loading: boolean
   }
 
-  private loadResource: Promise<Resource>
+  private loadResource: Promise<ResourceInterface>
 
   /**
-   * @param entityLoaded a Promise that resolves to a StoreValue when the entity has finished
+   * @param entityLoaded a Promise that resolves to a Resource when the entity has finished
    *                     loading from the API
    * @param absoluteSelf optional fully qualified URI of the entity being loaded, if available. If passed, the
-   *                     returned LoadingStoreValue will return it in calls to .self and ._meta.self
+   *                     returned LoadingResource will return it in calls to .self and ._meta.self
    */
-  constructor (loadResource: Promise<Resource>, absoluteSelf: string | null = null) {
+  constructor (loadResource: Promise<ResourceInterface>, absoluteSelf: string | null = null) {
     this._meta = {
       self: absoluteSelf,
       load: loadResource,
@@ -39,28 +39,28 @@ class LoadingStoreValue implements Resource {
     this.loadResource = loadResource
 
     const handler = {
-      get: function (target: LoadingStoreValue, prop: string | number | symbol) {
-        // This is necessary so that Vue's reactivity system understands to treat this LoadingStoreValue
+      get: function (target: LoadingResource, prop: string | number | symbol) {
+        // This is necessary so that Vue's reactivity system understands to treat this LoadingResource
         // like a normal object.
         if (prop === Symbol.toPrimitive) {
           return () => ''
         }
 
-        // This is necessary so that Vue's reactivity system understands to treat this LoadingStoreValue
+        // This is necessary so that Vue's reactivity system understands to treat this LoadingResource
         // like a normal object.
         if (['then', Symbol.toStringTag, 'state', 'getters', '$options', '_isVue', '__file', 'render', 'constructor'].includes(prop as string)) {
           return undefined
         }
 
-        // proxy to properties that actually exist on LoadingStoreValue (_meta, $reload, etc.)
+        // proxy to properties that actually exist on LoadingResource (_meta, $reload, etc.)
         if (Reflect.has(target, prop)) {
           return Reflect.get(target, prop)
         }
 
-        // Proxy to all other unknown properties: return a function that yields another LoadingStoreValue
+        // Proxy to all other unknown properties: return a function that yields another LoadingResource
         const loadProperty = loadResource.then(resource => resource[prop])
 
-        const result = templateParams => new LoadingStoreValue(loadProperty.then(property => {
+        const result = templateParams => new LoadingResource(loadProperty.then(property => {
           try {
             return property(templateParams)._meta.load
           } catch (e) {
@@ -76,28 +76,28 @@ class LoadingStoreValue implements Resource {
     return new Proxy(this, handler)
   }
 
-  get items (): Array<Resource> {
-    return LoadingStoreCollection.create(this.loadResource.then(resource => (resource as Collection).items))
+  get items (): Array<ResourceInterface> {
+    return LoadingCollection.create(this.loadResource.then(resource => (resource as CollectionInterface).items))
   }
 
-  get allItems (): Array<Resource> {
-    return LoadingStoreCollection.create(this.loadResource.then(resource => (resource as Collection).allItems))
+  get allItems (): Array<ResourceInterface> {
+    return LoadingCollection.create(this.loadResource.then(resource => (resource as CollectionInterface).allItems))
   }
 
-  public $reload (): Promise<Resource> {
+  public $reload (): Promise<ResourceInterface> {
     // Skip reloading entities that are already loading
     return this._meta.load
   }
 
-  public $loadItems (): Promise<Collection> {
-    return this._meta.load.then(resource => (resource as Collection).$loadItems())
+  public $loadItems (): Promise<CollectionInterface> {
+    return this._meta.load.then(resource => (resource as CollectionInterface).$loadItems())
   }
 
-  public $post (data: unknown): Promise<Resource | null> {
+  public $post (data: unknown): Promise<ResourceInterface | null> {
     return this._meta.load.then(resource => resource.$post(data))
   }
 
-  public $patch (data: unknown): Promise<Resource> {
+  public $patch (data: unknown): Promise<ResourceInterface> {
     return this._meta.load.then(resource => resource.$patch(data))
   }
 
@@ -114,4 +114,4 @@ class LoadingStoreValue implements Resource {
   }
 }
 
-export default LoadingStoreValue
+export default LoadingResource

src/StoreValue.ts src/Resource.tssrc/StoreValue.ts renamed to src/Resource.ts

@@ -1,20 +1,20 @@
 import urltemplate from 'url-template'
 import { isTemplatedLink, isVirtualLink, isEntityReference } from './halHelpers'
-import Resource from './interfaces/Resource'
+import ResourceInterface from './interfaces/ResourceInterface'
 import ApiActions from './interfaces/ApiActions'
 import { StoreData } from './interfaces/StoreData'
-import StoreValueCreator from './StoreValueCreator'
+import ResourceCreator from './ResourceCreator'
 import { InternalConfig } from './interfaces/Config'
 
 /**
- * Represents an actual StoreValue, by wrapping the given Vuex store storeData. The storeData must not be loading.
+ * Represents an actual Resource, by wrapping the given Vuex store storeData. The storeData must not be loading.
  * If the storeData has been loaded into the store before but is currently reloading, the old storeData will be
  * returned, along with a ._meta.load promise that resolves when the reload is complete.
  */
-class StoreValue implements Resource {
+class Resource implements ResourceInterface {
   public _meta: {
     self: string,
-    load: Promise<Resource>
+    load: Promise<ResourceInterface>
     loading: boolean
   }
 
@@ -25,10 +25,10 @@ class StoreValue implements Resource {
   /**
    * @param storeData fully loaded entity storeData from the Vuex store
    * @param apiActions inject dependency: API actions
-   * @param storeValueCreator inject dependency StoreValue factory
+   * @param resourceCreator inject dependency Resource factory
    * @param config inject dependency: config options
    */
-  constructor (storeData: StoreData, apiActions: ApiActions, storeValueCreator: StoreValueCreator, config: InternalConfig) {
+  constructor (storeData: StoreData, apiActions: ApiActions, resourceCreator: ResourceCreator, config: InternalConfig) {
     this.apiActions = apiActions
     this.config = config
     this._storeData = storeData
@@ -58,7 +58,7 @@ class StoreValue implements Resource {
 
     // Use a trivial load promise to break endless recursion, except if we are currently reloading the storeData from the API
     const loadResource = storeData._meta.reloading
-      ? (storeData._meta.load as Promise<StoreData>).then(reloadedData => storeValueCreator.wrap(reloadedData))
+      ? (storeData._meta.load as Promise<StoreData>).then(reloadedData => resourceCreator.wrap(reloadedData))
       : Promise.resolve(this)
 
     // Use a shallow clone of _meta, since we don't want to overwrite the ._meta.load promise or self link in the Vuex store
@@ -69,19 +69,19 @@ class StoreValue implements Resource {
     }
   }
 
-  $reload (): Promise<Resource> {
+  $reload (): Promise<ResourceInterface> {
     return this.apiActions.reload(this)
   }
 
-  $post (data: unknown): Promise<Resource | null> {
+  $post (data: unknown): Promise<ResourceInterface | null> {
     if (this.isVirtual()) {
       throw new Error('$post is not implemented for virtual resources')
     }
 
     return this.apiActions.post(this._meta.self, data)
   }
 
-  $patch (data: unknown): Promise<Resource> {
+  $patch (data: unknown): Promise<ResourceInterface> {
     if (this.isVirtual()) {
       throw new Error('$patch is not implemented for virtual resources')
     }
@@ -120,4 +120,4 @@ class StoreValue implements Resource {
   }
 }
 
-export default StoreValue
+export default Resource