refactor reload; allow reload of virtual link via string

Author: usu

src/Resource.ts

@@ -1,5 +1,5 @@
 import urltemplate from 'url-template'
-import { isTemplatedLink, isVirtualLink, isEntityReference } from './halHelpers'
+import { isTemplatedLink, isVirtualLink, isEntityReference, isVirtualResource } from './halHelpers'
 import ResourceInterface from './interfaces/ResourceInterface'
 import ApiActions from './interfaces/ApiActions'
 import { StoreData } from './interfaces/StoreData'
@@ -74,23 +74,23 @@ class Resource implements ResourceInterface {
   }
 
   $post (data: unknown): Promise<ResourceInterface | null> {
-    if (this.isVirtual()) {
+    if (isVirtualResource(this)) {
       throw new Error('$post is not implemented for virtual resources')
     }
 
     return this.apiActions.post(this._meta.self, data)
   }
 
   $patch (data: unknown): Promise<ResourceInterface> {
-    if (this.isVirtual()) {
+    if (isVirtualResource(this)) {
       throw new Error('$patch is not implemented for virtual resources')
     }
 
     return this.apiActions.patch(this._meta.self, data)
   }
 
   $del (): Promise<string | void> {
-    if (this.isVirtual()) {
+    if (isVirtualResource(this)) {
       throw new Error('$del is not implemented for virtual resources')
     }
 
@@ -110,14 +110,6 @@ class Resource implements ResourceInterface {
     // alternatively: could also return '{}', as the data cannot be used directly, anyway
     return JSON.stringify(this._storeData)
   }
-
-  /**
-   * returns true, if resource is only virtual generated an not an actual resource on the API
-   */
-  private isVirtual (): boolean {
-    const meta = this._storeData._meta
-    return 'virtual' in meta && meta.virtual
-  }
 }
 
 export default Resource

src/halHelpers.ts

@@ -1,4 +1,5 @@
 import { Link, VirtualLink, TemplatedLink, StoreDataCollection } from './interfaces/StoreData'
+import { ResourceInterface, VirtualResource } from './interfaces/ResourceInterface'
 
 type keyValueObject = Record<string, unknown>
 
@@ -40,6 +41,16 @@ function isVirtualLink (object: keyValueObject): object is VirtualLink {
   return isEqualIgnoringOrder(Object.keys(object), ['href', 'virtual']) && (object.virtual === true)
 }
 
+/**
+ * A virtual resource contains a generated, virtual self link which points to another store key but
+ * doesn't correspond to an actual resource on the API. Such resources have the _meta.virtual flag set to true.
+ * @param resource
+ * @returns boolean  true if resource is a VirtualResource
+ */
+function isVirtualResource (resource: ResourceInterface): resource is VirtualResource {
+  return (resource as VirtualResource)._storeData?._meta?.virtual
+}
+
 /**
  * A standalone collection in the Vuex store has an items property that is an array.
  * @param object    to be examined
@@ -49,4 +60,4 @@ function isCollection (object: keyValueObject): object is StoreDataCollection {
   return !!(object && Array.isArray(object.items))
 }
 
-export { isTemplatedLink, isVirtualLink, isEntityReference, isCollection }
+export { isTemplatedLink, isVirtualLink, isEntityReference, isCollection, isVirtualResource }

src/index.ts

@@ -12,6 +12,7 @@ import { AxiosInstance, AxiosError } from 'axios'
 import ResourceInterface from './interfaces/ResourceInterface'
 import StoreData, { Link, SerializablePromise } from './interfaces/StoreData'
 import ApiActions from './interfaces/ApiActions'
+import { isVirtualResource } from './halHelpers'
 
 /**
  * Defines the API store methods available in all Vue components. The methods can be called as follows:
@@ -132,19 +133,23 @@ function HalJsonVuex (store: Store<Record<string, State>>, axios: AxiosInstance,
    *                    in the Vuex store.
    */
   async function reload (uriOrEntity: string | ResourceInterface): Promise<ResourceInterface> {
-    if (uriOrEntity instanceof Resource && 'virtual' in uriOrEntity._storeData._meta && uriOrEntity._storeData._meta.virtual) {
+    let resource: ResourceInterface
+
+    if (typeof uriOrEntity === 'string') {
+      resource = get(uriOrEntity)
+    } else {
+      resource = uriOrEntity
+    }
+
+    if (isVirtualResource(resource)) {
       // For embedded collections which had to reload the parent entity, unwrap the embedded collection after loading has finished
-      const { owningResource, owningRelation } = uriOrEntity._storeData._meta
+      const { owningResource, owningRelation } = resource._storeData._meta
       return reload(owningResource).then(owner => owner[owningRelation]())
     }
 
-    const uri = normalizeEntityUri(uriOrEntity, axios.defaults.baseURL)
+    const uri = normalizeEntityUri(resource, axios.defaults.baseURL)
 
     if (uri === null) {
-      if (uriOrEntity instanceof LoadingResource) {
-        // A LoadingResource is safe to return without breaking the UI.
-        return uriOrEntity
-      }
       // We don't know anything about the requested object, something is wrong.
       throw new Error(`Could not perform reload, "${uriOrEntity}" is not an entity or URI`)
     }
@@ -159,16 +164,6 @@ function HalJsonVuex (store: Store<Record<string, State>>, axios: AxiosInstance,
     return loadPromise.then(storeData => resourceCreator.wrap(storeData))
   }
 
-  async function reloadResourceFromStoreData (storeData: StoreData) {
-    if ('virtual' in storeData._meta && storeData._meta.virtual) {
-      const { owningResource, owningRelation } = storeData._meta
-
-      return reload(owningResource).then(owner => owner[owningRelation]())
-    }
-
-    return reload(storeData._meta.self)
-  }
-
   /**
    * Returns true if uri doesn't exist in store (never loaded before)
    * @param uri
@@ -367,7 +362,7 @@ function HalJsonVuex (store: Store<Record<string, State>>, axios: AxiosInstance,
       .filter(outdatedEntity => !outdatedEntity._meta.deleting)
 
       // reload outdated entities...
-      .map(outdatedEntity => reloadResourceFromStoreData(outdatedEntity).catch(() => {
+      .map(outdatedEntity => reload(outdatedEntity._meta.self).catch(() => {
         // ...but ignore any errors (such as 404 errors during reloading)
         // handleAxiosError will take care of recursively deleting cascade-deleted entities
       }))

src/interfaces/ResourceInterface.ts

@@ -1,4 +1,4 @@
-import StoreData from './StoreData'
+import { StoreData, VirtualStoreData } from './StoreData'
 
 /**
  * Generic interface for a standalone ResourceInterface (e.g. a HAl resource with an own store entry and a self link)
@@ -12,7 +12,7 @@ interface ResourceInterface {
         deleting?: boolean
     }
 
-    _storeData?: StoreData
+    _storeData?: StoreData // optional, because LoadingResource has no _storeData
 
     $reload: () => Promise<ResourceInterface>
     $post: (data: unknown) => Promise<ResourceInterface | null>
@@ -21,5 +21,9 @@ interface ResourceInterface {
     $href: (relation: string, templateParams: Record<string, string | number | boolean>) => Promise<string | undefined>
 }
 
-export { ResourceInterface }
+interface VirtualResource extends ResourceInterface {
+    _storeData: VirtualStoreData
+}
+
+export { ResourceInterface, VirtualResource }
 export default ResourceInterface

src/interfaces/StoreData.ts

@@ -31,14 +31,14 @@ type VirtualStoreDataMeta = StoreDataMeta & {
     }
 }
 
-type StoreDataEntity = (StoreDataMeta | VirtualStoreDataMeta) & {
+type StoreDataEntity = StoreDataMeta & {
     items: never,
     _meta: {
         load: SerializablePromise<StoreDataEntity>
     }
 }
 
-type StoreDataCollection = (StoreDataMeta | VirtualStoreDataMeta) & {
+type StoreDataCollection = StoreDataMeta & {
     items: Array<Link>,
     _meta: {
         load: SerializablePromise<StoreDataCollection>
@@ -47,6 +47,8 @@ type StoreDataCollection = (StoreDataMeta | VirtualStoreDataMeta) & {
 
 type StoreData = StoreDataEntity | StoreDataCollection
 
-export { StoreData, Link, VirtualLink, TemplatedLink, StoreDataEntity, StoreDataCollection, SerializablePromise }
+type VirtualStoreData = StoreData & VirtualStoreDataMeta
+
+export { StoreData, VirtualStoreData, Link, VirtualLink, TemplatedLink, StoreDataEntity, StoreDataCollection, SerializablePromise }
 
 export default StoreData

src/normalizeEntityUri.ts

@@ -36,9 +36,16 @@ function sortQueryParams (uri: string): string {
  * @param baseUrl         common URI prefix to remove during normalization
  * @returns {null|string} normalized URI, or null if the uriOrEntity argument was not understood
  */
-function normalizeEntityUri (uriOrEntity: string | ResourceInterface | StoreData = '', baseUrl = ''): string | null {
-  if (typeof uriOrEntity === 'string') return normalizeUri(uriOrEntity, baseUrl)
-  return normalizeUri(((uriOrEntity || {})._meta || {}).self, baseUrl)
+function normalizeEntityUri (uriOrEntity: string | ResourceInterface | null = '', baseUrl = ''): string | null {
+  let uri
+
+  if (typeof uriOrEntity === 'string') {
+    uri = uriOrEntity
+  } else {
+    uri = uriOrEntity?._meta?.self
+  }
+
+  return normalizeUri(uri, baseUrl)
 }
 
 /**