remove EmbeddedCollection as special case

Author: usu

src/EmbeddedCollection.ts

@@ -18,7 +18,7 @@ type GConstructor<T> = new (...args: any[]) => T;
 type HasStoreData = GConstructor<{ _storeData: { items: Array<Link> } }>;
 
 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-function HasItems<TBase extends HasStoreData> (Base: TBase, apiActions: ApiActions, config: InternalConfig, reloadUri?: string, reloadProperty?: string) {
+function HasItems<TBase extends HasStoreData> (Base: TBase, apiActions: ApiActions, config: InternalConfig) {
   /**
    * Filter out items that are marked as deleting (eager removal)
    */
@@ -75,8 +75,8 @@ function HasItems<TBase extends HasStoreData> (Base: TBase, apiActions: ApiActio
       }
 
       // eager loading of 'fetchAllUri' (e.g. parent for embedded collections)
-      if (config.avoidNPlusOneRequests && reloadUri) {
-        return apiActions.reload({ _meta: { reload: { uri: reloadUri || '', property: reloadProperty || '' } } }) as Promise<Collection> // we know that reload resolves to a type Collection
+      if (config.avoidNPlusOneRequests) {
+        return apiActions.reload(this as unknown as Collection) as Promise<Collection> // we know that reload resolves to a type Collection
 
       // no eager loading: replace each reference (Link) with a StoreValue (Resource)
       } else {

src/HasItems.ts

@@ -1,13 +1,10 @@
 import urltemplate from 'url-template'
 import { isTemplatedLink, isVirtualLink, isEntityReference } from './halHelpers'
-import EmbeddedCollection from './EmbeddedCollection'
 import Resource from './interfaces/Resource'
 import ApiActions from './interfaces/ApiActions'
-import { StoreData, StoreDataEntity } from './interfaces/StoreData'
-import Collection from './interfaces/Collection'
+import { StoreData } from './interfaces/StoreData'
 import StoreValueCreator from './StoreValueCreator'
 import { InternalConfig } from './interfaces/Config'
-import HasItems from './HasItems'
 
 /**
  * Represents an actual StoreValue, by wrapping the given Vuex store storeData. The storeData must not be loading.
@@ -43,18 +40,7 @@ class StoreValue implements Resource {
 
         // storeData[key] is a virtual link (=embedded collection)
         if (isVirtualLink(value)) {
-          // build complete Collection class = EmbeddedCollection + HasItems mixin
-          const EmbeddedCollectionClass = HasItems(EmbeddedCollection, this.apiActions, this.config, storeData._meta.self, key)
-
-          const loadCollection = storeData._meta.loading && storeData._meta.load
-            ? (storeData._meta.load as Promise<StoreDataEntity>).then(() => {
-                const collection = this.apiActions.get(value.href) as Collection
-                return new EmbeddedCollectionClass(collection, storeData._meta.self, key, this.apiActions)
-              })
-            : null
-
-          const collection = this.apiActions.get(value.href) as Collection
-          this[key] = () => new EmbeddedCollectionClass(collection, storeData._meta.self, key, this.apiActions, loadCollection)
+          this[key] = () => this.apiActions.get(value.href)
 
           // storeData[key] is a reference only (contains only href; no data)
         } else if (isEntityReference(value)) {
@@ -84,18 +70,30 @@ class StoreValue implements Resource {
   }
 
   $reload (): Promise<Resource> {
-    return this.apiActions.reload(this._meta.self)
+    return this.apiActions.reload(this)
   }
 
   $post (data: unknown): Promise<Resource | 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> {
+    if (this.isVirtual()) {
+      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()) {
+      throw new Error('$del is not implemented for virtual resources')
+    }
+
     return this.apiActions.del(this._meta.self)
   }
 
@@ -112,6 +110,14 @@ class StoreValue implements Resource {
     // 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 StoreValue

src/StoreValue.ts

@@ -10,10 +10,8 @@ import { ExternalConfig } from './interfaces/Config'
 import { Store } from 'vuex/types'
 import { AxiosInstance, AxiosError } from 'axios'
 import Resource from './interfaces/Resource'
-import StoreData, { VirtualStoreData, Link, SerializablePromise } from './interfaces/StoreData'
+import StoreData, { Link, SerializablePromise } from './interfaces/StoreData'
 import ApiActions from './interfaces/ApiActions'
-import EmbeddedCollectionClass from './EmbeddedCollection'
-import EmbeddedCollection, { EmbeddedCollectionMeta } from './interfaces/EmbeddedCollection'
 
 /**
  * Defines the API store methods available in all Vue components. The methods can be called as follows:
@@ -133,15 +131,11 @@ function HalJsonVuex (store: Store<Record<string, State>>, axios: AxiosInstance,
    * @returns Promise   Resolves when the GET request has completed and the updated entity is available
    *                    in the Vuex store.
    */
-  async function reload (uriOrEntity: string | Resource | StoreData | VirtualStoreData | EmbeddedCollectionMeta): Promise<Resource | EmbeddedCollection> {
-    if (isEmbeddedCollection(uriOrEntity)) {
+  async function reload (uriOrEntity: string | Resource): Promise<Resource> {
+    if (uriOrEntity instanceof StoreValue && 'virtual' in uriOrEntity._storeData._meta && uriOrEntity._storeData._meta.virtual) {
       // For embedded collections which had to reload the parent entity, unwrap the embedded collection after loading has finished
-      return reload(uriOrEntity._meta.reload.uri).then(parent => parent[uriOrEntity._meta.reload.property]() as EmbeddedCollection)
-    }
-
-    if (isVirtualStoreData(uriOrEntity) && uriOrEntity._meta.virtual) {
-      // For virtual resources which had to reload the owningResource, unwrap the relation after loading has finished
-      return reload(uriOrEntity._meta.owningResource).then(owner => owner[uriOrEntity._meta.owningRelation]() as Resource)
+      const { owningResource, owningRelation } = uriOrEntity._storeData._meta
+      return reload(owningResource).then(owner => owner[owningRelation]())
     }
 
     const uri = normalizeEntityUri(uriOrEntity, axios.defaults.baseURL)
@@ -165,33 +159,14 @@ function HalJsonVuex (store: Store<Record<string, State>>, axios: AxiosInstance,
     return loadPromise.then(storeData => storeValueCreator.wrap(storeData))
   }
 
-  /**
-   * Type guard for EmbeddedCollectionMeta
-   * @param uriOrEntity
-   */
-  function isVirtualStoreData (uriOrEntity: string | Resource | EmbeddedCollectionMeta | StoreData | VirtualStoreData | null): uriOrEntity is VirtualStoreData {
-    if (uriOrEntity === null) return false
-
-    if (typeof uriOrEntity === 'string') return false
-
-    // found an object that looks like an EmbeddedCollectionMeta
-    return 'virtual' in uriOrEntity._meta
-  }
-
-  /**
-   * Type guard for EmbeddedCollectionMeta
-   * @param uriOrEntity
-   */
-  function isEmbeddedCollection (uriOrEntity: string | Resource | EmbeddedCollectionMeta | StoreData | VirtualStoreData | null): uriOrEntity is EmbeddedCollectionMeta {
-    if (uriOrEntity === null) return false
-
-    if (typeof uriOrEntity === 'string') return false
+  async function reloadResourceFromStoreData (storeData: StoreData) {
+    if ('virtual' in storeData._meta && storeData._meta.virtual) {
+      const { owningResource, owningRelation } = storeData._meta
 
-    // found an actual EmbeddedCollection instance
-    if (uriOrEntity instanceof EmbeddedCollectionClass) return true
+      return reload(owningResource).then(owner => owner[owningRelation]())
+    }
 
-    // found an object that looks like an EmbeddedCollectionMeta
-    return 'reload' in uriOrEntity._meta
+    return reload(storeData._meta.self)
   }
 
   /**
@@ -392,7 +367,7 @@ function HalJsonVuex (store: Store<Record<string, State>>, axios: AxiosInstance,
       .filter(outdatedEntity => !outdatedEntity._meta.deleting)
 
       // reload outdated entities...
-      .map(outdatedEntity => reload(outdatedEntity).catch(() => {
+      .map(outdatedEntity => reloadResourceFromStoreData(outdatedEntity).catch(() => {
         // ...but ignore any errors (such as 404 errors during reloading)
         // handleAxiosError will take care of recursively deleting cascade-deleted entities
       }))

src/index.ts

@@ -1,10 +1,9 @@
-import EmbeddedCollection, { EmbeddedCollectionMeta } from './EmbeddedCollection'
 import Resource from './Resource'
 import StoreData from './StoreData'
 
 interface ApiActions {
-    get: (uriOrEntity: string | Resource | StoreData, forceReload?: boolean) => Resource
-    reload: (uriOrEntity: string | Resource | StoreData | EmbeddedCollectionMeta) => Promise<Resource | EmbeddedCollection>
+    get: (uriOrEntity: string | Resource | StoreData) => Resource
+    reload: (uriOrEntity: string | Resource) => Promise<Resource>
     post: (uriOrEntity: string | Resource, data: unknown) => Promise<Resource | null>
     patch: (uriOrEntity: string | Resource, data: unknown) => Promise<Resource>
     del: (uriOrEntity: string | Resource) => Promise<string | void>

src/interfaces/ApiActions.ts

@@ -23,22 +23,22 @@ type StoreDataMeta = {
     }
 }
 
-type VirtualStoreDataMeta = {
+type VirtualStoreDataMeta = StoreDataMeta & {
     _meta: {
         virtual: boolean
         owningResource: string
         owningRelation: string
     }
 }
 
-type StoreDataEntity = StoreDataMeta & {
+type StoreDataEntity = (StoreDataMeta | VirtualStoreDataMeta) & {
     items: never,
     _meta: {
         load: SerializablePromise<StoreDataEntity>
     }
 }
 
-type StoreDataCollection = StoreDataMeta & {
+type StoreDataCollection = (StoreDataMeta | VirtualStoreDataMeta) & {
     items: Array<Link>,
     _meta: {
         load: SerializablePromise<StoreDataCollection>
@@ -47,8 +47,6 @@ type StoreDataCollection = StoreDataMeta & {
 
 type StoreData = StoreDataEntity | StoreDataCollection
 
-type VirtualStoreData = StoreData & VirtualStoreDataMeta
-
-export { StoreData, VirtualStoreData, Link, VirtualLink, TemplatedLink, StoreDataEntity, StoreDataCollection, SerializablePromise }
+export { StoreData, Link, VirtualLink, TemplatedLink, StoreDataEntity, StoreDataCollection, SerializablePromise }
 
 export default StoreData

src/interfaces/EmbeddedCollection.ts

@@ -13,7 +13,6 @@ import templatedLink from './resources/templated-link'
 import rootWithLink from './resources/root-with-link'
 import StoreValue from '../src/StoreValue'
 import LoadingStoreValue from '../src/LoadingStoreValue'
-import EmbeddedCollection from '../src/EmbeddedCollection'
 
 async function letNetworkRequestFinish () {
   await new Promise(resolve => {
@@ -123,7 +122,7 @@ describe('Using dollar methods', () => {
     await letNetworkRequestFinish()
     const camp = vm.api.get('/camps/1')
     expect(camp).toBeInstanceOf(StoreValue)
-    expect(camp.periods()).toBeInstanceOf(EmbeddedCollection)
+    expect(camp.periods()).toBeInstanceOf(StoreValue)
 
     // when
     const load = camp.periods().$reload()
@@ -133,7 +132,7 @@ describe('Using dollar methods', () => {
     const periods = await load
 
     expect(periods.items.length).toEqual(2)
-    expect(periods).toBeInstanceOf(EmbeddedCollection)
+    expect(periods).toBeInstanceOf(StoreValue)
 
     done()
   })
@@ -543,7 +542,7 @@ describe('Using dollar methods', () => {
     vm.api.get('/users/1').lastReadBook().chapters()
     await letNetworkRequestFinish()
     const lastReadBookChapters = vm.api.get('/users/1').lastReadBook().chapters()
-    expect(lastReadBookChapters).toBeInstanceOf(EmbeddedCollection)
+    expect(lastReadBookChapters).toBeInstanceOf(StoreValue)
 
     // when
     const load = lastReadBookChapters.$loadItems()

src/interfaces/StoreData.ts

@@ -791,7 +791,7 @@ describe('API store', () => {
         vm.api.reload(embeddedCollection)
 
         // then
-        expect(embeddedCollection._meta.self).toBeUndefined()
+        expect(embeddedCollection._meta.self).toBe('http://localhost/camps/1#activityTypes')
         await letNetworkRequestFinish()
         expect(vm.$store.state.api['/camps/1#activityTypes'].items).toMatchObject(campData.storeState)
       })
@@ -839,7 +839,7 @@ describe('API store', () => {
         vm.api.reload(embeddedCollection)
 
         // then
-        expect(embeddedCollection._meta.self).toBeUndefined()
+        expect(embeddedCollection._meta.self).toBe('http://localhost/camps/1#activityTypes')
         await letNetworkRequestFinish()
         expect(vm.$store.state.api['/camps/1#activityTypes'].items).toMatchObject(activityTypeStoreState)
       })