@startinblox/core 0.17.21-beta.2 → 0.17.21-beta.6

package/dist/libs/store/store.js

@@ -0,0 +1,860 @@
+let _Symbol$toPrimitive;
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import JSONLDContextParser from '../../_snowpack/pkg/jsonld-context-parser.js'; //@ts-ignore
+
+import PubSub from 'https://cdn.skypack.dev/pubsub-js';
+const ContextParser = JSONLDContextParser.ContextParser;
+const myParser = new ContextParser();
+export const base_context = {
+  '@vocab': 'http://happy-dev.fr/owl/#',
+  rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+  rdfs: 'http://www.w3.org/2000/01/rdf-schema#',
+  ldp: 'http://www.w3.org/ns/ldp#',
+  foaf: 'http://xmlns.com/foaf/0.1/',
+  name: 'rdfs:label',
+  acl: 'http://www.w3.org/ns/auth/acl#',
+  permissions: 'acl:accessControl',
+  mode: 'acl:mode',
+  geo: "http://www.w3.org/2003/01/geo/wgs84_pos#",
+  lat: "geo:lat",
+  lng: "geo:long"
+};
+
+class Store {
+  // index of all the containers per resource
+  // index of all the containers per resource
+  constructor(storeOptions) {
+    this.storeOptions = storeOptions;
+
+    _defineProperty(this, "cache", void 0);
+
+    _defineProperty(this, "subscriptionIndex", void 0);
+
+    _defineProperty(this, "subscriptionVirtualContainersIndex", void 0);
+
+    _defineProperty(this, "loadingList", void 0);
+
+    _defineProperty(this, "headers", void 0);
+
+    _defineProperty(this, "fetch", void 0);
+
+    _defineProperty(this, "session", void 0);
+
+    _defineProperty(this, "resolveResource", function (id, resolve) {
+      const handler = function (event) {
+        if (event.detail.id === id) {
+          resolve(event.detail.resource); // TODO : callback
+
+          document.removeEventListener('resourceReady', handler);
+        }
+      };
+
+      return handler;
+    });
+
+    this.cache = new Map();
+    this.subscriptionIndex = new Map();
+    this.subscriptionVirtualContainersIndex = new Map();
+    this.loadingList = new Set();
+    this.headers = {
+      'Content-Type': 'application/ld+json'
+    };
+    this.fetch = this.storeOptions.fetchMethod;
+    this.session = this.storeOptions.session;
+  }
+  /**
+   * Fetch data and cache it
+   * @param id - uri of the resource to fetch
+   * @param context - context used to expand id and predicates when accessing the resource
+   * @param idParent - uri of the parent caller used to expand uri for local files
+   * @param localData - data to put in cache
+   * @param forceFetch - force the fetch of data
+   *
+   * @returns The fetched resource
+   *
+   * @async
+   */
+
+
+  async getData(id, context = {}, idParent = "", localData, forceFetch = false) {
+    if (localData == null && this.cache.has(id) && !this.loadingList.has(id)) {
+      const resource = this.get(id);
+      if (resource && resource.isFullResource() && !forceFetch) return resource; // if resource is not complete, re-fetch it
+    }
+
+    return new Promise(async resolve => {
+      document.addEventListener('resourceReady', this.resolveResource(id, resolve));
+      if (this.loadingList.has(id)) return;
+      this.loadingList.add(id); // Generate proxy
+
+      const clientContext = await myParser.parse(context);
+      let resource = null;
+
+      if (this._isLocalId(id)) {
+        if (localData == null) localData = {};
+        localData["@id"] = id;
+        resource = localData;
+      } else try {
+        resource = localData || (await this.fetchData(id, clientContext, idParent));
+      } catch (error) {
+        console.error(error);
+      }
+
+      if (!resource) {
+        this.loadingList.delete(id);
+        resolve(null);
+        return;
+      }
+
+      const serverContext = await myParser.parse([resource['@context'] || {}]);
+      const resourceProxy = new CustomGetter(id, resource, clientContext, serverContext, idParent).getProxy(); // Cache proxy
+
+      await this.cacheGraph(id, resourceProxy, clientContext, serverContext, idParent || id);
+      this.loadingList.delete(id);
+      document.dispatchEvent(new CustomEvent('resourceReady', {
+        detail: {
+          id: id,
+          resource: this.get(id)
+        }
+      }));
+    });
+  }
+
+  async fetchAuthn(iri, options) {
+    let authenticated = false;
+    if (this.session) authenticated = await this.session;
+
+    if (this.fetch && authenticated) {
+      // authenticated
+      return this.fetch.then(fn => fn(iri, options));
+    } else {
+      // anonymous
+      if (options.headers) options.headers = this._convertHeaders(options.headers);
+      return fetch(iri, options).then(function (response) {
+        if (options.method === "PURGE" && !response.ok && response.status === 404) {
+          const err = new Error("PURGE call is returning 404");
+          throw err;
+        }
+
+        return response;
+      });
+    }
+  }
+
+  async fetchData(id, context = {}, idParent = "") {
+    const iri = this._getAbsoluteIri(id, context, idParent);
+
+    const headers = { ...this.headers,
+      'accept-language': this._getLanguage()
+    };
+    return this.fetchAuthn(iri, {
+      method: 'GET',
+      headers: headers,
+      credentials: 'include'
+    }).then(response => {
+      if (!response.ok) return;
+      return response.json();
+    });
+  }
+
+  async cacheGraph(key, resource, clientContext, parentContext, parentId) {
+    if (resource.properties) {
+      // if proxy, cache it
+      if (this.get(key)) {
+        // if already cached, merge data
+        this.cache.get(key).merge(resource);
+      } else {
+        // else, put in cache
+        this.cache.set(key, resource);
+      }
+    } // Cache nested resources
+
+
+    if (resource.getSubObjects) {
+      for (let res of resource.getSubObjects()) {
+        let newParentContext = parentContext; // If additional context in resource, use it to expand properties
+
+        if (res['@context']) newParentContext = await myParser.parse({ ...parentContext,
+          ...res['@context']
+        });
+        const resourceProxy = new CustomGetter(res['@id'], res, clientContext, newParentContext, parentId).getProxy(); // this.subscribeResourceTo(resource['@id'], res['@id']); // removed to prevent useless updates
+
+        await this.cacheGraph(res['@id'], resourceProxy, clientContext, parentContext, parentId);
+      }
+    } // Cache children of container
+
+
+    if (resource['@type'] == "ldp:Container" && resource.getChildren) {
+      const cacheChildrenPromises = [];
+
+      for (let res of resource.getChildren()) {
+        this.subscribeResourceTo(resource['@id'], res['@id']);
+        cacheChildrenPromises.push(this.cacheGraph(res['@id'], res, clientContext, parentContext, parentId));
+      }
+
+      await Promise.all(cacheChildrenPromises);
+      return;
+    } // Create proxy, (fetch data) and cache resource
+
+
+    if (resource['@id'] && !resource.properties) {
+      if (resource['@id'].match(/^b\d+$/)) return; // not anonymous node
+      // Fetch data if
+
+      if (resource['@type'] === "sib:federatedContainer" && resource['@cache'] !== 'false') {
+        // if object is federated container
+        await this.getData(resource['@id'], clientContext, parentId); // then init graph
+
+        return;
+      }
+
+      const resourceProxy = new CustomGetter(resource['@id'], resource, clientContext, parentContext, parentId).getProxy();
+      await this.cacheGraph(key, resourceProxy, clientContext, parentContext, parentId);
+    }
+  }
+  /**
+   * Update fetch
+   * @param method - 'POST', 'PATCH', 'PUT', '_LOCAL'
+   * @param resource - resource to send
+   * @param id - uri to update
+   * @returns - object
+   */
+
+
+  async _fetch(method, resource, id) {
+    if (method !== '_LOCAL') return this.fetchAuthn(id, {
+      method: method,
+      headers: this.headers,
+      body: JSON.stringify(resource),
+      credentials: 'include'
+    });
+    const resourceProxy = store.get(id);
+    const clientContext = resourceProxy ? resourceProxy.clientContext : resource['@context'];
+    this.clearCache(id);
+    await this.getData(id, clientContext, '', resource);
+    return {
+      ok: true
+    };
+  }
+
+  async _updateResource(method, resource, id) {
+    if (!['POST', 'PUT', 'PATCH', '_LOCAL'].includes(method)) throw new Error('Error: method not allowed');
+    const context = await myParser.parse([resource['@context'] || {}]); // parse context before expandTerm
+
+    const expandedId = this._getExpandedId(id, context);
+
+    return this._fetch(method, resource, id).then(async response => {
+      if (response.ok) {
+        var _response$headers;
+
+        if (method !== '_LOCAL') {
+          await this.purge(id);
+          this.clearCache(expandedId);
+        } // clear cache
+
+
+        this.getData(expandedId, resource['@context']).then(async () => {
+          // re-fetch data
+          const nestedResources = await this.getNestedResources(resource, id);
+          const resourcesToRefresh = this.subscriptionVirtualContainersIndex.get(expandedId) || [];
+          const resourcesToNotify = this.subscriptionIndex.get(expandedId) || [];
+          return this.refreshResources([...nestedResources, ...resourcesToRefresh]) // refresh related resources
+          .then(resourceIds => this.notifyResources([expandedId, ...resourceIds, ...resourcesToNotify])); // notify components
+        });
+        return ((_response$headers = response.headers) === null || _response$headers === void 0 ? void 0 : _response$headers.get('Location')) || null;
+      } else {
+        throw response;
+      }
+    });
+  }
+  /**
+   * Clear cache and refetch data for a list of ids
+   * @param resourceIds -
+   * @returns - all the resource ids
+   */
+
+
+  async refreshResources(resourceIds) {
+    resourceIds = [...new Set(resourceIds.filter(id => this.cache.has(id)))]; // remove duplicates and not cached resources
+
+    const resourceWithContexts = resourceIds.map(resourceId => {
+      var _store$get;
+
+      return {
+        "id": resourceId,
+        "context": (_store$get = store.get(resourceId)) === null || _store$get === void 0 ? void 0 : _store$get.clientContext
+      };
+    });
+
+    for (const resource of resourceWithContexts) {
+      if (!this._isLocalId(resource.id)) this.clearCache(resource.id);
+    }
+
+    await Promise.all(resourceWithContexts.map(({
+      id,
+      context
+    }) => this.getData(id, context || base_context)));
+    return resourceIds;
+  }
+  /**
+   * Notifies all components for a list of ids
+   * @param resourceIds -
+   */
+
+
+  async notifyResources(resourceIds) {
+    resourceIds = [...new Set(resourceIds)]; // remove duplicates
+
+    for (const id of resourceIds) PubSub.publish(id);
+  }
+  /**
+   * Return id of nested properties of a resource
+   * @param resource - object
+   * @param id - string
+   */
+
+
+  async getNestedResources(resource, id) {
+    const cachedResource = store.get(id);
+    if (!cachedResource || cachedResource.isContainer()) return [];
+    let nestedProperties = [];
+    const excludeKeys = ['@context'];
+
+    for (let p of Object.keys(resource)) {
+      if (resource[p] && typeof resource[p] === 'object' && !excludeKeys.includes(p) && resource[p]['@id']) {
+        nestedProperties.push(resource[p]['@id']);
+      }
+    }
+
+    return nestedProperties;
+  }
+  /**
+   * Returns the resource with id from the cache
+   * @param id - id of the resource to retrieve
+   *
+   * @returns Resource (Proxy) if in the cache, null otherwise
+   */
+
+
+  get(id) {
+    return this.cache.get(id) || null;
+  }
+  /**
+   * Removes a resource from the cache
+   * @param id - id of the resource to remove from the cache
+   */
+
+
+  clearCache(id) {
+    if (this.cache.has(id)) {
+      // For federation, clear each source
+      const resource = this.cache.get(id);
+
+      if (resource['@type'] === 'ldp:Container') {
+        resource['ldp:contains'].forEach(child => {
+          if (child && child['@type'] === 'ldp:Container') this.cache.delete(child['@id']);
+        });
+      }
+
+      this.cache.delete(id);
+    }
+  }
+  /**
+   * Send data to create a local resource in a container
+   * @param resource - resource to create
+   * @param id - uri of the container to add resource. should start with ``
+   *
+   * @returns id of the posted resource
+   */
+
+
+  async setLocalData(resource, id) {
+    return this._updateResource('_LOCAL', resource, id);
+  }
+  /**
+   * Send a POST request to create a resource in a container
+   * @param resource - resource to create
+   * @param id - uri of the container to add resource
+   *
+   * @returns id of the posted resource
+   */
+
+
+  async post(resource, id) {
+    return this._updateResource('POST', resource, id);
+  }
+  /**
+   * Send a PUT request to edit a resource
+   * @param resource - resource data to send
+   * @param id - uri of the resource to edit
+   *
+   * @returns id of the edited resource
+   */
+
+
+  async put(resource, id) {
+    return this._updateResource('PUT', resource, id);
+  }
+  /**
+   * Send a PATCH request to edit a resource
+   * @param resource - resource data to send
+   * @param id - uri of the resource to patch
+   *
+   * @returns id of the edited resource
+   */
+
+
+  async patch(resource, id) {
+    return this._updateResource('PATCH', resource, id);
+  }
+  /**
+   * Send a PURGE request to remove a resource from REDIS AD cache
+   * @param id - uri of the resource to patch
+   *
+   * @returns id of the edited resource
+   */
+
+
+  async purge(id) {
+    console.log('Purging resource ' + id);
+    await this.fetchAuthn(id, {
+      method: "PURGE",
+      headers: this.headers
+    }).catch(function (error) {
+      console.warn('No purge method allowed: ' + error);
+    });
+
+    try {
+      const fullURL = new URL(id);
+      var pathArray = fullURL.pathname.split('/');
+      var containerUrl = fullURL.origin + '/' + pathArray[1] + '/';
+      const headers = { ...this.headers,
+        'X-Cache-Purge-Match': 'startswith'
+      };
+      await this.fetchAuthn(containerUrl, {
+        method: "PURGE",
+        headers: headers
+      }).catch(function (error) {
+        console.warn('No purge method allowed: ' + error);
+      });
+    } catch (error) {
+      console.warn('The resource ID is not a complete URL: ' + error);
+      return;
+    }
+  }
+  /**
+   * Send a DELETE request to delete a resource
+   * @param id - uri of the resource to delete
+   * @param context - can be used to expand id
+   *
+   * @returns id of the deleted resource
+   */
+
+
+  async delete(id, context = {}) {
+    const expandedId = this._getExpandedId(id, context);
+
+    const deleted = await this.fetchAuthn(expandedId, {
+      method: 'DELETE',
+      headers: this.headers,
+      credentials: 'include'
+    });
+    await this.purge(id);
+    const resourcesToNotify = this.subscriptionIndex.get(expandedId) || [];
+    const resourcesToRefresh = this.subscriptionVirtualContainersIndex.get(expandedId) || [];
+    this.refreshResources([...resourcesToNotify, ...resourcesToRefresh]).then(resourceIds => this.notifyResources(resourceIds));
+    return deleted;
+  }
+  /**
+   * Convert headers object to Headers
+   * @param headersObject - object
+   * @returns {Headers}
+   */
+
+
+  _convertHeaders(headersObject) {
+    const headers = new Headers();
+
+    for (const [key, value] of Object.entries(headersObject)) {
+      headers.set(key, value);
+    }
+
+    return headers;
+  }
+
+  _getExpandedId(id, context) {
+    return context && Object.keys(context) ? ContextParser.expandTerm(id, context) : id;
+  }
+
+  _isLocalId(id) {
+    return id.startsWith('store://local.');
+  }
+  /**
+   * Make a resource listen changes of another one
+   * @param resourceId - id of the resource which needs to be updated
+   * @param nestedResourceId - id of the resource which will change
+   */
+
+
+  subscribeResourceTo(resourceId, nestedResourceId) {
+    const existingSubscriptions = this.subscriptionIndex.get(nestedResourceId) || [];
+    this.subscriptionIndex.set(nestedResourceId, [...new Set([...existingSubscriptions, resourceId])]);
+  }
+  /**
+   * Make a virtual container listen for changes of a resource
+   * @param virtualContainerId - id of the container which needs to be updated
+   * @param nestedResourceId - id of the resource which will change
+   */
+
+
+  subscribeVirtualContainerTo(virtualContainerId, nestedResourceId) {
+    const existingSubscriptions = this.subscriptionVirtualContainersIndex.get(nestedResourceId) || [];
+    this.subscriptionVirtualContainersIndex.set(nestedResourceId, [...new Set([...existingSubscriptions, virtualContainerId])]);
+  }
+  /**
+   * Return absolute IRI of the resource
+   * @param id
+   * @param context
+   * @param parentId
+   */
+
+
+  _getAbsoluteIri(id, context, parentId) {
+    let iri = ContextParser.expandTerm(id, context); // expand if reduced ids
+
+    if (parentId) {
+      // and get full URL from parent caller for local files
+      let parentIri = new URL(parentId, document.location.href).href;
+      iri = new URL(iri, parentIri).href;
+    } else {
+      iri = new URL(iri, document.location.href).href;
+    }
+
+    return iri;
+  }
+  /**
+   * Check if object is a full resource
+   * @param resource
+   */
+
+
+  _resourceIsComplete(resource) {
+    return !!(Object.keys(resource).filter(p => !p.startsWith('@')).length > 0 && resource['@id']);
+  }
+  /**
+   * Return language of the users
+   */
+
+
+  _getLanguage() {
+    return localStorage.getItem('language') || window.navigator.language.slice(0, 2);
+  }
+  /**
+   * Save the preferred language of the user
+   * @param selectedLanguageCode
+   */
+
+
+  selectLanguage(selectedLanguageCode) {
+    localStorage.setItem('language', selectedLanguageCode);
+  }
+
+}
+
+let store;
+
+if (window.sibStore) {
+  store = window.sibStore;
+} else {
+  const sibAuth = document.querySelector('sib-auth');
+  const storeOptions = {};
+
+  if (sibAuth) {
+    const sibAuthDefined = customElements.whenDefined(sibAuth.localName);
+    storeOptions.session = sibAuthDefined.then(() => sibAuth.session);
+    storeOptions.fetchMethod = sibAuthDefined.then(() => sibAuth.getFetch());
+  }
+
+  store = new Store(storeOptions);
+  window.sibStore = store;
+}
+
+export { store };
+_Symbol$toPrimitive = Symbol.toPrimitive;
+
+class CustomGetter {
+  // content of the requested resource
+  // context given by the app
+  // context given by the server
+  // id of the parent resource, used to get the absolute url of the current resource
+  constructor(resourceId, resource, clientContext, serverContext = {}, parentId = "") {
+    _defineProperty(this, "resource", void 0);
+
+    _defineProperty(this, "resourceId", void 0);
+
+    _defineProperty(this, "clientContext", void 0);
+
+    _defineProperty(this, "serverContext", void 0);
+
+    _defineProperty(this, "parentId", void 0);
+
+    this.clientContext = clientContext;
+    this.serverContext = serverContext;
+    this.parentId = parentId;
+    this.resource = this.expandProperties({ ...resource
+    }, serverContext);
+    this.resourceId = resourceId;
+  }
+  /**
+   * Expand all predicates of a resource with a given context
+   * @param resource: object
+   * @param context: object
+   */
+
+
+  expandProperties(resource, context) {
+    for (let prop of Object.keys(resource)) {
+      if (!prop) continue;
+      this.objectReplaceProperty(resource, prop, ContextParser.expandTerm(prop, context, true));
+    }
+
+    return resource;
+  }
+  /**
+   * Change the key of an object
+   * @param object: object
+   * @param oldProp: string - current key
+   * @param newProp: string - new key to set
+   */
+
+
+  objectReplaceProperty(object, oldProp, newProp) {
+    if (newProp !== oldProp) {
+      Object.defineProperty(object, newProp, Object.getOwnPropertyDescriptor(object, oldProp) || '');
+      delete object[oldProp];
+    }
+  }
+  /**
+   * Get the property of a resource for a given path
+   * @param path: string
+   */
+
+
+  async get(path) {
+    if (!path) return;
+    const path1 = path.split('.');
+    const path2 = [];
+    let value;
+
+    if (!this.isFullResource()) {
+      // if resource is not complete, fetch it first
+      await this.getResource(this.resourceId, this.clientContext, this.parentId);
+    }
+
+    while (true) {
+      try {
+        value = this.resource[this.getExpandedPredicate(path1[0])];
+      } catch (e) {
+        break;
+      }
+
+      if (path1.length <= 1) break; // no dot path
+
+      const lastPath1El = path1.pop();
+      if (lastPath1El) path2.unshift(lastPath1El);
+    }
+
+    if (path2.length === 0) {
+      // end of the path
+      if (!value || !value['@id']) return value; // no value or not a resource
+
+      return await this.getResource(value['@id'], this.clientContext, this.parentId || this.resourceId); // return complete resource
+    }
+
+    if (!value) return undefined;
+    let resource = await this.getResource(value['@id'], this.clientContext, this.parentId || this.resourceId);
+    store.subscribeResourceTo(this.resourceId, value['@id']);
+    return resource ? await resource[path2.join('.')] : undefined; // return value
+  }
+  /**
+   * Cache resource in the store, and return the created proxy
+   * @param id
+   * @param context
+   * @param iriParent
+   * @param forceFetch
+   */
+
+
+  async getResource(id, context, iriParent, forceFetch = false) {
+    return store.getData(id, context, iriParent, undefined, forceFetch);
+  }
+  /**
+   * Return true if the resource is a container
+   */
+
+
+  isContainer() {
+    return this.resource["@type"] == "ldp:Container" || this.resource["@type"] == "sib:federatedContainer";
+  }
+  /**
+   * Get all properties of a resource
+   */
+
+
+  getProperties() {
+    return Object.keys(this.resource).map(prop => this.getCompactedPredicate(prop));
+  }
+  /**
+   * Get children of container as objects
+   */
+
+
+  getChildren() {
+    return this.resource[this.getExpandedPredicate("ldp:contains")] || [];
+  }
+  /**
+   * Get children of container as Proxys
+   */
+
+
+  getLdpContains() {
+    const children = this.resource[this.getExpandedPredicate("ldp:contains")];
+    return children ? children.map(res => store.get(res['@id'])) : [];
+  }
+  /**
+   * Get all nested resource or containers which contains datas
+   */
+
+
+  getSubObjects() {
+    let subObjects = [];
+
+    for (let p of Object.keys(this.resource)) {
+      let property = this.resource[p];
+      if (!this.isFullNestedResource(property)) continue; // if not a resource, stop
+
+      if (property['@type'] == "ldp:Container" && (property['ldp:contains'] == undefined || property['ldp:contains'].length >= 1 && !this.isFullNestedResource(property['ldp:contains'][0]))) continue; // if not a full container
+
+      subObjects.push(property);
+    }
+
+    return subObjects;
+  }
+
+  merge(resource) {
+    this.resource = { ...this.getResourceData(),
+      ...resource.getResourceData()
+    };
+  }
+
+  getResourceData() {
+    return this.resource;
+  }
+  /**
+   * return true if prop is a resource with an @id and some properties
+   * @param prop
+   */
+
+
+  isFullNestedResource(prop) {
+    return prop && typeof prop == "object" && prop['@id'] != undefined && Object.keys(prop).filter(p => !p.startsWith('@')).length > 0;
+  }
+  /**
+   * return true resource seems complete
+   * @param prop
+   */
+
+
+  isFullResource() {
+    return Object.keys(this.resource).filter(p => !p.startsWith('@')).length > 0;
+  }
+
+  async getPermissions() {
+    const permissionPredicate = this.getExpandedPredicate("permissions");
+    let permissions = this.resource[permissionPredicate];
+
+    if (!permissions) {
+      // if no permission, re-fetch data
+      await this.getResource(this.resourceId, this.clientContext, this.parentId, true);
+      permissions = this.resource[permissionPredicate];
+    }
+
+    return permissions ? permissions.map(perm => ContextParser.expandTerm(perm.mode['@type'], this.serverContext, true)) : [];
+  }
+  /**
+   * Remove the resource from the cache
+   */
+
+
+  clearCache() {
+    store.clearCache(this.resourceId);
+  }
+
+  getExpandedPredicate(property) {
+    return ContextParser.expandTerm(property, this.clientContext, true);
+  }
+
+  getCompactedPredicate(property) {
+    return ContextParser.compactIri(property, this.clientContext, true);
+  }
+
+  getCompactedIri(id) {
+    return ContextParser.compactIri(id, this.clientContext);
+  }
+
+  toString() {
+    return this.getCompactedIri(this.resource['@id']);
+  }
+
+  [_Symbol$toPrimitive]() {
+    return this.getCompactedIri(this.resource['@id']);
+  }
+  /**
+   * Returns a Proxy which handles the different get requests
+   */
+
+
+  getProxy() {
+    return new Proxy(this, {
+      get: (resource, property) => {
+        if (!this.resource) return undefined;
+        if (typeof resource[property] === 'function') return resource[property].bind(resource);
+
+        switch (property) {
+          case '@id':
+            return this.getCompactedIri(this.resource['@id']);
+          // Compact @id if possible
+
+          case '@type':
+            return this.resource['@type'];
+          // return synchronously
+
+          case 'properties':
+            return this.getProperties();
+
+          case 'ldp:contains':
+            return this.getLdpContains();
+          // returns standard arrays synchronously
+
+          case 'permissions':
+            return this.getPermissions();
+          // get expanded permissions
+
+          case 'clientContext':
+            return this.clientContext;
+          // get saved client context to re-fetch easily a resource
+
+          case 'then':
+            return;
+
+          default:
+            return resource.get(property);
+        }
+      }
+    });
+  }
+
+}
+//# sourceMappingURL=store.js.map