@semapps/semantic-data-provider 1.1.3 → 1.1.5

package/dist/index.cjs.js

@@ -4,8 +4,8 @@ var $bkNnK$rdfjsdatamodel = require("@rdfjs/data-model");
 var $bkNnK$sparqljs = require("sparqljs");
 var $bkNnK$cryptojsmd5 = require("crypto-js/md5");
 var $bkNnK$reactadmin = require("react-admin");
-var $bkNnK$urljoin = require("url-join");
 var $bkNnK$jwtdecode = require("jwt-decode");
+var $bkNnK$urljoin = require("url-join");
 var $bkNnK$httplinkheader = require("http-link-header");
 var $bkNnK$changecase = require("change-case");
 var $bkNnK$react = require("react");
@@ -359,6 +359,19 @@ const $e6fbab1f303bdb93$var$arrayOf = (value)=>{
 var $e6fbab1f303bdb93$export$2e2bcd8739ae039 = $e6fbab1f303bdb93$var$arrayOf;
 
 
+
+// Fetch the selected resources of the provided containers
+// Filter out resources that are provided (can avoid loading a resource twice)
+const $448b8598c73a447a$var$fetchSelectedResources = async (containers, excludedResourcesUris, config)=>{
+    let selectedResourcesUris = containers.filter((c)=>c.selectedResources).map((c)=>c.selectedResources).flat();
+    // Filter out resources which are already included in the SPARQL query results
+    selectedResourcesUris = selectedResourcesUris.filter((uri)=>!excludedResourcesUris.includes(uri));
+    const selectedResources = await Promise.all(selectedResourcesUris.map((resourceUri)=>(0, $3db7a4510a668a04$export$2e2bcd8739ae039)(resourceUri, config)));
+    return selectedResources;
+};
+var $448b8598c73a447a$export$2e2bcd8739ae039 = $448b8598c73a447a$var$fetchSelectedResources;
+
+
 const $8c999cc29c8d6a6c$var$isValidLDPContainer = (container)=>{
     const resourceType = container.type || container['@type'];
     return Array.isArray(resourceType) ? resourceType.includes('ldp:Container') : resourceType === 'ldp:Container';
@@ -366,23 +379,24 @@ const $8c999cc29c8d6a6c$var$isValidLDPContainer = (container)=>{
 const $8c999cc29c8d6a6c$var$isObject = (val)=>{
     return val != null && typeof val === 'object' && !Array.isArray(val);
 };
-const $8c999cc29c8d6a6c$var$fetchContainers = async (containers, params, { httpClient: httpClient, jsonContext: jsonContext })=>{
-    const fetchPromises = containers.map((container)=>httpClient(container.uri).then(async ({ json: json })=>{
-            const jsonResponse = json;
-            // If container's context is different, compact it to have an uniform result
-            // TODO deep compare if the context is an object
-            if (jsonResponse['@context'] !== jsonContext) return (0, ($parcel$interopDefault($bkNnK$jsonld))).compact(jsonResponse, jsonContext);
-            return jsonResponse;
-        }).then((json)=>{
-            if (!$8c999cc29c8d6a6c$var$isValidLDPContainer(json)) throw new Error(`${container.uri} is not a LDP container`);
-            return (0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(json['ldp:contains']).map((resource)=>({
-                    '@context': json['@context'],
-                    ...resource
-                }));
-        }));
+const $8c999cc29c8d6a6c$var$fetchContainers = async (containers, params, config)=>{
+    const { httpClient: httpClient, jsonContext: jsonContext } = config;
     // Fetch simultaneously all containers
-    const results = await Promise.all(fetchPromises);
+    const results = await Promise.all(containers.filter((c)=>!c.selectedResources).map(async (container)=>{
+        let { json: json } = await httpClient(container.uri);
+        // If container's context is different, compact it to have an uniform result
+        // TODO deep compare if the context is an object
+        if (json['@context'] !== jsonContext) json = await (0, ($parcel$interopDefault($bkNnK$jsonld))).compact(json, jsonContext);
+        if (!$8c999cc29c8d6a6c$var$isValidLDPContainer(json)) throw new Error(`${container.uri} is not a LDP container`);
+        return (0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(json['ldp:contains']).map((resource)=>({
+                '@context': json['@context'],
+                ...resource
+            }));
+    }));
     let resources = results.flat();
+    // Append selected resources (if any)
+    const selectedResources = await (0, $448b8598c73a447a$export$2e2bcd8739ae039)(containers, resources.map((r)=>r.id), config);
+    resources = resources.concat(selectedResources);
     resources = resources.map((resource)=>{
         resource.id = resource.id || resource['@id'];
         return resource;
@@ -782,6 +796,7 @@ const $33c37185da3771a9$var$buildSparqlQuery = ({ containersUris: containersUris
 var $33c37185da3771a9$export$2e2bcd8739ae039 = $33c37185da3771a9$var$buildSparqlQuery;
 
 
+
 const $1e7a94d745f8597b$var$compare = (a, b)=>{
     switch(typeof a){
         case 'string':
@@ -793,16 +808,19 @@ const $1e7a94d745f8597b$var$compare = (a, b)=>{
     }
 };
 const $1e7a94d745f8597b$var$fetchSparqlEndpoints = async (containers, resourceId, params, config)=>{
-    const { dataServers: dataServers, resources: resources, httpClient: httpClient, jsonContext: jsonContext, ontologies: ontologies } = config;
-    const dataModel = resources[resourceId];
-    const serversToQuery = containers.reduce((acc, cur)=>{
+    const { dataServers: dataServers, httpClient: httpClient, jsonContext: jsonContext, ontologies: ontologies } = config;
+    const dataModel = config.resources[resourceId];
+    // Find servers to query with SPARQL
+    // (Ignore containers with selected resources, they will be fetched below)
+    const serversToQuery = containers.filter((c)=>!c.selectedResources).reduce((acc, cur)=>{
         if (!acc.includes(cur.server)) acc.push(cur.server);
         return acc;
     }, []);
-    const sparqlQueryPromises = serversToQuery.map((serverKey)=>new Promise((resolve, reject)=>{
+    // Run simultaneous SPARQL queries
+    const results = await Promise.all(serversToQuery.map((serverKey)=>new Promise((resolve, reject)=>{
             const blankNodes = params.filter?.blankNodes || dataModel.list?.blankNodes;
             const sparqlQuery = (0, $33c37185da3771a9$export$2e2bcd8739ae039)({
-                containersUris: containers.filter((c)=>c.server === serverKey).map((c)=>c.uri),
+                containersUris: containers.filter((c)=>c.server === serverKey && !c.selectedResources).map((c)=>c.uri),
                 params: params,
                 dataModel: dataModel,
                 ontologies: ontologies
@@ -842,17 +860,18 @@ const $1e7a94d745f8597b$var$fetchSparqlEndpoints = async (containers, resourceId
                         ...resource
                     })) || []);
             }).catch((e)=>reject(e));
-        }));
-    // Run simultaneous SPARQL queries
-    let results = await Promise.all(sparqlQueryPromises);
-    if (results.length === 0) return {
+        })));
+    // Merge results from all SPARQL servers
+    let resources = results.flat();
+    // Append selected resources to SPARQL query results
+    const selectedResources = await (0, $448b8598c73a447a$export$2e2bcd8739ae039)(containers, resources.map((r)=>r.id), config);
+    resources = resources.concat(selectedResources);
+    if (resources.length === 0) return {
         data: [],
         total: 0
     };
-    // Merge all results in one array
-    results = [].concat(...results);
     // Add id in addition to @id, as this is what React-Admin expects
-    let returnData = results.map((item)=>{
+    let returnData = resources.map((item)=>{
         item.id = item.id || item['@id'];
         return item;
     });
@@ -1020,14 +1039,22 @@ var $ceaafb56f75454f0$export$2e2bcd8739ae039 = $ceaafb56f75454f0$var$updateMetho
 
 
 
+
 /*
  * HTTP client used by all calls in data provider and auth provider
  * Do proxy calls if a proxy endpoint is available and the server is different from the auth server
  */ const $341dff85fe619d85$var$httpClient = (dataServers)=>(url, options = {})=>{
         if (!url) throw new Error(`No URL provided on httpClient call`);
+        const token = localStorage.getItem('token');
+        let webId = localStorage.getItem('webId');
+        if (!webId) {
+            const payload = (0, ($parcel$interopDefault($bkNnK$jwtdecode)))(token);
+            webId = payload.webId || payload.webid; // Currently we must deal with both formats
+            localStorage.setItem('webId', webId);
+        }
         const authServerKey = (0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)('authServer', dataServers);
         const serverKey = (0, $59a07b932dae8600$export$2e2bcd8739ae039)(url, dataServers);
-        const useProxy = serverKey !== authServerKey && dataServers[authServerKey]?.proxyUrl && dataServers[serverKey]?.noProxy !== true;
+        const useProxy = serverKey !== authServerKey && dataServers[webId]?.proxyUrl && dataServers[serverKey]?.noProxy !== true;
         if (!options.headers) options.headers = new Headers();
         switch(options.method){
             case 'POST':
@@ -1053,19 +1080,16 @@ var $ceaafb56f75454f0$export$2e2bcd8739ae039 = $ceaafb56f75454f0$var$updateMetho
                 else formData.append('body', options.body);
             }
             // Post to proxy endpoint with multipart/form-data format
-            return (0, $bkNnK$reactadmin.fetchUtils).fetchJson(dataServers[authServerKey].proxyUrl, {
+            return (0, $bkNnK$reactadmin.fetchUtils).fetchJson(dataServers[webId].proxyUrl, {
                 method: 'POST',
                 headers: new Headers({
-                    Authorization: `Bearer ${localStorage.getItem('token')}`
+                    Authorization: `Bearer ${token}`
                 }),
                 body: formData
             });
         }
         // Add token if the server is the same as the auth server
-        if (serverKey === authServerKey) {
-            const token = localStorage.getItem('token');
-            if (token) options.headers.set('Authorization', `Bearer ${token}`);
-        }
+        if (token && serverKey === authServerKey) options.headers.set('Authorization', `Bearer ${token}`);
         return (0, $bkNnK$reactadmin.fetchUtils).fetchJson(url, options);
     };
 var $341dff85fe619d85$export$2e2bcd8739ae039 = $341dff85fe619d85$var$httpClient;
@@ -1272,7 +1296,7 @@ const $89358cee13a17a31$var$configureUserStorage = ()=>({
                     const newConfig = {
                         ...config
                     };
-                    newConfig.dataServers.user = {
+                    newConfig.dataServers[webId] = {
                         pod: true,
                         default: true,
                         authServer: true,
@@ -1300,6 +1324,7 @@ var $89358cee13a17a31$export$2e2bcd8739ae039 = $89358cee13a17a31$var$configureUs
 
 
 
+
 const $37dc42f6e1c3b4af$var$getContainerFromDataRegistration = async (dataRegistrationUri, config)=>{
     const { json: dataRegistration } = await config.httpClient(dataRegistrationUri, {
         headers: new Headers({
@@ -1333,7 +1358,8 @@ const $37dc42f6e1c3b4af$var$getContainerFromDataRegistration = async (dataRegist
             '@container': '@language'
         }
     });
-    const { baseUrl: baseUrl } = config.dataServers.user;
+    const userStorage = (0, $8f44b7c15b8b8e1d$export$2e2bcd8739ae039)('default', config.dataServers);
+    const { baseUrl: baseUrl } = config.dataServers[userStorage];
     const containerPath = dataRegistration.id.replace(baseUrl, '');
     const container = {
         path: containerPath,
@@ -1359,7 +1385,9 @@ var $37dc42f6e1c3b4af$export$2e2bcd8739ae039 = $37dc42f6e1c3b4af$var$getContaine
  * Return a function that look if an app (clientId) is registered with an user (webId)
  * If not, it redirects to the endpoint provided by the user's authorization agent
  * See https://solid.github.io/data-interoperability-panel/specification/#authorization-agent
- */ const $c512de108ef5d674$var$fetchAppRegistration = ()=>({
+ */ const $c512de108ef5d674$var$fetchAppRegistration = (pluginConfig = {})=>{
+    const { includeSelectedResources: includeSelectedResources = true } = pluginConfig;
+    return {
         transformConfig: async (config)=>{
             const token = localStorage.getItem('token');
             // If the user is logged in
@@ -1381,15 +1409,27 @@ var $37dc42f6e1c3b4af$export$2e2bcd8739ae039 = $37dc42f6e1c3b4af$var$getContaine
                             const newConfig = {
                                 ...config
                             };
-                            // Load data grants concurrently to improve performances
+                            // Load access grants concurrently to improve performances
                             const results = await Promise.all((0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(appRegistration['interop:hasAccessGrant']).map(async (accessGrantUri)=>{
                                 const { json: accessGrant } = await config.httpClient(accessGrantUri);
-                                return Promise.all((0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(accessGrant['interop:hasDataGrant']).map(async (dataGrantUri)=>{
-                                    const { json: dataGrant } = await config.httpClient(dataGrantUri);
-                                    return (0, $37dc42f6e1c3b4af$export$2e2bcd8739ae039)(dataGrant['interop:hasDataRegistration'], config);
-                                }));
+                                const container = await (0, $37dc42f6e1c3b4af$export$2e2bcd8739ae039)(accessGrant['interop:hasDataRegistration'], config);
+                                container.server = accessGrant['interop:dataOwner'];
+                                if (accessGrant['interop:scopeOfGrant'] === 'interop:AllFromRegistry') return container;
+                                else if (accessGrant['interop:scopeOfGrant'] === 'interop:SelectedFromRegistry') {
+                                    if (!includeSelectedResources) return undefined;
+                                    container.selectedResources = (0, $e6fbab1f303bdb93$export$2e2bcd8739ae039)(accessGrant['interop:hasDataInstance']);
+                                    return container;
+                                }
                             }));
-                            newConfig.dataServers.user.containers = results.flat();
+                            // Put data shared by other users in other servers (storages)
+                            for (const container of results.flat().filter((i)=>i !== undefined))if (!newConfig.dataServers[container.server]) newConfig.dataServers[container.server] = {
+                                pod: true,
+                                baseUrl: `${container.server}/data`,
+                                containers: [
+                                    container
+                                ]
+                            };
+                            else newConfig.dataServers[container.server].containers.push(container);
                             return newConfig;
                         }
                     }
@@ -1397,7 +1437,8 @@ var $37dc42f6e1c3b4af$export$2e2bcd8739ae039 = $37dc42f6e1c3b4af$var$getContaine
             }
             return config;
         }
-    });
+    };
+};
 var $c512de108ef5d674$export$2e2bcd8739ae039 = $c512de108ef5d674$var$fetchAppRegistration;
 
 
@@ -1408,9 +1449,9 @@ const $cd772adda3024172$var$fetchDataRegistry = ()=>({
             const token = localStorage.getItem('token');
             // If the user is logged in
             if (token) {
-                if (!config.dataServers.user) throw new Error(`You must configure the user storage first with the configureUserStorage plugin`);
                 const payload = (0, ($parcel$interopDefault($bkNnK$jwtdecode)))(token);
                 const webId = payload.webId || payload.webid; // Currently we must deal with both formats
+                if (!config.dataServers[webId]) throw new Error(`You must configure the user storage first with the configureUserStorage plugin`);
                 const { json: user } = await config.httpClient(webId);
                 const { json: registrySet } = await config.httpClient(user['interop:hasRegistrySet']);
                 const { json: dataRegistry } = await config.httpClient(registrySet['interop:hasDataRegistry']);
@@ -1421,7 +1462,7 @@ const $cd772adda3024172$var$fetchDataRegistry = ()=>({
                     const newConfig = {
                         ...config
                     };
-                    newConfig.dataServers.user.containers?.push(...results.flat());
+                    newConfig.dataServers[webId].containers?.push(...results.flat());
                     return newConfig;
                 }
             }
@@ -1441,9 +1482,9 @@ const $69d4da9beaa62ac6$var$fetchTypeIndexes = ()=>({
             const token = localStorage.getItem('token');
             // If the user is logged in
             if (token) {
-                if (!config.dataServers.user) throw new Error(`You must configure the user storage first with the configureUserStorage plugin`);
                 const payload = (0, ($parcel$interopDefault($bkNnK$jwtdecode)))(token);
                 const webId = payload.webId || payload.webid; // Currently we must deal with both formats
+                if (!config.dataServers[webId]) throw new Error(`You must configure the user storage first with the configureUserStorage plugin`);
                 const { json: user } = await config.httpClient(webId);
                 const typeRegistrations = {
                     public: [],
@@ -1472,17 +1513,17 @@ const $69d4da9beaa62ac6$var$fetchTypeIndexes = ()=>({
                                     separateNumbers: true
                                 })
                             },
-                            path: typeRegistration['solid:instanceContainer'].replace(newConfig.dataServers.user.baseUrl, ''),
+                            path: typeRegistration['solid:instanceContainer'].replace(newConfig.dataServers[webId].baseUrl, ''),
                             types: await (0, $9ab033d1ec46b5da$export$2e2bcd8739ae039)(types, user['@context']),
                             private: mode === 'private'
                         };
-                        const containerIndex = newConfig.dataServers.user.containers.findIndex((c)=>c.path === container.path);
+                        const containerIndex = newConfig.dataServers[webId].containers.findIndex((c)=>c.path === container.path);
                         if (containerIndex !== -1) // If a container with this URI already exist, add type registration information if they are not set
-                        newConfig.dataServers.user.containers[containerIndex] = {
+                        newConfig.dataServers[webId].containers[containerIndex] = {
                             ...container,
-                            ...newConfig.dataServers.user.containers[containerIndex]
+                            ...newConfig.dataServers[webId].containers[containerIndex]
                         };
-                        else newConfig.dataServers.user.containers.push(container);
+                        else newConfig.dataServers[webId].containers.push(container);
                     }
                     return newConfig;
                 }