@semapps/semantic-data-provider 1.1.2 → 1.1.4

package/dist/index.cjs.js

@@ -131,7 +131,6 @@ var $0edd1f2d07c8231f$export$2e2bcd8739ae039 = $0edd1f2d07c8231f$var$getUploadsC
 
 
 const $6fcb30f76390d142$var$isFile = (o)=>o?.rawFile && o.rawFile instanceof File;
-const $6fcb30f76390d142$var$isFileToDelete = (o)=>o?.fileToDelete !== undefined && o?.fileToDelete !== null;
 const $6fcb30f76390d142$export$a5575dbeeffdad98 = async (rawFile, config, serverKey)=>{
     const uploadsContainerUri = (0, $0edd1f2d07c8231f$export$2e2bcd8739ae039)(config, serverKey);
     if (!uploadsContainerUri) throw new Error("You must define an container with binaryResources in one of the server's configuration");
@@ -145,16 +144,10 @@ const $6fcb30f76390d142$export$a5575dbeeffdad98 = async (rawFile, config, server
     if (response.status === 201) return response.headers.get('Location');
     return null;
 };
-const $6fcb30f76390d142$var$deleteFiles = async (filesToDelete, config)=>{
-    return Promise.all(filesToDelete.map((file)=>config.httpClient(file, {
-            method: 'DELETE'
-        })));
-};
 /*
  * Look for raw files in the record data.
  * If there are any, upload them and replace the file by its URL.
  */ const $6fcb30f76390d142$var$uploadAllFiles = async (record, config, serverKey)=>{
-    const filesToDelete = [];
     const updatedRecord = {
         ...record
     };
@@ -162,30 +155,16 @@ const $6fcb30f76390d142$var$deleteFiles = async (filesToDelete, config)=>{
         const value = record[property];
         if (Array.isArray(value)) for(let i = 0; i < value.length; i++){
             const itemValue = value[i];
-            if ($6fcb30f76390d142$var$isFile(itemValue)) {
-                if ($6fcb30f76390d142$var$isFileToDelete(itemValue)) filesToDelete.push(itemValue.fileToDelete);
-                updatedRecord[property][i] = await $6fcb30f76390d142$export$a5575dbeeffdad98(itemValue.rawFile, config, serverKey);
-            } else if ($6fcb30f76390d142$var$isFileToDelete(itemValue)) {
-                filesToDelete.push(itemValue.fileToDelete);
-                updatedRecord[property][i] = null;
-            }
-        }
-        else if ($6fcb30f76390d142$var$isFile(value)) {
-            if ($6fcb30f76390d142$var$isFileToDelete(value)) filesToDelete.push(value.fileToDelete);
-            updatedRecord[property] = await $6fcb30f76390d142$export$a5575dbeeffdad98(value.rawFile, config, serverKey);
-        } else if ($6fcb30f76390d142$var$isFileToDelete(value)) {
-            filesToDelete.push(value.fileToDelete);
-            updatedRecord[property] = null;
+            if ($6fcb30f76390d142$var$isFile(itemValue)) updatedRecord[property][i] = await $6fcb30f76390d142$export$a5575dbeeffdad98(itemValue.rawFile, config, serverKey);
         }
+        else if ($6fcb30f76390d142$var$isFile(value)) updatedRecord[property] = await $6fcb30f76390d142$export$a5575dbeeffdad98(value.rawFile, config, serverKey);
     }
     return {
-        updatedRecord: updatedRecord,
-        filesToDelete: filesToDelete
+        updatedRecord: updatedRecord
     };
 };
 var $6fcb30f76390d142$export$2e2bcd8739ae039 = {
-    upload: $6fcb30f76390d142$var$uploadAllFiles,
-    delete: $6fcb30f76390d142$var$deleteFiles
+    upload: $6fcb30f76390d142$var$uploadAllFiles
 };
 
 
@@ -321,13 +300,11 @@ const $907cbc087f6529e2$var$createMethod = (config)=>async (resourceId, params)=
 var $907cbc087f6529e2$export$2e2bcd8739ae039 = $907cbc087f6529e2$var$createMethod;
 
 
-
 const $566b5adde94810fa$var$deleteMethod = (config)=>async (resourceId, params)=>{
         const { httpClient: httpClient } = config;
         await httpClient(`${params.id}`, {
             method: 'DELETE'
         });
-        if (params.meta?.filesToDelete) await (0, $6fcb30f76390d142$export$2e2bcd8739ae039).delete(params.meta.filesToDelete, config);
         return {
             data: {
                 id: params.id
@@ -382,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';
@@ -389,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;
@@ -805,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':
@@ -816,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
@@ -865,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;
     });
@@ -1024,7 +1020,7 @@ const $ceaafb56f75454f0$var$updateMethod = (config)=>async (resourceId, params)=
         const { httpClient: httpClient, jsonContext: jsonContext, dataServers: dataServers } = config;
         const serverKey = (0, $59a07b932dae8600$export$2e2bcd8739ae039)(params.id, dataServers);
         // Upload files, if there are any
-        const { updatedRecord: updatedRecord, filesToDelete: filesToDelete } = await (0, $6fcb30f76390d142$export$2e2bcd8739ae039).upload(params.data, config, serverKey);
+        const { updatedRecord: updatedRecord } = await (0, $6fcb30f76390d142$export$2e2bcd8739ae039).upload(params.data, config, serverKey);
         params.data = updatedRecord;
         await httpClient(`${params.id}`, {
             method: 'PUT',
@@ -1033,8 +1029,6 @@ const $ceaafb56f75454f0$var$updateMethod = (config)=>async (resourceId, params)=
                 ...params.data
             })
         });
-        // Delete files only if update is successful
-        await (0, $6fcb30f76390d142$export$2e2bcd8739ae039).delete(filesToDelete, config);
         return {
             data: params.data
         };
@@ -1297,7 +1291,7 @@ const $89358cee13a17a31$var$configureUserStorage = ()=>({
                     const newConfig = {
                         ...config
                     };
-                    newConfig.dataServers.user = {
+                    newConfig.dataServers[webId] = {
                         pod: true,
                         default: true,
                         authServer: true,
@@ -1325,6 +1319,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({
@@ -1358,7 +1353,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,
@@ -1384,7 +1380,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
@@ -1406,15 +1404,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;
                         }
                     }
@@ -1422,7 +1432,8 @@ var $37dc42f6e1c3b4af$export$2e2bcd8739ae039 = $37dc42f6e1c3b4af$var$getContaine
             }
             return config;
         }
-    });
+    };
+};
 var $c512de108ef5d674$export$2e2bcd8739ae039 = $c512de108ef5d674$var$fetchAppRegistration;
 
 
@@ -1433,9 +1444,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']);
@@ -1446,7 +1457,7 @@ const $cd772adda3024172$var$fetchDataRegistry = ()=>({
                     const newConfig = {
                         ...config
                     };
-                    newConfig.dataServers.user.containers?.push(...results.flat());
+                    newConfig.dataServers[webId].containers?.push(...results.flat());
                     return newConfig;
                 }
             }
@@ -1466,9 +1477,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: [],
@@ -1497,17 +1508,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;
                 }